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

package/dist/file/symlink.d.ts

@@ -0,0 +1,19 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export interface SymlinkParams {
+    /**
+     * @remarks
+     * Specify the symbolic link type as file, directory or NTFS junction.
+     * This option only applies to Windows and is ignored on other operating systems.
+     */
+    type: "file" | "dir" | "junction";
+}
+export type SymlinkResult = FileSystemEither<DEither.Right<"symlink", void> | DEither.Left<"symlink-not-found", unknown> | DEither.Left<"symlink-permission-denied", unknown> | DEither.Left<"symlink-already-exists", unknown> | DEither.Left<"symlink-not-directory", unknown> | DEither.Left<"symlink-read-only", unknown> | DEither.Left<"symlink-invalid-argument", unknown> | DEither.Left<"symlink-too-many-open-files", unknown> | DEither.Left<"symlink-busy", unknown> | DEither.Left<"symlink-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
+    }
+}
+export declare function symlink(newPath: string & DPath.Path): (oldPath: string & DPath.Path) => Promise<SymlinkResult>;
+export declare function symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;

package/dist/file/symlink.mjs

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

package/dist/file/truncate.cjs

@@ -0,0 +1,38 @@
+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);
+//#region scripts/file/truncate.ts
+function handleNodeTruncateError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-truncate-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-truncate-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-truncate-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-truncate-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-truncate-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-truncate-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-truncate-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-truncate-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-truncate-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-truncate-error", error);
+}
+function handleDenoTruncateError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-truncate-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-truncate-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-truncate-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-truncate-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-truncate-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-truncate-busy", error);
+	return _duplojs_lang_either.left("file-system-truncate-error", error);
+}
+const truncate = require_implementor.implementFunction("truncate", {
+	NODE: async (path, size) => {
+		return (await require_implementor.nodeFileSystem.value).truncate(path, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleNodeTruncateError);
+	},
+	DENO: (path, size) => _duplojs_lang_common.pipe(path, _duplojs_lang_common.when(_duplojs_lang_common.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleDenoTruncateError))
+});
+//#endregion
+exports.truncate = truncate;

package/dist/file/truncate.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 TruncateResult = FileSystemEither<DEither.Right<"truncate", void> | DEither.Left<"truncate-not-found", unknown> | DEither.Left<"truncate-permission-denied", unknown> | DEither.Left<"truncate-is-directory", unknown> | DEither.Left<"truncate-not-directory", unknown> | DEither.Left<"truncate-no-space", unknown> | DEither.Left<"truncate-read-only", unknown> | DEither.Left<"truncate-invalid-argument", unknown> | DEither.Left<"truncate-too-many-open-files", unknown> | DEither.Left<"truncate-busy", unknown> | DEither.Left<"truncate-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        truncate(path: string & DPath.Path, size?: number): Promise<TruncateResult>;
+    }
+}
+export declare const truncate: (path: string & DPath.Path, size?: number) => Promise<TruncateResult>;

package/dist/file/truncate.mjs

@@ -0,0 +1,35 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/truncate.ts
+function handleNodeTruncateError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-truncate-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-truncate-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-truncate-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-truncate-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-truncate-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-truncate-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-truncate-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-truncate-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-truncate-busy", error);
+	}
+	return DEither.left("file-system-truncate-error", error);
+}
+function handleDenoTruncateError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-truncate-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-truncate-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-truncate-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-truncate-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-truncate-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-truncate-busy", error);
+	return DEither.left("file-system-truncate-error", error);
+}
+const truncate = implementFunction("truncate", {
+	NODE: async (path, size) => {
+		return (await nodeFileSystem.value).truncate(path, size).then(() => DEither.right("file-system-truncate")).catch(handleNodeTruncateError);
+	},
+	DENO: (path, size) => DCommon.pipe(path, DCommon.when(DCommon.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => DEither.right("file-system-truncate")).catch(handleDenoTruncateError))
+});
+//#endregion
+export { truncate };

package/dist/file/types/fileSystemEither.d.ts

