@duplojs/server 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/file/linkStat.cjs

@@ -7,22 +7,32 @@ _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_chrono = require("@duplojs/lang/chrono");
 _duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
 //#region scripts/file/linkStat.ts
+var LinkStatErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-not-found", Error) {};
+var LinkStatErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-permission-denied", Error) {};
+var LinkStatErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-not-directory", Error) {};
+var LinkStatErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-too-many-open-files", Error) {};
+var LinkStatErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-busy", Error) {};
+var LinkStatError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-link-stat-error", Error) {};
 function handleNodeLinkStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-link-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-link-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-link-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-link-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-link-stat-busy", error);
+	let linkStatError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkStatError = new LinkStatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkStatError = new LinkStatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") linkStatError = new LinkStatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkStatError = new LinkStatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkStatError = new LinkStatErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-link-stat-error", error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return _duplojs_lang_either.left("file-system-link-stat-error", linkStatError);
 }
 function handleDenoLinkStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-link-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-link-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-link-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-link-stat-busy", error);
-	return _duplojs_lang_either.left("file-system-link-stat-error", error);
+	let linkStatError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkStatError = new LinkStatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkStatError = new LinkStatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkStatError = new LinkStatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) linkStatError = new LinkStatErrorBusy(error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return _duplojs_lang_either.left("file-system-link-stat-error", linkStatError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -75,10 +85,14 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const linkStat = require_implementor.implementFunction("linkStat", {
-	NODE: async (path) => {
-		return (await require_implementor.nodeFileSystem.value).lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleNodeLinkStatError);
-	},
+	NODE: async (path) => require_implementor.nodeFileSystem.value.lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleNodeLinkStatError),
 	DENO: (path) => Deno.lstat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithDeno, (value) => _duplojs_lang_either.right("file-system-link-stat", value))).catch(handleDenoLinkStatError)
 });
 //#endregion
+exports.LinkStatError = LinkStatError;
+exports.LinkStatErrorBusy = LinkStatErrorBusy;
+exports.LinkStatErrorNotDirectory = LinkStatErrorNotDirectory;
+exports.LinkStatErrorNotFound = LinkStatErrorNotFound;
+exports.LinkStatErrorPermissionDenied = LinkStatErrorPermissionDenied;
+exports.LinkStatErrorTooManyOpenFiles = LinkStatErrorTooManyOpenFiles;
 exports.linkStat = linkStat;

package/dist/file/linkStat.d.ts

@@ -1,11 +1,31 @@
 import { StatInfo } from './stat';
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type LinkStatResult = FileSystemEither<DEither.Right<"link-stat", StatInfo> | DEither.Left<"link-stat-not-found", unknown> | DEither.Left<"link-stat-permission-denied", unknown> | DEither.Left<"link-stat-not-directory", unknown> | DEither.Left<"link-stat-too-many-open-files", unknown> | DEither.Left<"link-stat-busy", unknown> | DEither.Left<"link-stat-error", unknown>>;
+declare const LinkStatErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-not-found", unknown>>, unknown>;
+export declare class LinkStatErrorNotFound extends LinkStatErrorNotFound_base {
+}
+declare const LinkStatErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-permission-denied", unknown>>, unknown>;
+export declare class LinkStatErrorPermissionDenied extends LinkStatErrorPermissionDenied_base {
+}
+declare const LinkStatErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-not-directory", unknown>>, unknown>;
+export declare class LinkStatErrorNotDirectory extends LinkStatErrorNotDirectory_base {
+}
+declare const LinkStatErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-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-link-stat-too-many-open-files", unknown>>, unknown>;
+export declare class LinkStatErrorTooManyOpenFiles extends LinkStatErrorTooManyOpenFiles_base {
+}
+declare const LinkStatErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-busy", unknown>>, unknown>;
+export declare class LinkStatErrorBusy extends LinkStatErrorBusy_base {
+}
+declare const LinkStatError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-link-stat-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-link-stat-error", unknown>>, unknown>;
+export declare class LinkStatError extends LinkStatError_base {
+}
+export type LinkStatErrors = (LinkStatErrorNotFound | LinkStatErrorPermissionDenied | LinkStatErrorNotDirectory | LinkStatErrorTooManyOpenFiles | LinkStatErrorBusy | LinkStatError);
+export type LinkStatResult = (DEither.Right<"file-system-link-stat", StatInfo> | DEither.Left<"file-system-link-stat-error", LinkStatErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        linkStat(path: string & DPath.Path): Promise<LinkStatResult>;
+        linkStat(path: DPath.AnyPath): Promise<LinkStatResult>;
     }
 }
