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

package/dist/file/setMode.cjs

@@ -5,22 +5,32 @@ _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/setMode.ts
+var SetModeErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-not-found", Error) {};
+var SetModeErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-permission-denied", Error) {};
+var SetModeErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-not-directory", Error) {};
+var SetModeErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-read-only", Error) {};
+var SetModeErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-invalid-argument", Error) {};
+var SetModeError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-mode-error", Error) {};
 function handleNodeSetModeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-mode-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-mode-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-mode-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-mode-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-mode-invalid-argument", error);
+	let setModeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setModeError = new SetModeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setModeError = new SetModeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setModeError = new SetModeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setModeError = new SetModeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setModeError = new SetModeErrorInvalidArgument(error);
 	}
-	return _duplojs_lang_either.left("file-system-set-mode-error", error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", setModeError);
 }
 function handleDenoSetModeError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-mode-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-mode-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-mode-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-mode-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-set-mode-error", error);
+	let setModeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setModeError = new SetModeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setModeError = new SetModeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setModeError = new SetModeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setModeError = new SetModeErrorInvalidArgument(error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return _duplojs_lang_either.left("file-system-set-mode-error", setModeError);
 }
 function calculatePermissions(permissions) {
 	if (!permissions) return 0;
@@ -35,9 +45,7 @@ function toMode(mode) {
 	return special * 512 + user * 64 + group * 8 + other;
 }
 const setModeImplementation = require_implementor.implementFunction("setMode", {
-	NODE: async (path, mode) => {
-		return (await require_implementor.nodeFileSystem.value).chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleNodeSetModeError);
-	},
+	NODE: async (path, mode) => require_implementor.nodeFileSystem.value.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleNodeSetModeError),
 	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => _duplojs_lang_either.right("file-system-set-mode")).catch(handleDenoSetModeError)
 });
 function setMode(...args) {
@@ -48,4 +56,10 @@ function setMode(...args) {
 	return setModeImplementation(...args);
 }
 //#endregion
+exports.SetModeError = SetModeError;
+exports.SetModeErrorInvalidArgument = SetModeErrorInvalidArgument;
+exports.SetModeErrorNotDirectory = SetModeErrorNotDirectory;
+exports.SetModeErrorNotFound = SetModeErrorNotFound;
+exports.SetModeErrorPermissionDenied = SetModeErrorPermissionDenied;
+exports.SetModeErrorReadOnly = SetModeErrorReadOnly;
 exports.setMode = setMode;

package/dist/file/setMode.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";
 interface Permissions {
@@ -15,12 +15,31 @@ interface ModeObject {
     sticky?: boolean;
 }
 type SetMode = ModeObject | number;
-export type SetModeResult = FileSystemEither<DEither.Right<"set-mode", void> | DEither.Left<"set-mode-not-found", unknown> | DEither.Left<"set-mode-permission-denied", unknown> | DEither.Left<"set-mode-not-directory", unknown> | DEither.Left<"set-mode-read-only", unknown> | DEither.Left<"set-mode-invalid-argument", unknown> | DEither.Left<"set-mode-error", unknown>>;
+declare const SetModeErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-not-found", unknown>>, unknown>;
+export declare class SetModeErrorNotFound extends SetModeErrorNotFound_base {
+}
+declare const SetModeErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-permission-denied", unknown>>, unknown>;
+export declare class SetModeErrorPermissionDenied extends SetModeErrorPermissionDenied_base {
+}
+declare const SetModeErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-not-directory", unknown>>, unknown>;
+export declare class SetModeErrorNotDirectory extends SetModeErrorNotDirectory_base {
+}
+declare const SetModeErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-read-only", unknown>>, unknown>;
+export declare class SetModeErrorReadOnly extends SetModeErrorReadOnly_base {
+}
+declare const SetModeErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-invalid-argument", unknown>>, unknown>;
+export declare class SetModeErrorInvalidArgument extends SetModeErrorInvalidArgument_base {
+}
+declare const SetModeError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-mode-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-mode-error", unknown>>, unknown>;
+export declare class SetModeError extends SetModeError_base {
+}
+export type SetModeErrors = (SetModeErrorNotFound | SetModeErrorPermissionDenied | SetModeErrorNotDirectory | SetModeErrorReadOnly | SetModeErrorInvalidArgument | SetModeError);
+export type SetModeResult = (DEither.Right<"file-system-set-mode", void> | DEither.Left<"file-system-set-mode-error", SetModeErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        setMode(path: string & DPath.Path, mode: SetMode): Promise<SetModeResult>;
+        setMode(path: DPath.AnyPath, mode: SetMode): Promise<SetModeResult>;
     }
 }
-export declare function setMode(mode: SetMode): (path: string & DPath.Path) => Promise<SetModeResult>;
-export declare function setMode(path: string & DPath.Path, mode: SetMode): Promise<SetModeResult>;
+export declare function setMode(mode: SetMode): (path: DPath.AnyPath) => Promise<SetModeResult>;
+export declare function setMode(path: DPath.AnyPath, mode: SetMode): Promise<SetModeResult>;
 export {};

package/dist/file/setMode.mjs

@@ -2,22 +2,32 @@ import { implementFunction, nodeFileSystem } from "../implementor.mjs";
 import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/setMode.ts
+var SetModeErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-not-found", Error) {};
+var SetModeErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-permission-denied", Error) {};
+var SetModeErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-not-directory", Error) {};
+var SetModeErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-read-only", Error) {};
+var SetModeErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-invalid-argument", Error) {};
+var SetModeError = class extends DCommon.DuploJSError.parentClass("file-system-set-mode-error", Error) {};
 function handleNodeSetModeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-set-mode-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-mode-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-mode-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-set-mode-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-set-mode-invalid-argument", error);
+	let setModeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setModeError = new SetModeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setModeError = new SetModeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setModeError = new SetModeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setModeError = new SetModeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setModeError = new SetModeErrorInvalidArgument(error);
 	}
