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

package/dist/dataStructure/fundamentalType/types/fundamentalTypes.d.ts

@@ -1,6 +1,8 @@
 import { TheFile } from '../file';
+import { TheFolder } from '../folder';
 declare module "@duplojs/lang/dataStructure" {
     interface FundamentalTypesStore {
         serverFile: TheFile;
+        serverFolder: TheFolder;
     }
 }

package/dist/dataStructure/helper/file.d.ts

@@ -1,3 +1,3 @@
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import type * as DSFile from '../../file';
-export declare function file<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FileInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FileInterface, readonly [...GenericConstraints]>>;
+export declare function file<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FileInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FileInterface<import('@duplojs/lang/path').AnyPath>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helper/fileExist.cjs

@@ -0,0 +1,7 @@
+const require_fileExist = require("../constraint/fileExist.cjs");
+//#region scripts/dataStructure/helper/fileExist.ts
+function fileExist() {
+	return require_fileExist.FileExistConstraint();
+}
+//#endregion
+exports.fileExist = fileExist;

package/dist/dataStructure/helper/fileExist.d.ts

@@ -0,0 +1,2 @@
+import { FileExistConstraint } from '../constraint';
+export declare function fileExist(): FileExistConstraint;

package/dist/dataStructure/helper/fileExist.mjs

@@ -0,0 +1,7 @@
+import { FileExistConstraint } from "../constraint/fileExist.mjs";
+//#region scripts/dataStructure/helper/fileExist.ts
+function fileExist() {
+	return FileExistConstraint();
+}
+//#endregion
+export { fileExist };

package/dist/dataStructure/helper/folder.cjs