-export declare const linkStat: (path: string & DPath.Path) => Promise<LinkStatResult>;
+export declare const linkStat: (path: DPath.AnyPath) => Promise<LinkStatResult>;
+export {};

package/dist/file/linkStat.mjs

@@ -3,22 +3,32 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DChrono from "@duplojs/lang/chrono";
 //#region scripts/file/linkStat.ts
+var LinkStatErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-not-found", Error) {};
+var LinkStatErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-permission-denied", Error) {};
+var LinkStatErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-not-directory", Error) {};
+var LinkStatErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-too-many-open-files", Error) {};
+var LinkStatErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-busy", Error) {};
+var LinkStatError = class extends DCommon.DuploJSError.parentClass("file-system-link-stat-error", Error) {};
 function handleNodeLinkStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-link-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-link-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-link-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-link-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-link-stat-busy", error);
+	let linkStatError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") linkStatError = new LinkStatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") linkStatError = new LinkStatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") linkStatError = new LinkStatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") linkStatError = new LinkStatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") linkStatError = new LinkStatErrorBusy(error);
 	}
-	return DEither.left("file-system-link-stat-error", error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return DEither.left("file-system-link-stat-error", linkStatError);
 }
 function handleDenoLinkStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-link-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-link-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-link-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-link-stat-busy", error);
-	return DEither.left("file-system-link-stat-error", error);
+	let linkStatError = void 0;
+	if (error instanceof Deno.errors.NotFound) linkStatError = new LinkStatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) linkStatError = new LinkStatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) linkStatError = new LinkStatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) linkStatError = new LinkStatErrorBusy(error);
+	if (linkStatError === void 0) linkStatError = new LinkStatError(error);
+	return DEither.left("file-system-link-stat-error", linkStatError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -71,10 +81,8 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const linkStat = implementFunction("linkStat", {
-	NODE: async (path) => {
-		return (await nodeFileSystem.value).lstat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-link-stat", value))).catch(handleNodeLinkStatError);
-	},
+	NODE: async (path) => nodeFileSystem.value.lstat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-link-stat", value))).catch(handleNodeLinkStatError),
 	DENO: (path) => Deno.lstat(path).then(DCommon.innerPipe(createStatInfoWithDeno, (value) => DEither.right("file-system-link-stat", value))).catch(handleDenoLinkStatError)
 });
 //#endregion
-export { linkStat };
+export { LinkStatError, LinkStatErrorBusy, LinkStatErrorNotDirectory, LinkStatErrorNotFound, LinkStatErrorPermissionDenied, LinkStatErrorTooManyOpenFiles, linkStat };

package/dist/file/makeDirectory.cjs

@@ -1,36 +1,60 @@
 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/makeDirectory.ts
+var MakeDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-not-found", Error) {};
+var MakeDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-permission-denied", Error) {};
+var MakeDirectoryErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-already-exists", Error) {};
+var MakeDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-not-directory", Error) {};
+var MakeDirectoryErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-no-space", Error) {};
+var MakeDirectoryErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-read-only", Error) {};
+var MakeDirectoryErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-invalid-argument", Error) {};
+var MakeDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-too-many-open-files", Error) {};
+var MakeDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-busy", Error) {};
+var MakeDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-directory-error", Error) {};
 function handleNodeMakeDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-make-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-directory-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-make-directory-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-directory-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-directory-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-make-directory-busy", error);
+	let makeDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeDirectoryError = new MakeDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeDirectoryError = new MakeDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeDirectoryError = new MakeDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") makeDirectoryError = new MakeDirectoryErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-make-directory-error", error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-directory-error", makeDirectoryError);
 }
 function handleDenoMakeDirectoryError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-make-directory-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-directory-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-make-directory-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-directory-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-make-directory-busy", error);
