@duplojs/lang 0.0.0

package/dist/invocation/useCase.mjs

@@ -0,0 +1,25 @@
+import { entries } from "../object/entries.mjs";
+import { entry } from "../object/entry.mjs";
+import { fromEntries } from "../object/fromEntries.mjs";
+import { map } from "../array/map.mjs";
+import { forward } from "../common/forward.mjs";
+import { pipe } from "../common/pipe.mjs";
+import { uncapitalize } from "../string/uncapitalize.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/useCase.ts
+const useCaseHandlerKind = createKind("use-case-handler");
+function createUseCase(dependencies, getUseCase) {
+	return {
+		dependencies,
+		getUseCase: (injectedDependencies) => getUseCase(pipe(forward(dependencies), entries, map(([key, value]) => {
+			const formattedKey = uncapitalize(key);
+			return entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey] ? value.getUseCase(injectedDependencies) : injectedDependencies[formattedKey]);
+		}), fromEntries)),
+		[useCaseHandlerKind.runTimeKey]: null
+	};
+}
+function wireUseCases(useCases, ports) {
+	return pipe(useCases, entries, map(([key, useCase]) => entry(uncapitalize(key), useCase.getUseCase(ports))), fromEntries);
+}
+//#endregion
+export { createUseCase, useCaseHandlerKind, wireUseCases };

package/dist/kind/base.cjs

@@ -0,0 +1,35 @@
+//#region scripts/kind/base.ts
+const keyKindPrefix = "@duplojs/lang/kind/";
+function create(name) {
+	const runTimeKey = `${keyKindPrefix}${name}`;
+	return {
+		definition: {
+			name,
+			value: null
+		},
+		runTimeKey,
+		addTo(input, value) {
+			return {
+				...input,
+				[runTimeKey]: value
+			};
+		},
+		setTo(input, value) {
+			input[runTimeKey] = value;
+			return input;
+		},
+		has(input) {
+			return Boolean(input && typeof input === "object" && runTimeKey in input);
+		},
+		getValue(input) {
+			return input[runTimeKey];
+		}
+	};
+}
+function isRuntimeKey(value) {
+	return value.startsWith(keyKindPrefix);
+}
+//#endregion
+exports.create = create;
+exports.isRuntimeKey = isRuntimeKey;
+exports.keyKindPrefix = keyKindPrefix;

package/dist/kind/base.d.ts

@@ -0,0 +1,29 @@
+import type * as DCommon from '../common';
+import type * as DString from '../string';
+export interface Definition<GenericName extends string = string, GenericValue extends unknown = unknown> {
+    name: GenericName;
+    value: GenericValue;
+}
+export interface Handler<GenericKindDefinition extends Definition = Definition> {
+    definition: GenericKindDefinition;
+    runTimeKey: string;
+    has<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Kind<this, GenericKindDefinition["value"]>>;
+    addTo<GenericInput extends {}, GenericValue extends GenericKindDefinition["value"] = GenericKindDefinition["value"]>(input: GenericInput, value: GenericValue): (Kind<this, GenericValue> & DCommon.BreakGenericLink<GenericInput>);
+    /**
+     * @deprecated This method make mutation.
+     */
+    setTo<GenericInput extends {}, GenericValue extends GenericKindDefinition["value"] = GenericKindDefinition["value"]>(input: GenericInput, value: GenericValue): (Kind<this, GenericValue> & DCommon.BreakGenericLink<GenericInput>);
+    getValue<GenericKind extends Kind<this, GenericKindDefinition["value"]>>(input: GenericKind): GenericKind[KeySymbol][GenericKindDefinition["name"]];
+}
+declare const KeySymbol: unique symbol;
+export type KeySymbol = typeof KeySymbol;
+export interface Kind<GenericHandler extends Handler, GenericValue extends GenericHandler["definition"]["value"] = GenericHandler["definition"]["value"]> {
+    [KeySymbol]: {
+        [Prop in GenericHandler["definition"]["name"]]: GenericValue;
+    };
+}
+export declare const keyKindPrefix = "@duplojs/lang/kind/";
+export type ForbiddenKindNameCharacter = "@" | "/";
+export declare function create<GenericName extends string, GenericKindValue extends unknown = unknown>(name: (GenericName & DString.ForbiddenContain<GenericName, ForbiddenKindNameCharacter>)): Handler<Definition<GenericName, GenericKindValue>>;
+export declare function isRuntimeKey(value: string): boolean;
+export {};