@@ -0,0 +1,10 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_folder = require("../type/folder.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/helper/folder.ts
+function folder(constraints = []) {
+	return _duplojs_lang_dataStructure.TypeStructure(require_folder.FolderType(), constraints);
+}
+//#endregion
+exports.folder = folder;

package/dist/dataStructure/helper/folder.d.ts

@@ -0,0 +1,3 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+export declare function folder<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FolderInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FolderInterface<import('@duplojs/lang/path').AnyPath>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helper/folder.mjs

@@ -0,0 +1,8 @@
+import { FolderType } from "../type/folder.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/helper/folder.ts
+function folder(constraints = []) {
+	return DDataStructure.TypeStructure(FolderType(), constraints);
+}
+//#endregion
+export { folder };

package/dist/dataStructure/helper/folderExist.cjs

@@ -0,0 +1,7 @@
+const require_folderExist = require("../constraint/folderExist.cjs");
+//#region scripts/dataStructure/helper/folderExist.ts
+function folderExist() {
+	return require_folderExist.FolderExistConstraint();
+}
+//#endregion
+exports.folderExist = folderExist;

package/dist/dataStructure/helper/folderExist.d.ts

@@ -0,0 +1,2 @@
+import { FolderExistConstraint } from '../constraint';
+export declare function folderExist(): FolderExistConstraint;

package/dist/dataStructure/helper/folderExist.mjs

@@ -0,0 +1,7 @@
+import { FolderExistConstraint } from "../constraint/folderExist.mjs";
+//#region scripts/dataStructure/helper/folderExist.ts
+function folderExist() {
+	return FolderExistConstraint();
+}
+//#endregion
+export { folderExist };

package/dist/dataStructure/helper/index.d.ts

@@ -1,4 +1,6 @@
-export * from './exist';
+export * from './fileExist';
 export * from './file';
+export * from './folder';
+export * from './folderExist';
 export * from './mimeType';
 export * from './size';

package/dist/dataStructure/index.cjs

@@ -1,45 +1,61 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("./kind.cjs");
 const require_file = require("./fundamentalType/file.cjs");
+const require_folder = require("./fundamentalType/folder.cjs");
 const require_json = require("./common/codec/defaults/json.cjs");
 const require_string = require("./common/codec/defaults/string.cjs");
 const require_defaultInterpreter = require("./common/error/defaultInterpreter.cjs");
-const require_exist = require("./constraint/exist.cjs");
+const require_fileExist = require("./constraint/fileExist.cjs");
+const require_folderExist = require("./constraint/folderExist.cjs");
 const require_mimeType = require("./constraint/mimeType.cjs");
 const require_size = require("./constraint/size.cjs");
-const require_exist$1 = require("./helper/exist.cjs");
+const require_fileExist$1 = require("./helper/fileExist.cjs");
 const require_file$1 = require("./type/file.cjs");
+const require_folder$1 = require("./type/folder.cjs");
 const require_file$2 = require("./helper/file.cjs");
+const require_folder$2 = require("./helper/folder.cjs");
+const require_folderExist$1 = require("./helper/folderExist.cjs");
 const require_mimeType$1 = require("./helper/mimeType.cjs");
 const require_size$1 = require("./helper/size.cjs");
 //#region scripts/dataStructure/index.ts
 var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
-	ExistConstraint: () => require_exist.ExistConstraint,
+	FileExistConstraint: () => require_fileExist.FileExistConstraint,
 	FileType: () => require_file$1.FileType,
+	FolderExistConstraint: () => require_folderExist.FolderExistConstraint,
+	FolderType: () => require_folder$1.FolderType,
 	MimeTypeConstraint: () => require_mimeType.MimeTypeConstraint,
 	SizeConstraint: () => require_size.SizeConstraint,
 	TheFile: () => require_file.TheFile,
+	TheFolder: () => require_folder.TheFolder,
 	codecsJson: () => require_json.codecsJson,
 	codecsString: () => require_string.codecsString,
 	createKind: () => require_kind.createKind,
 	defaultErrorInterpreterCodecDictionary: () => require_defaultInterpreter.defaultErrorInterpreterCodecDictionary,
 	defaultErrorInterpreterDataStructureDictionary: () => require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary,
-	exist: () => require_exist$1.exist,
-	existConstraintKind: () => require_exist.existConstraintKind,
 	file: () => require_file$2.file,
+	fileExist: () => require_fileExist$1.fileExist,
+	fileExistConstraintKind: () => require_fileExist.fileExistConstraintKind,
 	fileFundamentalTypeKind: () => require_file.fileFundamentalTypeKind,
 	fileTypeKind: () => require_file$1.fileTypeKind,
+	folder: () => require_folder$2.folder,
+	folderExist: () => require_folderExist$1.folderExist,
+	folderExistConstraintKind: () => require_folderExist.folderExistConstraintKind,
+	folderFundamentalTypeKind: () => require_folder.folderFundamentalTypeKind,
+	folderTypeKind: () => require_folder$1.folderTypeKind,
 	mimeType: () => require_mimeType$1.mimeType,
 	mimeTypeConstraintKind: () => require_mimeType.mimeTypeConstraintKind,
 	size: () => require_size$1.size,
 	sizeConstraintKind: () => require_size.sizeConstraintKind
 });
 //#endregion
-exports.ExistConstraint = require_exist.ExistConstraint;
+exports.FileExistConstraint = require_fileExist.FileExistConstraint;
 exports.FileType = require_file$1.FileType;
+exports.FolderExistConstraint = require_folderExist.FolderExistConstraint;
+exports.FolderType = require_folder$1.FolderType;
 exports.MimeTypeConstraint = require_mimeType.MimeTypeConstraint;
 exports.SizeConstraint = require_size.SizeConstraint;
 exports.TheFile = require_file.TheFile;
+exports.TheFolder = require_folder.TheFolder;
 exports.codecsJson = require_json.codecsJson;
 exports.codecsString = require_string.codecsString;
 exports.createKind = require_kind.createKind;
@@ -51,11 +67,16 @@ Object.defineProperty(exports, "dataStructure_exports", {
 });
 exports.defaultErrorInterpreterCodecDictionary = require_defaultInterpreter.defaultErrorInterpreterCodecDictionary;
 exports.defaultErrorInterpreterDataStructureDictionary = require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary;
-exports.exist = require_exist$1.exist;
-exports.existConstraintKind = require_exist.existConstraintKind;
 exports.file = require_file$2.file;
