@duplojs/server 0.0.0-stage → 0.1.0-beta.10

package/dist/file/readJsonFile.d.ts

@@ -0,0 +1,33 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare const ReadJsonFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-not-found", unknown>>, unknown>;
+export declare class ReadJsonFileErrorNotFound extends ReadJsonFileErrorNotFound_base {
+}
+declare const ReadJsonFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-permission-denied", unknown>>, unknown>;
+export declare class ReadJsonFileErrorPermissionDenied extends ReadJsonFileErrorPermissionDenied_base {
+}
+declare const ReadJsonFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-is-directory", unknown>>, unknown>;
+export declare class ReadJsonFileErrorIsDirectory extends ReadJsonFileErrorIsDirectory_base {
+}
+declare const ReadJsonFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-not-directory", unknown>>, unknown>;
+export declare class ReadJsonFileErrorNotDirectory extends ReadJsonFileErrorNotDirectory_base {
+}
+declare const ReadJsonFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-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-read-json-file-too-many-open-files", unknown>>, unknown>;
+export declare class ReadJsonFileErrorTooManyOpenFiles extends ReadJsonFileErrorTooManyOpenFiles_base {
+}
+declare const ReadJsonFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-busy", unknown>>, unknown>;
+export declare class ReadJsonFileErrorBusy extends ReadJsonFileErrorBusy_base {
+}
+declare const ReadJsonFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-json-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-json-file-error", unknown>>, unknown>;
+export declare class ReadJsonFileError extends ReadJsonFileError_base {
+}
+export type ReadJsonFileErrors = (ReadJsonFileErrorNotFound | ReadJsonFileErrorPermissionDenied | ReadJsonFileErrorIsDirectory | ReadJsonFileErrorNotDirectory | ReadJsonFileErrorTooManyOpenFiles | ReadJsonFileErrorBusy | ReadJsonFileError);
+export type ReadJsonFileResult = (DEither.Right<"file-system-read-json-file", DCommon.Json> | DEither.Left<"file-system-read-json-file-error", ReadJsonFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        readJsonFile(path: DPath.AnyPath): Promise<ReadJsonFileResult>;
+    }
+}
+export declare const readJsonFile: (path: DPath.AnyPath) => Promise<ReadJsonFileResult>;
+export {};

package/dist/file/readJsonFile.mjs

@@ -0,0 +1,41 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readJsonFile.ts
+var ReadJsonFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-not-found", Error) {};
+var ReadJsonFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-permission-denied", Error) {};
+var ReadJsonFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-is-directory", Error) {};
+var ReadJsonFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-not-directory", Error) {};
+var ReadJsonFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-too-many-open-files", Error) {};
+var ReadJsonFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-busy", Error) {};
+var ReadJsonFileError = class extends DCommon.DuploJSError.parentClass("file-system-read-json-file-error", Error) {};
+function handleNodeReadJsonFileError(error) {
+	let readJsonFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readJsonFileError = new ReadJsonFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readJsonFileError = new ReadJsonFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") readJsonFileError = new ReadJsonFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") readJsonFileError = new ReadJsonFileErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readJsonFileError = new ReadJsonFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readJsonFileError = new ReadJsonFileErrorBusy(error);
+	}
+	if (readJsonFileError === void 0) readJsonFileError = new ReadJsonFileError(error);
+	return DEither.left("file-system-read-json-file-error", readJsonFileError);
+}
+function handleDenoReadJsonFileError(error) {
+	let readJsonFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) readJsonFileError = new ReadJsonFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readJsonFileError = new ReadJsonFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) readJsonFileError = new ReadJsonFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) readJsonFileError = new ReadJsonFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) readJsonFileError = new ReadJsonFileErrorBusy(error);
+	if (readJsonFileError === void 0) readJsonFileError = new ReadJsonFileError(error);
+	return DEither.left("file-system-read-json-file-error", readJsonFileError);
+}
+const readJsonFile = implementFunction("readJsonFile", {
+	NODE: async (path) => nodeFileSystem.value.readFile(path, { encoding: "utf-8" }).then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError),
+	DENO: (path) => Deno.readTextFile(path).then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleDenoReadJsonFileError),
+	BUN: (path) => Bun.file(path).text().then(JSON.parse).then((value) => DEither.right("file-system-read-json-file", value)).catch(handleNodeReadJsonFileError)
+});
+//#endregion
+export { ReadJsonFileError, ReadJsonFileErrorBusy, ReadJsonFileErrorIsDirectory, ReadJsonFileErrorNotDirectory, ReadJsonFileErrorNotFound, ReadJsonFileErrorPermissionDenied, ReadJsonFileErrorTooManyOpenFiles, readJsonFile };