-	return _duplojs_lang_either.left("file-system-make-directory-error", error);
+	let makeDirectoryError = void 0;
+	if (error instanceof Deno.errors.NotFound) makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) makeDirectoryError = new MakeDirectoryErrorBusy(error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-directory-error", makeDirectoryError);
 }
 const makeDirectory = require_implementor.implementFunction("makeDirectory", {
-	NODE: async (path, params) => {
-		return (await require_implementor.nodeFileSystem.value).mkdir(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError);
-	},
+	NODE: async (path, params) => require_implementor.nodeFileSystem.value.mkdir(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError),
 	DENO: (path, params) => Deno.mkdir(path, { recursive: params?.recursive }).then(() => _duplojs_lang_either.right("file-system-make-directory")).catch(handleDenoMakeDirectoryError)
 });
 //#endregion
+exports.MakeDirectoryError = MakeDirectoryError;
+exports.MakeDirectoryErrorAlreadyExists = MakeDirectoryErrorAlreadyExists;
+exports.MakeDirectoryErrorBusy = MakeDirectoryErrorBusy;
+exports.MakeDirectoryErrorInvalidArgument = MakeDirectoryErrorInvalidArgument;
+exports.MakeDirectoryErrorNoSpace = MakeDirectoryErrorNoSpace;
+exports.MakeDirectoryErrorNotDirectory = MakeDirectoryErrorNotDirectory;
+exports.MakeDirectoryErrorNotFound = MakeDirectoryErrorNotFound;
+exports.MakeDirectoryErrorPermissionDenied = MakeDirectoryErrorPermissionDenied;
+exports.MakeDirectoryErrorReadOnly = MakeDirectoryErrorReadOnly;
+exports.MakeDirectoryErrorTooManyOpenFiles = MakeDirectoryErrorTooManyOpenFiles;
 exports.makeDirectory = makeDirectory;

package/dist/file/makeDirectory.d.ts

@@ -1,14 +1,45 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
 interface MakeDirectoryParams {
     recursive?: boolean;
 }
-export type MakeDirectoryResult = FileSystemEither<DEither.Right<"make-directory", void> | DEither.Left<"make-directory-not-found", unknown> | DEither.Left<"make-directory-permission-denied", unknown> | DEither.Left<"make-directory-already-exists", unknown> | DEither.Left<"make-directory-not-directory", unknown> | DEither.Left<"make-directory-no-space", unknown> | DEither.Left<"make-directory-read-only", unknown> | DEither.Left<"make-directory-invalid-argument", unknown> | DEither.Left<"make-directory-too-many-open-files", unknown> | DEither.Left<"make-directory-busy", unknown> | DEither.Left<"make-directory-error", unknown>>;
+declare const MakeDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-not-found", unknown>>, unknown>;
+export declare class MakeDirectoryErrorNotFound extends MakeDirectoryErrorNotFound_base {
+}
+declare const MakeDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-permission-denied", unknown>>, unknown>;
+export declare class MakeDirectoryErrorPermissionDenied extends MakeDirectoryErrorPermissionDenied_base {
+}
+declare const MakeDirectoryErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-already-exists", unknown>>, unknown>;
+export declare class MakeDirectoryErrorAlreadyExists extends MakeDirectoryErrorAlreadyExists_base {
+}
+declare const MakeDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-not-directory", unknown>>, unknown>;
+export declare class MakeDirectoryErrorNotDirectory extends MakeDirectoryErrorNotDirectory_base {
+}
+declare const MakeDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-no-space", unknown>>, unknown>;
+export declare class MakeDirectoryErrorNoSpace extends MakeDirectoryErrorNoSpace_base {
+}
+declare const MakeDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-read-only", unknown>>, unknown>;
+export declare class MakeDirectoryErrorReadOnly extends MakeDirectoryErrorReadOnly_base {
+}
+declare const MakeDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-invalid-argument", unknown>>, unknown>;
+export declare class MakeDirectoryErrorInvalidArgument extends MakeDirectoryErrorInvalidArgument_base {
+}
+declare const MakeDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-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-make-directory-too-many-open-files", unknown>>, unknown>;
+export declare class MakeDirectoryErrorTooManyOpenFiles extends MakeDirectoryErrorTooManyOpenFiles_base {
+}
+declare const MakeDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-busy", unknown>>, unknown>;
+export declare class MakeDirectoryErrorBusy extends MakeDirectoryErrorBusy_base {
+}
+declare const MakeDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-directory-error", unknown>>, unknown>;
+export declare class MakeDirectoryError extends MakeDirectoryError_base {
+}
+export type MakeDirectoryErrors = (MakeDirectoryErrorNotFound | MakeDirectoryErrorPermissionDenied | MakeDirectoryErrorAlreadyExists | MakeDirectoryErrorNotDirectory | MakeDirectoryErrorNoSpace | MakeDirectoryErrorReadOnly | MakeDirectoryErrorInvalidArgument | MakeDirectoryErrorTooManyOpenFiles | MakeDirectoryErrorBusy | MakeDirectoryError);
+export type MakeDirectoryResult = (DEither.Right<"file-system-make-directory", void> | DEither.Left<"file-system-make-directory-error", MakeDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        makeDirectory(path: string & DPath.Path, params?: MakeDirectoryParams): Promise<MakeDirectoryResult>;
+        makeDirectory(path: DPath.AnyPath, params?: MakeDirectoryParams): Promise<MakeDirectoryResult>;
     }
 }
