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

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

@@ -0,0 +1,26 @@
+import { codecsJson } from "../codec/defaults/json.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/common/error/defaultInterpreter.ts
+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.`;
+		if (min !== void 0) return `Expected a file size of at least ${min} bytes.`;
+		if (max !== void 0) return `Expected a file size of at most ${max} bytes.`;
+		return "Expected a valid file size.";
+	},
+	"@DuplojsServerDataStructure/mime-type-constraint": (source) => `Expected a file with a MIME type matching ${source.definition.regex.toString()}.`,
+	"@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.";
+	if (issue.from === "encoding") return "The JSON file codec could not encode the file.";
+	if (issue.from === "decoding") return "The JSON file codec could not decode the value as a file.";
+	return `The JSON file codec encountered an external error while ${DDataStructure.encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+}]];
+//#endregion
+export { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary };

package/dist/dataStructure/common/error/index.d.ts

@@ -0,0 +1 @@
+export * from './defaultInterpreter';

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

@@ -0,0 +1,2 @@
+export * from './codec';
+export * from './error';

package/dist/dataStructure/constraint/fileExist.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/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;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+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/fileExist.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/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;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+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

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

package/dist/dataStructure/constraint/mimeType.cjs

@@ -0,0 +1,18 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/constraint/mimeType.ts
+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;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.MimeTypeConstraint = MimeTypeConstraint;
+exports.mimeTypeConstraintKind = mimeTypeConstraintKind;

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

@@ -0,0 +1,11 @@
+import * 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 mimeTypeConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/mime-type-constraint", unknown>>;
+export interface MimeTypeConstraintDefinition extends DDataStructure.ConstraintDefinition {
+    regex: RegExp;
+}
+export interface MimeTypeConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, MimeTypeConstraintDefinition> & DKind.Kind<typeof mimeTypeConstraintKind>> {
+}
+export declare const MimeTypeConstraint: (mimeType: Parameters<typeof DCommon.toRegExp>[0]) => MimeTypeConstraint;

package/dist/dataStructure/constraint/mimeType.mjs

@@ -0,0 +1,14 @@
+import { createKind } from "../kind.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/constraint/mimeType.ts
+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;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => false
+}));
+//#endregion
+export { MimeTypeConstraint, mimeTypeConstraintKind };

package/dist/dataStructure/constraint/size.cjs