+exports.fileExist = require_fileExist$1.fileExist;
+exports.fileExistConstraintKind = require_fileExist.fileExistConstraintKind;
 exports.fileFundamentalTypeKind = require_file.fileFundamentalTypeKind;
 exports.fileTypeKind = require_file$1.fileTypeKind;
+exports.folder = require_folder$2.folder;
+exports.folderExist = require_folderExist$1.folderExist;
+exports.folderExistConstraintKind = require_folderExist.folderExistConstraintKind;
+exports.folderFundamentalTypeKind = require_folder.folderFundamentalTypeKind;
+exports.folderTypeKind = require_folder$1.folderTypeKind;
 exports.mimeType = require_mimeType$1.mimeType;
 exports.mimeTypeConstraintKind = require_mimeType.mimeTypeConstraintKind;
 exports.size = require_size$1.size;

package/dist/dataStructure/index.mjs

@@ -1,38 +1,51 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
 import { TheFile, fileFundamentalTypeKind } from "./fundamentalType/file.mjs";
+import { TheFolder, folderFundamentalTypeKind } from "./fundamentalType/folder.mjs";
 import { codecsJson } from "./common/codec/defaults/json.mjs";
 import { codecsString } from "./common/codec/defaults/string.mjs";
 import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "./common/error/defaultInterpreter.mjs";
-import { ExistConstraint, existConstraintKind } from "./constraint/exist.mjs";
+import { FileExistConstraint, fileExistConstraintKind } from "./constraint/fileExist.mjs";
+import { FolderExistConstraint, folderExistConstraintKind } from "./constraint/folderExist.mjs";
 import { MimeTypeConstraint, mimeTypeConstraintKind } from "./constraint/mimeType.mjs";
 import { SizeConstraint, sizeConstraintKind } from "./constraint/size.mjs";
-import { exist } from "./helper/exist.mjs";
+import { fileExist } from "./helper/fileExist.mjs";
 import { FileType, fileTypeKind } from "./type/file.mjs";
+import { FolderType, folderTypeKind } from "./type/folder.mjs";
 import { file } from "./helper/file.mjs";
+import { folder } from "./helper/folder.mjs";
+import { folderExist } from "./helper/folderExist.mjs";
 import { mimeType } from "./helper/mimeType.mjs";
 import { size } from "./helper/size.mjs";
 //#region scripts/dataStructure/index.ts
 var dataStructure_exports = /* @__PURE__ */ __exportAll({
-	ExistConstraint: () => ExistConstraint,
+	FileExistConstraint: () => FileExistConstraint,
 	FileType: () => FileType,
+	FolderExistConstraint: () => FolderExistConstraint,
+	FolderType: () => FolderType,
 	MimeTypeConstraint: () => MimeTypeConstraint,
 	SizeConstraint: () => SizeConstraint,
 	TheFile: () => TheFile,
+	TheFolder: () => TheFolder,
 	codecsJson: () => codecsJson,
 	codecsString: () => codecsString,
 	createKind: () => createKind,
 	defaultErrorInterpreterCodecDictionary: () => defaultErrorInterpreterCodecDictionary,
 	defaultErrorInterpreterDataStructureDictionary: () => defaultErrorInterpreterDataStructureDictionary,
-	exist: () => exist,
-	existConstraintKind: () => existConstraintKind,
 	file: () => file,
+	fileExist: () => fileExist,
+	fileExistConstraintKind: () => fileExistConstraintKind,
 	fileFundamentalTypeKind: () => fileFundamentalTypeKind,
 	fileTypeKind: () => fileTypeKind,
+	folder: () => folder,
+	folderExist: () => folderExist,
+	folderExistConstraintKind: () => folderExistConstraintKind,
+	folderFundamentalTypeKind: () => folderFundamentalTypeKind,
+	folderTypeKind: () => folderTypeKind,
 	mimeType: () => mimeType,
 	mimeTypeConstraintKind: () => mimeTypeConstraintKind,
 	size: () => size,
 	sizeConstraintKind: () => sizeConstraintKind
 });
 //#endregion
