@duplojs/server 0.0.0-stage → 0.1.0-beta.2

package/dist/file/folderInterface.cjs

@@ -0,0 +1,74 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_stat = require("./stat.cjs");
+const require_rename = require("./rename.cjs");
+const require_exists = require("./exists.cjs");
+const require_move = require("./move.cjs");
+const require_remove = require("./remove.cjs");
+const require_relocate = require("./relocate.cjs");
+const require_readDirectory = require("./readDirectory.cjs");
+const require_walkDirectory = require("./walkDirectory.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/folderInterface.ts
+const folderInterfaceKind = require_kind.createKind("folderInterface");
+function createFolderInterface(path) {
+	function getName() {
+		return _duplojs_lang_path.getBaseName(path);
+	}
+	function getParentPath() {
+		return _duplojs_lang_path.getParentFolderPath(path);
+	}
+	function localRename(newName) {
+		return _duplojs_lang_common.asyncPipe(require_rename.rename(path, newName), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFolderInterface, (value) => _duplojs_lang_either.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return _duplojs_lang_common.asyncPipe(require_relocate.relocate(path, newParentPath), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFolderInterface, (value) => _duplojs_lang_either.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return _duplojs_lang_common.asyncPipe(require_move.move(path, newPath), _duplojs_lang_either.whenIsRight(() => _duplojs_lang_either.right("file-system-move", createFolderInterface(newPath))));
+	}
+	function localExists() {
+		return require_exists.exists(path);
+	}
+	function localRemove() {
+		return require_remove.remove(path);
+	}
+	function localStat() {
+		return require_stat.stat(path);
+	}
+	function getChildren() {
+		return require_readDirectory.readDirectory(path);
+	}
+	function walk(params) {
+		return require_walkDirectory.walkDirectory(path, params);
+	}
+	function isFolder() {
+		return _duplojs_lang_common.asyncPipe(localStat(), _duplojs_lang_either.whenHasInformationOtherwise("file-system-stat", ({ isDirectory }) => isDirectory, _duplojs_lang_common.justReturn(false)));
+	}
+	return {
+		path,
+		getName,
+		getParentPath,
+		move: localMove,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		getChildren,
+		stat: localStat,
+		walk,
+		isFolder,
+		[folderInterfaceKind.runTimeKey]: null
+	};
+}
+function isFolderInterface(input) {
+	return folderInterfaceKind.has(input);
+}
+//#endregion
+exports.createFolderInterface = createFolderInterface;
+exports.isFolderInterface = isFolderInterface;

package/dist/file/folderInterface.d.ts

@@ -0,0 +1,32 @@
+import { MoveResult } from './move';
+import { ExistsResult } from './exists';
+import { RenameResult } from './rename';
+import { RemoveResult } from './remove';
+import { ReadDirectoryResult } from './readDirectory';
+import { StatResult } from './stat';
+import { WalkDirectoryParams, WalkDirectoryResult } from './walkDirectory';
+import { RelocateResult } from './relocate';
+import type * as DKind from "@duplojs/lang/kind";
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+declare const folderInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/folderInterface", unknown>>;
+type FolderInterfaceRenameResult = Exclude<RenameResult, DEither.Right> | DEither.Right<"file-system-rename", FolderInterface>;
+type FolderInterfaceRelocateResult = Exclude<RelocateResult, DEither.Right> | DEither.Right<"file-system-relocate", FolderInterface>;
+type FolderInterfaceMoveResult = Exclude<MoveResult, DEither.Right> | DEither.Right<"file-system-move", FolderInterface>;
+export interface FolderInterface extends DKind.Kind<typeof folderInterfaceKind> {
+    path: string & DPath.Path;
+    getName(): (string & DPath.Segment) | null;
+    getParentPath(): (string & DPath.Path) | null;
+    rename(newName: (string & DPath.Segment)): Promise<FolderInterfaceRenameResult>;
+    exists(): Promise<ExistsResult>;
+    relocate(parentPath: string & DPath.Path): Promise<FolderInterfaceRelocateResult>;
+    move(newPath: string & DPath.Path): Promise<FolderInterfaceMoveResult>;
+    remove(): Promise<RemoveResult>;
+    getChildren(): Promise<ReadDirectoryResult>;
+    stat(): Promise<StatResult>;
+    walk(params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
+    isFolder(): Promise<boolean>;
+}
+export declare function createFolderInterface(path: string & DPath.Path): FolderInterface;
+export declare function isFolderInterface(input: unknown): input is FolderInterface;
+export {};

package/dist/file/folderInterface.mjs

@@ -0,0 +1,69 @@
+import { createKind } from "../kind.mjs";
+import { stat } from "./stat.mjs";
+import { rename } from "./rename.mjs";
+import { exists } from "./exists.mjs";
+import { move } from "./move.mjs";
+import { remove } from "./remove.mjs";
+import { relocate } from "./relocate.mjs";
+import { readDirectory } from "./readDirectory.mjs";
+import { walkDirectory } from "./walkDirectory.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/folderInterface.ts
+const folderInterfaceKind = createKind("folderInterface");
+function createFolderInterface(path) {
+	function getName() {
+		return DPath.getBaseName(path);
+	}
+	function getParentPath() {
+		return DPath.getParentFolderPath(path);
+	}
+	function localRename(newName) {
+		return DCommon.asyncPipe(rename(path, newName), DEither.whenIsRight(DCommon.innerPipe(createFolderInterface, (value) => DEither.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return DCommon.asyncPipe(relocate(path, newParentPath), DEither.whenIsRight(DCommon.innerPipe(createFolderInterface, (value) => DEither.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return DCommon.asyncPipe(move(path, newPath), DEither.whenIsRight(() => DEither.right("file-system-move", createFolderInterface(newPath))));
+	}
+	function localExists() {
+		return exists(path);
+	}
+	function localRemove() {
+		return remove(path);
+	}
+	function localStat() {
+		return stat(path);
+	}
+	function getChildren() {
+		return readDirectory(path);
+	}
+	function walk(params) {
+		return walkDirectory(path, params);
+	}
+	function isFolder() {
+		return DCommon.asyncPipe(localStat(), DEither.whenHasInformationOtherwise("file-system-stat", ({ isDirectory }) => isDirectory, DCommon.justReturn(false)));
+	}
+	return {
+		path,
+		getName,
+		getParentPath,
+		move: localMove,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		getChildren,
+		stat: localStat,
+		walk,
+		isFolder,
+		[folderInterfaceKind.runTimeKey]: null
+	};
+}
+function isFolderInterface(input) {
+	return folderInterfaceKind.has(input);
+}
+//#endregion
+export { createFolderInterface, isFolderInterface };

package/dist/file/index.cjs

@@ -0,0 +1,122 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_appendFile = require("./appendFile.cjs");
+const require_appendTextFile = require("./appendTextFile.cjs");
+const require_copy = require("./copy.cjs");
+const require_stat = require("./stat.cjs");
+const require_rename = require("./rename.cjs");
+const require_exists = require("./exists.cjs");
+const require_move = require("./move.cjs");
+const require_remove = require("./remove.cjs");
+const require_relocate = require("./relocate.cjs");
+const require_fileInterface = require("./fileInterface.cjs");
+const require_readDirectory = require("./readDirectory.cjs");
+const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
+const require_walkDirectory = require("./walkDirectory.cjs");
+const require_folderInterface = require("./folderInterface.cjs");
+const require_createEntryInterface = require("./createEntryInterface.cjs");
+const require_ensureDirectory = require("./ensureDirectory.cjs");
+const require_ensureFile = require("./ensureFile.cjs");
+const require_link = require("./link.cjs");
+const require_linkStat = require("./linkStat.cjs");
+const require_makeDirectory = require("./makeDirectory.cjs");
+const require_makeTemporaryDirectory = require("./makeTemporaryDirectory.cjs");
+const require_makeTemporaryFile = require("./makeTemporaryFile.cjs");
+const require_readFile = require("./readFile.cjs");
+const require_readJsonFile = require("./readJsonFile.cjs");
+const require_readLink = require("./readLink.cjs");
+const require_readTextFile = require("./readTextFile.cjs");
+const require_realPath = require("./realPath.cjs");
+const require_setMode = require("./setMode.cjs");
+const require_setOwner = require("./setOwner.cjs");
+const require_setTime = require("./setTime.cjs");
+const require_symlink = require("./symlink.cjs");
+const require_truncate = require("./truncate.cjs");
+const require_writeFile = require("./writeFile.cjs");
+const require_writeJsonFile = require("./writeJsonFile.cjs");
+const require_writeTextFile = require("./writeTextFile.cjs");
+//#region scripts/file/index.ts
+var file_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	appendFile: () => require_appendFile.appendFile,
+	appendTextFile: () => require_appendTextFile.appendTextFile,
+	copy: () => require_copy.copy,
+	createEntryInterface: () => require_createEntryInterface.createEntryInterface,
+	createFileInterface: () => require_fileInterface.createFileInterface,
+	createFolderInterface: () => require_folderInterface.createFolderInterface,
+	createUnknownEntryInterface: () => require_unknownEntryInterface.createUnknownEntryInterface,
+	ensureDirectory: () => require_ensureDirectory.ensureDirectory,
+	ensureFile: () => require_ensureFile.ensureFile,
+	exists: () => require_exists.exists,
+	isFileInterface: () => require_fileInterface.isFileInterface,
+	isFolderInterface: () => require_folderInterface.isFolderInterface,
+	isUnknownEntryInterface: () => require_unknownEntryInterface.isUnknownEntryInterface,
+	link: () => require_link.link,
+	linkStat: () => require_linkStat.linkStat,
+	makeDirectory: () => require_makeDirectory.makeDirectory,
+	makeTemporaryDirectory: () => require_makeTemporaryDirectory.makeTemporaryDirectory,
+	makeTemporaryFile: () => require_makeTemporaryFile.makeTemporaryFile,
+	move: () => require_move.move,
+	readDirectory: () => require_readDirectory.readDirectory,
+	readFile: () => require_readFile.readFile,
+	readJsonFile: () => require_readJsonFile.readJsonFile,
+	readLink: () => require_readLink.readLink,
+	readTextFile: () => require_readTextFile.readTextFile,
+	realPath: () => require_realPath.realPath,
+	relocate: () => require_relocate.relocate,
+	remove: () => require_remove.remove,
+	rename: () => require_rename.rename,
+	setMode: () => require_setMode.setMode,
+	setOwner: () => require_setOwner.setOwner,
+	setTime: () => require_setTime.setTime,
+	stat: () => require_stat.stat,
+	symlink: () => require_symlink.symlink,
+	truncate: () => require_truncate.truncate,
+	walkDirectory: () => require_walkDirectory.walkDirectory,
+	writeFile: () => require_writeFile.writeFile,
+	writeJsonFile: () => require_writeJsonFile.writeJsonFile,
+	writeTextFile: () => require_writeTextFile.writeTextFile
+});
+//#endregion
+exports.appendFile = require_appendFile.appendFile;
+exports.appendTextFile = require_appendTextFile.appendTextFile;
+exports.copy = require_copy.copy;
+exports.createEntryInterface = require_createEntryInterface.createEntryInterface;
+exports.createFileInterface = require_fileInterface.createFileInterface;
+exports.createFolderInterface = require_folderInterface.createFolderInterface;
+exports.createUnknownEntryInterface = require_unknownEntryInterface.createUnknownEntryInterface;
+exports.ensureDirectory = require_ensureDirectory.ensureDirectory;
+exports.ensureFile = require_ensureFile.ensureFile;
+exports.exists = require_exists.exists;
+Object.defineProperty(exports, "file_exports", {
+	enumerable: true,
+	get: function() {
+		return file_exports;
+	}
+});
+exports.isFileInterface = require_fileInterface.isFileInterface;
+exports.isFolderInterface = require_folderInterface.isFolderInterface;
+exports.isUnknownEntryInterface = require_unknownEntryInterface.isUnknownEntryInterface;
+exports.link = require_link.link;
+exports.linkStat = require_linkStat.linkStat;
+exports.makeDirectory = require_makeDirectory.makeDirectory;
+exports.makeTemporaryDirectory = require_makeTemporaryDirectory.makeTemporaryDirectory;
+exports.makeTemporaryFile = require_makeTemporaryFile.makeTemporaryFile;
+exports.move = require_move.move;
+exports.readDirectory = require_readDirectory.readDirectory;
+exports.readFile = require_readFile.readFile;
+exports.readJsonFile = require_readJsonFile.readJsonFile;
+exports.readLink = require_readLink.readLink;
+exports.readTextFile = require_readTextFile.readTextFile;
+exports.realPath = require_realPath.realPath;
+exports.relocate = require_relocate.relocate;
+exports.remove = require_remove.remove;
+exports.rename = require_rename.rename;
+exports.setMode = require_setMode.setMode;
+exports.setOwner = require_setOwner.setOwner;
+exports.setTime = require_setTime.setTime;
+exports.stat = require_stat.stat;
+exports.symlink = require_symlink.symlink;
+exports.truncate = require_truncate.truncate;
+exports.walkDirectory = require_walkDirectory.walkDirectory;
+exports.writeFile = require_writeFile.writeFile;
+exports.writeJsonFile = require_writeJsonFile.writeJsonFile;
+exports.writeTextFile = require_writeTextFile.writeTextFile;

package/dist/file/index.d.ts

@@ -0,0 +1,36 @@
+export * from './appendFile';
+export * from './appendTextFile';
+export * from './copy';
+export * from './createEntryInterface';
+export * from './ensureDirectory';
+export * from './ensureFile';
+export * from './exists';
+export * from './fileInterface';
+export * from './folderInterface';
+export * from './link';
+export * from './linkStat';
+export * from './makeDirectory';
+export * from './makeTemporaryDirectory';
+export * from './makeTemporaryFile';
+export * from './move';
+export * from './readDirectory';
+export * from './readFile';
+export * from './readJsonFile';
+export * from './readLink';
+export * from './readTextFile';
+export * from './realPath';
+export * from './relocate';
+export * from './remove';
+export * from './rename';
+export * from './setMode';
+export * from './setOwner';
+export * from './setTime';
+export * from './stat';
+export * from './symlink';
+export * from './truncate';
+export type * from './types';
+export * from './unknownEntryInterface';
+export * from './walkDirectory';
+export * from './writeFile';
+export * from './writeJsonFile';
+export * from './writeTextFile';

package/dist/file/index.mjs

@@ -0,0 +1,79 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { appendFile } from "./appendFile.mjs";
+import { appendTextFile } from "./appendTextFile.mjs";
+import { copy } from "./copy.mjs";
+import { stat } from "./stat.mjs";
+import { rename } from "./rename.mjs";
+import { exists } from "./exists.mjs";
+import { move } from "./move.mjs";
+import { remove } from "./remove.mjs";
+import { relocate } from "./relocate.mjs";
+import { createFileInterface, isFileInterface } from "./fileInterface.mjs";
+import { readDirectory } from "./readDirectory.mjs";
+import { createUnknownEntryInterface, isUnknownEntryInterface } from "./unknownEntryInterface.mjs";
+import { walkDirectory } from "./walkDirectory.mjs";
+import { createFolderInterface, isFolderInterface } from "./folderInterface.mjs";
+import { createEntryInterface } from "./createEntryInterface.mjs";
+import { ensureDirectory } from "./ensureDirectory.mjs";
+import { ensureFile } from "./ensureFile.mjs";
+import { link } from "./link.mjs";
+import { linkStat } from "./linkStat.mjs";
+import { makeDirectory } from "./makeDirectory.mjs";
+import { makeTemporaryDirectory } from "./makeTemporaryDirectory.mjs";
+import { makeTemporaryFile } from "./makeTemporaryFile.mjs";
+import { readFile } from "./readFile.mjs";
+import { readJsonFile } from "./readJsonFile.mjs";
+import { readLink } from "./readLink.mjs";
+import { readTextFile } from "./readTextFile.mjs";
+import { realPath } from "./realPath.mjs";
+import { setMode } from "./setMode.mjs";
+import { setOwner } from "./setOwner.mjs";
+import { setTime } from "./setTime.mjs";
+import { symlink } from "./symlink.mjs";
+import { truncate } from "./truncate.mjs";
+import { writeFile } from "./writeFile.mjs";
+import { writeJsonFile } from "./writeJsonFile.mjs";
+import { writeTextFile } from "./writeTextFile.mjs";
+//#region scripts/file/index.ts
+var file_exports = /* @__PURE__ */ __exportAll({
+	appendFile: () => appendFile,
+	appendTextFile: () => appendTextFile,
+	copy: () => copy,
+	createEntryInterface: () => createEntryInterface,
+	createFileInterface: () => createFileInterface,
+	createFolderInterface: () => createFolderInterface,
+	createUnknownEntryInterface: () => createUnknownEntryInterface,
+	ensureDirectory: () => ensureDirectory,
+	ensureFile: () => ensureFile,
+	exists: () => exists,
+	isFileInterface: () => isFileInterface,
+	isFolderInterface: () => isFolderInterface,
+	isUnknownEntryInterface: () => isUnknownEntryInterface,
+	link: () => link,
+	linkStat: () => linkStat,
+	makeDirectory: () => makeDirectory,
+	makeTemporaryDirectory: () => makeTemporaryDirectory,
+	makeTemporaryFile: () => makeTemporaryFile,
+	move: () => move,
+	readDirectory: () => readDirectory,
+	readFile: () => readFile,
+	readJsonFile: () => readJsonFile,
+	readLink: () => readLink,
+	readTextFile: () => readTextFile,
+	realPath: () => realPath,
+	relocate: () => relocate,
+	remove: () => remove,
+	rename: () => rename,
+	setMode: () => setMode,
+	setOwner: () => setOwner,
+	setTime: () => setTime,
+	stat: () => stat,
+	symlink: () => symlink,
+	truncate: () => truncate,
+	walkDirectory: () => walkDirectory,
+	writeFile: () => writeFile,
+	writeJsonFile: () => writeJsonFile,
+	writeTextFile: () => writeTextFile
+});
+//#endregion
+export { appendFile, appendTextFile, copy, createEntryInterface, createFileInterface, createFolderInterface, createUnknownEntryInterface, ensureDirectory, ensureFile, exists, file_exports, isFileInterface, isFolderInterface, isUnknownEntryInterface, link, linkStat, makeDirectory, makeTemporaryDirectory, makeTemporaryFile, move, readDirectory, readFile, readJsonFile, readLink, readTextFile, realPath, relocate, remove, rename, setMode, setOwner, setTime, stat, symlink, truncate, walkDirectory, writeFile, writeJsonFile, writeTextFile };

package/dist/file/link.cjs

@@ -0,0 +1,44 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/link.ts
+function handleNodeLinkError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-link-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-link-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-link-already-exists", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-link-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-link-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-link-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-link-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-link-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-link-busy", error);
+		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-link-cross-device", error);
+	}
+	return _duplojs_lang_either.left("file-system-link-error", error);
+}
+function handleDenoLinkError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-link-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-link-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-link-already-exists", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-link-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-link-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-link-busy", error);
+	return _duplojs_lang_either.left("file-system-link-error", error);
+}
+const linkImplementation = require_implementor.implementFunction("link", {
+	NODE: async (existingPath, newPath) => {
+		return (await require_implementor.nodeFileSystem.value).link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleNodeLinkError);
+	},
+	DENO: (existingPath, newPath) => Deno.link(existingPath, newPath).then(() => _duplojs_lang_either.right("file-system-link")).catch(handleDenoLinkError)
+});
+function link(...args) {
+	if (args.length === 1) {
+		const [newPath] = args;
+		return (existingPath) => linkImplementation(existingPath, newPath);
+	}
+	return linkImplementation(...args);
+}
+//#endregion
+exports.link = link;

package/dist/file/link.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type LinkResult = FileSystemEither<DEither.Right<"link", void> | DEither.Left<"link-not-found", unknown> | DEither.Left<"link-permission-denied", unknown> | DEither.Left<"link-already-exists", unknown> | DEither.Left<"link-not-directory", unknown> | DEither.Left<"link-no-space", unknown> | DEither.Left<"link-read-only", unknown> | DEither.Left<"link-invalid-argument", unknown> | DEither.Left<"link-too-many-open-files", unknown> | DEither.Left<"link-busy", unknown> | DEither.Left<"link-cross-device", unknown> | DEither.Left<"link-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        link(existingPath: string & DPath.Path, newPath: string & DPath.Path): Promise<LinkResult>;
+    }
+}
+export declare function link(newPath: string & DPath.Path): (existingPath: string & DPath.Path) => Promise<LinkResult>;
+export declare function link(existingPath: string & DPath.Path, newPath: string & DPath.Path): Promise<LinkResult>;

