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

package/dist/file/makeTemporaryFile.cjs

@@ -7,34 +7,43 @@ _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 //#region scripts/file/makeTemporaryFile.ts
+var MakeTemporaryFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-permission-denied", Error) {};
+var MakeTemporaryFileErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-already-exists", Error) {};
+var MakeTemporaryFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-not-directory", Error) {};
+var MakeTemporaryFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-no-space", Error) {};
+var MakeTemporaryFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-read-only", Error) {};
+var MakeTemporaryFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-invalid-argument", Error) {};
+var MakeTemporaryFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-too-many-open-files", Error) {};
+var MakeTemporaryFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-make-temporary-file-error", Error) {};
 function handleNodeMakeTemporaryFileError(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-file-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-make-temporary-file-already-exists", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-make-temporary-file-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-make-temporary-file-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-make-temporary-file-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-make-temporary-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-make-temporary-file-too-many-open-files", error);
+	let makeTemporaryFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryFileError = new MakeTemporaryFileErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryFileError = new MakeTemporaryFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryFileError = new MakeTemporaryFileErrorTooManyOpenFiles(error);
 	}
-	return _duplojs_lang_either.left("file-system-make-temporary-file-error", error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 function handleDenoMakeTemporaryFileError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-make-temporary-file-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-make-temporary-file-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-make-temporary-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-make-temporary-file-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-make-temporary-file-error", error);
+	let makeTemporaryFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return _duplojs_lang_either.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 const makeTemporaryFile = require_implementor.implementFunction("makeTemporaryFile", {
 	NODE: async (prefix, suffix) => {
-		const fs = await require_implementor.nodeFileSystem.value;
-		const os = await require_implementor.nodeOs.value;
-		const crypto = await require_implementor.nodeCrypto.value;
-		const tempPath = _duplojs_lang_common.forwardAsserts(os.tmpdir(), _duplojs_lang_path.is);
-		const fileName = _duplojs_lang_common.forwardAsserts(`${prefix}${crypto.randomUUID()}${suffix ?? ""}`, _duplojs_lang_path.isSegment);
+		const tempPath = _duplojs_lang_common.forwardAsserts(require_implementor.nodeOs.value.tmpdir(), _duplojs_lang_path.is);
+		const fileName = _duplojs_lang_common.forwardAsserts(`${prefix}${require_implementor.nodeCrypto.value.randomUUID()}${suffix ?? ""}`, _duplojs_lang_path.isSegment);
 		const fileTemporaryPath = _duplojs_lang_path.resolveRelative([tempPath, fileName]);
-		return fs.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
+		return require_implementor.nodeFileSystem.value.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => _duplojs_lang_either.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
 	},
 	DENO: (prefix, suffix) => Deno.makeTempFile({
 		prefix,
@@ -42,4 +51,12 @@ const makeTemporaryFile = require_implementor.implementFunction("makeTemporaryFi
 	}).then((value) => _duplojs_lang_either.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
 });
 //#endregion
+exports.MakeTemporaryFileError = MakeTemporaryFileError;
+exports.MakeTemporaryFileErrorAlreadyExists = MakeTemporaryFileErrorAlreadyExists;
+exports.MakeTemporaryFileErrorInvalidArgument = MakeTemporaryFileErrorInvalidArgument;
+exports.MakeTemporaryFileErrorNoSpace = MakeTemporaryFileErrorNoSpace;
+exports.MakeTemporaryFileErrorNotDirectory = MakeTemporaryFileErrorNotDirectory;
+exports.MakeTemporaryFileErrorPermissionDenied = MakeTemporaryFileErrorPermissionDenied;
+exports.MakeTemporaryFileErrorReadOnly = MakeTemporaryFileErrorReadOnly;
+exports.MakeTemporaryFileErrorTooManyOpenFiles = MakeTemporaryFileErrorTooManyOpenFiles;
 exports.makeTemporaryFile = makeTemporaryFile;

package/dist/file/makeTemporaryFile.d.ts

@@ -1,10 +1,36 @@
-import { FileSystemEither } from './types';
+import * as DCommon from "@duplojs/lang/common";
 import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type MakeTemporaryFileResult = FileSystemEither<DEither.Right<"make-temporary-file", string> | DEither.Left<"make-temporary-file-permission-denied", unknown> | DEither.Left<"make-temporary-file-already-exists", unknown> | DEither.Left<"make-temporary-file-not-directory", unknown> | DEither.Left<"make-temporary-file-no-space", unknown> | DEither.Left<"make-temporary-file-read-only", unknown> | DEither.Left<"make-temporary-file-invalid-argument", unknown> | DEither.Left<"make-temporary-file-too-many-open-files", unknown> | DEither.Left<"make-temporary-file-error", unknown>>;
+declare const MakeTemporaryFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-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-file-permission-denied", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorPermissionDenied extends MakeTemporaryFileErrorPermissionDenied_base {
+}
+declare const MakeTemporaryFileErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-already-exists", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorAlreadyExists extends MakeTemporaryFileErrorAlreadyExists_base {
+}
+declare const MakeTemporaryFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-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-file-not-directory", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorNotDirectory extends MakeTemporaryFileErrorNotDirectory_base {
+}
+declare const MakeTemporaryFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-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-file-no-space", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorNoSpace extends MakeTemporaryFileErrorNoSpace_base {
+}
+declare const MakeTemporaryFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-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-file-read-only", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorReadOnly extends MakeTemporaryFileErrorReadOnly_base {
+}
+declare const MakeTemporaryFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-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-file-invalid-argument", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorInvalidArgument extends MakeTemporaryFileErrorInvalidArgument_base {
+}
+declare const MakeTemporaryFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-too-many-open-files", unknown>>, unknown>;
+export declare class MakeTemporaryFileErrorTooManyOpenFiles extends MakeTemporaryFileErrorTooManyOpenFiles_base {
+}
+declare const MakeTemporaryFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-make-temporary-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-make-temporary-file-error", unknown>>, unknown>;
+export declare class MakeTemporaryFileError extends MakeTemporaryFileError_base {
+}
+export type MakeTemporaryFileErrors = (MakeTemporaryFileErrorPermissionDenied | MakeTemporaryFileErrorAlreadyExists | MakeTemporaryFileErrorNotDirectory | MakeTemporaryFileErrorNoSpace | MakeTemporaryFileErrorReadOnly | MakeTemporaryFileErrorInvalidArgument | MakeTemporaryFileErrorTooManyOpenFiles | MakeTemporaryFileError);
+export type MakeTemporaryFileResult = (DEither.Right<"file-system-make-temporary-file", string> | DEither.Left<"file-system-make-temporary-file-error", MakeTemporaryFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
         makeTemporaryFile(prefix: string & DPath.Segment, suffix?: string & DPath.Segment): Promise<MakeTemporaryFileResult>;
     }
 }
 export declare const makeTemporaryFile: (prefix: string & DPath.Segment, suffix?: string & DPath.Segment) => Promise<MakeTemporaryFileResult>;
