@ptolemy2002/ts-utils 3.2.1 → 3.4.0

package/README.md

@@ -106,6 +106,20 @@ This type returns an intersection of all the possible values in an object of typ
 ### Contains<L extends unknown[], T>
 This type returns a boolean indicating whether the type `T` is contained in the array `L`.
 
+### ArrayWithOptional<AR extends unknown[], AO extends unknown[]>
+This type returns a union of the array `AR` and an array that consists of all the elements of `AR` followed by all the elements of `AO`. You can chain it for multiple optional segments, like so:
+```typescript
+type MyArray = ArrayWithOptional<[number, string], ArrayWithOptional<[boolean], [Date]>>;
+```
+
+The resulting type `MyArray` would be equivalent to:
+```typescript
+type MyArray =
+    | [number, string]
+    | [number, string, boolean]
+    | [number, string, boolean, Date];
+```
+
 ## Functions
 The following functions are available in the library:
 
@@ -166,7 +180,7 @@ This function takes a condition of type `ValueCondition<T>` and returns a string
 #### Returns
 `ValueConditionType` - The type of the condition.
 
-### serializeValueConditionType<T>
+### serializableValueConditionType<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.
 
@@ -176,6 +190,26 @@ The same as `valueConditionType`, except that it specifically takes a `Serializa
 #### Returns
 `SerializableValueConditionType` - The type of the condition.
 
+### zodSerializableAdvancedConditionSchemaTemplate<ZT extends ZodType>
+#### Description
+A function that allows you to pass in a Zod schema and wrap it such that it can be used to validate a `SerializableAdvancedCondition<T>` where `T` is the type represented by the Zod schema. Note: not the full extent of recursion in `SerializableAdvancedCondition<T>` is supported, nor are functions.
+
+#### Parameters
+- `zt` (`ZT`) - The Zod schema representing the type `T`.
+
+#### Returns
+`ZodObject<...>` - A Zod schema that can be used to validate a `SerializableAdvancedCondition<T>`.
+
+### zodSerializableValueConditionSchemaTemplate<ZT extends ZodType>
+#### Description
+A function that allows you to pass in a Zod schema and wrap it such that it can be used to validate a `SerializableValueCondition<T>` where `T` is the type represented by the Zod schema. Note: not the full extent of recursion in `SerializableValueCondition<T>` is supported, nor are functions.
+
+#### Parameters
+- `zt` (`ZT`) - The Zod schema representing the type `T`.
+
+#### Returns
+`ZodUnion<...>` - A Zod schema that can be used to validate a `SerializableValueCondition<T>`.
+
 ### 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.
@@ -190,6 +224,8 @@ This function takes an object of type `T` and a list of keys `K` and returns a n
 ## Peer Dependencies
 - `is-callable^1.2.7`
 - `@ptolemy2002/ts-brand-utils^1.0.0`
+- `@ptolemy2002/regex-utils^4.2.0`
+- `zod^4.3.6`
 
 ## Commands
 The following commands exist in the project:

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { Branded, WithoutBrand } from "@ptolemy2002/ts-brand-utils";
+import z, { ZodType } from "zod";
 export type ValueOf<T> = T[keyof T];
 export type MaybeTransformer<T, Args extends any[] = []> = T | ((...args: Args) => T);
 export type MaybeTransformerRecord<T, Args extends any[] = []> = {
@@ -49,6 +50,26 @@ export type ValueConditionType = "advanced" | "function" | "value" | (ValueCondi
 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 declare function zodSerializableAdvancedConditionSchemaTemplate<ZT extends ZodType>(zt: ZT): z.ZodPipe<z.ZodObject<{
+    include: z.ZodOptional<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>]>>]>>;
+    exclude: z.ZodOptional<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>]>>]>>;
+}, z.core.$strip>, z.ZodTransform<SerializableAdvancedCondition<z.core.$InferUnionOutput<ZT>>, {
+    include?: false | z.core.$InferUnionOutput<ZT> | (false | z.core.$InferUnionOutput<ZT>)[];
+    exclude?: false | z.core.$InferUnionOutput<ZT> | (false | z.core.$InferUnionOutput<ZT>)[];
+}>>;
+export declare function zodSerializableValueConditionSchemaTemplate<ZT extends ZodType>(zt: ZT): z.ZodUnion<readonly [ZT, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodPipe<z.ZodObject<{
+    include: z.ZodOptional<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>]>>]>>;
+    exclude: z.ZodOptional<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>]>>]>>;
+}, z.core.$strip>, z.ZodTransform<SerializableAdvancedCondition<z.core.$InferUnionOutput<ZT>>, {
+    include?: false | z.core.$InferUnionOutput<ZT> | (false | z.core.$InferUnionOutput<ZT>)[];
+    exclude?: false | z.core.$InferUnionOutput<ZT> | (false | z.core.$InferUnionOutput<ZT>)[];
+}>>]>>, z.ZodPipe<z.ZodObject<{
+    include: z.ZodOptional<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>]>>]>>;
+    exclude: z.ZodOptional<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>, z.ZodArray<z.ZodUnion<readonly [ZT, z.ZodLiteral<false>]>>]>>;
+}, z.core.$strip>, z.ZodTransform<SerializableAdvancedCondition<z.core.$InferUnionOutput<ZT>>, {
+    include?: false | z.core.$InferUnionOutput<ZT> | (false | z.core.$InferUnionOutput<ZT>)[];
+    exclude?: false | z.core.$InferUnionOutput<ZT> | (false | z.core.$InferUnionOutput<ZT>)[];
+}>>]>;
 export type Rename<T, K extends keyof T, N extends string> = Pick<T, Exclude<keyof T, K>> & {
     [P in N]: T[K];
 };
@@ -57,3 +78,4 @@ export type ValuesIntersection<T> = ValueOf<{
 }> extends (x: infer I) => void ? I : never;
 export type Contains<L extends unknown[], T> = L extends [...unknown[], T] ? true : L extends [T, ...unknown[]] ? true : L extends [T] ? true : false;
 export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
+export type ArrayWithOptional<AR extends unknown[], AO extends unknown[]> = AR | [...AR, ...AO];

package/dist/index.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAdvancedCondition = isAdvancedCondition;
 exports.createAdvancedCondition = createAdvancedCondition;
@@ -6,9 +9,13 @@ exports.createSerializableAdvancedCondition = createSerializableAdvancedConditio
 exports.valueConditionMatches = valueConditionMatches;
 exports.valueConditionType = valueConditionType;
 exports.serializableValueConditionType = serializableValueConditionType;
+exports.zodSerializableAdvancedConditionSchemaTemplate = zodSerializableAdvancedConditionSchemaTemplate;
+exports.zodSerializableValueConditionSchemaTemplate = zodSerializableValueConditionSchemaTemplate;
 exports.omit = omit;
-const isCallable = require("is-callable");
+const is_callable_1 = __importDefault(require("is-callable"));
 const ts_brand_utils_1 = require("@ptolemy2002/ts-brand-utils");
+const regex_utils_1 = require("@ptolemy2002/regex-utils");
+const zod_1 = __importDefault(require("zod"));
 function isAdvancedCondition(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -36,7 +43,7 @@ function valueConditionMatches(value, condition) {
         return true;
     if (Array.isArray(condition))
         return condition.some(c => c !== false && valueConditionMatches(value, c));
-    if (isCallable(condition))
+    if ((0, is_callable_1.default)(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 (!isAdvancedCondition(condition))
@@ -47,10 +54,10 @@ function valueConditionMatches(value, condition) {
     if (!Array.isArray(exclude))
         exclude = [exclude];
     const included = (v) => {
-        return include.some(i => i !== false && (isCallable(i) ? i(v) : match(value, i)));
+        return include.some(i => i !== false && ((0, is_callable_1.default)(i) ? i(v) : match(value, i)));
     };
     const excluded = (v) => {
-        return exclude.some(e => e !== false && (isCallable(e) ? e(v) : match(value, e)));
+        return exclude.some(e => e !== false && ((0, is_callable_1.default)(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)
@@ -63,7 +70,7 @@ function valueConditionType(condition) {
         return condition.map(c => c === false ? "false" : valueConditionType(c));
     if (isAdvancedCondition(condition))
         return "advanced";
-    if (isCallable(condition))
+    if ((0, is_callable_1.default)(condition))
         return "function";
     return "value";
 }
@@ -75,6 +82,30 @@ function serializableValueConditionType(condition) {
         return "advanced";
     return "value";
 }
+const zodValueConditionGenericFactory = (0, regex_utils_1.zodGenericFactory)();
+function zodSerializableAdvancedConditionSchemaTemplate(zt) {
+    return zod_1.default.object({
+        include: zod_1.default.union([
+            zt,
+            zod_1.default.literal(false),
+            zod_1.default.array(zod_1.default.union([zt, zod_1.default.literal(false)]))
+        ]),
+        exclude: zod_1.default.union([
+            zt,
+            zod_1.default.literal(false),
+            zod_1.default.array(zod_1.default.union([zt, zod_1.default.literal(false)]))
+        ])
+    }).partial().transform((data) => createSerializableAdvancedCondition(data));
+}
+function zodSerializableValueConditionSchemaTemplate(zt) {
+    return zodValueConditionGenericFactory(zt)((s) => {
+        return zod_1.default.union([
+            s,
+            zod_1.default.array(zod_1.default.union([s, zod_1.default.literal(false), zodSerializableAdvancedConditionSchemaTemplate(s)])),
+            zodSerializableAdvancedConditionSchemaTemplate(s)
+        ]);
+    });
+}
 function omit(obj, ...keys) {
     const _ = { ...obj };
     keys.forEach((key) => delete _[key]);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/ts-utils",
-    "version": "3.2.1",
+    "version": "3.4.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -27,12 +27,16 @@
         "release-major": "bash ./scripts/release.sh major"
     },
     "peerDependencies": {
+        "@ptolemy2002/regex-utils": "^4.2.0",
+        "@ptolemy2002/ts-brand-utils": "^1.0.0",
         "is-callable": "^1.2.7",
-        "@ptolemy2002/ts-brand-utils": "^1.0.0"
+        "zod": "^4.3.6"
     },
     "devDependencies": {
-        "@types/is-callable": "~1.1.2",
+        "@ptolemy2002/regex-utils": "^4.2.0",
         "@ptolemy2002/ts-brand-utils": "^1.0.0",
-        "is-callable": "^1.2.7"
+        "@types/is-callable": "~1.1.2",
+        "is-callable": "^1.2.7",
+        "zod": "^4.3.6"
     }
 }