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

package/dist/dataStructure/common/error/defaultInterpreter.mjs

@@ -4,6 +4,7 @@ import * as DDataStructure from "@duplojs/lang/dataStructure";
 const defaultErrorInterpreterDataStructureDictionary = {
 	...DDataStructure.defaultErrorInterpreterDataStructureDictionary,
 	"@DuplojsServerDataStructure/file-type": () => "Expected a valid file.",
+	"@DuplojsServerDataStructure/folder-type": () => "Expected a valid folder.",
 	"@DuplojsServerDataStructure/size-constraint": (source) => {
 		const { min, max } = source.definition;
 		if (min !== void 0 && max !== void 0) return `Expected a file size between ${min} and ${max} bytes.`;
@@ -12,7 +13,8 @@ const defaultErrorInterpreterDataStructureDictionary = {
 		return "Expected a valid file size.";
 	},
 	"@DuplojsServerDataStructure/mime-type-constraint": (source) => `Expected a file with a MIME type matching ${source.definition.regex.toString()}.`,
-	"@DuplojsServerDataStructure/exist-constraint": () => "Expected the file to exist."
+	"@DuplojsServerDataStructure/file-exist-constraint": () => "Expected the file to exist.",
+	"@DuplojsServerDataStructure/folder-exist-constraint": () => "Expected the folder to exist."
 };
 const defaultErrorInterpreterCodecDictionary = [...DDataStructure.defaultErrorInterpreterCodecDictionary, [codecsJson.definition.file, (_codec, issue) => {
 	if (issue.from === "predicate") return DDataStructure.encodeIssueKind.has(issue) ? "The JSON file codec must produce a valid file path string." : "Expected a valid file path string for the JSON file codec.";

package/dist/dataStructure/constraint/{exist.cjs → fileExist.cjs}

@@ -4,9 +4,9 @@ let _duplojs_lang_either = require("@duplojs/lang/either");
 _duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
 _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
-//#region scripts/dataStructure/constraint/exist.ts
-const existConstraintKind = require_kind.createKind("exist-constraint");
-const ExistConstraint = _duplojs_lang_dataStructure.createConstraint(existConstraintKind, ({ init }) => () => init({}, {
+//#region scripts/dataStructure/constraint/fileExist.ts
+const fileExistConstraintKind = require_kind.createKind("file-exist-constraint");
+const FileExistConstraint = _duplojs_lang_dataStructure.createConstraint(fileExistConstraintKind, ({ init }) => () => init({}, {
 	executeCheck: async (_self, data) => {
 		const result = _duplojs_lang_either.rightPipe(await data.stat(), (stat) => stat.isFile ? stat : _duplojs_lang_either.fail());
 		if (_duplojs_lang_either.isLeft(result)) return _duplojs_lang_dataStructure.ErrorSymbol;
@@ -15,5 +15,5 @@ const ExistConstraint = _duplojs_lang_dataStructure.createConstraint(existConstr
 	isAsynchronous: () => true
 }));
 //#endregion
-exports.ExistConstraint = ExistConstraint;
-exports.existConstraintKind = existConstraintKind;
+exports.FileExistConstraint = FileExistConstraint;
+exports.fileExistConstraintKind = fileExistConstraintKind;

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

@@ -0,0 +1,10 @@
+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';
+export declare const fileExistConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/file-exist-constraint", unknown>>;
+export interface FileExistConstraintDefinition extends DDataStructure.ConstraintDefinition {
+}
+export interface FileExistConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, FileExistConstraintDefinition> & DKind.Kind<typeof fileExistConstraintKind>> {
+}
+export declare const FileExistConstraint: () => FileExistConstraint;

package/dist/dataStructure/constraint/{exist.mjs → fileExist.mjs}

@@ -1,9 +1,9 @@
 import { createKind } from "../kind.mjs";
 import * as DEither from "@duplojs/lang/either";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
-//#region scripts/dataStructure/constraint/exist.ts
-const existConstraintKind = createKind("exist-constraint");
-const ExistConstraint = DDataStructure.createConstraint(existConstraintKind, ({ init }) => () => init({}, {
+//#region scripts/dataStructure/constraint/fileExist.ts
+const fileExistConstraintKind = createKind("file-exist-constraint");
+const FileExistConstraint = DDataStructure.createConstraint(fileExistConstraintKind, ({ init }) => () => init({}, {
 	executeCheck: async (_self, data) => {
 		const result = DEither.rightPipe(await data.stat(), (stat) => stat.isFile ? stat : DEither.fail());
 		if (DEither.isLeft(result)) return DDataStructure.ErrorSymbol;
@@ -12,4 +12,4 @@ const ExistConstraint = DDataStructure.createConstraint(existConstraintKind, ({
 	isAsynchronous: () => true
 }));
 //#endregion
-export { ExistConstraint, existConstraintKind };
+export { FileExistConstraint, fileExistConstraintKind };

package/dist/dataStructure/constraint/folderExist.cjs

@@ -0,0 +1,19 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/constraint/folderExist.ts
+const folderExistConstraintKind = require_kind.createKind("folder-exist-constraint");
+const FolderExistConstraint = _duplojs_lang_dataStructure.createConstraint(folderExistConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: async (_self, data) => {
+		const result = _duplojs_lang_either.rightPipe(await data.stat(), (stat) => stat.isDirectory ? stat : _duplojs_lang_either.fail());
+		if (_duplojs_lang_either.isLeft(result)) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+exports.FolderExistConstraint = FolderExistConstraint;
+exports.folderExistConstraintKind = folderExistConstraintKind;

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

@@ -0,0 +1,10 @@
+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';
+export declare const folderExistConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/folder-exist-constraint", unknown>>;
+export interface FolderExistConstraintDefinition extends DDataStructure.ConstraintDefinition {
+}
+export interface FolderExistConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FolderInterface, DSFile.FolderInterface, FolderExistConstraintDefinition> & DKind.Kind<typeof folderExistConstraintKind>> {
+}
+export declare const FolderExistConstraint: () => FolderExistConstraint;

package/dist/dataStructure/constraint/folderExist.mjs

@@ -0,0 +1,15 @@
+import { createKind } from "../kind.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/constraint/folderExist.ts
+const folderExistConstraintKind = createKind("folder-exist-constraint");
+const FolderExistConstraint = DDataStructure.createConstraint(folderExistConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: async (_self, data) => {
+		const result = DEither.rightPipe(await data.stat(), (stat) => stat.isDirectory ? stat : DEither.fail());
+		if (DEither.isLeft(result)) return DDataStructure.ErrorSymbol;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+export { FolderExistConstraint, folderExistConstraintKind };

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

@@ -1,4 +1,5 @@
-export * from './exist';
+export * from './fileExist';
+export * from './folderExist';
 export * from './mimeType';
 export * from './size';
 export type * from './types';

package/dist/dataStructure/constraint/mimeType.cjs

@@ -8,7 +8,7 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 const mimeTypeConstraintKind = require_kind.createKind("mime-type-constraint");
 const MimeTypeConstraint = _duplojs_lang_dataStructure.createConstraint(mimeTypeConstraintKind, ({ init }) => (mimeType) => init({ regex: _duplojs_lang_common.toRegExp(mimeType) }, {
 	executeCheck: (self, data) => {
-		if (self.definition.regex.test(data.getMimeType() ?? "")) return _duplojs_lang_dataStructure.ErrorSymbol;
+		if (!self.definition.regex.test(data.getMimeType() ?? "")) return _duplojs_lang_dataStructure.ErrorSymbol;
 		return _duplojs_lang_dataStructure.SuccessSymbol;
 	},
 	isAsynchronous: () => false

package/dist/dataStructure/constraint/mimeType.mjs

@@ -5,7 +5,7 @@ import * as DDataStructure from "@duplojs/lang/dataStructure";
 const mimeTypeConstraintKind = createKind("mime-type-constraint");
 const MimeTypeConstraint = DDataStructure.createConstraint(mimeTypeConstraintKind, ({ init }) => (mimeType) => init({ regex: DCommon.toRegExp(mimeType) }, {
 	executeCheck: (self, data) => {
-		if (self.definition.regex.test(data.getMimeType() ?? "")) return DDataStructure.ErrorSymbol;
+		if (!self.definition.regex.test(data.getMimeType() ?? "")) return DDataStructure.ErrorSymbol;
 		return DDataStructure.SuccessSymbol;
 	},
 	isAsynchronous: () => false

package/dist/dataStructure/constraint/types/constraints.d.ts

@@ -1,9 +1,11 @@
-import { ExistConstraint } from '../exist';
+import { FileExistConstraint } from '../fileExist';
+import { FolderExistConstraint } from '../folderExist';
 import { MimeTypeConstraint } from '../mimeType';
 import { SizeConstraint } from '../size';
 declare module "@duplojs/lang/dataStructure" {
     interface ConstraintsStore {
-        exist: ExistConstraint;
+        fileExist: FileExistConstraint;
+        folderExist: FolderExistConstraint;
         size: SizeConstraint;
         mimeType: MimeTypeConstraint;
     }

package/dist/dataStructure/fundamentalType/folder.cjs

@@ -0,0 +1,11 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_folderInterface = require("../../file/folderInterface.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/fundamentalType/folder.ts
+const folderFundamentalTypeKind = require_kind.createKind("folder-fundamental-type");
+const TheFolder = _duplojs_lang_dataStructure.createFundamentalType(folderFundamentalTypeKind, (self, data) => require_folderInterface.isFolderInterface(data) ? _duplojs_lang_dataStructure.SuccessSymbol : _duplojs_lang_dataStructure.ErrorSymbol);
+//#endregion
+exports.TheFolder = TheFolder;
+exports.folderFundamentalTypeKind = folderFundamentalTypeKind;

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

@@ -0,0 +1,8 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DSFile from '../../file';
+export declare const folderFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/folder-fundamental-type", unknown>>;
+export interface TheFolder extends DCommon.UnionToIntersection<DDataStructure.FundamentalType<DSFile.FolderInterface> & DKind.Kind<typeof folderFundamentalTypeKind>> {
+}
+export declare const TheFolder: TheFolder;

package/dist/dataStructure/fundamentalType/folder.mjs

@@ -0,0 +1,8 @@
+import { isFolderInterface } from "../../file/folderInterface.mjs";
+import { createKind } from "../kind.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/fundamentalType/folder.ts
+const folderFundamentalTypeKind = createKind("folder-fundamental-type");
+const TheFolder = DDataStructure.createFundamentalType(folderFundamentalTypeKind, (self, data) => isFolderInterface(data) ? DDataStructure.SuccessSymbol : DDataStructure.ErrorSymbol);
+//#endregion
+export { TheFolder, folderFundamentalTypeKind };

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

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

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<DSFile.EntryPath>, 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<DSFile.EntryPath>, 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) {