npm - @duplojs/lang - Versions diffs - 0.0.1-beta.2 → 0.0.1-beta.4 - Mend

@duplojs/lang 0.0.1-beta.2 → 0.0.1-beta.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (123) hide show

package/dist/dataStructure/structure/defaults/lazy.cjs CHANGED Viewed

@@ -3,10 +3,15 @@ const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
+const require_identifier = require("../identifier.cjs");
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = require_kind.createKind("lazy-structure");
 const LazyStructure = require_base.createStructure(lazyStructureKind, ({ init }) => (getStructure, constraints) => init({
-	getter: require_memo.memo(getStructure),
+	getter: require_memo.memo(() => {
+		const dataStructure = getStructure();
+		if (require_identifier.structureIdentifier(dataStructure, lazyStructureKind)) return dataStructure.definition.getter.value;
+		return dataStructure;
+	}),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),

package/dist/dataStructure/structure/defaults/lazy.d.ts CHANGED Viewed

@@ -7,6 +7,6 @@ export declare const lazyStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface LazyStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly getter: DCommon.Memoized<Structure>;
 }
-export interface LazyStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
+export interface LazyStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
 }
 export declare const LazyStructure: <GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[]>(getStructure: () => GenericStructure, constraints: GenericConstraints) => NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/lazy.mjs CHANGED Viewed

@@ -3,10 +3,15 @@ import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol } from "../../common/resultSymbol.mjs";
 import { createStructure } from "../base.mjs";
