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

package/dist/file/stat.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/stat.ts
+var StatErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-not-found", Error) {};
+var StatErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-permission-denied", Error) {};
+var StatErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-not-directory", Error) {};
+var StatErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-too-many-open-files", Error) {};
+var StatErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-busy", Error) {};
+var StatError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-stat-error", Error) {};
 function handleNodeStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-stat-busy", error);
+	let statError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") statError = new StatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") statError = new StatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") statError = new StatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") statError = new StatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") statError = new StatErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-stat-error", error);
+	if (statError === void 0) statError = new StatError(error);
+	return _duplojs_lang_either.left("file-system-stat-error", statError);
 }
 function handleDenoStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-stat-busy", error);
-	return _duplojs_lang_either.left("file-system-stat-error", error);
+	let statError = void 0;
+	if (error instanceof Deno.errors.NotFound) statError = new StatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) statError = new StatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) statError = new StatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) statError = new StatErrorBusy(error);
+	if (statError === void 0) statError = new StatError(error);
+	return _duplojs_lang_either.left("file-system-stat-error", statError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -75,11 +85,15 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const stat = require_implementor.implementFunction("stat", {
-	NODE: async (path) => {
-		return (await require_implementor.nodeFileSystem.value).stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError);
-	},
+	NODE: async (path) => require_implementor.nodeFileSystem.value.stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError),
 	DENO: (path) => Deno.stat(path).then(_duplojs_lang_common.innerPipe(createStatInfoWithDeno, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleDenoStatError),
 	BUN: (path) => Bun.file(path).stat().then(_duplojs_lang_common.innerPipe(createStatInfoWithFsSource, (value) => _duplojs_lang_either.right("file-system-stat", value))).catch(handleNodeStatError)
 });
 //#endregion
+exports.StatError = StatError;
+exports.StatErrorBusy = StatErrorBusy;
+exports.StatErrorNotDirectory = StatErrorNotDirectory;
+exports.StatErrorNotFound = StatErrorNotFound;
+exports.StatErrorPermissionDenied = StatErrorPermissionDenied;
+exports.StatErrorTooManyOpenFiles = StatErrorTooManyOpenFiles;
 exports.stat = stat;

package/dist/file/stat.d.ts

@@ -1,4 +1,4 @@
-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";
 import * as DChrono from "@duplojs/lang/chrono";
@@ -33,10 +33,30 @@ export interface StatInfo {
     isFifo: boolean | null;
     isSocket: boolean | null;
 }
-export type StatResult = FileSystemEither<DEither.Right<"stat", StatInfo> | DEither.Left<"stat-not-found", unknown> | DEither.Left<"stat-permission-denied", unknown> | DEither.Left<"stat-not-directory", unknown> | DEither.Left<"stat-too-many-open-files", unknown> | DEither.Left<"stat-busy", unknown> | DEither.Left<"stat-error", unknown>>;
+declare const StatErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-not-found", unknown>>, unknown>;
+export declare class StatErrorNotFound extends StatErrorNotFound_base {
+}
+declare const StatErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-permission-denied", unknown>>, unknown>;
+export declare class StatErrorPermissionDenied extends StatErrorPermissionDenied_base {
+}
+declare const StatErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-not-directory", unknown>>, unknown>;
+export declare class StatErrorNotDirectory extends StatErrorNotDirectory_base {
+}
+declare const StatErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-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-stat-too-many-open-files", unknown>>, unknown>;
+export declare class StatErrorTooManyOpenFiles extends StatErrorTooManyOpenFiles_base {
+}
+declare const StatErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-busy", unknown>>, unknown>;
+export declare class StatErrorBusy extends StatErrorBusy_base {
+}
+declare const StatError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-stat-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-stat-error", unknown>>, unknown>;
+export declare class StatError extends StatError_base {
+}
+export type StatErrors = (StatErrorNotFound | StatErrorPermissionDenied | StatErrorNotDirectory | StatErrorTooManyOpenFiles | StatErrorBusy | StatError);
+export type StatResult = (DEither.Right<"file-system-stat", StatInfo> | DEither.Left<"file-system-stat-error", StatErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        stat(path: string & DPath.Path): Promise<StatResult>;
+        stat(path: DPath.AnyPath): Promise<StatResult>;
     }
 }
