@duplojs/utils 1.3.30 → 1.3.32

package/dist/clean/entity.d.ts

@@ -40,7 +40,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
     readonly name: GenericName;
     readonly propertiesDefinition: GenericPropertiesDefinition;
     readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, EntityRawProperties<GenericPropertiesDefinition>>;
-    "new"<GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
+    "new"<const GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
     map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
     mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
     is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
@@ -70,6 +70,6 @@ export interface PropertiesDefinitionParams {
         inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
     };
 }
-export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition): EntityHandler<GenericName, GenericPropertiesDefinition>;
+export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition & DObject.ForbiddenKey<GenericPropertiesDefinition, "_entityName" | "_flags">): EntityHandler<GenericName, GenericPropertiesDefinition>;
 export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
 export {};

package/dist/clean/flag.cjs

@@ -19,6 +19,10 @@ function createFlag(name) {
         getValue(entity) {
             return flagKind.getValue(entity)[name];
         },
+        has(entity) {
+            return flagKind.has(entity)
+                && name in flagKind.getValue(entity);
+        },
     });
 }
 

package/dist/clean/flag.d.ts

@@ -6,6 +6,7 @@ export interface FlagHandler<GenericEntity extends Entity = Entity, GenericName
     readonly name: GenericName;
     append<GenericInputEntity extends GenericEntity, GenericInputValue extends GenericValue>(entity: GenericInputEntity, ...args: IsEqual<GenericValue, never> extends true ? [] : [GenericInputValue]): (GenericInputEntity & Flag<GenericName, GenericInputValue>);
     getValue<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericValue>>(entity: GenericInputEntity): GetKindValue<typeof flagKind, GenericInputEntity>[GenericName];
+    has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): Extract<GenericInputEntity, Flag<GenericName, any>>;
 }
 export interface Flag<GenericName extends string = string, GenericValue extends unknown = never> extends Kind<typeof flagKind.definition, Record<GenericName, GenericValue>> {
 }

package/dist/clean/flag.mjs

@@ -17,6 +17,10 @@ function createFlag(name) {
         getValue(entity) {
             return flagKind.getValue(entity)[name];
         },
+        has(entity) {
+            return flagKind.has(entity)
+                && name in flagKind.getValue(entity);
+        },
     });
 }
 

package/dist/clean/index.cjs

@@ -6,6 +6,7 @@ var entity = require('./entity.cjs');
 var repository = require('./repository.cjs');
 var useCase = require('./useCase.cjs');
 var flag = require('./flag.cjs');
+var unwrapEntity = require('./unwrapEntity.cjs');
 var base = require('./constraint/base.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
@@ -53,6 +54,7 @@ exports.useCaseHandlerKind = useCase.useCaseHandlerKind;
 exports.useCaseInstances = useCase.useCaseInstances;
 exports.createFlag = flag.createFlag;
 exports.flagKind = flag.flagKind;
+exports.unwrapEntity = unwrapEntity.unwrapEntity;
 exports.CreateConstrainedTypeError = base.CreateConstrainedTypeError;
 exports.constrainedTypeKind = base.constrainedTypeKind;
 exports.constraintHandlerKind = base.constraintHandlerKind;

package/dist/clean/index.d.ts

@@ -7,3 +7,4 @@ export * from "./primitive";
 export * from "./repository";
 export * from "./useCase";
 export * from "./flag";
+export * from "./unwrapEntity";

package/dist/clean/index.mjs

@@ -4,6 +4,7 @@ export { CreateEntityError, createEntity, entityKind } from './entity.mjs';
 export { createRepository, repositoryHandlerKind } from './repository.mjs';
 export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.mjs';
 export { createFlag, flagKind } from './flag.mjs';
+export { unwrapEntity } from './unwrapEntity.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
 export { Int, Negative, Positive } from './constraint/defaultConstraint/number.mjs';
 export { Email, Url } from './constraint/defaultConstraint/string.mjs';

package/dist/clean/newType.d.ts

@@ -1,4 +1,4 @@
-import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing } from "..";
+import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing, type DeepReadonly } from "..";
 import { constrainedTypeKind, type ConstraintHandler } from "./constraint";
 import { type Primitive, type EligiblePrimitive } from "./primitive";
 import * as DEither from "../either";
