fractostate 4.2.1 → 4.3.2

package/dist/types-B_uh22Cx.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Core types for FractoState
+ */
+type TypeAwareOps<T, BA = any> = [T] extends [null | undefined] ? BaseOps<T, BA> : [T] extends [any[]] ? ArrayOps<T[number], BA> : [T] extends [number] ? NumberOps<BA> : [T] extends [string] ? StringOps<BA> : [T] extends [boolean] ? BooleanOps<BA> : [NonNullable<T>] extends [object] ? ObjectOps<T, BA> : BaseOps<T, BA>;
+type FlowOpsObject<T, BA = any> = {
+    readonly self: TypeAwareOps<T, BA>;
+    readonly state: T;
+};
+/**
+ * Action structure: (...args) => (ops) => Result
+ */
+type FlowAction<T, BA = any> = (...args: any[]) => (ops: FlowOpsObject<T, BA>) => any;
+/**
+ * Type-safe action definition.
+ * Each action is a curried function: (...args) => (ops) => Result
+ */
+type ActionDef<T, A> = (...args: never[]) => (ops: FlowOpsObject<T, BoundActions<A>>) => unknown;
+/**
+ * Transform actions for the component toolbox.
+ */
+type BoundActions<A> = {
+    [K in keyof A]: A[K] extends (...args: infer P) => (...inner: never[]) => infer R ? (...args: P) => R : A[K] extends (...args: infer P) => (ops: FlowOpsObject<infer _T, infer _BA>) => infer R ? (...args: P) => R : A[K];
+};
+interface FlowPlugin<T = any> {
+    name: string;
+    onInit?: (ctx: {
+        key: string;
+        initial: T;
+        store: any;
+    }) => void;
+    onUpdate?: (ctx: {
+        key: string;
+        prev: T;
+        next: T;
+        store: any;
+    }) => void;
+    onHydrate?: (ctx: {
+        key: string;
+        store: any;
+    }) => T | Promise<T> | undefined;
+}
+interface FlowEffect<T, BA = any> {
+    /** Function to run on init and when deps change */
+    run: (ops: FlowOpsObject<T, BA>) => void | Promise<void>;
+    /** Optional dependencies selector. If omitted, runs only on init */
+    deps?: (state: T) => unknown[];
+}
+interface FlowOptions<T = any, A = any> {
+    timeTravel?: boolean;
+    maxHistory?: number;
+    debounce?: number;
+    middleware?: Array<(state: T) => T>;
+    plugins?: FlowPlugin<T>[];
+    effects?: FlowEffect<T, BoundActions<A>>[];
+    force?: boolean;
+    skipEquality?: boolean;
+    isUndoRedo?: boolean;
+    bypassClone?: boolean;
+    /** The name of the component or module performing the update */
+    actor?: string;
+    /** Raw actions dictionary for internal binding */
+    actions?: A;
+}
+interface UseFlowOptions<T> extends FlowOptions<T> {
+    name?: string;
+}
+interface FlowDefinition<T, A = {}> {
+    key: string;
+    initial: T;
+    options?: FlowOptions<T> & {
+        actions?: A;
+    };
+}
+interface DerivedFlowDefinition<T, R> {
+    key: string;
+    source: FlowDefinition<T, any>;
+    selector: (state: T) => R;
+}
+interface FlowOperations<T, A = {}> {
+    /** The operation object for recursive state manipulation via proxies */
+    ops: FlowOpsObject<T, BoundActions<A>>;
+    /** The actions defined in defineFlow, bound to this specific state instance */
+    actions: BoundActions<A>;
+    /** Reverts to the previous state in history (if timeTravel is enabled) */
+    _undo: () => void;
+    /** Reapplies a previously undone state (if timeTravel is enabled) */
+    _redo: () => void;
+    /** Returns the full history stack for this flow */
+    history: T[];
+    /** Boolean indicating if an undo operation is currently possible */
+    _canUndo: boolean;
+    /** Boolean indicating if a redo operation is currently possible */
+    _canRedo: boolean;
+    /** Forcefully updates the state and records history even if values are identical. Useful for triggering effects or manual snapshots. */
+    _set: (val: T | ((prev: T) => T)) => void;
+    /** Optimized update: only commits the change if the new value differs from the current one. Saves history space and render cycles. */
+    _patch: (val: T | ((prev: T) => T)) => void;
+    /** Resets the state back to its initial defined configuration */
+    _reset: () => void;
+    /** Returns the current flow configuration options */
+    cf: FlowOptions<T>;
+    /** Boolean indicating if the flow is currently loading data from a hydration plugin (e.g., localStorage) */
+    isHydrating: boolean;
+}
+/**
+ * Common operations available on every state node.
+ * Prefixed with underscores to avoid collisions with your nested data properties.
+ */
+type BaseOps<T, BA = any> = {
+    /** Forcefully replace the value at this path, ignoring equality checks. Records history. */
+    _set: (value: T) => void;
+    /** Smart update: only commits the change if the value is different. */
+    _patch: (value: T) => void;
+    /** Unwraps the proxy and returns the raw value at this specific tree path. */
+    _val: T;
+    /** Access all actions defined in this flow */
+    __actions__: BA;
+};
+/** Operations specific to numeric values */
+type NumberOps<BA = any> = BaseOps<number, BA> & {
+    /** Increment by n (default 1) */
+    _increment: (n?: number) => void;
+    /** Decrement by n (default 1) */
+    _decrement: (n?: number) => void;
+    /** Add n to the value */
+    _add: (n: number) => void;
+    /** Subtract n from the value */
+    _subtract: (n: number) => void;
+    /** Multiply the value by n */
+    _multiply: (n: number) => void;
+    /** Divide the value by n */
+    _divide: (n: number) => void;
+};
+/** Operations specific to string values */
+type StringOps<BA = any> = BaseOps<string, BA> & {
+    /** Append a string at the end */
+    _append: (s: string) => void;
+    /** Prepend a string at the beginning */
+    _prepend: (s: string) => void;
+    /** Convert value to uppercase */
+    _uppercase: () => void;
+    /** Convert value to lowercase */
+    _lowercase: () => void;
+    /** Trim whitespace from both ends */
+    _trim: () => void;
+    /** Replace occurrences matching pattern */
+    _replace: (pattern: string | RegExp, replacement: string) => void;
+};
+/** Operations specific to array values */
+type ArrayOps<T, BA = any> = BaseOps<T[], BA> & {
+    /** Add an item to the end of the array */
+    _push: (v: T) => void;
+    /** Remove and return the last item */
+    _pop: () => void;
+    /** Remove and return the first item */
+    _shift: () => void;
+    /** Add an item to the beginning of the array */
+    _unshift: (v: T) => void;
+    /** Keep only items matching the condition */
+    _filter: (fn: (v: T, i: number) => boolean) => void;
+    /** Transform every item in the array */
+    _map: (fn: (v: T, i: number) => T) => void;
+    /** Remove item at a specific index */
+    _removeAt: (i: number) => void;
+    /** Insert an item at a specific index */
+    _insertAt: (i: number, v: T) => void;
+};
+/** Operations specific to object values */
+type ObjectOps<T, BA = any> = BaseOps<T, BA> & {
+    /** Shallow merge the provided object into the current state */
+    _merge: (p: Partial<NonNullable<T>>) => void;
+    /** Remove a specific key from the object */
+    _delete: (k: keyof NonNullable<T>) => void;
+} & {
+    [K in keyof NonNullable<T>]-?: TypeAwareOps<NonNullable<T>[K], BA>;
+};
+type BooleanOps<BA = any> = BaseOps<boolean, BA> & {
+    _toggle: () => void;
+};
+
+export type { ActionDef as A, BoundActions as B, DerivedFlowDefinition as D, FlowDefinition as F, NumberOps as N, ObjectOps as O, StringOps as S, TypeAwareOps as T, UseFlowOptions as U, FlowOptions as a, FlowOpsObject as b, FlowOperations as c, ArrayOps as d, BaseOps as e, BooleanOps as f, FlowAction as g, FlowEffect as h, FlowPlugin as i };

