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

package/dist/command/options/defaults/boolean.mjs

@@ -1,13 +1,25 @@
 import { createKind } from "../../kind.mjs";
-import { constructOption } from "../base.mjs";
+import { findOptionToken, optionKind } from "../base.mjs";
+import * as DArray from "@duplojs/lang/array";
 //#region scripts/command/options/defaults/boolean.ts
 const booleanOptionKind = createKind("command-boolean-option");
-const createBooleanOption = constructOption(booleanOptionKind, ({ init }) => (name, params) => init(name, (self, value, error) => {
-	if (typeof value === "string") return error.addUnexpectedOptionValueIssue(self.name, value);
-	return value !== null;
-}, {
-	description: params?.description ?? null,
-	aliases: params?.aliases ?? []
-}));
+function createBooleanOption(name, params) {
+	const self = {
+		name,
+		description: params?.description ?? null,
+		aliases: params?.aliases ?? [],
+		execute: (args, error) => {
+			const token = findOptionToken(args, self);
+			if (token?.value !== void 0) return Promise.resolve(error.addUnexpectedOptionValueIssue(self.name, token.value));
+			return Promise.resolve({
+				result: token !== null,
+				argumentRest: token ? DArray.spliceDelete(args, token.index, 1) : args
+			});
+		},
+		[optionKind.runTimeKey]: null,
+		[booleanOptionKind.runTimeKey]: null
+	};
+	return self;
+}
 //#endregion
 export { booleanOptionKind, createBooleanOption };

package/dist/command/options/defaults/simple.d.ts

@@ -1,5 +1,5 @@
 import { Option } from '../base';
-import { EligibleType } from '../../types';
+import { EligibleType, ForbiddenInvalidIdentifier } from '../../types';
 import type * as DCommon from "@duplojs/lang/common";
 import type * as DKind from "@duplojs/lang/kind";
 import type * as DDataStructure from "@duplojs/lang/dataStructure";
@@ -8,9 +8,11 @@ export interface SimpleOption<GenericName extends string = string, GenericValue
     readonly dataStructure: DDataStructure.Structure<GenericValue>;
     readonly required: boolean;
 }
-export interface CreateSimpleOptionParams {
+export interface CreateSimpleOptionParams<GenericAliases extends readonly string[] = readonly string[]> {
     description?: string;
-    aliases?: readonly string[];
+    aliases?: (GenericAliases & {
+        readonly [Index in keyof GenericAliases]: ForbiddenInvalidIdentifier<GenericAliases[Index]>;
+    });
     required?: boolean;
 }
-export declare const createOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateSimpleOptionParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams & CreateSimpleOptionParams) => SimpleOption<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;
+export declare const createOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericAliases extends readonly string[] = readonly string[], const GenericParams extends CreateSimpleOptionParams<GenericAliases> = {}>(name: GenericName & ForbiddenInvalidIdentifier<GenericName>, dataStructure: GenericStructure, params?: GenericParams & CreateSimpleOptionParams<GenericAliases>) => SimpleOption<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;

package/dist/command/types/forbiddenInvalidIdentifier.d.ts

@@ -0,0 +1,6 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DString from "@duplojs/lang/string";
+type AlphanumericCharacter = (DString.CharactersRangeStore["a-z" | "A-Z"] | DString.Digit);
+type AllowedIdentifierCharacter = (AlphanumericCharacter | "_" | "-");
+export type ForbiddenInvalidIdentifier<GenericName extends string> = DCommon.ContainExtends<GenericName, DCommon.BaseConstraint> extends true ? DCommon.ComputedTypeError<"Identifier cannot be a constrained string."> : DString.IsLiteral<GenericName> extends true ? DCommon.IsUnion<GenericName> extends true ? DCommon.ComputedTypeError<"Identifier must be a single string literal."> : DCommon.IsEqual<GenericName, ""> extends true ? DCommon.ComputedTypeError<"Identifier cannot be empty."> : DString.StartsWith<GenericName, AlphanumericCharacter> extends true ? DString.IsAllowedString<GenericName, AllowedIdentifierCharacter> extends true ? DString.IsAllowedString<GenericName, DString.Digit> extends false ? unknown : DCommon.ComputedTypeError<`Identifier "${GenericName}" cannot contain only digits.`> : DCommon.ComputedTypeError<`Identifier "${GenericName}" contains invalid characters (allowed: A-Z, a-z, 0-9, "_" and "-").`> : DCommon.ComputedTypeError<`Identifier "${GenericName}" must start with a letter or digit.`> : DCommon.ComputedTypeError<"Identifier must be a known string literal.">;
+export {};

