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

package/dist/file/appendTextFile.mjs

@@ -0,0 +1,41 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/appendTextFile.ts
+function handleNodeAppendTextFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-append-text-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-append-text-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-append-text-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-append-text-file-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-append-text-file-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-append-text-file-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-append-text-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-append-text-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-append-text-file-busy", error);
+	}
+	return DEither.left("file-system-append-text-file-error", error);
+}
+function handleDenoAppendTextFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-append-text-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-append-text-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-append-text-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-append-text-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-append-text-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-append-text-file-busy", error);
+	return DEither.left("file-system-append-text-file-error", error);
+}
+const appendTextFileImplementation = implementFunction("appendTextFile", {
+	NODE: async (path, data) => {
+		return (await nodeFileSystem.value).appendFile(path, data).then(() => DEither.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError);
+	},
+	DENO: (path, data) => Deno.writeTextFile(path, data, { append: true }).then(() => DEither.right("file-system-append-text-file")).catch(handleDenoAppendTextFileError)
+});
+function appendTextFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendTextFileImplementation(path, data);
+	}
+	return appendTextFileImplementation(...args);
+}
+//#endregion
+export { appendTextFile };

package/dist/file/copy.cjs

@@ -0,0 +1,31 @@
+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/copy.ts
+function handleNodeCopyError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-copy-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-copy-permission-denied", error);
+		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-copy-already-exists", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-copy-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-copy-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-copy-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-copy-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-copy-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-copy-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-copy-error", error);
+}
+const copyImplementation = require_implementor.implementFunction("copy", { NODE: async (fromPath, toPath) => {
+	return (await require_implementor.nodeFileSystem.value).cp(fromPath, toPath, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-copy")).catch(handleNodeCopyError);
+} });
+function copy(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => copyImplementation(fromPath, toPath);
+	}
+	return copyImplementation(...args);
+}
+//#endregion
+exports.copy = copy;

package/dist/file/copy.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 CopyResult = FileSystemEither<DEither.Right<"copy", void> | DEither.Left<"copy-not-found", unknown> | DEither.Left<"copy-permission-denied", unknown> | DEither.Left<"copy-already-exists", unknown> | DEither.Left<"copy-not-directory", unknown> | DEither.Left<"copy-no-space", unknown> | DEither.Left<"copy-read-only", unknown> | DEither.Left<"copy-invalid-argument", unknown> | DEither.Left<"copy-too-many-open-files", unknown> | DEither.Left<"copy-busy", unknown> | DEither.Left<"copy-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        copy(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<CopyResult>;
+    }
+}
+export declare function copy(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<CopyResult>;
+export declare function copy(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<CopyResult>;

package/dist/file/copy.mjs

@@ -0,0 +1,29 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/copy.ts
+function handleNodeCopyError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-copy-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-copy-permission-denied", error);
+		else if (error.code === "EEXIST") return DEither.left("file-system-copy-already-exists", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-copy-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-copy-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-copy-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-copy-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-copy-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-copy-busy", error);
+	}
+	return DEither.left("file-system-copy-error", error);
+}
+const copyImplementation = implementFunction("copy", { NODE: async (fromPath, toPath) => {
+	return (await nodeFileSystem.value).cp(fromPath, toPath, { recursive: true }).then(() => DEither.right("file-system-copy")).catch(handleNodeCopyError);
+} });
+function copy(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => copyImplementation(fromPath, toPath);
+	}
+	return copyImplementation(...args);
+}
+//#endregion
+export { copy };

package/dist/file/createEntryInterface.cjs