+export {};

package/dist/file/makeTemporaryFile.mjs

@@ -3,34 +3,43 @@ import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DPath from "@duplojs/lang/path";
 //#region scripts/file/makeTemporaryFile.ts
+var MakeTemporaryFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-permission-denied", Error) {};
+var MakeTemporaryFileErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-already-exists", Error) {};
+var MakeTemporaryFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-not-directory", Error) {};
+var MakeTemporaryFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-no-space", Error) {};
+var MakeTemporaryFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-read-only", Error) {};
+var MakeTemporaryFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-invalid-argument", Error) {};
+var MakeTemporaryFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-too-many-open-files", Error) {};
+var MakeTemporaryFileError = class extends DCommon.DuploJSError.parentClass("file-system-make-temporary-file-error", Error) {};
 function handleNodeMakeTemporaryFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-make-temporary-file-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-make-temporary-file-already-exists", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-make-temporary-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-make-temporary-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-make-temporary-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-make-temporary-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-make-temporary-file-too-many-open-files", error);
+	let makeTemporaryFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "EACCES" || error.code === "EPERM") makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+		else if (error.code === "ENOTDIR") makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") makeTemporaryFileError = new MakeTemporaryFileErrorNoSpace(error);
+		else if (error.code === "EROFS") makeTemporaryFileError = new MakeTemporaryFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") makeTemporaryFileError = new MakeTemporaryFileErrorTooManyOpenFiles(error);
 	}