package/dist/kind/base.mjs

@@ -0,0 +1,33 @@
+//#region scripts/kind/base.ts
+const keyKindPrefix = "@duplojs/lang/kind/";
+function create(name) {
+	const runTimeKey = `${keyKindPrefix}${name}`;
+	return {
+		definition: {
+			name,
+			value: null
+		},
+		runTimeKey,
+		addTo(input, value) {
+			return {
+				...input,
+				[runTimeKey]: value
+			};
+		},
+		setTo(input, value) {
+			input[runTimeKey] = value;
+			return input;
+		},
+		has(input) {
+			return Boolean(input && typeof input === "object" && runTimeKey in input);
+		},
+		getValue(input) {
+			return input[runTimeKey];
+		}
+	};
+}
+function isRuntimeKey(value) {
+	return value.startsWith(keyKindPrefix);
+}
+//#endregion
+export { create, isRuntimeKey, keyKindPrefix };

package/dist/kind/createIdentifier.cjs

@@ -0,0 +1,16 @@
+//#region scripts/kind/createIdentifier.ts
+function createKindIdentifier() {
+	function identifier(...args) {
+		if (args.length === 1) {
+			const [kind] = args;
+			return (input) => identifier(input, kind);
+		}
+		const [input, kind] = args;
+		const formattedKind = kind instanceof Array ? kind : [kind];
+		for (const kind of formattedKind) if (!kind.has(input)) return false;
+		return true;
+	}
+	return identifier;
+}
+//#endregion
+exports.createKindIdentifier = createKindIdentifier;

package/dist/kind/createIdentifier.d.ts

@@ -0,0 +1,7 @@
+import { Kind, Handler } from './base';
+import { GetHandler } from './types';
+import type * as DCommon from '../common';
+export declare function createKindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent>(): {
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
+};

package/dist/kind/createIdentifier.mjs

@@ -0,0 +1,16 @@
+//#region scripts/kind/createIdentifier.ts
+function createKindIdentifier() {
+	function identifier(...args) {
+		if (args.length === 1) {
+			const [kind] = args;
+			return (input) => identifier(input, kind);
+		}
+		const [input, kind] = args;
+		const formattedKind = kind instanceof Array ? kind : [kind];
+		for (const kind of formattedKind) if (!kind.has(input)) return false;
+		return true;
+	}
+	return identifier;
+}
+//#endregion
+export { createKindIdentifier };

package/dist/kind/has.cjs

@@ -0,0 +1,12 @@
+//#region scripts/kind/has.ts
+function has(...args) {
+	if (args.length === 1) {
+		const [kinds] = args;
+		return (input) => has(input, kinds);
+	}
+	const [input, kinds] = args;
+	for (const kind of kinds) if (!kind.has(input)) return false;
+	return true;
+}
+//#endregion
+exports.has = has;

package/dist/kind/has.d.ts

@@ -0,0 +1,4 @@
+import { Kind, Handler } from './base';
+import type * as DCommon from '../common';
+export declare function has<GenericInput extends unknown, const GenericKindHandlers extends DCommon.AnyTuple<Handler>, GenericKindHandler extends GenericKindHandlers[number]>(kinds: GenericKindHandlers): (input: GenericInput) => input is Extract<GenericInput, DCommon.UnionToIntersection<GenericKindHandler extends any ? Kind<GenericKindHandler> : never>>;
+export declare function has<GenericInput extends unknown, const GenericKindHandlers extends DCommon.AnyTuple<Handler>, GenericKindHandler extends GenericKindHandlers[number]>(input: GenericInput, kinds: GenericKindHandlers): input is Extract<GenericInput, DCommon.UnionToIntersection<GenericKindHandler extends any ? Kind<GenericKindHandler> : never>>;

package/dist/kind/has.mjs

@@ -0,0 +1,12 @@
+//#region scripts/kind/has.ts
+function has(...args) {
+	if (args.length === 1) {
+		const [kinds] = args;
+		return (input) => has(input, kinds);
+	}
+	const [input, kinds] = args;
+	for (const kind of kinds) if (!kind.has(input)) return false;
+	return true;
+}
+//#endregion
+export { has };

package/dist/kind/hasSome.cjs

@@ -0,0 +1,12 @@
+//#region scripts/kind/hasSome.ts
+function hasSome(...args) {
+	if (args.length === 1) {
+		const [kinds] = args;
+		return (input) => hasSome(input, kinds);
+	}
+	const [input, kinds] = args;
+	for (const kind of kinds) if (kind.has(input)) return true;
+	return false;
+}
+//#endregion
+exports.hasSome = hasSome;

