@zeix/cause-effect 0.15.0 → 0.15.2

package/types/index.d.ts

@@ -1,15 +1,16 @@
 /**
  * @name Cause & Effect
- * @version 0.15.0
+ * @version 0.15.1
  * @author Esther Brunner
  */
 export { type Computed, type ComputedCallback, computed, isComputed, isComputedCallback, TYPE_COMPUTED, } from './src/computed';
-export { type DiffResult, diff, isEqual, type UnknownRecord } from './src/diff';
+export { type DiffResult, diff, isEqual, type UnknownArray, type UnknownRecord, type UnknownRecordOrArray, } from './src/diff';
 export { type EffectCallback, effect, type MaybeCleanup } from './src/effect';
+export { CircularDependencyError, InvalidSignalValueError, NullishSignalValueError, StoreKeyExistsError, StoreKeyRangeError, StoreKeyReadonlyError, } from './src/errors';
 export { type MatchHandlers, match } from './src/match';
 export { type ResolveResult, resolve } from './src/resolve';
 export { batch, type Cleanup, enqueue, flush, notify, observe, subscribe, type Updater, type Watcher, watch, } from './src/scheduler';
-export { isSignal, type MaybeSignal, type Signal, type SignalValues, toSignal, UNSET, } from './src/signal';
+export { isMutableSignal, isSignal, type Signal, type SignalValues, toSignal, type UnknownSignalRecord, } from './src/signal';
 export { isState, type State, state, TYPE_STATE } from './src/state';
-export { isStore, type Store, type StoreAddEvent, type StoreChangeEvent, type StoreEventMap, type StoreRemoveEvent, store, TYPE_STORE, } from './src/store';
-export { CircularDependencyError, isAbortError, isAsyncFunction, isFunction, toError, } from './src/util';
+export { isStore, type Store, type StoreAddEvent, type StoreChangeEvent, type StoreEventMap, type StoreRemoveEvent, type StoreSortEvent, store, TYPE_STORE, } from './src/store';
+export { isAbortError, isAsyncFunction, isFunction, isNumber, isRecord, isRecordOrArray, isString, isSymbol, toError, UNSET, } from './src/util';

package/types/src/diff.d.ts

@@ -1,5 +1,10 @@
 type UnknownRecord = Record<string, unknown & {}>;
