@duplojs/utils 0.3.1 → 1.0.1

package/dist/number/negate.cjs

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

package/dist/number/negate.d.ts

@@ -0,0 +1 @@
+export declare function negate<GenericValue extends number>(value: GenericValue): number;

package/dist/number/negate.mjs

@@ -0,0 +1,5 @@
+function negate(value) {
+    return -value;
+}
+
+export { negate };

package/dist/number/power.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function power(...args) {
+    if (args.length === 1) {
+        const [exponent] = args;
+        return (value) => power(value, exponent);
+    }
+    const [value, exponent] = args;
+    return value ** exponent;
+}
+
+exports.power = power;

package/dist/number/power.d.ts

@@ -0,0 +1,2 @@
+export declare function power<GenericValue extends number>(exponent: number): (value: GenericValue) => number;
+export declare function power<GenericValue extends number>(value: GenericValue, exponent: number): number;

package/dist/number/power.mjs

@@ -0,0 +1,10 @@
+function power(...args) {
+    if (args.length === 1) {
+        const [exponent] = args;
+        return (value) => power(value, exponent);
+    }
+    const [value, exponent] = args;
+    return value ** exponent;
+}
+
+export { power };

package/dist/number/round.cjs

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

package/dist/number/round.d.ts

@@ -0,0 +1 @@
+export declare function round<GenericValue extends number>(value: GenericValue): number;

package/dist/number/round.mjs

@@ -0,0 +1,5 @@
+function round(value) {
+    return Math.round(value);
+}
+
+export { round };

package/dist/number/sin.cjs

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

package/dist/number/sin.d.ts

@@ -0,0 +1 @@
+export declare function sin<GenericValue extends number>(value: GenericValue): number;

package/dist/number/sin.mjs

@@ -0,0 +1,5 @@
+function sin(value) {
+    return Math.sin(value);
+}
+
+export { sin };

package/dist/number/subtract.cjs

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

package/dist/number/subtract.d.ts

@@ -0,0 +1,2 @@
+export declare function subtract<GenericValue extends number>(subtrahend: number): (value: GenericValue) => number;
+export declare function subtract<GenericValue extends number>(value: GenericValue, subtrahend: number): number;

package/dist/number/subtract.mjs

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

package/dist/number/tan.cjs

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

package/dist/number/tan.d.ts

@@ -0,0 +1 @@
+export declare function tan<GenericValue extends number>(value: GenericValue): number;

package/dist/number/tan.mjs

@@ -0,0 +1,5 @@
+function tan(value) {
+    return Math.tan(value);
+}
+
+export { tan };

package/dist/number/trunc.cjs

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

package/dist/number/trunc.d.ts

@@ -0,0 +1 @@
+export declare function trunc<GenericValue extends number>(value: GenericValue): number;

package/dist/number/trunc.mjs

@@ -0,0 +1,5 @@
+function trunc(value) {
+    return Math.trunc(value);
+}
+
+export { trunc };

package/dist/object/assign.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function assign(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => assign(input, value);
+    }
+    const [input, value] = args;
+    return {
+        ...input,
+        ...value,
+    };
+}
+
+exports.assign = assign;

package/dist/object/assign.d.ts

@@ -0,0 +1,4 @@
+import { type AnyObject } from "../common/types/anyObject";
+import { type AssignObjects } from "./types";
+export declare function assign<GenericInput extends object, GenericValue extends Partial<Record<keyof GenericInput, unknown>> & AnyObject>(value: GenericValue): (input: GenericInput) => AssignObjects<GenericInput, GenericValue>;
+export declare function assign<GenericInput extends object, GenericValue extends Partial<Record<keyof GenericInput, unknown>> & AnyObject>(input: GenericInput, value: GenericValue): AssignObjects<GenericInput, GenericValue>;

package/dist/object/assign.mjs

@@ -0,0 +1,13 @@
+function assign(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => assign(input, value);
+    }
+    const [input, value] = args;
+    return {
+        ...input,
+        ...value,
+    };
+}
+
+export { assign };

package/dist/object/entries.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var wrapValue = require('../common/wrapValue.cjs');
+
+function entries(object) {
+    return Object.entries(object)
+        .filter(([key]) => !key.startsWith(wrapValue.keyWrappedValue));
+}
+
+exports.entries = entries;

package/dist/object/entries.d.ts

@@ -0,0 +1,7 @@
+import { 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> = ({
+    [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>>;

package/dist/object/entries.mjs

@@ -0,0 +1,8 @@
+import { keyWrappedValue } from '../common/wrapValue.mjs';
+
+function entries(object) {
+    return Object.entries(object)
+        .filter(([key]) => !key.startsWith(keyWrappedValue));
+}
+
+export { entries };

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;