-export declare const stat: (path: string & DPath.Path) => Promise<StatResult>;
+export declare const stat: (path: DPath.AnyPath) => Promise<StatResult>;
+export {};

package/dist/file/stat.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/stat.ts
+var StatErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-stat-not-found", Error) {};
+var StatErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-stat-permission-denied", Error) {};
+var StatErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-stat-not-directory", Error) {};
+var StatErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-stat-too-many-open-files", Error) {};
+var StatErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-stat-busy", Error) {};
+var StatError = class extends DCommon.DuploJSError.parentClass("file-system-stat-error", Error) {};
 function handleNodeStatError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-stat-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-stat-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-stat-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-stat-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-stat-busy", error);
+	let statError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") statError = new StatErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") statError = new StatErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") statError = new StatErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") statError = new StatErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") statError = new StatErrorBusy(error);
 	}
-	return DEither.left("file-system-stat-error", error);
+	if (statError === void 0) statError = new StatError(error);
+	return DEither.left("file-system-stat-error", statError);
 }
 function handleDenoStatError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-stat-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-stat-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-stat-not-directory", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-stat-busy", error);
-	return DEither.left("file-system-stat-error", error);
+	let statError = void 0;
+	if (error instanceof Deno.errors.NotFound) statError = new StatErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) statError = new StatErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) statError = new StatErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) statError = new StatErrorBusy(error);
+	if (statError === void 0) statError = new StatError(error);
+	return DEither.left("file-system-stat-error", statError);
 }
 function createStatInfoWithFsSource(source) {
 	return {
@@ -71,11 +81,9 @@ function createStatInfoWithDeno(source) {
 	};
 }
 const stat = implementFunction("stat", {
-	NODE: async (path) => {
-		return (await nodeFileSystem.value).stat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-stat", value))).catch(handleNodeStatError);
-	},
+	NODE: async (path) => nodeFileSystem.value.stat(path).then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-stat", value))).catch(handleNodeStatError),
 	DENO: (path) => Deno.stat(path).then(DCommon.innerPipe(createStatInfoWithDeno, (value) => DEither.right("file-system-stat", value))).catch(handleDenoStatError),
 	BUN: (path) => Bun.file(path).stat().then(DCommon.innerPipe(createStatInfoWithFsSource, (value) => DEither.right("file-system-stat", value))).catch(handleNodeStatError)
 });
 //#endregion
-export { stat };
+export { StatError, StatErrorBusy, StatErrorNotDirectory, StatErrorNotFound, StatErrorPermissionDenied, StatErrorTooManyOpenFiles, stat };

package/dist/file/symlink.cjs

@@ -1,34 +1,47 @@
 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/symlink.ts
+var SymlinkErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-not-found", Error) {};
+var SymlinkErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-permission-denied", Error) {};
+var SymlinkErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-already-exists", Error) {};
+var SymlinkErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-not-directory", Error) {};
+var SymlinkErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-read-only", Error) {};
+var SymlinkErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-invalid-argument", Error) {};
+var SymlinkErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-too-many-open-files", Error) {};
+var SymlinkErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-busy", Error) {};
+var SymlinkError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-symlink-error", Error) {};
 function handleNodeSymlinkError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-symlink-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-symlink-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-symlink-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-symlink-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-symlink-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-symlink-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-symlink-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-symlink-busy", error);
+	let symlinkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") symlinkError = new SymlinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") symlinkError = new SymlinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") symlinkError = new SymlinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") symlinkError = new SymlinkErrorNotDirectory(error);
+		else if (error.code === "EROFS") symlinkError = new SymlinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") symlinkError = new SymlinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") symlinkError = new SymlinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") symlinkError = new SymlinkErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-symlink-error", error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return _duplojs_lang_either.left("file-system-symlink-error", symlinkError);
 }
 function handleDenoSymlinkError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-symlink-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-symlink-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-symlink-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-symlink-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-symlink-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-symlink-busy", error);
