@ptolemy2002/ts-utils 3.1.0 → 3.2.1

package/README.md

@@ -90,6 +90,16 @@ This type is the same as `AdvancedCondition<T>` except that the `include` and `e
 
 This is assignable to any field that accepts an `AdvancedCondition<T>`.
 
+### ValueConditionType
+This type is a union of string literals representing the possible types a `ValueCondition<T>` can be. It may also be a list of those same string literals plus `"false"`, representing the types of each element in an array condition. This array may be nested to any depth. To be precise, it is defined as follows:
+
+```typescript
+type ValueConditionType = "advanced" | "function" | "value" | (ValueConditionType | "false")[];
+```
+
+### SerializableValueConditionType
+This type is the same as `ValueConditionType` except that the `"function"` type is omitted, since functions are not allowed in `SerializableValueCondition<T>`.
+
 ### ValuesIntersection<T>
 This type returns an intersection of all the possible values in an object of type `T`.
 
@@ -142,6 +152,30 @@ This function takes a value of type `T` and a condition of type `OptionalValueCo
 #### Returns
 `boolean` - Whether the value meets the condition.
 
+### valueConditionType<T>
+#### Description
+This function takes a condition of type `ValueCondition<T>` and returns a string indicating the type of condition it is. The possible return values are:
+- `"advanced"` - The condition is an instance of `AdvancedCondition<T>`.
+- `"function"` - The condition is a function that takes a value of type `T` and (presumably) returns a boolean. The return type is not checked, due to potential side effects of calling the function.
+- `"value"` - The condition is a value of type `T`.
+- `(ValueConditionType | "false")[]` - The condition is an array of conditions, and the return value is an array of the types of each condition in the array.
+
+#### Parameters
+- `condition` (`ValueCondition<T>`) - The condition to check.
+
+#### Returns
+`ValueConditionType` - The type of the condition.
+
+### serializeValueConditionType<T>
+#### Description
+The same as `valueConditionType`, except that it specifically takes a `SerializableValueCondition<T>` and returns a `SerializableValueConditionType`. The difference is that function conditions are not serializable, so they are not included in the return type and cannot be specified in the argument.
+
+#### Parameters
+- `condition` (`SerializableValueCondition<T>`) - The condition to check.
+
+#### Returns
+`SerializableValueConditionType` - The type of the condition.
+
 ### omit<T, K extends keyof T>
 #### Description
 This function takes an object of type `T` and a list of keys `K` and returns a new object with all the keys in `K` removed.

package/dist/index.d.ts

@@ -28,14 +28,15 @@ export type Override<T, U> = Omit<T, keyof U> & U;
 export declare const advancedConditionSymbol: unique symbol;
 export type AdvancedCondition<T> = Branded<{
     __isAdvancedCondition: true;
-    include?: T | false | ((v: T) => boolean) | (T | false | ((v: T) => boolean) | false)[];
-    exclude?: T | false | ((v: T) => boolean) | (T | false | ((v: T) => boolean | false))[];
+    include?: T | false | ((v: T) => boolean) | (T | false | ((v: T) => boolean))[];
+    exclude?: T | false | ((v: T) => boolean) | (T | false | ((v: T) => boolean))[];
     match?: (a: T, b: T) => boolean;
 }, [typeof advancedConditionSymbol]>;
-export type SerializableAdvancedCondition<T> = Override<Omit<AdvancedCondition<T>, "match">, {
-    include?: Exclude<AdvancedCondition<T>["include"], () => any>;
-    exclude?: Exclude<AdvancedCondition<T>["exclude"], () => any>;
-}>;
+export type SerializableAdvancedCondition<T> = Branded<{
+    __isAdvancedCondition: true;
+    include?: T | false | (T | false)[];
+    exclude?: T | false | (T | false)[];
+}, [typeof advancedConditionSymbol]>;
 export declare function isAdvancedCondition(value: any): value is AdvancedCondition<any>;
 export declare function createAdvancedCondition<T>(condition: WithoutBrand<Omit<AdvancedCondition<T>, "__isAdvancedCondition">>): AdvancedCondition<T>;
 export declare function createSerializableAdvancedCondition<T>(condition: WithoutBrand<Omit<SerializableAdvancedCondition<T>, "__isAdvancedCondition">>): SerializableAdvancedCondition<T>;
@@ -44,6 +45,10 @@ export type OptionalValueCondition<T> = ValueCondition<T> | null;
 export type SerializableValueCondition<T> = SerializableAdvancedCondition<T> | T | (SerializableValueCondition<T> | false)[];
 export type OptionalSerializableValueCondition<T> = SerializableValueCondition<T> | null;
 export declare function valueConditionMatches<T>(value: T, condition: OptionalValueCondition<T>): boolean;
+export type ValueConditionType = "advanced" | "function" | "value" | (ValueConditionType | "false")[];
+export type SerializableValueConditionType = "advanced" | "value" | (SerializableValueConditionType | "false")[];
+export declare function valueConditionType<T>(condition: ValueCondition<T>): ValueConditionType;
+export declare function serializableValueConditionType<T>(condition: SerializableValueCondition<T>): SerializableValueConditionType;
 export type Rename<T, K extends keyof T, N extends string> = Pick<T, Exclude<keyof T, K>> & {
     [P in N]: T[K];
 };

package/dist/index.js

@@ -4,6 +4,8 @@ exports.isAdvancedCondition = isAdvancedCondition;
 exports.createAdvancedCondition = createAdvancedCondition;
 exports.createSerializableAdvancedCondition = createSerializableAdvancedCondition;
 exports.valueConditionMatches = valueConditionMatches;
+exports.valueConditionType = valueConditionType;
+exports.serializableValueConditionType = serializableValueConditionType;
 exports.omit = omit;
 const isCallable = require("is-callable");
 const ts_brand_utils_1 = require("@ptolemy2002/ts-brand-utils");
@@ -55,6 +57,24 @@ function valueConditionMatches(value, condition) {
         return !excluded(value);
     return included(value) && !excluded(value);
 }
+function valueConditionType(condition) {
+    // Type assertion here because TS cannot infer that the filter will remove all false values
+    if (Array.isArray(condition))
+        return condition.map(c => c === false ? "false" : valueConditionType(c));
+    if (isAdvancedCondition(condition))
+        return "advanced";
+    if (isCallable(condition))
+        return "function";
+    return "value";
+}
+function serializableValueConditionType(condition) {
+    // Type assertion here because TS cannot infer that the filter will remove all false values
+    if (Array.isArray(condition))
+        return condition.map(c => c === false ? "false" : serializableValueConditionType(c));
+    if (isAdvancedCondition(condition))
+        return "advanced";
+    return "value";
+}
 function omit(obj, ...keys) {
     const _ = { ...obj };
     keys.forEach((key) => delete _[key]);

package/package.json

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