@ptolemy2002/ts-utils 1.3.0 → 1.3.2

package/README.md

@@ -36,7 +36,7 @@ This type returns a type that is the same as `T` except that the keys in `K` are
 ### ValueCondition<T>
 This type allows the user to specify a condition for matching a subset of type `T`. It can be one of the following:
 - A value of type `T`
-- An object with keys `include` and `exclude` that are both either objects of type `T`, functions that take a value of `T` and return a boolean, or arrays of objects of any of the preceding types or `false`. In addition, there is a `match` key that takes 2 values of type `T` and returns a boolean. Each of these keys is optional.
+- An object with keys `include` and `exclude` that are both either objects of type `T`, functions that take a value of `T` and return a boolean, or arrays of objects of any of the preceding types or `false`. In addition, there is a `match` key that takes 2 values of type `T` and returns a boolean. Each of these keys is optional. The one required key is `_isCondition` which should be set to `true`. This allows this condition object to be distinguished from a regular object of type `T`.
 - An array of objects of type `T | ValueCondition<T> | false`.
 - A function that takes a value of type `T` and returns a boolean.
 

package/dist/index.d.ts

@@ -9,10 +9,12 @@ export type KeysMatching<T, V> = {
     [K in keyof T]-?: T[K] extends V ? K : never;
 }[keyof T];
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-export type ValueCondition<T> = Partial<{
+export type ValueCondition<T> = ({
+    _isCondition: true;
+} & Partial<{
     include: T | ((v: T) => boolean) | (T | ((v: T) => boolean) | false)[];
     exclude: T | ((v: T) => boolean) | (T | ((v: T) => boolean) | false)[];
     match: (a: T, b: T) => boolean;
-}> | T | ((v: T) => boolean) | (ValueCondition<T> | false)[];
+}>) | T | ((v: T) => boolean) | (ValueCondition<T> | false)[];
 export type OptionalValueCondition<T> = ValueCondition<T> | null;
 export declare function valueConditionMatches<T>(value: T, condition: OptionalValueCondition<T>): boolean;

package/dist/index.js

@@ -5,12 +5,13 @@ const isCallable = require("is-callable");
 function valueConditionMatches(value, condition) {
     if (condition === null)
         return true;
-    if (Object.is(value, condition))
-        return true;
     if (Array.isArray(condition))
         return condition.some(c => c !== false && valueConditionMatches(value, c));
     if (isCallable(condition))
         return condition(value);
+    // If the condition value here is not a condition object, it must be of type T, so we can directly compare it
+    if (condition._isCondition !== true)
+        return Object.is(value, condition);
     let { include = [], exclude = [], match = Object.is } = condition;
     if (!Array.isArray(include))
         include = [include];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/ts-utils",
-    "version": "1.3.0",
+    "version": "1.3.2",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",