-export declare const makeDirectory: (path: string & DPath.Path, params?: MakeDirectoryParams) => Promise<MakeDirectoryResult>;
+export declare const makeDirectory: (path: DPath.AnyPath, params?: MakeDirectoryParams) => Promise<MakeDirectoryResult>;
 export {};

package/dist/file/makeDirectory.mjs

@@ -1,34 +1,47 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/makeDirectory.ts
+var MakeDirectoryErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-not-found", Error) {};
+var MakeDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-permission-denied", Error) {};
+var MakeDirectoryErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-already-exists", Error) {};
+var MakeDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-not-directory", Error) {};
+var MakeDirectoryErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-no-space", Error) {};
+var MakeDirectoryErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-read-only", Error) {};
+var MakeDirectoryErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-invalid-argument", Error) {};
+var MakeDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-too-many-open-files", Error) {};
+var MakeDirectoryErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-busy", Error) {};
+var MakeDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-make-directory-error", Error) {};
 function handleNodeMakeDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-make-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-directory-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-make-directory-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-make-directory-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-make-directory-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-make-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-make-directory-busy", error);
+	let makeDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeDirectoryError = new MakeDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeDirectoryError = new MakeDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeDirectoryError = new MakeDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") makeDirectoryError = new MakeDirectoryErrorBusy(error);
 	}
-	return DEither.left("file-system-make-directory-error", error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return DEither.left("file-system-make-directory-error", makeDirectoryError);
 }
 function handleDenoMakeDirectoryError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-make-directory-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-directory-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-make-directory-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-directory-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-make-directory-busy", error);
-	return DEither.left("file-system-make-directory-error", error);
+	let makeDirectoryError = void 0;
+	if (error instanceof Deno.errors.NotFound) makeDirectoryError = new MakeDirectoryErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeDirectoryError = new MakeDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeDirectoryError = new MakeDirectoryErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeDirectoryError = new MakeDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeDirectoryError = new MakeDirectoryErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) makeDirectoryError = new MakeDirectoryErrorBusy(error);
+	if (makeDirectoryError === void 0) makeDirectoryError = new MakeDirectoryError(error);
+	return DEither.left("file-system-make-directory-error", makeDirectoryError);
 }
 const makeDirectory = implementFunction("makeDirectory", {
-	NODE: async (path, params) => {
-		return (await nodeFileSystem.value).mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError);
-	},
+	NODE: async (path, params) => nodeFileSystem.value.mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleNodeMakeDirectoryError),
 	DENO: (path, params) => Deno.mkdir(path, { recursive: params?.recursive }).then(() => DEither.right("file-system-make-directory")).catch(handleDenoMakeDirectoryError)
 });
 //#endregion
