@gjsify/fs 0.0.2 → 0.0.3

package/lib/cjs/index.js

@@ -1,95 +1,95 @@
-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 src_exports = {};
-__export(src_exports, {
-  FSWatcher: () => import_fs_watcher.default,
-  ReadStream: () => import_read_stream.ReadStream,
-  close: () => import_callback.close,
-  createReadStream: () => import_read_stream.createReadStream,
-  default: () => src_default,
-  existsSync: () => import_sync.existsSync,
-  lstat: () => import_callback.lstat,
-  lstatSync: () => import_sync.lstatSync,
-  mkdirSync: () => import_sync.mkdirSync,
-  mkdtempSync: () => import_sync.mkdtempSync,
-  open: () => import_callback.open,
-  openSync: () => import_sync.openSync,
-  promises: () => promises,
-  read: () => import_callback.read,
-  readFileSync: () => import_sync.readFileSync,
-  readdir: () => import_callback.readdir,
-  readdirSync: () => import_sync.readdirSync,
-  realpath: () => import_callback.realpath,
-  realpathSync: () => import_sync.realpathSync,
-  rm: () => import_callback.rm,
-  rmSync: () => import_sync.rmSync,
-  rmdirSync: () => import_sync.rmdirSync,
-  statSync: () => import_sync.statSync,
-  symlink: () => import_callback.symlink,
-  symlinkSync: () => import_sync.symlinkSync,
-  unlinkSync: () => import_sync.unlinkSync,
-  watch: () => import_sync.watch,
-  write: () => import_callback.write,
-  writeFileSync: () => import_sync.writeFileSync
-});
-module.exports = __toCommonJS(src_exports);
-var import_sync = require("./sync.js");
-var import_callback = require("./callback.js");
-var import_fs_watcher = __toESM(require("./fs-watcher.js"), 1);
-var import_read_stream = require("./read-stream.js");
-var promises = __toESM(require("./promises.js"), 1);
+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: import_fs_watcher.default,
-  existsSync: import_sync.existsSync,
-  readdirSync: import_sync.readdirSync,
-  readFileSync: import_sync.readFileSync,
-  writeFileSync: import_sync.writeFileSync,
-  mkdirSync: import_sync.mkdirSync,
-  rmdirSync: import_sync.rmdirSync,
-  unlinkSync: import_sync.unlinkSync,
-  mkdtempSync: import_sync.mkdtempSync,
-  rmSync: import_sync.rmSync,
-  statSync: import_sync.statSync,
-  openSync: import_sync.openSync,
-  realpathSync: import_sync.realpathSync,
-  symlinkSync: import_sync.symlinkSync,
-  lstatSync: import_sync.lstatSync,
-  watch: import_sync.watch,
-  createReadStream: import_read_stream.createReadStream,
-  ReadStream: import_read_stream.ReadStream,
+  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,
-  open: import_callback.open,
-  close: import_callback.close,
-  read: import_callback.read,
-  write: import_callback.write,
-  rm: import_callback.rm,
-  realpath: import_callback.realpath,
-  readdir: import_callback.readdir,
-  symlink: import_callback.symlink,
-  lstat: import_callback.lstat
+  read,
+  readFileSync,
+  readdir,
+  readdirSync,
+  realpath,
+  realpathSync,
+  rm,
+  rmSync,
+  rmdirSync,
+  statSync,
+  symlink,
+  symlinkSync,
+  unlinkSync,
+  watch,
+  write,
+  writeFileSync
 };

package/lib/cjs/promises.js