package/dist/types-C9aLynPD.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Core types for FractoState
+ */
+type TypeAwareOps<T, A = any> = [T] extends [null | undefined] ? BaseOps<T, A> : [T] extends [any[]] ? ArrayOps<T[number], A> : [T] extends [number] ? NumberOps<A> : [T] extends [string] ? StringOps<A> : [T] extends [boolean] ? BooleanOps<A> : [NonNullable<T>] extends [object] ? ObjectOps<T, A> : BaseOps<T, A>;
+type FlowOpsObject<T, A = any> = {
+    readonly self: TypeAwareOps<T, A>;
+    readonly state: T;
+};
+/**
+ * Action structure: (...args) => (ops) => Result
+ */
+type FlowAction<T, A = any> = (...args: any[]) => (ops: FlowOpsObject<T, A>) => any;
+/**
+ * Transform actions for the component toolbox.
+ */
+type BoundActions<A> = {
+    [K in keyof A]: A[K] extends (...args: infer P) => (...inner: any[]) => infer R ? (...args: P) => R : never;
+};
+interface FlowPlugin<T = any> {
+    name: string;
+    onInit?: (ctx: {
+        key: string;
+        initial: T;
+        store: any;
+    }) => void;
+    onUpdate?: (ctx: {
+        key: string;
+        prev: T;
+        next: T;
+        store: any;
+    }) => void;
+    onHydrate?: (ctx: {
+        key: string;
+        store: any;
+    }) => T | Promise<T> | undefined;
+}
+interface FlowEffect<T, A = any> {
+    /** Function to run on init and when deps change */
+    run: (ops: FlowOpsObject<T, A>) => void | Promise<void>;
+    /** Optional dependencies selector. If omitted, runs only on init */
+    deps?: (state: T) => any[];
+}
+interface FlowOptions<T = any, A = any> {
+    timeTravel?: boolean;
+    maxHistory?: number;
+    debounce?: number;
+    middleware?: Array<(state: T) => T>;
+    plugins?: FlowPlugin<T>[];
+    effects?: FlowEffect<T, A>[];
+    force?: boolean;
+    skipEquality?: boolean;
+    isUndoRedo?: boolean;
+    bypassClone?: boolean;
+    /** The name of the component or module performing the update */
+    actor?: string;
+    /** Raw actions dictionary for internal binding */
+    actions?: A;
+}
+interface UseFlowOptions<T> extends FlowOptions<T> {
+    name?: string;
+}
+interface FlowDefinition<T, A = {}> {
+    key: string;
+    initial: T;
+    options?: FlowOptions<T> & {
+        actions?: A;
+    };
+}
+interface DerivedFlowDefinition<T, R> {
+    key: string;
+    source: FlowDefinition<T, any>;
+    selector: (state: T) => R;
+}
+interface FlowOperations<T, A = {}> {
+    /** The operation object for recursive state manipulation via proxies */
+    ops: FlowOpsObject<T>;
+    /** The actions defined in defineFlow, bound to this specific state instance */
+    actions: BoundActions<A>;
+    /** Reverts to the previous state in history (if timeTravel is enabled) */
+    _undo: () => void;
+    /** Reapplies a previously undone state (if timeTravel is enabled) */
+    _redo: () => void;
+    /** Returns the full history stack for this flow */
+    history: T[];
+    /** Boolean indicating if an undo operation is currently possible */
+    _canUndo: boolean;
+    /** Boolean indicating if a redo operation is currently possible */
+    _canRedo: boolean;
+    /** Forcefully updates the state and records history even if values are identical. Useful for triggering effects or manual snapshots. */
+    _set: (val: T | ((prev: T) => T)) => void;
+    /** Optimized update: only commits the change if the new value differs from the current one. Saves history space and render cycles. */
+    _patch: (val: T | ((prev: T) => T)) => void;
+    /** Resets the state back to its initial defined configuration */
+    _reset: () => void;
+    /** Returns the current flow configuration options */
+    cf: FlowOptions<T>;
+    /** Boolean indicating if the flow is currently loading data from a hydration plugin (e.g., localStorage) */
+    isHydrating: boolean;
+}
+/**
+ * Common operations available on every state node.
+ * Prefixed with underscores to avoid collisions with your nested data properties.
+ */
+type BaseOps<T, A = any> = {
+    /** Forcefully replace the value at this path, ignoring equality checks. Records history. */
+    _set: (value: T) => void;
+    /** Smart update: only commits the change if the value is different. */
+    _patch: (value: T) => void;
+    /** Unwraps the proxy and returns the raw value at this specific tree path. */
+    _val: T;
+    /** Access all actions defined in this flow */
+    __actions__: BoundActions<A>;
+};
+/** Operations specific to numeric values */
+type NumberOps<A = any> = BaseOps<number, A> & {
+    /** Increment by n (default 1) */
+    _increment: (n?: number) => void;
+    /** Decrement by n (default 1) */
+    _decrement: (n?: number) => void;
+    /** Add n to the value */
+    _add: (n: number) => void;
+    /** Subtract n from the value */
+    _subtract: (n: number) => void;
+    /** Multiply the value by n */
+    _multiply: (n: number) => void;
+    /** Divide the value by n */
+    _divide: (n: number) => void;
+};
+/** Operations specific to string values */
+type StringOps<A = any> = BaseOps<string, A> & {
+    /** Append a string at the end */
+    _append: (s: string) => void;
+    /** Prepend a string at the beginning */
+    _prepend: (s: string) => void;
+    /** Convert value to uppercase */
+    _uppercase: () => void;
+    /** Convert value to lowercase */
+    _lowercase: () => void;
+    /** Trim whitespace from both ends */
+    _trim: () => void;
+    /** Replace occurrences matching pattern */
+    _replace: (pattern: string | RegExp, replacement: string) => void;
+};
+/** Operations specific to array values */
+type ArrayOps<T, A = any> = BaseOps<T[], A> & {
+    /** Add an item to the end of the array */
+    _push: (v: T) => void;
+    /** Remove and return the last item */
+    _pop: () => void;
+    /** Remove and return the first item */
+    _shift: () => void;
+    /** Add an item to the beginning of the array */
+    _unshift: (v: T) => void;
+    /** Keep only items matching the condition */
+    _filter: (fn: (v: T, i: number) => boolean) => void;
+    /** Transform every item in the array */
+    _map: (fn: (v: T, i: number) => T) => void;
+    /** Remove item at a specific index */
+    _removeAt: (i: number) => void;
+    /** Insert an item at a specific index */
+    _insertAt: (i: number, v: T) => void;
+};
+/** Operations specific to object values */
+type ObjectOps<T, A = any> = BaseOps<T, A> & {
+    /** Shallow merge the provided object into the current state */
+    _merge: (p: Partial<NonNullable<T>>) => void;
+    /** Remove a specific key from the object */
+    _delete: (k: keyof NonNullable<T>) => void;
+} & {
+    [K in keyof NonNullable<T>]-?: TypeAwareOps<NonNullable<T>[K], A>;
+};
+type BooleanOps<A = any> = BaseOps<boolean, A> & {
+    _toggle: () => void;
+};
+
+export type { ArrayOps as A, BaseOps as B, DerivedFlowDefinition as D, FlowDefinition as F, NumberOps as N, ObjectOps as O, StringOps as S, TypeAwareOps as T, UseFlowOptions as U, FlowOptions as a, FlowOpsObject as b, FlowOperations as c, BooleanOps as d, BoundActions as e, FlowAction as f, FlowEffect as g, FlowPlugin as h };

