@oscarpalmer/mora 0.22.0 → 0.24.0

package/types/value/array.d.ts

@@ -1,6 +1,6 @@
-import { type Unsubscribe } from '../subscription';
+import type { ReactiveOptions, Unsubscribe } from '../models';
 import { type Computed } from './computed';
-import { Reactive, type ReactiveOptions } from './reactive';
+import { Reactive } from './reactive';
 export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
     #private;
     /**
@@ -16,61 +16,93 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
      * Clear the array
      */
     clear(): void;
+    /**
+     * Create a computed, filtered array
+     * @param callback Callback to evaluate each item
+     * @return Computed array of filtered items
+     */
+    filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
     /**
      * @inheritdoc
      */
     get(): Item[];
     /**
      * Get the value at an index
+     * @param index Index of item to get _(if negative, starts from the end)_
+     * @returns Item at index, or `undefined` if it doesn't exist
      */
     get(index: number): Item | undefined;
     /**
      * Get the length of the array
+     * @returns Length of the array
      */
     get(property: 'length'): number;
-    /**
-     * Create a computed, filtered array
-     */
-    filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
     /**
      * Create a computed, mapped array
+     * @param callback Callback to transform each item
+     * @return Computed array of mapped items
      */
     map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
+    /**
+     * Notify dependents of changes
+     *
+     * _This bypasses equality checks and will immediately notify dependents.
+     * Use this only if you're modifying nested data that would be ignored by equality checks._
+     */
+    notify(): void;
     /**
      * @inheritdoc
      */
     peek(): Item[];
+    /**
+     * Get the value at an index _(without reactivity)_
+     * @param index Index of item to get _(if negative, starts from the end)_
+     * @returns Item at index, or `undefined` if it doesn't exist
+     */
     peek(index: number): Item | undefined;
     /**
      * Get the length of the array _(without reactivity)_
+     * @returns Length of the array
      */
-    peek(length: true): number;
+    peek(property: 'length'): number;
     /**
      * Remove and return the last item of the array
+     * @returns Removed item, or `undefined` if the array is empty
      */
     pop(): Item | undefined;
     /**
      * Add items to the end of the array
+     * @param items Items to add
+     * @returns New array length
      */
     push(...items: Item[]): number;
     /**
      * Set the value
+     * @param value New array of items _(defaults to an empty array)_
      */
     set(value?: Item[]): void;
     /**
      * Set the value at an index
+     * @param index Index of item to set __(if negative, starts from the end)_
+     * @param value New item
      */
     set(index: number, value: Item): void;
     /**
      * Set the length of the array
+     * @param value New array length
      */
     set(property: 'length', value: number): void;
     /**
      * Remove and return the first item of the array
+     * @returns Removed item, or `undefined` if the array is empty
      */
     shift(): Item | undefined;
     /**
      * Remove and return items from the array _(and optionally add new items)_
+     * @param from Index to start removing items from
+     * @param to Index to stop removing items at _(defaults to the end of the array)_
+     * @param items Optional items to add
+     * @returns Removed items
      */
     splice(from: number, to?: number, ...items: Item[]): Item[];
     /**
@@ -79,18 +111,27 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
     subscribe(callback: (value: Item[]) => void): Unsubscribe;
     /**
      * Subscribe to changes at a specific index
+     * @param index Index of item to subscribe to
+     * @param callback Callback for changes
+     * @returns Unsubscribe callback
      */
     subscribe(index: number, callback: (value: Item | undefined) => void): Unsubscribe;
     /**
      * Add items to the beginning of the array
+     * @param items Items to add
+     * @returns New array length
      */
     unshift(...items: Item[]): number;
     /**
      * Update the value _(based on the current value)_
+     * @param callback Callback to update the value
      */
     update(callback: (value: Item[]) => Item[]): void;
 }
 /**
  * Create a reactive array
+ * @param value Initial array of items
+ * @param options Optional reactivity options
+ * @returns Reactive array
  */
 export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/types/value/computed.d.ts

