@duplojs/utils 0.3.0 → 1.0.0

package/dist/object/fromEntries.cjs

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

package/dist/object/fromEntries.d.ts

@@ -0,0 +1,6 @@
+import { type ObjectEntry, type ObjectKey, type AnyValue, type SimplifyTopLevel } from "../common";
+type ComputeEntries<GenericEntry extends ObjectEntry> = SimplifyTopLevel<{
+    [Entry in GenericEntry as Entry[0]]?: Entry[1];
+}>;
+export declare function fromEntries<GenericKey extends ObjectKey, GenericValue extends AnyValue, GenericEntry extends [GenericKey, GenericValue]>(entries: GenericEntry[]): ComputeEntries<GenericEntry>;
+export {};

package/dist/object/fromEntries.mjs

@@ -0,0 +1,5 @@
+function fromEntries(entries) {
+    return Object.fromEntries(entries);
+}
+
+export { fromEntries };

package/dist/object/getProperty.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function getProperty(...args) {
+    if (args.length === 1) {
+        const [key] = args;
+        return (obj) => getProperty(obj, key);
+    }
+    const [obj, key] = args;
+    return obj[key];
+}
+
+exports.getProperty = getProperty;

package/dist/object/getProperty.d.ts

@@ -0,0 +1,8 @@
+import { type PartialKeys } from "./types";
+import { type UnionObjectToIntersection } from "./types/UnionObjectToIntersection";
+type MergeTopLevelUnionObject<GenericObject extends object, GenericFullObjectKeys extends keyof UnionObjectToIntersection<GenericObject> = keyof UnionObjectToIntersection<GenericObject>> = PartialKeys<{
+    [Prop in GenericFullObjectKeys]: (GenericObject extends object ? Prop extends keyof GenericObject ? GenericObject[Prop] : never : never);
+}, Exclude<GenericFullObjectKeys, keyof GenericObject>>;
+export declare function getProperty<GenericObject extends object, GenericFullObject extends MergeTopLevelUnionObject<GenericObject>, GenericKey extends keyof GenericFullObject>(key: GenericKey): (obj: GenericObject) => GenericFullObject[GenericKey];
+export declare function getProperty<GenericObject extends object, GenericFullObject extends MergeTopLevelUnionObject<GenericObject>, GenericKey extends keyof GenericFullObject>(obj: GenericObject, key: GenericKey): GenericFullObject[GenericKey];
+export {};

package/dist/object/getProperty.mjs

@@ -0,0 +1,10 @@
+function getProperty(...args) {
+    if (args.length === 1) {
+        const [key] = args;
+        return (obj) => getProperty(obj, key);
+    }
+    const [obj, key] = args;
+    return obj[key];
+}
+
+export { getProperty };