-	return _duplojs_lang_either.left("file-system-symlink-error", error);
+	let symlinkError = void 0;
+	if (error instanceof Deno.errors.NotFound) symlinkError = new SymlinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) symlinkError = new SymlinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) symlinkError = new SymlinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) symlinkError = new SymlinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) symlinkError = new SymlinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) symlinkError = new SymlinkErrorBusy(error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return _duplojs_lang_either.left("file-system-symlink-error", symlinkError);
 }
 const symlinkImplementation = require_implementor.implementFunction("symlink", {
-	NODE: async (oldPath, newPath, params) => {
-		return (await require_implementor.nodeFileSystem.value).symlink(oldPath, newPath, params?.type).then(() => _duplojs_lang_either.right("file-system-symlink")).catch(handleNodeSymlinkError);
-	},
+	NODE: async (oldPath, newPath, params) => require_implementor.nodeFileSystem.value.symlink(oldPath, newPath, params?.type).then(() => _duplojs_lang_either.right("file-system-symlink")).catch(handleNodeSymlinkError),
 	DENO: (oldPath, newPath, params) => Deno.symlink(oldPath, newPath, params).then(() => _duplojs_lang_either.right("file-system-symlink")).catch(handleDenoSymlinkError)
 });
 function symlink(...args) {
@@ -39,4 +52,13 @@ function symlink(...args) {
 	return symlinkImplementation(...args);
 }
 //#endregion
+exports.SymlinkError = SymlinkError;
+exports.SymlinkErrorAlreadyExists = SymlinkErrorAlreadyExists;
+exports.SymlinkErrorBusy = SymlinkErrorBusy;
+exports.SymlinkErrorInvalidArgument = SymlinkErrorInvalidArgument;
+exports.SymlinkErrorNotDirectory = SymlinkErrorNotDirectory;
+exports.SymlinkErrorNotFound = SymlinkErrorNotFound;
+exports.SymlinkErrorPermissionDenied = SymlinkErrorPermissionDenied;
+exports.SymlinkErrorReadOnly = SymlinkErrorReadOnly;
+exports.SymlinkErrorTooManyOpenFiles = SymlinkErrorTooManyOpenFiles;
 exports.symlink = symlink;

package/dist/file/symlink.d.ts

@@ -1,4 +1,4 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 export interface SymlinkParams {
@@ -9,11 +9,40 @@ export interface SymlinkParams {
      */
     type: "file" | "dir" | "junction";
 }
-export type SymlinkResult = FileSystemEither<DEither.Right<"symlink", void> | DEither.Left<"symlink-not-found", unknown> | DEither.Left<"symlink-permission-denied", unknown> | DEither.Left<"symlink-already-exists", unknown> | DEither.Left<"symlink-not-directory", unknown> | DEither.Left<"symlink-read-only", unknown> | DEither.Left<"symlink-invalid-argument", unknown> | DEither.Left<"symlink-too-many-open-files", unknown> | DEither.Left<"symlink-busy", unknown> | DEither.Left<"symlink-error", unknown>>;
+declare const SymlinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-found", unknown>>, unknown>;
+export declare class SymlinkErrorNotFound extends SymlinkErrorNotFound_base {
+}
+declare const SymlinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-permission-denied", unknown>>, unknown>;
+export declare class SymlinkErrorPermissionDenied extends SymlinkErrorPermissionDenied_base {
+}
+declare const SymlinkErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-already-exists", unknown>>, unknown>;
+export declare class SymlinkErrorAlreadyExists extends SymlinkErrorAlreadyExists_base {
+}
+declare const SymlinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-not-directory", unknown>>, unknown>;
+export declare class SymlinkErrorNotDirectory extends SymlinkErrorNotDirectory_base {
+}
+declare const SymlinkErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-read-only", unknown>>, unknown>;
+export declare class SymlinkErrorReadOnly extends SymlinkErrorReadOnly_base {
+}
+declare const SymlinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-invalid-argument", unknown>>, unknown>;
+export declare class SymlinkErrorInvalidArgument extends SymlinkErrorInvalidArgument_base {
+}
+declare const SymlinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-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-symlink-too-many-open-files", unknown>>, unknown>;
+export declare class SymlinkErrorTooManyOpenFiles extends SymlinkErrorTooManyOpenFiles_base {
+}
+declare const SymlinkErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-busy", unknown>>, unknown>;
+export declare class SymlinkErrorBusy extends SymlinkErrorBusy_base {
+}
+declare const SymlinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-symlink-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-symlink-error", unknown>>, unknown>;
+export declare class SymlinkError extends SymlinkError_base {
+}
+export type SymlinkErrors = (SymlinkErrorNotFound | SymlinkErrorPermissionDenied | SymlinkErrorAlreadyExists | SymlinkErrorNotDirectory | SymlinkErrorReadOnly | SymlinkErrorInvalidArgument | SymlinkErrorTooManyOpenFiles | SymlinkErrorBusy | SymlinkError);
+export type SymlinkResult = (DEither.Right<"file-system-symlink", void> | DEither.Left<"file-system-symlink-error", SymlinkErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
+        symlink(oldPath: DPath.AnyPath, newPath: DPath.AnyPath, params?: SymlinkParams): Promise<SymlinkResult>;
     }
 }
-export declare function symlink(newPath: string & DPath.Path): (oldPath: string & DPath.Path) => Promise<SymlinkResult>;
-export declare function symlink(oldPath: string & DPath.Path, newPath: string & DPath.Path, params?: SymlinkParams): Promise<SymlinkResult>;
+export declare function symlink(newPath: DPath.AnyPath): (oldPath: DPath.AnyPath) => Promise<SymlinkResult>;
+export declare function symlink(oldPath: DPath.AnyPath, newPath: DPath.AnyPath, params?: SymlinkParams): Promise<SymlinkResult>;
+export {};

package/dist/file/symlink.mjs

@@ -1,32 +1,44 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/symlink.ts
+var SymlinkErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-symlink-not-found", Error) {};
+var SymlinkErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-symlink-permission-denied", Error) {};
+var SymlinkErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-symlink-already-exists", Error) {};
+var SymlinkErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-symlink-not-directory", Error) {};
+var SymlinkErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-symlink-read-only", Error) {};
+var SymlinkErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-symlink-invalid-argument", Error) {};
+var SymlinkErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-symlink-too-many-open-files", Error) {};
+var SymlinkErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-symlink-busy", Error) {};
+var SymlinkError = class extends DCommon.DuploJSError.parentClass("file-system-symlink-error", Error) {};
 function handleNodeSymlinkError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-symlink-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-symlink-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-symlink-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-symlink-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-symlink-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-symlink-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-symlink-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-symlink-busy", error);
+	let symlinkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") symlinkError = new SymlinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") symlinkError = new SymlinkErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") symlinkError = new SymlinkErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") symlinkError = new SymlinkErrorNotDirectory(error);
+		else if (error.code === "EROFS") symlinkError = new SymlinkErrorReadOnly(error);
+		else if (error.code === "EINVAL") symlinkError = new SymlinkErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") symlinkError = new SymlinkErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") symlinkError = new SymlinkErrorBusy(error);
 	}