+import { structureIdentifier } from "../identifier.mjs";
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = createKind("lazy-structure");
 const LazyStructure = createStructure(lazyStructureKind, ({ init }) => (getStructure, constraints) => init({
-	getter: memo(getStructure),
+	getter: memo(() => {
+		const dataStructure = getStructure();
+		if (structureIdentifier(dataStructure, lazyStructureKind)) return dataStructure.definition.getter.value;
+		return dataStructure;
+	}),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),

package/dist/dataStructure/structure/defaults/nonEncodableString.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ export declare const nonEncodableStringStructureKind: DKind.Handler<DKind.Defini
 export interface NonEncodableStringStructureDefinition extends StructureDefinition<readonly []> {
     readonly value: string;
 }
-export interface NonEncodableStringStructure extends DCommon.UnionToIntersection<Structure<String, NonEncodableStringStructureDefinition> & DKind.Kind<typeof nonEncodableStringStructureKind>> {
+export interface NonEncodableStringStructure extends DCommon.Forward<Structure<String, NonEncodableStringStructureDefinition> & DKind.Kind<typeof nonEncodableStringStructureKind>> {
 }
 export declare const NonEncodableStringStructure: (value: string) => NoInfer<NonEncodableStringStructure>;

package/dist/dataStructure/structure/defaults/object.d.ts CHANGED Viewed

@@ -25,6 +25,6 @@ export interface ObjectStructureDefinition<GenericConstraints extends readonly C
     readonly shape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
     readonly keys: readonly string[];
 }
-export interface ObjectStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {
+export interface ObjectStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {
 }
 export declare const ObjectStructure: <GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[]>(shape: GenericShape, constraints: GenericConstraints) => NoInfer<ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/record.cjs CHANGED Viewed

@@ -1,6 +1,6 @@
 const require_callThen = require("../../../common/callThen.cjs");
 const require_isType = require("../../../common/isType.cjs");
-const require_justExec = require("../../../common/justExec.cjs");
+const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
@@ -16,10 +16,10 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	key,
 	value,
 	constraints,
-	requiredKeys: require_justExec.justExec(() => {
+	requiredKeys: require_memo.memo(() => {
 		if (require_identifier.structureIdentifier(key, require_union.unionStructureKind)) {
-			if (key.definition.values.some((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_string.stringTypeKind))) return null;
-			return key.definition.values.map((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_stringLiteral.stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(require_isType.isType("string"));
+			if (key.definition.values.value.some((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_string.stringTypeKind))) return null;
+			return key.definition.values.value.map((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_stringLiteral.stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(require_isType.isType("string"));
 		}
 		if (require_identifier.structureIdentifier(key, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(key.definition.type, require_stringLiteral.stringLiteralTypeKind)) return [key.definition.type.definition.value];
 		return null;
@@ -28,7 +28,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	executeCheck: (self, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const result = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (resultKey) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeCheck(data[key], errorHandler), (resultValue) => resultValue === require_resultSymbol.ErrorSymbol || resultKey === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol))), require_resultSymbol.SuccessSymbol);
@@ -40,7 +40,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	executeEncode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
@@ -53,7 +53,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	executeDecode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {

package/dist/dataStructure/structure/defaults/record.d.ts CHANGED Viewed

@@ -12,8 +12,8 @@ export declare const recordStructureKind: DKind.Handler<DKind.Definition<"@Duplo
 export interface RecordStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly key: UnionStructure<string> | TypeStructure<string>;
     readonly value: Structure;
-    readonly requiredKeys: string[] | null;
+    readonly requiredKeys: DCommon.Memoized<string[] | null>;
 }
-export interface RecordStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, RecordStructureDefinition<GenericConstraints>> & DKind.Kind<typeof recordStructureKind>> {
+export interface RecordStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, RecordStructureDefinition<GenericConstraints>> & DKind.Kind<typeof recordStructureKind>> {
 }
 export declare const RecordStructure: <GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[]>(key: GenericKey, value: GenericValueStructure, constraints: GenericConstraints) => NoInfer<RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/record.mjs CHANGED Viewed

@@ -1,6 +1,6 @@
 import { callThen } from "../../../common/callThen.mjs";
 import { isType } from "../../../common/isType.mjs";
-import { justExec } from "../../../common/justExec.mjs";
+import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createStructure } from "../base.mjs";
@@ -16,10 +16,10 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	key,
 	value,
 	constraints,
-	requiredKeys: justExec(() => {
+	requiredKeys: memo(() => {
 		if (structureIdentifier(key, unionStructureKind)) {
-			if (key.definition.values.some((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringTypeKind))) return null;
-			return key.definition.values.map((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(isType("string"));
+			if (key.definition.values.value.some((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringTypeKind))) return null;
+			return key.definition.values.value.map((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(isType("string"));
 		}
 		if (structureIdentifier(key, typeStructureKind) && typeIdentifier(key.definition.type, stringLiteralTypeKind)) return [key.definition.type.definition.value];
 		return null;
@@ -28,7 +28,7 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	executeCheck: (self, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const result = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (resultKey) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeCheck(data[key], errorHandler), (resultValue) => resultValue === ErrorSymbol || resultKey === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol))), SuccessSymbol);
@@ -40,7 +40,7 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	executeEncode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
@@ -53,7 +53,7 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	executeDecode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {

package/dist/dataStructure/structure/defaults/type.d.ts CHANGED Viewed

@@ -7,6 +7,6 @@ export declare const typeStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface TypeStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly type: Type;
 }
-export interface TypeStructure<GenericType extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.UnionToIntersection<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
+export interface TypeStructure<GenericType extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.Forward<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
 }
 export declare const TypeStructure: <GenericType extends Type, const GenericConstraints extends readonly Constraint<TypeValue<GenericType>>[]>(type: GenericType, constraints: GenericConstraints) => NoInfer<TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/union.cjs CHANGED Viewed

@@ -1,18 +1,24 @@
 const require_callThen = require("../../../common/callThen.cjs");
+const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_error = require("../../common/error.cjs");
 const require_base = require("../base.cjs");
 const require_identifier = require("../identifier.cjs");
+const require_lazy = require("./lazy.cjs");
 //#region scripts/dataStructure/structure/defaults/union.ts
 const unionStructureKind = require_kind.createKind("union-structure");
 const UnionStructure = require_base.createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
-	values: values.flatMap((value) => require_identifier.structureIdentifier(value, unionStructureKind) ? value.definition.values : value),
+	values: require_memo.memo(() => values.flatMap((value) => (function flatUnion(structure) {
+		if (require_identifier.structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.flatMap(flatUnion);
+		if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return flatUnion(structure.definition.getter.value);
+		return structure;
+	})(value))),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const result = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+		const result = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === require_resultSymbol.SuccessSymbol) return awaitedAccumulator;
 			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
@@ -32,7 +38,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 	},
 	executeEncode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const encodedData = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+		const encodedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
 			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
@@ -52,7 +58,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 	},
 	executeDecode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const decodedData = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+		const decodedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
 			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
@@ -70,7 +76,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 			return require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData);
 		});
 	},
-	isAsynchronous: (self) => self.definition.values.some((value) => value.isAsynchronous())
+	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion
 exports.UnionStructure = UnionStructure;

package/dist/dataStructure/structure/defaults/union.d.ts CHANGED Viewed

@@ -5,8 +5,8 @@ import type * as DKind from '../../../kind';
 import * as DCommon from '../../../common';
 export declare const unionStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/union-structure", unknown>>;
 export interface UnionStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
-    readonly values: DCommon.AnyTuple<Structure>;
+    readonly values: DCommon.Memoized<DCommon.AnyTuple<Structure>>;
 }
-export interface UnionStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
+export interface UnionStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
 }
 export declare const UnionStructure: <GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[]>(values: GenericValues, constraints: GenericConstraints) => NoInfer<UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/union.mjs CHANGED Viewed

@@ -1,18 +1,24 @@
 import { callThen } from "../../../common/callThen.mjs";
+import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createGetErrorHandler } from "../../common/error.mjs";
 import { createStructure } from "../base.mjs";
 import { structureIdentifier } from "../identifier.mjs";
+import { lazyStructureKind } from "./lazy.mjs";
 //#region scripts/dataStructure/structure/defaults/union.ts
 const unionStructureKind = createKind("union-structure");
 const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
-	values: values.flatMap((value) => structureIdentifier(value, unionStructureKind) ? value.definition.values : value),
+	values: memo(() => values.flatMap((value) => (function flatUnion(structure) {
+		if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.flatMap(flatUnion);
+		if (structureIdentifier(structure, lazyStructureKind)) return flatUnion(structure.definition.getter.value);
+		return structure;
+	})(value))),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const result = self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const result = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === SuccessSymbol) return awaitedAccumulator;
 			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
@@ -32,7 +38,7 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 	},
 	executeEncode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const encodedData = self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const encodedData = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
 			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
@@ -52,7 +58,7 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 	},
 	executeDecode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const decodedData = self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const decodedData = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
 			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
 			if (errorHandlers && subErrorHandler) {
@@ -70,7 +76,7 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 			return callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData);
 		});
 	},
