@ptolemy2002/ts-utils 3.3.0 → 3.5.0

package/README.md

@@ -180,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.
 
@@ -190,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.
@@ -201,9 +221,17 @@ This function takes an object of type `T` and a list of keys `K` and returns a n
 #### Returns
 `Omit<T, K>` - The object with the keys omitted.
 
+## Classes
+This library exports the following classes:
+
+### Collection<T>
+An abstract class representing an object that can be treated as an array, but with some methods overwritten to use a collection of this type rather than a standard array. No methods are implemented here, so it is up to the extending class to do it all. This is just a template for the extending class to ensure that it has all the necessary methods and that they return the correct types.
+
 ## 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];
 };
@@ -58,3 +79,36 @@ export type ValuesIntersection<T> = ValueOf<{
 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];
+export declare abstract class Collection<T> {
+    abstract length(): number;
+    abstract at(index: number): T | undefined;
+    abstract find(predicate: (item: T, index: number, array: Collection<T>) => boolean): T | undefined;
+    abstract findIndex(predicate: (item: T, index: number, array: Collection<T>) => boolean): number;
+    abstract indexOf(item: T, fromIndex?: number): number;
+    abstract includes(item: T, fromIndex?: number): boolean;
+    abstract some(predicate: (item: T, index: number, array: Collection<T>) => boolean): boolean;
+    abstract every(predicate: (item: T, index: number, array: Collection<T>) => boolean): boolean;
+    abstract forEach(callback: (item: T, index: number, array: Collection<T>) => void): void;
+    abstract map<U>(callback: (item: T, index: number, array: Collection<T>) => U): U[];
+    abstract filter(predicate: (item: T, index: number, array: Collection<T>) => boolean): Collection<T>;
+    abstract flat(depth?: number): Collection<T>;
+    abstract flatMap<U>(callback: (item: T, index: number, array: Collection<T>) => U | U[], depth?: number): U[];
+    abstract slice(start?: number, end?: number): Collection<T>;
+    abstract concat(...others: (T | T[] | Collection<T>)[]): Collection<T>;
+    abstract push(...items: T[]): void;
+    abstract pop(): T | undefined;
+    abstract shift(): T | undefined;
+    abstract unshift(...items: T[]): number;
+    abstract splice(start: number, deleteCount?: number, ...items: T[]): Collection<T>;
+    abstract reverse(): Collection<T>;
+    abstract sort(compareFn?: (a: T, b: T) => number): Collection<T>;
+    abstract fill(value: T, start?: number, end?: number): Collection<T>;
+    abstract [Symbol.iterator](): Iterator<T>;
+    abstract entries(): IterableIterator<[number, T]>;
+    abstract keys(): IterableIterator<number>;
+    abstract values(): IterableIterator<T>;
+    abstract reduce<U>(accumulator: U, callback: (accumulator: U, item: T, index: number, array: Collection<T>) => U): U;
+    abstract reduce(callback: (accumulator: T, item: T, index: number, array: Collection<T>) => T): T;
+    abstract reduce<U>(callback: (accumulator: U | T, item: T, index: number, array: Collection<T>) => U | T, initialValue?: U): U | T;
+    abstract toArray(): T[];
+}

package/dist/index.js

@@ -1,14 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
 exports.isAdvancedCondition = isAdvancedCondition;
 exports.createAdvancedCondition = createAdvancedCondition;
 exports.createSerializableAdvancedCondition = createSerializableAdvancedCondition;
 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 +44,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 +55,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 +71,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,8 +83,35 @@ 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]);
     return _;
 }
+class Collection {
+}
+exports.Collection = Collection;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/ts-utils",
-    "version": "3.3.0",
+    "version": "3.5.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"
     }
 }