@duplojs/lang 0.0.1-beta.8 → 0.1.0-beta.1

package/dist/modeling/newType/base.mjs

@@ -3,7 +3,7 @@ import { left } from "../../either/left/create.mjs";
 import { right } from "../../either/right/create.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { ErrorPromise, createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/newType/base.ts
@@ -19,6 +19,7 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
 	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
 	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeParse: (self, codecContext, data, errorHandler) => callThen(self.definition.inner.executeParse(codecContext, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,
@@ -30,14 +31,14 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 		const errorHandler = createGetErrorHandler();
 		const [codecs, data] = args;
 		const result = self.executeDecode(codecs.context.value, data, errorHandler);
-		if (result instanceof Promise) return left("async-error", void 0);
+		if (result instanceof Promise) return left("async-error", new ErrorPromise());
 		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", result);
 	},
 	map: (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		const result = self.executeCheck(data, errorHandler);
-		if (result instanceof Promise) return left("async-error", void 0);
+		if (result instanceof Promise) return left("async-error", new ErrorPromise());
 		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", data);
 	},
@@ -54,11 +55,11 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		if (await self.executeCheck(data, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", data);
-	})
+	}
 }));
 //#endregion
 export { NewTypeStructure, newTypeStructureKind };

package/dist/modeling/taggedObject/base.cjs

@@ -3,15 +3,15 @@ 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_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
-const require_error = require("../../dataStructure/common/error.cjs");
-const require_base = require("../../dataStructure/structure/base.cjs");
+const require_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = require("../../dataStructure/structure/base.cjs");
 const require_nonEncodableString = require("../../dataStructure/structure/defaults/nonEncodableString.cjs");
 const require_object = require("../../dataStructure/structure/defaults/object.cjs");
 const require_kind = require("../kind.cjs");
 //#region scripts/modeling/taggedObject/base.ts
 const objectTagKind = require_kind.createKind("object-tag");
 const taggedObjectStructureKind = require_kind.createKind("tagged-object-structure");
-const TaggedObjectStructure = require_base.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
+const TaggedObjectStructure = require_base$1.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
 	inner: require_object.ObjectStructure({
 		...shape,
 		[objectTagKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
@@ -21,6 +21,7 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
 }, {
 	name,
@@ -33,24 +34,24 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 			const [codecs] = args;
 			return (value) => self.decodeMap(codecs, value);
 		}
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const [codecs, data] = args;
 		const result = self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
 			...data,
 			[objectTagKind.runTimeKey]: name
 		} : data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		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 errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[objectTagKind.runTimeKey]: name
 		} : data;
 		const result = self.executeCheck(formattedData, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", formattedData);
 	},
@@ -60,7 +61,7 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 			return (value) => self.asyncDecodeMap(codecs, value);
 		}
 		return require_justExec.justExec(async () => {
-			const errorHandler = require_error.createGetErrorHandler();
+			const errorHandler = require_base.createGetErrorHandler();
 			const [codecs, data] = args;
 			const result = await self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
 				...data,
@@ -70,15 +71,25 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
-		const errorHandler = require_error.createGetErrorHandler();
+	asyncMap: async (self, data) => {
+		const errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[objectTagKind.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);
-	})
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, update] = args;
+		const updatedTaggedObject = { [objectTagKind.runTimeKey]: name };
+		for (const key of self.definition.inner.definition.keys) updatedTaggedObject[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedTaggedObject;
+	}
 }));
 //#endregion
 exports.TaggedObjectStructure = TaggedObjectStructure;

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