-	return DEither.left("file-system-make-temporary-file-error", error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return DEither.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 function handleDenoMakeTemporaryFileError(error) {
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-make-temporary-file-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-make-temporary-file-already-exists", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-make-temporary-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-make-temporary-file-invalid-argument", error);
-	return DEither.left("file-system-make-temporary-file-error", error);
+	let makeTemporaryFileError = void 0;
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) makeTemporaryFileError = new MakeTemporaryFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) makeTemporaryFileError = new MakeTemporaryFileErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.NotADirectory) makeTemporaryFileError = new MakeTemporaryFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) makeTemporaryFileError = new MakeTemporaryFileErrorInvalidArgument(error);
+	if (makeTemporaryFileError === void 0) makeTemporaryFileError = new MakeTemporaryFileError(error);
+	return DEither.left("file-system-make-temporary-file-error", makeTemporaryFileError);
 }
 const makeTemporaryFile = implementFunction("makeTemporaryFile", {
 	NODE: async (prefix, suffix) => {
-		const fs = await nodeFileSystem.value;
-		const os = await nodeOs.value;
-		const crypto = await nodeCrypto.value;
-		const tempPath = DCommon.forwardAsserts(os.tmpdir(), DPath.is);
-		const fileName = DCommon.forwardAsserts(`${prefix}${crypto.randomUUID()}${suffix ?? ""}`, DPath.isSegment);
+		const tempPath = DCommon.forwardAsserts(nodeOs.value.tmpdir(), DPath.is);
+		const fileName = DCommon.forwardAsserts(`${prefix}${nodeCrypto.value.randomUUID()}${suffix ?? ""}`, DPath.isSegment);
 		const fileTemporaryPath = DPath.resolveRelative([tempPath, fileName]);
-		return fs.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => DEither.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
+		return nodeFileSystem.value.open(fileTemporaryPath, "wx").then((fh) => fh.close()).then(() => DEither.right("file-system-make-temporary-file", fileTemporaryPath)).catch(handleNodeMakeTemporaryFileError);
 	},
 	DENO: (prefix, suffix) => Deno.makeTempFile({
 		prefix,
@@ -38,4 +47,4 @@ const makeTemporaryFile = implementFunction("makeTemporaryFile", {
 	}).then((value) => DEither.right("file-system-make-temporary-file", value)).catch(handleDenoMakeTemporaryFileError)
 });
 //#endregion
-export { makeTemporaryFile };
+export { MakeTemporaryFileError, MakeTemporaryFileErrorAlreadyExists, MakeTemporaryFileErrorInvalidArgument, MakeTemporaryFileErrorNoSpace, MakeTemporaryFileErrorNotDirectory, MakeTemporaryFileErrorPermissionDenied, MakeTemporaryFileErrorReadOnly, MakeTemporaryFileErrorTooManyOpenFiles, makeTemporaryFile };

package/dist/file/move.cjs

@@ -1,37 +1,52 @@
 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/move.ts
+var MoveErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-not-found", Error) {};
+var MoveErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-permission-denied", Error) {};
+var MoveErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-already-exists", Error) {};
+var MoveErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-is-directory", Error) {};
+var MoveErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-not-directory", Error) {};
+var MoveErrorDirectoryNotEmpty = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-directory-not-empty", Error) {};
+var MoveErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-read-only", Error) {};
+var MoveErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-invalid-argument", Error) {};
+var MoveErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-busy", Error) {};
+var MoveErrorCrossDevice = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-cross-device", Error) {};
+var MoveError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-move-error", Error) {};
 function handleNodeMoveError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-move-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-move-permission-denied", error);
-		else if (error.code === "EEXIST") return _duplojs_lang_either.left("file-system-move-already-exists", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-move-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-move-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return _duplojs_lang_either.left("file-system-move-directory-not-empty", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-move-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-move-invalid-argument", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-move-busy", error);
-		else if (error.code === "EXDEV") return _duplojs_lang_either.left("file-system-move-cross-device", error);
+	let moveError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") moveError = new MoveErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") moveError = new MoveErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") moveError = new MoveErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") moveError = new MoveErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") moveError = new MoveErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") moveError = new MoveErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") moveError = new MoveErrorReadOnly(error);
+		else if (error.code === "EINVAL") moveError = new MoveErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") moveError = new MoveErrorBusy(error);
+		else if (error.code === "EXDEV") moveError = new MoveErrorCrossDevice(error);
 	}