package/dist/command/types/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './eligibleType';
 export type * from './forbiddenDuplicateName';
+export type * from './forbiddenInvalidIdentifier';

package/dist/common/environmentVariable/index.d.ts

@@ -3,7 +3,7 @@ import * as DEither from "@duplojs/lang/either";
 import type * as DPath from "@duplojs/lang/path";
 import type * as DSFile from '../../file';
 export interface EnvironmentVariableFileParams {
-    includedEnvironmentFiles?: (string & DPath.Path)[];
+    includedEnvironmentFiles?: DPath.AnyPath[];
     override?: boolean;
     justRead?: boolean;
     codecs?: DDataStructure.Codecs;

package/dist/common/environmentVariable/overrideEnvironmentVariables.d.ts

@@ -1,3 +1,3 @@
-export declare function overrideEnvironmentVariables(arrayEnv: Record<string, string>[], override: boolean): {
+export declare function overrideEnvironmentVariables(arrayEnv: readonly Record<string, string>[], override: boolean): {
     [x: string]: string;
 };

package/dist/common/environmentVariable/parseEnvironmentFiles.d.ts

@@ -1,4 +1,5 @@
 import type * as DPath from "@duplojs/lang/path";
 import * as DEither from "@duplojs/lang/either";
+import * as DSFile from '../../file';
 export declare function parseEnvironmentLine(line: string): Record<string, string>;
-export declare function parseEnvironmentFiles(baseEnv: Record<string, string>, paths: (string & DPath.Path)[]): Promise<DEither.Left<"file-system-read-text-file-not-found", unknown> | DEither.Left<"file-system-read-text-file-permission-denied", unknown> | DEither.Left<"file-system-read-text-file-is-directory", unknown> | DEither.Left<"file-system-read-text-file-not-directory", unknown> | DEither.Left<"file-system-read-text-file-too-many-open-files", unknown> | DEither.Left<"file-system-read-text-file-busy", unknown> | DEither.Left<"file-system-read-text-file-error", unknown> | Record<string, string>[]>;
+export declare function parseEnvironmentFiles(baseEnv: Record<string, string>, paths: DPath.AnyPath[]): Promise<DEither.Left<"file-system-read-text-file-error", DSFile.ReadTextFileErrors> | readonly Record<string, string>[]>;

package/dist/common/index.cjs

@@ -7,6 +7,7 @@ const require_index = require("./environmentVariable/index.cjs");
 const require_environmentVariableOrThrow = require("./environmentVariableOrThrow.cjs");
 const require_exitProcess = require("./exitProcess.cjs");
 const require_getProcessArguments = require("./getProcessArguments.cjs");
+const require_getCurrentDirectoryName = require("./meta/getCurrentDirectoryName.cjs");
 //#region scripts/common/index.ts
 var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	EnvironmentVariableError: () => require_environmentVariableOrThrow.EnvironmentVariableError,
@@ -15,6 +16,7 @@ var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	environmentVariable: () => require_index.environmentVariable,
 	environmentVariableOrThrow: () => require_environmentVariableOrThrow.environmentVariableOrThrow,
 	exitProcess: () => require_exitProcess.exitProcess,
+	getCurrentDirectoryName: () => require_getCurrentDirectoryName.getCurrentDirectoryName,
 	getCurrentWorkDirectory: () => require_getCurrentWorkDirectory.getCurrentWorkDirectory,
 	getCurrentWorkDirectoryOrThrow: () => require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow,
 	getProcessArguments: () => require_getProcessArguments.getProcessArguments,
@@ -34,6 +36,7 @@ Object.defineProperty(exports, "common_exports", {
 exports.environmentVariable = require_index.environmentVariable;
 exports.environmentVariableOrThrow = require_environmentVariableOrThrow.environmentVariableOrThrow;
 exports.exitProcess = require_exitProcess.exitProcess;
+exports.getCurrentDirectoryName = require_getCurrentDirectoryName.getCurrentDirectoryName;
 exports.getCurrentWorkDirectory = require_getCurrentWorkDirectory.getCurrentWorkDirectory;
 exports.getCurrentWorkDirectoryOrThrow = require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow;
 exports.getProcessArguments = require_getProcessArguments.getProcessArguments;

package/dist/common/index.d.ts

@@ -6,3 +6,4 @@ export * from './environmentVariable';
 export * from './environmentVariableOrThrow';
 export * from './exitProcess';
 export * from './getProcessArguments';
+export * from './meta';

package/dist/common/index.mjs

@@ -7,6 +7,7 @@ import { environmentVariable } from "./environmentVariable/index.mjs";
 import { EnvironmentVariableError, environmentVariableOrThrow } from "./environmentVariableOrThrow.mjs";
 import { exitProcess } from "./exitProcess.mjs";
 import { getProcessArguments } from "./getProcessArguments.mjs";
+import { getCurrentDirectoryName } from "./meta/getCurrentDirectoryName.mjs";
 //#region scripts/common/index.ts
 var common_exports = /* @__PURE__ */ __exportAll({
 	EnvironmentVariableError: () => EnvironmentVariableError,
@@ -15,6 +16,7 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	environmentVariable: () => environmentVariable,
 	environmentVariableOrThrow: () => environmentVariableOrThrow,
 	exitProcess: () => exitProcess,
+	getCurrentDirectoryName: () => getCurrentDirectoryName,
 	getCurrentWorkDirectory: () => getCurrentWorkDirectory,
 	getCurrentWorkDirectoryOrThrow: () => getCurrentWorkDirectoryOrThrow,
 	getProcessArguments: () => getProcessArguments,
@@ -22,4 +24,4 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	setCurrentWorkingDirectoryOrThrow: () => setCurrentWorkingDirectoryOrThrow
 });
 //#endregion
-export { EnvironmentVariableError, GetCurrentWorkDirectoryError, SetCurrentWorkingDirectoryError, common_exports, environmentVariable, environmentVariableOrThrow, exitProcess, getCurrentWorkDirectory, getCurrentWorkDirectoryOrThrow, getProcessArguments, setCurrentWorkingDirectory, setCurrentWorkingDirectoryOrThrow };
+export { EnvironmentVariableError, GetCurrentWorkDirectoryError, SetCurrentWorkingDirectoryError, common_exports, environmentVariable, environmentVariableOrThrow, exitProcess, getCurrentDirectoryName, getCurrentWorkDirectory, getCurrentWorkDirectoryOrThrow, getProcessArguments, setCurrentWorkingDirectory, setCurrentWorkingDirectoryOrThrow };

package/dist/common/meta/getCurrentDirectoryName.cjs

@@ -0,0 +1,10 @@
+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_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/common/meta/getCurrentDirectoryName.ts
+const getCurrentDirectoryName = require_implementor.implementFunction("getCurrentDirectoryName", { NODE: (importMeta) => _duplojs_lang_common.pipe(importMeta.dirname, _duplojs_lang_path.createAbsoluteOrThrow) });
+//#endregion
+exports.getCurrentDirectoryName = getCurrentDirectoryName;

package/dist/common/meta/getCurrentDirectoryName.d.ts

@@ -0,0 +1,7 @@
+import * as DPath from "@duplojs/lang/path";
+declare module '../../implementor' {
+    interface ServerFunction {
+        getCurrentDirectoryName(importMeta: ImportMeta): string & DPath.Absolute;
+    }
+}
+export declare const getCurrentDirectoryName: (importMeta: ImportMeta) => string & DPath.Absolute;

package/dist/common/meta/getCurrentDirectoryName.mjs

@@ -0,0 +1,7 @@
+import { implementFunction } from "../../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/common/meta/getCurrentDirectoryName.ts
+const getCurrentDirectoryName = implementFunction("getCurrentDirectoryName", { NODE: (importMeta) => DCommon.pipe(importMeta.dirname, DPath.createAbsoluteOrThrow) });
+//#endregion
+export { getCurrentDirectoryName };

package/dist/common/meta/index.d.ts

@@ -0,0 +1,7 @@
+import type * as DKind from "@duplojs/lang/kind";
+declare const importMetaKind: DKind.Handler<DKind.Definition<"@DuplojsServer/import-meta", unknown>>;
+declare global {
+    interface ImportMeta extends DKind.Kind<typeof importMetaKind> {
+    }
+}
+export * from './getCurrentDirectoryName';

package/dist/dataStructure/common/codec/defaults/json.cjs

@@ -1,6 +1,8 @@
 const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
 const require_fileInterface = require("../../../../file/fileInterface.cjs");
+const require_folderInterface = require("../../../../file/folderInterface.cjs");
 const require_file = require("../../../fundamentalType/file.cjs");
+const require_folder = require("../../../fundamentalType/folder.cjs");
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
@@ -8,7 +10,16 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 //#region scripts/dataStructure/common/codec/defaults/json.ts
 const codecsJson = _duplojs_lang_dataStructure.createCodecs({
 	..._duplojs_lang_dataStructure.codecsJson.definition,
-	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string" && _duplojs_lang_path.is(data), (data) => data.path, (data) => require_fileInterface.createFileInterface(data))
+	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_fileInterface.createFileInterface(result);
+	}),
+	folder: _duplojs_lang_dataStructure.createCodec(require_folder.TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_folderInterface.createFolderInterface(result);
+	})
 });
 //#endregion
 exports.codecsJson = codecsJson;

package/dist/dataStructure/common/codec/defaults/json.d.ts

@@ -1,8 +1,8 @@
-import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as FundamentalType from "../../../fundamentalType";
 export declare const codecsJson: DDataStructure.Codecs<{
-    file: DDataStructure.Codec<FundamentalType.TheFile, string & DPath.Path>;
+    file: DDataStructure.Codec<FundamentalType.TheFile, string>;
+    folder: DDataStructure.Codec<FundamentalType.TheFolder, string>;
     bigint: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheBigint, string>;
     date: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheDate, string>;
     time: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheTime, string>;

package/dist/dataStructure/common/codec/defaults/json.mjs

@@ -1,11 +1,22 @@
 import { createFileInterface } from "../../../../file/fileInterface.mjs";
+import { createFolderInterface } from "../../../../file/folderInterface.mjs";
 import { TheFile } from "../../../fundamentalType/file.mjs";
+import { TheFolder } from "../../../fundamentalType/folder.mjs";
 import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 //#region scripts/dataStructure/common/codec/defaults/json.ts
 const codecsJson = DDataStructure.createCodecs({
 	...DDataStructure.codecsJson.definition,
-	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string" && DPath.is(data), (data) => data.path, (data) => createFileInterface(data))
+	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFileInterface(result);
+	}),
+	folder: DDataStructure.createCodec(TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFolderInterface(result);
+	})
 });
 //#endregion
 export { codecsJson };