@@ -1,14 +1,5 @@
-import { type Effect } from '../effect';
-import { Reactive, type ReactiveOptions, type ReactiveState } from './reactive';
-export type ComputedEffect = {
-    dirty: boolean;
-    instance: Effect;
-};
-export type InternalComputed = {
-    readonly effect: ComputedEffect;
-    readonly state: ReactiveState<unknown, unknown>;
-};
-export declare let activeComputed: Computed<unknown> | undefined;
+import type { ReactiveOptions } from '../models';
+import { Reactive } from './reactive';
 export declare class Computed<Value> extends Reactive<Value> {
     private readonly effect;
     constructor(callback: () => Value, options?: ReactiveOptions<Value>);

package/types/value/reactive.d.ts

@@ -1,45 +1,36 @@
-import type { GenericCallback } from '@oscarpalmer/atoms/models';
-import type { Effect } from '../effect';
-import { type Subscription, type Unsubscribe } from '../subscription';
-import type { Computed } from './computed';
+import type { ReactiveOptions, ReactiveState, Unsubscribe } from '../models';
 export declare abstract class Reactive<Value, Equal = Value> {
     protected readonly state: ReactiveState<Value, Equal>;
     constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
     /**
      * Get the value
+     * @return Current value
      */
     abstract get(): Value;
     /**
      * Get the value _(without reactivity)_
+     * @return Current value
      */
     peek(): Value;
     /**
      * Subscribe to changes
+     * @param callback Callback for changes
+     * @return Unsubscribe callback
      */
     subscribe(callback: (value: Value) => void): Unsubscribe;
     /**
      * JSON representation of the value
+     * @return JSON value
      */
     toJSON(): Value;
     /**
      * String representation of the value
+     * @return Value as string
      */
     toString(): string;
     /**
      * Unsubscribe from changes
+     * @param callback Callback to unsubscribe
      */
     unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveOptions<Value> = {
-    /**
-     * Method to compare values for equality
-     */
-    equal?: (first: Value, second: Value) => boolean;
-};
-export type ReactiveState<Value, Equal> = {
-    computeds: Set<Computed<unknown>>;
-    effects: Set<Effect>;
-    equal: (first: Equal, second: Equal) => boolean;
-    subscriptions: Map<GenericCallback, Subscription>;
-    value: Value;
-};

package/types/value/signal.d.ts

@@ -1,4 +1,5 @@
-import { Reactive, type ReactiveOptions } from './reactive';
+import type { ReactiveOptions } from '../models';
+import { Reactive } from './reactive';
 export declare class Signal<Value> extends Reactive<Value> {
     constructor(value: Value, options?: ReactiveOptions<Value>);
     /**
@@ -7,14 +8,19 @@ export declare class Signal<Value> extends Reactive<Value> {
     get(): Value;
     /**
      * Set the value
+     * @param value New value
      */
     set(value: Value): void;
     /**
      * Update the value _(based on the current value)_
+     * @param callback Callback to update the value
      */
     update(callback: (value: Value) => Value): void;
 }
 /**
  * Create a reactive value
+ * @param value Initial value
+ * @param options Optional reactivity options
+ * @returns Reactive value
  */
 export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;

package/types/value/store.d.ts

@@ -1,6 +1,6 @@
 import type { Key, PlainObject } from '@oscarpalmer/atoms/models';
-import { type Unsubscribe } from '../subscription';
-import { Reactive, type ReactiveOptions } from './reactive';
+import type { ReactiveOptions, Unsubscribe } from '../models';
+import { Reactive } from './reactive';
 export declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
     #private;
     constructor(value: Value, options?: ReactiveOptions<Value>);
@@ -9,35 +9,56 @@ export declare class Store<Value extends PlainObject> extends Reactive<Value, Va
      */
     get(): Value;
     /**
-     * Get a value by key _(without reactivity)_
+     * Get a value by key
+     * @param key Key of the value to get
+     * @returns Value for the specified key, or `undefined` if it doesn't exist
      */
-    get(key: keyof Value): Value[keyof Value];
+    get<Key extends keyof Value>(key: Key): Value[Key];
     /**
-     * Get a value by key _(without reactivity)_
+     * Get a value by key
+     * @param key Key of the value to get
+     * @returns Value for the specified key, or `undefined` if it doesn't exist
      */
     get(key: Key): unknown;
+    /**
+     * Notify dependents of changes
+     *
+     * _This bypasses equality checks and will immediately notify dependents.
+     * Use this only if you're modifying nested data that would be ignored by equality checks._
+     */
+    notify(): void;
     /**
      * Get the value _(without reactivity)_
+     * @returns The current value
      */
     peek(): Value;
     /**
      * Get a value by key _(without reactivity)_
+     * @param key Key of the value to get
+     * @returns Value for the specified key, or `undefined` if it doesn't exist
      */
-    peek(key: keyof Value): Value[keyof Value];
+    peek<Key extends keyof Value>(key: Key): Value[Key];
     /**
      * Get a value by key _(without reactivity)_
+     * @param key Key of the value to get
+     * @returns Value for the specified key, or `undefined` if it doesn't exist
      */
     peek(key: Key): unknown;
     /**
      * Set the value
+     * @param value New value _(defaults to an empty object)_
      */
     set(value?: Value): void;
     /**
      * Set a value by key
+     * @param key Key of the value to set
+     * @param value New value
      */
-    set(key: keyof Value, value: Value[keyof Value]): void;
+    set<Key extends keyof Value>(key: Key, value: Value[Key]): void;
     /**
      * Set a value by key
+     * @param key Key of the value to set
+     * @param value New value
      */
     set(key: Key, value: unknown): void;
     /**
@@ -46,18 +67,28 @@ export declare class Store<Value extends PlainObject> extends Reactive<Value, Va
     subscribe(callback: (value: Value) => void): Unsubscribe;
     /**
      * Subscribe to changes for a specific key
+     * @param key Key of the value to subscribe to
+     * @param callback Callback for changes
+     * @returns Unsubscribe callback
      */
     subscribe<Key extends keyof Value>(key: Key, callback: (value: Value[Key] | undefined) => void): Unsubscribe;
     /**
      * Subscribe to changes for a specific key
+     * @param key Key of the value to subscribe to
+     * @param callback Callback for changes
+     * @returns Unsubscribe callback
      */
     subscribe(key: Key, callback: (value: unknown) => void): Unsubscribe;
     /**
      * Update the value _(based on the current value)_
+     * @param callback Callback to update the value
      */
     update(callback: (value: Value) => Value): void;
 }
 /**
  * Create a reactive store
+ * @param value Initial object value
+ * @param options Optional reactivity options
+ * @returns Reactive store
  */
 export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;