package/dist/file/readLink.cjs

@@ -0,0 +1,46 @@
+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/readLink.ts
+var ReadLinkErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-link-not-found", Error) {};
+var ReadLinkErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-link-permission-denied", Error) {};
+var ReadLinkErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-link-invalid-argument", Error) {};
+var ReadLinkErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-link-not-directory", Error) {};
+var ReadLinkErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-link-too-many-open-files", Error) {};
+var ReadLinkError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-link-error", Error) {};
+function handleNodeReadLinkError(error) {
+	let readLinkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readLinkError = new ReadLinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readLinkError = new ReadLinkErrorPermissionDenied(error);
+		else if (error.code === "EINVAL") readLinkError = new ReadLinkErrorInvalidArgument(error);
+		else if (error.code === "ENOTDIR") readLinkError = new ReadLinkErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readLinkError = new ReadLinkErrorTooManyOpenFiles(error);
+	}
+	if (readLinkError === void 0) readLinkError = new ReadLinkError(error);
+	return _duplojs_lang_either.left("file-system-read-link-error", readLinkError);
+}
+function handleDenoReadLinkError(error) {
+	let readLinkError = void 0;
+	if (error instanceof Deno.errors.NotFound) readLinkError = new ReadLinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readLinkError = new ReadLinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.InvalidData) readLinkError = new ReadLinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.NotADirectory) readLinkError = new ReadLinkErrorNotDirectory(error);
+	if (readLinkError === void 0) readLinkError = new ReadLinkError(error);
+	return _duplojs_lang_either.left("file-system-read-link-error", readLinkError);
+}
+const readLink = require_implementor.implementFunction("readLink", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.readlink(path, { encoding: "utf-8" }).then((value) => _duplojs_lang_either.right("file-system-read-link", value)).catch(handleNodeReadLinkError),
+	DENO: (path) => Deno.readLink(path).then((value) => _duplojs_lang_either.right("file-system-read-link", value)).catch(handleDenoReadLinkError)
+});
+//#endregion
+exports.ReadLinkError = ReadLinkError;
+exports.ReadLinkErrorInvalidArgument = ReadLinkErrorInvalidArgument;
+exports.ReadLinkErrorNotDirectory = ReadLinkErrorNotDirectory;
+exports.ReadLinkErrorNotFound = ReadLinkErrorNotFound;
+exports.ReadLinkErrorPermissionDenied = ReadLinkErrorPermissionDenied;
+exports.ReadLinkErrorTooManyOpenFiles = ReadLinkErrorTooManyOpenFiles;
+exports.readLink = readLink;

package/dist/file/readLink.d.ts