@@ -0,0 +1,29 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/constraint/size.ts
+const sizeConstraintKind = require_kind.createKind("size-constraint");
+const SizeConstraint = _duplojs_lang_dataStructure.createConstraint(sizeConstraintKind, ({ init }) => (params) => init({
+	max: params.max === void 0 ? void 0 : _duplojs_lang_common.stringToBytes(params.max),
+	min: params.min === void 0 ? void 0 : _duplojs_lang_common.stringToBytes(params.min)
+}, {
+	executeCheck: async (self, data) => {
+		const result = _duplojs_lang_either.rightPipe(await data.stat(), (stat) => {
+			if (!stat.isFile) return _duplojs_lang_either.fail();
+			if (self.definition.max !== void 0 && stat.sizeBytes > self.definition.max) return _duplojs_lang_either.fail();
+			if (self.definition.min !== void 0 && stat.sizeBytes < self.definition.min) return _duplojs_lang_either.fail();
+			return stat;
+		});
+		if (_duplojs_lang_either.isLeft(result)) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+exports.SizeConstraint = SizeConstraint;
+exports.sizeConstraintKind = sizeConstraintKind;

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

@@ -0,0 +1,16 @@
+import * 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 sizeConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/size-constraint", unknown>>;
+export interface SizeConstraintDefinition extends DDataStructure.ConstraintDefinition {
+    min?: number;
+    max?: number;
+}
+export interface SizeConstraintParams {
+    min?: number | DCommon.BytesInString;
+    max?: number | DCommon.BytesInString;
+}
+export interface SizeConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, SizeConstraintDefinition> & DKind.Kind<typeof sizeConstraintKind>> {
+}
+export declare const SizeConstraint: (params: SizeConstraintParams) => SizeConstraint;

package/dist/dataStructure/constraint/size.mjs

@@ -0,0 +1,24 @@
+import { createKind } from "../kind.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/constraint/size.ts
+const sizeConstraintKind = createKind("size-constraint");
+const SizeConstraint = DDataStructure.createConstraint(sizeConstraintKind, ({ init }) => (params) => init({
+	max: params.max === void 0 ? void 0 : DCommon.stringToBytes(params.max),
+	min: params.min === void 0 ? void 0 : DCommon.stringToBytes(params.min)
+}, {
+	executeCheck: async (self, data) => {
+		const result = DEither.rightPipe(await data.stat(), (stat) => {
+			if (!stat.isFile) return DEither.fail();
+			if (self.definition.max !== void 0 && stat.sizeBytes > self.definition.max) return DEither.fail();
+			if (self.definition.min !== void 0 && stat.sizeBytes < self.definition.min) return DEither.fail();
+			return stat;
+		});
+		if (DEither.isLeft(result)) return DDataStructure.ErrorSymbol;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+export { SizeConstraint, sizeConstraintKind };

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

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

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

@@ -0,0 +1 @@
+export type * from './constraints';

package/dist/dataStructure/fundamentalType/file.cjs

@@ -0,0 +1,11 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_fileInterface = require("../../file/fileInterface.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/file.ts
+const fileFundamentalTypeKind = require_kind.createKind("file-fundamental-type");
+const TheFile = _duplojs_lang_dataStructure.createFundamentalType(fileFundamentalTypeKind, (self, data) => require_fileInterface.isFileInterface(data) ? _duplojs_lang_dataStructure.SuccessSymbol : _duplojs_lang_dataStructure.ErrorSymbol);
+//#endregion
+exports.TheFile = TheFile;
+exports.fileFundamentalTypeKind = fileFundamentalTypeKind;

package/dist/dataStructure/fundamentalType/file.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 fileFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/file-fundamental-type", unknown>>;
+export interface TheFile extends DCommon.UnionToIntersection<DDataStructure.FundamentalType<DSFile.FileInterface> & DKind.Kind<typeof fileFundamentalTypeKind>> {
+}
+export declare const TheFile: TheFile;

package/dist/dataStructure/fundamentalType/file.mjs

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

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

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

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

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

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

@@ -0,0 +1 @@
+export type * from './fundamentalTypes';

package/dist/dataStructure/helper/file.cjs

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

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

@@ -0,0 +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<import('@duplojs/lang/path').AnyPath>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helper/file.mjs

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

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

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

package/dist/dataStructure/helper/mimeType.cjs

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

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

@@ -0,0 +1,2 @@
+import { MimeTypeConstraint } from '../constraint';
+export declare function mimeType(mimeType: Parameters<typeof MimeTypeConstraint>[0]): MimeTypeConstraint;

package/dist/dataStructure/helper/mimeType.mjs

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

package/dist/dataStructure/helper/size.cjs

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

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

@@ -0,0 +1,2 @@
+import { SizeConstraint, SizeConstraintParams } from '../constraint';
+export declare function size(params: SizeConstraintParams): SizeConstraint;

package/dist/dataStructure/helper/size.mjs

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

package/dist/dataStructure/index.cjs

@@ -0,0 +1,83 @@
+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_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_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({
+	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,
+	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.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;
+Object.defineProperty(exports, "dataStructure_exports", {
+	enumerable: true,
+	get: function() {
+		return dataStructure_exports;
+	}
+});
+exports.defaultErrorInterpreterCodecDictionary = require_defaultInterpreter.defaultErrorInterpreterCodecDictionary;
+exports.defaultErrorInterpreterDataStructureDictionary = require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary;
+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;
+exports.sizeConstraintKind = require_size.sizeConstraintKind;

package/dist/dataStructure/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './constraint';
+export * from './fundamentalType';
+export * from './helper';
+export * from './kind';
+export * from './type';