-	return DEither.left("file-system-set-mode-error", error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return DEither.left("file-system-set-mode-error", setModeError);
 }
 function handleDenoSetModeError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-mode-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-mode-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-mode-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-mode-invalid-argument", error);
-	return DEither.left("file-system-set-mode-error", error);
+	let setModeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setModeError = new SetModeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setModeError = new SetModeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setModeError = new SetModeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setModeError = new SetModeErrorInvalidArgument(error);
+	if (setModeError === void 0) setModeError = new SetModeError(error);
+	return DEither.left("file-system-set-mode-error", setModeError);
 }
 function calculatePermissions(permissions) {
 	if (!permissions) return 0;
@@ -32,9 +42,7 @@ function toMode(mode) {
 	return special * 512 + user * 64 + group * 8 + other;
 }
 const setModeImplementation = implementFunction("setMode", {
-	NODE: async (path, mode) => {
-		return (await nodeFileSystem.value).chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleNodeSetModeError);
-	},
+	NODE: async (path, mode) => nodeFileSystem.value.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleNodeSetModeError),
 	DENO: (path, mode) => Deno.chmod(path, toMode(mode)).then(() => DEither.right("file-system-set-mode")).catch(handleDenoSetModeError)
 });
 function setMode(...args) {
@@ -45,4 +53,4 @@ function setMode(...args) {
 	return setModeImplementation(...args);
 }
 //#endregion
-export { setMode };
+export { SetModeError, SetModeErrorInvalidArgument, SetModeErrorNotDirectory, SetModeErrorNotFound, SetModeErrorPermissionDenied, SetModeErrorReadOnly, setMode };

package/dist/file/setOwner.cjs

@@ -1,29 +1,39 @@
 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/setOwner.ts
+var SetOwnerErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-not-found", Error) {};
+var SetOwnerErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-permission-denied", Error) {};
+var SetOwnerErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-not-directory", Error) {};
+var SetOwnerErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-read-only", Error) {};
+var SetOwnerErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-invalid-argument", Error) {};
+var SetOwnerError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-owner-error", Error) {};
 function handleNodeSetOwnerError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-owner-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-owner-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-owner-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-owner-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-owner-invalid-argument", error);
+	let setOwnerError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setOwnerError = new SetOwnerErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setOwnerError = new SetOwnerErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setOwnerError = new SetOwnerErrorNotDirectory(error);
+		else if (error.code === "EROFS") setOwnerError = new SetOwnerErrorReadOnly(error);
+		else if (error.code === "EINVAL") setOwnerError = new SetOwnerErrorInvalidArgument(error);
 	}
