@gjsify/fs 0.0.1 → 0.0.3

package/lib/cjs/fs-watcher.js

@@ -0,0 +1,50 @@
+import Gio from "@girs/gio-2.0";
+import { EventEmitter } from "events";
+const privates = /* @__PURE__ */ new WeakMap();
+class FSWatcher extends EventEmitter {
+  constructor(filename, options, listener) {
+    super();
+    if (!options || typeof options !== "object")
+      options = { persistent: true };
+    const cancellable = Gio.Cancellable.new();
+    const file = Gio.File.new_for_path(filename);
+    const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
+    watcher.connect("changed", changed.bind(this));
+    privates.set(this, {
+      persistent: options.persistent,
+      cancellable,
+      // even if never used later on, the monitor needs to be
+      // attached to this instance or GJS reference counter
+      // will ignore it and no watch will ever happen
+      watcher
+    });
+    if (listener)
+      this.on("change", listener);
+  }
+  close() {
+    const { cancellable, persistent } = privates.get(this);
+    if (!cancellable.is_cancelled()) {
+      cancellable.cancel();
+    }
+  }
+}
+;
+function changed(watcher, file, otherFile, eventType) {
+  switch (eventType) {
+    case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
+      this.emit("change", "change", file.get_basename());
+      break;
+    case Gio.FileMonitorEvent.DELETED:
+    case Gio.FileMonitorEvent.CREATED:
+    case Gio.FileMonitorEvent.RENAMED:
+    case Gio.FileMonitorEvent.MOVED_IN:
+    case Gio.FileMonitorEvent.MOVED_OUT:
+      this.emit("rename", "rename", file.get_basename());
+      break;
+  }
+}
+var fs_watcher_default = FSWatcher;
+export {
+  FSWatcher,
+  fs_watcher_default as default
+};

package/lib/cjs/index.js

@@ -0,0 +1,95 @@
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmdirSync,
+  unlinkSync,
+  watch,
+  mkdtempSync,
+  rmSync,
+  statSync,
+  openSync,
+  realpathSync,
+  symlinkSync,
+  lstatSync
+} from "./sync.js";
+import {
+  open,
+  close,
+  read,
+  write,
+  rm,
+  realpath,
+  readdir,
+  symlink,
+  lstat
+} from "./callback.js";
+import FSWatcher from "./fs-watcher.js";
+import {
+  createReadStream,
+  ReadStream
+} from "./read-stream.js";
+import * as promises from "./promises.js";
+var src_default = {
+  FSWatcher,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmdirSync,
+  unlinkSync,
+  mkdtempSync,
+  rmSync,
+  statSync,
+  openSync,
+  realpathSync,
+  symlinkSync,
+  lstatSync,
+  watch,
+  createReadStream,
+  ReadStream,
+  promises,
+  open,
+  close,
+  read,
+  write,
+  rm,
+  realpath,
+  readdir,
+  symlink,
+  lstat
+};
+export {
+  FSWatcher,
+  ReadStream,
+  close,
+  createReadStream,
+  src_default as default,
+  existsSync,
+  lstat,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  open,
+  openSync,
+  promises,
+  read,
+  readFileSync,
+  readdir,
+  readdirSync,
+  realpath,
+  realpathSync,
+  rm,
+  rmSync,
+  rmdirSync,
+  statSync,
+  symlink,
+  symlinkSync,
+  unlinkSync,
+  watch,
+  write,
+  writeFileSync
+};

package/lib/cjs/promises.js