@@ -36,14 +36,19 @@ export type TaggedObjectMap<GenericValue extends unknown, GenericRawValue = DCom
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: TaggedObjectMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
-export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
+export type TaggedObjectUpdate<GenericTaggedObject extends ObjectTag, GenericNewProperties extends object> = Extract<(ObjectTag<GetTagValue<GenericTaggedObject>> & DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject> extends infer InferredProperties ? {
+    [Prop in keyof InferredProperties]: Prop extends keyof GenericNewProperties ? GenericNewProperties[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? InferredProperties[Prop] : InferredNewValue : never : InferredProperties[Prop];
+} : never>), any>;
+export interface TaggedObjectStructure<out GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
     "new"(properties: DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject>>): GenericTaggedObject;
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<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<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    map(data: TaggedObjectMap<DKind.Remove<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<TaggedObjectMap<DKind.Remove<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<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>) => (DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>): (DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: TaggedObjectMap<DKind.Remove<GenericTaggedObject>>): (DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>) => Promise<DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>): Promise<DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: TaggedObjectMap<DKind.Remove<GenericTaggedObject>>): Promise<DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"map-error", DDataStructure.Error>>;
+    update<GenericInput extends GenericTaggedObject, const GenericPayload extends Partial<DKind.Remove<GenericTaggedObject>>>(update: GenericPayload): (input: GenericInput) => TaggedObjectUpdate<GenericInput, GenericPayload>;
+    update<GenericInput extends GenericTaggedObject, const GenericPayload extends Partial<DKind.Remove<GenericTaggedObject>>>(input: GenericInput, update: GenericPayload): TaggedObjectUpdate<GenericInput, GenericPayload>;
 }
 export declare const TaggedObjectStructure: <GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape) => TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;

package/dist/modeling/taggedObject/base.mjs

@@ -3,7 +3,7 @@ import { left } from "../../either/left/create.mjs";
 import { right } from "../../either/right/create.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { ErrorPromise, createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
@@ -21,6 +21,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
 }, {
 	name,
@@ -39,7 +40,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 			...data,
 			[objectTagKind.runTimeKey]: name
 		} : data, errorHandler);
-		if (result instanceof Promise) return left("async-error", void 0);
+		if (result instanceof Promise) return left("async-error", new ErrorPromise());
 		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", result);
 	},
@@ -50,7 +51,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 			[objectTagKind.runTimeKey]: name
 		} : data;
 		const result = self.executeCheck(formattedData, errorHandler);
-		if (result instanceof Promise) return left("async-error", void 0);
+		if (result instanceof Promise) return left("async-error", new ErrorPromise());
 		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
 	},
@@ -70,7 +71,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		const formattedData = isSimple(data) ? {
 			...data,
@@ -78,7 +79,17 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 		} : data;
 		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
-	})
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, update] = args;
+		const updatedTaggedObject = { [objectTagKind.runTimeKey]: name };
+		for (const key of self.definition.inner.definition.keys) updatedTaggedObject[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedTaggedObject;
+	}
 }));
 //#endregion
 export { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };

package/dist/object/assign.d.ts

@@ -1,4 +1,4 @@
-import { AssignObjects } from './types';
+import { Assign } from './types';
 import type * as DCommon from '../common';
-export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(value: GenericValue): (object: GenericObject) => AssignObjects<GenericObject, GenericValue>;
-export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(object: GenericObject, value: GenericValue): AssignObjects<GenericObject, GenericValue>;
+export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(value: GenericValue): (object: GenericObject) => Assign<GenericObject, GenericValue>;
+export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(object: GenericObject, value: GenericValue): Assign<GenericObject, GenericValue>;

package/dist/object/deepOverride.cjs

@@ -0,0 +1,33 @@
+const require_isSimple = require("./isSimple.cjs");
+const require_justExec = require("../common/justExec.cjs");
+//#region scripts/object/deepOverride.ts
+function deepOverride(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (object) => deepOverride(object, value);
+	}
+	const [object, initialValue] = args;
+	return require_justExec.justExec(function override(value = initialValue, currentValue = object) {
+		if (value === void 0) return currentValue;
+		if (Array.isArray(value)) {
+			if (!Array.isArray(currentValue)) return currentValue;
+			const result = [...currentValue];
+			const commonLength = Math.min(currentValue.length, value.length);
+			for (let index = 0; index < commonLength; index++) {
+				const overrideValue = value[index];
+				if (overrideValue !== void 0) result[index] = override(overrideValue, currentValue[index]);
+			}
+			return result;
+		}
+		if (require_isSimple.isSimple(value)) {
+			if (!require_isSimple.isSimple(currentValue)) return currentValue;
+			return Object.entries(value).reduce((result, [key, overrideValue]) => {
+				if (overrideValue !== void 0) result[key] = override(overrideValue, result[key]);
+				return result;
+			}, { ...currentValue });
+		}
+		return value;
+	});
+}
+//#endregion
+exports.deepOverride = deepOverride;