@@ -1,63 +1,17 @@
-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 promises_exports = {};
-__export(promises_exports, {
-  default: () => promises_default,
-  lstat: () => import_fs_lstat.lstatPromise,
-  mkdir: () => mkdir,
-  mkdtemp: () => mkdtemp,
-  open: () => open,
-  readFile: () => readFile,
-  readdir: () => import_fs_readdir.readdirPromise,
-  realpath: () => import_fs_realpath.realpathPromise,
-  rm: () => rm,
-  rmdir: () => rmdir,
-  stat: () => import_fs_stat.statPromise,
-  symlink: () => import_fs_symlink.symlinkPromise,
-  unlink: () => unlink,
-  write: () => write,
-  writeFile: () => writeFile
-});
-module.exports = __toCommonJS(promises_exports);
-var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
-var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
-var import_utils = require("@gjsify/utils");
-var import_path = require("path");
-var import_encoding = require("./encoding.js");
-var import_sync = require("./sync.js");
-var import_file_handle = require("./file-handle.js");
-var import_utils2 = require("./utils.js");
-var import_dirent = require("./dirent.js");
-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");
+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;
@@ -69,14 +23,14 @@ async function mkdir(path, options) {
   } else {
     mode = options;
   }
-  const firstPath = (0, import_sync.mkdirSync)(path, {
+  const firstPath = mkdirSync(path, {
     recursive,
     mode
   });
   return firstPath;
 }
 async function readFile(path, options = { encoding: null, flag: "r" }) {
-  const file = import_gio_2.default.File.new_for_path(path.toString());
+  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 {
@@ -89,28 +43,28 @@ async function readFile(path, options = { encoding: null, flag: "r" }) {
   if (!ok) {
     throw new Error("failed to read file");
   }
-  return (0, import_encoding.encodeUint8Array)((0, import_encoding.getEncodingFromOptions)(options, "buffer"), data);
+  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
 }
 async function mkdtemp(prefix, options) {
-  const encoding = (0, import_encoding.getEncodingFromOptions)(options);
-  const path = (0, import_utils2.tempDirPath)(prefix);
+  const encoding = getEncodingFromOptions(options);
+  const path = tempDirPath(prefix);
   await mkdir(
     path,
     { recursive: false, mode: 448 }
   );
-  return (0, import_encoding.decode)(path, encoding);
+  return decode(path, encoding);
 }
 async function writeFile(path, data) {
-  return (0, import_sync.writeFileSync)(path, data);
+  return writeFileSync(path, data);
 }
 async function rmdir(path, options) {
-  return (0, import_sync.rmdirSync)(path, options);
+  return rmdirSync(path, options);
 }
 async function unlink(path) {
-  return (0, import_sync.unlinkSync)(path);
+  return unlinkSync(path);
 }
 async function open(path, flags, mode) {
-  return new import_file_handle.FileHandle({
+  return new FileHandle({
     path,
     flags,
     mode
@@ -123,39 +77,39 @@ async function write(fd, data, positionOrOffset, encodingOrLength, position) {
   return _writeBuf(fd, data, positionOrOffset, encodingOrLength, position);
 }
 async function _writeBuf(fd, buffer, offset, length, position) {
-  (0, import_utils.warnNotImplemented)("fs.promises.write");
+  warnNotImplemented("fs.promises.write");
   return {
     bytesWritten: 0,
     buffer
   };
 }
 async function _writeStr(fd, data, position, encoding) {
-  (0, import_utils.warnNotImplemented)("fs.promises.write");
+  warnNotImplemented("fs.promises.write");
   return {
     bytesWritten: 0,
     buffer: data
   };
 }
 async function rm(path, options) {
-  const file = import_gio_2.default.File.new_for_path(path.toString());
+  const file = Gio.File.new_for_path(path.toString());
   const recursive = options?.recursive || false;
-  const dirent = new import_dirent.Dirent(path.toString());
+  const dirent = new Dirent(path.toString());
   if (dirent.isDirectory()) {
-    const childFiles = await (0, import_fs_readdir.readdirPromise)(path, { withFileTypes: true });
+    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((0, import_path.join)(path.toString(), childFile.name), options);
+        await rmdir(join(path.toString(), childFile.name), options);
       } else if (childFile.isFile()) {
-        await rm((0, import_path.join)(path.toString(), childFile.name), options);
+        await rm(join(path.toString(), childFile.name), options);
       }
     }
   }
   const ok = await new Promise((resolve, reject) => {
     try {
-      file.delete_async(import_glib_2.default.PRIORITY_DEFAULT, null, (self, res) => {
+      file.delete_async(GLib.PRIORITY_DEFAULT, null, (self, res) => {
         try {
           resolve(file.delete_finish(res));
         } catch (error) {
@@ -175,15 +129,32 @@ var promises_default = {
   readFile,
   mkdir,
   mkdtemp,
-  realpath: import_fs_realpath.realpathPromise,
-  readdir: import_fs_readdir.readdirPromise,
+  realpath,
+  readdir,
   writeFile,
   rmdir,
   unlink,
   open,
   write,
   rm,
-  lstat: import_fs_lstat.lstatPromise,
-  symlink: import_fs_symlink.symlinkPromise,
-  stat: import_fs_stat.statPromise
+  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

@@ -1,44 +1,10 @@
-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 read_stream_exports = {};
-__export(read_stream_exports, {
-  ReadStream: () => ReadStream,
-  createReadStream: () => createReadStream,
-  fromFileUrl: () => fromFileUrl
-});
-module.exports = __toCommonJS(read_stream_exports);
-var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
-var import_utils = require("@gjsify/utils");
-var import_buffer = require("buffer");
-var import_stream = require("stream");
-var import_url = require("url");
+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 import_url.URL ? url : new import_url.URL(url);
+  url = url instanceof URL ? url : new URL(url);
   if (url.protocol != "file:") {
     throw new TypeError("Must be a file URL.");
   }
@@ -46,9 +12,9 @@ function fromFileUrl(url) {
     url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")
   );
 }
-class ReadStream extends import_stream.Readable {
+class ReadStream extends Readable {
   close(callback) {
-    callback((0, import_utils.notImplemented)("ReadStream.close"));
+    callback(notImplemented("ReadStream.close"));
   }
   /**
    * The number of bytes that have been read so far.
@@ -69,14 +35,14 @@ class ReadStream extends import_stream.Readable {
    */
   pending;
   constructor(path, opts) {
-    path = path instanceof import_url.URL ? fromFileUrl(path) : path;
+    path = path instanceof URL ? fromFileUrl(path) : path;
     const hasBadOptions = opts && (opts.start || opts.end);
     if (hasBadOptions) {
-      (0, import_utils.notImplemented)(
+      notImplemented(
         `fs.ReadStream.prototype.constructor with unsupported options (${JSON.stringify(opts)})`
       );
     }
-    const file = import_glib_2.default.IOChannel.new_file(path.toString(), "r");
+    const file = GLib.IOChannel.new_file(path.toString(), "r");
     const buffer = "";
     super({
       autoDestroy: true,
@@ -86,7 +52,7 @@ class ReadStream extends import_stream.Readable {
         try {
           let n = 0;
           file.read(buffer, 16 * 1024, n);
-          this.push(n ? import_buffer.Buffer.from(buffer.slice(0, n)) : null);
+          this.push(n ? Buffer.from(buffer.slice(0, n)) : null);
         } catch (err) {
           this.destroy(err);
         }
@@ -105,3 +71,8 @@ class ReadStream extends import_stream.Readable {
 function createReadStream(path, options) {
   return new ReadStream(path, options);
 }
+export {
+  ReadStream,
+  createReadStream,
+  fromFileUrl
+};

package/lib/cjs/stats.js

@@ -1,39 +1,7 @@
-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 stats_exports = {};
-__export(stats_exports, {
-  Stats: () => Stats
-});
-module.exports = __toCommonJS(stats_exports);
-var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
-var import_dirent = require("./dirent.js");
-var import_path = require("path");
-class Stats extends import_dirent.Dirent {
+import Gio from "@girs/gio-2.0";
+import { Dirent } from "./dirent.js";
+import { basename } from "path";
+class Stats extends Dirent {
   dev;
   ino;
   mode;
@@ -64,11 +32,14 @@ class Stats extends import_dirent.Dirent {
   constructor(path, filename) {
     const pathStr = path.toString();
     if (!filename)
-      filename = (0, import_path.basename)(pathStr);
+      filename = basename(pathStr);
     super(pathStr, filename);
     if (!this._file) {
       throw new TypeError("this._file is not defined!");
     }
-    this._info = this._file.query_info("standard::", import_gio_2.default.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    this._info = this._file.query_info("standard::", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
   }
 }
+export {
+  Stats
+};