-type DiffResult<T extends UnknownRecord = UnknownRecord> = {
+type UnknownArray = ReadonlyArray<unknown & {}>;
+type ArrayToRecord<T extends UnknownArray> = {
+    [key: string]: T extends Array<infer U extends {}> ? U : never;
+};
+type UnknownRecordOrArray = UnknownRecord | ArrayToRecord<UnknownArray>;
+type DiffResult<T extends UnknownRecordOrArray = UnknownRecord> = {
     changed: boolean;
     add: Partial<T>;
     change: Partial<T>;
@@ -23,5 +28,5 @@ declare const isEqual: <T>(a: T, b: T, visited?: WeakSet<object>) => boolean;
  * @param {T} newObj - The new record to compare
  * @returns {DiffResult<T>} The result of the comparison
  */
-declare const diff: <T extends UnknownRecord>(oldObj: T, newObj: T) => DiffResult<T>;
-export { type DiffResult, diff, isEqual, type UnknownRecord };
+declare const diff: <T extends UnknownRecordOrArray>(oldObj: T, newObj: T) => DiffResult<T>;
+export { type ArrayToRecord, type DiffResult, diff, isEqual, type UnknownRecord, type UnknownArray, type UnknownRecordOrArray, };

package/types/src/errors.d.ts

@@ -0,0 +1,19 @@
+declare class CircularDependencyError extends Error {
+    constructor(where: string);
+}
+declare class InvalidSignalValueError extends TypeError {
+    constructor(where: string, value: string);
+}
+declare class NullishSignalValueError extends TypeError {
+    constructor(where: string);
+}
+declare class StoreKeyExistsError extends Error {
+    constructor(key: string, value: string);
+}
+declare class StoreKeyRangeError extends RangeError {
+    constructor(index: number);
+}
+declare class StoreKeyReadonlyError extends Error {
+    constructor(key: string, value: string);
+}
+export { CircularDependencyError, InvalidSignalValueError, NullishSignalValueError, StoreKeyExistsError, StoreKeyRangeError, StoreKeyReadonlyError, };

package/types/src/match.d.ts

@@ -1,7 +1,7 @@
 import type { ResolveResult } from './resolve';
-import type { Signal, SignalValues } from './signal';
-type MatchHandlers<S extends Record<string, Signal<unknown & {}>>> = {
-    ok?: (values: SignalValues<S>) => void;
+import type { SignalValues, UnknownSignalRecord } from './signal';
+type MatchHandlers<S extends UnknownSignalRecord> = {
+    ok: (values: SignalValues<S>) => void;
     err?: (errors: readonly Error[]) => void;
     nil?: () => void;
 };
@@ -17,5 +17,5 @@ type MatchHandlers<S extends Record<string, Signal<unknown & {}>>> = {
  * @param {MatchHandlers<S>} handlers - Handlers for different states (side effects only)
  * @returns {void} - Always returns void
  */
-declare function match<S extends Record<string, Signal<unknown & {}>>>(result: ResolveResult<S>, handlers: MatchHandlers<S>): void;
+declare function match<S extends UnknownSignalRecord>(result: ResolveResult<S>, handlers: MatchHandlers<S>): void;
 export { match, type MatchHandlers };

package/types/src/resolve.d.ts

@@ -1,5 +1,5 @@
-import { type Signal, type SignalValues } from './signal';
-type ResolveResult<S extends Record<string, Signal<unknown & {}>>> = {
+import type { SignalValues, UnknownSignalRecord } from './signal';
+type ResolveResult<S extends UnknownSignalRecord> = {
     ok: true;
     values: SignalValues<S>;
     errors?: never;
@@ -25,5 +25,5 @@ type ResolveResult<S extends Record<string, Signal<unknown & {}>>> = {
  * @param {S} signals - Signals to resolve
  * @returns {ResolveResult<S>} - Discriminated union result
  */
-declare function resolve<S extends Record<string, Signal<unknown & {}>>>(signals: S): ResolveResult<S>;
+declare function resolve<S extends UnknownSignalRecord>(signals: S): ResolveResult<S>;
 export { resolve, type ResolveResult };

package/types/src/signal.d.ts

@@ -4,13 +4,12 @@ import { type Store } from './store';
 type Signal<T extends {}> = {
     get(): T;
 };
-type MaybeSignal<T extends {}> = T | Signal<T> | ComputedCallback<T>;
-type SignalValues<S extends Record<string, Signal<unknown & {}>>> = {
+type UnknownSignalRecord = Record<string, Signal<unknown & {}>>;
+type SignalValues<S extends UnknownSignalRecord> = {
     [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
 };
-declare const UNSET: any;
 /**
- * Check whether a value is a Signal or not
+ * Check whether a value is a Signal
  *
  * @since 0.9.0
  * @param {unknown} value - value to check
@@ -18,23 +17,21 @@ declare const UNSET: any;
  */
 declare const isSignal: <T extends {}>(value: unknown) => value is Signal<T>;
 /**
- * Convert a value to a Signal if it's not already a Signal
+ * Check whether a value is a State or Store
  *
- * @since 0.9.6
+ * @since 0.15.2
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a State or Store, false otherwise
  */
-declare function toSignal<T extends Array<unknown & {}>>(value: T[]): Store<Record<string, T>>;
-declare function toSignal<T extends Record<keyof T, T[keyof T]>>(value: T): Store<T>;
-declare function toSignal<T extends {}>(value: ComputedCallback<T>): Computed<T>;
-declare function toSignal<T extends {}>(value: Signal<T>): Signal<T>;
-declare function toSignal<T extends {}>(value: T): State<T>;
+declare const isMutableSignal: <T extends {}>(value: unknown) => value is State<T> | Store<T>;
 /**
- * Convert a value to a mutable Signal if it's not already a Signal
+ * Convert a value to a Signal if it's not already a Signal
  *
  * @since 0.9.6
+ * @param {T} value - value to convert
+ * @returns {Signal<T>} - Signal instance
  */
-declare function toMutableSignal<T extends Array<unknown & {}>>(value: T[]): Store<Record<string, T>>;
-declare function toMutableSignal<T extends Record<keyof T, T[keyof T]>>(value: T): Store<T>;
-declare function toMutableSignal<T extends State<T>>(value: State<T>): State<T>;
-declare function toMutableSignal<T extends Store<T>>(value: Store<T>): Store<T>;
-declare function toMutableSignal<T extends {}>(value: T): State<T>;
-export { type Signal, type MaybeSignal, type SignalValues, UNSET, isSignal, toSignal, toMutableSignal, };
+declare function toSignal<T extends {}>(value: T): T extends Store<infer U> ? Store<U> : T extends State<infer U> ? State<U> : T extends Computed<infer U> ? Computed<U> : T extends Signal<infer U> ? Signal<U> : T extends ReadonlyArray<infer U extends {}> ? Store<U[]> : T extends Record<string, unknown & {}> ? Store<{
+    [K in keyof T]: T[K];
+}> : T extends ComputedCallback<infer U extends {}> ? Computed<U> : State<T>;
+export { type Signal, type UnknownSignalRecord, type SignalValues, isSignal, isMutableSignal, toSignal, };

package/types/src/store.d.ts

@@ -1,51 +1,74 @@
-import { type UnknownRecord } from './diff';
-import { type Signal } from './signal';
+import { type UnknownArray, type UnknownRecord, type UnknownRecordOrArray } from './diff';
 import { type State } from './state';
-declare const TYPE_STORE = "Store";
-interface StoreAddEvent<T extends UnknownRecord> extends CustomEvent {
-    type: 'store-add';
-    detail: Partial<T>;
-}
-interface StoreChangeEvent<T extends UnknownRecord> extends CustomEvent {
-    type: 'store-change';
-    detail: Partial<T>;
-}
-interface StoreRemoveEvent<T extends UnknownRecord> extends CustomEvent {
-    type: 'store-remove';
-    detail: Partial<T>;
-}
-type StoreEventMap<T extends UnknownRecord> = {
+type ArrayItem<T> = T extends readonly (infer U extends {})[] ? U : never;
+type StoreEventMap<T extends UnknownRecord | UnknownArray> = {
     'store-add': StoreAddEvent<T>;
     'store-change': StoreChangeEvent<T>;
     'store-remove': StoreRemoveEvent<T>;
+    'store-sort': StoreSortEvent;
 };
-interface StoreEventTarget<T extends UnknownRecord> extends EventTarget {
+interface StoreEventTarget<T extends UnknownRecord | UnknownArray> 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]>;
-} & 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;
+interface BaseStore<T extends UnknownRecord | UnknownArray> extends StoreEventTarget<T> {
+    readonly [Symbol.toStringTag]: 'Store';
     get(): T;
-    remove<K extends keyof T & string>(key: K): void;
     set(value: T): void;
-    update(updater: (value: T) => T): void;
-    size: State<number>;
+    update(fn: (value: T) => T): void;
+    sort<U = T extends UnknownArray ? ArrayItem<T> : T[Extract<keyof T, string>]>(compareFn?: (a: U, b: U) => number): void;
+    readonly size: State<number>;
+}
+type RecordStore<T extends UnknownRecord> = BaseStore<T> & {
+    [K in keyof T]: T[K] extends readonly unknown[] | Record<string, unknown> ? Store<T[K]> : State<T[K]>;
+} & {
+    add<K extends Extract<keyof T, string>>(key: K, value: T[K]): void;
+    remove<K extends Extract<keyof T, string>>(key: K): void;
+    [Symbol.iterator](): IterableIterator<[
+        Extract<keyof T, string>,
+        T[Extract<keyof T, string>] extends readonly unknown[] | Record<string, unknown> ? Store<T[Extract<keyof T, string>]> : State<T[Extract<keyof T, string>]>
+    ]>;
+};
+type ArrayStore<T extends UnknownArray> = BaseStore<T> & {
+    readonly length: number;
+    [n: number]: ArrayItem<T> extends readonly unknown[] | Record<string, unknown> ? Store<ArrayItem<T>> : State<ArrayItem<T>>;
+    add(value: ArrayItem<T>): void;
+    remove(index: number): void;
+    [Symbol.iterator](): IterableIterator<ArrayItem<T> extends readonly unknown[] | Record<string, unknown> ? Store<ArrayItem<T>> : State<ArrayItem<T>>>;
+    readonly [Symbol.isConcatSpreadable]: boolean;
 };
+interface StoreAddEvent<T extends UnknownRecord | UnknownArray> extends CustomEvent {
+    type: 'store-add';
+    detail: Partial<T>;
+}
+interface StoreChangeEvent<T extends UnknownRecord | UnknownArray> extends CustomEvent {
+    type: 'store-change';
+    detail: Partial<T>;
+}
+interface StoreRemoveEvent<T extends UnknownRecord | UnknownArray> extends CustomEvent {
+    type: 'store-remove';
+    detail: Partial<T>;
+}
+interface StoreSortEvent extends CustomEvent {
+    type: 'store-sort';
+    detail: string[];
+}
+type Store<T> = T extends UnknownRecord ? RecordStore<T> : T extends UnknownArray ? ArrayStore<T> : never;
+declare const TYPE_STORE = "Store";
 /**
  * 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 UnknownRecord | UnknownArray>(initialValue: T) => Store<T>;
 /**
  * Check if the provided value is a Store instance
  *
@@ -53,5 +76,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>;
-export { TYPE_STORE, isStore, store, type Store, type StoreAddEvent, type StoreChangeEvent, type StoreRemoveEvent, type StoreEventMap, };
+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 StoreSortEvent, type StoreEventMap, };

package/types/src/util.d.ts

@@ -1,15 +1,17 @@
-declare const isNumber: (value: unknown) => value is number;
+declare const UNSET: any;
 declare const isString: (value: unknown) => value is string;
+declare const isNumber: (value: unknown) => value is number;
+declare const isSymbol: (value: unknown) => value is symbol;
 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 isDefinedObject: (value: unknown) => value is Record<string, unknown>;
 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 isRecordOrArray: <T extends Record<string | number, unknown> | ReadonlyArray<unknown>>(value: unknown) => value is T;
 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, };
+declare const arrayToRecord: <T>(array: T[]) => Record<string, T>;
+declare const recordToArray: <T>(record: Record<string | number, T>) => Record<string, T> | T[];
+declare const valueString: (value: unknown) => string;
+export { UNSET, isString, isNumber, isSymbol, isFunction, isAsyncFunction, isDefinedObject, isObjectOfType, isRecord, isRecordOrArray, hasMethod, isAbortError, toError, arrayToRecord, recordToArray, valueString, };

package/index.d.ts

@@ -1,36 +0,0 @@
-/**
- * @name Cause & Effect
- * @version 0.14.2
- * @author Esther Brunner
- */
-export {
-	type Computed,
-	type ComputedCallback,
-	computed,
-	isComputed,
-	TYPE_COMPUTED,
-} from './src/computed'
-export { type EffectMatcher, type MaybeCleanup, effect } from './src/effect'
-export {
-	batch,
-	type Cleanup,
-	enqueue,
-	flush,
-	notify,
-	observe,
-	subscribe,
-	type Updater,
-	type Watcher,
-	watch,
-} from './src/scheduler'
-export {
-	isComputedCallback,
-	isSignal,
-	type MaybeSignal,
-	type Signal,
-	type SignalValues,
-	toSignal,
-	UNSET,
-} from './src/signal'
-export { isState, type State, state, TYPE_STATE } from './src/state'
-export { CircularDependencyError, isFunction } from './src/util'

package/types/test-new-effect.d.ts

@@ -1 +0,0 @@
-export {};