@duplojs/server 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/file/appendFile.d.ts

@@ -1,7 +1,38 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type AppendFileResult = FileSystemEither<DEither.Right<"append-file", void> | DEither.Left<"append-file-not-found", unknown> | DEither.Left<"append-file-permission-denied", unknown> | DEither.Left<"append-file-is-directory", unknown> | DEither.Left<"append-file-not-directory", unknown> | DEither.Left<"append-file-no-space", unknown> | DEither.Left<"append-file-read-only", unknown> | DEither.Left<"append-file-invalid-argument", unknown> | DEither.Left<"append-file-too-many-open-files", unknown> | DEither.Left<"append-file-busy", unknown> | DEither.Left<"append-file-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const AppendFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-found", unknown>>, unknown>;
+declare class AppendFileErrorNotFound extends AppendFileErrorNotFound_base {
+}
+declare const AppendFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-permission-denied", unknown>>, unknown>;
+declare class AppendFileErrorPermissionDenied extends AppendFileErrorPermissionDenied_base {
+}
+declare const AppendFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-is-directory", unknown>>, unknown>;
+declare class AppendFileErrorIsDirectory extends AppendFileErrorIsDirectory_base {
+}
+declare const AppendFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-directory", unknown>>, unknown>;
+declare class AppendFileErrorNotDirectory extends AppendFileErrorNotDirectory_base {
+}
+declare const AppendFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-no-space", unknown>>, unknown>;
+declare class AppendFileErrorNoSpace extends AppendFileErrorNoSpace_base {
+}
+declare const AppendFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-read-only", unknown>>, unknown>;
+declare class AppendFileErrorReadOnly extends AppendFileErrorReadOnly_base {
+}
+declare const AppendFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-invalid-argument", unknown>>, unknown>;
+declare class AppendFileErrorInvalidArgument extends AppendFileErrorInvalidArgument_base {
+}
+declare const AppendFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-file-too-many-open-files", unknown>>, unknown>;
+declare class AppendFileErrorTooManyOpenFiles extends AppendFileErrorTooManyOpenFiles_base {
+}
+declare const AppendFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-busy", unknown>>, unknown>;
+declare class AppendFileErrorBusy extends AppendFileErrorBusy_base {
+}
+declare const AppendFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-error", unknown>>, unknown>;
+declare class AppendFileError extends AppendFileError_base {
+}
+export type AppendFileErrors = (AppendFileErrorNotFound | AppendFileErrorPermissionDenied | AppendFileErrorIsDirectory | AppendFileErrorNotDirectory | AppendFileErrorNoSpace | AppendFileErrorReadOnly | AppendFileErrorInvalidArgument | AppendFileErrorTooManyOpenFiles | AppendFileErrorBusy | AppendFileError);
+export type AppendFileResult = (DEither.Right<"file-system-append-file", void> | DEither.Left<"file-system-append-file-error", AppendFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
@@ -9,3 +40,4 @@ declare module '../implementor' {
 }
 export declare function appendFile(data: Uint8Array): (path: string & DPath.Path) => Promise<AppendFileResult>;
 export declare function appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
+export {};

package/dist/file/appendFile.mjs

@@ -1,33 +1,46 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/appendFile.ts
+var AppendFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-append-file-not-found", Error) {};
+var AppendFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-append-file-permission-denied", Error) {};
+var AppendFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-file-is-directory", Error) {};
+var AppendFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-file-not-directory", Error) {};
+var AppendFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-append-file-no-space", Error) {};
+var AppendFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-append-file-read-only", Error) {};
+var AppendFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-append-file-invalid-argument", Error) {};
+var AppendFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-append-file-too-many-open-files", Error) {};
+var AppendFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-append-file-busy", Error) {};
+var AppendFileError = class extends DCommon.DuploJSError.parentClass("file-system-append-file-error", Error) {};
 function handleNodeAppendFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-append-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-append-file-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-append-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-append-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-append-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-append-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-append-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-append-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-append-file-busy", error);
-	}
-	return DEither.left("file-system-append-file-error", error);
+	let appendFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") appendFileError = new AppendFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendFileError = new AppendFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendFileError = new AppendFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendFileError = new AppendFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendFileError = new AppendFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendFileError = new AppendFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendFileError = new AppendFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendFileError = new AppendFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendFileError = new AppendFileErrorBusy(error);
+		else appendFileError = new AppendFileError(error);
+	} else appendFileError = new AppendFileError(error);
+	return DEither.left("file-system-append-file-error", appendFileError);
 }
 function handleDenoAppendFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-append-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-append-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-append-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-append-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-append-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-append-file-busy", error);