-	return _duplojs_lang_either.left("file-system-move-error", error);
+	if (moveError === void 0) moveError = new MoveError(error);
+	return _duplojs_lang_either.left("file-system-move-error", moveError);
 }
 function handleDenoMoveError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-move-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-move-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return _duplojs_lang_either.left("file-system-move-already-exists", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-move-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-move-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-move-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-move-busy", error);
-	return _duplojs_lang_either.left("file-system-move-error", error);
+	let moveError = void 0;
+	if (error instanceof Deno.errors.NotFound) moveError = new MoveErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) moveError = new MoveErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) moveError = new MoveErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) moveError = new MoveErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) moveError = new MoveErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) moveError = new MoveErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) moveError = new MoveErrorBusy(error);
+	if (moveError === void 0) moveError = new MoveError(error);
+	return _duplojs_lang_either.left("file-system-move-error", moveError);
 }
 const moveImplementation = require_implementor.implementFunction("move", {
-	NODE: async (fromPath, toPath) => {
-		return (await require_implementor.nodeFileSystem.value).rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleNodeMoveError);
-	},
+	NODE: async (fromPath, toPath) => require_implementor.nodeFileSystem.value.rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleNodeMoveError),
 	DENO: (fromPath, toPath) => Deno.rename(fromPath, toPath).then(() => _duplojs_lang_either.right("file-system-move")).catch(handleDenoMoveError)
 });
 function move(...args) {
@@ -42,4 +57,15 @@ function move(...args) {
 	return moveImplementation(...args);
 }
 //#endregion
+exports.MoveError = MoveError;
+exports.MoveErrorAlreadyExists = MoveErrorAlreadyExists;
+exports.MoveErrorBusy = MoveErrorBusy;
+exports.MoveErrorCrossDevice = MoveErrorCrossDevice;
+exports.MoveErrorDirectoryNotEmpty = MoveErrorDirectoryNotEmpty;
+exports.MoveErrorInvalidArgument = MoveErrorInvalidArgument;
+exports.MoveErrorIsDirectory = MoveErrorIsDirectory;
+exports.MoveErrorNotDirectory = MoveErrorNotDirectory;
+exports.MoveErrorNotFound = MoveErrorNotFound;
+exports.MoveErrorPermissionDenied = MoveErrorPermissionDenied;
+exports.MoveErrorReadOnly = MoveErrorReadOnly;
 exports.move = move;

package/dist/file/move.d.ts

@@ -1,11 +1,46 @@
-import { FileSystemEither } from './types';
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
-export type MoveResult = FileSystemEither<DEither.Right<"move", void> | DEither.Left<"move-not-found", unknown> | DEither.Left<"move-permission-denied", unknown> | DEither.Left<"move-already-exists", unknown> | DEither.Left<"move-is-directory", unknown> | DEither.Left<"move-not-directory", unknown> | DEither.Left<"move-directory-not-empty", unknown> | DEither.Left<"move-read-only", unknown> | DEither.Left<"move-invalid-argument", unknown> | DEither.Left<"move-busy", unknown> | DEither.Left<"move-cross-device", unknown> | DEither.Left<"move-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const MoveErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-not-found", unknown>>, unknown>;
+export declare class MoveErrorNotFound extends MoveErrorNotFound_base {
+}
+declare const MoveErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-permission-denied", unknown>>, unknown>;
+export declare class MoveErrorPermissionDenied extends MoveErrorPermissionDenied_base {
+}
+declare const MoveErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-already-exists", unknown>>, unknown>;
+export declare class MoveErrorAlreadyExists extends MoveErrorAlreadyExists_base {
+}
+declare const MoveErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-is-directory", unknown>>, unknown>;
+export declare class MoveErrorIsDirectory extends MoveErrorIsDirectory_base {
+}
+declare const MoveErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-not-directory", unknown>>, unknown>;
+export declare class MoveErrorNotDirectory extends MoveErrorNotDirectory_base {
+}
+declare const MoveErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-directory-not-empty", unknown>>, unknown>;
+export declare class MoveErrorDirectoryNotEmpty extends MoveErrorDirectoryNotEmpty_base {
+}
+declare const MoveErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-read-only", unknown>>, unknown>;
+export declare class MoveErrorReadOnly extends MoveErrorReadOnly_base {
+}
+declare const MoveErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-invalid-argument", unknown>>, unknown>;
+export declare class MoveErrorInvalidArgument extends MoveErrorInvalidArgument_base {
+}
+declare const MoveErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-busy", unknown>>, unknown>;
+export declare class MoveErrorBusy extends MoveErrorBusy_base {
+}
+declare const MoveErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-cross-device", unknown>>, unknown>;
+export declare class MoveErrorCrossDevice extends MoveErrorCrossDevice_base {
+}
+declare const MoveError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-move-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-move-error", unknown>>, unknown>;
+export declare class MoveError extends MoveError_base {
+}
+export type MoveErrors = (MoveErrorNotFound | MoveErrorPermissionDenied | MoveErrorAlreadyExists | MoveErrorIsDirectory | MoveErrorNotDirectory | MoveErrorDirectoryNotEmpty | MoveErrorReadOnly | MoveErrorInvalidArgument | MoveErrorBusy | MoveErrorCrossDevice | MoveError);
+export type MoveResult = (DEither.Right<"file-system-move", void> | DEither.Left<"file-system-move-error", MoveErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        move(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<MoveResult>;
+        move(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<MoveResult>;
     }
 }
-export declare function move(toPath: string & DPath.Path): (fromPath: string & DPath.Path) => Promise<MoveResult>;
-export declare function move(fromPath: string & DPath.Path, toPath: string & DPath.Path): Promise<MoveResult>;
+export declare function move(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<MoveResult>;
+export declare function move(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<MoveResult>;
+export {};

package/dist/file/move.mjs

@@ -1,35 +1,49 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/move.ts
+var MoveErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-move-not-found", Error) {};
+var MoveErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-move-permission-denied", Error) {};
+var MoveErrorAlreadyExists = class extends DCommon.DuploJSError.parentClass("file-system-move-already-exists", Error) {};
+var MoveErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-move-is-directory", Error) {};
+var MoveErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-move-not-directory", Error) {};
+var MoveErrorDirectoryNotEmpty = class extends DCommon.DuploJSError.parentClass("file-system-move-directory-not-empty", Error) {};
+var MoveErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-move-read-only", Error) {};
+var MoveErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-move-invalid-argument", Error) {};
+var MoveErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-move-busy", Error) {};
+var MoveErrorCrossDevice = class extends DCommon.DuploJSError.parentClass("file-system-move-cross-device", Error) {};
+var MoveError = class extends DCommon.DuploJSError.parentClass("file-system-move-error", Error) {};
 function handleNodeMoveError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-move-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-move-permission-denied", error);
-		else if (error.code === "EEXIST") return DEither.left("file-system-move-already-exists", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-move-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-move-not-directory", error);
-		else if (error.code === "ENOTEMPTY") return DEither.left("file-system-move-directory-not-empty", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-move-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-move-invalid-argument", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-move-busy", error);
-		else if (error.code === "EXDEV") return DEither.left("file-system-move-cross-device", error);
+	let moveError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") moveError = new MoveErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") moveError = new MoveErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") moveError = new MoveErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") moveError = new MoveErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") moveError = new MoveErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") moveError = new MoveErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") moveError = new MoveErrorReadOnly(error);
+		else if (error.code === "EINVAL") moveError = new MoveErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") moveError = new MoveErrorBusy(error);
+		else if (error.code === "EXDEV") moveError = new MoveErrorCrossDevice(error);
 	}
-	return DEither.left("file-system-move-error", error);
+	if (moveError === void 0) moveError = new MoveError(error);
+	return DEither.left("file-system-move-error", moveError);
 }
 function handleDenoMoveError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-move-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-move-permission-denied", error);