-export { ExistConstraint, FileType, MimeTypeConstraint, SizeConstraint, TheFile, codecsJson, codecsString, createKind, dataStructure_exports, defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary, exist, existConstraintKind, file, fileFundamentalTypeKind, fileTypeKind, mimeType, mimeTypeConstraintKind, size, sizeConstraintKind };
+export { FileExistConstraint, FileType, FolderExistConstraint, FolderType, MimeTypeConstraint, SizeConstraint, TheFile, TheFolder, codecsJson, codecsString, createKind, dataStructure_exports, defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary, file, fileExist, fileExistConstraintKind, fileFundamentalTypeKind, fileTypeKind, folder, folderExist, folderExistConstraintKind, folderFundamentalTypeKind, folderTypeKind, mimeType, mimeTypeConstraintKind, size, sizeConstraintKind };

package/dist/dataStructure/type/folder.cjs

@@ -0,0 +1,14 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_folder = require("../fundamentalType/folder.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/type/folder.ts
+const folderTypeKind = require_kind.createKind("folder-type");
+const FolderType = _duplojs_lang_dataStructure.createType(require_folder.TheFolder, folderTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => _duplojs_lang_dataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.FolderType = FolderType;
+exports.folderTypeKind = folderTypeKind;

package/dist/dataStructure/type/folder.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+import * as FundamentalType from "../fundamentalType";
+export declare const folderTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/folder-type", unknown>>;
+export interface FolderTypeDefinition extends DDataStructure.TypeDefinition {
+}
+export interface FolderType extends DCommon.UnionToIntersection<DDataStructure.Type<FundamentalType.TheFolder, DSFile.FolderInterface, FolderTypeDefinition> & DKind.Kind<typeof folderTypeKind>> {
+}
+export declare const FolderType: () => FolderType;

package/dist/dataStructure/type/folder.mjs

@@ -0,0 +1,11 @@
+import { createKind } from "../kind.mjs";
+import { TheFolder } from "../fundamentalType/folder.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/type/folder.ts
+const folderTypeKind = createKind("folder-type");
+const FolderType = DDataStructure.createType(TheFolder, folderTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => DDataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { FolderType, folderTypeKind };

package/dist/dataStructure/type/index.d.ts

@@ -1,2 +1,3 @@
 export * from './file';
+export * from './folder';
 export type * from './types';

package/dist/dataStructure/type/types/types.d.ts

@@ -1,6 +1,8 @@
 import { FileType } from '../file';
+import { FolderType } from '../folder';
 declare module "@duplojs/lang/dataStructure" {
     interface TypesStore {
         serverFile: FileType;
+        serverFolder: FolderType;
     }
 }

package/dist/file/appendFile.cjs

@@ -1,35 +1,49 @@
 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/appendFile.ts
+var AppendFileErrorNotFound = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-not-found", Error) {};
+var AppendFileErrorPermissionDenied = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-permission-denied", Error) {};
+var AppendFileErrorIsDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-is-directory", Error) {};
+var AppendFileErrorNotDirectory = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-not-directory", Error) {};
+var AppendFileErrorNoSpace = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-no-space", Error) {};
+var AppendFileErrorReadOnly = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-read-only", Error) {};
+var AppendFileErrorInvalidArgument = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-invalid-argument", Error) {};
+var AppendFileErrorTooManyOpenFiles = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-too-many-open-files", Error) {};
+var AppendFileErrorBusy = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-busy", Error) {};
+var AppendFileError = class extends _duplojs_lang_common.DuploJSError.parentClass("file-system-append-file-error", Error) {};
 function handleNodeAppendFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-append-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-append-file-permission-denied", error);
-		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-append-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-append-file-not-directory", error);
-		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-append-file-no-space", error);
-		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-append-file-read-only", error);
-		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-append-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-append-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-append-file-busy", error);
-	}
-	return _duplojs_lang_either.left("file-system-append-file-error", error);
+	let appendFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") appendFileError = new AppendFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendFileError = new AppendFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendFileError = new AppendFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendFileError = new AppendFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendFileError = new AppendFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendFileError = new AppendFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendFileError = new AppendFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendFileError = new AppendFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendFileError = new AppendFileErrorBusy(error);
+		else appendFileError = new AppendFileError(error);
+	} else appendFileError = new AppendFileError(error);
+	return _duplojs_lang_either.left("file-system-append-file-error", appendFileError);
 }
 function handleDenoAppendFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-append-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-append-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-append-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-append-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-append-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-append-file-busy", error);