package/dist/object/deepOverride.d.ts

@@ -0,0 +1,20 @@
+import { HasKeySignature, keyofWithoutSignature } from './types';
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+type DeepOverrideParameter<GenericValue extends unknown> = (GenericValue extends unknown ? readonly [
+    GenericValue,
+    DCommon.RemoveConstraint<GenericValue>
+] : never) extends infer InferredItem extends readonly [unknown, unknown] ? DCommon.IsUnion<Extract<InferredItem[1], object>> extends true ? Exclude<InferredItem[1], object> | undefined : InferredItem extends unknown ? InferredItem[1] extends DCommon.AnyFunction ? InferredItem[0] : InferredItem[1] extends object ? InferredItem[0] extends DCommon.Constraint ? undefined : InferredItem[1] extends readonly unknown[] ? InferredItem[1] extends readonly [
+    infer InferredFirst,
+    ...infer InferredRest
+] ? readonly [
+    DeepOverrideParameter<InferredFirst> | undefined,
+    ...Extract<DeepOverrideParameter<InferredRest>, readonly unknown[]>
+] : InferredItem[1] extends readonly [] ? readonly [] : readonly (DeepOverrideParameter<InferredItem[1][number]> | undefined)[] : DCommon.SimplifyTopLevel<{
+    readonly [Prop in Exclude<keyofWithoutSignature<InferredItem[1]>, DKind.KeySymbol>]?: DeepOverrideParameter<InferredItem[1][Prop]> | undefined;
+} & (HasKeySignature<InferredItem[1]> extends true ? {
+    readonly [key: string]: InferredItem[1][keyof InferredItem[1]];
+} : unknown)> : InferredItem[0] | undefined : never : never;
+export declare function deepOverride<GenericObject extends object>(value: NoInfer<DeepOverrideParameter<GenericObject>>): (object: GenericObject) => GenericObject;
+export declare function deepOverride<GenericObject extends object>(object: GenericObject, value: NoInfer<DeepOverrideParameter<GenericObject>>): GenericObject;
+export {};

package/dist/object/deepOverride.mjs

@@ -0,0 +1,33 @@
+import { isSimple } from "./isSimple.mjs";
+import { justExec } from "../common/justExec.mjs";
+//#region scripts/object/deepOverride.ts
+function deepOverride(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (object) => deepOverride(object, value);
+	}
+	const [object, initialValue] = args;
+	return justExec(function override(value = initialValue, currentValue = object) {
+		if (value === void 0) return currentValue;
+		if (Array.isArray(value)) {
+			if (!Array.isArray(currentValue)) return currentValue;
+			const result = [...currentValue];
+			const commonLength = Math.min(currentValue.length, value.length);
+			for (let index = 0; index < commonLength; index++) {
+				const overrideValue = value[index];
+				if (overrideValue !== void 0) result[index] = override(overrideValue, currentValue[index]);
+			}
+			return result;
+		}
+		if (isSimple(value)) {
+			if (!isSimple(currentValue)) return currentValue;
+			return Object.entries(value).reduce((result, [key, overrideValue]) => {
+				if (overrideValue !== void 0) result[key] = override(overrideValue, result[key]);
+				return result;
+			}, { ...currentValue });
+		}
+		return value;
+	});
+}
+//#endregion
+export { deepOverride };

package/dist/object/entries.d.ts

@@ -1,9 +1,9 @@
 import type * as DString from '../string';
 import type * as DCommon from '../common';