@@ -34,6 +34,6 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
 export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
     ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>,
     ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>[]
-]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DDataParser.Output<GenericDataParser>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, readonly []>>>;
+]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, readonly []>>>;
 export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constrains"][number]["name"]> : never, any>;
 export {};

package/dist/clean/unwrapEntity.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var entity = require('./entity.cjs');
+var flag = require('./flag.cjs');
+var unwrap = require('../common/unwrap.cjs');
+
+function unwrapEntity(entity$1) {
+    const unwrapEntity = {};
+    for (const prop in entity$1) {
+        if (prop === entity.entityKind.runTimeKey) {
+            unwrapEntity._entityName = entity$1[prop];
+        }
+        else if (prop === flag.flagKind.runTimeKey) {
+            unwrapEntity._flags = entity$1[prop];
+        }
+        else if (entity$1[prop] instanceof Array) {
+            unwrapEntity[prop] = entity$1[prop].map(unwrap.unwrap);
+        }
+        else {
+            unwrapEntity[prop] = unwrap.unwrap(entity$1[prop]);
+        }
+    }
+    return unwrapEntity;
+}
+
+exports.unwrapEntity = unwrapEntity;

package/dist/clean/unwrapEntity.d.ts

@@ -0,0 +1,13 @@
+import { type GetKindValue, type SimplifyTopLevel, type Kind, type Unwrap, type DeepReadonly } from "../common";
+import { entityKind, type Entity } from "./entity";
+import { flagKind } from "./flag";
+type UnwrapArrayProperties<GenericValue extends readonly any[]> = GenericValue extends readonly [infer InferredFirst, ...infer InferredRest] ? (InferredRest extends readonly [] ? readonly [] : UnwrapArrayProperties<InferredRest>) extends infer InferredResult extends readonly any[] ? readonly [Unwrap<InferredFirst>, ...InferredResult] : never : readonly Unwrap<GenericValue[number]>[];
+export type UnwrapEntity<GenericEntity extends Entity> = SimplifyTopLevel<DeepReadonly<{
+    [Prop in Extract<keyof GenericEntity, string>]: GenericEntity[Prop] extends readonly any[] ? UnwrapArrayProperties<GenericEntity[Prop]> : Unwrap<GenericEntity[Prop]>;
+} & {
+    [Prop in "_entityName"]: GetKindValue<typeof entityKind, GenericEntity>;
+} & (GenericEntity extends Kind<typeof flagKind.definition, any> ? {
+    [Prop in "_flags"]: SimplifyTopLevel<GetKindValue<typeof flagKind, GenericEntity>>;
+} : {})>>;
+export declare function unwrapEntity<GenericEntity extends Entity>(entity: GenericEntity): UnwrapEntity<GenericEntity>;
+export {};

package/dist/clean/unwrapEntity.mjs

@@ -0,0 +1,24 @@
+import { entityKind } from './entity.mjs';
+import { flagKind } from './flag.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+
+function unwrapEntity(entity) {
+    const unwrapEntity = {};
+    for (const prop in entity) {
+        if (prop === entityKind.runTimeKey) {
+            unwrapEntity._entityName = entity[prop];
+        }
+        else if (prop === flagKind.runTimeKey) {
+            unwrapEntity._flags = entity[prop];
+        }
+        else if (entity[prop] instanceof Array) {
+            unwrapEntity[prop] = entity[prop].map(unwrap);
+        }
+        else {
+            unwrapEntity[prop] = unwrap(entity[prop]);
+        }
+    }
+    return unwrapEntity;
+}
+
+export { unwrapEntity };

package/dist/common/index.d.ts

@@ -45,3 +45,5 @@ export * from "./truthy";
 export * from "./falsy";
 export * from "./hasSomeKinds";
 export * from "./hasKinds";
+export * from "./toCurriedPredicate";
+export * from "./pipeCall";

package/dist/common/override.cjs

@@ -1,33 +1,53 @@
 'use strict';
 
 var globalStore = require('./globalStore.cjs');