package/dist/kind/hasSome.d.ts

@@ -0,0 +1,4 @@
+import { Kind, Handler } from './base';
+import type * as DCommon from '../common';
+export declare function hasSome<GenericInput extends unknown, const GenericKindHandlers extends DCommon.AnyTuple<Handler>, GenericKindHandler extends GenericKindHandlers[number]>(kinds: GenericKindHandlers): (input: GenericInput) => input is Extract<GenericInput, GenericKindHandler extends any ? Kind<GenericKindHandler> : never>;
+export declare function hasSome<GenericInput extends unknown, const GenericKindHandlers extends DCommon.AnyTuple<Handler>, GenericKindHandler extends GenericKindHandlers[number]>(input: GenericInput, kinds: GenericKindHandlers): input is Extract<GenericInput, GenericKindHandler extends any ? Kind<GenericKindHandler> : never>;

package/dist/kind/hasSome.mjs

@@ -0,0 +1,12 @@
+//#region scripts/kind/hasSome.ts
+function hasSome(...args) {
+	if (args.length === 1) {
+		const [kinds] = args;
+		return (input) => hasSome(input, kinds);
+	}
+	const [input, kinds] = args;
+	for (const kind of kinds) if (kind.has(input)) return true;
+	return false;
+}
+//#endregion
+export { hasSome };

package/dist/kind/index.cjs

@@ -0,0 +1,33 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_base = require("./base.cjs");
+const require_parentClass = require("./parentClass.cjs");
+const require_namespace = require("./namespace.cjs");
+const require_createIdentifier = require("./createIdentifier.cjs");
+const require_has = require("./has.cjs");
+const require_hasSome = require("./hasSome.cjs");
+//#region scripts/kind/index.ts
+var kind_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	create: () => require_base.create,
+	createKindIdentifier: () => require_createIdentifier.createKindIdentifier,
+	createNamespace: () => require_namespace.createNamespace,
+	has: () => require_has.has,
+	hasSome: () => require_hasSome.hasSome,
+	isRuntimeKey: () => require_base.isRuntimeKey,
+	keyKindPrefix: () => require_base.keyKindPrefix,
+	parentClass: () => require_parentClass.parentClass
+});
+//#endregion
+exports.create = require_base.create;
+exports.createKindIdentifier = require_createIdentifier.createKindIdentifier;
+exports.createNamespace = require_namespace.createNamespace;
+exports.has = require_has.has;
+exports.hasSome = require_hasSome.hasSome;
+exports.isRuntimeKey = require_base.isRuntimeKey;
+exports.keyKindPrefix = require_base.keyKindPrefix;
+Object.defineProperty(exports, "kind_exports", {
+	enumerable: true,
+	get: function() {
+		return kind_exports;
+	}
+});
+exports.parentClass = require_parentClass.parentClass;

package/dist/kind/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './types';
+export * from './base';
+export * from './parentClass';
+export * from './namespace';
+export * from './createIdentifier';
+export * from './has';
+export * from './hasSome';

package/dist/kind/index.mjs

@@ -0,0 +1,20 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { create, isRuntimeKey, keyKindPrefix } from "./base.mjs";
+import { parentClass } from "./parentClass.mjs";
+import { createNamespace } from "./namespace.mjs";
+import { createKindIdentifier } from "./createIdentifier.mjs";
+import { has } from "./has.mjs";
+import { hasSome } from "./hasSome.mjs";
+//#region scripts/kind/index.ts
+var kind_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	createKindIdentifier: () => createKindIdentifier,
+	createNamespace: () => createNamespace,
+	has: () => has,
+	hasSome: () => hasSome,
+	isRuntimeKey: () => isRuntimeKey,
+	keyKindPrefix: () => keyKindPrefix,
+	parentClass: () => parentClass
+});
+//#endregion
+export { create, createKindIdentifier, createNamespace, has, hasSome, isRuntimeKey, keyKindPrefix, kind_exports, parentClass };

package/dist/kind/namespace.cjs

@@ -0,0 +1,9 @@
+const require_base = require("./base.cjs");
+//#region scripts/kind/namespace.ts
+function createNamespace(namespace) {
+	return (name) => {
+		return require_base.create(`@${namespace}/${name}`);
+	};
+}
+//#endregion
+exports.createNamespace = createNamespace;