@@ -0,0 +1,16 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_stat = require("./stat.cjs");
+const require_fileInterface = require("./fileInterface.cjs");
+const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
+const require_folderInterface = require("./folderInterface.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+//#region scripts/file/createEntryInterface.ts
+async function createEntryInterface(path) {
+	const result = await _duplojs_lang_either.rightAsyncPipe(require_stat.stat(path), _duplojs_lang_pattern.when(({ isFile }) => isFile, () => _duplojs_lang_either.right("file-interface", require_fileInterface.createFileInterface(path))), _duplojs_lang_pattern.when(({ isDirectory }) => isDirectory, () => _duplojs_lang_either.right("folder-interface", require_folderInterface.createFolderInterface(path))), _duplojs_lang_pattern.otherwise(() => _duplojs_lang_either.right("unknown-entry-interface", require_unknownEntryInterface.createUnknownEntryInterface(path))));
+	return _duplojs_lang_either.whenIsLeft(result, (value) => _duplojs_lang_either.left("create-entry-interface-error", value));
+}
+//#endregion
+exports.createEntryInterface = createEntryInterface;

package/dist/file/createEntryInterface.d.ts

@@ -0,0 +1,3 @@
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export declare function createEntryInterface(path: string & DPath.Path): Promise<DEither.Right<"file-interface", import('./fileInterface').FileInterface> | DEither.Right<"folder-interface", import('./folderInterface').FolderInterface> | DEither.Right<"unknown-entry-interface", import('./unknownEntryInterface').UnknownEntryInterface> | DEither.Left<"create-entry-interface-error", unknown>>;

package/dist/file/createEntryInterface.mjs

@@ -0,0 +1,13 @@
+import { stat } from "./stat.mjs";
+import { createFileInterface } from "./fileInterface.mjs";
+import { createUnknownEntryInterface } from "./unknownEntryInterface.mjs";
+import { createFolderInterface } from "./folderInterface.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DPattern from "@duplojs/lang/pattern";
+//#region scripts/file/createEntryInterface.ts
+async function createEntryInterface(path) {
+	const result = await DEither.rightAsyncPipe(stat(path), DPattern.when(({ isFile }) => isFile, () => DEither.right("file-interface", createFileInterface(path))), DPattern.when(({ isDirectory }) => isDirectory, () => DEither.right("folder-interface", createFolderInterface(path))), DPattern.otherwise(() => DEither.right("unknown-entry-interface", createUnknownEntryInterface(path))));
+	return DEither.whenIsLeft(result, (value) => DEither.left("create-entry-interface-error", value));
+}
+//#endregion
+export { createEntryInterface };

package/dist/file/ensureDirectory.cjs

@@ -0,0 +1,32 @@
+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/ensureDirectory.ts
+function handleNodeEnsureDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-ensure-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-ensure-directory-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-ensure-directory-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-ensure-directory-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-ensure-directory-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-ensure-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-ensure-directory-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-ensure-directory-error", error);
+}
+function handleDenoEnsureDirectoryError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-ensure-directory-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-ensure-directory-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-ensure-directory-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-ensure-directory-busy", error);
+	return _duplojs_lang_either.left("file-system-ensure-directory-error", error);
+}
+const ensureDirectory = require_implementor.implementFunction("ensureDirectory", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).mkdir(path, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-ensure-directory")).catch(handleNodeEnsureDirectoryError);
+	},
+	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
+});
+//#endregion
+exports.ensureDirectory = ensureDirectory;

package/dist/file/ensureDirectory.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type EnsureDirectoryResult = FileSystemEither<DEither.Right<"ensure-directory", void> | DEither.Left<"ensure-directory-permission-denied", unknown> | DEither.Left<"ensure-directory-not-directory", unknown> | DEither.Left<"ensure-directory-no-space", unknown> | DEither.Left<"ensure-directory-read-only", unknown> | DEither.Left<"ensure-directory-invalid-argument", unknown> | DEither.Left<"ensure-directory-too-many-open-files", unknown> | DEither.Left<"ensure-directory-busy", unknown> | DEither.Left<"ensure-directory-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        ensureDirectory(path: string & DPath.Path): Promise<EnsureDirectoryResult>;
+    }
+}
+export declare const ensureDirectory: (path: string & DPath.Path) => Promise<EnsureDirectoryResult>;

package/dist/file/ensureDirectory.mjs

@@ -0,0 +1,30 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/ensureDirectory.ts
+function handleNodeEnsureDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-ensure-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-ensure-directory-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-ensure-directory-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-ensure-directory-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-ensure-directory-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-ensure-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-ensure-directory-busy", error);
+	}
+	return DEither.left("file-system-ensure-directory-error", error);
+}
+function handleDenoEnsureDirectoryError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-ensure-directory-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-ensure-directory-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-ensure-directory-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-ensure-directory-busy", error);
+	return DEither.left("file-system-ensure-directory-error", error);
+}
+const ensureDirectory = implementFunction("ensureDirectory", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleNodeEnsureDirectoryError);
+	},
+	DENO: (path) => Deno.mkdir(path, { recursive: true }).then(() => DEither.right("file-system-ensure-directory")).catch(handleDenoEnsureDirectoryError)
+});
+//#endregion
+export { ensureDirectory };

package/dist/file/ensureFile.cjs

@@ -0,0 +1,38 @@
+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/ensureFile.ts
+function handleNodeEnsureFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-ensure-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-ensure-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-ensure-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-ensure-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-ensure-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-ensure-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-ensure-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-ensure-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-ensure-file-error", error);
+}
+function handleDenoEnsureFileError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-ensure-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-ensure-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-ensure-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-ensure-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-ensure-file-busy", error);
+	return _duplojs_lang_either.left("file-system-ensure-file-error", error);
+}
+const ensureFile = require_implementor.implementFunction("ensureFile", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).open(path, "a").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleNodeEnsureFileError);
+	},
+	DENO: (path) => Deno.open(path, {
+		write: true,
+		create: true,
+		append: true
+	}).then((fh) => void fh.close()).then(() => _duplojs_lang_either.right("file-system-ensure-file")).catch(handleDenoEnsureFileError)
+});
+//#endregion
+exports.ensureFile = ensureFile;