-var pipe = require('./pipe.cjs');
-var fromEntries = require('../object/fromEntries.cjs');
-var map = require('../array/map.cjs');
-var entry = require('../object/entry.cjs');
 
 const SymbolOverrideStore = Symbol.for("@duplojs/utils/override");
 const overrideStore = globalStore.createGlobalStore(SymbolOverrideStore, {});
 function createOverride(overrideName) {
-    const store = overrideStore.value[overrideName] ?? [];
-    overrideStore.set({
-        ...overrideStore.value,
-        [overrideName]: store,
-    });
+    const overridePropertiesStore = overrideStore.value[overrideName] ?? {};
+    overrideStore.value[overrideName] ||= overridePropertiesStore;
+    let cachedStoreKey = Object.keys(overridePropertiesStore);
     return {
         setMethod(prop, theFunction) {
-            store.push([prop, theFunction]);
+            overridePropertiesStore[prop] = theFunction;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         setPropertyDefaultValue(prop, value) {
-            store.push([prop, value]);
+            overridePropertiesStore[prop] = value;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         apply(overrideInterface) {
-            const self = {
-                ...overrideInterface,
-                ...pipe.pipe(store, map.map(([key, value]) => entry.entry(key, typeof value === "function"
-                    ? (...args) => value(self, ...args)
-                    : value)), fromEntries.fromEntries),
-            };
+            const cachedOverrideProperties = {};
+            const self = new Proxy({}, {
+                get(target, prop) {
+                    if (overridePropertiesStore[prop]) {
+                        if (!cachedOverrideProperties[prop]) {
+                            cachedOverrideProperties[prop] = typeof overridePropertiesStore[prop] === "function"
+                                ? (...args) => overridePropertiesStore[prop](self, ...args)
+                                : overridePropertiesStore[prop];
+                        }
+                        return cachedOverrideProperties[prop];
+                    }
+                    return overrideInterface[prop];
+                },
+                ownKeys() {
+                    return [
+                        ...Object.keys(overrideInterface),
+                        ...cachedStoreKey,
+                    ];
+                },
+                has(target, prop) {
+                    return Object.keys(overrideInterface).includes(prop)
+                        || cachedStoreKey.includes(prop);
+                },
+                getOwnPropertyDescriptor() {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                    };
+                },
+            });
             return self;
         },
     };

package/dist/common/override.d.ts

@@ -1,17 +1,14 @@
-import { type GetPropsWithValueExtends } from "../object";
-import { type Adaptor, type AnyFunction, type AnyValue, type ObjectKey } from "./types";
+import { type Adaptor, type AnyFunction, type AnyValue } from "./types";
+import type * as DObject from "../object";
 declare const SymbolOverrideStore: unique symbol;
 declare module "./globalStore" {
     interface GlobalStore {
-        [SymbolOverrideStore]: Record<string, [
-            ObjectKey,
-            Exclude<AnyValue, AnyFunction> | AnyFunction<[object, ...unknown[]]>
-        ][]>;
+        [SymbolOverrideStore]: Record<string, Record<string, unknown>>;
     }
 }
 export interface OverrideHandler<GenericInterface extends object> {
-    setMethod<GenericProperty extends GetPropsWithValueExtends<GenericInterface, AnyFunction>>(prop: GenericProperty, theFunction: (self: GenericInterface, ...args: Parameters<GenericInterface[GenericProperty]>) => ReturnType<GenericInterface[GenericProperty]>): void;
-    setPropertyDefaultValue<GenericProperty extends Exclude<keyof GenericInterface, GetPropsWithValueExtends<GenericInterface, AnyFunction>>>(prop: GenericProperty, value: Adaptor<GenericInterface[GenericProperty], AnyValue>): void;
+    setMethod<GenericProperty extends DObject.GetPropsWithValueExtends<GenericInterface, AnyFunction>>(prop: GenericProperty, theFunction: (self: GenericInterface, ...args: Parameters<GenericInterface[GenericProperty]>) => ReturnType<GenericInterface[GenericProperty]>): void;
+    setPropertyDefaultValue<GenericProperty extends Exclude<keyof GenericInterface, DObject.GetPropsWithValueExtends<GenericInterface, AnyFunction>>>(prop: GenericProperty, value: Adaptor<GenericInterface[GenericProperty], AnyValue>): void;
     apply(overrideInterface: GenericInterface): GenericInterface;
 }
 export declare function createOverride<GenericInterface extends object>(overrideName: string): OverrideHandler<GenericInterface>;

package/dist/common/override.mjs

@@ -1,31 +1,51 @@
 import { createGlobalStore } from './globalStore.mjs';
-import { pipe } from './pipe.mjs';
-import { fromEntries } from '../object/fromEntries.mjs';
-import { map } from '../array/map.mjs';
-import { entry } from '../object/entry.mjs';
 
 const SymbolOverrideStore = Symbol.for("@duplojs/utils/override");
 const overrideStore = createGlobalStore(SymbolOverrideStore, {});
 function createOverride(overrideName) {
-    const store = overrideStore.value[overrideName] ?? [];
-    overrideStore.set({
-        ...overrideStore.value,
-        [overrideName]: store,
-    });
+    const overridePropertiesStore = overrideStore.value[overrideName] ?? {};
+    overrideStore.value[overrideName] ||= overridePropertiesStore;
+    let cachedStoreKey = Object.keys(overridePropertiesStore);
     return {
         setMethod(prop, theFunction) {
-            store.push([prop, theFunction]);
+            overridePropertiesStore[prop] = theFunction;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         setPropertyDefaultValue(prop, value) {
-            store.push([prop, value]);
+            overridePropertiesStore[prop] = value;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         apply(overrideInterface) {
-            const self = {
-                ...overrideInterface,
-                ...pipe(store, map(([key, value]) => entry(key, typeof value === "function"
-                    ? (...args) => value(self, ...args)
-                    : value)), fromEntries),
-            };
+            const cachedOverrideProperties = {};
+            const self = new Proxy({}, {
+                get(target, prop) {
+                    if (overridePropertiesStore[prop]) {
+                        if (!cachedOverrideProperties[prop]) {
+                            cachedOverrideProperties[prop] = typeof overridePropertiesStore[prop] === "function"
+                                ? (...args) => overridePropertiesStore[prop](self, ...args)
+                                : overridePropertiesStore[prop];
+                        }
+                        return cachedOverrideProperties[prop];
+                    }
+                    return overrideInterface[prop];
+                },
+                ownKeys() {
+                    return [
+                        ...Object.keys(overrideInterface),
+                        ...cachedStoreKey,
+                    ];
+                },
+                has(target, prop) {
+                    return Object.keys(overrideInterface).includes(prop)
+                        || cachedStoreKey.includes(prop);
+                },
+                getOwnPropertyDescriptor() {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                    };
+                },
+            });
             return self;
         },
     };

package/dist/common/pipeCall.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function pipeCall(theFunction) {
+    return theFunction;
+}
+
+exports.pipeCall = pipeCall;

package/dist/common/pipeCall.d.ts

@@ -0,0 +1 @@
+export declare function pipeCall<GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: NoInfer<GenericInput>) => GenericOutput): (input: GenericInput) => NoInfer<GenericOutput>;

package/dist/common/pipeCall.mjs

@@ -0,0 +1,5 @@
+function pipeCall(theFunction) {
+    return theFunction;
+}
+
+export { pipeCall };

package/dist/common/toCurriedPredicate.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function toCurriedPredicate(thePredicate) {
+    return thePredicate;
+}
+
+exports.toCurriedPredicate = toCurriedPredicate;

package/dist/common/toCurriedPredicate.d.ts

@@ -0,0 +1 @@
+export declare function toCurriedPredicate<GenericInput extends unknown, GenericPredicate extends GenericInput>(thePredicate: (input: GenericInput) => input is GenericPredicate): (input: GenericInput) => input is GenericPredicate;

package/dist/common/toCurriedPredicate.mjs

@@ -0,0 +1,5 @@
+function toCurriedPredicate(thePredicate) {
+    return thePredicate;
+}
+
+export { toCurriedPredicate };

package/dist/common/types/DeepReadonly.d.ts

@@ -0,0 +1,3 @@
+export type DeepReadonly<GenericValue extends unknown> = GenericValue extends object ? {
+    readonly [Prop in keyof GenericValue]: DeepReadonly<GenericValue[Prop]>;
+} : GenericValue;

package/dist/common/types/anyValue.d.ts

@@ -1,2 +1,2 @@
 import { type AnyFunction } from "./anyFunction";
-export type AnyValue = string | number | boolean | object | null | bigint | AnyFunction | undefined | symbol;
+export type AnyValue = string | number | boolean | object | null | bigint | AnyFunction | undefined | symbol | AnyValue[];

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

@@ -43,3 +43,4 @@ export * from "./onlyLiteral";
 export * from "./sortType";
 export * from "./maybeGetter";
 export * from "./falsyValue";
+export * from "./DeepReadonly";

package/dist/dataParser/extended/object.cjs

@@ -4,6 +4,7 @@ var baseExtended = require('../baseExtended.cjs');
 var index = require('../parsers/object/index.cjs');
 var required = require('../parsers/object/required.cjs');
 var partial = require('../parsers/object/partial.cjs');
+var _extends = require('../parsers/object/extends.cjs');
 var pick = require('../parsers/object/pick.cjs');
 var omit = require('../parsers/object/omit.cjs');
 var override = require('../../common/override.cjs');
@@ -18,6 +19,10 @@ function object(shape, definition) {
             const newShape = pick.pickShape(self.definition.shape, pickObject);
             return object(newShape, definition);
         },
+        extends: (self, extension, definition) => {
+            const newShape = _extends.extendsShape(self.definition.shape, extension);
+            return object(newShape, definition);
+        },
         partial: (self, definition) => {
             const newShape = partial.partialShape(self.definition.shape);
             return object(newShape, definition);

package/dist/dataParser/extended/object.d.ts

@@ -3,6 +3,7 @@ import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Output } from "../base";
+import { type AssignObjects } from "../../object";
 type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (Kind<typeof dataParsers.objectKind.definition> & DataParserExtended<GenericDefinition, dataParsers.DataParserObjectShapeOutput<GenericDefinition["shape"]>, dataParsers.DataParserObjectShapeInput<GenericDefinition["shape"]>>);
 export interface DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject = dataParsers.DataParserDefinitionObject> extends _DataParserObjectExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
@@ -25,6 +26,9 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
     pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: SimplifyTopLevel<Pick<GenericDefinition["shape"], Adaptor<keyof GenericPickObject, keyof GenericDefinition["shape"]>>>;
     }>>;
+    extends<const GenericExtension extends dataParsers.DataParserObjectShape, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(extension: GenericExtension, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: AssignObjects<GenericDefinition["shape"], GenericExtension>;
+    }>>;
     partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: dataParsers.PartialDataParserObject<GenericDefinition["shape"]>;
     }>>;

