@ptolemy2002/ts-utils 1.1.0 → 1.3.0

package/README.md

@@ -30,8 +30,37 @@ This type returns an object with all the properties of `T` and any number of oth
 ### KeysMatching<T, V>
 This type returns a union of all the keys in `T` that have a value assignable to `V`.
 
+### PartialBy<T, K extends keyof T>
+This type returns a type that is the same as `T` except that the keys in `K` are optional.
+
+### 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 array of objects of type `T | ValueCondition<T> | false`.
+- A function that takes a value of type `T` and returns a boolean.
+
+The condition can then be passed to the `valueConditionMatches` function along with a value of type `T` to determine if the condition is met for that value.
+
+### OptionalValueCondition<T>
+This type is the same as `ValueCondition<T>` except that the value can also be `null`, indicating any value is acceptable.
+
+## Functions
+The following functions are available in the library:
+
+### valueConditionMatches<T>
+#### Description
+This function takes a value of type `T` and a condition of type `OptionalValueCondition<T>` and returns a boolean indicating whether the value meets the condition. If the condition is `null`, the function will always return `true`. Any instance of the value `false` will be filtered out of lists. If `match` is not specified, it will default to `Object.is`. If `include` is not specified or empty, it will be ignored and `exclude` will act as the only constraint. If `exclude` is not specified, it will be assumed to be empty.
+
+#### Parameters
+- `value` (`T`) - The value to check against the condition.
+- `condition` (`OptionalValueCondition<T>`) - The condition to check against the value.
+
+#### Returns
+- `boolean` - Whether the value meets the condition.
+
 ## Peer Dependencies
-None
+- `is-callable^1.2.7`
 
 ## Commands
 The following commands exist in the project:

package/dist/index.d.ts

@@ -8,3 +8,11 @@ export type TAndOthers<T, K extends keyof any = PropertyKey> = Record<K, any> &
 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<{
+    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)[];
+export type OptionalValueCondition<T> = ValueCondition<T> | null;
+export declare function valueConditionMatches<T>(value: T, condition: OptionalValueCondition<T>): boolean;

package/dist/index.js

@@ -1,2 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueConditionMatches = valueConditionMatches;
+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);
+    let { include = [], exclude = [], match = Object.is } = condition;
+    if (!Array.isArray(include))
+        include = [include];
+    if (!Array.isArray(exclude))
+        exclude = [exclude];
+    const included = (v) => {
+        return include.some(i => i !== false && (isCallable(i) ? i(v) : match(value, i)));
+    };
+    const excluded = (v) => {
+        return exclude.some(e => e !== false && (isCallable(e) ? e(v) : match(value, e)));
+    };
+    // If there are no includes, the last condition will unexpectedly fail, so we add a separate case for this
+    if (include.length === 0)
+        return !excluded(value);
+    return included(value) && !excluded(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/ts-utils",
-    "version": "1.1.0",
+    "version": "1.3.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -26,5 +26,11 @@
         "release-minor": "bash ./scripts/release.sh minor",
         "release-major": "bash ./scripts/release.sh major"
     },
-    "devDependencies": {}
+    "peerDependencies": {
+        "is-callable": "^1.2.7"
+    },
+    "devDependencies": {
+        "@types/is-callable": "~1.1.2",
+        "is-callable": "^1.2.7"
+    }
 }