@@ -0,0 +1,160 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { warnNotImplemented } from "@gjsify/utils";
+import { join } from "path";
+import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
+import { writeFileSync, mkdirSync, rmdirSync, unlinkSync } from "./sync.js";
+import { FileHandle } from "./file-handle.js";
+import { tempDirPath } from "./utils.js";
+import { Dirent } from "./dirent.js";
+import { realpathPromise as realpath } from "@gjsify/deno_std/node/_fs/_fs_realpath";
+import { readdirPromise as readdir } from "@gjsify/deno_std/node/_fs/_fs_readdir";
+import { symlinkPromise as symlink } from "@gjsify/deno_std/node/_fs/_fs_symlink";
+import { lstatPromise as lstat } from "@gjsify/deno_std/node/_fs/_fs_lstat";
+import { statPromise as stat } from "@gjsify/deno_std/node/_fs/_fs_stat";
+async function mkdir(path, options) {
+  let recursive;
+  let mode = 511;
+  if (typeof options === "object") {
+    if (options.recursive)
+      recursive = options.recursive;
+    if (options.mode)
+      mode = options.mode;
+  } else {
+    mode = options;
+  }
+  const firstPath = mkdirSync(path, {
+    recursive,
+    mode
+  });
+  return firstPath;
+}
+async function readFile(path, options = { encoding: null, flag: "r" }) {
+  const file = Gio.File.new_for_path(path.toString());
+  const [ok, data] = await new Promise((resolve, reject) => {
+    file.load_contents_async(null, (self, res) => {
+      try {
+        resolve(file.load_contents_finish(res));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+  if (!ok) {
+    throw new Error("failed to read file");
+  }
+  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+}
+async function mkdtemp(prefix, options) {
+  const encoding = getEncodingFromOptions(options);
+  const path = tempDirPath(prefix);
+  await mkdir(
+    path,
+    { recursive: false, mode: 448 }
+  );
+  return decode(path, encoding);
+}
+async function writeFile(path, data) {
+  return writeFileSync(path, data);
+}
+async function rmdir(path, options) {
+  return rmdirSync(path, options);
+}
+async function unlink(path) {
+  return unlinkSync(path);
+}
+async function open(path, flags, mode) {
+  return new FileHandle({
+    path,
+    flags,
+    mode
+  });
+}
+async function write(fd, data, positionOrOffset, encodingOrLength, position) {
+  if (typeof data === "string") {
+    return _writeStr(fd, data, positionOrOffset, encodingOrLength);
+  }
+  return _writeBuf(fd, data, positionOrOffset, encodingOrLength, position);
+}
+async function _writeBuf(fd, buffer, offset, length, position) {
+  warnNotImplemented("fs.promises.write");
+  return {
+    bytesWritten: 0,
+    buffer
+  };
+}
+async function _writeStr(fd, data, position, encoding) {
+  warnNotImplemented("fs.promises.write");
+  return {
+    bytesWritten: 0,
+    buffer: data
+  };
+}
+async function rm(path, options) {
+  const file = Gio.File.new_for_path(path.toString());
+  const recursive = options?.recursive || false;
+  const dirent = new Dirent(path.toString());
+  if (dirent.isDirectory()) {
+    const childFiles = await readdir(path, { withFileTypes: true });
+    if (!recursive && childFiles.length) {
+      throw new Error("Dir is not empty!");
+    }
+    for (const childFile of childFiles) {
+      if (childFile.isDirectory()) {
+        await rmdir(join(path.toString(), childFile.name), options);
+      } else if (childFile.isFile()) {
+        await rm(join(path.toString(), childFile.name), options);
+      }
+    }
+  }
+  const ok = await new Promise((resolve, reject) => {
+    try {
+      file.delete_async(GLib.PRIORITY_DEFAULT, null, (self, res) => {
+        try {
+          resolve(file.delete_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  if (!ok) {
+    const err = new Error("failed to remove file " + path);
+    throw err;
+  }
+}
+var promises_default = {
+  readFile,
+  mkdir,
+  mkdtemp,
+  realpath,
+  readdir,
+  writeFile,
+  rmdir,
+  unlink,
+  open,
+  write,
+  rm,
+  lstat,
+  symlink,
+  stat
+};
+export {
+  promises_default as default,
+  lstat,
+  mkdir,
+  mkdtemp,
+  open,
+  readFile,
+  readdir,
+  realpath,
+  rm,
+  rmdir,
+  stat,
+  symlink,
+  unlink,
+  write,
+  writeFile
+};

package/lib/cjs/read-stream.js

@@ -0,0 +1,78 @@
+import GLib from "@girs/glib-2.0";
+import { notImplemented } from "@gjsify/utils";
+import { Buffer } from "buffer";
+import { Readable } from "stream";
+import { URL } from "url";
+function fromFileUrl(url) {
+  url = url instanceof URL ? url : new URL(url);
+  if (url.protocol != "file:") {
+    throw new TypeError("Must be a file URL.");
+  }
+  return decodeURIComponent(
+    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")
+  );
+}
+class ReadStream extends Readable {
+  close(callback) {
+    callback(notImplemented("ReadStream.close"));
+  }
+  /**
+   * The number of bytes that have been read so far.
+   * @since v6.4.0
+   */
+  bytesRead;
+  /**
+   * The path to the file the stream is reading from as specified in the first
+   * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a
+   * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`.
+   * @since v0.1.93
+   */
+  path;
+  /**
+   * This property is `true` if the underlying file has not been opened yet,
+   * i.e. before the `'ready'` event is emitted.
+   * @since v11.2.0, v10.16.0
+   */
+  pending;
+  constructor(path, opts) {
+    path = path instanceof URL ? fromFileUrl(path) : path;
+    const hasBadOptions = opts && (opts.start || opts.end);
+    if (hasBadOptions) {
+      notImplemented(
+        `fs.ReadStream.prototype.constructor with unsupported options (${JSON.stringify(opts)})`
+      );
+    }
+    const file = GLib.IOChannel.new_file(path.toString(), "r");
+    const buffer = "";
+    super({
+      autoDestroy: true,
+      emitClose: true,
+      objectMode: false,
+      read: async function(_size) {
+        try {
+          let n = 0;
+          file.read(buffer, 16 * 1024, n);
+          this.push(n ? Buffer.from(buffer.slice(0, n)) : null);
+        } catch (err) {
+          this.destroy(err);
+        }
+      },
+      destroy: (err, cb) => {
+        try {
+          file.close();
+        } catch {
+        }
+        cb(err);
+      }
+    });
+    this.path = path.toString();
+  }
+}
+function createReadStream(path, options) {
+  return new ReadStream(path, options);
+}
+export {
+  ReadStream,
+  createReadStream,
+  fromFileUrl
+};

package/lib/cjs/stats.js

@@ -0,0 +1,45 @@
+import Gio from "@girs/gio-2.0";
+import { Dirent } from "./dirent.js";
+import { basename } from "path";
+class Stats extends Dirent {
+  dev;
+  ino;
+  mode;
+  nlink;
+  uid;
+  gid;
+  rdev;
+  size;
+  blksize;
+  blocks;
+  atimeMs;
+  mtimeMs;
+  ctimeMs;
+  /** The timestamp indicating the creation time of this file expressed in milliseconds since the POSIX Epoch. */
+  get birthtimeMs() {
+    const creationDateTime = this._info.get_creation_date_time();
+    return creationDateTime.get_microsecond() * 1e3;
+  }
+  atime;
+  mtime;
+  ctime;
+  /** The timestamp indicating the creation time of this file. */
+  get birthtime() {
+    const creationDateTime = this._info.get_creation_date_time();
+    return new Date(creationDateTime.format_iso8601());
+  }
+  _info;
+  constructor(path, filename) {
+    const pathStr = path.toString();
+    if (!filename)
+      filename = basename(pathStr);
+    super(pathStr, filename);
+    if (!this._file) {
+      throw new TypeError("this._file is not defined!");
+    }
+    this._info = this._file.query_info("standard::", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+  }
+}
+export {
+  Stats
+};

package/lib/cjs/sync.js

@@ -0,0 +1,126 @@
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+import { existsSync } from "@gjsify/utils";
+import { join } from "path";
+import FSWatcher from "./fs-watcher.js";
+import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
+import { FileHandle } from "./file-handle.js";
+import { Dirent } from "./dirent.js";
+import { tempDirPath } from "./utils.js";
+import { realpathSync } from "@gjsify/deno_std/node/_fs/_fs_realpath";
+import { readdirSync } from "@gjsify/deno_std/node/_fs/_fs_readdir";
+import { symlinkSync } from "@gjsify/deno_std/node/_fs/_fs_symlink";
+import { lstatSync } from "@gjsify/deno_std/node/_fs/_fs_lstat";
+import { statSync } from "@gjsify/deno_std/node/_fs/_fs_stat";
+function readFileSync(path, options = { encoding: null, flag: "r" }) {
+  const file = Gio.File.new_for_path(path);
+  const [ok, data] = file.load_contents(null);
+  if (!ok) {
+    throw new Error("failed to read file");
+  }
+  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+}
+function mkdirSync(path, options) {
+  let recursive = false;
+  let mode = 511;
+  if (typeof options === "object") {
+    if (options?.recursive)
+      recursive = options.recursive;
+    if (options?.mode)
+      mode = options.mode;
+  } else {
+    mode = options || 511;
+  }
+  if (typeof path !== "string") {
+    path = path.toString();
+  }
+  if (typeof mode === "string") {
+    throw new TypeError("mode as string is currently not supported!");
+  }
+  if (GLib.mkdir_with_parents(path, mode) !== 0) {
+    throw new Error(`failed to make ${path} directory`);
+  }
+  if (recursive) {
+    return path.split("/")[0];
+  }
+  return void 0;
+}
+function rmdirSync(path, options) {
+  const recursive = options?.recursive || false;
+  const childFiles = readdirSync(path, { withFileTypes: true });
+  if (!recursive && childFiles.length) {
+    throw new Error("Dir is not empty!");
+  }
+  for (const childFile of childFiles) {
+    if (childFile.isDirectory()) {
+      rmdirSync(join(path.toString(), childFile.name));
+    } else if (childFile.isFile()) {
+      rmSync(join(path.toString(), childFile.name));
+    }
+  }
+  const result = GLib.rmdir(path.toString());
+  if (result !== 0) {
+    throw new Error(`Failed to remove ${path} directory`);
+  }
+}
+function unlinkSync(path) {
+  GLib.unlink(path);
+}
+function writeFileSync(path, data) {
+  GLib.file_set_contents(path, data);
+}
+function watch(filename, options, listener) {
+  return new FSWatcher(filename, options, listener);
+}
+function openSync(path, flags, mode) {
+  return new FileHandle({ path, flags, mode });
+}
+function mkdtempSync(prefix, options) {
+  const encoding = getEncodingFromOptions(options);
+  const path = tempDirPath(prefix);
+  mkdirSync(
+    path,
+    { recursive: false, mode: 511 }
+  );
+  return decode(path, encoding);
+}
+function rmSync(path, options) {
+  const file = Gio.File.new_for_path(path.toString());
+  const recursive = options?.recursive || false;
+  const dirent = new Dirent(path.toString());
+  if (dirent.isDirectory()) {
+    const childFiles = readdirSync(path, { withFileTypes: true });
+    if (!recursive && childFiles.length) {
+      throw new Error("Dir is not empty!");
+    }
+    for (const childFile of childFiles) {
+      if (childFile.isDirectory()) {
+        rmdirSync(join(path.toString(), childFile.name), options);
+      } else if (childFile.isFile()) {
+        rmSync(join(path.toString(), childFile.name), options);
+      }
+    }
+  }
+  const ok = file.delete(null);
+  if (!ok) {
+    const err = new Error("failed to remove file " + path);
+    throw err;
+  }
+}
+export {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  rmdirSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+  watch,
+  writeFileSync
+};

package/lib/cjs/types/index.js

@@ -0,0 +1,6 @@
+export * from "./encoding-option.js";
+export * from "./file-read-options.js";
+export * from "./file-read-result.js";
+export * from "./flag-and-open-mode.js";
+export * from "./open-flags.js";
+export * from "./read-options.js";

package/lib/cjs/utils.js

@@ -0,0 +1,18 @@
+import { existsSync } from "./sync.js";
+const CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function randomName() {
+  return [...Array(6)].map(
+    () => CHARS[Math.floor(Math.random() * CHARS.length)]
+  ).join("");
+}
+function tempDirPath(prefix) {
+  let path;
+  do {
+    path = prefix + randomName();
+  } while (existsSync(path));
+  return path;
+}
+export {
+  randomName,
+  tempDirPath
+};