@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/dataStructure/helpers/nullable.mjs

@@ -1,12 +1,15 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isNullStructure } from "./isNullStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { null as nullHelper } from "./null.mjs";
 //#region scripts/dataStructure/helpers/nullable.ts
 function nullable(structure) {
-	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.some(isNullStructure) ? union(structure.definition.values) : union([nullHelper(), ...structure.definition.values]);
-	return union([nullHelper(), structure]);
+	return union([lazy(() => {
+		if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.some(isNullStructure) ? structure : union([nullHelper(), union(structure.definition.values.value)]);
+		return union([nullHelper(), structure]);
+	})]);
 }
 //#endregion
 export { nullable };

package/dist/dataStructure/helpers/number.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-export declare function number<const GenericConstraints extends readonly Constraint<number>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<number, readonly [...GenericConstraints]>;
+export declare function number<const GenericConstraints extends readonly Constraint<number>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<number, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/numberInString.cjs

@@ -0,0 +1,7 @@
+const require_numberInString = require("../constraint/defaults/numberInString.cjs");
+//#region scripts/dataStructure/helpers/numberInString.ts
+function numberInString() {
+	return require_numberInString.NumberInStringConstraint();
+}
+//#endregion
+exports.numberInString = numberInString;

package/dist/dataStructure/helpers/numberInString.d.ts

@@ -0,0 +1,2 @@
+import { NumberInStringConstraint } from '../constraint';
+export declare function numberInString(): NumberInStringConstraint;

package/dist/dataStructure/helpers/numberInString.mjs

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

package/dist/dataStructure/helpers/object.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { ObjectStructure, ShapeObjectStructureValue, ShapeObjectStructure } from '../structure';
-export declare function object<GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[] = readonly []>(shape: GenericShape, constraints?: GenericConstraints): ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>;
+export declare function object<GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[] = readonly []>(shape: GenericShape, constraints?: GenericConstraints): NoInfer<ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/optional.cjs

@@ -1,12 +1,15 @@
 const require_identifier = require("../structure/identifier.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+const require_lazy = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_undefined = require("./undefined.cjs");
 //#region scripts/dataStructure/helpers/optional.ts
 function optional(structure) {
-	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.some(require_isUndefinedStructure.isUndefinedStructure) ? require_union$1.union(structure.definition.values) : require_union$1.union([require_undefined.undefined(), ...structure.definition.values]);
-	return require_union$1.union([require_undefined.undefined(), structure]);
+	return require_union$1.union([require_lazy.lazy(() => {
+		if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.value.some(require_isUndefinedStructure.isUndefinedStructure) ? structure : require_union$1.union([require_undefined.undefined(), require_union$1.union(structure.definition.values.value)]);
+		return require_union$1.union([require_undefined.undefined(), structure]);
+	})]);
 }
 //#endregion
 exports.optional = optional;

package/dist/dataStructure/helpers/optional.mjs

@@ -1,12 +1,15 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { undefined as undefinedHelper } from "./undefined.mjs";
 //#region scripts/dataStructure/helpers/optional.ts
 function optional(structure) {
-	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.some(isUndefinedStructure) ? union(structure.definition.values) : union([undefinedHelper(), ...structure.definition.values]);
-	return union([undefinedHelper(), structure]);
+	return union([lazy(() => {
+		if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.some(isUndefinedStructure) ? structure : union([undefinedHelper(), union(structure.definition.values.value)]);
+		return union([undefinedHelper(), structure]);
+	})]);
 }
 //#endregion
 export { optional };

package/dist/dataStructure/helpers/partial.cjs

@@ -1,17 +1,20 @@
 const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+const require_lazy$1 = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_object = require("./object.cjs");
 const require_undefined = require("./undefined.cjs");
 //#region scripts/dataStructure/helpers/partial.ts
 function partialStructure(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return partialStructure(structure.definition.getter.value);
 	if (require_isUndefinedStructure.isUndefinedStructure(structure)) return structure;
-	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.some(require_isUndefinedStructure.isUndefinedStructure) ? structure : require_union$1.union([require_undefined.undefined(), ...structure.definition.values]);
+	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.value.some(require_isUndefinedStructure.isUndefinedStructure) ? structure : require_union$1.union([require_undefined.undefined(), ...structure.definition.values.value]);
 	return require_union$1.union([require_undefined.undefined(), structure]);
 }
 function partial(structure) {
-	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, partialStructure(entry.value)])));
+	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => partialStructure(entry.value))])));
 }
 //#endregion
 exports.partial = partial;

package/dist/dataStructure/helpers/partial.mjs