@@ -0,0 +1,2 @@
+import type * as DEither from "@duplojs/lang/either";
+export type FileSystemEither<GenericEither extends DEither.Left | DEither.Right> = GenericEither extends DEither.Left<infer GenericInformation, infer GenericValue> ? DEither.Left<`file-system-${GenericInformation}`, GenericValue> : GenericEither extends DEither.Right<infer GenericInformation, infer GenericValue> ? DEither.Right<`file-system-${GenericInformation}`, GenericValue> : never;

package/dist/file/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './fileSystemEither';

package/dist/file/unknownEntryInterface.cjs

@@ -0,0 +1,36 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_stat = require("./stat.cjs");
+const require_exists = require("./exists.cjs");
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/unknownEntryInterface.ts
+const unknownInterfaceKind = require_kind.createKind("unknownInterface");
+function createUnknownEntryInterface(path) {
+	function getName() {
+		return _duplojs_lang_path.getBaseName(path);
+	}
+	function getParentPath() {
+		return _duplojs_lang_path.getParentFolderPath(path);
+	}
+	function localStat() {
+		return require_stat.stat(path);
+	}
+	function exist() {
+		return require_exists.exists(path);
+	}
+	return {
+		path,
+		getName,
+		getParentPath,
+		stat: localStat,
+		exist,
+		[unknownInterfaceKind.runTimeKey]: null
+	};
+}
+function isUnknownEntryInterface(input) {
+	return unknownInterfaceKind.has(input);
+}
+//#endregion
+exports.createUnknownEntryInterface = createUnknownEntryInterface;
+exports.isUnknownEntryInterface = isUnknownEntryInterface;

package/dist/file/unknownEntryInterface.d.ts

@@ -0,0 +1,15 @@
+import { StatResult } from './stat';
+import { ExistsResult } from './exists';
+import type * as DKind from "@duplojs/lang/kind";
+import * as DPath from "@duplojs/lang/path";
+declare const unknownInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/unknownInterface", unknown>>;
+export interface UnknownEntryInterface extends DKind.Kind<typeof unknownInterfaceKind> {
+    path: string & DPath.Path;
+    getName(): (string & DPath.Segment) | null;
+    getParentPath(): (string & DPath.Path) | null;
+    stat(): Promise<StatResult>;
+    exist(): Promise<ExistsResult>;
+}
+export declare function createUnknownEntryInterface(path: string & DPath.Path): UnknownEntryInterface;
+export declare function isUnknownEntryInterface(input: unknown): input is UnknownEntryInterface;
+export {};

package/dist/file/unknownEntryInterface.mjs

@@ -0,0 +1,33 @@
+import { createKind } from "../kind.mjs";
+import { stat } from "./stat.mjs";
+import { exists } from "./exists.mjs";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/unknownEntryInterface.ts
+const unknownInterfaceKind = createKind("unknownInterface");
+function createUnknownEntryInterface(path) {
+	function getName() {
+		return DPath.getBaseName(path);
+	}
+	function getParentPath() {
+		return DPath.getParentFolderPath(path);
+	}
+	function localStat() {
+		return stat(path);
+	}
+	function exist() {
+		return exists(path);
+	}
+	return {
+		path,
+		getName,
+		getParentPath,
+		stat: localStat,
+		exist,
+		[unknownInterfaceKind.runTimeKey]: null
+	};
+}
+function isUnknownEntryInterface(input) {
+	return unknownInterfaceKind.has(input);
+}
+//#endregion
+export { createUnknownEntryInterface, isUnknownEntryInterface };

package/dist/file/walkDirectory.cjs