package/dist/dataParser/extended/object.mjs

@@ -2,6 +2,7 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { object as object$1 } from '../parsers/object/index.mjs';
 import { requiredShape } from '../parsers/object/required.mjs';
 import { partialShape } from '../parsers/object/partial.mjs';
+import { extendsShape } from '../parsers/object/extends.mjs';
 import { pickShape } from '../parsers/object/pick.mjs';
 import { omitShape } from '../parsers/object/omit.mjs';
 import { createOverride } from '../../common/override.mjs';
@@ -16,6 +17,10 @@ function object(shape, definition) {
             const newShape = pickShape(self.definition.shape, pickObject);
             return object(newShape, definition);
         },
+        extends: (self, extension, definition) => {
+            const newShape = extendsShape(self.definition.shape, extension);
+            return object(newShape, definition);
+        },
         partial: (self, definition) => {
             const newShape = partialShape(self.definition.shape);
             return object(newShape, definition);

package/dist/dataParser/identifier.d.ts

@@ -8,7 +8,7 @@ import { type DataParser } from "./base";
  * parsers, the correct type can be retrieved.
  */
 export declare const identifier: {
-    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
         output: string;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
@@ -60,7 +60,7 @@ export declare const identifier: {
         input: unknown[];
         output: unknown[];
     }>>, GenericInput extends DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+    <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
         output: string;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {

package/dist/dataParser/index.cjs

@@ -16,6 +16,7 @@ var omit = require('./parsers/object/omit.cjs');
 var pick = require('./parsers/object/pick.cjs');
 var partial = require('./parsers/object/partial.cjs');
 var required = require('./parsers/object/required.cjs');
+var _extends = require('./parsers/object/extends.cjs');
 var index$3 = require('./parsers/object/index.cjs');
 var int = require('./parsers/number/checkers/int.cjs');
 var min$1 = require('./parsers/number/checkers/min.cjs');
@@ -97,6 +98,8 @@ exports.partial = partial.partial;
 exports.partialShape = partial.partialShape;
 exports.required = required.required;
 exports.requiredShape = required.requiredShape;
+exports.extends = _extends.extends;
+exports.extendsShape = _extends.extendsShape;
 exports.object = index$3.object;
 exports.objectKind = index$3.objectKind;
 exports.checkerInt = int.checkerInt;

package/dist/dataParser/index.mjs

@@ -16,6 +16,7 @@ export { omit, omitShape } from './parsers/object/omit.mjs';
 export { pick, pickShape } from './parsers/object/pick.mjs';
 export { partial, partialShape } from './parsers/object/partial.mjs';
 export { required, requiredShape } from './parsers/object/required.mjs';
+export { extends, extendsShape } from './parsers/object/extends.mjs';
 export { object, objectKind } from './parsers/object/index.mjs';
 export { checkerInt, checkerIntKind, int } from './parsers/number/checkers/int.mjs';
 export { checkerNumberMin, checkerNumberMinKind } from './parsers/number/checkers/min.mjs';

package/dist/dataParser/parsers/literal.d.ts

@@ -25,8 +25,8 @@ export interface DataParserLiteral<GenericDefinition extends DataParserDefinitio
      */
     construct<const GenericDefinition extends DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, GenericDefinition>>;
 }
-export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
-    value: GenericValue[];
+export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | readonly GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
+    value: readonly GenericValue[];
 }>>;
 export declare namespace literal {
     var overrideHandler: import("../../common").OverrideHandler<DataParserLiteral<DataParserDefinitionLiteral>>;

package/dist/dataParser/parsers/object/extends.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var index = require('./index.cjs');
+var assign = require('../../../object/assign.cjs');
+
+function extendsShape(shape, extension) {
+    return assign.assign(shape, extension);
+}
+function extend(dataParser, extension, definition) {
+    const newShape = extendsShape(dataParser.definition.shape, extension);
+    return index.object(newShape, definition);
+}
+
+exports.extends = extend;
+exports.extendsShape = extendsShape;

package/dist/dataParser/parsers/object/extends.d.ts

@@ -0,0 +1,9 @@
+import { type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type NeverCoalescing } from "../../../common";
+import { type AssignObjects } from "../../../object";
+export declare function extendsShape(shape: DataParserObjectShape, extension: DataParserObjectShape): DataParserObjectShape;
+declare function extend<GenericDataParserObject extends DataParserObject, const GenericExtension extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, extension: GenericExtension, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+    readonly shape: AssignObjects<GenericDataParserObject["definition"]["shape"], GenericExtension>;
+}>>;
+export { extend as extends };

package/dist/dataParser/parsers/object/extends.mjs

@@ -0,0 +1,12 @@
+import { object } from './index.mjs';
+import { assign } from '../../../object/assign.mjs';
+
+function extendsShape(shape, extension) {
+    return assign(shape, extension);
+}
+function extend(dataParser, extension, definition) {
+    const newShape = extendsShape(dataParser.definition.shape, extension);
+    return object(newShape, definition);
+}
+
+export { extend as extends, extendsShape };

package/dist/dataParser/parsers/object/index.d.ts

@@ -8,6 +8,7 @@ export * from "./omit";
 export * from "./pick";
 export * from "./partial";
 export * from "./required";
+export * from "./extends";
 export type DataParserObjectShape = Readonly<Record<string, DataParser>>;
 export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectShape> = {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Output<GenericShape[Prop]>;

package/dist/index.cjs

@@ -58,6 +58,8 @@ var truthy = require('./common/truthy.cjs');
 var falsy = require('./common/falsy.cjs');
 var hasSomeKinds = require('./common/hasSomeKinds.cjs');
 var hasKinds = require('./common/hasKinds.cjs');
+var toCurriedPredicate = require('./common/toCurriedPredicate.cjs');
+var pipeCall = require('./common/pipeCall.cjs');
 
 
 
@@ -143,3 +145,5 @@ exports.truthy = truthy.truthy;
 exports.falsy = falsy.falsy;
 exports.hasSomeKinds = hasSomeKinds.hasSomeKinds;
 exports.hasKinds = hasKinds.hasKinds;
+exports.toCurriedPredicate = toCurriedPredicate.toCurriedPredicate;
+exports.pipeCall = pipeCall.pipeCall;

package/dist/index.mjs

@@ -80,3 +80,5 @@ export { truthy } from './common/truthy.mjs';
 export { falsy } from './common/falsy.mjs';
 export { hasSomeKinds } from './common/hasSomeKinds.mjs';
 export { hasKinds } from './common/hasKinds.mjs';
+export { toCurriedPredicate } from './common/toCurriedPredicate.mjs';
+export { pipeCall } from './common/pipeCall.mjs';

package/dist/metadata.json

@@ -976,6 +976,15 @@
         {
           "name": "repository.mjs"
         },
+        {
+          "name": "unwrapEntity.cjs"
+        },
+        {
+          "name": "unwrapEntity.d.ts"
+        },
+        {
+          "name": "unwrapEntity.mjs"
+        },
         {
           "name": "useCase.cjs"
         },
@@ -1026,6 +1035,9 @@
             {
               "name": "deepPartial.d.ts"
             },
+            {
+              "name": "DeepReadonly.d.ts"
+            },
             {
               "name": "deepRemoveReadonly.d.ts"
             },
@@ -1418,6 +1430,15 @@
         {
           "name": "pipe.mjs"
         },
+        {
+          "name": "pipeCall.cjs"
+        },
+        {
+          "name": "pipeCall.d.ts"
+        },
+        {
+          "name": "pipeCall.mjs"
+        },
         {
           "name": "promiseObject.cjs"
         },
@@ -1463,6 +1484,15 @@
         {
           "name": "stringToMillisecond.mjs"
         },
+        {
+          "name": "toCurriedPredicate.cjs"
+        },
+        {
+          "name": "toCurriedPredicate.d.ts"
+        },
+        {
+          "name": "toCurriedPredicate.mjs"
+        },
         {
           "name": "toJSON.cjs"
         },
@@ -2077,6 +2107,15 @@
             {
               "name": "object",
               "files": [
+                {
+                  "name": "extends.cjs"
+                },
+                {
+                  "name": "extends.d.ts"
+                },
+                {
+                  "name": "extends.mjs"
+                },
                 {
                   "name": "index.cjs"
                 },
@@ -4119,6 +4158,9 @@
             {
               "name": "flatObject.d.ts"
             },
+            {
+              "name": "forbiddenKey.d.ts"
+            },
             {
               "name": "getPropsWithValue.d.ts"
             },
@@ -4151,6 +4193,15 @@
         {
           "name": "assign.mjs"
         },
+        {
+          "name": "countKeys.cjs"
+        },
+        {
+          "name": "countKeys.d.ts"
+        },
+        {
+          "name": "countKeys.mjs"
+        },
         {
           "name": "deepDiscriminate.cjs"
         },

package/dist/object/countKeys.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var wrapValue = require('../common/wrapValue.cjs');
+var kind = require('../common/kind.cjs');
+
+function countKeys(object) {
+    return Object.keys(object)
+        .filter((key) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key))
+        .length;
+}
+
+exports.countKeys = countKeys;

package/dist/object/countKeys.d.ts

@@ -0,0 +1 @@
+export declare function countKeys<GenericObject extends object>(object: GenericObject): number;

package/dist/object/countKeys.mjs

@@ -0,0 +1,10 @@
+import { isRuntimeWrappedValueKey } from '../common/wrapValue.mjs';
+import { isRuntimeKind } from '../common/kind.mjs';
+
+function countKeys(object) {
+    return Object.keys(object)
+        .filter((key) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key))
+        .length;
+}
+
+export { countKeys };

package/dist/object/entries.cjs

@@ -7,5 +7,11 @@ function entries(object) {
     return Object.entries(object)
         .filter(([key]) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));
 }
+/**
+ * @deprecated Not ignore kind key.
+ */
+entries.unsafe = function (object) {
+    return Object.entries(object);
+};
 
 exports.entries = entries;

package/dist/object/entries.d.ts

@@ -1,8 +1,11 @@
 import { type DString } from "..";
-import { type IsEqual, type ObjectEntry, type ObjectKey } from "../common";
+import { type AnyValue, type IsEqual, type ObjectEntry, type ObjectKey } from "../common";
 import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
 export type GetEntry<GenericKey extends 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]][] : ({
+export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? [DString.Number, GenericObject[number]][] : IsEqual<GenericObject, object> extends true ? [string, AnyValue][] : ({
     [Prop in keyof GenericObject]-?: GetEntry<Prop, GenericObject[Prop]>;
 }[keyof GenericObject]) extends infer InferredResult extends ObjectEntry ? IsEqual<InferredResult, never> extends true ? [] : InferredResult[] : never;
 export declare function entries<GenericObject extends object>(object: GenericObject): SimplifyTopLevel<GetEntries<GenericObject>>;
+export declare namespace entries {
+    var unsafe: <GenericObject extends object>(object: GenericObject) => [string, AnyValue][];
+}

package/dist/object/entries.mjs

@@ -5,5 +5,11 @@ function entries(object) {
     return Object.entries(object)
         .filter(([key]) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));
 }
+/**
+ * @deprecated Not ignore kind key.
+ */
+entries.unsafe = function (object) {
+    return Object.entries(object);
+};
 
 export { entries };

package/dist/object/hasKeys.d.ts

@@ -1,3 +1,3 @@
 import { type RequiredKeys } from "./types/requiredKeys";
-export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(keys: GenericKeys | GenericKeys[]): (partialObject: GenericObject) => partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;
-export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(partialObject: GenericObject, keys: GenericKeys | GenericKeys[]): partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;
+export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(keys: GenericKeys | readonly GenericKeys[]): (partialObject: GenericObject) => partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;
+export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(partialObject: GenericObject, keys: GenericKeys | readonly GenericKeys[]): partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;

package/dist/object/index.cjs

@@ -4,6 +4,7 @@ var entries = require('./entries.cjs');
 var fromEntries = require('./fromEntries.cjs');
 var hasKeys = require('./hasKeys.cjs');
 var keys = require('./keys.cjs');
+var countKeys = require('./countKeys.cjs');
 var values = require('./values.cjs');
 var getProperty = require('./getProperty.cjs');
 var transformProperties = require('./transformProperties.cjs');
@@ -24,6 +25,7 @@ exports.entries = entries.entries;
 exports.fromEntries = fromEntries.fromEntries;
 exports.hasKeys = hasKeys.hasKeys;
 exports.keys = keys.keys;
+exports.countKeys = countKeys.countKeys;
 exports.values = values.values;
 exports.getProperty = getProperty.getProperty;
 exports.transformProperties = transformProperties.transformProperties;

package/dist/object/index.d.ts

@@ -3,6 +3,7 @@ export * from "./entries";
 export * from "./fromEntries";
 export * from "./hasKeys";
 export * from "./keys";
+export * from "./countKeys";
 export * from "./values";
 export * from "./getProperty";
 export * from "./transformProperties";

package/dist/object/index.mjs

@@ -2,6 +2,7 @@ export { entries } from './entries.mjs';
 export { fromEntries } from './fromEntries.mjs';
 export { hasKeys } from './hasKeys.mjs';
 export { keys } from './keys.mjs';
+export { countKeys } from './countKeys.mjs';
 export { values } from './values.mjs';
 export { getProperty } from './getProperty.mjs';
 export { transformProperties } from './transformProperties.mjs';

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

@@ -0,0 +1,6 @@
+import { type IsEqual } from "../../common";
+declare const SymbolForbiddenKey: unique symbol;
+export type ForbiddenKey<GenericObject extends object, GenericKey extends string> = (GenericKey extends keyof GenericObject ? {
+    [SymbolForbiddenKey]: `Key ${GenericKey} is forbidden.`;
+} : never) extends infer InferredResult ? IsEqual<InferredResult, never> extends true ? unknown : InferredResult : never;
+export {};

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

@@ -6,3 +6,4 @@ export * from "./getPropsWithValue";
 export * from "./flatObject";
 export * from "./getPropsWithValueExtends";
 export * from "./unFlatObject";
+export * from "./forbiddenKey";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.3.30",
+  "version": "1.3.32",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"