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

package/dist/file/writeFile.d.ts

@@ -0,0 +1,43 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare const WriteFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-not-found", unknown>>, unknown>;
+export declare class WriteFileErrorNotFound extends WriteFileErrorNotFound_base {
+}
+declare const WriteFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-permission-denied", unknown>>, unknown>;
+export declare class WriteFileErrorPermissionDenied extends WriteFileErrorPermissionDenied_base {
+}
+declare const WriteFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-is-directory", unknown>>, unknown>;
+export declare class WriteFileErrorIsDirectory extends WriteFileErrorIsDirectory_base {
+}
+declare const WriteFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-not-directory", unknown>>, unknown>;
+export declare class WriteFileErrorNotDirectory extends WriteFileErrorNotDirectory_base {
+}
+declare const WriteFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-no-space", unknown>>, unknown>;
+export declare class WriteFileErrorNoSpace extends WriteFileErrorNoSpace_base {
+}
+declare const WriteFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-read-only", unknown>>, unknown>;
+export declare class WriteFileErrorReadOnly extends WriteFileErrorReadOnly_base {
+}
+declare const WriteFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-invalid-argument", unknown>>, unknown>;
+export declare class WriteFileErrorInvalidArgument extends WriteFileErrorInvalidArgument_base {
+}
+declare const WriteFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-too-many-open-files", unknown>>, unknown>;
+export declare class WriteFileErrorTooManyOpenFiles extends WriteFileErrorTooManyOpenFiles_base {
+}
+declare const WriteFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-busy", unknown>>, unknown>;
+export declare class WriteFileErrorBusy extends WriteFileErrorBusy_base {
+}
+declare const WriteFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-file-error", unknown>>, unknown>;
+export declare class WriteFileError extends WriteFileError_base {
+}
+export type WriteFileErrors = (WriteFileErrorNotFound | WriteFileErrorPermissionDenied | WriteFileErrorIsDirectory | WriteFileErrorNotDirectory | WriteFileErrorNoSpace | WriteFileErrorReadOnly | WriteFileErrorInvalidArgument | WriteFileErrorTooManyOpenFiles | WriteFileErrorBusy | WriteFileError);
+export type WriteFileResult = (DEither.Right<"file-system-write-file", void> | DEither.Left<"file-system-write-file-error", WriteFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        writeFile(path: DPath.AnyPath, data: Uint8Array): Promise<WriteFileResult>;
+    }
+}
+export declare function writeFile(data: Uint8Array): (path: DPath.AnyPath) => Promise<WriteFileResult>;
+export declare function writeFile(path: DPath.AnyPath, data: Uint8Array): Promise<WriteFileResult>;
+export {};

package/dist/file/writeFile.mjs