-export { makeDirectory };
+export { MakeDirectoryError, MakeDirectoryErrorAlreadyExists, MakeDirectoryErrorBusy, MakeDirectoryErrorInvalidArgument, MakeDirectoryErrorNoSpace, MakeDirectoryErrorNotDirectory, MakeDirectoryErrorNotFound, MakeDirectoryErrorPermissionDenied, MakeDirectoryErrorReadOnly, MakeDirectoryErrorTooManyOpenFiles, makeDirectory };

package/dist/file/makeTemporaryDirectory.cjs

@@ -1,30 +1,48 @@
 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/makeTemporaryDirectory.ts
+var MakeTemporaryDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-permission-denied", Error) {};
+var MakeTemporaryDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-not-directory", Error) {};
+var MakeTemporaryDirectoryErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-no-space", Error) {};
+var MakeTemporaryDirectoryErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-read-only", Error) {};
+var MakeTemporaryDirectoryErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-invalid-argument", Error) {};
+var MakeTemporaryDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-too-many-open-files", Error) {};
+var MakeTemporaryDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-directory-error", Error) {};
 function handleNodeMakeTemporaryDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-make-temporary-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-temporary-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-temporary-directory-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-temporary-directory-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-temporary-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-temporary-directory-too-many-open-files", error);
+	let makeTemporaryDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorTooManyOpenFiles(error);
 	}
-	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 function handleDenoMakeTemporaryDirectoryError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-temporary-directory-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-temporary-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-temporary-directory-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", error);
+	let makeTemporaryDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 const makeTemporaryDirectory = require_implementor.implementFunction("makeTemporaryDirectory", {
-	NODE: async (prefix) => {
-		return (await require_implementor.nodeFileSystem.value).mkdtemp(prefix).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError);
-	},
+	NODE: async (prefix) => require_implementor.nodeFileSystem.value.mkdtemp(prefix).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError),
 	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => _duplojs_lang_either.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
 });
 //#endregion
+exports.MakeTemporaryDirectoryError = MakeTemporaryDirectoryError;
+exports.MakeTemporaryDirectoryErrorInvalidArgument = MakeTemporaryDirectoryErrorInvalidArgument;
+exports.MakeTemporaryDirectoryErrorNoSpace = MakeTemporaryDirectoryErrorNoSpace;
+exports.MakeTemporaryDirectoryErrorNotDirectory = MakeTemporaryDirectoryErrorNotDirectory;
+exports.MakeTemporaryDirectoryErrorPermissionDenied = MakeTemporaryDirectoryErrorPermissionDenied;
+exports.MakeTemporaryDirectoryErrorReadOnly = MakeTemporaryDirectoryErrorReadOnly;
+exports.MakeTemporaryDirectoryErrorTooManyOpenFiles = MakeTemporaryDirectoryErrorTooManyOpenFiles;
 exports.makeTemporaryDirectory = makeTemporaryDirectory;

package/dist/file/makeTemporaryDirectory.d.ts