@@ -0,0 +1,30 @@
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import * as DCommon from "@duplojs/lang/common";
+declare const ReadLinkErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-not-found", unknown>>, unknown>;
+export declare class ReadLinkErrorNotFound extends ReadLinkErrorNotFound_base {
+}
+declare const ReadLinkErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-permission-denied", unknown>>, unknown>;
+export declare class ReadLinkErrorPermissionDenied extends ReadLinkErrorPermissionDenied_base {
+}
+declare const ReadLinkErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-invalid-argument", unknown>>, unknown>;
+export declare class ReadLinkErrorInvalidArgument extends ReadLinkErrorInvalidArgument_base {
+}
+declare const ReadLinkErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-not-directory", unknown>>, unknown>;
+export declare class ReadLinkErrorNotDirectory extends ReadLinkErrorNotDirectory_base {
+}
+declare const ReadLinkErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-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-link-too-many-open-files", unknown>>, unknown>;
+export declare class ReadLinkErrorTooManyOpenFiles extends ReadLinkErrorTooManyOpenFiles_base {
+}
+declare const ReadLinkError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-link-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-link-error", unknown>>, unknown>;
+export declare class ReadLinkError extends ReadLinkError_base {
+}
+export type ReadLinkErrors = (ReadLinkErrorNotFound | ReadLinkErrorPermissionDenied | ReadLinkErrorInvalidArgument | ReadLinkErrorNotDirectory | ReadLinkErrorTooManyOpenFiles | ReadLinkError);
+export type ReadLinkResult = (DEither.Right<"file-system-read-link", string> | DEither.Left<"file-system-read-link-error", ReadLinkErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        readLink(path: DPath.AnyPath): Promise<ReadLinkResult>;
+    }
+}
+export declare const readLink: (path: DPath.AnyPath) => Promise<ReadLinkResult>;
+export {};

package/dist/file/readLink.mjs

@@ -0,0 +1,37 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readLink.ts
+var ReadLinkErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-read-link-not-found", Error) {};
+var ReadLinkErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-read-link-permission-denied", Error) {};
+var ReadLinkErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-read-link-invalid-argument", Error) {};
+var ReadLinkErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-link-not-directory", Error) {};
+var ReadLinkErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-read-link-too-many-open-files", Error) {};
+var ReadLinkError = class extends DCommon.DuploJSError.parentClass("file-system-read-link-error", Error) {};
+function handleNodeReadLinkError(error) {
+	let readLinkError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readLinkError = new ReadLinkErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readLinkError = new ReadLinkErrorPermissionDenied(error);
+		else if (error.code === "EINVAL") readLinkError = new ReadLinkErrorInvalidArgument(error);
+		else if (error.code === "ENOTDIR") readLinkError = new ReadLinkErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readLinkError = new ReadLinkErrorTooManyOpenFiles(error);
+	}
+	if (readLinkError === void 0) readLinkError = new ReadLinkError(error);
+	return DEither.left("file-system-read-link-error", readLinkError);
+}
+function handleDenoReadLinkError(error) {
+	let readLinkError = void 0;
+	if (error instanceof Deno.errors.NotFound) readLinkError = new ReadLinkErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readLinkError = new ReadLinkErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.InvalidData) readLinkError = new ReadLinkErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.NotADirectory) readLinkError = new ReadLinkErrorNotDirectory(error);
+	if (readLinkError === void 0) readLinkError = new ReadLinkError(error);
+	return DEither.left("file-system-read-link-error", readLinkError);
+}
+const readLink = implementFunction("readLink", {
+	NODE: async (path) => nodeFileSystem.value.readlink(path, { encoding: "utf-8" }).then((value) => DEither.right("file-system-read-link", value)).catch(handleNodeReadLinkError),
+	DENO: (path) => Deno.readLink(path).then((value) => DEither.right("file-system-read-link", value)).catch(handleDenoReadLinkError)
+});
+//#endregion
+export { ReadLinkError, ReadLinkErrorInvalidArgument, ReadLinkErrorNotDirectory, ReadLinkErrorNotFound, ReadLinkErrorPermissionDenied, ReadLinkErrorTooManyOpenFiles, readLink };

package/dist/file/readTextFile.cjs

