@sladg/apex-state 3.6.3 → 3.7.0

package/dist/index.d.ts

@@ -204,6 +204,12 @@ type PathValuePair<STATE, Depth extends number> = DeepKey<STATE, Depth> extends
  * Same distribution as PathValuePair but with array values.
  */
 type PathValueArrayPair<STATE, Depth extends number> = DeepKey<STATE, Depth> extends infer P ? P extends string ? [P, DeepValue<STATE, P>[]] : never : never;
+/**
+ * Array-elements pair for CONTAINS_ANY / CONTAINS_ALL operators.
+ * Same distribution as PathArrayElementPair but the second element is an array
+ * of items, enabling multi-value containment checks.
+ */
+type PathArrayElementsPair<STATE, Depth extends number> = DeepKey<STATE, Depth> extends infer P ? P extends string ? NonNullable<DeepValue<STATE, P>> extends readonly (infer Item)[] ? [P, Item[]] : never : never : never;
 /**
  * Paths that resolve to number, plus `.length` on array-valued paths.
  * Allows GT/LT/GTE/LTE to compare against array lengths without
@@ -223,6 +229,8 @@ type NumericPaths<STATE, Depth extends number> = DeepKeyFiltered<STATE, number,
  * - AND/OR/NOT: Boolean combinators
  * - GT/LT/GTE/LTE: Numeric comparisons (only on number paths or array.length)
  * - IN: Check if path value is in allowed list (values must match path type)
+ * - CONTAINS_ANY: Check if array at path contains any of the given elements
+ * - CONTAINS_ALL: Check if array at path contains all of the given elements
  * - Shorthand: [path, value] tuple as shorthand for IS_EQUAL
  *
  * @example
@@ -271,6 +279,10 @@ type BoolLogic<STATE, Depth extends number = DefaultDepth> = {
     LTE: [NumericPaths<STATE, Depth>, number];
 } | {
     IN: PathValueArrayPair<STATE, Depth>;
+} | {
+    CONTAINS_ANY: PathArrayElementsPair<STATE, Depth>;
+} | {
+    CONTAINS_ALL: PathArrayElementsPair<STATE, Depth>;
 } | PathValuePair<STATE, Depth>;
 
 /**
@@ -1702,6 +1714,7 @@ declare const hashKey: {
  *
  * Provides type-safe predicates for common type checks with TypeScript support
  */
+
 /**
  * Unified namespace for type checking
  *
@@ -1723,6 +1736,7 @@ declare const is: {
     undefined: (value: unknown) => value is undefined;
     null: (value: unknown) => value is null;
     object: (value: unknown) => value is Record<string, unknown>;
+    objectOrArray: (value: unknown) => value is Record<string, unknown> | unknown[];
     array: (value: unknown) => value is unknown[];
     string: (value: unknown) => value is string;
     number: (value: unknown) => value is number;
@@ -1731,23 +1745,25 @@ declare const is: {
     symbol: (value: unknown) => value is symbol;
     date: (value: unknown) => value is Date;
     regexp: (value: unknown) => value is RegExp;
-    primitive: (value: unknown) => value is string | number | boolean | symbol | bigint | null | undefined;
+    numericKey: (value: string) => boolean;
+    primitive: (value: unknown) => value is Primitive;
     empty: (value: unknown) => boolean;
     equal: (a: unknown, b: unknown) => boolean;
     not: {
         nil: <T>(value: T | null | undefined) => value is T;
         undefined: <T>(value: T | undefined) => value is T;
         null: <T>(value: T | null) => value is T;
-        object: (value: unknown) => boolean;
-        array: (value: unknown) => boolean;
-        string: (value: unknown) => boolean;
-        number: (value: unknown) => boolean;
-        boolean: (value: unknown) => boolean;
-        function: (value: unknown) => boolean;
-        symbol: (value: unknown) => boolean;
-        date: (value: unknown) => boolean;
-        regexp: (value: unknown) => boolean;
-        primitive: (value: unknown) => boolean;
+        object: <T>(value: T) => value is Exclude<T, Record<string, unknown>>;
+        objectOrArray: <T>(value: T) => value is Exclude<T, Record<string, unknown> | unknown[]>;
+        array: <T>(value: T) => value is Exclude<T, unknown[]>;
+        string: <T>(value: T) => value is Exclude<T, string>;
+        number: <T>(value: T) => value is Exclude<T, number>;
+        boolean: <T>(value: T) => value is Exclude<T, boolean>;
+        function: <T>(value: T) => value is Exclude<T, (...args: unknown[]) => unknown>;
+        symbol: <T>(value: T) => value is Exclude<T, symbol>;
+        date: <T>(value: T) => value is Exclude<T, Date>;
+        regexp: <T>(value: T) => value is Exclude<T, RegExp>;
+        primitive: <T>(value: T) => value is Exclude<T, Primitive>;
         empty: (value: unknown) => boolean;
         equal: (a: unknown, b: unknown) => boolean;
     };