-	return DEither.left("file-system-symlink-error", error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return DEither.left("file-system-symlink-error", symlinkError);
 }
 function handleDenoSymlinkError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-symlink-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-symlink-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-symlink-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-symlink-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-symlink-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-symlink-busy", error);
-	return DEither.left("file-system-symlink-error", error);
+	let symlinkError = void 0;
+	if (error instanceof Deno.errors.NotFound) symlinkError = new SymlinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) symlinkError = new SymlinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) symlinkError = new SymlinkErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) symlinkError = new SymlinkErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) symlinkError = new SymlinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) symlinkError = new SymlinkErrorBusy(error);
+	if (symlinkError === void 0) symlinkError = new SymlinkError(error);
+	return DEither.left("file-system-symlink-error", symlinkError);
 }
 const symlinkImplementation = implementFunction("symlink", {
-	NODE: async (oldPath, newPath, params) => {
-		return (await nodeFileSystem.value).symlink(oldPath, newPath, params?.type).then(() => DEither.right("file-system-symlink")).catch(handleNodeSymlinkError);
-	},
+	NODE: async (oldPath, newPath, params) => nodeFileSystem.value.symlink(oldPath, newPath, params?.type).then(() => DEither.right("file-system-symlink")).catch(handleNodeSymlinkError),
 	DENO: (oldPath, newPath, params) => Deno.symlink(oldPath, newPath, params).then(() => DEither.right("file-system-symlink")).catch(handleDenoSymlinkError)
 });
 function symlink(...args) {
@@ -37,4 +49,4 @@ function symlink(...args) {
 	return symlinkImplementation(...args);
 }
 //#endregion
-export { symlink };
+export { SymlinkError, SymlinkErrorAlreadyExists, SymlinkErrorBusy, SymlinkErrorInvalidArgument, SymlinkErrorNotDirectory, SymlinkErrorNotFound, SymlinkErrorPermissionDenied, SymlinkErrorReadOnly, SymlinkErrorTooManyOpenFiles, symlink };

package/dist/file/truncate.cjs

@@ -5,34 +5,56 @@ _duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 //#region scripts/file/truncate.ts
+var TruncateErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-not-found", Error) {};
+var TruncateErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-permission-denied", Error) {};
+var TruncateErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-is-directory", Error) {};
+var TruncateErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-not-directory", Error) {};
+var TruncateErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-no-space", Error) {};
+var TruncateErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-read-only", Error) {};
+var TruncateErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-invalid-argument", Error) {};
+var TruncateErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-too-many-open-files", Error) {};
+var TruncateErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-busy", Error) {};
+var TruncateError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-truncate-error", Error) {};
 function handleNodeTruncateError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-truncate-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-truncate-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-truncate-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-truncate-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-truncate-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-truncate-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-truncate-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-truncate-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-truncate-busy", error);
+	let truncateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") truncateError = new TruncateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") truncateError = new TruncateErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") truncateError = new TruncateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") truncateError = new TruncateErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") truncateError = new TruncateErrorNoSpace(error);
+		else if (error.code === "EROFS") truncateError = new TruncateErrorReadOnly(error);
+		else if (error.code === "EINVAL") truncateError = new TruncateErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") truncateError = new TruncateErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") truncateError = new TruncateErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-truncate-error", error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return _duplojs_lang_either.left("file-system-truncate-error", truncateError);
 }
 function handleDenoTruncateError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-truncate-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-truncate-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-truncate-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-truncate-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-truncate-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-truncate-busy", error);