@@ -0,0 +1,51 @@
+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/readTextFile.ts
+var ReadTextFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-not-found", Error) {};
+var ReadTextFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-permission-denied", Error) {};
+var ReadTextFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-is-directory", Error) {};
+var ReadTextFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-not-directory", Error) {};
+var ReadTextFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-too-many-open-files", Error) {};
+var ReadTextFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-busy", Error) {};
+var ReadTextFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-read-text-file-error", Error) {};
+function handleNodeReadTextFileError(error) {
+	let readTextFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readTextFileError = new ReadTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readTextFileError = new ReadTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") readTextFileError = new ReadTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") readTextFileError = new ReadTextFileErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readTextFileError = new ReadTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readTextFileError = new ReadTextFileErrorBusy(error);
+	}
+	if (readTextFileError === void 0) readTextFileError = new ReadTextFileError(error);
+	return _duplojs_lang_either.left("file-system-read-text-file-error", readTextFileError);
+}
+function handleDenoReadTextFileError(error) {
+	let readTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) readTextFileError = new ReadTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readTextFileError = new ReadTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) readTextFileError = new ReadTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) readTextFileError = new ReadTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) readTextFileError = new ReadTextFileErrorBusy(error);
+	if (readTextFileError === void 0) readTextFileError = new ReadTextFileError(error);
+	return _duplojs_lang_either.left("file-system-read-text-file-error", readTextFileError);
+}
+const readTextFile = require_implementor.implementFunction("readTextFile", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.readFile(path, { encoding: "utf-8" }).then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError),
+	DENO: (path) => Deno.readTextFile(path).then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleDenoReadTextFileError),
+	BUN: (path) => Bun.file(path).text().then((value) => _duplojs_lang_either.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError)
+});
+//#endregion
+exports.ReadTextFileError = ReadTextFileError;
+exports.ReadTextFileErrorBusy = ReadTextFileErrorBusy;
+exports.ReadTextFileErrorIsDirectory = ReadTextFileErrorIsDirectory;
+exports.ReadTextFileErrorNotDirectory = ReadTextFileErrorNotDirectory;
+exports.ReadTextFileErrorNotFound = ReadTextFileErrorNotFound;
+exports.ReadTextFileErrorPermissionDenied = ReadTextFileErrorPermissionDenied;
+exports.ReadTextFileErrorTooManyOpenFiles = ReadTextFileErrorTooManyOpenFiles;
+exports.readTextFile = readTextFile;

package/dist/file/readTextFile.d.ts

@@ -0,0 +1,33 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare const ReadTextFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-not-found", unknown>>, unknown>;
+export declare class ReadTextFileErrorNotFound extends ReadTextFileErrorNotFound_base {
+}
+declare const ReadTextFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-permission-denied", unknown>>, unknown>;
+export declare class ReadTextFileErrorPermissionDenied extends ReadTextFileErrorPermissionDenied_base {
+}
+declare const ReadTextFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-is-directory", unknown>>, unknown>;
+export declare class ReadTextFileErrorIsDirectory extends ReadTextFileErrorIsDirectory_base {
+}
+declare const ReadTextFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-not-directory", unknown>>, unknown>;
+export declare class ReadTextFileErrorNotDirectory extends ReadTextFileErrorNotDirectory_base {
+}
+declare const ReadTextFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-too-many-open-files", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-too-many-open-files", unknown>>, unknown>;
+export declare class ReadTextFileErrorTooManyOpenFiles extends ReadTextFileErrorTooManyOpenFiles_base {
+}
+declare const ReadTextFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-busy", unknown>>, unknown>;
+export declare class ReadTextFileErrorBusy extends ReadTextFileErrorBusy_base {
+}
+declare const ReadTextFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-read-text-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-read-text-file-error", unknown>>, unknown>;
+export declare class ReadTextFileError extends ReadTextFileError_base {
+}
+export type ReadTextFileErrors = (ReadTextFileErrorNotFound | ReadTextFileErrorPermissionDenied | ReadTextFileErrorIsDirectory | ReadTextFileErrorNotDirectory | ReadTextFileErrorTooManyOpenFiles | ReadTextFileErrorBusy | ReadTextFileError);
+export type ReadTextFileResult = (DEither.Right<"file-system-read-text-file", string> | DEither.Left<"file-system-read-text-file-error", ReadTextFileErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        readTextFile(path: DPath.AnyPath): Promise<ReadTextFileResult>;
+    }
+}
+export declare const readTextFile: (path: DPath.AnyPath) => Promise<ReadTextFileResult>;
+export {};