package/dist/dataStructure/common/codec/defaults/string.cjs

@@ -1,6 +1,8 @@
 const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
 const require_fileInterface = require("../../../../file/fileInterface.cjs");
+const require_folderInterface = require("../../../../file/folderInterface.cjs");
 const require_file = require("../../../fundamentalType/file.cjs");
+const require_folder = require("../../../fundamentalType/folder.cjs");
 let _duplojs_lang_path = require("@duplojs/lang/path");
 _duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
 let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
@@ -8,7 +10,16 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 //#region scripts/dataStructure/common/codec/defaults/string.ts
 const codecsString = _duplojs_lang_dataStructure.createCodecs({
 	..._duplojs_lang_dataStructure.codecsString.definition,
-	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string" && _duplojs_lang_path.is(data), (data) => data.path, (data) => require_fileInterface.createFileInterface(data))
+	file: _duplojs_lang_dataStructure.createCodec(require_file.TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_fileInterface.createFileInterface(result);
+	}),
+	folder: _duplojs_lang_dataStructure.createCodec(require_folder.TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = _duplojs_lang_path.normalize(data);
+		if (!result) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return require_folderInterface.createFolderInterface(result);
+	})
 });
 //#endregion
 exports.codecsString = codecsString;

package/dist/dataStructure/common/codec/defaults/string.d.ts

