@duplojs/utils 1.0.4 → 1.0.5

package/dist/object/deepDiscriminate.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var equal = require('../common/equal.cjs');
+var getDeepProperty = require('./getDeepProperty.cjs');
+
+function deepDiscriminate(...args) {
+    if (args.length === 2) {
+        const [path, value] = args;
+        return (input) => deepDiscriminate(input, path, value);
+    }
+    const [input, path, value] = args;
+    return equal.equal(getDeepProperty.getDeepProperty(input, path), value);
+}
+
+exports.deepDiscriminate = deepDiscriminate;

package/dist/object/deepDiscriminate.d.ts

@@ -0,0 +1,11 @@
+import { type EligibleEqual, type MaybeArray } from "../common";
+import { type UnFlatObject, type FlatObject } from "./types";
+import { type GetPropsWithValueExtends } from "./types/getPropsWithValueExtends";
+type ObjectProjection<GenericInput extends object> = FlatObject<GenericInput> extends infer InferredResult extends object ? Omit<Pick<InferredResult, GetPropsWithValueExtends<InferredResult, EligibleEqual>>, `${string}[${string}]${string}`> : never;
+export declare function deepDiscriminate<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection, GenericValue extends EligibleEqual>(path: GenericPath, value: (MaybeArray<(GenericValue & GenericObjectProjection[GenericPath])> | MaybeArray<GenericObjectProjection[GenericPath]>)): (input: GenericInput) => input is Extract<GenericInput, UnFlatObject<{
+    [Prop in GenericPath]: GenericValue;
+}>>;
+export declare function deepDiscriminate<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection, GenericValue extends EligibleEqual>(input: GenericInput, path: GenericPath, value: (MaybeArray<(GenericValue & GenericObjectProjection[GenericPath])> | MaybeArray<GenericObjectProjection[GenericPath]>)): input is Extract<GenericInput, UnFlatObject<{
+    [Prop in GenericPath]: GenericValue;
+}>>;
+export {};

package/dist/object/deepDiscriminate.mjs

@@ -0,0 +1,13 @@
+import { equal } from '../common/equal.mjs';
+import { getDeepProperty } from './getDeepProperty.mjs';
+
+function deepDiscriminate(...args) {
+    if (args.length === 2) {
+        const [path, value] = args;
+        return (input) => deepDiscriminate(input, path, value);
+    }
+    const [input, path, value] = args;
+    return equal(getDeepProperty(input, path), value);
+}
+
+export { deepDiscriminate };

package/dist/object/discriminate.cjs

@@ -1,15 +1,14 @@
 'use strict';
 
 var equal = require('../common/equal.cjs');
-var getDeepProperty = require('./getDeepProperty.cjs');
 
 function discriminate(...args) {
     if (args.length === 2) {
-        const [path, value] = args;
-        return (input) => discriminate(input, path, value);
+        const [key, value] = args;
+        return (input) => discriminate(input, key, value);
     }
-    const [input, path, value] = args;
-    return equal.equal(getDeepProperty.getDeepProperty(input, path), value);
+    const [input, key, value] = args;
+    return equal.equal(input[key], value);
 }
 
 exports.discriminate = discriminate;

package/dist/object/discriminate.d.ts

@@ -1,11 +1,8 @@
 import { type EligibleEqual, type MaybeArray } from "../common";
-import { type UnFlatObject, type FlatObject } from "./types";
 import { type GetPropsWithValueExtends } from "./types/getPropsWithValueExtends";
-type ObjectProjection<GenericInput extends object> = FlatObject<GenericInput> extends infer InferredResult extends object ? Omit<Pick<InferredResult, GetPropsWithValueExtends<InferredResult, EligibleEqual>>, `${string}[${string}]${string}`> : never;
-export declare function discriminate<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection, GenericValue extends EligibleEqual>(path: GenericPath, value: (MaybeArray<(GenericValue & GenericObjectProjection[GenericPath])> | MaybeArray<GenericObjectProjection[GenericPath]>)): (input: GenericInput) => input is Extract<GenericInput, UnFlatObject<{
-    [Prop in GenericPath]: GenericValue;
-}>>;
-export declare function discriminate<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection, GenericValue extends EligibleEqual>(input: GenericInput, path: GenericPath, value: (MaybeArray<(GenericValue & GenericObjectProjection[GenericPath])> | MaybeArray<GenericObjectProjection[GenericPath]>)): input is Extract<GenericInput, UnFlatObject<{
-    [Prop in GenericPath]: GenericValue;
-}>>;
-export {};
+export declare function discriminate<GenericInput extends object, GenericKey extends GetPropsWithValueExtends<GenericInput, EligibleEqual>, GenericValue extends EligibleEqual>(key: GenericKey, value: (MaybeArray<(GenericValue & GenericInput[GenericKey])> | MaybeArray<GenericInput[GenericKey]>)): (input: GenericInput) => input is Extract<GenericInput, {
+    [Prop in GenericKey]: GenericValue;
+}>;
+export declare function discriminate<GenericInput extends object, GenericKey extends GetPropsWithValueExtends<GenericInput, EligibleEqual>, GenericValue extends EligibleEqual>(input: GenericInput, key: GenericKey, value: (MaybeArray<(GenericValue & GenericInput[GenericKey])> | MaybeArray<GenericInput[GenericKey]>)): input is Extract<GenericInput, {
+    [Prop in GenericKey]: GenericValue;
+}>;

package/dist/object/discriminate.mjs

@@ -1,13 +1,12 @@
 import { equal } from '../common/equal.mjs';
-import { getDeepProperty } from './getDeepProperty.mjs';
 
 function discriminate(...args) {
     if (args.length === 2) {
-        const [path, value] = args;
-        return (input) => discriminate(input, path, value);
+        const [key, value] = args;
+        return (input) => discriminate(input, key, value);
     }
-    const [input, path, value] = args;
-    return equal(getDeepProperty(input, path), value);
+    const [input, key, value] = args;
+    return equal(input[key], value);
 }
 
 export { discriminate };

package/dist/object/index.cjs

@@ -13,8 +13,9 @@ var assign = require('./assign.cjs');
 var override = require('./override.cjs');
 var omit = require('./omit.cjs');
 var pick = require('./pick.cjs');
-var discriminate = require('./discriminate.cjs');
+var deepDiscriminate = require('./deepDiscriminate.cjs');
 var getDeepProperty = require('./getDeepProperty.cjs');
+var discriminate = require('./discriminate.cjs');
 
 
 
@@ -31,5 +32,6 @@ exports.assign = assign.assign;
 exports.override = override.override;
 exports.omit = omit.omit;
 exports.pick = pick.pick;
-exports.discriminate = discriminate.discriminate;
+exports.deepDiscriminate = deepDiscriminate.deepDiscriminate;
 exports.getDeepProperty = getDeepProperty.getDeepProperty;
+exports.discriminate = discriminate.discriminate;

package/dist/object/index.d.ts

@@ -12,5 +12,6 @@ export * from "./assign";
 export * from "./override";
 export * from "./omit";
 export * from "./pick";
-export * from "./discriminate";
+export * from "./deepDiscriminate";
 export * from "./getDeepProperty";
+export * from "./discriminate";

package/dist/object/index.mjs

@@ -11,5 +11,6 @@ export { assign } from './assign.mjs';
 export { override } from './override.mjs';
 export { omit } from './omit.mjs';
 export { pick } from './pick.mjs';
-export { discriminate } from './discriminate.mjs';
+export { deepDiscriminate } from './deepDiscriminate.mjs';
 export { getDeepProperty } from './getDeepProperty.mjs';
+export { discriminate } from './discriminate.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",