-	return DEither.left("file-system-append-file-error", error);
+	let appendFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendFileError = new AppendFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendFileError = new AppendFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendFileError = new AppendFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendFileError = new AppendFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendFileError = new AppendFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendFileError = new AppendFileErrorBusy(error);
+	else appendFileError = new AppendFileError(error);
+	return DEither.left("file-system-append-file-error", appendFileError);
 }
 const appendFileImplementation = implementFunction("appendFile", {
-	NODE: async (path, data) => {
-		return (await nodeFileSystem.value).appendFile(path, data).then(() => DEither.right("file-system-append-file")).catch(handleNodeAppendFileError);
-	},
+	NODE: async (path, data) => nodeFileSystem.value.appendFile(path, data).then(() => DEither.right("file-system-append-file")).catch(handleNodeAppendFileError),
 	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => DEither.right("file-system-append-file")).catch(handleDenoAppendFileError)
 });
 function appendFile(...args) {

package/dist/file/appendTextFile.cjs

@@ -1,35 +1,49 @@
 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/appendTextFile.ts
+var AppendTextFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-not-found", Error) {};
+var AppendTextFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-permission-denied", Error) {};
+var AppendTextFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-is-directory", Error) {};
+var AppendTextFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-not-directory", Error) {};
+var AppendTextFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-no-space", Error) {};
+var AppendTextFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-read-only", Error) {};
+var AppendTextFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-invalid-argument", Error) {};
+var AppendTextFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-too-many-open-files", Error) {};
+var AppendTextFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-busy", Error) {};
+var AppendTextFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-text-file-error", Error) {};
 function handleNodeAppendTextFileError(error) {
+	let appendTextFileError = void 0;
 	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-append-text-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-append-text-file-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-append-text-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-append-text-file-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-append-text-file-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-append-text-file-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-append-text-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-append-text-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-append-text-file-busy", error);
+		if (error.code === "ENOENT") appendTextFileError = new AppendTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendTextFileError = new AppendTextFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendTextFileError = new AppendTextFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendTextFileError = new AppendTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendTextFileError = new AppendTextFileErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-append-text-file-error", error);
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return _duplojs_lang_either.left("file-system-append-text-file-error", appendTextFileError);
 }
 function handleDenoAppendTextFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-append-text-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-append-text-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-append-text-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-append-text-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-append-text-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-append-text-file-busy", error);
-	return _duplojs_lang_either.left("file-system-append-text-file-error", error);
+	let appendTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendTextFileError = new AppendTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendTextFileError = new AppendTextFileErrorBusy(error);
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return _duplojs_lang_either.left("file-system-append-text-file-error", appendTextFileError);
 }
 const appendTextFileImplementation = require_implementor.implementFunction("appendTextFile", {
-	NODE: async (path, data) => {
-		return (await require_implementor.nodeFileSystem.value).appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError);
-	},
+	NODE: async (path, data) => require_implementor.nodeFileSystem.value.appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError),
 	DENO: (path, data) => Deno.writeTextFile(path, data, { append: true }).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleDenoAppendTextFileError)
 });
 function appendTextFile(...args) {

package/dist/file/appendTextFile.d.ts

@@ -1,7 +1,38 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type AppendTextFileResult = FileSystemEither<DEither.Right<"append-text-file", void> | DEither.Left<"append-text-file-not-found", unknown> | DEither.Left<"append-text-file-permission-denied", unknown> | DEither.Left<"append-text-file-is-directory", unknown> | DEither.Left<"append-text-file-not-directory", unknown> | DEither.Left<"append-text-file-no-space", unknown> | DEither.Left<"append-text-file-read-only", unknown> | DEither.Left<"append-text-file-invalid-argument", unknown> | DEither.Left<"append-text-file-too-many-open-files", unknown> | DEither.Left<"append-text-file-busy", unknown> | DEither.Left<"append-text-file-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const AppendTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-not-found", unknown>>, unknown>;
+declare class AppendTextFileErrorNotFound extends AppendTextFileErrorNotFound_base {
+}
+declare const AppendTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-permission-denied", unknown>>, unknown>;
+declare class AppendTextFileErrorPermissionDenied extends AppendTextFileErrorPermissionDenied_base {
+}
+declare const AppendTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-is-directory", unknown>>, unknown>;
+declare class AppendTextFileErrorIsDirectory extends AppendTextFileErrorIsDirectory_base {
+}
+declare const AppendTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-not-directory", unknown>>, unknown>;
+declare class AppendTextFileErrorNotDirectory extends AppendTextFileErrorNotDirectory_base {
+}
+declare const AppendTextFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-no-space", unknown>>, unknown>;
+declare class AppendTextFileErrorNoSpace extends AppendTextFileErrorNoSpace_base {
+}
+declare const AppendTextFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-read-only", unknown>>, unknown>;
+declare class AppendTextFileErrorReadOnly extends AppendTextFileErrorReadOnly_base {
+}
+declare const AppendTextFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-invalid-argument", unknown>>, unknown>;
+declare class AppendTextFileErrorInvalidArgument extends AppendTextFileErrorInvalidArgument_base {
+}
+declare const AppendTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-text-file-too-many-open-files", unknown>>, unknown>;
+declare class AppendTextFileErrorTooManyOpenFiles extends AppendTextFileErrorTooManyOpenFiles_base {
+}
+declare const AppendTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-busy", unknown>>, unknown>;
+declare class AppendTextFileErrorBusy extends AppendTextFileErrorBusy_base {
+}
+declare const AppendTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-text-file-error", unknown>>, unknown>;
+declare class AppendTextFileError extends AppendTextFileError_base {
+}
+export type AppendTextFileErrors = (AppendTextFileErrorNotFound | AppendTextFileErrorPermissionDenied | AppendTextFileErrorIsDirectory | AppendTextFileErrorNotDirectory | AppendTextFileErrorNoSpace | AppendTextFileErrorReadOnly | AppendTextFileErrorInvalidArgument | AppendTextFileErrorTooManyOpenFiles | AppendTextFileErrorBusy | AppendTextFileError);
+export type AppendTextFileResult = (DEither.Right<"file-system-append-text-file", void> | DEither.Left<"file-system-append-text-file-error", AppendTextFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         appendTextFile(path: string & DPath.Path, data: string): Promise<AppendTextFileResult>;
@@ -9,3 +40,4 @@ declare module '../implementor' {
 }
 export declare function appendTextFile(data: string): (path: string & DPath.Path) => Promise<AppendTextFileResult>;
 export declare function appendTextFile(path: string & DPath.Path, data: string): Promise<AppendTextFileResult>;
+export {};

package/dist/file/appendTextFile.mjs

@@ -1,33 +1,46 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/appendTextFile.ts
+var AppendTextFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-not-found", Error) {};
+var AppendTextFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-permission-denied", Error) {};
+var AppendTextFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-is-directory", Error) {};
+var AppendTextFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-not-directory", Error) {};
+var AppendTextFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-no-space", Error) {};
+var AppendTextFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-read-only", Error) {};
+var AppendTextFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-invalid-argument", Error) {};
+var AppendTextFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-too-many-open-files", Error) {};
+var AppendTextFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-busy", Error) {};
+var AppendTextFileError = class extends DCommon.DuploJSError.parentClass("file-system-append-text-file-error", Error) {};
 function handleNodeAppendTextFileError(error) {
+	let appendTextFileError = void 0;
 	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-append-text-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-append-text-file-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-append-text-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-append-text-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-append-text-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-append-text-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-append-text-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-append-text-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-append-text-file-busy", error);
+		if (error.code === "ENOENT") appendTextFileError = new AppendTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendTextFileError = new AppendTextFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendTextFileError = new AppendTextFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendTextFileError = new AppendTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendTextFileError = new AppendTextFileErrorBusy(error);
 	}
-	return DEither.left("file-system-append-text-file-error", error);
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return DEither.left("file-system-append-text-file-error", appendTextFileError);
 }
 function handleDenoAppendTextFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-append-text-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-append-text-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-append-text-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-append-text-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-append-text-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-append-text-file-busy", error);
-	return DEither.left("file-system-append-text-file-error", error);
+	let appendTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendTextFileError = new AppendTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendTextFileError = new AppendTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendTextFileError = new AppendTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendTextFileError = new AppendTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendTextFileError = new AppendTextFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendTextFileError = new AppendTextFileErrorBusy(error);
+	if (appendTextFileError === void 0) appendTextFileError = new AppendTextFileError(error);
+	return DEither.left("file-system-append-text-file-error", appendTextFileError);
 }
 const appendTextFileImplementation = implementFunction("appendTextFile", {
-	NODE: async (path, data) => {
-		return (await nodeFileSystem.value).appendFile(path, data).then(() => DEither.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError);
-	},
+	NODE: async (path, data) => nodeFileSystem.value.appendFile(path, data).then(() => DEither.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError),
 	DENO: (path, data) => Deno.writeTextFile(path, data, { append: true }).then(() => DEither.right("file-system-append-text-file")).catch(handleDenoAppendTextFileError)
 });
 function appendTextFile(...args) {

package/dist/file/copy.cjs

@@ -1,25 +1,37 @@
 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/copy.ts
+var CopyErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-not-found", Error) {};
+var CopyErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-permission-denied", Error) {};
+var CopyErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-already-exists", Error) {};
+var CopyErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-not-directory", Error) {};
+var CopyErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-no-space", Error) {};
+var CopyErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-read-only", Error) {};
+var CopyErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-invalid-argument", Error) {};
+var CopyErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-too-many-open-files", Error) {};
+var CopyErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-busy", Error) {};
+var CopyError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-copy-error", Error) {};
 function handleNodeCopyError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-copy-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-copy-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-copy-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-copy-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-copy-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-copy-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-copy-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-copy-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-copy-busy", error);
+	let copyError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") copyError = new CopyErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") copyError = new CopyErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") copyError = new CopyErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") copyError = new CopyErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") copyError = new CopyErrorNoSpace(error);
+		else if (error.code === "EROFS") copyError = new CopyErrorReadOnly(error);
+		else if (error.code === "EINVAL") copyError = new CopyErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") copyError = new CopyErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") copyError = new CopyErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-copy-error", error);
+	if (copyError === void 0) copyError = new CopyError(error);
+	return _duplojs_lang_either.left("file-system-copy-error", copyError);
 }