@@ -1,9 +1,32 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
-export type MakeTemporaryDirectoryResult = FileSystemEither<DEither.Right<"make-temporary-directory", string> | DEither.Left<"make-temporary-directory-permission-denied", unknown> | DEither.Left<"make-temporary-directory-not-directory", unknown> | DEither.Left<"make-temporary-directory-no-space", unknown> | DEither.Left<"make-temporary-directory-read-only", unknown> | DEither.Left<"make-temporary-directory-invalid-argument", unknown> | DEither.Left<"make-temporary-directory-too-many-open-files", unknown> | DEither.Left<"make-temporary-directory-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const MakeTemporaryDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-permission-denied", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryErrorPermissionDenied extends MakeTemporaryDirectoryErrorPermissionDenied_base {
+}
+declare const MakeTemporaryDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-not-directory", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryErrorNotDirectory extends MakeTemporaryDirectoryErrorNotDirectory_base {
+}
+declare const MakeTemporaryDirectoryErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-no-space", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryErrorNoSpace extends MakeTemporaryDirectoryErrorNoSpace_base {
+}
+declare const MakeTemporaryDirectoryErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-read-only", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryErrorReadOnly extends MakeTemporaryDirectoryErrorReadOnly_base {
+}
+declare const MakeTemporaryDirectoryErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-invalid-argument", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryErrorInvalidArgument extends MakeTemporaryDirectoryErrorInvalidArgument_base {
+}
+declare const MakeTemporaryDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-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-make-temporary-directory-too-many-open-files", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryErrorTooManyOpenFiles extends MakeTemporaryDirectoryErrorTooManyOpenFiles_base {
+}
+declare const MakeTemporaryDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-directory-error", unknown>>, unknown>;
+export declare class MakeTemporaryDirectoryError extends MakeTemporaryDirectoryError_base {
+}
+export type MakeTemporaryDirectoryErrors = (MakeTemporaryDirectoryErrorPermissionDenied | MakeTemporaryDirectoryErrorNotDirectory | MakeTemporaryDirectoryErrorNoSpace | MakeTemporaryDirectoryErrorReadOnly | MakeTemporaryDirectoryErrorInvalidArgument | MakeTemporaryDirectoryErrorTooManyOpenFiles | MakeTemporaryDirectoryError);
+export type MakeTemporaryDirectoryResult = (DEither.Right<"file-system-make-temporary-directory", string> | DEither.Left<"file-system-make-temporary-directory-error", MakeTemporaryDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         makeTemporaryDirectory(prefix: string): Promise<MakeTemporaryDirectoryResult>;
     }
 }
 export declare const makeTemporaryDirectory: (prefix: string) => Promise<MakeTemporaryDirectoryResult>;
+export {};

package/dist/file/makeTemporaryDirectory.mjs

@@ -1,28 +1,38 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/makeTemporaryDirectory.ts
+var MakeTemporaryDirectoryErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-permission-denied", Error) {};
+var MakeTemporaryDirectoryErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-not-directory", Error) {};
+var MakeTemporaryDirectoryErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-no-space", Error) {};
+var MakeTemporaryDirectoryErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-read-only", Error) {};
+var MakeTemporaryDirectoryErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-invalid-argument", Error) {};
+var MakeTemporaryDirectoryErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-too-many-open-files", Error) {};
+var MakeTemporaryDirectoryError = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-directory-error", Error) {};
 function handleNodeMakeTemporaryDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-temporary-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-temporary-directory-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-make-temporary-directory-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-make-temporary-directory-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-make-temporary-directory-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-temporary-directory-too-many-open-files", error);
+	let makeTemporaryDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorTooManyOpenFiles(error);
 	}
-	return DEither.left("file-system-make-temporary-directory-error", error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return DEither.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 function handleDenoMakeTemporaryDirectoryError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-temporary-directory-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-temporary-directory-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-temporary-directory-invalid-argument", error);
-	return DEither.left("file-system-make-temporary-directory-error", error);
+	let makeTemporaryDirectoryError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryDirectoryError = new MakeTemporaryDirectoryErrorInvalidArgument(error);
+	if (makeTemporaryDirectoryError === void 0) makeTemporaryDirectoryError = new MakeTemporaryDirectoryError(error);
+	return DEither.left("file-system-make-temporary-directory-error", makeTemporaryDirectoryError);
 }
 const makeTemporaryDirectory = implementFunction("makeTemporaryDirectory", {
-	NODE: async (prefix) => {
-		return (await nodeFileSystem.value).mkdtemp(prefix).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError);
-	},
+	NODE: async (prefix) => nodeFileSystem.value.mkdtemp(prefix).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleNodeMakeTemporaryDirectoryError),
 	DENO: (prefix) => Deno.makeTempDir({ prefix }).then((value) => DEither.right("file-system-make-temporary-directory", value)).catch(handleDenoMakeTemporaryDirectoryError)
 });
 //#endregion
-export { makeTemporaryDirectory };
+export { MakeTemporaryDirectoryError, MakeTemporaryDirectoryErrorInvalidArgument, MakeTemporaryDirectoryErrorNoSpace, MakeTemporaryDirectoryErrorNotDirectory, MakeTemporaryDirectoryErrorPermissionDenied, MakeTemporaryDirectoryErrorReadOnly, MakeTemporaryDirectoryErrorTooManyOpenFiles, makeTemporaryDirectory };