@@ -0,0 +1,34 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+const require_fileInterface = require("./fileInterface.cjs");
+const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
+const require_folderInterface = require("./folderInterface.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);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+let _duplojs_lang_generator = require("@duplojs/lang/generator");
+_duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
+//#region scripts/file/walkDirectory.ts
+function handleNodeWalkDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-walk-directory-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-walk-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-walk-directory-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-walk-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-walk-directory-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-walk-directory-error", error);
+}
+const walkDirectory = require_implementor.implementFunction("walkDirectory", { NODE: async (path, params) => {
+	return (await require_implementor.nodeFileSystem.value).readdir(path, {
+		recursive: params?.recursive ?? false,
+		withFileTypes: true
+	}).then(_duplojs_lang_common.innerPipe(_duplojs_lang_generator.map(_duplojs_lang_common.innerPipe(_duplojs_lang_pattern.when((dirent) => dirent.isFile(), ({ parentPath, name }) => require_fileInterface.createFileInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))), _duplojs_lang_pattern.when((dirent) => dirent.isDirectory(), ({ parentPath, name }) => require_folderInterface.createFolderInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))), _duplojs_lang_pattern.otherwise(({ parentPath, name }) => require_unknownEntryInterface.createUnknownEntryInterface(_duplojs_lang_common.forwardAsserts(_duplojs_lang_path.normalize(`${parentPath}/${name}`), (result) => _duplojs_lang_common.isType(result, "string") && _duplojs_lang_path.is(result)))))), (value) => _duplojs_lang_either.right("file-system-walk-directory", value))).catch(handleNodeWalkDirectoryError);
+} });
+//#endregion
+exports.walkDirectory = walkDirectory;

package/dist/file/walkDirectory.d.ts

@@ -0,0 +1,16 @@
+import { FileInterface } from './fileInterface';
+import { FolderInterface } from './folderInterface';
+import { UnknownEntryInterface } from './unknownEntryInterface';
+import { FileSystemEither } from './types';
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export interface WalkDirectoryParams {
+    recursive?: boolean;
+}
+export type WalkDirectoryResult = FileSystemEither<DEither.Right<"walk-directory", Generator<FileInterface | FolderInterface | UnknownEntryInterface>> | DEither.Left<"walk-directory-not-found", unknown> | DEither.Left<"walk-directory-permission-denied", unknown> | DEither.Left<"walk-directory-not-directory", unknown> | DEither.Left<"walk-directory-too-many-open-files", unknown> | DEither.Left<"walk-directory-busy", unknown> | DEither.Left<"walk-directory-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        walkDirectory(path: string & DPath.Path, params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
+    }
+}
+export declare const walkDirectory: (path: string & DPath.Path, params?: WalkDirectoryParams) => Promise<WalkDirectoryResult>;

package/dist/file/walkDirectory.mjs

@@ -0,0 +1,28 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import { createFileInterface } from "./fileInterface.mjs";
+import { createUnknownEntryInterface } from "./unknownEntryInterface.mjs";
+import { createFolderInterface } from "./folderInterface.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DGenerator from "@duplojs/lang/generator";
+//#region scripts/file/walkDirectory.ts
+function handleNodeWalkDirectoryError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-walk-directory-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-walk-directory-permission-denied", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-walk-directory-not-directory", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-walk-directory-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-walk-directory-busy", error);
+	}
+	return DEither.left("file-system-walk-directory-error", error);
+}
+const walkDirectory = implementFunction("walkDirectory", { NODE: async (path, params) => {
+	return (await nodeFileSystem.value).readdir(path, {
+		recursive: params?.recursive ?? false,
+		withFileTypes: true
+	}).then(DCommon.innerPipe(DGenerator.map(DCommon.innerPipe(DPattern.when((dirent) => dirent.isFile(), ({ parentPath, name }) => createFileInterface(DCommon.forwardAsserts(DPath.normalize(`${parentPath}/${name}`), (result) => DCommon.isType(result, "string") && DPath.is(result)))), DPattern.when((dirent) => dirent.isDirectory(), ({ parentPath, name }) => createFolderInterface(DCommon.forwardAsserts(DPath.normalize(`${parentPath}/${name}`), (result) => DCommon.isType(result, "string") && DPath.is(result)))), DPattern.otherwise(({ parentPath, name }) => createUnknownEntryInterface(DCommon.forwardAsserts(DPath.normalize(`${parentPath}/${name}`), (result) => DCommon.isType(result, "string") && DPath.is(result)))))), (value) => DEither.right("file-system-walk-directory", value))).catch(handleNodeWalkDirectoryError);
+} });
+//#endregion
+export { walkDirectory };