package/dist/kind/namespace.d.ts

@@ -0,0 +1,3 @@
+import { Definition, Handler, ForbiddenKindNameCharacter } from './base';
+import type * as DString from '../string';
+export declare function createNamespace<GenericNamespace extends string>(namespace: (GenericNamespace & DString.ForbiddenContain<GenericNamespace, ForbiddenKindNameCharacter>)): <GenericName extends string, GenericKindValue extends unknown = unknown>(name: (GenericName & DString.ForbiddenContain<GenericName, ForbiddenKindNameCharacter>)) => Handler<Definition<`@${GenericNamespace}/${GenericName}`, GenericKindValue>>;

package/dist/kind/namespace.mjs

@@ -0,0 +1,9 @@
+import { create } from "./base.mjs";
+//#region scripts/kind/namespace.ts
+function createNamespace(namespace) {
+	return (name) => {
+		return create(`@${namespace}/${name}`);
+	};
+}
+//#endregion
+export { createNamespace };

package/dist/kind/parentClass.cjs

@@ -0,0 +1,14 @@
+const require_base = require("./base.cjs");
+//#region scripts/kind/parentClass.ts
+function parentClass(kindHandler, parent) {
+	const formattedKindHandler = typeof kindHandler === "string" ? require_base.create(kindHandler) : kindHandler;
+	return class extends (parent ?? class {}) {
+		constructor(kindValue, ...parentParams) {
+			super(...parentParams);
+			this[formattedKindHandler.runTimeKey] = kindValue;
+		}
+		static [Symbol.hasInstance] = parent ? (input) => input instanceof parent && formattedKindHandler.has(input) : formattedKindHandler.has;
+	};
+}
+//#endregion
+exports.parentClass = parentClass;

package/dist/kind/parentClass.d.ts

@@ -0,0 +1,7 @@
+import { Kind, Definition, Handler } from './base';
+import type * as DCommon from '../common';
+export type KindClass<GenericKindHandler extends Handler, GenericParent extends DCommon.AnyAbstractConstructor = DCommon.AnyAbstractConstructor<unknown[], never>> = ((new <GenericKindValue extends GenericKindHandler["definition"]["value"] = GenericKindHandler["definition"]["value"], GenericParentInstance extends InstanceType<GenericParent> = InstanceType<GenericParent>>(kindValue: GenericKindValue, ...args: DCommon.NeverCoalescing<ConstructorParameters<GenericParent>, []>) => (DCommon.NeverCoalescing<GenericParentInstance, {}> & Kind<GenericKindHandler, GenericKindValue>)) & (DCommon.IsEqual<GenericParent, never> extends true ? {} : {
+    [Prop in Exclude<keyof GenericParent, DCommon.ClearClassKeys>]: GenericParent[Prop];
+}));
+export declare function parentClass<GenericKindName extends string, GenericParent extends object = never>(kind: GenericKindName, parent?: (GenericParent & DCommon.RequireConstructor<GenericParent>)): KindClass<Handler<Definition<GenericKindName>>, Extract<GenericParent, DCommon.AnyAbstractConstructor>>;
+export declare function parentClass<GenericKindHandler extends Handler, GenericParent extends object = never>(kindHandler: GenericKindHandler, parent?: (GenericParent & DCommon.RequireConstructor<GenericParent>)): KindClass<GenericKindHandler, Extract<GenericParent, DCommon.AnyAbstractConstructor>>;

package/dist/kind/parentClass.mjs

@@ -0,0 +1,14 @@
+import { create } from "./base.mjs";
+//#region scripts/kind/parentClass.ts
+function parentClass(kindHandler, parent) {
+	const formattedKindHandler = typeof kindHandler === "string" ? create(kindHandler) : kindHandler;
+	return class extends (parent ?? class {}) {
+		constructor(kindValue, ...parentParams) {
+			super(...parentParams);
+			this[formattedKindHandler.runTimeKey] = kindValue;
+		}
+		static [Symbol.hasInstance] = parent ? (input) => input instanceof parent && formattedKindHandler.has(input) : formattedKindHandler.has;
+	};
+}
+//#endregion
+export { parentClass };

package/dist/kind/types/getHandler.d.ts

@@ -0,0 +1,4 @@
+import { Definition, Handler, KeySymbol, Kind } from '../base';
+export type GetHandler<GenericObject extends Kind<any>> = {
+    [Prop in keyof GenericObject[KeySymbol]]: Prop extends string ? Handler<Definition<Prop, GenericObject[KeySymbol][Prop]>> : never;
+}[keyof GenericObject[KeySymbol]];