@@ -1,8 +1,8 @@
-import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as FundamentalType from "../../../fundamentalType";
 export declare const codecsString: DDataStructure.Codecs<{
-    file: DDataStructure.Codec<FundamentalType.TheFile, string & DPath.Path>;
+    file: DDataStructure.Codec<FundamentalType.TheFile, string>;
+    folder: DDataStructure.Codec<FundamentalType.TheFolder, string>;
     bigint: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheBigint, string>;
     boolean: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheBoolean, "true" | "false">;
     date: import('@duplojs/lang/dataStructure').Codec<DDataStructure.TheDate, string>;

package/dist/dataStructure/common/codec/defaults/string.mjs

@@ -1,11 +1,22 @@
 import { createFileInterface } from "../../../../file/fileInterface.mjs";
+import { createFolderInterface } from "../../../../file/folderInterface.mjs";
 import { TheFile } from "../../../fundamentalType/file.mjs";
+import { TheFolder } from "../../../fundamentalType/folder.mjs";
 import * as DPath from "@duplojs/lang/path";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 //#region scripts/dataStructure/common/codec/defaults/string.ts
 const codecsString = DDataStructure.createCodecs({
 	...DDataStructure.codecsString.definition,
-	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string" && DPath.is(data), (data) => data.path, (data) => createFileInterface(data))
+	file: DDataStructure.createCodec(TheFile, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFileInterface(result);
+	}),
+	folder: DDataStructure.createCodec(TheFolder, (data) => typeof data === "string", (data) => data.path, (data) => {
+		const result = DPath.normalize(data);
+		if (!result) return DDataStructure.ErrorSymbol;
+		return createFolderInterface(result);
+	})
 });
 //#endregion
 export { codecsString };

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