-const copyImplementation = require_implementor.implementFunction("copy", { NODE: async (fromPath, toPath) => {
-	return (await require_implementor.nodeFileSystem.value).cp(fromPath, toPath, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-copy")).catch(handleNodeCopyError);
-} });
+const copyImplementation = require_implementor.implementFunction("copy", { NODE: async (fromPath, toPath) => require_implementor.nodeFileSystem.value.cp(fromPath, toPath, { recursive: true }).then(() => _duplojs_lang_either.right("file-system-copy")).catch(handleNodeCopyError) });
 function copy(...args) {
 	if (args.length === 1) {
 		const [toPath] = args;

package/dist/file/copy.d.ts

@@ -1,7 +1,38 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type CopyResult = FileSystemEither<DEither.Right<"copy", void> | DEither.Left<"copy-not-found", unknown> | DEither.Left<"copy-permission-denied", unknown> | DEither.Left<"copy-already-exists", unknown> | DEither.Left<"copy-not-directory", unknown> | DEither.Left<"copy-no-space", unknown> | DEither.Left<"copy-read-only", unknown> | DEither.Left<"copy-invalid-argument", unknown> | DEither.Left<"copy-too-many-open-files", unknown> | DEither.Left<"copy-busy", unknown> | DEither.Left<"copy-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const CopyErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-not-found", unknown>>, unknown>;
+declare class CopyErrorNotFound extends CopyErrorNotFound_base {
+}
+declare const CopyErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-permission-denied", unknown>>, unknown>;
+declare class CopyErrorPermissionDenied extends CopyErrorPermissionDenied_base {
+}
+declare const CopyErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-already-exists", unknown>>, unknown>;
+declare class CopyErrorAlreadyExists extends CopyErrorAlreadyExists_base {
+}
+declare const CopyErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-not-directory", unknown>>, unknown>;
+declare class CopyErrorNotDirectory extends CopyErrorNotDirectory_base {
+}
+declare const CopyErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-no-space", unknown>>, unknown>;
+declare class CopyErrorNoSpace extends CopyErrorNoSpace_base {
+}
+declare const CopyErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-read-only", unknown>>, unknown>;
+declare class CopyErrorReadOnly extends CopyErrorReadOnly_base {
+}
+declare const CopyErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-invalid-argument", unknown>>, unknown>;
+declare class CopyErrorInvalidArgument extends CopyErrorInvalidArgument_base {
+}
+declare const CopyErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-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-copy-too-many-open-files", unknown>>, unknown>;
+declare class CopyErrorTooManyOpenFiles extends CopyErrorTooManyOpenFiles_base {
+}
+declare const CopyErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-busy", unknown>>, unknown>;
+declare class CopyErrorBusy extends CopyErrorBusy_base {
+}
+declare const CopyError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-copy-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-copy-error", unknown>>, unknown>;
+declare class CopyError extends CopyError_base {
+}
+export type CopyErrors = (CopyErrorNotFound | CopyErrorPermissionDenied | CopyErrorAlreadyExists | CopyErrorNotDirectory | CopyErrorNoSpace | CopyErrorReadOnly | CopyErrorInvalidArgument | CopyErrorTooManyOpenFiles | CopyErrorBusy | CopyError);
+export type CopyResult = (DEither.Right<"file-system-copy", void> | DEither.Left<"file-system-copy-error", CopyErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         copy(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<CopyResult>;
@@ -9,3 +40,4 @@ declare module '../implementor' {
 }
 export declare function copy(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<CopyResult>;
 export declare function copy(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<CopyResult>;
+export {};

package/dist/file/copy.mjs

@@ -1,23 +1,34 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/copy.ts
+var CopyErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-copy-not-found", Error) {};
+var CopyErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-copy-permission-denied", Error) {};
+var CopyErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-copy-already-exists", Error) {};
+var CopyErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-copy-not-directory", Error) {};
+var CopyErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-copy-no-space", Error) {};
+var CopyErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-copy-read-only", Error) {};
+var CopyErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-copy-invalid-argument", Error) {};
+var CopyErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-copy-too-many-open-files", Error) {};
+var CopyErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-copy-busy", Error) {};
+var CopyError = class extends DCommon.DuploJSError.parentClass("file-system-copy-error", Error) {};
 function handleNodeCopyError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-copy-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-copy-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-copy-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-copy-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-copy-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-copy-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-copy-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-copy-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-copy-busy", error);
+	let copyError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") copyError = new CopyErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") copyError = new CopyErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") copyError = new CopyErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") copyError = new CopyErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") copyError = new CopyErrorNoSpace(error);
+		else if (error.code === "EROFS") copyError = new CopyErrorReadOnly(error);
+		else if (error.code === "EINVAL") copyError = new CopyErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") copyError = new CopyErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") copyError = new CopyErrorBusy(error);
 	}
-	return DEither.left("file-system-copy-error", error);
+	if (copyError === void 0) copyError = new CopyError(error);
+	return DEither.left("file-system-copy-error", copyError);
 }
-const copyImplementation = implementFunction("copy", { NODE: async (fromPath, toPath) => {
-	return (await nodeFileSystem.value).cp(fromPath, toPath, { recursive: true }).then(() => DEither.right("file-system-copy")).catch(handleNodeCopyError);
-} });
+const copyImplementation = implementFunction("copy", { NODE: async (fromPath, toPath) => nodeFileSystem.value.cp(fromPath, toPath, { recursive: true }).then(() => DEither.right("file-system-copy")).catch(handleNodeCopyError) });
 function copy(...args) {
 	if (args.length === 1) {
 		const [toPath] = args;

package/dist/file/createEntryInterface.cjs

@@ -3,10 +3,10 @@ const require_stat = require("./stat.cjs");
 const require_fileInterface = require("./fileInterface.cjs");
 const require_unknownEntryInterface = require("./unknownEntryInterface.cjs");
 const require_folderInterface = require("./folderInterface.cjs");
-let _duplojs_lang_either = require("@duplojs/lang/either");
-_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_pattern = require("@duplojs/lang/pattern");
 _duplojs_lang_pattern = require_runtime.__toESM(_duplojs_lang_pattern, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 //#region scripts/file/createEntryInterface.ts
 async function createEntryInterface(path) {
 	const result = await _duplojs_lang_either.rightAsyncPipe(require_stat.stat(path), _duplojs_lang_pattern.when(({ isFile }) => isFile, () => _duplojs_lang_either.right("file-interface", require_fileInterface.createFileInterface(path))), _duplojs_lang_pattern.when(({ isDirectory }) => isDirectory, () => _duplojs_lang_either.right("folder-interface", require_folderInterface.createFolderInterface(path))), _duplojs_lang_pattern.otherwise(() => _duplojs_lang_either.right("unknown-entry-interface", require_unknownEntryInterface.createUnknownEntryInterface(path))));

package/dist/file/createEntryInterface.d.ts

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

package/dist/file/createEntryInterface.mjs

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

package/dist/file/ensureDirectory.cjs

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