-	if (error instanceof Deno.errors.AlreadyExists) return DEither.left("file-system-move-already-exists", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-move-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-move-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-move-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-move-busy", error);
-	return DEither.left("file-system-move-error", error);
+	let moveError = void 0;
+	if (error instanceof Deno.errors.NotFound) moveError = new MoveErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) moveError = new MoveErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) moveError = new MoveErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) moveError = new MoveErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) moveError = new MoveErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) moveError = new MoveErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) moveError = new MoveErrorBusy(error);
+	if (moveError === void 0) moveError = new MoveError(error);
+	return DEither.left("file-system-move-error", moveError);
 }
 const moveImplementation = implementFunction("move", {
-	NODE: async (fromPath, toPath) => {
-		return (await nodeFileSystem.value).rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleNodeMoveError);
-	},
+	NODE: async (fromPath, toPath) => nodeFileSystem.value.rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleNodeMoveError),
 	DENO: (fromPath, toPath) => Deno.rename(fromPath, toPath).then(() => DEither.right("file-system-move")).catch(handleDenoMoveError)
 });
 function move(...args) {
@@ -40,4 +54,4 @@ function move(...args) {
 	return moveImplementation(...args);
 }
 //#endregion
-export { move };
+export { MoveError, MoveErrorAlreadyExists, MoveErrorBusy, MoveErrorCrossDevice, MoveErrorDirectoryNotEmpty, MoveErrorInvalidArgument, MoveErrorIsDirectory, MoveErrorNotDirectory, MoveErrorNotFound, MoveErrorPermissionDenied, MoveErrorReadOnly, move };

package/dist/file/readDirectory.cjs

@@ -1,20 +1,44 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_implementor = require("../implementor.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("../common/getCurrentWorkDirectoryOrThrow.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
 let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
 //#region scripts/file/readDirectory.ts
+var ReadDirectoryErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-not-found", Error) {};
+var ReadDirectoryErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-permission-denied", Error) {};
+var ReadDirectoryErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-not-directory", Error) {};
+var ReadDirectoryErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-too-many-open-files", Error) {};
+var ReadDirectoryErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-busy", Error) {};
+var ReadDirectoryError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-directory-error", Error) {};
 function handleNodeReadDirectoryError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-read-directory-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-read-directory-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-read-directory-not-directory", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-read-directory-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-read-directory-busy", error);
+	let readDirectoryError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readDirectoryError = new ReadDirectoryErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readDirectoryError = new ReadDirectoryErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") readDirectoryError = new ReadDirectoryErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readDirectoryError = new ReadDirectoryErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readDirectoryError = new ReadDirectoryErrorBusy(error);
 	}
