@gjsify/fs 0.0.1 → 0.0.2

package/README.md

@@ -1,9 +1,7 @@
-# @gjsify/fs [![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](https://opensource.org/licenses/ISC)
+# @gjsify/fs
 
-fs core module for [gjs](https://gitlab.gnome.org/GNOME/gjs) forked from [@cgjs/fs](https://github.com/cgjs/cgjs/tree/master/packages/fs)
-
-* [x] existsSync
-* [x] readdirSync
-* [x] readFileSync
-* [x] mkdirSync
-* [x] rmdirSync
+## Inspirations
+- https://github.com/cgjs/cgjs/blob/master/packages/fs/index.js
+- https://github.com/geut/brode/blob/main/packages/browser-node-core/src/fs.js
+- https://github.com/mafintosh/level-filesystem/blob/master/index.js
+- https://github.com/denoland/deno_std/blob/main/node/fs.ts

package/lib/cjs/callback.js

@@ -0,0 +1,131 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var callback_exports = {};
+__export(callback_exports, {
+  close: () => close,
+  lstat: () => import_fs_lstat.lstat,
+  open: () => open,
+  read: () => read,
+  readdir: () => import_fs_readdir.readdir,
+  realpath: () => import_fs_realpath.realpath,
+  rm: () => rm,
+  stat: () => import_fs_stat.stat,
+  symlink: () => import_fs_symlink.symlink,
+  write: () => write
+});
+module.exports = __toCommonJS(callback_exports);
+var import_promises = require("./promises.js");
+var import_utils = require("@gjsify/utils");
+var import_file_handle = require("./file-handle.js");
+var import_buffer = require("buffer");
+var import_fs_realpath = require("@gjsify/deno_std/node/_fs/_fs_realpath");
+var import_fs_readdir = require("@gjsify/deno_std/node/_fs/_fs_readdir");
+var import_fs_symlink = require("@gjsify/deno_std/node/_fs/_fs_symlink");
+var import_fs_lstat = require("@gjsify/deno_std/node/_fs/_fs_lstat");
+var import_fs_stat = require("@gjsify/deno_std/node/_fs/_fs_stat");
+function open(path, ...args) {
+  let flags;
+  let mode;
+  let callback;
+  switch (args.length) {
+    case 1:
+      callback = args[0];
+      break;
+    case 2:
+      flags = args[0];
+      callback = args[1];
+      break;
+    case 3:
+      flags = args[0];
+      mode = args[1];
+      callback = args[2];
+      break;
+    default:
+      break;
+  }
+  (0, import_promises.open)(path, flags, mode).then((fileHandle) => {
+    callback(null, fileHandle.fd);
+  }).catch((err) => {
+    callback(err, -1);
+  });
+}
+function write(fd, data, ...args) {
+  const fileHandle = import_file_handle.FileHandle.getInstance(fd);
+  if (typeof data === "string") {
+    const callback2 = args[args.length - 1];
+    fileHandle.write(data, ...args.pop()).then((res) => {
+      callback2(null, res.bytesWritten, res.buffer);
+    }).catch((err) => {
+      callback2(err, 0, "");
+    });
+    return;
+  }
+  const callback = args[args.length - 1];
+  const offset = args[0];
+  const length = args[1];
+  const position = args[2];
+  fileHandle.write(data, offset, length, position).then((res) => {
+    callback(null, res.bytesWritten, res.buffer);
+  }).catch((err) => {
+    callback(err, 0, import_buffer.Buffer.from([]));
+  });
+}
+function read(fd, ...args) {
+  const fileHandle = import_file_handle.FileHandle.getInstance(fd);
+  const callback = args[args.length - 1];
+  const err = new Error((0, import_utils.warnNotImplemented)("fs.read"));
+  callback(err, 0, import_buffer.Buffer.from(""));
+  let buffer;
+  let offset;
+  let length;
+  let position;
+  if (typeof args[0] === "object") {
+    const options = args[0];
+    buffer = options.buffer;
+    offset = options.offset;
+    length = options.length;
+    position = options.position;
+  } else {
+    buffer = args[0];
+    offset = args[1];
+    length = args[2];
+    position = args[3];
+  }
+  fileHandle.read(buffer, offset, length, position).then((res) => {
+    callback(null, res.bytesRead, res.buffer);
+  }).catch((err2) => {
+    callback(err2, 0, import_buffer.Buffer.from([]));
+  });
+}
+function close(fd, callback) {
+  import_file_handle.FileHandle.getInstance(fd).close().then(() => {
+    callback(null);
+  }).catch((err) => callback(err));
+}
+function rm(path, ...args) {
+  let options = {};
+  let callback = args[args.length - 1];
+  if (args.length >= 2) {
+    options = args[0];
+  }
+  (0, import_promises.rm)(path, options).then(() => {
+    callback(null);
+  }).catch((err) => {
+    callback(err);
+  });
+}

package/lib/cjs/dirent.js

@@ -0,0 +1,127 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dirent_exports = {};
+__export(dirent_exports, {
+  Dirent: () => Dirent
+});
+module.exports = __toCommonJS(dirent_exports);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_path = require("path");
+class Dirent {
+  /**
+   * The file name that this `fs.Dirent` object refers to. The type of this
+   * value is determined by the `options.encoding` passed to {@link readdir} or {@link readdirSync}.
+   * @since v10.10.0
+   */
+  name;
+  _isFile = false;
+  _isDirectory = false;
+  _isBlockDevice = false;
+  _isCharacterDevice = false;
+  _isSymbolicLink = false;
+  _isFIFO = false;
+  _isSocket = false;
+  /** This is not part of node.fs and is used internal by gjsify */
+  _file;
+  /** This is not part of node.fs and is used internal by gjsify */
+  constructor(path, filename) {
+    if (!filename)
+      filename = (0, import_path.basename)(path);
+    this.name = filename;
+    this._file = import_gio_2.default.File.new_for_path(path);
+    const type = this._file.query_file_type(import_gio_2.default.FileQueryInfoFlags.NONE, null);
+    switch (type) {
+      case import_gio_2.default.FileType.DIRECTORY:
+        this._isDirectory = true;
+        break;
+      case import_gio_2.default.FileType.MOUNTABLE:
+        break;
+      case import_gio_2.default.FileType.REGULAR:
+        this._isFile = true;
+        break;
+      case import_gio_2.default.FileType.SYMBOLIC_LINK:
+      case import_gio_2.default.FileType.SHORTCUT:
+        this._isSymbolicLink = true;
+        break;
+      case import_gio_2.default.FileType.SPECIAL:
+        this._isBlockDevice = import_gio_2.default.unix_is_system_device_path(path);
+        break;
+    }
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a regular file.
+   * @since v10.10.0
+   */
+  isFile() {
+    return this._isFile;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a file system
+   * directory.
+   * @since v10.10.0
+   */
+  isDirectory() {
+    return this._isDirectory;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a block device.
+   * @since v10.10.0
+   */
+  isBlockDevice() {
+    return this._isBlockDevice;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a character device.
+   * @since v10.10.0
+   */
+  isCharacterDevice() {
+    return this._isCharacterDevice;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a symbolic link.
+   * @since v10.10.0
+   */
+  isSymbolicLink() {
+    return this._isSymbolicLink;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a first-in-first-out
+   * (FIFO) pipe.
+   * @since v10.10.0
+   */
+  isFIFO() {
+    return this._isFIFO;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a socket.
+   * @since v10.10.0
+   */
+  isSocket() {
+    return this._isSocket;
+  }
+}

package/lib/cjs/encoding.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encoding_exports = {};
+__export(encoding_exports, {
+  decode: () => decode,
+  encodeUint8Array: () => encodeUint8Array,
+  getEncodingFromOptions: () => getEncodingFromOptions
+});
+module.exports = __toCommonJS(encoding_exports);
+var import_buffer = require("buffer");
+function getEncodingFromOptions(options = { encoding: null, flag: "r" }, defaultEncoding = "utf8") {
+  if (options === null) {
+    return defaultEncoding;
+  }
+  if (typeof options === "string") {
+    return options;
+  }
+  if (typeof options === "object" && typeof options.encoding === "string") {
+    return options.encoding;
+  }
+  return defaultEncoding;
+}
+function encodeUint8Array(encoding, data) {
+  if (encoding === "buffer") {
+    return import_buffer.Buffer.from(data);
+  }
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(data);
+}
+function decode(str, encoding) {
+  if (!encoding)
+    return str;
+  else {
+    const decoder = new TextDecoder(encoding);
+    const encoder = new TextEncoder();
+    return decoder.decode(encoder.encode(str));
+  }
+}