package/dist/file/writeFile.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/writeFile.ts
+function handleNodeWriteFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-write-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-write-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-write-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-write-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-write-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-write-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-write-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-write-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-write-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-write-file-error", error);
+}
+function handleDenoWriteFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-write-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-write-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-write-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-write-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-write-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-write-file-busy", error);
+	return _duplojs_lang_either.left("file-system-write-file-error", error);
+}
+const writeFileImplementation = require_implementor.implementFunction("writeFile", {
+	NODE: async (path, data) => {
+		return (await require_implementor.nodeFileSystem.value).writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError);
+	},
+	DENO: (path, data) => Deno.writeFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleDenoWriteFileError),
+	BUN: (path, data) => Bun.file(path).write(data).then(() => _duplojs_lang_either.right("file-system-write-file")).catch(handleNodeWriteFileError)
+});
+function writeFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => writeFileImplementation(path, data);
+	}
+	return writeFileImplementation(...args);
+}
+//#endregion
+exports.writeFile = writeFile;

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

package/dist/file/writeFile.mjs

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

package/dist/file/writeJsonFile.cjs

@@ -0,0 +1,56 @@
+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);
+//#region scripts/file/writeJsonFile.ts
+function handleNodeWriteJsonFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-write-json-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-write-json-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-write-json-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-write-json-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-write-json-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-write-json-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-write-json-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-write-json-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-write-json-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-write-json-file-error", error);
+}
+function handleDenoWriteJsonFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-write-json-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-write-json-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-write-json-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-write-json-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-write-json-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-write-json-file-busy", error);
+	return _duplojs_lang_either.left("file-system-write-json-file-error", error);
+}
+const writeJsonFileImplementation = require_implementor.implementFunction("writeJsonFile", {
+	NODE: async (path, data, params) => {
+		const fs = await require_implementor.nodeFileSystem.value;
+		return _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => JSON.stringify(data, null, params?.space)), _duplojs_lang_either.matchInformation({
+			"safe-callback-error": (value) => _duplojs_lang_either.left("file-system-write-json-file-error", value),
+			"safe-callback-success": (value) => fs.writeFile(path, value, { encoding: "utf-8" }).then(() => _duplojs_lang_either.right("file-system-write-json-file")).catch(handleNodeWriteJsonFileError)
+		}));
+	},
+	DENO: async (path, data, params) => _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => JSON.stringify(data, null, params?.space)), _duplojs_lang_either.matchInformation({
+		"safe-callback-error": (value) => _duplojs_lang_either.left("file-system-write-json-file-error", value),
+		"safe-callback-success": (value) => Deno.writeTextFile(path, value).then(() => _duplojs_lang_either.right("file-system-write-json-file")).catch(handleDenoWriteJsonFileError)
+	})),
+	BUN: async (path, data, params) => _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => JSON.stringify(data, null, params?.space)), _duplojs_lang_either.matchInformation({
+		"safe-callback-error": (value) => _duplojs_lang_either.left("file-system-write-json-file-error", value),
+		"safe-callback-success": (value) => Bun.file(path).write(value).then(() => _duplojs_lang_either.right("file-system-write-json-file")).catch(handleNodeWriteJsonFileError)
+	}))
+});
+function writeJsonFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => writeJsonFileImplementation(path, data);
+	}
+	return writeJsonFileImplementation(...args);
+}
+//#endregion
+exports.writeJsonFile = writeJsonFile;

package/dist/file/writeJsonFile.d.ts

@@ -0,0 +1,15 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+interface WriteJsonFile {
+    space?: number;
+}
+export type WriteJsonFileResult = FileSystemEither<DEither.Right<"write-json-file", void> | DEither.Left<"write-json-file-not-found", unknown> | DEither.Left<"write-json-file-permission-denied", unknown> | DEither.Left<"write-json-file-is-directory", unknown> | DEither.Left<"write-json-file-not-directory", unknown> | DEither.Left<"write-json-file-no-space", unknown> | DEither.Left<"write-json-file-read-only", unknown> | DEither.Left<"write-json-file-invalid-argument", unknown> | DEither.Left<"write-json-file-too-many-open-files", unknown> | DEither.Left<"write-json-file-busy", unknown> | DEither.Left<"write-json-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        writeJsonFile(path: string & DPath.Path, data: unknown, params?: WriteJsonFile): Promise<WriteJsonFileResult>;
+    }
+}
+export declare function writeJsonFile(data: unknown): (path: string & DPath.Path) => Promise<WriteJsonFileResult>;
+export declare function writeJsonFile(path: string & DPath.Path, data: unknown, params?: WriteJsonFile): Promise<WriteJsonFileResult>;
+export {};