package/dist/types-dU51pXGw.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Core types for FractoState
+ */
+type TypeAwareOps<T, A = any> = [T] extends [null | undefined] ? BaseOps<T, A> : [T] extends [any[]] ? ArrayOps<T[number], A> : [T] extends [number] ? NumberOps<A> : [T] extends [string] ? StringOps<A> : [T] extends [boolean] ? BooleanOps<A> : [NonNullable<T>] extends [object] ? ObjectOps<T, A> : BaseOps<T, A>;
+type FlowOpsObject<T, A = any> = {
+    readonly self: TypeAwareOps<T, A>;
+    readonly state: T;
+};
+/**
+ * Action structure: (...args) => (ops) => Result
+ */
+type FlowAction<T, A = any> = (...args: any[]) => (ops: FlowOpsObject<T, A>) => any;
+/**
+ * Transform actions for the component toolbox.
+ */
+type BoundActions<A> = {
+    [K in keyof A]: A[K] extends (...args: infer P) => (...inner: any[]) => infer R ? (...args: P) => R : never;
+};
+interface FlowPlugin<T = any> {
+    name: string;
+    onInit?: (ctx: {
+        key: string;
+        initial: T;
+        store: any;
+    }) => void;
+    onUpdate?: (ctx: {
+        key: string;
+        prev: T;
+        next: T;
+        store: any;
+    }) => void;
+    onHydrate?: (ctx: {
+        key: string;
+        store: any;
+    }) => T | Promise<T> | undefined;
+    /** Return methods that will be exposed under ops.self._[pluginName] */
+    getOps?: (ctx: {
+        key: string;
+        store: any;
+    }) => Record<string, Function>;
+}
+interface FlowEffect<T, A = any> {
+    /** Function to run on init and when deps change */
+    run: (ops: FlowOpsObject<T, A>) => void | Promise<void>;
+    /** Optional dependencies selector. If omitted, runs only on init */
+    deps?: (state: T) => any[];
+}
+interface FlowOptions<T = any, A = any> {
+    timeTravel?: boolean;
+    maxHistory?: number;
+    debounce?: number;
+    middleware?: Array<(state: T) => T>;
+    plugins?: FlowPlugin<T>[];
+    effects?: FlowEffect<T, A>[];
+    force?: boolean;
+    skipEquality?: boolean;
+    isUndoRedo?: boolean;
+    bypassClone?: boolean;
+    /** The name of the component or module performing the update */
+    actor?: string;
+    /** Raw actions dictionary for internal binding */
+    actions?: A;
+}
+interface UseFlowOptions<T> extends FlowOptions<T> {
+    name?: string;
+}
+interface FlowDefinition<T, A = {}> {
+    key: string;
+    initial: T;
+    options?: FlowOptions<T> & {
+        actions?: A;
+    };
+}
+interface DerivedFlowDefinition<T, R> {
+    key: string;
+    source: FlowDefinition<T, any>;
+    selector: (state: T) => R;
+}
+interface FlowOperations<T, A = {}> {
+    /** The operation object for recursive state manipulation via proxies */
+    ops: FlowOpsObject<T, A>;
+    /** The actions defined in defineFlow, bound to this specific state instance */
+    actions: BoundActions<A>;
+    /** Reverts to the previous state in history (if timeTravel is enabled) */
+    _undo: () => void;
+    /** Reapplies a previously undone state (if timeTravel is enabled) */
+    _redo: () => void;
+    /** Returns the full history stack for this flow */
+    history: T[];
+    /** Boolean indicating if an undo operation is currently possible */
+    _canUndo: boolean;
+    /** Boolean indicating if a redo operation is currently possible */
+    _canRedo: boolean;
+    /** Forcefully updates the state and records history even if values are identical. Useful for triggering effects or manual snapshots. */
+    _set: (val: T | ((prev: T) => T)) => void;
+    /** Optimized update: only commits the change if the new value differs from the current one. Saves history space and render cycles. */
+    _patch: (val: T | ((prev: T) => T)) => void;
+    /** Resets the state back to its initial defined configuration */
+    _reset: () => void;
+    /** Returns the current flow configuration options */
+    cf: FlowOptions<T>;
+    /** Boolean indicating if the flow is currently loading data from a hydration plugin (e.g., localStorage) */
+    isHydrating: boolean;
+}
+/**
+ * Common operations available on every state node.
+ * Prefixed with underscores to avoid collisions with your nested data properties.
+ */
+type BaseOps<T, A = any> = {
+    /** Forcefully replace the value at this path, ignoring equality checks. Records history. */
+    _set: (value: T) => void;
+    /** Smart update: only commits the change if the value is different. */
+    _patch: (value: T) => void;
+    /** Unwraps the proxy and returns the raw value at this specific tree path. */
+    _val: T;
+    /** Access all actions defined in this flow */
+    __actions__: BoundActions<A>;
+    /** Persistence control (provided by persist plugin) */
+    _persist?: {
+        clear: () => void;
+        update: () => void;
+        refresh: () => Promise<void>;
+    };
+};
+/** Operations specific to numeric values */
+type NumberOps<A = any> = BaseOps<number, A> & {
+    /** Increment by n (default 1) */
+    _increment: (n?: number) => void;
+    /** Decrement by n (default 1) */
+    _decrement: (n?: number) => void;
+    /** Add n to the value */
+    _add: (n: number) => void;
+    /** Subtract n from the value */
+    _subtract: (n: number) => void;
+    /** Multiply the value by n */
+    _multiply: (n: number) => void;
+    /** Divide the value by n */
+    _divide: (n: number) => void;
+};
+/** Operations specific to string values */
+type StringOps<A = any> = BaseOps<string, A> & {
+    /** Append a string at the end */
+    _append: (s: string) => void;
+    /** Prepend a string at the beginning */
+    _prepend: (s: string) => void;
+    /** Convert value to uppercase */
+    _uppercase: () => void;
+    /** Convert value to lowercase */
+    _lowercase: () => void;
+    /** Trim whitespace from both ends */
+    _trim: () => void;
+    /** Replace occurrences matching pattern */
+    _replace: (pattern: string | RegExp, replacement: string) => void;
+};
+/** Operations specific to array values */
+type ArrayOps<T, A = any> = BaseOps<T[], A> & {
+    /** Add an item to the end of the array */
+    _push: (v: T) => void;
+    /** Remove and return the last item */
+    _pop: () => void;
+    /** Remove and return the first item */
+    _shift: () => void;
+    /** Add an item to the beginning of the array */
+    _unshift: (v: T) => void;
+    /** Keep only items matching the condition */
+    _filter: (fn: (v: T, i: number) => boolean) => void;
+    /** Transform every item in the array */
+    _map: (fn: (v: T, i: number) => T) => void;
+    /** Remove item at a specific index */
+    _removeAt: (i: number) => void;
+    /** Insert an item at a specific index */
+    _insertAt: (i: number, v: T) => void;
+};
+/** Operations specific to object values */
+type ObjectOps<T, A = any> = BaseOps<T, A> & {
+    /** Shallow merge the provided object into the current state */
+    _merge: (p: Partial<NonNullable<T>>) => void;
+    /** Remove a specific key from the object */
+    _delete: (k: keyof NonNullable<T>) => void;
+} & {
+    [K in keyof NonNullable<T>]-?: TypeAwareOps<NonNullable<T>[K], A>;
+};
+type BooleanOps<A = any> = BaseOps<boolean, A> & {
+    _toggle: () => void;
+};
+
+export type { ArrayOps as A, BaseOps as B, DerivedFlowDefinition as D, FlowDefinition as F, NumberOps as N, ObjectOps as O, StringOps as S, TypeAwareOps as T, UseFlowOptions as U, FlowOpsObject as a, FlowOptions as b, FlowOperations as c, BooleanOps as d, BoundActions as e, FlowAction as f, FlowEffect as g, FlowPlugin as h };

package/package.json

@@ -112,5 +112,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "4.2.1"
+  "version": "4.3.2"
 }