package/dist/file/readTextFile.mjs

@@ -0,0 +1,41 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/readTextFile.ts
+var ReadTextFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-not-found", Error) {};
+var ReadTextFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-permission-denied", Error) {};
+var ReadTextFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-is-directory", Error) {};
+var ReadTextFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-not-directory", Error) {};
+var ReadTextFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-too-many-open-files", Error) {};
+var ReadTextFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-busy", Error) {};
+var ReadTextFileError = class extends DCommon.DuploJSError.parentClass("file-system-read-text-file-error", Error) {};
+function handleNodeReadTextFileError(error) {
+	let readTextFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") readTextFileError = new ReadTextFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") readTextFileError = new ReadTextFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") readTextFileError = new ReadTextFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") readTextFileError = new ReadTextFileErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") readTextFileError = new ReadTextFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") readTextFileError = new ReadTextFileErrorBusy(error);
+	}
+	if (readTextFileError === void 0) readTextFileError = new ReadTextFileError(error);
+	return DEither.left("file-system-read-text-file-error", readTextFileError);
+}
+function handleDenoReadTextFileError(error) {
+	let readTextFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) readTextFileError = new ReadTextFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) readTextFileError = new ReadTextFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) readTextFileError = new ReadTextFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) readTextFileError = new ReadTextFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.Busy) readTextFileError = new ReadTextFileErrorBusy(error);
+	if (readTextFileError === void 0) readTextFileError = new ReadTextFileError(error);
+	return DEither.left("file-system-read-text-file-error", readTextFileError);
+}
+const readTextFile = implementFunction("readTextFile", {
+	NODE: async (path) => nodeFileSystem.value.readFile(path, { encoding: "utf-8" }).then((value) => DEither.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError),
+	DENO: (path) => Deno.readTextFile(path).then((value) => DEither.right("file-system-read-text-file", value)).catch(handleDenoReadTextFileError),
+	BUN: (path) => Bun.file(path).text().then((value) => DEither.right("file-system-read-text-file", value)).catch(handleNodeReadTextFileError)
+});
+//#endregion
+export { ReadTextFileError, ReadTextFileErrorBusy, ReadTextFileErrorIsDirectory, ReadTextFileErrorNotDirectory, ReadTextFileErrorNotFound, ReadTextFileErrorPermissionDenied, ReadTextFileErrorTooManyOpenFiles, readTextFile };

package/dist/file/realPath.cjs

@@ -0,0 +1,42 @@
+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/realPath.ts
+var RealPathErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-real-path-not-found", Error) {};
+var RealPathErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-real-path-permission-denied", Error) {};
+var RealPathErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-real-path-not-directory", Error) {};
+var RealPathErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-real-path-too-many-open-files", Error) {};
+var RealPathError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-real-path-error", Error) {};
+function handleNodeRealPathError(error) {
+	let realPathError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") realPathError = new RealPathErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") realPathError = new RealPathErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") realPathError = new RealPathErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") realPathError = new RealPathErrorTooManyOpenFiles(error);
+	}
+	if (realPathError === void 0) realPathError = new RealPathError(error);
+	return _duplojs_lang_either.left("file-system-real-path-error", realPathError);
+}
+function handleDenoRealPathError(error) {
+	let realPathError = void 0;
+	if (error instanceof Deno.errors.NotFound) realPathError = new RealPathErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) realPathError = new RealPathErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) realPathError = new RealPathErrorNotDirectory(error);
+	if (realPathError === void 0) realPathError = new RealPathError(error);
+	return _duplojs_lang_either.left("file-system-real-path-error", realPathError);
+}
+const realPath = require_implementor.implementFunction("realPath", {
+	NODE: async (path) => require_implementor.nodeFileSystem.value.realpath(path).then((value) => _duplojs_lang_either.right("file-system-real-path", value)).catch(handleNodeRealPathError),
+	DENO: (path) => Deno.realPath(path).then((value) => _duplojs_lang_either.right("file-system-real-path", value)).catch(handleDenoRealPathError)
+});
+//#endregion
+exports.RealPathError = RealPathError;
+exports.RealPathErrorNotDirectory = RealPathErrorNotDirectory;
+exports.RealPathErrorNotFound = RealPathErrorNotFound;
+exports.RealPathErrorPermissionDenied = RealPathErrorPermissionDenied;
+exports.RealPathErrorTooManyOpenFiles = RealPathErrorTooManyOpenFiles;
+exports.realPath = realPath;