package/dist/file/writeJsonFile.mjs

@@ -0,0 +1,53 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/writeJsonFile.ts
+function handleNodeWriteJsonFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-write-json-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-write-json-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-write-json-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-write-json-file-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-write-json-file-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-write-json-file-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-write-json-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-write-json-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-write-json-file-busy", error);
+	}
+	return DEither.left("file-system-write-json-file-error", error);
+}
+function handleDenoWriteJsonFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-write-json-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-write-json-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-write-json-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-write-json-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-write-json-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-write-json-file-busy", error);
+	return DEither.left("file-system-write-json-file-error", error);
+}
+const writeJsonFileImplementation = implementFunction("writeJsonFile", {
+	NODE: async (path, data, params) => {
+		const fs = await nodeFileSystem.value;
+		return DCommon.pipe(DEither.safeCallback(() => JSON.stringify(data, null, params?.space)), DEither.matchInformation({
+			"safe-callback-error": (value) => DEither.left("file-system-write-json-file-error", value),
+			"safe-callback-success": (value) => fs.writeFile(path, value, { encoding: "utf-8" }).then(() => DEither.right("file-system-write-json-file")).catch(handleNodeWriteJsonFileError)
+		}));
+	},
+	DENO: async (path, data, params) => DCommon.pipe(DEither.safeCallback(() => JSON.stringify(data, null, params?.space)), DEither.matchInformation({
+		"safe-callback-error": (value) => DEither.left("file-system-write-json-file-error", value),
+		"safe-callback-success": (value) => Deno.writeTextFile(path, value).then(() => DEither.right("file-system-write-json-file")).catch(handleDenoWriteJsonFileError)
+	})),
+	BUN: async (path, data, params) => DCommon.pipe(DEither.safeCallback(() => JSON.stringify(data, null, params?.space)), DEither.matchInformation({
+		"safe-callback-error": (value) => DEither.left("file-system-write-json-file-error", value),
+		"safe-callback-success": (value) => Bun.file(path).write(value).then(() => DEither.right("file-system-write-json-file")).catch(handleNodeWriteJsonFileError)
+	}))
+});
+function writeJsonFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => writeJsonFileImplementation(path, data);
+	}
+	return writeJsonFileImplementation(...args);
+}
+//#endregion
+export { writeJsonFile };

package/dist/file/writeTextFile.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/writeTextFile.ts
+function handleNodeWriteTextFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-write-text-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-write-text-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-write-text-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-write-text-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-write-text-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-write-text-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-write-text-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-write-text-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-write-text-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-write-text-file-error", error);
+}
+function handleDenoWriteTextFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-write-text-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-write-text-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-write-text-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-write-text-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-write-text-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-write-text-file-busy", error);
+	return _duplojs_lang_either.left("file-system-write-text-file-error", error);
+}
+const writeTextFileImplementation = require_implementor.implementFunction("writeTextFile", {
+	NODE: async (path, data) => {
+		return (await require_implementor.nodeFileSystem.value).writeFile(path, data, { encoding: "utf-8" }).then(() => _duplojs_lang_either.right("file-system-write-text-file")).catch(handleNodeWriteTextFileError);
+	},
+	DENO: (path, data) => Deno.writeTextFile(path, data).then(() => _duplojs_lang_either.right("file-system-write-text-file")).catch(handleDenoWriteTextFileError),
+	BUN: (path, data) => Bun.file(path).write(data).then(() => _duplojs_lang_either.right("file-system-write-text-file")).catch(handleNodeWriteTextFileError)
+});
+function writeTextFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => writeTextFileImplementation(path, data);
+	}
+	return writeTextFileImplementation(...args);
+}
+//#endregion
+exports.writeTextFile = writeTextFile;