@@ -1,17 +1,20 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { object } from "./object.mjs";
 import { undefined as undefinedHelper } from "./undefined.mjs";
 //#region scripts/dataStructure/helpers/partial.ts
 function partialStructure(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return partialStructure(structure.definition.getter.value);
 	if (isUndefinedStructure(structure)) return structure;
-	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.some(isUndefinedStructure) ? structure : union([undefinedHelper(), ...structure.definition.values]);
+	if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.some(isUndefinedStructure) ? structure : union([undefinedHelper(), ...structure.definition.values.value]);
 	return union([undefinedHelper(), structure]);
 }
 function partial(structure) {
-	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, partialStructure(entry.value)])));
+	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, lazy(() => partialStructure(entry.value))])));
 }
 //#endregion
 export { partial };

package/dist/dataStructure/helpers/path.cjs

@@ -0,0 +1,7 @@
+const require_path = require("../constraint/defaults/path.cjs");
+//#region scripts/dataStructure/helpers/path.ts
+function path() {
+	return require_path.PathConstraint();
+}
+//#endregion
+exports.path = path;

package/dist/dataStructure/helpers/path.d.ts

@@ -0,0 +1,2 @@
+import { PathConstraint } from '../constraint';
+export declare function path(): PathConstraint;

package/dist/dataStructure/helpers/path.mjs

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

package/dist/dataStructure/helpers/record.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { RecordStructure, RecordStructureValue, Structure, TypeStructure, UnionStructure } from '../structure';
-export declare function record<GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[] = readonly []>(key: GenericKey, value: GenericValueStructure, constraints?: GenericConstraints): RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>;
+export declare function record<GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[] = readonly []>(key: GenericKey, value: GenericValueStructure, constraints?: GenericConstraints): NoInfer<RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/regex.cjs

@@ -0,0 +1,7 @@
+const require_regex = require("../constraint/defaults/regex.cjs");
+//#region scripts/dataStructure/helpers/regex.ts
+function regex(regex) {
+	return require_regex.RegexConstraint(regex);
+}
+//#endregion
+exports.regex = regex;

package/dist/dataStructure/helpers/regex.d.ts

@@ -0,0 +1,2 @@
+import { RegexConstraint } from '../constraint';
+export declare function regex(regex: RegExp): RegexConstraint;

package/dist/dataStructure/helpers/regex.mjs

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

package/dist/dataStructure/helpers/required.cjs

@@ -1,18 +1,21 @@
 const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+const require_lazy$1 = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_object = require("./object.cjs");
 //#region scripts/dataStructure/helpers/required.ts
 function requiredStructure(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return requiredStructure(structure.definition.getter.value);
 	if (!require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure;
-	const values = structure.definition.values.filter((value) => !require_isUndefinedStructure.isUndefinedStructure(value));
+	const values = structure.definition.values.value.filter((value) => !require_isUndefinedStructure.isUndefinedStructure(value));
 	if (values.length === 1) return values[0];
-	if (values.length === structure.definition.values.length) return structure;
+	if (values.length === structure.definition.values.value.length) return structure;
 	return require_union$1.union(values);
 }
 function required(structure) {
-	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, requiredStructure(entry.value)])));
+	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => requiredStructure(entry.value))])));
 }
 //#endregion
 exports.required = required;

package/dist/dataStructure/helpers/required.d.ts

@@ -1,4 +1,5 @@
 import { ObjectStructure, StructureInitialValue } from '../structure';
+import type * as DCommon from '../../common';
 export declare function required<GenericObjectStructure extends ObjectStructure, GenericObjectStructureValue extends StructureInitialValue<GenericObjectStructure>>(structure: GenericObjectStructure): ObjectStructure<{
-    readonly [Prop in keyof GenericObjectStructureValue]-?: Exclude<GenericObjectStructureValue[Prop], undefined>;
+    readonly [Prop in keyof GenericObjectStructureValue]-?: DCommon.IsEqual<GenericObjectStructureValue[Prop], undefined> extends true ? undefined : Exclude<GenericObjectStructureValue[Prop], undefined>;
 }, readonly []>;

package/dist/dataStructure/helpers/required.mjs

@@ -1,18 +1,21 @@
 import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
 import { unionStructureKind } from "../structure/defaults/union.mjs";
 import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+import { lazy } from "./lazy.mjs";
 import { union } from "./union.mjs";
 import { object } from "./object.mjs";
 //#region scripts/dataStructure/helpers/required.ts
 function requiredStructure(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return requiredStructure(structure.definition.getter.value);
 	if (!structureIdentifier(structure, unionStructureKind)) return structure;
-	const values = structure.definition.values.filter((value) => !isUndefinedStructure(value));
+	const values = structure.definition.values.value.filter((value) => !isUndefinedStructure(value));
 	if (values.length === 1) return values[0];
-	if (values.length === structure.definition.values.length) return structure;
+	if (values.length === structure.definition.values.value.length) return structure;
 	return union(values);
 }
 function required(structure) {
-	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, requiredStructure(entry.value)])));
+	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, lazy(() => requiredStructure(entry.value))])));
 }
 //#endregion
 export { required };

