@zeix/cause-effect 0.16.0 → 0.16.1

package/types/index.d.ts

@@ -1,10 +1,10 @@
 /**
  * @name Cause & Effect
- * @version 0.16.0
+ * @version 0.16.1
  * @author Esther Brunner
  */
 export { type Computed, type ComputedCallback, createComputed, isComputed, isComputedCallback, TYPE_COMPUTED, } from './src/computed';
-export { type DiffResult, diff, isEqual, type UnknownArray, type UnknownRecord, type UnknownRecordOrArray, } from './src/diff';
+export { type DiffResult, diff, isEqual, type PartialRecord, type UnknownArray, type UnknownRecord, } from './src/diff';
 export { createEffect, type EffectCallback, type MaybeCleanup, } from './src/effect';
 export { CircularDependencyError, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, StoreKeyExistsError, StoreKeyRangeError, StoreKeyReadonlyError, } from './src/errors';
 export { type MatchHandlers, match } from './src/match';
@@ -13,4 +13,4 @@ export { isMutableSignal, isSignal, type Signal, type SignalValues, toSignal, ty
 export { createState, isState, type State, TYPE_STATE } from './src/state';
 export { createStore, isStore, type Store, type StoreChanges, TYPE_STORE, } from './src/store';
 export { batch, type Cleanup, createWatcher, flush, notify, observe, subscribe, type Watcher, } from './src/system';
-export { isAbortError, isAsyncFunction, isFunction, isNumber, isRecord, isRecordOrArray, isString, isSymbol, toError, UNSET, valueString, } from './src/util';
+export { isAbortError, isAsyncFunction, isFunction, isNumber, isObjectOfType, isRecord, isRecordOrArray, isString, isSymbol, toError, UNSET, valueString, } from './src/util';

package/types/src/diff.d.ts

@@ -3,12 +3,12 @@ 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> = {
+type PartialRecord<T> = T extends UnknownArray ? Partial<ArrayToRecord<T>> : Partial<T>;
+type DiffResult<T extends UnknownRecord | UnknownArray = UnknownRecord> = {
     changed: boolean;
-    add: Partial<T>;
-    change: Partial<T>;
-    remove: Partial<T>;
+    add: PartialRecord<T>;
+    change: PartialRecord<T>;
+    remove: PartialRecord<T>;
 };
 /**
  * Checks if two values are equal with cycle detection
@@ -28,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 UnknownRecordOrArray>(oldObj: T, newObj: T) => DiffResult<T>;
-export { type ArrayToRecord, type DiffResult, diff, isEqual, type UnknownRecord, type UnknownArray, type UnknownRecordOrArray, };
+declare const diff: <T extends UnknownRecord | UnknownArray>(oldObj: T extends UnknownArray ? ArrayToRecord<T> : T, newObj: T extends UnknownArray ? ArrayToRecord<T> : T) => DiffResult<T>;
+export { type ArrayToRecord, type DiffResult, diff, isEqual, type UnknownRecord, type UnknownArray, type PartialRecord, };

package/types/src/store.d.ts

@@ -1,16 +1,16 @@
-import { type UnknownArray, type UnknownRecord, type UnknownRecordOrArray } from './diff';
+import { type PartialRecord, type UnknownArray, type UnknownRecord } from './diff';
 import { type State } from './state';
 import { type Cleanup } from './system';
 type ArrayItem<T> = T extends readonly (infer U extends {})[] ? U : never;
 type StoreChanges<T> = {
-    add: Partial<T>;
-    change: Partial<T>;
-    remove: Partial<T>;
+    add: PartialRecord<T>;
+    change: PartialRecord<T>;
+    remove: PartialRecord<T>;
     sort: string[];
 };
 interface BaseStore {
     readonly [Symbol.toStringTag]: 'Store';
-    readonly size: State<number>;
+    readonly length: number;
 }
 type RecordStore<T extends UnknownRecord> = BaseStore & {
     [K in keyof T]: T[K] extends readonly unknown[] | Record<string, unknown> ? Store<T[K]> : State<T[K]>;
@@ -38,7 +38,6 @@ type ArrayStore<T extends UnknownArray> = BaseStore & {
     sort<U = ArrayItem<T>>(compareFn?: (a: U, b: U) => number): void;
     on<K extends keyof StoreChanges<T>>(type: K, listener: (change: StoreChanges<T>[K]) => void): Cleanup;
     remove(index: number): void;
-    readonly length: number;
 };
 type Store<T extends UnknownRecord | UnknownArray> = T extends UnknownRecord ? RecordStore<T> : T extends UnknownArray ? ArrayStore<T> : never;
 declare const TYPE_STORE = "Store";
@@ -62,5 +61,5 @@ declare const createStore: <T extends UnknownRecord | UnknownArray>(initialValue
  * @param {unknown} value - value to check
  * @returns {boolean} - true if the value is a Store instance, false otherwise
  */
-declare const isStore: <T extends UnknownRecordOrArray>(value: unknown) => value is Store<T>;
+declare const isStore: <T extends UnknownRecord | UnknownArray>(value: unknown) => value is Store<T>;
 export { TYPE_STORE, isStore, createStore, type Store, type StoreChanges };