-	return _duplojs_lang_either.left("file-system-truncate-error", error);
+	let truncateError = void 0;
+	if (error instanceof Deno.errors.NotFound) truncateError = new TruncateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) truncateError = new TruncateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) truncateError = new TruncateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) truncateError = new TruncateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) truncateError = new TruncateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) truncateError = new TruncateErrorBusy(error);
+	if (truncateError === void 0) truncateError = new TruncateError(error);
+	return _duplojs_lang_either.left("file-system-truncate-error", truncateError);
 }
 const truncate = require_implementor.implementFunction("truncate", {
-	NODE: async (path, size) => {
-		return (await require_implementor.nodeFileSystem.value).truncate(path, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleNodeTruncateError);
-	},
+	NODE: async (path, size) => require_implementor.nodeFileSystem.value.truncate(path, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleNodeTruncateError),
 	DENO: (path, size) => _duplojs_lang_common.pipe(path, _duplojs_lang_common.when(_duplojs_lang_common.instanceOf(URL), ({ pathname }) => decodeURIComponent(pathname)), (stringPath) => Deno.truncate(stringPath, size).then(() => _duplojs_lang_either.right("file-system-truncate")).catch(handleDenoTruncateError))
 });
 //#endregion
+exports.TruncateError = TruncateError;
+exports.TruncateErrorBusy = TruncateErrorBusy;
+exports.TruncateErrorInvalidArgument = TruncateErrorInvalidArgument;
+exports.TruncateErrorIsDirectory = TruncateErrorIsDirectory;
+exports.TruncateErrorNoSpace = TruncateErrorNoSpace;
+exports.TruncateErrorNotDirectory = TruncateErrorNotDirectory;
+exports.TruncateErrorNotFound = TruncateErrorNotFound;
+exports.TruncateErrorPermissionDenied = TruncateErrorPermissionDenied;
+exports.TruncateErrorReadOnly = TruncateErrorReadOnly;
+exports.TruncateErrorTooManyOpenFiles = TruncateErrorTooManyOpenFiles;
 exports.truncate = truncate;

