static-fs/dist/common/fs.js

A static filesystem to bundle files and read them using NodeJS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.readdir = readdir;
exports.stat = stat;
exports.lstat = lstat;
exports.open = open;
exports.close = close;
exports.write = write;
exports.read = read;
exports.readFile = readFile;
exports.writeFile = writeFile;
exports.copyFile = copyFile;
exports.isDirectory = isDirectory;
exports.isFile = isFile;
exports.mkdir = mkdir;
exports.exists = void 0;

var filesystem = _interopRequireWildcard(require("fs"));

var _path = require("path");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

// shallow copy original function implementations before we start tweaking.
const fs = { ...filesystem
}; // promisify async functions.

function readdir(path) {
  return new Promise((r, j) => fs.readdir(path, (err, files) => err ? j(err) : r(files)));
}

function stat(path) {
  return new Promise((r, j) => fs.stat(path, (err, files) => err ? j(err) : r(files)));
}

function lstat(path) {
  return new Promise((r, j) => fs.lstat(path, (err, files) => err ? j(err) : r(files)));
}

function open(path, flags, mode) {
  return new Promise((r, j) => fs.open(path, flags, mode, (err, descriptor) => err ? j(err) : r(descriptor)));
}

function close(fd) {
  return new Promise((r, j) => fs.close(fd, err => err ? j(err) : r()));
}

function write(fd, buffer, offset, length, position) {
  return new Promise((r, j) => fs.write(fd, buffer, offset || 0, length || buffer.length, position || undefined, (err, written) => err ? j(err) : r(written)));
}

function read(fd, buffer, offset, length, position) {
  return new Promise((r, j) => fs.read(fd, buffer, offset, length, position || null, (err, bytes) => err ? j(err) : r(bytes)));
}

function readFile(path, options) {
  return new Promise((r, j) => fs.readFile(path, options, (err, data) => err ? j(err) : r(data)));
}

function fs_mkdir(path) {
  return new Promise((r, j) => fs.mkdir(path, err => err ? j(err) : r()));
}

function writeFile(filename, content) {
  return new Promise((r, j) => fs.writeFile(filename, content, err => err ? j(err) : r()));
}

async function copyFile(source, target) {
  await mkdir((0, _path.dirname)(target));
  return await new Promise((resolve, reject) => {
    const rd = fs.createReadStream(source);
    rd.on('error', rejectCleanup);
    const wr = fs.createWriteStream(target);
    wr.on('error', rejectCleanup);

    function rejectCleanup(err) {
      rd.destroy();
      wr.end();
      reject(err);
    }

    wr.on('finish', () => {
      rd.close();
      wr.close();
      resolve();
    });
    rd.pipe(wr);
  });
}

const exists = path => new Promise(r => fs.stat(path, err => err ? r(false) : r(true)));

exports.exists = exists;

async function isDirectory(dirPath) {
  try {
    if (await exists(dirPath)) {
      return (await lstat(dirPath)).isDirectory();
    }
  } catch (e) {// don't throw!
  }

  return false;
}

async function isFile(filePath) {
  try {
    if (await exists(filePath)) {
      return !(await lstat(filePath)).isDirectory();
    }
  } catch (e) {// don't throw!
  }

  return false;
}

async function mkdir(dirPath) {
  if (!(await isDirectory(dirPath))) {
    const p = (0, _path.normalize)(dirPath + '/');
    const parent = (0, _path.dirname)(dirPath);

    if (!(await isDirectory(parent))) {
      if (p !== parent) {
        await mkdir(parent);
      }
    }

    try {
      await fs_mkdir(p);
    } catch (e) {
      if (!(await isDirectory(p))) {
        throw new Error(e);
      }
    }
  }
}