-	return _duplojs_lang_either.left("file-system-append-file-error", error);
+	let appendFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendFileError = new AppendFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendFileError = new AppendFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendFileError = new AppendFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendFileError = new AppendFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendFileError = new AppendFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendFileError = new AppendFileErrorBusy(error);
+	else appendFileError = new AppendFileError(error);
+	return _duplojs_lang_either.left("file-system-append-file-error", appendFileError);
 }
 const appendFileImplementation = require_implementor.implementFunction("appendFile", {
-	NODE: async (path, data) => {
-		return (await require_implementor.nodeFileSystem.value).appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleNodeAppendFileError);
-	},
+	NODE: async (path, data) => require_implementor.nodeFileSystem.value.appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleNodeAppendFileError),
 	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleDenoAppendFileError)
 });
 function appendFile(...args) {
@@ -40,4 +54,14 @@ function appendFile(...args) {
 	return appendFileImplementation(...args);
 }
 //#endregion
+exports.AppendFileError = AppendFileError;
+exports.AppendFileErrorBusy = AppendFileErrorBusy;
+exports.AppendFileErrorInvalidArgument = AppendFileErrorInvalidArgument;
+exports.AppendFileErrorIsDirectory = AppendFileErrorIsDirectory;
+exports.AppendFileErrorNoSpace = AppendFileErrorNoSpace;
+exports.AppendFileErrorNotDirectory = AppendFileErrorNotDirectory;
+exports.AppendFileErrorNotFound = AppendFileErrorNotFound;
+exports.AppendFileErrorPermissionDenied = AppendFileErrorPermissionDenied;
+exports.AppendFileErrorReadOnly = AppendFileErrorReadOnly;
+exports.AppendFileErrorTooManyOpenFiles = AppendFileErrorTooManyOpenFiles;
 exports.appendFile = appendFile;

package/dist/file/appendFile.d.ts

@@ -1,11 +1,43 @@
-import { FileSystemEither } from './types';
 import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
-export type AppendFileResult = FileSystemEither<DEither.Right<"append-file", void> | DEither.Left<"append-file-not-found", unknown> | DEither.Left<"append-file-permission-denied", unknown> | DEither.Left<"append-file-is-directory", unknown> | DEither.Left<"append-file-not-directory", unknown> | DEither.Left<"append-file-no-space", unknown> | DEither.Left<"append-file-read-only", unknown> | DEither.Left<"append-file-invalid-argument", unknown> | DEither.Left<"append-file-too-many-open-files", unknown> | DEither.Left<"append-file-busy", unknown> | DEither.Left<"append-file-error", unknown>>;
+import * as DCommon from "@duplojs/lang/common";
+declare const AppendFileErrorNotFound_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-found", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-found", unknown>>, unknown>;
+export declare class AppendFileErrorNotFound extends AppendFileErrorNotFound_base {
+}
+declare const AppendFileErrorPermissionDenied_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-permission-denied", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-permission-denied", unknown>>, unknown>;
+export declare class AppendFileErrorPermissionDenied extends AppendFileErrorPermissionDenied_base {
+}
+declare const AppendFileErrorIsDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-is-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-is-directory", unknown>>, unknown>;
+export declare class AppendFileErrorIsDirectory extends AppendFileErrorIsDirectory_base {
+}
+declare const AppendFileErrorNotDirectory_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-not-directory", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-not-directory", unknown>>, unknown>;
+export declare class AppendFileErrorNotDirectory extends AppendFileErrorNotDirectory_base {
+}
+declare const AppendFileErrorNoSpace_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-no-space", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-no-space", unknown>>, unknown>;
+export declare class AppendFileErrorNoSpace extends AppendFileErrorNoSpace_base {
+}
+declare const AppendFileErrorReadOnly_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-read-only", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-read-only", unknown>>, unknown>;
+export declare class AppendFileErrorReadOnly extends AppendFileErrorReadOnly_base {
+}
+declare const AppendFileErrorInvalidArgument_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-invalid-argument", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-invalid-argument", unknown>>, unknown>;
+export declare class AppendFileErrorInvalidArgument extends AppendFileErrorInvalidArgument_base {
+}
+declare const AppendFileErrorTooManyOpenFiles_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-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-append-file-too-many-open-files", unknown>>, unknown>;
+export declare class AppendFileErrorTooManyOpenFiles extends AppendFileErrorTooManyOpenFiles_base {
+}
+declare const AppendFileErrorBusy_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-busy", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-busy", unknown>>, unknown>;
+export declare class AppendFileErrorBusy extends AppendFileErrorBusy_base {
+}
+declare const AppendFileError_base: abstract new (error: Error) => DCommon.DuploJSError<"file-system-append-file-error", Error> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-file-system-append-file-error", unknown>>, unknown>;
+export declare class AppendFileError extends AppendFileError_base {
+}
+export type AppendFileErrors = (AppendFileErrorNotFound | AppendFileErrorPermissionDenied | AppendFileErrorIsDirectory | AppendFileErrorNotDirectory | AppendFileErrorNoSpace | AppendFileErrorReadOnly | AppendFileErrorInvalidArgument | AppendFileErrorTooManyOpenFiles | AppendFileErrorBusy | AppendFileError);
+export type AppendFileResult = (DEither.Right<"file-system-append-file", void> | DEither.Left<"file-system-append-file-error", AppendFileErrors>);
 declare module '../implementor' {
     interface ServerFunction {
-        appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
+        appendFile(path: DPath.AnyPath, data: Uint8Array): Promise<AppendFileResult>;
     }
 }
-export declare function appendFile(data: Uint8Array): (path: string & DPath.Path) => Promise<AppendFileResult>;
-export declare function appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
+export declare function appendFile(data: Uint8Array): (path: DPath.AnyPath) => Promise<AppendFileResult>;
+export declare function appendFile(path: DPath.AnyPath, data: Uint8Array): Promise<AppendFileResult>;
+export {};

package/dist/file/appendFile.mjs

@@ -1,33 +1,46 @@
 import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 //#region scripts/file/appendFile.ts
+var AppendFileErrorNotFound = class extends DCommon.DuploJSError.parentClass("file-system-append-file-not-found", Error) {};
+var AppendFileErrorPermissionDenied = class extends DCommon.DuploJSError.parentClass("file-system-append-file-permission-denied", Error) {};
+var AppendFileErrorIsDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-file-is-directory", Error) {};
+var AppendFileErrorNotDirectory = class extends DCommon.DuploJSError.parentClass("file-system-append-file-not-directory", Error) {};
+var AppendFileErrorNoSpace = class extends DCommon.DuploJSError.parentClass("file-system-append-file-no-space", Error) {};
+var AppendFileErrorReadOnly = class extends DCommon.DuploJSError.parentClass("file-system-append-file-read-only", Error) {};
+var AppendFileErrorInvalidArgument = class extends DCommon.DuploJSError.parentClass("file-system-append-file-invalid-argument", Error) {};
+var AppendFileErrorTooManyOpenFiles = class extends DCommon.DuploJSError.parentClass("file-system-append-file-too-many-open-files", Error) {};
+var AppendFileErrorBusy = class extends DCommon.DuploJSError.parentClass("file-system-append-file-busy", Error) {};
+var AppendFileError = class extends DCommon.DuploJSError.parentClass("file-system-append-file-error", Error) {};
 function handleNodeAppendFileError(error) {
-	if (typeof error === "object" && error !== null && "code" in error) {
-		if (error.code === "ENOENT") return DEither.left("file-system-append-file-not-found", error);
-		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-append-file-permission-denied", error);
-		else if (error.code === "EISDIR") return DEither.left("file-system-append-file-is-directory", error);
-		else if (error.code === "ENOTDIR") return DEither.left("file-system-append-file-not-directory", error);
-		else if (error.code === "ENOSPC") return DEither.left("file-system-append-file-no-space", error);
-		else if (error.code === "EROFS") return DEither.left("file-system-append-file-read-only", error);
-		else if (error.code === "EINVAL") return DEither.left("file-system-append-file-invalid-argument", error);
-		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-append-file-too-many-open-files", error);
-		else if (error.code === "EBUSY") return DEither.left("file-system-append-file-busy", error);
-	}
-	return DEither.left("file-system-append-file-error", error);
+	let appendFileError = void 0;
+	if ("code" in error) {
+		if (error.code === "ENOENT") appendFileError = new AppendFileErrorNotFound(error);
+		else if (error.code === "EACCES" || error.code === "EPERM") appendFileError = new AppendFileErrorPermissionDenied(error);
+		else if (error.code === "EISDIR") appendFileError = new AppendFileErrorIsDirectory(error);
+		else if (error.code === "ENOTDIR") appendFileError = new AppendFileErrorNotDirectory(error);
+		else if (error.code === "ENOSPC") appendFileError = new AppendFileErrorNoSpace(error);
+		else if (error.code === "EROFS") appendFileError = new AppendFileErrorReadOnly(error);
+		else if (error.code === "EINVAL") appendFileError = new AppendFileErrorInvalidArgument(error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") appendFileError = new AppendFileErrorTooManyOpenFiles(error);
+		else if (error.code === "EBUSY") appendFileError = new AppendFileErrorBusy(error);
+		else appendFileError = new AppendFileError(error);
+	} else appendFileError = new AppendFileError(error);
+	return DEither.left("file-system-append-file-error", appendFileError);
 }
 function handleDenoAppendFileError(error) {
-	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-append-file-not-found", error);
-	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-append-file-permission-denied", error);
-	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-append-file-is-directory", error);
-	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-append-file-not-directory", error);
-	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-append-file-invalid-argument", error);
-	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-append-file-busy", error);
-	return DEither.left("file-system-append-file-error", error);
+	let appendFileError = void 0;
+	if (error instanceof Deno.errors.NotFound) appendFileError = new AppendFileErrorNotFound(error);
+	else if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) appendFileError = new AppendFileErrorPermissionDenied(error);
+	else if (error instanceof Deno.errors.IsADirectory) appendFileError = new AppendFileErrorIsDirectory(error);
+	else if (error instanceof Deno.errors.NotADirectory) appendFileError = new AppendFileErrorNotDirectory(error);
+	else if (error instanceof Deno.errors.InvalidData) appendFileError = new AppendFileErrorInvalidArgument(error);
+	else if (error instanceof Deno.errors.Busy) appendFileError = new AppendFileErrorBusy(error);
+	else appendFileError = new AppendFileError(error);
+	return DEither.left("file-system-append-file-error", appendFileError);
 }
 const appendFileImplementation = implementFunction("appendFile", {
-	NODE: async (path, data) => {
-		return (await nodeFileSystem.value).appendFile(path, data).then(() => DEither.right("file-system-append-file")).catch(handleNodeAppendFileError);
-	},
+	NODE: async (path, data) => nodeFileSystem.value.appendFile(path, data).then(() => DEither.right("file-system-append-file")).catch(handleNodeAppendFileError),
 	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => DEither.right("file-system-append-file")).catch(handleDenoAppendFileError)
 });
 function appendFile(...args) {
@@ -38,4 +51,4 @@ function appendFile(...args) {
 	return appendFileImplementation(...args);
 }
 //#endregion
-export { appendFile };
+export { AppendFileError, AppendFileErrorBusy, AppendFileErrorInvalidArgument, AppendFileErrorIsDirectory, AppendFileErrorNoSpace, AppendFileErrorNotDirectory, AppendFileErrorNotFound, AppendFileErrorPermissionDenied, AppendFileErrorReadOnly, AppendFileErrorTooManyOpenFiles, appendFile };