-	return _duplojs_lang_either.left("file-system-read-directory-error", error);
+	if (readDirectoryError === void 0) readDirectoryError = new ReadDirectoryError(error);
+	return _duplojs_lang_either.left("file-system-read-directory-error", readDirectoryError);
 }
-const readDirectory = require_implementor.implementFunction("readDirectory", { NODE: async (path, params) => {
-	return (await require_implementor.nodeFileSystem.value).readdir(path, { recursive: params?.recursive }).then((value) => _duplojs_lang_either.right("file-system-read-directory", value)).catch(handleNodeReadDirectoryError);
+const readDirectory = require_implementor.implementFunction("readDirectory", { NODE: (path, params) => {
+	return (params?.absolute ? require_implementor.nodeFileSystem.value.readdir(path, {
+		recursive: params.recursive,
+		withFileTypes: true
+	}).then((value) => _duplojs_lang_array.map(value, ({ name, parentPath }) => _duplojs_lang_path.resolveFrom(require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow(), [_duplojs_lang_path.normalize(`${parentPath}/${name}`)]))) : require_implementor.nodeFileSystem.value.readdir(path, { recursive: params?.recursive }).then((value) => _duplojs_lang_array.map(value, (subPath) => _duplojs_lang_path.normalize(subPath)))).then(_duplojs_lang_common.innerPipe((paths) => params?.matcher ? _duplojs_lang_array.filter(paths, params.matcher) : paths, (value) => _duplojs_lang_either.right("file-system-read-directory", value))).catch(handleNodeReadDirectoryError);
 } });
 //#endregion
+exports.ReadDirectoryError = ReadDirectoryError;
+exports.ReadDirectoryErrorBusy = ReadDirectoryErrorBusy;
+exports.ReadDirectoryErrorNotDirectory = ReadDirectoryErrorNotDirectory;
+exports.ReadDirectoryErrorNotFound = ReadDirectoryErrorNotFound;
+exports.ReadDirectoryErrorPermissionDenied = ReadDirectoryErrorPermissionDenied;
+exports.ReadDirectoryErrorTooManyOpenFiles = ReadDirectoryErrorTooManyOpenFiles;
 exports.readDirectory = readDirectory;

package/dist/file/readDirectory.d.ts

@@ -1,14 +1,35 @@
-import { FileSystemEither } from './types';
-import type * as DPath from "@duplojs/lang/path";
+import * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+declare const ReadDirectoryErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-not-found", unknown>>, unknown>;
+export declare class ReadDirectoryErrorNotFound extends ReadDirectoryErrorNotFound_base {
+}
+declare const ReadDirectoryErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-permission-denied", unknown>>, unknown>;
+export declare class ReadDirectoryErrorPermissionDenied extends ReadDirectoryErrorPermissionDenied_base {
+}
+declare const ReadDirectoryErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-not-directory", unknown>>, unknown>;
+export declare class ReadDirectoryErrorNotDirectory extends ReadDirectoryErrorNotDirectory_base {
+}
+declare const ReadDirectoryErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-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-read-directory-too-many-open-files", unknown>>, unknown>;
+export declare class ReadDirectoryErrorTooManyOpenFiles extends ReadDirectoryErrorTooManyOpenFiles_base {
+}
+declare const ReadDirectoryErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-busy", unknown>>, unknown>;
+export declare class ReadDirectoryErrorBusy extends ReadDirectoryErrorBusy_base {
+}
+declare const ReadDirectoryError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-directory-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-directory-error", unknown>>, unknown>;
+export declare class ReadDirectoryError extends ReadDirectoryError_base {
+}
+export type ReadDirectoryErrors = (ReadDirectoryErrorNotFound | ReadDirectoryErrorPermissionDenied | ReadDirectoryErrorNotDirectory | ReadDirectoryErrorTooManyOpenFiles | ReadDirectoryErrorBusy | ReadDirectoryError);
 interface ReadDirectoryParams {
     recursive?: boolean;
+    absolute?: boolean;
+    matcher?: DPath.PathMatcher;
 }
-export type ReadDirectoryResult = FileSystemEither<DEither.Right<"read-directory", (string & DPath.Path)[]> | DEither.Left<"read-directory-not-found", unknown> | DEither.Left<"read-directory-permission-denied", unknown> | DEither.Left<"read-directory-not-directory", unknown> | DEither.Left<"read-directory-too-many-open-files", unknown> | DEither.Left<"read-directory-busy", unknown> | DEither.Left<"read-directory-error", unknown>>;
+export type ReadDirectoryResult<GenericParams extends ReadDirectoryParams = ReadDirectoryParams> = (DEither.Right<"file-system-read-directory", readonly (string & DPath.Path & (DCommon.IsEqual<GenericParams["absolute"], true> extends true ? DPath.Absolute : unknown))[]> | DEither.Left<"file-system-read-directory-error", ReadDirectoryErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        readDirectory(path: string & DPath.Path, params?: ReadDirectoryParams): Promise<ReadDirectoryResult>;
+        readDirectory<const GenericParams extends ReadDirectoryParams = {}>(path: DPath.AnyPath, params?: GenericParams): Promise<ReadDirectoryResult<GenericParams>>;
     }
 }
-export declare const readDirectory: (path: string & DPath.Path, params?: ReadDirectoryParams) => Promise<ReadDirectoryResult>;
+export declare const readDirectory: <const GenericParams extends ReadDirectoryParams = {}>(path: DPath.AnyPath, params?: GenericParams) => Promise<ReadDirectoryResult<GenericParams>>;
 export {};