package/dist/object/hasKeys.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function hasKeys(...args) {
+    if (args.length === 1) {
+        const [keys] = args;
+        return (partialObject) => hasKeys(partialObject, keys);
+    }
+    const [partialObject, keys] = args;
+    const formattedKey = keys instanceof Array ? keys : [keys];
+    for (const key of formattedKey) {
+        if (partialObject[key] === undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.hasKeys = hasKeys;

package/dist/object/hasKeys.d.ts

@@ -0,0 +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>>;

package/dist/object/hasKeys.mjs

@@ -0,0 +1,16 @@
+function hasKeys(...args) {
+    if (args.length === 1) {
+        const [keys] = args;
+        return (partialObject) => hasKeys(partialObject, keys);
+    }
+    const [partialObject, keys] = args;
+    const formattedKey = keys instanceof Array ? keys : [keys];
+    for (const key of formattedKey) {
+        if (partialObject[key] === undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { hasKeys };

package/dist/object/index.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var entries = require('./entries.cjs');
+var fromEntries = require('./fromEntries.cjs');
+var hasKeys = require('./hasKeys.cjs');
+var keys = require('./keys.cjs');
+var values = require('./values.cjs');
+var getProperty = require('./getProperty.cjs');
+var transformProperties = require('./transformProperties.cjs');
+var transformProperty = require('./transformProperty.cjs');
+var to = require('./to.cjs');
+var assign = require('./assign.cjs');
+var override = require('./override.cjs');
+var omit = require('./omit.cjs');
+var pick = require('./pick.cjs');
+
+
+
+exports.entries = entries.entries;
+exports.fromEntries = fromEntries.fromEntries;
+exports.hasKeys = hasKeys.hasKeys;
+exports.keys = keys.keys;
+exports.values = values.values;
+exports.getProperty = getProperty.getProperty;
+exports.transformProperties = transformProperties.transformProperties;
+exports.transformProperty = transformProperty.transformProperty;
+exports.to = to.to;
+exports.assign = assign.assign;
+exports.override = override.override;
+exports.omit = omit.omit;
+exports.pick = pick.pick;

package/dist/object/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./types";
+export * from "./entries";
+export * from "./fromEntries";
+export * from "./hasKeys";
+export * from "./keys";
+export * from "./values";
+export * from "./getProperty";
+export * from "./transformProperties";
+export * from "./transformProperty";
+export * from "./to";
+export * from "./assign";
+export * from "./override";
+export * from "./omit";
+export * from "./pick";

package/dist/object/index.mjs

@@ -0,0 +1,13 @@
+export { entries } from './entries.mjs';
+export { fromEntries } from './fromEntries.mjs';
+export { hasKeys } from './hasKeys.mjs';
+export { keys } from './keys.mjs';
+export { values } from './values.mjs';
+export { getProperty } from './getProperty.mjs';
+export { transformProperties } from './transformProperties.mjs';
+export { transformProperty } from './transformProperty.mjs';
+export { to } from './to.mjs';
+export { assign } from './assign.mjs';
+export { override } from './override.mjs';
+export { omit } from './omit.mjs';
+export { pick } from './pick.mjs';

package/dist/object/keys.cjs

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

package/dist/object/keys.d.ts

@@ -0,0 +1 @@
+export declare function keys<GenericObject extends object>(object: GenericObject): (keyof GenericObject)[];

package/dist/object/keys.mjs

@@ -0,0 +1,5 @@
+function keys(object) {
+    return Object.keys(object);
+}
+
+export { keys };

package/dist/object/omit.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function omit(...args) {
+    if (args.length === 1) {
+        const [omitValue] = args;
+        return (input) => omit(input, omitValue);
+    }
+    const [input, omitValue] = args;
+    const formattedOmitValue = omitValue instanceof Array
+        ? omitValue.reduce((acc, value) => {
+            acc[value] = true;
+            return acc;
+        }, {})
+        : omitValue;
+    return Object.entries(input)
+        .reduce((acc, [key, value]) => {
+        if (formattedOmitValue[key] !== true) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+
+exports.omit = omit;

package/dist/object/omit.d.ts

@@ -0,0 +1,8 @@
+import { type ObjectKey, type SimplifyTopLevel } from "../common";
+import { type Adaptor } from "../common/types/adaptor";
+import { type GetPropsWithValue } from "./types/getPropsWithValue";
+import { type PartialKeys } from "./types";
+type ComputeResultWithOmitIsObject<GenericInput extends object, GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>>> = SimplifyTopLevel<Omit<GenericInput, GetPropsWithValue<GenericOmitValue, true>> extends infer InferredValue extends object ? PartialKeys<InferredValue, Adaptor<GetPropsWithValue<GenericOmitValue, boolean> | GetPropsWithValue<GenericOmitValue, boolean | undefined> | GetPropsWithValue<GenericOmitValue, true | undefined>, keyof InferredValue>> : never>;
+export declare function omit<GenericInput extends object, GenericValue extends boolean, GenericOmitValue extends Partial<Record<keyof GenericInput, GenericValue>> | readonly (keyof GenericInput)[]>(omitValue: GenericOmitValue): (input: GenericInput) => GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithOmitIsObject<GenericInput, GenericOmitValue> : SimplifyTopLevel<Omit<GenericInput, Adaptor<GenericOmitValue, ObjectKey[]>[number]>>;
+export declare function omit<GenericInput extends object, GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[]>(input: GenericInput, omitValue: GenericOmitValue): GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithOmitIsObject<GenericInput, GenericOmitValue> : SimplifyTopLevel<Omit<GenericInput, Adaptor<GenericOmitValue, ObjectKey[]>[number]>>;
+export {};

package/dist/object/omit.mjs

@@ -0,0 +1,22 @@
+function omit(...args) {
+    if (args.length === 1) {
+        const [omitValue] = args;
+        return (input) => omit(input, omitValue);
+    }
+    const [input, omitValue] = args;
+    const formattedOmitValue = omitValue instanceof Array
+        ? omitValue.reduce((acc, value) => {
+            acc[value] = true;
+            return acc;
+        }, {})
+        : omitValue;
+    return Object.entries(input)
+        .reduce((acc, [key, value]) => {
+        if (formattedOmitValue[key] !== true) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+
+export { omit };

package/dist/object/override.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function override(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => override(input, value);
+    }
+    const [input, value] = args;
+    return Object.entries(value)
+        .reduce((acc, [key, value]) => {
+        if (value !== undefined) {
+            acc[key] = value;
+        }
+        return acc;
+    }, { ...input });
+}
+
+exports.override = override;

package/dist/object/override.d.ts

@@ -0,0 +1,2 @@
+export declare function override<GenericInput extends object>(value: Partial<NoInfer<GenericInput>>): (input: GenericInput) => GenericInput;
+export declare function override<GenericInput extends object>(input: GenericInput, value: Partial<NoInfer<GenericInput>>): GenericInput;

package/dist/object/override.mjs

@@ -0,0 +1,16 @@
+function override(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => override(input, value);
+    }
+    const [input, value] = args;
+    return Object.entries(value)
+        .reduce((acc, [key, value]) => {
+        if (value !== undefined) {
+            acc[key] = value;
+        }
+        return acc;
+    }, { ...input });
+}
+
+export { override };

package/dist/object/pick.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function pick(...args) {
+    if (args.length === 1) {
+        const [pickValue] = args;
+        return (input) => pick(input, pickValue);
+    }
+    const [input, pickValue] = args;
+    const formattedPickValue = pickValue instanceof Array
+        ? pickValue.reduce((acc, value) => {
+            acc[value] = true;
+            return acc;
+        }, {})
+        : pickValue;
+    return Object.entries(input)
+        .reduce((acc, [key, value]) => {
+        if (formattedPickValue[key] === true) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+
+exports.pick = pick;

package/dist/object/pick.d.ts

@@ -0,0 +1,7 @@
+import { type ObjectKey, type SimplifyTopLevel } from "../common";
+import { type Adaptor } from "../common/types/adaptor";
+import { type GetPropsWithValue } from "./types/getPropsWithValue";
+type ComputeResultWithPickIsObject<GenericInput extends object, GenericPickValue extends Partial<Record<keyof GenericInput, boolean>>> = SimplifyTopLevel<Pick<GenericInput, Adaptor<GetPropsWithValue<GenericPickValue, true>, keyof GenericInput>> & Partial<Pick<GenericInput, Adaptor<GetPropsWithValue<GenericPickValue, boolean> | GetPropsWithValue<GenericPickValue, boolean | undefined> | GetPropsWithValue<GenericPickValue, true | undefined>, keyof GenericInput>>>>;
+export declare function pick<GenericInput extends object, GenericValue extends boolean, GenericPickValue extends Partial<Record<keyof GenericInput, GenericValue>> | readonly (keyof GenericInput)[]>(pickValue: GenericPickValue): (input: GenericInput) => GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithPickIsObject<GenericInput, GenericPickValue> : SimplifyTopLevel<Pick<GenericInput, Adaptor<GenericPickValue, ObjectKey[]>[number]>>;
+export declare function pick<GenericInput extends object, GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[]>(input: GenericInput, pickValue: GenericPickValue): GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithPickIsObject<GenericInput, GenericPickValue> : SimplifyTopLevel<Pick<GenericInput, Adaptor<GenericPickValue, ObjectKey[]>[number]>>;
+export {};

package/dist/object/pick.mjs

@@ -0,0 +1,22 @@
+function pick(...args) {
+    if (args.length === 1) {
+        const [pickValue] = args;
+        return (input) => pick(input, pickValue);
+    }
+    const [input, pickValue] = args;
+    const formattedPickValue = pickValue instanceof Array
+        ? pickValue.reduce((acc, value) => {
+            acc[value] = true;
+            return acc;
+        }, {})
+        : pickValue;
+    return Object.entries(input)
+        .reduce((acc, [key, value]) => {
+        if (formattedPickValue[key] === true) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+
+export { pick };

package/dist/object/to.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function to(...args) {
+    if (args.length === 1) {
+        const [shape] = args;
+        return (input) => to(input, shape);
+    }
+    const [input, shapeObject] = args;
+    return Object.entries(shapeObject)
+        .reduce((acc, [key, theFunction]) => {
+        acc[key] = theFunction?.(input);
+        return acc;
+    }, {});
+}
+
+exports.to = to;

package/dist/object/to.d.ts

@@ -0,0 +1,10 @@
+import { type FixDeepFunctionInfer, type AnyFunction, type SimplifyTopLevel, type Adaptor } from "../common";
+type ShapeObject<GenericInput extends unknown = unknown> = {
+    [Prop in string]?: (input: GenericInput) => unknown;
+};
+type ComputesResult<GenericShapeObject extends ShapeObject<any>> = SimplifyTopLevel<{
+    [Prop in keyof GenericShapeObject]: (ReturnType<Adaptor<GenericShapeObject[Prop], AnyFunction>> | (undefined extends GenericShapeObject[Prop] ? undefined : never));
+}>;
+export declare function to<GenericInput extends unknown, GenericShapeObject extends ShapeObject<NoInfer<GenericInput>>>(shapeObject: ShapeObject<NoInfer<GenericInput>> & GenericShapeObject): (input: GenericInput) => ComputesResult<NoInfer<GenericShapeObject>>;
+export declare function to<GenericInput extends unknown, GenericShapeObject extends ShapeObject<GenericInput>>(input: GenericInput, shapeObject: FixDeepFunctionInfer<ShapeObject<GenericInput>, GenericShapeObject>): ComputesResult<GenericShapeObject>;
+export {};

package/dist/object/to.mjs

@@ -0,0 +1,14 @@
+function to(...args) {
+    if (args.length === 1) {
+        const [shape] = args;
+        return (input) => to(input, shape);
+    }
+    const [input, shapeObject] = args;
+    return Object.entries(shapeObject)
+        .reduce((acc, [key, theFunction]) => {
+        acc[key] = theFunction?.(input);
+        return acc;
+    }, {});
+}
+
+export { to };

package/dist/object/transformProperties.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function transformProperties(...args) {
+    if (args.length === 1) {
+        const [transformers] = args;
+        return (obj) => transformProperties(obj, transformers);
+    }
+    const [obj, transformObject] = args;
+    return Object.entries(transformObject)
+        .reduce((acc, [key, theFunction]) => {
+        if (theFunction) {
+            acc[key] = theFunction(acc[key]);
+        }
+        return acc;
+    }, { ...obj });
+}
+
+exports.transformProperties = transformProperties;

package/dist/object/transformProperties.d.ts

@@ -0,0 +1,10 @@
+import { type Adaptor, type FixDeepFunctionInfer, type AnyFunction, type SimplifyTopLevel } from "../common";
+type TransformObject<GenericObjectInput extends object = object> = {
+    [Prop in keyof GenericObjectInput]?: (input: GenericObjectInput[Prop]) => unknown;
+};
+type ComputesResult<GenericObjectInput extends object, GenericTransformObject extends TransformObject<GenericObjectInput>> = SimplifyTopLevel<Omit<GenericObjectInput, keyof GenericTransformObject> & {
+    [Prop in keyof GenericTransformObject]: (ReturnType<Adaptor<GenericTransformObject[Prop], AnyFunction>> | (undefined extends GenericTransformObject[Prop] ? GenericObjectInput[Adaptor<Prop, keyof GenericObjectInput>] : never));
+}>;
+export declare function transformProperties<GenericObjectInput extends object, GenericTransformObject extends TransformObject<NoInfer<GenericObjectInput>>>(transformObject: TransformObject<NoInfer<GenericObjectInput>> & GenericTransformObject): (obj: GenericObjectInput) => ComputesResult<NoInfer<GenericObjectInput>, NoInfer<GenericTransformObject>>;
+export declare function transformProperties<GenericObjectInput extends object, GenericTransformObject extends TransformObject<GenericObjectInput>>(obj: GenericObjectInput, transformObject: FixDeepFunctionInfer<TransformObject<GenericObjectInput>, GenericTransformObject>): ComputesResult<GenericObjectInput, GenericTransformObject>;
+export {};

package/dist/object/transformProperties.mjs

@@ -0,0 +1,16 @@
+function transformProperties(...args) {
+    if (args.length === 1) {
+        const [transformers] = args;
+        return (obj) => transformProperties(obj, transformers);
+    }
+    const [obj, transformObject] = args;
+    return Object.entries(transformObject)
+        .reduce((acc, [key, theFunction]) => {
+        if (theFunction) {
+            acc[key] = theFunction(acc[key]);
+        }
+        return acc;
+    }, { ...obj });
+}
+
+export { transformProperties };

package/dist/object/transformProperty.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function transformProperty(...args) {
+    if (args.length === 2) {
+        const [key, transform] = args;
+        return (obj) => transformProperty(obj, key, transform);
+    }
+    const [obj, key, transform] = args;
+    return {
+        ...obj,
+        [key]: transform(obj[key]),
+    };
+}
+
+exports.transformProperty = transformProperty;

package/dist/object/transformProperty.d.ts

@@ -0,0 +1,7 @@
+import { type SimplifyTopLevel } from "../common";
+export declare function transformProperty<GenericObject extends object, GenericKey extends keyof GenericObject, GenericNewValue extends unknown>(key: GenericKey, transform: (value: GenericObject[GenericKey]) => GenericNewValue): (obj: GenericObject) => SimplifyTopLevel<{
+    [Prop in GenericKey]: GenericNewValue;
+} & Omit<GenericObject, GenericKey>>;
+export declare function transformProperty<GenericObject extends object, GenericKey extends keyof GenericObject, GenericNewValue extends unknown>(obj: GenericObject, key: GenericKey, transform: (value: GenericObject[GenericKey]) => GenericNewValue): SimplifyTopLevel<{
+    [Prop in GenericKey]: GenericNewValue;
+} & Omit<GenericObject, GenericKey>>;

package/dist/object/transformProperty.mjs

@@ -0,0 +1,13 @@
+function transformProperty(...args) {
+    if (args.length === 2) {
+        const [key, transform] = args;
+        return (obj) => transformProperty(obj, key, transform);
+    }
+    const [obj, key, transform] = args;
+    return {
+        ...obj,
+        [key]: transform(obj[key]),
+    };
+}
+
+export { transformProperty };

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

@@ -0,0 +1,2 @@
+import { type UnionToIntersection } from "../../common";
+export type UnionObjectToIntersection<GenericValue extends object> = UnionToIntersection<GenericValue> extends infer InferredObject extends object ? InferredObject : never;

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

@@ -0,0 +1,2 @@
+import { type SimplifyTopLevel } from "../../common/types/simplifyTopLevel";
+export type AssignObjects<GenericFirstObject extends object, GenericSecondObject extends object> = SimplifyTopLevel<Omit<GenericFirstObject, keyof GenericSecondObject> & GenericSecondObject>;

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

@@ -0,0 +1,25 @@
+import { type TupleHasSpread } from "../../array";
+import { type AnyTuple, type IsEqual } from "../../common";
+export type FlatObject<GenericObject extends object, GenericPath extends string = ""> = GenericObject extends object ? ((Exclude<GenericObject, readonly any[]> extends infer InferredObject extends object ? IsEqual<InferredObject, never> extends true ? never : {
+    [Prop in Extract<keyof InferredObject, string | number>]: InferredObject[Prop] extends object ? FlatObject<InferredObject[Prop], `${GenericPath}.${Prop}`> : {
+        path: `${GenericPath}.${Prop}`;
+        value: InferredObject[Prop];
+    };
+}[Extract<keyof InferredObject, string | number>] : never) | (GenericObject extends AnyTuple ? TupleHasSpread<GenericObject> extends true ? never : GenericObject extends readonly [
+    ...infer InferredRest,
+    infer InferredLast
+] ? ((InferredLast extends object ? FlatObject<InferredLast, `${GenericPath}.[${InferredRest["length"]}]`> : {
+    path: `${GenericPath}.[${InferredRest["length"]}]`;
+    value: InferredLast;
+}) | (IsEqual<InferredRest, []> extends true ? never : FlatObject<InferredRest, GenericPath>)) : never : never) | (GenericObject extends AnyTuple ? TupleHasSpread<GenericObject> extends true ? GenericObject[number] extends infer InferredValue ? InferredValue extends object ? FlatObject<InferredValue, `${GenericPath}.[number]`> : {
+    path: `${GenericPath}.[number]`;
+    value: InferredValue;
+} : never : never : never) | (Exclude<Extract<GenericObject, readonly any[]>, AnyTuple> extends infer InferredArray extends readonly any[] ? IsEqual<InferredArray, never> extends true ? never : InferredArray[number] extends infer InferredValue ? InferredValue extends object ? FlatObject<InferredValue, `${GenericPath}.[number]`> : {
+    path: `${GenericPath}.[number]`;
+    value: InferredValue;
+} : never : never)) extends infer InferredResult extends {
+    path: string;
+    value: any;
+} ? IsEqual<GenericPath, ""> extends true ? IsEqual<InferredResult, never> extends true ? {} : {
+    [Result in InferredResult as Result["path"] extends `.${infer inferredPath}` ? inferredPath : never]: Result["value"];
+} : InferredResult : never : never;

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

@@ -0,0 +1,4 @@
+import { type IsEqual } from "../../common";
+export type GetPropsWithValue<GenericObject extends object, GenericValue extends unknown> = {
+    [Prop in keyof GenericObject]: IsEqual<GenericObject[Prop], GenericValue> extends true ? Prop : never;
+}[keyof GenericObject];

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

@@ -0,0 +1,6 @@
+export * from "./assignObjects";
+export * from "./partialKeys";
+export * from "./requiredKeys";
+export * from "./UnionObjectToIntersection";
+export * from "./getPropsWithValue";
+export * from "./flatObject";

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

@@ -0,0 +1,2 @@
+import { type SimplifyTopLevel } from "../../common";
+export type PartialKeys<T extends object, K extends keyof T = keyof T> = SimplifyTopLevel<Omit<T, K> & Partial<Pick<T, K>>>;

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

@@ -0,0 +1,2 @@
+import { type SimplifyTopLevel } from "../../common/types/simplifyTopLevel";
+export type RequiredKeys<GenericObject extends object, GenericKeys extends keyof GenericObject = keyof GenericObject> = SimplifyTopLevel<Required<Pick<GenericObject, GenericKeys>> & GenericObject>;

package/dist/object/values.cjs

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

package/dist/object/values.d.ts

@@ -0,0 +1,4 @@
+import { type AnyValue } from "../common/types/anyValue";
+export declare function values<GenericValue extends AnyValue>(object: {
+    [key: string]: GenericValue;
+} | ArrayLike<GenericValue>): GenericValue[];

package/dist/object/values.mjs

@@ -0,0 +1,5 @@
+function values(object) {
+    return Object.values(object);
+}
+
+export { values };

package/dist/pattern/exhaustive.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var unwrap = require('../common/unwrap.cjs');
+
+function exhaustive(result) {
+    return unwrap.unwrap(result);
+}
+
+exports.exhaustive = exhaustive;

package/dist/pattern/exhaustive.d.ts

@@ -0,0 +1,3 @@
+import { type Unwrap } from "../common";
+import { type PatternResult } from "./result";
+export declare function exhaustive<const GenericValue extends unknown, GenericResult extends PatternResult<GenericValue>>(result: GenericResult): Unwrap<GenericResult>;

package/dist/pattern/exhaustive.mjs

@@ -0,0 +1,7 @@
+import { unwrap } from '../common/unwrap.mjs';
+
+function exhaustive(result) {
+    return unwrap(result);
+}
+
+export { exhaustive };

package/dist/pattern/index.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var result = require('./result.cjs');
+var exhaustive = require('./exhaustive.cjs');
+var otherwise = require('./otherwise.cjs');
+var matchPrimitive = require('./matchPrimitive.cjs');
+var match = require('./match.cjs');
+var isMatch = require('./isMatch.cjs');
+var pattern = require('./types/pattern.cjs');
+var union = require('./union.cjs');
+
+
+
+exports.isResult = result.isResult;
+exports.result = result.result;
+exports.exhaustive = exhaustive.exhaustive;
+exports.otherwise = otherwise.otherwise;
+exports.matchPrimitive = matchPrimitive.matchPrimitive;
+exports.match = match.match;
+exports.isMatch = isMatch.isMatch;
+exports.SymbolToolPatternFunctionLabel = pattern.SymbolToolPatternFunctionLabel;
+exports.union = union.union;

package/dist/pattern/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./result";
+export * from "./exhaustive";
+export * from "./otherwise";
+export * from "./matchPrimitive";
+export * from "./match";
+export * from "./isMatch";
+export * from "./types";
+export * from "./union";

package/dist/pattern/index.mjs

@@ -0,0 +1,8 @@
+export { isResult, result } from './result.mjs';
+export { exhaustive } from './exhaustive.mjs';
+export { otherwise } from './otherwise.mjs';
+export { matchPrimitive } from './matchPrimitive.mjs';
+export { match } from './match.mjs';
+export { isMatch } from './isMatch.mjs';
+export { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
+export { union } from './union.mjs';