-	return _duplojs_lang_either.left("file-system-set-owner-error", error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", setOwnerError);
 }
 function handleDenoSetOwnerError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-owner-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-owner-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-owner-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-owner-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-set-owner-error", error);
+	let setOwnerError = void 0;
+	if (error instanceof Deno.errors.NotFound) setOwnerError = new SetOwnerErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setOwnerError = new SetOwnerErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setOwnerError = new SetOwnerErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return _duplojs_lang_either.left("file-system-set-owner-error", setOwnerError);
 }
 const setOwnerImplementation = require_implementor.implementFunction("setOwner", {
-	NODE: async (path, { userId, groupId }) => {
-		return (await require_implementor.nodeFileSystem.value).chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleNodeSetOwnerError);
-	},
+	NODE: async (path, { userId, groupId }) => require_implementor.nodeFileSystem.value.chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleNodeSetOwnerError),
 	DENO: (path, { userId, groupId }) => Deno.chown(path, userId, groupId).then(() => _duplojs_lang_either.right("file-system-set-owner")).catch(handleDenoSetOwnerError)
 });
 function setOwner(...args) {
@@ -34,4 +44,10 @@ function setOwner(...args) {
 	return setOwnerImplementation(...args);
 }
 //#endregion
+exports.SetOwnerError = SetOwnerError;
+exports.SetOwnerErrorInvalidArgument = SetOwnerErrorInvalidArgument;
+exports.SetOwnerErrorNotDirectory = SetOwnerErrorNotDirectory;
+exports.SetOwnerErrorNotFound = SetOwnerErrorNotFound;
+exports.SetOwnerErrorPermissionDenied = SetOwnerErrorPermissionDenied;
+exports.SetOwnerErrorReadOnly = SetOwnerErrorReadOnly;
 exports.setOwner = setOwner;

package/dist/file/setOwner.d.ts

@@ -1,15 +1,35 @@
-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 SetOwnerParams {
     userId: number;
     groupId: number;
 }
-export type SetOwnerResult = FileSystemEither<DEither.Right<"set-owner", void> | DEither.Left<"set-owner-not-found", unknown> | DEither.Left<"set-owner-permission-denied", unknown> | DEither.Left<"set-owner-not-directory", unknown> | DEither.Left<"set-owner-read-only", unknown> | DEither.Left<"set-owner-invalid-argument", unknown> | DEither.Left<"set-owner-error", unknown>>;
+declare const SetOwnerErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-not-found", unknown>>, unknown>;
+export declare class SetOwnerErrorNotFound extends SetOwnerErrorNotFound_base {
+}
+declare const SetOwnerErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-permission-denied", unknown>>, unknown>;
+export declare class SetOwnerErrorPermissionDenied extends SetOwnerErrorPermissionDenied_base {
+}
+declare const SetOwnerErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-not-directory", unknown>>, unknown>;
+export declare class SetOwnerErrorNotDirectory extends SetOwnerErrorNotDirectory_base {
+}
+declare const SetOwnerErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-read-only", unknown>>, unknown>;
+export declare class SetOwnerErrorReadOnly extends SetOwnerErrorReadOnly_base {
+}
+declare const SetOwnerErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-invalid-argument", unknown>>, unknown>;
+export declare class SetOwnerErrorInvalidArgument extends SetOwnerErrorInvalidArgument_base {
+}
+declare const SetOwnerError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-owner-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-owner-error", unknown>>, unknown>;
+export declare class SetOwnerError extends SetOwnerError_base {
+}
+export type SetOwnerErrors = (SetOwnerErrorNotFound | SetOwnerErrorPermissionDenied | SetOwnerErrorNotDirectory | SetOwnerErrorReadOnly | SetOwnerErrorInvalidArgument | SetOwnerError);
+export type SetOwnerResult = (DEither.Right<"file-system-set-owner", void> | DEither.Left<"file-system-set-owner-error", SetOwnerErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        setOwner(path: string & DPath.Path, params: SetOwnerParams): Promise<SetOwnerResult>;
+        setOwner(path: DPath.AnyPath, params: SetOwnerParams): Promise<SetOwnerResult>;
     }
 }