package/dist/dataStructure/helpers/segmentPath.cjs

@@ -0,0 +1,7 @@
+const require_segmentPath = require("../constraint/defaults/segmentPath.cjs");
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return require_segmentPath.SegmentPathConstraint();
+}
+//#endregion
+exports.segmentPath = segmentPath;

package/dist/dataStructure/helpers/segmentPath.d.ts

@@ -0,0 +1,2 @@
+import { SegmentPathConstraint } from '../constraint';
+export declare function segmentPath(): SegmentPathConstraint;

package/dist/dataStructure/helpers/segmentPath.mjs

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

package/dist/dataStructure/helpers/string.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-export declare function string<const GenericConstraints extends readonly Constraint<string>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<string, readonly [...GenericConstraints]>;
+export declare function string<const GenericConstraints extends readonly Constraint<string>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<string, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/time.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
 import type * as DChrono from '../../chrono';
-export declare function time<const GenericConstraints extends readonly Constraint<DChrono.TheTime>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<DChrono.TheTime, readonly [...GenericConstraints]>;
+export declare function time<const GenericConstraints extends readonly Constraint<DChrono.TheTime>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<DChrono.TheTime, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/trimmed.cjs

@@ -0,0 +1,7 @@
+const require_trimmed = require("../constraint/defaults/trimmed.cjs");
+//#region scripts/dataStructure/helpers/trimmed.ts
+function trimmed() {
+	return require_trimmed.TrimmedConstraint();
+}
+//#endregion
+exports.trimmed = trimmed;

package/dist/dataStructure/helpers/trimmed.d.ts

@@ -0,0 +1,2 @@
+import { TrimmedConstraint } from '../constraint';
+export declare function trimmed(): TrimmedConstraint;

package/dist/dataStructure/helpers/trimmed.mjs

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

package/dist/dataStructure/helpers/undefined.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-declare function undefinedHelper<const GenericConstraints extends readonly Constraint<undefined>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<undefined, readonly [...GenericConstraints]>;
+declare function undefinedHelper<const GenericConstraints extends readonly Constraint<undefined>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<undefined, readonly [...GenericConstraints]>>;
 export { undefinedHelper as undefined };

package/dist/dataStructure/helpers/union.d.ts

@@ -1,4 +1,4 @@
 import { UnionStructure, Structure, StructureValue } from '../structure';
 import { Constraint } from '../constraint';
 import type * as DCommon from '../../common';
-export declare function union<GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[] = readonly []>(values: GenericValues, constraints?: GenericConstraints): UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>;
+export declare function union<GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[] = readonly []>(values: GenericValues, constraints?: GenericConstraints): NoInfer<UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/unwrapLazy.cjs

@@ -0,0 +1,9 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
+//#region scripts/dataStructure/helpers/unwrapLazy.ts
+function unwrapLazy(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return structure.definition.getter.value;
+	return structure;
+}
+//#endregion
+exports.unwrapLazy = unwrapLazy;

package/dist/dataStructure/helpers/unwrapLazy.d.ts

@@ -0,0 +1,2 @@
+import { Structure, StructureValue } from '../structure';
+export declare function unwrapLazy<GenericStructure extends Structure>(structure: GenericStructure): Structure<StructureValue<GenericStructure>>;

package/dist/dataStructure/helpers/unwrapLazy.mjs

@@ -0,0 +1,9 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
+//#region scripts/dataStructure/helpers/unwrapLazy.ts
+function unwrapLazy(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return structure.definition.getter.value;
+	return structure;
+}
+//#endregion
+export { unwrapLazy };

package/dist/dataStructure/helpers/url.cjs

@@ -1,7 +1,7 @@
 const require_url = require("../constraint/defaults/url.cjs");
 //#region scripts/dataStructure/helpers/url.ts
-function url(params) {
-	return require_url.UrlConstraint(params);
+function url() {
+	return require_url.UrlConstraint();
 }
 //#endregion
 exports.url = url;

package/dist/dataStructure/helpers/url.d.ts

@@ -1,3 +1,2 @@
 import { UrlConstraint } from '../constraint';
-import type * as DString from '../../string';
-export declare function url(params?: DString.IsUrlParams): UrlConstraint;
+export declare function url(): UrlConstraint;

package/dist/dataStructure/helpers/url.mjs

@@ -1,7 +1,7 @@
 import { UrlConstraint } from "../constraint/defaults/url.mjs";
 //#region scripts/dataStructure/helpers/url.ts
-function url(params) {
-	return UrlConstraint(params);
+function url() {
+	return UrlConstraint();
 }
 //#endregion
 export { url };