@zeix/cause-effect 0.15.0 → 0.15.1

package/types/src/store.d.ts

@@ -1,39 +1,39 @@
-import { type UnknownRecord } from './diff';
+import { type UnknownRecord, type UnknownRecordOrArray } from './diff';
 import { type Signal } from './signal';
 import { type State } from './state';
 declare const TYPE_STORE = "Store";
-interface StoreAddEvent<T extends UnknownRecord> extends CustomEvent {
+interface StoreAddEvent<T extends UnknownRecordOrArray> extends CustomEvent {
     type: 'store-add';
     detail: Partial<T>;
 }
-interface StoreChangeEvent<T extends UnknownRecord> extends CustomEvent {
+interface StoreChangeEvent<T extends UnknownRecordOrArray> extends CustomEvent {
     type: 'store-change';
     detail: Partial<T>;
 }
-interface StoreRemoveEvent<T extends UnknownRecord> extends CustomEvent {
+interface StoreRemoveEvent<T extends UnknownRecordOrArray> extends CustomEvent {
     type: 'store-remove';
     detail: Partial<T>;
 }
-type StoreEventMap<T extends UnknownRecord> = {
+type StoreEventMap<T extends UnknownRecordOrArray> = {
     'store-add': StoreAddEvent<T>;
     'store-change': StoreChangeEvent<T>;
     'store-remove': StoreRemoveEvent<T>;
 };
-interface StoreEventTarget<T extends UnknownRecord> extends EventTarget {
+interface StoreEventTarget<T extends UnknownRecordOrArray> extends EventTarget {
     addEventListener<K extends keyof StoreEventMap<T>>(type: K, listener: (event: StoreEventMap<T>[K]) => void, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof StoreEventMap<T>>(type: K, listener: (event: StoreEventMap<T>[K]) => void, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     dispatchEvent(event: Event): boolean;
 }
-type Store<T extends UnknownRecord = UnknownRecord> = {
-    [K in keyof T & string]: T[K] extends UnknownRecord ? Store<T[K]> : State<T[K]>;
+type Store<T extends UnknownRecordOrArray = UnknownRecord> = {
+    [K in keyof T]: T[K] extends UnknownRecord ? Store<T[K]> : State<T[K]>;
 } & StoreEventTarget<T> & {
     [Symbol.toStringTag]: 'Store';
-    [Symbol.iterator](): IterableIterator<[string, Signal<T[keyof T]>]>;
-    add<K extends keyof T & string>(key: K, value: T[K]): void;
+    [Symbol.iterator](): IterableIterator<[keyof T, Signal<T[keyof T]>]>;
+    add<K extends keyof T>(key: K, value: T[K]): void;
     get(): T;
-    remove<K extends keyof T & string>(key: K): void;
+    remove<K extends keyof T>(key: K): void;
     set(value: T): void;
     update(updater: (value: T) => T): void;
     size: State<number>;
@@ -41,11 +41,16 @@ type Store<T extends UnknownRecord = UnknownRecord> = {
 /**
  * Create a new store with deeply nested reactive properties
  *
+ * Supports both objects and arrays as initial values. Arrays are converted
+ * to records internally for storage but maintain their array type through
+ * the .get() method, which automatically converts objects with consecutive
+ * numeric keys back to arrays.
+ *
  * @since 0.15.0
- * @param {T} initialValue - initial object value of the store
- * @returns {Store<T>} - new store with reactive properties
+ * @param {T} initialValue - initial object or array value of the store
+ * @returns {Store<T>} - new store with reactive properties that preserves the original type T
  */
-declare const store: <T extends UnknownRecord>(initialValue: T) => Store<T>;
+declare const store: <T extends UnknownRecordOrArray>(initialValue: T) => Store<T>;
 /**
  * Check if the provided value is a Store instance
  *
@@ -53,5 +58,5 @@ declare const store: <T extends UnknownRecord>(initialValue: T) => Store<T>;
  * @param {unknown} value - value to check
  * @returns {boolean} - true if the value is a Store instance, false otherwise
  */
-declare const isStore: <T extends UnknownRecord>(value: unknown) => value is Store<T>;
+declare const isStore: <T extends UnknownRecordOrArray>(value: unknown) => value is Store<T>;
 export { TYPE_STORE, isStore, store, type Store, type StoreAddEvent, type StoreChangeEvent, type StoreRemoveEvent, type StoreEventMap, };

package/types/src/util.d.ts

@@ -1,15 +1,14 @@
-declare const isNumber: (value: unknown) => value is number;
 declare const isString: (value: unknown) => value is string;
+declare const isNumber: (value: unknown) => value is number;
 declare const isFunction: <T>(fn: unknown) => fn is (...args: unknown[]) => T;
 declare const isAsyncFunction: <T>(fn: unknown) => fn is (...args: unknown[]) => Promise<T>;
 declare const isObjectOfType: <T>(value: unknown, type: string) => value is T;
 declare const isRecord: <T extends Record<string, unknown>>(value: unknown) => value is T;
-declare const isPrimitive: (value: unknown) => boolean;
-declare const arrayToRecord: <T extends unknown & {}>(array: T[]) => Record<string, T>;
+declare const validArrayIndexes: (keys: Array<PropertyKey>) => number[] | null;
 declare const hasMethod: <T extends object & Record<string, (...args: unknown[]) => unknown>>(obj: T, methodName: string) => obj is T & Record<string, (...args: unknown[]) => unknown>;
 declare const isAbortError: (error: unknown) => boolean;
 declare const toError: (reason: unknown) => Error;
 declare class CircularDependencyError extends Error {
     constructor(where: string);
 }
-export { isNumber, isString, isFunction, isAsyncFunction, isObjectOfType, isRecord, isPrimitive, arrayToRecord, hasMethod, isAbortError, toError, CircularDependencyError, };
+export { isString, isNumber, isFunction, isAsyncFunction, isObjectOfType, isRecord, validArrayIndexes, hasMethod, isAbortError, toError, CircularDependencyError, };