package/dist/file/ensureFile.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type EnsureFileResult = FileSystemEither<DEither.Right<"ensure-file", void> | DEither.Left<"ensure-file-permission-denied", unknown> | DEither.Left<"ensure-file-is-directory", unknown> | DEither.Left<"ensure-file-not-directory", unknown> | DEither.Left<"ensure-file-no-space", unknown> | DEither.Left<"ensure-file-read-only", unknown> | DEither.Left<"ensure-file-invalid-argument", unknown> | DEither.Left<"ensure-file-too-many-open-files", unknown> | DEither.Left<"ensure-file-busy", unknown> | DEither.Left<"ensure-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        ensureFile(path: string & DPath.Path): Promise<EnsureFileResult>;
+    }
+}
+export declare const ensureFile: (path: string & DPath.Path) => Promise<EnsureFileResult>;

package/dist/file/ensureFile.mjs

@@ -0,0 +1,36 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/ensureFile.ts
+function handleNodeEnsureFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-ensure-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-ensure-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-ensure-file-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-ensure-file-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-ensure-file-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-ensure-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-ensure-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-ensure-file-busy", error);
+	}
+	return DEither.left("file-system-ensure-file-error", error);
+}
+function handleDenoEnsureFileError(error) {
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-ensure-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-ensure-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-ensure-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-ensure-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-ensure-file-busy", error);
+	return DEither.left("file-system-ensure-file-error", error);
+}
+const ensureFile = implementFunction("ensureFile", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).open(path, "a").then((fh) => fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleNodeEnsureFileError);
+	},
+	DENO: (path) => Deno.open(path, {
+		write: true,
+		create: true,
+		append: true
+	}).then((fh) => void fh.close()).then(() => DEither.right("file-system-ensure-file")).catch(handleDenoEnsureFileError)
+});
+//#endregion
+export { ensureFile };

package/dist/file/exists.cjs

@@ -0,0 +1,29 @@
+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/exists.ts
+function handleNodeExistsError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-exists-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-exists-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-exists-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-exists-too-many-open-files", error);
+	}
+	return _duplojs_lang_either.left("file-system-exists-error", error);
+}
+function handleDenoExistsError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-exists-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-exists-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-exists-not-directory", error);
+	return _duplojs_lang_either.left("file-system-exists-error", error);
+}
+const exists = require_implementor.implementFunction("exists", {
+	NODE: async (path) => {
+		return (await require_implementor.nodeFileSystem.value).access(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleNodeExistsError);
+	},
+	DENO: (path) => Deno.stat(path).then(() => _duplojs_lang_either.right("file-system-exists")).catch(handleDenoExistsError),
+	BUN: (path) => Bun.file(path).exists().then((value) => value ? _duplojs_lang_either.right("file-system-exists") : _duplojs_lang_either.left("file-system-exists-not-found", /* @__PURE__ */ new Error("Path does not exist"))).catch(handleNodeExistsError)
+});
+//#endregion
+exports.exists = exists;

package/dist/file/exists.d.ts

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

package/dist/file/exists.mjs

@@ -0,0 +1,27 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/exists.ts
+function handleNodeExistsError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-exists-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-exists-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-exists-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-exists-too-many-open-files", error);
+	}
+	return DEither.left("file-system-exists-error", error);
+}
+function handleDenoExistsError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-exists-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-exists-permission-denied", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-exists-not-directory", error);
+	return DEither.left("file-system-exists-error", error);
+}
+const exists = implementFunction("exists", {
+	NODE: async (path) => {
+		return (await nodeFileSystem.value).access(path).then(() => DEither.right("file-system-exists")).catch(handleNodeExistsError);
+	},
+	DENO: (path) => Deno.stat(path).then(() => DEither.right("file-system-exists")).catch(handleDenoExistsError),
+	BUN: (path) => Bun.file(path).exists().then((value) => value ? DEither.right("file-system-exists") : DEither.left("file-system-exists-not-found", /* @__PURE__ */ new Error("Path does not exist"))).catch(handleNodeExistsError)
+});
+//#endregion
+export { exists };