@@ -6,6 +6,7 @@ _duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructur
 const defaultErrorInterpreterDataStructureDictionary = {
 	..._duplojs_lang_dataStructure.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.`;
@@ -14,7 +15,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 = [..._duplojs_lang_dataStructure.defaultErrorInterpreterCodecDictionary, [require_json.codecsJson.definition.file, (_codec, issue) => {
 	if (issue.from === "predicate") return _duplojs_lang_dataStructure.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/common/error/defaultInterpreter.d.ts

@@ -1,9 +1,11 @@
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsServerDataStructure/file-type": () => string;
+    readonly "@DuplojsServerDataStructure/folder-type": () => string;
     readonly "@DuplojsServerDataStructure/size-constraint": (source: import('../..').SizeConstraint) => string;
     readonly "@DuplojsServerDataStructure/mime-type-constraint": (source: import('../..').MimeTypeConstraint) => string;
-    readonly "@DuplojsServerDataStructure/exist-constraint": () => string;
+    readonly "@DuplojsServerDataStructure/file-exist-constraint": () => string;
+    readonly "@DuplojsServerDataStructure/folder-exist-constraint": () => string;
     readonly "@DuplojsLangDataStructure/array-structure": () => string;
     readonly "@DuplojsLangDataStructure/lazy-structure": () => string;
     readonly "@DuplojsLangDataStructure/non-encodable-string-structure": (source: import('@duplojs/lang/dataStructure').NonEncodableStringStructure) => string;
@@ -29,9 +31,11 @@ export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsLangDataStructure/between-than-constraint": (source: import('@duplojs/lang/dataStructure').BetweenThanConstraint<number, number>) => string;
     readonly "@DuplojsLangDataStructure/between-than-or-equal-constraint": (source: import('@duplojs/lang/dataStructure').BetweenThanOrEqualConstraint<number, number>) => string;
     readonly "@DuplojsLangDataStructure/email-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/ends-with-constraint": (source: import('@duplojs/lang/dataStructure').EndsWithConstraint<string>) => string;
     readonly "@DuplojsLangDataStructure/even-constraint": () => string;
     readonly "@DuplojsLangDataStructure/greater-than-constraint": (source: import('@duplojs/lang/dataStructure').GreaterThanConstraint<number>) => string;
     readonly "@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source: import('@duplojs/lang/dataStructure').GreaterThanOrEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/include-constraint": (source: import('@duplojs/lang/dataStructure').IncludeConstraint<string>) => string;
     readonly "@DuplojsLangDataStructure/integer-constraint": () => string;
     readonly "@DuplojsLangDataStructure/less-than-constraint": (source: import('@duplojs/lang/dataStructure').LessThanConstraint<number>) => string;
     readonly "@DuplojsLangDataStructure/less-than-or-equal-constraint": (source: import('@duplojs/lang/dataStructure').LessThanOrEqualConstraint<number>) => string;
@@ -51,6 +55,7 @@ export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsLangDataStructure/regex-constraint": (source: import('@duplojs/lang/dataStructure').RegexConstraint) => string;
     readonly "@DuplojsLangDataStructure/safe-constraint": () => string;
     readonly "@DuplojsLangDataStructure/segment-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/starts-with-constraint": (source: import('@duplojs/lang/dataStructure').StartsWithConstraint<string>) => string;
     readonly "@DuplojsLangDataStructure/strict-negative-constraint": () => string;
     readonly "@DuplojsLangDataStructure/strict-positive-constraint": () => string;
     readonly "@DuplojsLangDataStructure/string-length-equal-constraint": (source: import('@duplojs/lang/dataStructure').StringLengthEqualConstraint<number>) => string;
@@ -61,4 +66,4 @@ export declare const defaultErrorInterpreterDataStructureDictionary: {
     readonly "@DuplojsLangModeling/new-type-structure": () => string;
     readonly "@DuplojsLangModeling/tagged-object-structure": (source: import('@duplojs/lang/modeling').TaggedObjectStructure<import('@duplojs/lang/modeling').ObjectTag<string>>) => string;
 };
-export declare const defaultErrorInterpreterCodecDictionary: [[DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBoolean, "true" | "false">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNull, "null">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNumber, string & import('@duplojs/lang/string').Number>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheUndefined, "undefined" | undefined>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<import('../..').TheFile, string & import('@duplojs/lang/path').Path>, (_codec: DDataStructure.Codec<DDataStructure.FundamentalType<unknown>, unknown>, issue: DDataStructure.EncodeIssue | DDataStructure.DecodeIssue) => string]];
+export declare const defaultErrorInterpreterCodecDictionary: [[DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBigint, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheBoolean, "true" | "false">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheDate, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNull, "null">, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheNumber, string & import('@duplojs/lang/string').Number>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheTime, string>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<DDataStructure.TheUndefined, "undefined" | undefined>, (codec: import('@duplojs/lang/dataStructure').Codec, issue: import('@duplojs/lang/dataStructure').EncodeIssue | import('@duplojs/lang/dataStructure').DecodeIssue) => string], [DDataStructure.Codec<import('../..').TheFile, string>, (_codec: DDataStructure.Codec<DDataStructure.FundamentalType<unknown>, unknown>, issue: DDataStructure.EncodeIssue | DDataStructure.DecodeIssue) => string]];

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';