-	isAsynchronous: (self) => self.definition.values.some((value) => value.isAsynchronous())
+	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion
 export { UnionStructure, unionStructureKind };

package/dist/dataStructure/structure/identifier.d.ts CHANGED Viewed

@@ -1,5 +1,4 @@
 import { Structure } from './base';
-export declare const structureIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", String>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').ObjectTag<string>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>> extends true ? Extract<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, GenericGroupedKind> | Extract<import('..').NonEncodableStringStructure, GenericGroupedKind> | Extract<import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityStructure<string, Record<string, unknown>>, GenericGroupedKind> | Extract<import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>>, GenericGroupedKind> | Extract<import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/tagged-object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", String>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').ObjectTag<string>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>> extends true ? Extract<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, GenericGroupedKind> | Extract<import('..').NonEncodableStringStructure, GenericGroupedKind> | Extract<import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityStructure<string, Record<string, unknown>>, GenericGroupedKind> | Extract<import('../../modeling').TaggedObjectStructure<import('../../modeling').ObjectTag<string>>, GenericGroupedKind> | Extract<import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-};
+import { Structures } from './types';
+import * as DKind from '../../kind';
+export declare const structureIdentifier: DKind.KindIdentifier<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, Structures>;

package/dist/dataStructure/type/defaults/bigint.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const bigintTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-type", unknown>>;
 export interface BigintTypeDefinition extends TypeDefinition {
 }