package/dist/file/fileInterface.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");
+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/fileInterface.ts
+const fileInterfaceKind = require_kind.createKind("fileInterface");
+function createFileInterface(path) {
+	function getName() {
+		return _duplojs_lang_path.getBaseName(path);
+	}
+	function getExtension(params) {
+		return _duplojs_lang_path.getExtensionName(path, params);
+	}
+	function getMimeType() {
+		const extension = getExtension();
+		if (!extension) return null;
+		return _duplojs_lang_common.mimeType.get(extension) ?? null;
+	}
+	function getParentPath() {
+		return _duplojs_lang_path.getParentFolderPath(path);
+	}
+	function localExists() {
+		return require_exists.exists(path);
+	}
+	function localRename(newName) {
+		return _duplojs_lang_common.asyncPipe(require_rename.rename(path, newName), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFileInterface, (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(createFileInterface, (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", createFileInterface(newPath))));
+	}
+	function localRemove() {
+		return require_remove.remove(path);
+	}
+	function localStat() {
+		return require_stat.stat(path);
+	}
+	function isFile() {
+		return _duplojs_lang_common.asyncPipe(localStat(), _duplojs_lang_either.whenHasInformationOtherwise("file-system-stat", ({ isFile }) => isFile, _duplojs_lang_common.justReturn(false)));
+	}
+	return {
+		path,
+		getName,
+		getExtension,
+		getMimeType,
+		getParentPath,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		move: localMove,
+		stat: localStat,
+		isFile,
+		[fileInterfaceKind.runTimeKey]: null
+	};
+}
+function isFileInterface(input) {
+	return fileInterfaceKind.has(input);
+}
+//#endregion
+exports.createFileInterface = createFileInterface;
+exports.isFileInterface = isFileInterface;

package/dist/file/fileInterface.d.ts

@@ -0,0 +1,30 @@
+import { RenameResult } from './rename';
+import { ExistsResult } from './exists';
+import { MoveResult } from './move';
+import { RemoveResult } from './remove';
+import { StatResult } from './stat';
+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 fileInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/fileInterface", unknown>>;
+type FileInterfaceRenameResult = Exclude<RenameResult, DEither.Right> | DEither.Right<"file-system-rename", FileInterface>;
+type FileInterfaceRelocateResult = Exclude<RelocateResult, DEither.Right> | DEither.Right<"file-system-relocate", FileInterface>;
+type FileInterfaceMoveResult = Exclude<MoveResult, DEither.Right> | DEither.Right<"file-system-move", FileInterface>;
+export interface FileInterface extends DKind.Kind<typeof fileInterfaceKind> {
+    path: string & DPath.Path;
+    getName(): (string & DPath.Segment) | null;
+    getMimeType(): string | null;
+    getExtension(params?: DPath.GetExtensionNameParams): (string & DPath.Segment) | null;
+    getParentPath(): (string & DPath.Path) | null;
+    rename(newName: string & DPath.Segment): Promise<FileInterfaceRenameResult>;
+    relocate(parentPath: string & DPath.Path): Promise<FileInterfaceRelocateResult>;
+    move(newPath: string & DPath.Path): Promise<FileInterfaceMoveResult>;
+    exists(): Promise<ExistsResult>;
+    remove(): Promise<RemoveResult>;
+    stat(): Promise<StatResult>;
+    isFile(): Promise<boolean>;
+}
+export declare function createFileInterface(path: string & DPath.Path): FileInterface;
+export declare function isFileInterface(input: unknown): input is FileInterface;
+export {};

package/dist/file/fileInterface.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 * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/fileInterface.ts
+const fileInterfaceKind = createKind("fileInterface");
+function createFileInterface(path) {
+	function getName() {
+		return DPath.getBaseName(path);
+	}
+	function getExtension(params) {
+		return DPath.getExtensionName(path, params);
+	}
+	function getMimeType() {
+		const extension = getExtension();
+		if (!extension) return null;
+		return DCommon.mimeType.get(extension) ?? null;
+	}
+	function getParentPath() {
+		return DPath.getParentFolderPath(path);
+	}
+	function localExists() {
+		return exists(path);
+	}
+	function localRename(newName) {
+		return DCommon.asyncPipe(rename(path, newName), DEither.whenIsRight(DCommon.innerPipe(createFileInterface, (value) => DEither.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return DCommon.asyncPipe(relocate(path, newParentPath), DEither.whenIsRight(DCommon.innerPipe(createFileInterface, (value) => DEither.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return DCommon.asyncPipe(move(path, newPath), DEither.whenIsRight(() => DEither.right("file-system-move", createFileInterface(newPath))));
+	}
+	function localRemove() {
+		return remove(path);
+	}
+	function localStat() {
+		return stat(path);
+	}
+	function isFile() {
+		return DCommon.asyncPipe(localStat(), DEither.whenHasInformationOtherwise("file-system-stat", ({ isFile }) => isFile, DCommon.justReturn(false)));
+	}
+	return {
+		path,
+		getName,
+		getExtension,
+		getMimeType,
+		getParentPath,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		move: localMove,
+		stat: localStat,
+		isFile,
+		[fileInterfaceKind.runTimeKey]: null
+	};
+}
+function isFileInterface(input) {
+	return fileInterfaceKind.has(input);
+}
+//#endregion
+export { createFileInterface, isFileInterface };