package/dist/file/realPath.d.ts

@@ -0,0 +1,27 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+declare const RealPathErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-not-found", unknown>>, unknown>;
+export declare class RealPathErrorNotFound extends RealPathErrorNotFound_base {
+}
+declare const RealPathErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-permission-denied", unknown>>, unknown>;
+export declare class RealPathErrorPermissionDenied extends RealPathErrorPermissionDenied_base {
+}
+declare const RealPathErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-not-directory", unknown>>, unknown>;
+export declare class RealPathErrorNotDirectory extends RealPathErrorNotDirectory_base {
+}
+declare const RealPathErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-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-real-path-too-many-open-files", unknown>>, unknown>;
+export declare class RealPathErrorTooManyOpenFiles extends RealPathErrorTooManyOpenFiles_base {
+}
+declare const RealPathError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-real-path-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-real-path-error", unknown>>, unknown>;
+export declare class RealPathError extends RealPathError_base {
+}
+export type RealPathErrors = (RealPathErrorNotFound | RealPathErrorPermissionDenied | RealPathErrorNotDirectory | RealPathErrorTooManyOpenFiles | RealPathError);
+export type RealPathResult = (DEither.Right<"file-system-real-path", string> | DEither.Left<"file-system-real-path-error", RealPathErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        realPath(path: DPath.AnyPath): Promise<RealPathResult>;
+    }
+}
+export declare const realPath: (path: DPath.AnyPath) => Promise<RealPathResult>;
+export {};

package/dist/file/realPath.mjs

@@ -0,0 +1,34 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/realPath.ts
+var RealPathErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-real-path-not-found", Error) {};
+var RealPathErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-real-path-permission-denied", Error) {};
+var RealPathErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-real-path-not-directory", Error) {};
+var RealPathErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-real-path-too-many-open-files", Error) {};
+var RealPathError = class extends DCommon.DuploJSError.parentClass("file-system-real-path-error", Error) {};
+function handleNodeRealPathError(error) {
+	let realPathError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") realPathError = new RealPathErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") realPathError = new RealPathErrorPermissionDenied(error);
+		else if (error.code === "ENOTDIR") realPathError = new RealPathErrorNotDirectory(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") realPathError = new RealPathErrorTooManyOpenFiles(error);
+	}
+	if (realPathError === void 0) realPathError = new RealPathError(error);
+	return DEither.left("file-system-real-path-error", realPathError);
+}
+function handleDenoRealPathError(error) {
+	let realPathError = void 0;
+	if (error instanceof Deno.errors.NotFound) realPathError = new RealPathErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) realPathError = new RealPathErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.NotADirectory) realPathError = new RealPathErrorNotDirectory(error);
+	if (realPathError === void 0) realPathError = new RealPathError(error);
+	return DEither.left("file-system-real-path-error", realPathError);
+}
+const realPath = implementFunction("realPath", {
+	NODE: async (path) => nodeFileSystem.value.realpath(path).then((value) => DEither.right("file-system-real-path", value)).catch(handleNodeRealPathError),
+	DENO: (path) => Deno.realPath(path).then((value) => DEither.right("file-system-real-path", value)).catch(handleDenoRealPathError)
+});
+//#endregion
+export { RealPathError, RealPathErrorNotDirectory, RealPathErrorNotFound, RealPathErrorPermissionDenied, RealPathErrorTooManyOpenFiles, realPath };