-export interface BigintType extends DCommon.UnionToIntersection<Type<FundamentalType.TheBigint, bigint, BigintTypeDefinition> & DKind.Kind<typeof bigintTypeKind>> {
+export interface BigintType extends DCommon.Forward<Type<FundamentalType.TheBigint, bigint, BigintTypeDefinition> & DKind.Kind<typeof bigintTypeKind>> {
 }
 export declare const BigintType: () => BigintType;

package/dist/dataStructure/type/defaults/bigintLiteral.d.ts CHANGED Viewed

@@ -6,6 +6,6 @@ export declare const bigintLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface BigintLiteralTypeDefinition extends TypeDefinition {
     value: bigint;
 }
-export interface BigintLiteralType<GenericValue extends bigint = bigint> extends DCommon.UnionToIntersection<Type<FundamentalType.TheBigint, GenericValue, BigintLiteralTypeDefinition> & DKind.Kind<typeof bigintLiteralTypeKind>> {
+export interface BigintLiteralType<GenericValue extends bigint = bigint> extends DCommon.Forward<Type<FundamentalType.TheBigint, GenericValue, BigintLiteralTypeDefinition> & DKind.Kind<typeof bigintLiteralTypeKind>> {
 }
 export declare const BigintLiteralType: <const GenericBigint extends bigint>(value: GenericBigint) => BigintLiteralType<GenericBigint>;

package/dist/dataStructure/type/defaults/boolean.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const booleanTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/boolean-type", unknown>>;
 export interface BooleanTypeDefinition extends TypeDefinition {
 }
-export interface BooleanType extends DCommon.UnionToIntersection<Type<FundamentalType.TheBoolean, boolean, BooleanTypeDefinition> & DKind.Kind<typeof booleanTypeKind>> {
+export interface BooleanType extends DCommon.Forward<Type<FundamentalType.TheBoolean, boolean, BooleanTypeDefinition> & DKind.Kind<typeof booleanTypeKind>> {
 }
 export declare const BooleanType: () => BooleanType;

package/dist/dataStructure/type/defaults/booleanLiteral.d.ts CHANGED Viewed

@@ -6,6 +6,6 @@ export declare const booleanLiteralTypeKind: DKind.Handler<DKind.Definition<"@Du
 export interface BooleanLiteralTypeDefinition extends TypeDefinition {
     value: boolean;
 }
-export interface BooleanLiteralType<GenericValue extends boolean = boolean> extends DCommon.UnionToIntersection<Type<FundamentalType.TheBoolean, GenericValue, BooleanLiteralTypeDefinition> & DKind.Kind<typeof booleanLiteralTypeKind>> {
+export interface BooleanLiteralType<GenericValue extends boolean = boolean> extends DCommon.Forward<Type<FundamentalType.TheBoolean, GenericValue, BooleanLiteralTypeDefinition> & DKind.Kind<typeof booleanLiteralTypeKind>> {
 }
 export declare const BooleanLiteralType: <const GenericBoolean extends boolean>(value: GenericBoolean) => BooleanLiteralType<GenericBoolean>;

package/dist/dataStructure/type/defaults/date.d.ts CHANGED Viewed

@@ -6,6 +6,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const dateTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/date-type", unknown>>;
 export interface DateTypeDefinition extends TypeDefinition {
 }
-export interface DateType extends DCommon.UnionToIntersection<Type<FundamentalType.TheDate, DChrono.TheDate, DateTypeDefinition> & DKind.Kind<typeof dateTypeKind>> {
+export interface DateType extends DCommon.Forward<Type<FundamentalType.TheDate, DChrono.TheDate, DateTypeDefinition> & DKind.Kind<typeof dateTypeKind>> {
 }
 export declare const DateType: () => DateType;

package/dist/dataStructure/type/defaults/null.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const nullTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/null-type", unknown>>;
 export interface NullTypeDefinition extends TypeDefinition {
 }
-export interface NullType extends DCommon.UnionToIntersection<Type<FundamentalType.TheNull, null, NullTypeDefinition> & DKind.Kind<typeof nullTypeKind>> {
+export interface NullType extends DCommon.Forward<Type<FundamentalType.TheNull, null, NullTypeDefinition> & DKind.Kind<typeof nullTypeKind>> {
 }
 export declare const NullType: () => NullType;

package/dist/dataStructure/type/defaults/number.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const numberTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/number-type", unknown>>;
 export interface NumberTypeDefinition extends TypeDefinition {
 }
-export interface NumberType extends DCommon.UnionToIntersection<Type<FundamentalType.TheNumber, number, NumberTypeDefinition> & DKind.Kind<typeof numberTypeKind>> {
+export interface NumberType extends DCommon.Forward<Type<FundamentalType.TheNumber, number, NumberTypeDefinition> & DKind.Kind<typeof numberTypeKind>> {
 }
 export declare const NumberType: () => NumberType;

package/dist/dataStructure/type/defaults/numberLiteral.d.ts CHANGED Viewed

@@ -6,6 +6,6 @@ export declare const numberLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface NumberLiteralTypeDefinition extends TypeDefinition {
     value: number;
 }
-export interface NumberLiteralType<GenericValue extends number = number> extends DCommon.UnionToIntersection<Type<FundamentalType.TheNumber, GenericValue, NumberLiteralTypeDefinition> & DKind.Kind<typeof numberLiteralTypeKind>> {
+export interface NumberLiteralType<GenericValue extends number = number> extends DCommon.Forward<Type<FundamentalType.TheNumber, GenericValue, NumberLiteralTypeDefinition> & DKind.Kind<typeof numberLiteralTypeKind>> {
 }
 export declare const NumberLiteralType: <const GenericNumber extends number>(value: GenericNumber) => NumberLiteralType<GenericNumber>;

package/dist/dataStructure/type/defaults/string.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const stringTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/string-type", unknown>>;
 export interface StringTypeDefinition extends TypeDefinition {
 }
-export interface StringType extends DCommon.UnionToIntersection<Type<FundamentalType.TheString, string, StringTypeDefinition> & DKind.Kind<typeof stringTypeKind>> {
+export interface StringType extends DCommon.Forward<Type<FundamentalType.TheString, string, StringTypeDefinition> & DKind.Kind<typeof stringTypeKind>> {
 }
 export declare const StringType: () => StringType;

package/dist/dataStructure/type/defaults/stringLiteral.d.ts CHANGED Viewed

@@ -6,6 +6,6 @@ export declare const stringLiteralTypeKind: DKind.Handler<DKind.Definition<"@Dup
 export interface StringLiteralTypeDefinition extends TypeDefinition {
     value: string;
 }
-export interface StringLiteralType<GenericValue extends string = string> extends DCommon.UnionToIntersection<Type<FundamentalType.TheString, GenericValue, StringLiteralTypeDefinition> & DKind.Kind<typeof stringLiteralTypeKind>> {
+export interface StringLiteralType<GenericValue extends string = string> extends DCommon.Forward<Type<FundamentalType.TheString, GenericValue, StringLiteralTypeDefinition> & DKind.Kind<typeof stringLiteralTypeKind>> {
 }
 export declare const StringLiteralType: <const GenericString extends string>(value: GenericString) => StringLiteralType<GenericString>;

package/dist/dataStructure/type/defaults/time.d.ts CHANGED Viewed

@@ -6,6 +6,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const timeTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-type", unknown>>;
 export interface TimeTypeDefinition extends TypeDefinition {
 }
-export interface TimeType extends DCommon.UnionToIntersection<Type<FundamentalType.TheTime, DChrono.TheTime, TimeTypeDefinition> & DKind.Kind<typeof timeTypeKind>> {
+export interface TimeType extends DCommon.Forward<Type<FundamentalType.TheTime, DChrono.TheTime, TimeTypeDefinition> & DKind.Kind<typeof timeTypeKind>> {
 }
 export declare const TimeType: () => TimeType;

package/dist/dataStructure/type/defaults/undefined.d.ts CHANGED Viewed

@@ -5,6 +5,6 @@ import * as FundamentalType from "../../fundamentalType";
 export declare const undefinedTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/undefined-type", unknown>>;
 export interface UndefinedTypeDefinition extends TypeDefinition {
 }
-export interface UndefinedType extends DCommon.UnionToIntersection<Type<FundamentalType.TheUndefined, undefined, UndefinedTypeDefinition> & DKind.Kind<typeof undefinedTypeKind>> {
+export interface UndefinedType extends DCommon.Forward<Type<FundamentalType.TheUndefined, undefined, UndefinedTypeDefinition> & DKind.Kind<typeof undefinedTypeKind>> {
 }
 export declare const UndefinedType: () => UndefinedType;

package/dist/dataStructure/type/identifier.d.ts CHANGED Viewed

@@ -1,5 +1,4 @@
 import { Type } from './base';
-export declare const typeIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-};
+import { Types } from './types';
+import * as DKind from '../../kind';
+export declare const typeIdentifier: DKind.KindIdentifier<Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>, Types>;

package/dist/index.cjs CHANGED Viewed

@@ -15,6 +15,7 @@ const require_callThen = require("./common/callThen.cjs");
 const require_index$1 = require("./object/index.cjs");
 const require_clone = require("./common/clone.cjs");
 const require_index$2 = require("./common/constraint/cast/index.cjs");
+const require_remove = require("./common/constraint/remove.cjs");
 const require_detachObjectMethod = require("./common/detachObjectMethod.cjs");
 const require_enum = require("./common/enum.cjs");
 const require_equal = require("./common/equal.cjs");
@@ -286,6 +287,7 @@ exports.preparePipe = require_preparePipe.preparePipe;
 exports.promiseAll = require_promiseAll.promiseAll;
 exports.promiseObject = require_promiseObject.promiseObject;
 exports.queueKind = require_queue.queueKind;
+exports.removeConstraint = require_remove.removeConstraint;
 exports.shameOnYou = require_index$2.shameOnYou;
 exports.simpleClone = require_simpleClone.simpleClone;
 exports.stringToBytes = require_stringToBytes.stringToBytes;

package/dist/index.mjs CHANGED Viewed

@@ -14,6 +14,7 @@ import { callThen } from "./common/callThen.mjs";
 import { object_exports } from "./object/index.mjs";
 import { clone } from "./common/clone.mjs";
 import { cast, shameOnYou } from "./common/constraint/cast/index.mjs";
+import { removeConstraint } from "./common/constraint/remove.mjs";
 import { detachObjectMethod } from "./common/detachObjectMethod.mjs";
 import { createEnum } from "./common/enum.mjs";
 import { equal } from "./common/equal.mjs";
@@ -67,4 +68,4 @@ import { pattern_exports } from "./pattern/index.mjs";
 import { invocation_exports } from "./invocation/index.mjs";
 import { path_exports } from "./path/index.mjs";
 import { printer_exports } from "./printer/index.mjs";
-export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/invocation/flow/base.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult, UnwrapFlowControllerResult } from './controller';
-import { DKind } from '../../index.ts';
 import * as DCommon from '../../common';
+import type * as DKind from '../../kind';
 type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = GenericAccumulator extends [
     ...infer InferredRest,
     infer InferredLast

package/dist/invocation/flow/controller/defaults/aborter.cjs CHANGED Viewed

@@ -1,5 +1,6 @@
 const require_parentClass = require("../../../../kind/parentClass.cjs");
 const require_create = require("../../../../either/left/create.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
 const require_kind = require("../../../kind.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/invocation/flow/controller/defaults/aborter.ts
@@ -11,14 +12,16 @@ var AbortErrorFlowController = class extends require_parentClass.parentClass(req
 		this.abortController = abortController;
 	}
 };
-const aborter = require_base.createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction) => {
+const aborter = require_base.createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
 	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : require_stringToMillisecond.stringToMillisecond(params.timeout);
 	return init(async (previousFunction) => {
 		const result = previousFunction();
 		if (require_base.flowControllerExitKind.has(result)) return result;
 		aborter?.abort(new AbortErrorFlowController(aborter));
 		const currentAborter = new AbortController();
 		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
 		try {
 			const abortResult = await theFunction(result, currentAborter);
 			if (currentAborter.signal.aborted === true) return exitFlow(require_create.left("signal-aborted", currentAborter.signal.reason));