package/dist/file/truncate.d.ts

@@ -1,10 +1,42 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type TruncateResult = FileSystemEither<DEither.Right<"truncate", void> | DEither.Left<"truncate-not-found", unknown> | DEither.Left<"truncate-permission-denied", unknown> | DEither.Left<"truncate-is-directory", unknown> | DEither.Left<"truncate-not-directory", unknown> | DEither.Left<"truncate-no-space", unknown> | DEither.Left<"truncate-read-only", unknown> | DEither.Left<"truncate-invalid-argument", unknown> | DEither.Left<"truncate-too-many-open-files", unknown> | DEither.Left<"truncate-busy", unknown> | DEither.Left<"truncate-error", unknown>>;
+declare const TruncateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-found", unknown>>, unknown>;
+export declare class TruncateErrorNotFound extends TruncateErrorNotFound_base {
+}
+declare const TruncateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-permission-denied", unknown>>, unknown>;
+export declare class TruncateErrorPermissionDenied extends TruncateErrorPermissionDenied_base {
+}
+declare const TruncateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-is-directory", unknown>>, unknown>;
+export declare class TruncateErrorIsDirectory extends TruncateErrorIsDirectory_base {
+}
+declare const TruncateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-not-directory", unknown>>, unknown>;
+export declare class TruncateErrorNotDirectory extends TruncateErrorNotDirectory_base {
+}
+declare const TruncateErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-no-space", unknown>>, unknown>;
+export declare class TruncateErrorNoSpace extends TruncateErrorNoSpace_base {
+}
+declare const TruncateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-read-only", unknown>>, unknown>;
+export declare class TruncateErrorReadOnly extends TruncateErrorReadOnly_base {
+}
+declare const TruncateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-invalid-argument", unknown>>, unknown>;
+export declare class TruncateErrorInvalidArgument extends TruncateErrorInvalidArgument_base {
+}
+declare const TruncateErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-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-truncate-too-many-open-files", unknown>>, unknown>;
+export declare class TruncateErrorTooManyOpenFiles extends TruncateErrorTooManyOpenFiles_base {
+}
+declare const TruncateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-busy", unknown>>, unknown>;
+export declare class TruncateErrorBusy extends TruncateErrorBusy_base {
+}
+declare const TruncateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-truncate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-truncate-error", unknown>>, unknown>;
+export declare class TruncateError extends TruncateError_base {
+}
+export type TruncateErrors = (TruncateErrorNotFound | TruncateErrorPermissionDenied | TruncateErrorIsDirectory | TruncateErrorNotDirectory | TruncateErrorNoSpace | TruncateErrorReadOnly | TruncateErrorInvalidArgument | TruncateErrorTooManyOpenFiles | TruncateErrorBusy | TruncateError);
+export type TruncateResult = (DEither.Right<"file-system-truncate", void> | DEither.Left<"file-system-truncate-error", TruncateErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        truncate(path: string & DPath.Path, size?: number): Promise<TruncateResult>;
+        truncate(path: DPath.AnyPath, size?: number): Promise<TruncateResult>;
     }
 }
-export declare const truncate: (path: string & DPath.Path, size?: number) => Promise<TruncateResult>;
+export declare const truncate: (path: DPath.AnyPath, size?: number) => Promise<TruncateResult>;
+export {};