package/dist/file/relocate.cjs

@@ -0,0 +1,83 @@
+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_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/file/relocate.ts
+var RelocateErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-not-found", Error) {};
+var RelocateErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-permission-denied", Error) {};
+var RelocateErrorAlreadyExists = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-already-exists", Error) {};
+var RelocateErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-is-directory", Error) {};
+var RelocateErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-not-directory", Error) {};
+var RelocateErrorDirectoryNotEmpty = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-directory-not-empty", Error) {};
+var RelocateErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-read-only", Error) {};
+var RelocateErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-invalid-argument", Error) {};
+var RelocateErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-busy", Error) {};
+var RelocateErrorCrossDevice = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-cross-device", Error) {};
+var RelocateError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-relocate-error", Error) {};
+function handleNodeRelocateError(error) {
+	let relocateError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") relocateError = new RelocateErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") relocateError = new RelocateErrorPermissionDenied(error);
+		else if (error.code === "EEXIST") relocateError = new RelocateErrorAlreadyExists(error);
+		else if (error.code === "EISDIR") relocateError = new RelocateErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") relocateError = new RelocateErrorNotDirectory(error);
+		else if (error.code === "ENOTEMPTY") relocateError = new RelocateErrorDirectoryNotEmpty(error);
+		else if (error.code === "EROFS") relocateError = new RelocateErrorReadOnly(error);
+		else if (error.code === "EINVAL") relocateError = new RelocateErrorInvalidArgument(error);
+		else if (error.code === "EBUSY") relocateError = new RelocateErrorBusy(error);
+		else if (error.code === "EXDEV") relocateError = new RelocateErrorCrossDevice(error);
+	}
+	if (relocateError === void 0) relocateError = new RelocateError(error);
+	return _duplojs_lang_either.left("file-system-relocate-error", relocateError);
+}
+function handleDenoRelocateError(error) {
+	let relocateError = void 0;
+	if (error instanceof Deno.errors.NotFound) relocateError = new RelocateErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) relocateError = new RelocateErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.AlreadyExists) relocateError = new RelocateErrorAlreadyExists(error);
+	else if (error instanceof Deno.errors.IsADirectory) relocateError = new RelocateErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) relocateError = new RelocateErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) relocateError = new RelocateErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) relocateError = new RelocateErrorBusy(error);
+	if (relocateError === void 0) relocateError = new RelocateError(error);
+	return _duplojs_lang_either.left("file-system-relocate-error", relocateError);
+}
+const relocateImplementation = require_implementor.implementFunction("relocate", {
+	NODE: async (fromPath, newParentPath) => {
+		const baseName = _duplojs_lang_path.getBaseName(fromPath);
+		if (!baseName) return _duplojs_lang_either.left("file-system-relocate-error", new RelocateErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid base name ${fromPath}`)));
+		const newPath = _duplojs_lang_path.resolveRelative([newParentPath, baseName]);
+		return require_implementor.nodeFileSystem.value.rename(fromPath, newPath).then(() => _duplojs_lang_either.right("file-system-relocate", newPath)).catch(handleNodeRelocateError);
+	},
+	DENO: async (fromPath, newParentPath) => {
+		const baseName = _duplojs_lang_path.getBaseName(fromPath);
+		if (!baseName) return Promise.resolve(_duplojs_lang_either.left("file-system-relocate-error", new RelocateErrorInvalidArgument(/* @__PURE__ */ new Error(`Invalid base name ${fromPath}`))));
+		const newPath = _duplojs_lang_path.resolveRelative([newParentPath, baseName]);
+		return Deno.rename(fromPath, newPath).then(() => _duplojs_lang_either.right("file-system-relocate", newPath)).catch(handleDenoRelocateError);
+	}
+});
+function relocate(...args) {
+	if (args.length === 1) {
+		const [toPath] = args;
+		return (fromPath) => relocateImplementation(fromPath, toPath);
+	}
+	return relocateImplementation(...args);
+}
+//#endregion
+exports.RelocateError = RelocateError;
+exports.RelocateErrorAlreadyExists = RelocateErrorAlreadyExists;
+exports.RelocateErrorBusy = RelocateErrorBusy;
+exports.RelocateErrorCrossDevice = RelocateErrorCrossDevice;
+exports.RelocateErrorDirectoryNotEmpty = RelocateErrorDirectoryNotEmpty;
+exports.RelocateErrorInvalidArgument = RelocateErrorInvalidArgument;
+exports.RelocateErrorIsDirectory = RelocateErrorIsDirectory;
+exports.RelocateErrorNotDirectory = RelocateErrorNotDirectory;
+exports.RelocateErrorNotFound = RelocateErrorNotFound;
+exports.RelocateErrorPermissionDenied = RelocateErrorPermissionDenied;
+exports.RelocateErrorReadOnly = RelocateErrorReadOnly;
+exports.relocate = relocate;

package/dist/file/relocate.d.ts

@@ -0,0 +1,46 @@
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+declare const RelocateErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-not-found", unknown>>, unknown>;
+export declare class RelocateErrorNotFound extends RelocateErrorNotFound_base {
+}
+declare const RelocateErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-permission-denied", unknown>>, unknown>;
+export declare class RelocateErrorPermissionDenied extends RelocateErrorPermissionDenied_base {
+}
+declare const RelocateErrorAlreadyExists_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-already-exists", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-already-exists", unknown>>, unknown>;
+export declare class RelocateErrorAlreadyExists extends RelocateErrorAlreadyExists_base {
+}
+declare const RelocateErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-is-directory", unknown>>, unknown>;
+export declare class RelocateErrorIsDirectory extends RelocateErrorIsDirectory_base {
+}
+declare const RelocateErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-not-directory", unknown>>, unknown>;
+export declare class RelocateErrorNotDirectory extends RelocateErrorNotDirectory_base {
+}
+declare const RelocateErrorDirectoryNotEmpty_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-directory-not-empty", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-directory-not-empty", unknown>>, unknown>;
+export declare class RelocateErrorDirectoryNotEmpty extends RelocateErrorDirectoryNotEmpty_base {
+}
+declare const RelocateErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-read-only", unknown>>, unknown>;
+export declare class RelocateErrorReadOnly extends RelocateErrorReadOnly_base {
+}
+declare const RelocateErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-invalid-argument", unknown>>, unknown>;
+export declare class RelocateErrorInvalidArgument extends RelocateErrorInvalidArgument_base {
+}
+declare const RelocateErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-busy", unknown>>, unknown>;
+export declare class RelocateErrorBusy extends RelocateErrorBusy_base {
+}
+declare const RelocateErrorCrossDevice_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-cross-device", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-cross-device", unknown>>, unknown>;
+export declare class RelocateErrorCrossDevice extends RelocateErrorCrossDevice_base {
+}
+declare const RelocateError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-relocate-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-relocate-error", unknown>>, unknown>;
+export declare class RelocateError extends RelocateError_base {
+}
+export type RelocateErrors = (RelocateErrorNotFound | RelocateErrorPermissionDenied | RelocateErrorAlreadyExists | RelocateErrorIsDirectory | RelocateErrorNotDirectory | RelocateErrorDirectoryNotEmpty | RelocateErrorReadOnly | RelocateErrorInvalidArgument | RelocateErrorBusy | RelocateErrorCrossDevice | RelocateError);
+export type RelocateResult = (DEither.Right<"file-system-relocate", string & DPath.Path> | DEither.Left<"file-system-relocate-error", RelocateErrors>);
+declare module '../implementor' {
+    interface ServerFunction {
+        relocate(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<RelocateResult>;
+    }
+}
+export declare function relocate(toPath: DPath.AnyPath): (fromPath: DPath.AnyPath) => Promise<RelocateResult>;
+export declare function relocate(fromPath: DPath.AnyPath, toPath: DPath.AnyPath): Promise<RelocateResult>;
+export {};