-export declare function setOwner(params: SetOwnerParams): (path: string & DPath.Path) => Promise<SetOwnerResult>;
-export declare function setOwner(path: string & DPath.Path, params: SetOwnerParams): Promise<SetOwnerResult>;
+export declare function setOwner(params: SetOwnerParams): (path: DPath.AnyPath) => Promise<SetOwnerResult>;
+export declare function setOwner(path: DPath.AnyPath, params: SetOwnerParams): Promise<SetOwnerResult>;
+export {};

package/dist/file/setOwner.mjs

@@ -1,27 +1,36 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/setOwner.ts
+var SetOwnerErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-not-found", Error) {};
+var SetOwnerErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-permission-denied", Error) {};
+var SetOwnerErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-not-directory", Error) {};
+var SetOwnerErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-read-only", Error) {};
+var SetOwnerErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-invalid-argument", Error) {};
+var SetOwnerError = class extends DCommon.DuploJSError.parentClass("file-system-set-owner-error", Error) {};
 function handleNodeSetOwnerError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-set-owner-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-owner-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-owner-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-set-owner-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-set-owner-invalid-argument", error);
+	let setOwnerError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setOwnerError = new SetOwnerErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setOwnerError = new SetOwnerErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setOwnerError = new SetOwnerErrorNotDirectory(error);
+		else if (error.code === "EROFS") setOwnerError = new SetOwnerErrorReadOnly(error);
+		else if (error.code === "EINVAL") setOwnerError = new SetOwnerErrorInvalidArgument(error);
 	}
-	return DEither.left("file-system-set-owner-error", error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return DEither.left("file-system-set-owner-error", setOwnerError);
 }
 function handleDenoSetOwnerError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-owner-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-owner-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-owner-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-owner-invalid-argument", error);
-	return DEither.left("file-system-set-owner-error", error);
+	let setOwnerError = void 0;
+	if (error instanceof Deno.errors.NotFound) setOwnerError = new SetOwnerErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setOwnerError = new SetOwnerErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setOwnerError = new SetOwnerErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setOwnerError = new SetOwnerErrorInvalidArgument(error);
+	if (setOwnerError === void 0) setOwnerError = new SetOwnerError(error);
+	return DEither.left("file-system-set-owner-error", setOwnerError);
 }
 const setOwnerImplementation = implementFunction("setOwner", {
-	NODE: async (path, { userId, groupId }) => {
-		return (await nodeFileSystem.value).chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleNodeSetOwnerError);
-	},
+	NODE: async (path, { userId, groupId }) => nodeFileSystem.value.chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleNodeSetOwnerError),
 	DENO: (path, { userId, groupId }) => Deno.chown(path, userId, groupId).then(() => DEither.right("file-system-set-owner")).catch(handleDenoSetOwnerError)
 });
 function setOwner(...args) {
@@ -32,4 +41,4 @@ function setOwner(...args) {
 	return setOwnerImplementation(...args);
 }
 //#endregion
-export { setOwner };
+export { SetOwnerError, SetOwnerErrorInvalidArgument, SetOwnerErrorNotDirectory, SetOwnerErrorNotFound, SetOwnerErrorPermissionDenied, SetOwnerErrorReadOnly, setOwner };

package/dist/file/setTime.cjs

@@ -1,31 +1,41 @@
 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);
 let _duplojs_lang_chrono = require("@duplojs/lang/chrono");
 _duplojs_lang_chrono = require_runtime.__toESM(_duplojs_lang_chrono, 1);
 //#region scripts/file/setTime.ts
