@gjsify/fs 0.3.12 → 0.3.14

package/lib/esm/callback.js

@@ -1,357 +1,356 @@
+import { normalizePath } from "./utils.js";
+import { BigIntStats, STAT_ATTRIBUTES, Stats } from "./stats.js";
+import { FileHandle } from "./file-handle.js";
+import { createNodeError } from "./errors.js";
+import { accessSync, appendFileSync, chmodSync, chownSync, copyFileSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, truncateSync, writeFileSync } from "./sync.js";
+import { open as open$1, rm as rm$1 } from "./promises.js";
 import GLib from "@girs/glib-2.0";
 import Gio from "@girs/gio-2.0";
-import { open as openP, rm as rmP } from "./promises.js";
-import { FileHandle } from "./file-handle.js";
 import { Buffer } from "node:buffer";
-import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
-import { createNodeError } from "./errors.js";
-import { realpathSync, readdirSync, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, mkdirSync, rmdirSync, readFileSync, writeFileSync } from "./sync.js";
-import { normalizePath } from "./utils.js";
+
+//#region src/callback.ts
 function parseOptsCb(optionsOrCallback, maybeCallback) {
-  return typeof optionsOrCallback === "function" ? { options: {}, callback: optionsOrCallback } : { options: optionsOrCallback ?? {}, callback: maybeCallback };
+	return typeof optionsOrCallback === "function" ? {
+		options: {},
+		callback: optionsOrCallback
+	} : {
+		options: optionsOrCallback ?? {},
+		callback: maybeCallback
+	};
 }
 function statImpl(path, flags, syscall, options, callback) {
-  const pathStr = normalizePath(path);
-  const file = Gio.File.new_for_path(pathStr);
-  file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-    try {
-      const info = file.query_info_finish(res);
-      callback(null, options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
-    } catch (err) {
-      callback(createNodeError(err, syscall, pathStr));
-    }
-  });
+	const pathStr = normalizePath(path);
+	const file = Gio.File.new_for_path(pathStr);
+	file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+		try {
+			const info = file.query_info_finish(res);
+			callback(null, options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
+		} catch (err) {
+			callback(createNodeError(err, syscall, pathStr));
+		}
+	});
 }
 function stat(path, optionsOrCallback, maybeCallback) {
-  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
-  statImpl(path, Gio.FileQueryInfoFlags.NONE, "stat", options, callback);
+	const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+	statImpl(path, Gio.FileQueryInfoFlags.NONE, "stat", options, callback);
 }
 function lstat(path, optionsOrCallback, maybeCallback) {
-  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
-  statImpl(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, "lstat", options, callback);
+	const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+	statImpl(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, "lstat", options, callback);
 }
 function readdir(path, optionsOrCallback, maybeCallback) {
-  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
-  Promise.resolve().then(() => {
-    try {
-      callback(null, readdirSync(path, options));
-    } catch (err) {
-      callback(createNodeError(err, "readdir", path));
-    }
-  });
+	const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+	Promise.resolve().then(() => {
+		try {
+			callback(null, readdirSync(path, options));
+		} catch (err) {
+			callback(createNodeError(err, "readdir", path));
+		}
+	});
 }
 function realpath(path, optionsOrCallback, maybeCallback) {
-  const { callback } = parseOptsCb(optionsOrCallback, maybeCallback);
-  Promise.resolve().then(() => {
-    try {
-      callback(null, realpathSync(path));
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const { callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+	Promise.resolve().then(() => {
+		try {
+			callback(null, realpathSync(path));
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function symlink(target, path, typeOrCallback, maybeCallback) {
-  const callback = typeof typeOrCallback === "function" ? typeOrCallback : maybeCallback;
-  if (typeof callback !== "function") {
-    throw new TypeError("Callback must be a function. Received " + typeof callback);
-  }
-  const pathStr = normalizePath(path);
-  const targetStr = normalizePath(target);
-  const file = Gio.File.new_for_path(pathStr);
-  file.make_symbolic_link_async(targetStr, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-    try {
-      file.make_symbolic_link_finish(res);
-      callback(null);
-    } catch (err) {
-      callback(createNodeError(err, "symlink", targetStr, pathStr));
-    }
-  });
+	const callback = typeof typeOrCallback === "function" ? typeOrCallback : maybeCallback;
+	if (typeof callback !== "function") {
+		throw new TypeError("Callback must be a function. Received " + typeof callback);
+	}
+	const pathStr = normalizePath(path);
+	const targetStr = normalizePath(target);
+	const file = Gio.File.new_for_path(pathStr);
+	file.make_symbolic_link_async(targetStr, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+		try {
+			file.make_symbolic_link_finish(res);
+			callback(null);
+		} catch (err) {
+			callback(createNodeError(err, "symlink", targetStr, pathStr));
+		}
+	});
 }
 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;
-  }
-  openP(path, flags, mode).then((fileHandle) => {
-    callback(null, fileHandle.fd);
-  }).catch((err) => {
-    callback(err, -1);
-  });
+	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;
+	}
+	open$1(path, flags, mode).then((fileHandle) => {
+		callback(null, fileHandle.fd);
+	}).catch((err) => {
+		callback(err, -1);
+	});
 }
 function write(fd, data, ...args) {
-  const fileHandle = FileHandle.getInstance(fd);
-  if (typeof data === "string") {
-    const callback2 = args.pop();
-    const position2 = args[0];
-    const encoding = args[1];
-    fileHandle.write(data, position2, encoding).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, Buffer.from([]));
-  });
+	const fileHandle = FileHandle.getInstance(fd);
+	if (typeof data === "string") {
+		const callback = args.pop();
+		const position = args[0];
+		const encoding = args[1];
+		fileHandle.write(data, position, encoding).then((res) => {
+			callback(null, res.bytesWritten, res.buffer);
+		}).catch((err) => {
+			callback(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, Buffer.from([]));
+	});
 }
 function read(fd, ...args) {
-  const fileHandle = FileHandle.getInstance(fd);
-  const callback = args[args.length - 1];
-  let buffer;
-  let offset;
-  let length;
-  let position;
-  if (args.length <= 1) {
-  } else if (typeof args[0] === "object" && !ArrayBuffer.isView(args[0])) {
-    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((err) => {
-    callback(err, 0, Buffer.from([]));
-  });
+	const fileHandle = FileHandle.getInstance(fd);
+	const callback = args[args.length - 1];
+	let buffer;
+	let offset;
+	let length;
+	let position;
+	if (args.length <= 1) {} else if (typeof args[0] === "object" && !ArrayBuffer.isView(args[0])) {
+		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((err) => {
+		callback(err, 0, Buffer.from([]));
+	});
 }
+/**
+* Closes the file descriptor. No arguments other than a possible exception are
+* given to the completion callback.
+*
+* Calling `fs.close()` on any file descriptor (`fd`) that is currently in use
+* through any other `fs` operation may lead to undefined behavior.
+*
+* See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
+* @since v0.0.2
+*/
 function close(fd, callback) {
-  FileHandle.getInstance(fd).close().then(() => {
-    callback(null);
-  }).catch((err) => callback(err));
+	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];
-  }
-  rmP(path, options).then(() => {
-    callback(null);
-  }).catch((err) => {
-    callback(err);
-  });
+	let options = {};
+	let callback = args[args.length - 1];
+	if (args.length >= 2) {
+		options = args[0];
+	}
+	rm$1(path, options).then(() => {
+		callback(null);
+	}).catch((err) => {
+		callback(err);
+	});
 }
 function rename(oldPath, newPath, callback) {
-  Promise.resolve().then(() => {
-    try {
-      renameSync(oldPath, newPath);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	Promise.resolve().then(() => {
+		try {
+			renameSync(oldPath, newPath);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function copyFile(src, dest, modeOrCb, maybeCb) {
-  const mode = typeof modeOrCb === "function" ? 0 : modeOrCb;
-  const callback = typeof modeOrCb === "function" ? modeOrCb : maybeCb;
-  Promise.resolve().then(() => {
-    try {
-      copyFileSync(src, dest, mode);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const mode = typeof modeOrCb === "function" ? 0 : modeOrCb;
+	const callback = typeof modeOrCb === "function" ? modeOrCb : maybeCb;
+	Promise.resolve().then(() => {
+		try {
+			copyFileSync(src, dest, mode);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function access(path, modeOrCb, maybeCb) {
-  const mode = typeof modeOrCb === "function" ? void 0 : modeOrCb;
-  const callback = typeof modeOrCb === "function" ? modeOrCb : maybeCb;
-  Promise.resolve().then(() => {
-    try {
-      accessSync(path, mode);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const mode = typeof modeOrCb === "function" ? undefined : modeOrCb;
+	const callback = typeof modeOrCb === "function" ? modeOrCb : maybeCb;
+	Promise.resolve().then(() => {
+		try {
+			accessSync(path, mode);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function appendFile(path, data, optsOrCb, maybeCb) {
-  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
-  Promise.resolve().then(() => {
-    try {
-      appendFileSync(path, data, options);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+	const options = typeof optsOrCb === "function" ? undefined : optsOrCb;
+	Promise.resolve().then(() => {
+		try {
+			appendFileSync(path, data, options);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function readlink(path, optsOrCb, maybeCb) {
-  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
-  Promise.resolve().then(() => {
-    try {
-      callback(null, readlinkSync(path, options));
-    } catch (err) {
-      callback(err, "");
-    }
-  });
+	const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+	const options = typeof optsOrCb === "function" ? undefined : optsOrCb;
+	Promise.resolve().then(() => {
+		try {
+			callback(null, readlinkSync(path, options));
+		} catch (err) {
+			callback(err, "");
+		}
+	});
 }
 function truncate(path, lenOrCb, maybeCb) {
-  const len = typeof lenOrCb === "function" ? 0 : lenOrCb;
-  const callback = typeof lenOrCb === "function" ? lenOrCb : maybeCb;
-  Promise.resolve().then(() => {
-    try {
-      truncateSync(path, len);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const len = typeof lenOrCb === "function" ? 0 : lenOrCb;
+	const callback = typeof lenOrCb === "function" ? lenOrCb : maybeCb;
+	Promise.resolve().then(() => {
+		try {
+			truncateSync(path, len);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function chmod(path, mode, callback) {
-  Promise.resolve().then(() => {
-    try {
-      chmodSync(path, mode);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	Promise.resolve().then(() => {
+		try {
+			chmodSync(path, mode);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function chown(path, uid, gid, callback) {
-  Promise.resolve().then(() => {
-    try {
-      chownSync(path, uid, gid);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	Promise.resolve().then(() => {
+		try {
+			chownSync(path, uid, gid);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function mkdir(path, optsOrCb, maybeCb) {
-  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
-  Promise.resolve().then(() => {
-    try {
-      mkdirSync(path, options);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+	const options = typeof optsOrCb === "function" ? undefined : optsOrCb;
+	Promise.resolve().then(() => {
+		try {
+			mkdirSync(path, options);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function rmdir(path, optsOrCb, maybeCb) {
-  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
-  Promise.resolve().then(() => {
-    try {
-      rmdirSync(path, options);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+	const options = typeof optsOrCb === "function" ? undefined : optsOrCb;
+	Promise.resolve().then(() => {
+		try {
+			rmdirSync(path, options);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function readFile(path, optsOrCb, maybeCb) {
-  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
-  const pathStr = normalizePath(path);
-  Promise.resolve().then(() => {
-    try {
-      const readOpts = typeof options === "string" ? { encoding: options, flag: "r" } : { encoding: options?.encoding ?? null, flag: options?.flag ?? "r" };
-      callback(null, readFileSync(pathStr, readOpts));
-    } catch (err) {
-      callback(err, null);
-    }
-  });
+	const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+	const options = typeof optsOrCb === "function" ? undefined : optsOrCb;
+	const pathStr = normalizePath(path);
+	Promise.resolve().then(() => {
+		try {
+			const readOpts = typeof options === "string" ? {
+				encoding: options,
+				flag: "r"
+			} : {
+				encoding: options?.encoding ?? null,
+				flag: options?.flag ?? "r"
+			};
+			callback(null, readFileSync(pathStr, readOpts));
+		} catch (err) {
+			callback(err, null);
+		}
+	});
 }
 function writeFile(path, data, optsOrCb, maybeCb) {
-  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-  const pathStr = normalizePath(path);
-  Promise.resolve().then(() => {
-    try {
-      writeFileSync(pathStr, data);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+	const pathStr = normalizePath(path);
+	Promise.resolve().then(() => {
+		try {
+			writeFileSync(pathStr, data);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function link(existingPath, newPath, callback) {
-  const existingStr = normalizePath(existingPath);
-  const newStr = normalizePath(newPath);
-  Promise.resolve().then(() => {
-    try {
-      const result = GLib.spawn_command_line_sync(`ln ${existingStr} ${newStr}`);
-      if (!result[0]) {
-        throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingStr}' -> '${newStr}'`), {
-          code: "EPERM",
-          errno: -1,
-          syscall: "link",
-          path: existingStr,
-          dest: newStr
-        });
-      }
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const existingStr = normalizePath(existingPath);
+	const newStr = normalizePath(newPath);
+	Promise.resolve().then(() => {
+		try {
+			const result = GLib.spawn_command_line_sync(`ln ${existingStr} ${newStr}`);
+			if (!result[0]) {
+				throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingStr}' -> '${newStr}'`), {
+					code: "EPERM",
+					errno: -1,
+					syscall: "link",
+					path: existingStr,
+					dest: newStr
+				});
+			}
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
 function unlink(path, callback) {
-  const pathStr = normalizePath(path);
-  Promise.resolve().then(() => {
-    try {
-      GLib.unlink(pathStr);
-      callback(null);
-    } catch (err) {
-      callback(err);
-    }
-  });
+	const pathStr = normalizePath(path);
+	Promise.resolve().then(() => {
+		try {
+			GLib.unlink(pathStr);
+			callback(null);
+		} catch (err) {
+			callback(err);
+		}
+	});
 }
-export {
-  access,
-  appendFile,
-  chmod,
-  chown,
-  close,
-  copyFile,
-  link,
-  lstat,
-  mkdir,
-  open,
-  read,
-  readFile,
-  readdir,
-  readlink,
-  realpath,
-  rename,
-  rm,
-  rmdir,
-  stat,
-  symlink,
-  truncate,
-  unlink,
-  write,
-  writeFile
-};
+
+//#endregion
+export { access, appendFile, chmod, chown, close, copyFile, link, lstat, mkdir, open, read, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat, symlink, truncate, unlink, write, writeFile };