package/dist/kind/types/getValue.d.ts

@@ -0,0 +1,2 @@
+import { Handler, KeySymbol, Kind } from '../base';
+export type GetValue<GenericKindHandler extends Handler, GenericObject extends Kind<any>> = GenericObject[KeySymbol][GenericKindHandler["definition"]["name"]];

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

@@ -0,0 +1,3 @@
+export type * from './getHandler';
+export type * from './getValue';
+export type * from './remove';

package/dist/kind/types/remove.d.ts

@@ -0,0 +1,2 @@
+import { KeySymbol, Kind } from '../base';
+export type Remove<GenericObject extends Kind<any>> = Omit<GenericObject, KeySymbol>;

package/dist/modeling/entity/base.cjs

@@ -0,0 +1,87 @@
+const require_isSimple = require("../../object/isSimple.cjs");
+const require_create = require("../../either/left/create.cjs");
+const require_create$1 = require("../../either/right/create.cjs");
+const require_justExec = require("../../common/justExec.cjs");
+const require_memo = require("../../common/memo.cjs");
+const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
+const require_error = require("../../dataStructure/common/error.cjs");
+const require_base = require("../../dataStructure/structure/base.cjs");
+const require_object = require("../../dataStructure/structure/defaults/object.cjs");
+const require_kind = require("../kind.cjs");
+const require_entityName = require("./entityName.cjs");
+//#region scripts/modeling/entity/base.ts
+const entityKind = require_kind.createKind("entity");
+const entityStructureKind = require_kind.createKind("entity-structure");
+const EntityStructure = require_base.createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
+	inner: require_memo.memo(() => require_object.ObjectStructure({
+		...shape(),
+		[entityKind.runTimeKey]: require_entityName.EntityNameStructure(name)
+	}, [])),
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => self.definition.inner.value.executeCheck(data, errorHandler),
+	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeEncode(codecContext, data, errorHandler),
+	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeDecode(codecContext, data, errorHandler),
+	isAsynchronous: (self) => self.definition.inner.value.isAsynchronous()
+}, {
+	name,
+	new: (self, properties) => ({
+		...properties,
+		[entityKind.runTimeKey]: name
+	}),
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = require_error.createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
+			...data,
+			[entityKind.runTimeKey]: name
+		} : data, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = require_error.createGetErrorHandler();
+		const formattedData = require_isSimple.isSimple(data) ? {
+			...data,
+			[entityKind.runTimeKey]: name
+		} : data;
+		const result = self.executeCheck(formattedData, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", formattedData);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return require_justExec.justExec(async () => {
+			const errorHandler = require_error.createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
+				...data,
+				[entityKind.runTimeKey]: name
+			} : data, errorHandler);
+			if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+			return require_create$1.right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => require_justExec.justExec(async () => {
+		const errorHandler = require_error.createGetErrorHandler();
+		const formattedData = require_isSimple.isSimple(data) ? {
+			...data,
+			[entityKind.runTimeKey]: name
+		} : data;
+		if (await self.executeCheck(formattedData, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", formattedData);
+	})
+}));
+//#endregion
+exports.EntityStructure = EntityStructure;
+exports.entityKind = entityKind;
+exports.entityStructureKind = entityStructureKind;

package/dist/modeling/entity/base.d.ts

@@ -0,0 +1,43 @@
+import { NewType, NewTypeMap } from '../newType';
+import type * as DKind from '../../kind';
+import * as DCommon from '../../common';
+import * as DDataStructure from '../../dataStructure';
+import * as DEither from '../../either';
+declare module '../../dataStructure' {
+    interface StructuresStore {
+        entity: EntityStructure;
+    }
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
+        entity: GenericValue extends Entity<infer InferredName> ? (Entity<InferredName> & {
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
+        }) : never;
+    }
+}
+export declare const entityKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity", string>>;
+export interface Entity<GenericName extends string = string> extends DKind.Kind<typeof entityKind, GenericName> {
+}
+export type GetEntityName<GenericEntity extends Entity> = GenericEntity extends Entity<infer InferredName> ? InferredName : never;
+export declare const entityStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-structure", unknown>>;
+export interface EntityStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
+    readonly inner: DCommon.Memoized<DDataStructure.ObjectStructure>;
+}
+export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends object ? DCommon.Or<[
+    DCommon.IsExtends<GenericRawValue, readonly any[]>,
+    DCommon.And<[
+        DCommon.IsExtends<keyof GenericRawValue, string>,
+        DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
+    ]>
+]> extends true ? {
+    [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
+} : GenericRawValue extends Entity ? EntityMap<DKind.Remove<GenericRawValue>> : GenericRawValue : GenericRawValue;
+export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.UnionToIntersection<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
+    readonly name: GenericName;
+    "new"<GenericNewProperties extends GenericProperties>(properties: GenericNewProperties): (Entity<GenericName> & GenericNewProperties);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: EntityMap<DDataStructure.StructureValue<this>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: EntityMap<DDataStructure.StructureValue<this>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+}
+export declare const EntityStructure: <GenericName extends string, GenericShape extends DDataStructure.ShapeObjectStructure, const GenericProperties extends DDataStructure.ShapeObjectStructureValue<GenericShape>>(name: GenericName, shape: () => GenericShape) => EntityStructure<GenericName, GenericProperties>;