@@ -0,0 +1,55 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/writeFile.ts
+var WriteFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-write-file-not-found", Error) {};
+var WriteFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-write-file-permission-denied", Error) {};
+var WriteFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-file-is-directory", Error) {};
+var WriteFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-file-not-directory", Error) {};
+var WriteFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-write-file-no-space", Error) {};
+var WriteFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-write-file-read-only", Error) {};
+var WriteFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-write-file-invalid-argument", Error) {};
+var WriteFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-write-file-too-many-open-files", Error) {};
+var WriteFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-write-file-busy", Error) {};
+var WriteFileError = class extends DCommon.DuploJSError.parentClass("file-system-write-file-error", Error) {};
+function handleNodeWriteFileError(error) {
+	let writeFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeFileError = new WriteFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeFileError = new WriteFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeFileError = new WriteFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeFileError = new WriteFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeFileError = new WriteFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeFileError = new WriteFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeFileError = new WriteFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeFileError = new WriteFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeFileError = new WriteFileErrorBusy(error);
+	}
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return DEither.left("file-system-write-file-error", writeFileError);
+}
+function handleDenoWriteFileError(error) {
+	let writeFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeFileError = new WriteFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeFileError = new WriteFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeFileError = new WriteFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeFileError = new WriteFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeFileError = new WriteFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeFileError = new WriteFileErrorBusy(error);
+	if (writeFileError === void 0) writeFileError = new WriteFileError(error);
+	return DEither.left("file-system-write-file-error", writeFileError);
+}
+const writeFileImplementation = implementFunction("writeFile", {
+	NODE: async (path, data) => 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 { WriteFileError, WriteFileErrorBusy, WriteFileErrorInvalidArgument, WriteFileErrorIsDirectory, WriteFileErrorNoSpace, WriteFileErrorNotDirectory, WriteFileErrorNotFound, WriteFileErrorPermissionDenied, WriteFileErrorReadOnly, WriteFileErrorTooManyOpenFiles, writeFile };

package/dist/file/writeJsonFile.cjs

@@ -0,0 +1,77 @@
+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
+var WriteJsonFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-not-found", Error) {};
+var WriteJsonFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-permission-denied", Error) {};
+var WriteJsonFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-is-directory", Error) {};
+var WriteJsonFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-not-directory", Error) {};
+var WriteJsonFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-no-space", Error) {};
+var WriteJsonFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-read-only", Error) {};
+var WriteJsonFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-invalid-argument", Error) {};
+var WriteJsonFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-too-many-open-files", Error) {};
+var WriteJsonFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-busy", Error) {};
+var WriteJsonFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-json-file-error", Error) {};
+function handleNodeWriteJsonFileError(error) {
+	let writeJsonFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeJsonFileError = new WriteJsonFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeJsonFileError = new WriteJsonFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeJsonFileError = new WriteJsonFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeJsonFileError = new WriteJsonFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeJsonFileError = new WriteJsonFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeJsonFileError = new WriteJsonFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeJsonFileError = new WriteJsonFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeJsonFileError = new WriteJsonFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeJsonFileError = new WriteJsonFileErrorBusy(error);
+	}
+	if (writeJsonFileError === void 0) writeJsonFileError = new WriteJsonFileError(error);
+	return _duplojs_lang_either.left("file-system-write-json-file-error", writeJsonFileError);
+}
+function handleDenoWriteJsonFileError(error) {
+	let writeJsonFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeJsonFileError = new WriteJsonFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeJsonFileError = new WriteJsonFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeJsonFileError = new WriteJsonFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeJsonFileError = new WriteJsonFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeJsonFileError = new WriteJsonFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeJsonFileError = new WriteJsonFileErrorBusy(error);
+	if (writeJsonFileError === void 0) writeJsonFileError = new WriteJsonFileError(error);
+	return _duplojs_lang_either.left("file-system-write-json-file-error", writeJsonFileError);
+}
+const writeJsonFileImplementation = require_implementor.implementFunction("writeJsonFile", {
+	NODE: 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", new WriteJsonFileError(value)),
+		"safe-callback-success": (value) => require_implementor.nodeFileSystem.value.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", new WriteJsonFileError(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", new WriteJsonFileError(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.WriteJsonFileError = WriteJsonFileError;
+exports.WriteJsonFileErrorBusy = WriteJsonFileErrorBusy;
+exports.WriteJsonFileErrorInvalidArgument = WriteJsonFileErrorInvalidArgument;
+exports.WriteJsonFileErrorIsDirectory = WriteJsonFileErrorIsDirectory;
+exports.WriteJsonFileErrorNoSpace = WriteJsonFileErrorNoSpace;
+exports.WriteJsonFileErrorNotDirectory = WriteJsonFileErrorNotDirectory;
+exports.WriteJsonFileErrorNotFound = WriteJsonFileErrorNotFound;
+exports.WriteJsonFileErrorPermissionDenied = WriteJsonFileErrorPermissionDenied;
+exports.WriteJsonFileErrorReadOnly = WriteJsonFileErrorReadOnly;
+exports.WriteJsonFileErrorTooManyOpenFiles = WriteJsonFileErrorTooManyOpenFiles;
+exports.writeJsonFile = writeJsonFile;

package/dist/file/writeJsonFile.d.ts

@@ -0,0 +1,46 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+interface WriteJsonFileParams {
+    space?: number;
+}
+declare const WriteJsonFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-not-found", unknown>>, unknown>;
+export declare class WriteJsonFileErrorNotFound extends WriteJsonFileErrorNotFound_base {
+}
+declare const WriteJsonFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-permission-denied", unknown>>, unknown>;
+export declare class WriteJsonFileErrorPermissionDenied extends WriteJsonFileErrorPermissionDenied_base {
+}
+declare const WriteJsonFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-is-directory", unknown>>, unknown>;
+export declare class WriteJsonFileErrorIsDirectory extends WriteJsonFileErrorIsDirectory_base {
+}
+declare const WriteJsonFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-not-directory", unknown>>, unknown>;
+export declare class WriteJsonFileErrorNotDirectory extends WriteJsonFileErrorNotDirectory_base {
+}
+declare const WriteJsonFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-no-space", unknown>>, unknown>;
+export declare class WriteJsonFileErrorNoSpace extends WriteJsonFileErrorNoSpace_base {
+}
+declare const WriteJsonFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-read-only", unknown>>, unknown>;
+export declare class WriteJsonFileErrorReadOnly extends WriteJsonFileErrorReadOnly_base {
+}
+declare const WriteJsonFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-invalid-argument", unknown>>, unknown>;
+export declare class WriteJsonFileErrorInvalidArgument extends WriteJsonFileErrorInvalidArgument_base {
+}
+declare const WriteJsonFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-too-many-open-files", unknown>>, unknown>;
+export declare class WriteJsonFileErrorTooManyOpenFiles extends WriteJsonFileErrorTooManyOpenFiles_base {
+}
+declare const WriteJsonFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-busy", unknown>>, unknown>;
+export declare class WriteJsonFileErrorBusy extends WriteJsonFileErrorBusy_base {
+}
+declare const WriteJsonFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-json-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-json-file-error", unknown>>, unknown>;
+export declare class WriteJsonFileError extends WriteJsonFileError_base {
+}
+export type WriteJsonFileErrors = (WriteJsonFileErrorNotFound | WriteJsonFileErrorPermissionDenied | WriteJsonFileErrorIsDirectory | WriteJsonFileErrorNotDirectory | WriteJsonFileErrorNoSpace | WriteJsonFileErrorReadOnly | WriteJsonFileErrorInvalidArgument | WriteJsonFileErrorTooManyOpenFiles | WriteJsonFileErrorBusy | WriteJsonFileError);
+export type WriteJsonFileResult = (DEither.Right<"file-system-write-json-file", void> | DEither.Left<"file-system-write-json-file-error", WriteJsonFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        writeJsonFile(path: DPath.AnyPath, data: unknown, params?: WriteJsonFileParams): Promise<WriteJsonFileResult>;
+    }
+}
+export declare function writeJsonFile(data: unknown): (path: DPath.AnyPath) => Promise<WriteJsonFileResult>;
+export declare function writeJsonFile(path: DPath.AnyPath, data: unknown, params?: WriteJsonFileParams): Promise<WriteJsonFileResult>;
+export {};

package/dist/file/writeJsonFile.mjs

@@ -0,0 +1,64 @@
+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
+var WriteJsonFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-not-found", Error) {};
+var WriteJsonFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-permission-denied", Error) {};
+var WriteJsonFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-is-directory", Error) {};
+var WriteJsonFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-not-directory", Error) {};
+var WriteJsonFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-no-space", Error) {};
+var WriteJsonFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-read-only", Error) {};
+var WriteJsonFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-invalid-argument", Error) {};
+var WriteJsonFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-too-many-open-files", Error) {};
+var WriteJsonFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-busy", Error) {};
+var WriteJsonFileError = class extends DCommon.DuploJSError.parentClass("file-system-write-json-file-error", Error) {};
+function handleNodeWriteJsonFileError(error) {
+	let writeJsonFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeJsonFileError = new WriteJsonFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeJsonFileError = new WriteJsonFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeJsonFileError = new WriteJsonFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeJsonFileError = new WriteJsonFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeJsonFileError = new WriteJsonFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeJsonFileError = new WriteJsonFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeJsonFileError = new WriteJsonFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeJsonFileError = new WriteJsonFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeJsonFileError = new WriteJsonFileErrorBusy(error);
+	}
+	if (writeJsonFileError === void 0) writeJsonFileError = new WriteJsonFileError(error);
+	return DEither.left("file-system-write-json-file-error", writeJsonFileError);
+}
+function handleDenoWriteJsonFileError(error) {
+	let writeJsonFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeJsonFileError = new WriteJsonFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeJsonFileError = new WriteJsonFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeJsonFileError = new WriteJsonFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeJsonFileError = new WriteJsonFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeJsonFileError = new WriteJsonFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeJsonFileError = new WriteJsonFileErrorBusy(error);
+	if (writeJsonFileError === void 0) writeJsonFileError = new WriteJsonFileError(error);
+	return DEither.left("file-system-write-json-file-error", writeJsonFileError);
+}
+const writeJsonFileImplementation = implementFunction("writeJsonFile", {
+	NODE: 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", new WriteJsonFileError(value)),
+		"safe-callback-success": (value) => nodeFileSystem.value.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", new WriteJsonFileError(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", new WriteJsonFileError(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 { WriteJsonFileError, WriteJsonFileErrorBusy, WriteJsonFileErrorInvalidArgument, WriteJsonFileErrorIsDirectory, WriteJsonFileErrorNoSpace, WriteJsonFileErrorNotDirectory, WriteJsonFileErrorNotFound, WriteJsonFileErrorPermissionDenied, WriteJsonFileErrorReadOnly, WriteJsonFileErrorTooManyOpenFiles, writeJsonFile };

package/dist/file/writeTextFile.cjs

@@ -0,0 +1,68 @@
+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/writeTextFile.ts
+var WriteTextFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-not-found", Error) {};
+var WriteTextFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-permission-denied", Error) {};
+var WriteTextFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-is-directory", Error) {};
+var WriteTextFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-not-directory", Error) {};
+var WriteTextFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-no-space", Error) {};
+var WriteTextFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-read-only", Error) {};
+var WriteTextFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-invalid-argument", Error) {};
+var WriteTextFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-too-many-open-files", Error) {};
+var WriteTextFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-busy", Error) {};
+var WriteTextFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-write-text-file-error", Error) {};
+function handleNodeWriteTextFileError(error) {
+	let writeTextFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeTextFileError = new WriteTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeTextFileError = new WriteTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeTextFileError = new WriteTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeTextFileError = new WriteTextFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeTextFileError = new WriteTextFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeTextFileError = new WriteTextFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeTextFileError = new WriteTextFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeTextFileError = new WriteTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeTextFileError = new WriteTextFileErrorBusy(error);
+	}
+	if (writeTextFileError === void 0) writeTextFileError = new WriteTextFileError(error);
+	return _duplojs_lang_either.left("file-system-write-text-file-error", writeTextFileError);
+}
+function handleDenoWriteTextFileError(error) {
+	let writeTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeTextFileError = new WriteTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeTextFileError = new WriteTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeTextFileError = new WriteTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeTextFileError = new WriteTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeTextFileError = new WriteTextFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeTextFileError = new WriteTextFileErrorBusy(error);
+	if (writeTextFileError === void 0) writeTextFileError = new WriteTextFileError(error);
+	return _duplojs_lang_either.left("file-system-write-text-file-error", writeTextFileError);
+}
+const writeTextFileImplementation = require_implementor.implementFunction("writeTextFile", {
+	NODE: async (path, data) => 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.WriteTextFileError = WriteTextFileError;
+exports.WriteTextFileErrorBusy = WriteTextFileErrorBusy;
+exports.WriteTextFileErrorInvalidArgument = WriteTextFileErrorInvalidArgument;
+exports.WriteTextFileErrorIsDirectory = WriteTextFileErrorIsDirectory;
+exports.WriteTextFileErrorNoSpace = WriteTextFileErrorNoSpace;
+exports.WriteTextFileErrorNotDirectory = WriteTextFileErrorNotDirectory;
+exports.WriteTextFileErrorNotFound = WriteTextFileErrorNotFound;
+exports.WriteTextFileErrorPermissionDenied = WriteTextFileErrorPermissionDenied;
+exports.WriteTextFileErrorReadOnly = WriteTextFileErrorReadOnly;
+exports.WriteTextFileErrorTooManyOpenFiles = WriteTextFileErrorTooManyOpenFiles;
+exports.writeTextFile = writeTextFile;

package/dist/file/writeTextFile.d.ts

@@ -0,0 +1,43 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare const WriteTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-not-found", unknown>>, unknown>;
+export declare class WriteTextFileErrorNotFound extends WriteTextFileErrorNotFound_base {
+}
+declare const WriteTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-permission-denied", unknown>>, unknown>;
+export declare class WriteTextFileErrorPermissionDenied extends WriteTextFileErrorPermissionDenied_base {
+}
+declare const WriteTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-is-directory", unknown>>, unknown>;
+export declare class WriteTextFileErrorIsDirectory extends WriteTextFileErrorIsDirectory_base {
+}
+declare const WriteTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-not-directory", unknown>>, unknown>;
+export declare class WriteTextFileErrorNotDirectory extends WriteTextFileErrorNotDirectory_base {
+}
+declare const WriteTextFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-no-space", unknown>>, unknown>;
+export declare class WriteTextFileErrorNoSpace extends WriteTextFileErrorNoSpace_base {
+}
+declare const WriteTextFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-read-only", unknown>>, unknown>;
+export declare class WriteTextFileErrorReadOnly extends WriteTextFileErrorReadOnly_base {
+}
+declare const WriteTextFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-invalid-argument", unknown>>, unknown>;
+export declare class WriteTextFileErrorInvalidArgument extends WriteTextFileErrorInvalidArgument_base {
+}
+declare const WriteTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-too-many-open-files", unknown>>, unknown>;
+export declare class WriteTextFileErrorTooManyOpenFiles extends WriteTextFileErrorTooManyOpenFiles_base {
+}
+declare const WriteTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-busy", unknown>>, unknown>;
+export declare class WriteTextFileErrorBusy extends WriteTextFileErrorBusy_base {
+}
+declare const WriteTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-write-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-write-text-file-error", unknown>>, unknown>;
+export declare class WriteTextFileError extends WriteTextFileError_base {
+}
+export type WriteTextFileErrors = (WriteTextFileErrorNotFound | WriteTextFileErrorPermissionDenied | WriteTextFileErrorIsDirectory | WriteTextFileErrorNotDirectory | WriteTextFileErrorNoSpace | WriteTextFileErrorReadOnly | WriteTextFileErrorInvalidArgument | WriteTextFileErrorTooManyOpenFiles | WriteTextFileErrorBusy | WriteTextFileError);
+export type WriteTextFileResult = (DEither.Right<"file-system-write-text-file", void> | DEither.Left<"file-system-write-text-file-error", WriteTextFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        writeTextFile(path: DPath.AnyPath, data: string): Promise<WriteTextFileResult>;
+    }
+}
+export declare function writeTextFile(data: string): (path: DPath.AnyPath) => Promise<WriteTextFileResult>;
+export declare function writeTextFile(path: DPath.AnyPath, data: string): Promise<WriteTextFileResult>;
+export {};

package/dist/file/writeTextFile.mjs

@@ -0,0 +1,55 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/writeTextFile.ts
+var WriteTextFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-not-found", Error) {};
+var WriteTextFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-permission-denied", Error) {};
+var WriteTextFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-is-directory", Error) {};
+var WriteTextFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-not-directory", Error) {};
+var WriteTextFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-no-space", Error) {};
+var WriteTextFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-read-only", Error) {};
+var WriteTextFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-invalid-argument", Error) {};
+var WriteTextFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-too-many-open-files", Error) {};
+var WriteTextFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-busy", Error) {};
+var WriteTextFileError = class extends DCommon.DuploJSError.parentClass("file-system-write-text-file-error", Error) {};
+function handleNodeWriteTextFileError(error) {
+	let writeTextFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") writeTextFileError = new WriteTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") writeTextFileError = new WriteTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") writeTextFileError = new WriteTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") writeTextFileError = new WriteTextFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") writeTextFileError = new WriteTextFileErrorNoSpace(error);
+		else if (error.code === "EROFS") writeTextFileError = new WriteTextFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") writeTextFileError = new WriteTextFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") writeTextFileError = new WriteTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") writeTextFileError = new WriteTextFileErrorBusy(error);
+	}
+	if (writeTextFileError === void 0) writeTextFileError = new WriteTextFileError(error);
+	return DEither.left("file-system-write-text-file-error", writeTextFileError);
+}
+function handleDenoWriteTextFileError(error) {
+	let writeTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) writeTextFileError = new WriteTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) writeTextFileError = new WriteTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) writeTextFileError = new WriteTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) writeTextFileError = new WriteTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) writeTextFileError = new WriteTextFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) writeTextFileError = new WriteTextFileErrorBusy(error);
+	if (writeTextFileError === void 0) writeTextFileError = new WriteTextFileError(error);
+	return DEither.left("file-system-write-text-file-error", writeTextFileError);
+}
+const writeTextFileImplementation = implementFunction("writeTextFile", {
+	NODE: async (path, data) => nodeFileSystem.value.writeFile(path, data, { encoding: "utf-8" }).then(() => DEither.right("file-system-write-text-file")).catch(handleNodeWriteTextFileError),
+	DENO: (path, data) => Deno.writeTextFile(path, data).then(() => DEither.right("file-system-write-text-file")).catch(handleDenoWriteTextFileError),
+	BUN: (path, data) => Bun.file(path).write(data).then(() => DEither.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
+export { WriteTextFileError, WriteTextFileErrorBusy, WriteTextFileErrorInvalidArgument, WriteTextFileErrorIsDirectory, WriteTextFileErrorNoSpace, WriteTextFileErrorNotDirectory, WriteTextFileErrorNotFound, WriteTextFileErrorPermissionDenied, WriteTextFileErrorReadOnly, WriteTextFileErrorTooManyOpenFiles, writeTextFile };

package/dist/implementor.cjs

@@ -0,0 +1,67 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
+_duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+_duplojs_lang_common.createEnum([
+	"BUN",
+	"DENO",
+	"NODE",
+	"TEST"
+]);
+const SymbolEnvironmentStore = Symbol("environmentStore");
+const environmentStoreHandler = _duplojs_lang_common.createGlobalStore(SymbolEnvironmentStore, _duplojs_lang_common.justExec(() => {
+	if (typeof Deno !== "undefined") return "DENO";
+	if (typeof Bun !== "undefined") return "BUN";
+	if (typeof process !== "undefined" && process.versions?.node) return "NODE";
+	return "NODE";
+}));
+function setEnvironment(environment) {
+	environmentStoreHandler.set(environment);
+}
+let TESTImplementation;
+(function(_TESTImplementation) {
+	const store = /* @__PURE__ */ new Map();
+	function clear() {
+		store.clear();
+	}
+	_TESTImplementation.clear = clear;
+	function set(functionName, theFunction) {
+		store.set(functionName, theFunction);
+		return theFunction;
+	}
+	_TESTImplementation.set = set;
+	function get(functionName) {
+		return store.get(functionName);
+	}
+	_TESTImplementation.get = get;
+})(TESTImplementation || (TESTImplementation = {}));
+function implementFunction(functionName, theFunctions) {
+	const environmentFunctions = {
+		NODE: theFunctions.NODE,
+		BUN: theFunctions.BUN ||= theFunctions.NODE,
+		DENO: theFunctions.DENO ||= theFunctions.NODE,
+		get TEST() {
+			const theFunction = TESTImplementation.get(functionName);
+			if (!theFunction) throw new Error(`Missing function implementation "${functionName}" in TEST environment.`);
+			return theFunction;
+		}
+	};
+	return (...args) => environmentFunctions[environmentStoreHandler.value](...args);
+}
+const requireModule = _duplojs_lang_common.memo(() => _duplojs_lang_pattern.matchWithStringOtherwise(environmentStoreHandler.value, { BUN: () => require }, () => process.getBuiltinModule));
+const nodeFileSystem = _duplojs_lang_common.memo(() => requireModule.value("node:fs/promises"));
+const nodeCrypto = _duplojs_lang_common.memo(() => requireModule.value("node:crypto"));
+const nodeOs = _duplojs_lang_common.memo(() => requireModule.value("node:os"));
+//#endregion
+Object.defineProperty(exports, "TESTImplementation", {
+	enumerable: true,
+	get: function() {
+		return TESTImplementation;
+	}
+});
+exports.implementFunction = implementFunction;
+exports.nodeCrypto = nodeCrypto;
+exports.nodeFileSystem = nodeFileSystem;
+exports.nodeOs = nodeOs;
+exports.setEnvironment = setEnvironment;

package/dist/implementor.d.ts

@@ -0,0 +1,35 @@
+import * as DCommon from "@duplojs/lang/common";
+export interface ServerFunction {
+}
+export declare const SupportedEnvironment: {
+    BUN: "BUN";
+    DENO: "DENO";
+    NODE: "NODE";
+    TEST: "TEST";
+    toTuple: () => readonly ["BUN", "DENO", "NODE", "TEST"];
+    has: <GenericValue extends string>(value: GenericValue) => value is GenericValue & ("BUN" | "DENO" | "NODE" | "TEST");
+    contract: <GenericContractValue extends string = "BUN" | "DENO" | "NODE" | "TEST">(...args: (Exclude<"BUN", GenericContractValue> | Exclude<"DENO", GenericContractValue> | Exclude<"NODE", GenericContractValue> | Exclude<"TEST", GenericContractValue> extends infer InferredMissingValue extends string ? DCommon.IsNever<InferredMissingValue> extends true ? unknown : DCommon.ComputedTypeError<`Enum contract is missing value "${InferredMissingValue}".`> : never) & (Exclude<GenericContractValue, "BUN" | "DENO" | "NODE" | "TEST"> extends infer InferredUnknownValue extends string ? DCommon.IsNever<InferredUnknownValue> extends true ? unknown : DCommon.ComputedTypeError<`Enum contract contains unknown value "${InferredUnknownValue}".`> : never) extends infer InferredRequirement ? DCommon.IsEqual<InferredRequirement, unknown> extends true ? [] : [] & InferredRequirement : never) => /*elided*/ any;
+};
+export type SupportedEnvironment = DCommon.GetEnumValue<typeof SupportedEnvironment>;
+declare const SymbolEnvironmentStore: unique symbol;
+type SymbolEnvironmentStore = typeof SymbolEnvironmentStore;
+declare module "@duplojs/lang" {
+    interface GlobalStore {
+        [SymbolEnvironmentStore]: SupportedEnvironment;
+    }
+}
+export declare function setEnvironment(environment: SupportedEnvironment): void;
+export declare namespace TESTImplementation {
+    function clear(): void;
+    function set<GenericFunctionName extends keyof ServerFunction>(functionName: GenericFunctionName, theFunction: ServerFunction[GenericFunctionName]): ServerFunction[GenericFunctionName];
+    function get<GenericFunctionName extends keyof ServerFunction>(functionName: GenericFunctionName): ServerFunction[GenericFunctionName] | undefined;
+}
+export declare function implementFunction<GenericFunctionName extends keyof ServerFunction>(functionName: GenericFunctionName, theFunctions: {
+    NODE: ServerFunction[GenericFunctionName];
+    BUN?: ServerFunction[GenericFunctionName];
+    DENO?: ServerFunction[GenericFunctionName];
+}): ServerFunction[GenericFunctionName];
+export declare const nodeFileSystem: DCommon.Memoized<typeof import("node:fs/promises")>;
+export declare const nodeCrypto: DCommon.Memoized<typeof import("node:crypto")>;
+export declare const nodeOs: DCommon.Memoized<typeof import("node:os")>;
+export {};