+var SetTimeErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-not-found", Error) {};
+var SetTimeErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-permission-denied", Error) {};
+var SetTimeErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-not-directory", Error) {};
+var SetTimeErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-read-only", Error) {};
+var SetTimeErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-invalid-argument", Error) {};
+var SetTimeError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-set-time-error", Error) {};
 function handleNodeSetTimeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-set-time-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-set-time-permission-denied", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-set-time-not-directory", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-set-time-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-set-time-invalid-argument", error);
+	let setTimeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setTimeError = new SetTimeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setTimeError = new SetTimeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setTimeError = new SetTimeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setTimeError = new SetTimeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setTimeError = new SetTimeErrorInvalidArgument(error);
 	}
-	return _duplojs_lang_either.left("file-system-set-time-error", error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return _duplojs_lang_either.left("file-system-set-time-error", setTimeError);
 }
 function handleDenoSetTimeError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-set-time-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-set-time-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-set-time-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-set-time-invalid-argument", error);
-	return _duplojs_lang_either.left("file-system-set-time-error", error);
+	let setTimeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setTimeError = new SetTimeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setTimeError = new SetTimeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setTimeError = new SetTimeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setTimeError = new SetTimeErrorInvalidArgument(error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return _duplojs_lang_either.left("file-system-set-time-error", setTimeError);
 }
 const setTimeImplementation = require_implementor.implementFunction("setTime", {
-	NODE: async (path, { accessTime, modifiedTime }) => {
-		return (await require_implementor.nodeFileSystem.value).utimes(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleNodeSetTimeError);
-	},
+	NODE: async (path, { accessTime, modifiedTime }) => require_implementor.nodeFileSystem.value.utimes(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleNodeSetTimeError),
 	DENO: (path, { accessTime, modifiedTime }) => Deno.utime(path, _duplojs_lang_chrono.toTimestamp(accessTime), _duplojs_lang_chrono.toTimestamp(modifiedTime)).then(() => _duplojs_lang_either.right("file-system-set-time")).catch(handleDenoSetTimeError)
 });
 function setTime(...args) {
@@ -36,4 +46,10 @@ function setTime(...args) {
 	return setTimeImplementation(...args);
 }
 //#endregion
+exports.SetTimeError = SetTimeError;
+exports.SetTimeErrorInvalidArgument = SetTimeErrorInvalidArgument;
+exports.SetTimeErrorNotDirectory = SetTimeErrorNotDirectory;
+exports.SetTimeErrorNotFound = SetTimeErrorNotFound;
+exports.SetTimeErrorPermissionDenied = SetTimeErrorPermissionDenied;
+exports.SetTimeErrorReadOnly = SetTimeErrorReadOnly;
 exports.setTime = setTime;

package/dist/file/setTime.d.ts

@@ -1,17 +1,36 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import * as DChrono from "@duplojs/lang/chrono";
 import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
 interface SetTimeParams {
     accessTime: DChrono.TheDate;
     modifiedTime: DChrono.TheDate;
 }
-export type SetTimeResult = FileSystemEither<DEither.Right<"set-time", void> | DEither.Left<"set-time-not-found", unknown> | DEither.Left<"set-time-permission-denied", unknown> | DEither.Left<"set-time-not-directory", unknown> | DEither.Left<"set-time-read-only", unknown> | DEither.Left<"set-time-invalid-argument", unknown> | DEither.Left<"set-time-error", unknown>>;
+declare const SetTimeErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-not-found", unknown>>, unknown>;
+export declare class SetTimeErrorNotFound extends SetTimeErrorNotFound_base {
+}
+declare const SetTimeErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-permission-denied", unknown>>, unknown>;
+export declare class SetTimeErrorPermissionDenied extends SetTimeErrorPermissionDenied_base {
+}
+declare const SetTimeErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-not-directory", unknown>>, unknown>;
+export declare class SetTimeErrorNotDirectory extends SetTimeErrorNotDirectory_base {
+}
+declare const SetTimeErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-read-only", unknown>>, unknown>;
+export declare class SetTimeErrorReadOnly extends SetTimeErrorReadOnly_base {
+}
+declare const SetTimeErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-invalid-argument", unknown>>, unknown>;
+export declare class SetTimeErrorInvalidArgument extends SetTimeErrorInvalidArgument_base {
+}
+declare const SetTimeError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-set-time-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-set-time-error", unknown>>, unknown>;
+export declare class SetTimeError extends SetTimeError_base {
+}
+export type SetTimeErrors = (SetTimeErrorNotFound | SetTimeErrorPermissionDenied | SetTimeErrorNotDirectory | SetTimeErrorReadOnly | SetTimeErrorInvalidArgument | SetTimeError);
+export type SetTimeResult = (DEither.Right<"file-system-set-time", void> | DEither.Left<"file-system-set-time-error", SetTimeErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        setTime(path: string & DPath.Path, params: SetTimeParams): Promise<SetTimeResult>;
+        setTime(path: DPath.AnyPath, params: SetTimeParams): Promise<SetTimeResult>;
     }
 }