package/dist/modeling/entity/base.mjs

@@ -0,0 +1,85 @@
+import { isSimple } from "../../object/isSimple.mjs";
+import { left } from "../../either/left/create.mjs";
+import { right } from "../../either/right/create.mjs";
+import { justExec } from "../../common/justExec.mjs";
+import { memo } from "../../common/memo.mjs";
+import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
+import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { createStructure } from "../../dataStructure/structure/base.mjs";
+import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
+import { createKind } from "../kind.mjs";
+import { EntityNameStructure } from "./entityName.mjs";
+//#region scripts/modeling/entity/base.ts
+const entityKind = createKind("entity");
+const entityStructureKind = createKind("entity-structure");
+const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
+	inner: memo(() => ObjectStructure({
+		...shape(),
+		[entityKind.runTimeKey]: EntityNameStructure(name)
+	}, [])),
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => self.definition.inner.value.executeCheck(data, errorHandler),
+	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeEncode(codecContext, data, errorHandler),
+	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeDecode(codecContext, data, errorHandler),
+	isAsynchronous: (self) => self.definition.inner.value.isAsynchronous()
+}, {
+	name,
+	new: (self, properties) => ({
+		...properties,
+		[entityKind.runTimeKey]: name
+	}),
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, isSimple(data) ? {
+			...data,
+			[entityKind.runTimeKey]: name
+		} : data, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = createGetErrorHandler();
+		const formattedData = isSimple(data) ? {
+			...data,
+			[entityKind.runTimeKey]: name
+		} : data;
+		const result = self.executeCheck(formattedData, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", formattedData);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return justExec(async () => {
+			const errorHandler = createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, isSimple(data) ? {
+				...data,
+				[entityKind.runTimeKey]: name
+			} : data, errorHandler);
+			if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+			return right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => justExec(async () => {
+		const errorHandler = createGetErrorHandler();
+		const formattedData = isSimple(data) ? {
+			...data,
+			[entityKind.runTimeKey]: name
+		} : data;
+		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", formattedData);
+	})
+}));
+//#endregion
+export { EntityStructure, entityKind, entityStructureKind };

package/dist/modeling/entity/entityName.cjs

@@ -0,0 +1,13 @@
+const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
+const require_base = require("../../dataStructure/structure/base.cjs");
+//#region scripts/modeling/entity/entityName.ts
+const entityNameStructureKind = require("../kind.cjs").createKind("entity-name-structure");
+const EntityNameStructure = require_base.createStructure(entityNameStructureKind, ({ init }) => (name) => init({ constraints: [] }, {
+	executeCheck: (self, data, errorHandler) => data === name ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeEncode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeDecode: (self, codecContext, data, errorHandler) => data === name ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}, { name }));
+//#endregion
+exports.EntityNameStructure = EntityNameStructure;
+exports.entityNameStructureKind = entityNameStructureKind;

package/dist/modeling/entity/entityName.d.ts

@@ -0,0 +1,13 @@
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+import * as DDataStructure from '../../dataStructure';
+declare module '../../dataStructure' {
+    interface StructuresStore {
+        entityName: EntityNameStructure;
+    }
+}
+export declare const entityNameStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-name-structure", unknown>>;
+export interface EntityNameStructure extends DCommon.UnionToIntersection<DDataStructure.Structure<unknown> & DKind.Kind<typeof entityNameStructureKind>> {
+    readonly name: string;
+}
+export declare const EntityNameStructure: (name: string) => EntityNameStructure;