package/dist/file/link.mjs

@@ -0,0 +1,42 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/link.ts
+function handleNodeLinkError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-link-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-link-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-link-already-exists", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-link-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-link-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-link-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-link-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-link-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-link-busy", error);
+		else if (error.code === "EXDEV") return DEither.left("file-system-link-cross-device", error);
+	}
+	return DEither.left("file-system-link-error", error);
+}
+function handleDenoLinkError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-link-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-link-permission-denied", error);
+	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-link-already-exists", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-link-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-link-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-link-busy", error);
+	return DEither.left("file-system-link-error", error);
+}
+const linkImplementation = implementFunction("link", {
+	NODE: async (existingPath, newPath) => {
+		return (await nodeFileSystem.value).link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleNodeLinkError);
+	},
+	DENO: (existingPath, newPath) => Deno.link(existingPath, newPath).then(() => DEither.right("file-system-link")).catch(handleDenoLinkError)
+});
+function link(...args) {
+	if (args.length === 1) {
+		const [newPath] = args;
+		return (existingPath) => linkImplementation(existingPath, newPath);
+	}
+	return linkImplementation(...args);
+}
+//#endregion
+export { link };

package/dist/file/linkStat.cjs

@@ -0,0 +1,84 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_chrono = require("@duplojs/lang/chrono");
+_duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
+//#region scripts/file/linkStat.ts
+function handleNodeLinkStatError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-link-stat-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-link-stat-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-link-stat-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-link-stat-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-link-stat-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-link-stat-error", error);
+}
+function handleDenoLinkStatError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-link-stat-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-link-stat-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-link-stat-not-directory", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-link-stat-busy", error);
+	return _duplojs_lang_either.left("file-system-link-stat-error", error);
+}
+function createStatInfoWithFsSource(source) {
+	return {
+		isFile: source.isFile(),
+		isDirectory: source.isDirectory(),
+		isSymlink: source.isSymbolicLink(),
+		sizeBytes: source.size,
+		modifiedAt: _duplojs_lang_chrono.isSafeTimestamp(source.mtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.mtime) : null,
+		accessedAt: _duplojs_lang_chrono.isSafeTimestamp(source.atime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.atime) : null,
+		createdAt: _duplojs_lang_chrono.isSafeTimestamp(source.birthtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.birthtime) : null,
+		changedAt: _duplojs_lang_chrono.isSafeTimestamp(source.ctime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.ctime) : null,
+		deviceId: source.dev,
+		inode: source.ino,
+		permissionsMode: source.mode,
+		hardLinkCount: source.nlink,
+		ownerUserId: source.uid,
+		ownerGroupId: source.gid,
+		specialDeviceId: source.rdev,
+		ioBlockSize: source.blksize,
+		allocatedBlockCount: source.blocks,
+		isBlockDevice: source.isBlockDevice(),
+		isCharacterDevice: source.isCharacterDevice(),
+		isFifo: source.isFIFO(),
+		isSocket: source.isSocket()
+	};
+}
+function createStatInfoWithDeno(source) {
+	return {
+		isFile: source.isFile,
+		isDirectory: source.isDirectory,
+		isSymlink: source.isSymlink,
+		sizeBytes: source.size,
+		modifiedAt: source.mtime && _duplojs_lang_chrono.isSafeTimestamp(source.mtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.mtime) : null,
+		accessedAt: source.atime && _duplojs_lang_chrono.isSafeTimestamp(source.atime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.atime) : null,
+		createdAt: source.birthtime && _duplojs_lang_chrono.isSafeTimestamp(source.birthtime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.birthtime) : null,
+		changedAt: source.ctime && _duplojs_lang_chrono.isSafeTimestamp(source.ctime.getTime()) ? _duplojs_lang_chrono.createDateOrThrow(source.ctime) : null,
+		deviceId: source.dev,
+		inode: source.ino,
+		permissionsMode: source.mode,
+		hardLinkCount: source.nlink,
+		ownerUserId: source.uid,
+		ownerGroupId: source.gid,
+		specialDeviceId: source.rdev,
+		ioBlockSize: source.blksize,
+		allocatedBlockCount: source.blocks,
+		isBlockDevice: source.isBlockDevice,
+		isCharacterDevice: source.isCharDevice,
+		isFifo: source.isFifo,
+		isSocket: source.isSocket
+	};
+}
+const linkStat = require_implementor.implementFunction("linkStat", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleNodeLinkStatError);
+	},
+	DENO: (path) => Deno.lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithDeno, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleDenoLinkStatError)
+});
+//#endregion
+exports.linkStat = linkStat;

package/dist/file/linkStat.d.ts

@@ -0,0 +1,11 @@
+import { StatInfo } from './stat';
+import { FileSystemEither } from './types';
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export type LinkStatResult = FileSystemEither<DEither.Right<"link-stat", StatInfo> | DEither.Left<"link-stat-not-found", unknown> | DEither.Left<"link-stat-permission-denied", unknown> | DEither.Left<"link-stat-not-directory", unknown> | DEither.Left<"link-stat-too-many-open-files", unknown> | DEither.Left<"link-stat-busy", unknown> | DEither.Left<"link-stat-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        linkStat(path: string & DPath.Path): Promise<LinkStatResult>;
+    }
+}
+export declare const linkStat: (path: string & DPath.Path) => Promise<LinkStatResult>;