-export declare function setTime(params: SetTimeParams): (path: string & DPath.Path) => Promise<SetTimeResult>;
-export declare function setTime(path: string & DPath.Path, params: SetTimeParams): Promise<SetTimeResult>;
+export declare function setTime(params: SetTimeParams): (path: DPath.AnyPath) => Promise<SetTimeResult>;
+export declare function setTime(path: DPath.AnyPath, params: SetTimeParams): Promise<SetTimeResult>;
 export {};

package/dist/file/setTime.mjs

@@ -1,28 +1,37 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DChrono from "@duplojs/lang/chrono";
 //#region scripts/file/setTime.ts
+var SetTimeErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-set-time-not-found", Error) {};
+var SetTimeErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-set-time-permission-denied", Error) {};
+var SetTimeErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-set-time-not-directory", Error) {};
+var SetTimeErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-set-time-read-only", Error) {};
+var SetTimeErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-set-time-invalid-argument", Error) {};
+var SetTimeError = class extends DCommon.DuploJSError.parentClass("file-system-set-time-error", Error) {};
 function handleNodeSetTimeError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-set-time-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-set-time-permission-denied", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-set-time-not-directory", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-set-time-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-set-time-invalid-argument", error);
+	let setTimeError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") setTimeError = new SetTimeErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") setTimeError = new SetTimeErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") setTimeError = new SetTimeErrorNotDirectory(error);
+		else if (error.code === "EROFS") setTimeError = new SetTimeErrorReadOnly(error);
+		else if (error.code === "EINVAL") setTimeError = new SetTimeErrorInvalidArgument(error);
 	}
-	return DEither.left("file-system-set-time-error", error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return DEither.left("file-system-set-time-error", setTimeError);
 }
 function handleDenoSetTimeError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-set-time-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-set-time-permission-denied", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-set-time-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-set-time-invalid-argument", error);
-	return DEither.left("file-system-set-time-error", error);
+	let setTimeError = void 0;
+	if (error instanceof Deno.errors.NotFound) setTimeError = new SetTimeErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) setTimeError = new SetTimeErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) setTimeError = new SetTimeErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) setTimeError = new SetTimeErrorInvalidArgument(error);
+	if (setTimeError === void 0) setTimeError = new SetTimeError(error);
+	return DEither.left("file-system-set-time-error", setTimeError);
 }
 const setTimeImplementation = implementFunction("setTime", {
-	NODE: async (path, { accessTime, modifiedTime }) => {
-		return (await nodeFileSystem.value).utimes(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleNodeSetTimeError);
-	},
+	NODE: async (path, { accessTime, modifiedTime }) => nodeFileSystem.value.utimes(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleNodeSetTimeError),
 	DENO: (path, { accessTime, modifiedTime }) => Deno.utime(path, DChrono.toTimestamp(accessTime), DChrono.toTimestamp(modifiedTime)).then(() => DEither.right("file-system-set-time")).catch(handleDenoSetTimeError)
 });
 function setTime(...args) {
@@ -33,4 +42,4 @@ function setTime(...args) {
 	return setTimeImplementation(...args);
 }
 //#endregion
-export { setTime };
+export { SetTimeError, SetTimeErrorInvalidArgument, SetTimeErrorNotDirectory, SetTimeErrorNotFound, SetTimeErrorPermissionDenied, SetTimeErrorReadOnly, setTime };