-export type GetEntry<GenericKey extends DCommon.ObjectKey, GenericValue extends unknown> = GenericValue extends any ? GenericKey extends string | number ? [`${GenericKey}`, GenericValue] : never : never;
-export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? [DString.Number, GenericObject[number]][] : DCommon.IsEqual<GenericObject, object> extends true ? [string, DCommon.AnyValue][] : ({
+export type GetEntry<GenericKey extends DCommon.ObjectKey, GenericValue extends unknown> = GenericValue extends any ? GenericKey extends string | number ? readonly [`${GenericKey}`, GenericValue] : never : never;
+export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? readonly (readonly [DString.Number, GenericObject[number]])[] : DCommon.IsEqual<GenericObject, object> extends true ? readonly [string, DCommon.AnyValue][] : ({
     [Prop in keyof GenericObject]-?: GetEntry<Prop, GenericObject[Prop]>;
-}[keyof GenericObject]) extends infer InferredResult extends DCommon.ObjectEntry ? DCommon.IsEqual<InferredResult, never> extends true ? [] : InferredResult[] : never;
+}[keyof GenericObject]) extends infer InferredResult extends DCommon.ObjectEntry ? DCommon.IsEqual<InferredResult, never> extends true ? readonly [] : readonly InferredResult[] : never;
 export declare function entries<GenericObject extends object>(object: GenericObject): DCommon.SimplifyTopLevel<GetEntries<GenericObject>>;
 export declare namespace entries {
     var unsafe: {

package/dist/object/index.cjs

@@ -1,6 +1,8 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_assign = require("./assign.cjs");
 const require_countKeys = require("./countKeys.cjs");
+const require_isSimple = require("./isSimple.cjs");
+const require_deepOverride = require("./deepOverride.cjs");
 const require_getDeepProperty = require("./getDeepProperty.cjs");
 const require_deepDiscriminate = require("./deepDiscriminate.cjs");
 const require_discriminate = require("./discriminate.cjs");
@@ -11,7 +13,6 @@ const require_entry = require("./entry.cjs");
 const require_fromEntries = require("./fromEntries.cjs");
 const require_getProperty = require("./getProperty.cjs");
 const require_hasKeys = require("./hasKeys.cjs");
-const require_isSimple = require("./isSimple.cjs");
 const require_keys = require("./keys.cjs");
 const require_omit = require("./omit.cjs");
 const require_override = require("./override.cjs");
@@ -25,6 +26,7 @@ var object_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	assign: () => require_assign.assign,
 	countKeys: () => require_countKeys.countKeys,
 	deepDiscriminate: () => require_deepDiscriminate.deepDiscriminate,
+	deepOverride: () => require_deepOverride.deepOverride,
 	discriminate: () => require_discriminate.discriminate,
 	discriminateEntryKey: () => require_discriminateEntryKey.discriminateEntryKey,
 	discriminateEntryValue: () => require_discriminateEntryValue.discriminateEntryValue,
@@ -48,6 +50,7 @@ var object_exports = /* @__PURE__ */ require_runtime.__exportAll({
 exports.assign = require_assign.assign;
 exports.countKeys = require_countKeys.countKeys;
 exports.deepDiscriminate = require_deepDiscriminate.deepDiscriminate;
+exports.deepOverride = require_deepOverride.deepOverride;
 exports.discriminate = require_discriminate.discriminate;
 exports.discriminateEntryKey = require_discriminateEntryKey.discriminateEntryKey;
 exports.discriminateEntryValue = require_discriminateEntryValue.discriminateEntryValue;

package/dist/object/index.d.ts

@@ -1,5 +1,6 @@
 export * from './assign';
 export * from './countKeys';
+export * from './deepOverride';
 export * from './deepDiscriminate';
 export * from './discriminate';
 export * from './discriminateEntryKey';

package/dist/object/index.mjs

@@ -1,6 +1,8 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { assign } from "./assign.mjs";
 import { countKeys } from "./countKeys.mjs";
+import { isSimple } from "./isSimple.mjs";
+import { deepOverride } from "./deepOverride.mjs";
 import { getDeepProperty } from "./getDeepProperty.mjs";
 import { deepDiscriminate } from "./deepDiscriminate.mjs";
 import { discriminate } from "./discriminate.mjs";
@@ -11,7 +13,6 @@ import { entry } from "./entry.mjs";
 import { fromEntries } from "./fromEntries.mjs";
 import { getProperty } from "./getProperty.mjs";
 import { hasKeys } from "./hasKeys.mjs";
-import { isSimple } from "./isSimple.mjs";
 import { keys } from "./keys.mjs";
 import { omit } from "./omit.mjs";
 import { override } from "./override.mjs";
@@ -25,6 +26,7 @@ var object_exports = /* @__PURE__ */ __exportAll({
 	assign: () => assign,
 	countKeys: () => countKeys,
 	deepDiscriminate: () => deepDiscriminate,
+	deepOverride: () => deepOverride,
 	discriminate: () => discriminate,
 	discriminateEntryKey: () => discriminateEntryKey,
 	discriminateEntryValue: () => discriminateEntryValue,
@@ -45,4 +47,4 @@ var object_exports = /* @__PURE__ */ __exportAll({
 	values: () => values
 });
 //#endregion
-export { assign, countKeys, deepDiscriminate, discriminate, discriminateEntryKey, discriminateEntryValue, entries, entry, fromEntries, getDeepProperty, getProperty, hasKeys, isSimple, keys, object_exports, omit, override, pick, to, transformProperties, transformProperty, values };
+export { assign, countKeys, deepDiscriminate, deepOverride, discriminate, discriminateEntryKey, discriminateEntryValue, entries, entry, fromEntries, getDeepProperty, getProperty, hasKeys, isSimple, keys, object_exports, omit, override, pick, to, transformProperties, transformProperty, values };

package/dist/object/isSimple.cjs

@@ -1,6 +1,6 @@
 //#region scripts/object/isSimple.ts
 function isSimple(input) {
-	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor.name === "Object");
+	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor?.name === "Object");
 }
 //#endregion
 exports.isSimple = isSimple;

package/dist/object/isSimple.mjs

@@ -1,6 +1,6 @@
 //#region scripts/object/isSimple.ts
 function isSimple(input) {
-	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor.name === "Object");
+	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor?.name === "Object");
 }
 //#endregion
 export { isSimple };

package/dist/object/keys.d.ts

@@ -1 +1 @@
-export declare function keys<GenericObject extends object>(object: GenericObject): `${Exclude<keyof GenericObject, symbol>}`[];
+export declare function keys<GenericObject extends object>(object: GenericObject): readonly `${Exclude<keyof GenericObject, symbol>}`[];

package/dist/object/override.cjs

@@ -5,7 +5,7 @@ function override(...args) {
 		return (object) => override(object, value);
 	}
 	const [object, value] = args;
-	return Object.entries(value).reduce((acc, [key, value]) => {
+	return Object.entries(value ?? {}).reduce((acc, [key, value]) => {
 		if (value !== void 0) acc[key] = value;
 		return acc;
 	}, { ...object });

package/dist/object/override.d.ts

@@ -1,2 +1,5 @@
-export declare function override<GenericObject extends object>(value: Partial<NoInfer<GenericObject>>): (object: GenericObject) => GenericObject;
-export declare function override<GenericObject extends object>(object: GenericObject, value: Partial<NoInfer<GenericObject>>): GenericObject;
+import type * as DCommon from '../common';
+type OverrideParameter<GenericValue extends object> = DCommon.IsUnion<GenericValue> extends true ? undefined : Partial<GenericValue>;
+export declare function override<GenericObject extends object>(value: OverrideParameter<GenericObject>): (object: GenericObject) => GenericObject;
+export declare function override<GenericObject extends object>(object: GenericObject, value: OverrideParameter<GenericObject>): GenericObject;
+export {};

package/dist/object/override.mjs

@@ -5,7 +5,7 @@ function override(...args) {
 		return (object) => override(object, value);
 	}
 	const [object, value] = args;
-	return Object.entries(value).reduce((acc, [key, value]) => {
+	return Object.entries(value ?? {}).reduce((acc, [key, value]) => {
 		if (value !== void 0) acc[key] = value;
 		return acc;
 	}, { ...object });

package/dist/object/types/assign.d.ts

@@ -0,0 +1,2 @@
+import type * as DCommon from '../../common';
+export type Assign<GenericFirstObject extends object, GenericSecondObject extends object> = DCommon.SimplifyTopLevel<Omit<GenericFirstObject, keyof GenericSecondObject> & GenericSecondObject>;

package/dist/object/types/forbiddenKey.d.ts

@@ -1,2 +1,2 @@
 import type * as DCommon from '../../common';
-export type ForbiddenKey<GenericObject extends object, GenericKey extends string> = (GenericKey extends keyof GenericObject ? DCommon.ComputedTypeError<`Key "${GenericKey}" is forbidden.`> : never) extends infer InferredResult ? DCommon.IsEqual<InferredResult, never> extends true ? unknown : InferredResult : never;
+export type ForbiddenKey<GenericObject extends object, GenericKey extends string | number> = DCommon.IsNever<GenericKey> extends true ? unknown : (`${GenericKey}` extends `${Extract<keyof GenericObject, string | number>}` ? DCommon.ComputedTypeError<`Key "${GenericKey}" is forbidden.`> : never) extends infer InferredResult ? DCommon.IsEqual<InferredResult, never> extends true ? unknown : InferredResult : never;

package/dist/object/types/forbiddenUndefinedProps.d.ts

@@ -0,0 +1,3 @@
+import { GetPropsWithValueExtends } from './getPropsWithValueExtends';
+import type * as DCommon from '../../common';
+export type ForbiddenUndefinedProps<GenericObject extends object> = DCommon.IsNever<GetPropsWithValueExtends<GenericObject, undefined>> extends true ? unknown : DCommon.ComputedTypeError<"Having \"undefined\" values for properties is not allowed.">;

package/dist/object/types/hasKeySignature.d.ts

@@ -0,0 +1 @@
+export type HasKeySignature<GenericValue extends object> = string extends keyof GenericValue ? true : number extends keyof GenericValue ? true : symbol extends keyof GenericValue ? true : false;

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

@@ -1,13 +1,17 @@
-export type * from './assignObjects';
-export type * from './everyCombination';
+export type * from './assign';
 export type * from './deepPartial';
 export type * from './deepReadonly';
 export type * from './deepRemoveReadonly';
 export type * from './deepRequired';
+export type * from './everyCombination';
 export type * from './flatObject';
 export type * from './forbiddenKey';
+export type * from './forbiddenUndefinedProps';
 export type * from './getPropsWithValue';
 export type * from './getPropsWithValueExtends';
+export type * from './hasKeySignature';
+export type * from './keyofWithoutSignature';
+export type * from './override';
 export type * from './partialKeys';
 export type * from './requireAtLeastOne';
 export type * from './requiredKeys';

package/dist/object/types/keyofWithoutSignature.d.ts

@@ -0,0 +1,3 @@
+export type keyofWithoutSignature<GenericValue extends object> = keyof {
+    [Prop in keyof GenericValue as string extends Prop ? never : number extends Prop ? never : symbol extends Prop ? never : Prop]: GenericValue[Prop];
+};

package/dist/object/types/override.d.ts

@@ -0,0 +1,4 @@
+import type * as DCommon from '../../common';
+export type Override<GenericInput extends object, GenericNewValue extends Partial<GenericInput>> = DCommon.SimplifyTopLevel<{
+    [Prop in keyof GenericInput]: Prop extends keyof GenericNewValue ? GenericNewValue[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? GenericInput[Prop] : InferredNewValue : never : GenericInput[Prop];
+}>;

package/dist/object/types/split.d.ts

@@ -2,12 +2,12 @@ import type * as DCommon from '../../common';
 type CreateShape<GenericResult extends unknown, GenericProp extends keyof any> = GenericResult extends any ? {
     [RemapProp in GenericProp]: GenericResult;
 } : never;
-export type Split<GenericValue extends unknown, GenericMax extends number = 10, GenericAccumulator extends readonly never[] = readonly []> = GenericValue extends object ? GenericAccumulator["length"] extends GenericMax ? GenericValue : {
+export type Split<GenericValue extends unknown, GenericMax extends number = 10, GenericAccumulator extends readonly never[] = readonly []> = GenericValue extends unknown ? DCommon.IsObject<GenericValue> extends true ? GenericAccumulator["length"] extends GenericMax ? GenericValue : {
     [Prop in keyof GenericValue]: DCommon.NeverCoalescing<CreateShape<Split<GenericValue[Prop], GenericMax, [
         ...GenericAccumulator,
         never
     ]>, Prop>, {
         [RemapProp in Prop]: never;
     }>;
-}[keyof GenericValue] : GenericValue;
+}[keyof GenericValue] : GenericValue : never;
 export {};

package/dist/object/values.d.ts

@@ -1,2 +1,2 @@
 import type * as DCommon from '../common';
-export declare function values<GenericObject extends Record<string, DCommon.AnyValue>>(object: GenericObject): GenericObject[keyof GenericObject][];
+export declare function values<GenericObject extends Record<string, DCommon.AnyValue>>(object: GenericObject): readonly GenericObject[keyof GenericObject][];

package/dist/path/create.cjs

@@ -0,0 +1,11 @@
+const require_error = require("../either/left/error.cjs");
+const require_success = require("../either/right/success.cjs");
+const require_normalize = require("./normalize.cjs");
+//#region scripts/path/create.ts
+function create(value) {
+	const result = require_normalize.normalize(value);
+	if (result) return require_success.success(result);
+	return require_error.error(value);
+}
+//#endregion
+exports.create = create;

package/dist/path/create.d.ts

@@ -0,0 +1,3 @@
+import { Path } from './constraints';
+import * as DEither from '../either';
+export declare function create(value: string): (DEither.Success<string & Path> | DEither.Error<string>);

package/dist/path/create.mjs

@@ -0,0 +1,11 @@
+import { error } from "../either/left/error.mjs";
+import { success } from "../either/right/success.mjs";
+import { normalize } from "./normalize.mjs";
+//#region scripts/path/create.ts
+function create(value) {
+	const result = normalize(value);
+	if (result) return success(result);
+	return error(value);
+}
+//#endregion
+export { create };

package/dist/path/createAbsolute.cjs

@@ -0,0 +1,12 @@
+const require_error = require("../either/left/error.cjs");
+const require_success = require("../either/right/success.cjs");
+const require_normalize = require("./normalize.cjs");
+const require_isAbsolute = require("./isAbsolute.cjs");
+//#region scripts/path/createAbsolute.ts
+function createAbsolute(value) {
+	const result = require_normalize.normalize(value);
+	if (result && require_isAbsolute.isAbsolute(result)) return require_success.success(result);
+	return require_error.error(value);
+}
+//#endregion
+exports.createAbsolute = createAbsolute;

package/dist/path/createAbsolute.d.ts

@@ -0,0 +1,3 @@
+import { Absolute } from './constraints';
+import * as DEither from '../either';
+export declare function createAbsolute(value: string): (DEither.Success<string & Absolute> | DEither.Error<string>);

package/dist/path/createAbsolute.mjs

@@ -0,0 +1,12 @@
+import { error } from "../either/left/error.mjs";
+import { success } from "../either/right/success.mjs";
+import { normalize } from "./normalize.mjs";
+import { isAbsolute } from "./isAbsolute.mjs";
+//#region scripts/path/createAbsolute.ts
+function createAbsolute(value) {
+	const result = normalize(value);
+	if (result && isAbsolute(result)) return success(result);
+	return error(value);
+}
+//#endregion
+export { createAbsolute };