mates-devtools 0.1.0-beta.1

package/dist/types/lib/actions/animateSwap.d.ts

@@ -0,0 +1,79 @@
+import type { AnimationPreset } from "./animateTypes";
+/**
+ * Animate an element with a given preset. Cancels any in-flight
+ * animations on the element first.
+ *
+ * Returns a promise that resolves when the animation finishes or is cancelled.
+ */
+export declare function animateContainer(el: HTMLElement, preset: AnimationPreset): Promise<void>;
+/**
+ * Wait two animation frames so lit-html has committed any pending
+ * template updates to the DOM before we read element geometry or
+ * start a new animation.
+ */
+export declare function nextFrame(): Promise<void>;
+/**
+ * Configuration for a single `animateSwap` call.
+ */
+export interface AnimateSwapConfig {
+    /**
+     * The wrapper element to animate.
+     * When `null`/`undefined`, the swap runs immediately with no animation.
+     */
+    el: HTMLElement | null | undefined;
+    /** Animation preset played on the wrapper *before* the swap. */
+    exit: AnimationPreset;
+    /** Animation preset played on the wrapper *after* the swap. */
+    enter: AnimationPreset;
+    /**
+     * Called between exit and enter — this is where you update the atom /
+     * state that drives what is rendered inside the wrapper.
+     */
+    swap: () => void;
+    /**
+     * Optional: re-resolve the wrapper element after the swap.
+     * Useful when the swap replaces the wrapper itself (e.g. a new `<div>`
+     * rendered by lit-html). When omitted the original `el` is reused.
+     */
+    getEl?: () => HTMLElement | null | undefined;
+    /**
+     * Optional staleness guard. Called after exit and after swap — if it
+     * returns `true` the sequence aborts early. Use this to bail out when
+     * a newer swap has been requested while this one was in flight.
+     *
+     * @example
+     * ```ts
+     * isStale: () => nextRoute.get() !== targetRoute
+     * ```
+     */
+    isStale?: () => boolean;
+}
+/**
+ * Orchestrates the exit → swap → enter animation sequence.
+ *
+ * 1. Play `exit` on `el`.
+ * 2. Call `swap()` — the caller updates state so the template re-renders.
+ * 3. Wait one double-rAF (`nextFrame`) so lit-html commits the new DOM.
+ * 4. Play `enter` on the (possibly new) wrapper element.
+ *
+ * At steps 2 and 4 the optional `isStale()` guard is checked — if it
+ * returns `true` the sequence stops, letting a newer transition take over.
+ *
+ * If `el` is `null`/`undefined`, steps 1 and 3–4 are skipped and
+ * `swap()` is called immediately.
+ *
+ * @example
+ * ```ts
+ * // Inside an effect that watches `nextRoute`:
+ * await animateSwap({
+ *   el: wrapperRef.value,
+ *   exit: current?.exit ?? fadeOutPreset(200),
+ *   enter: next?.enter ?? fadeInPreset(250),
+ *   swap: () => currentRoute.set(next),
+ *   getEl: () => wrapperRef.value,
+ *   isStale: () => nextRoute.get() !== next,
+ * });
+ * ```
+ */
+export declare function animateSwap(config: AnimateSwapConfig): Promise<void>;
+//# sourceMappingURL=animateSwap.d.ts.map

package/dist/types/lib/actions/animateSwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animateSwap.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/animateSwap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOtD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,WAAW,EACf,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAOzC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,EAAE,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IAEnC,gEAAgE;IAChE,IAAI,EAAE,eAAe,CAAC;IAEtB,+DAA+D;IAC/D,KAAK,EAAE,eAAe,CAAC;IAEvB;;;OAGG;IACH,IAAI,EAAE,MAAM,IAAI,CAAC;IAEjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IAE7C;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B1E"}

package/dist/types/lib/actions/animateTypes.d.ts

@@ -0,0 +1,103 @@
+import type { AtomType } from "../Mutables/atom/atom";
+/**
+ * Keyframe definition — maps directly to the Web Animations API `Keyframe` type.
+ */
+export type AnimateKeyframes = Keyframe[] | PropertyIndexedKeyframes;
+/**
+ * Animation timing options — maps to `KeyframeAnimationOptions` from the
+ * Web Animations API, with sensible defaults layered on top.
+ */
+export interface AnimateOptions extends KeyframeAnimationOptions {
+    /** Duration in milliseconds. Defaults to 300. */
+    duration?: number;
+    /** CSS easing string. Defaults to "ease". */
+    easing?: string;
+    /** Fill mode. Defaults to "both". */
+    fill?: FillMode;
+}
+/**
+ * How to supply the target element — directly, via a Ref, or via a lazy getter.
+ */
+export type ElementTarget = Element | {
+    value?: Element | undefined;
+} | (() => Element | null | undefined);
+/**
+ * The handle returned by `animate()`.
+ *
+ * A lightweight, stateful animation controller backed by the Web Animations API.
+ * Only exposes what you need: start/stop controls, a single reactive `isRunning`
+ * atom, and re-configuration helpers.
+ *
+ * @example
+ * ```ts
+ * const { start, stop, isRunning } = animate(
+ *   boxRef,
+ *   [{ opacity: 0 }, { opacity: 1 }],
+ *   { duration: 400 },
+ *   () => console.log("started"),
+ *   () => console.log("ended"),
+ * );
+ *
+ * start();          // plays (cancels any previous run)
+ * stop();           // cancels entirely
+ * isRunning();      // true while playing
+ * pause();
+ * resume();
+ * reverse();
+ * finish();         // jumps to end state
+ * ```
+ */
+export interface AnimationHandle {
+    /** Play the animation. Auto-cancels any in-flight run. */
+    start: () => void;
+    /** Cancel the animation entirely. */
+    stop: () => void;
+    /** Pause a running animation. */
+    pause: () => void;
+    /** Resume a paused animation. */
+    resume: () => void;
+    /** Reverse the playback direction. */
+    reverse: () => void;
+    /** Jump to the end state immediately. */
+    finish: () => void;
+    /** Atom: `true` while the animation is running. */
+    isRunning: AtomType<boolean>;
+    /** The current Web Animations API `Animation` instance, or `null` if idle. */
+    readonly currentAnimation: Animation | null;
+    /** The current playback state of the underlying animation. */
+    readonly playState: AnimationPlayState | "idle";
+    /** Replace the target element after creation. */
+    setElement: (el: ElementTarget) => void;
+    /** Replace the keyframes after creation. */
+    setKeyframes: (keyframes: AnimateKeyframes) => void;
+    /** Merge new options into the current options. */
+    setOptions: (options: AnimateOptions) => void;
+}
+/**
+ * Configuration for the `animateDirective` lit-html directive.
+ */
+export interface AnimateDirectiveConfig {
+    /** Keyframes to animate */
+    keyframes: AnimateKeyframes;
+    /** Animation options (duration, easing, fill, etc.) */
+    options?: AnimateOptions;
+    /**
+     * When true, the animation plays immediately when the directive
+     * is first applied or when this value transitions from false→true.
+     * Defaults to true.
+     */
+    play?: boolean;
+    /** Callback fired when the animation starts. */
+    onStart?: () => void;
+    /** Callback fired when the animation ends (finished or cancelled). */
+    onEnd?: () => void;
+}
+/**
+ * Preset animation factories — convenience functions that return
+ * `{ keyframes, options }` pairs ready to spread into `animate()`.
+ */
+export interface AnimationPreset {
+    keyframes: AnimateKeyframes;
+    options: AnimateOptions;
+}
+//# sourceMappingURL=animateTypes.d.ts.map

package/dist/types/lib/actions/animateTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animateTypes.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/animateTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,EAAE,GAAG,wBAAwB,CAAC;AAErE;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,wBAAwB;IAC9D,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,OAAO,GACP;IAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,GAC/B,CAAC,MAAM,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAIvC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,eAAe;IAC9B,0DAA0D;IAC1D,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,qCAAqC;IACrC,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,iCAAiC;IACjC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,iCAAiC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,sCAAsC;IACtC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,yCAAyC;IACzC,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB,mDAAmD;IACnD,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAE7B,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5C,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,MAAM,CAAC;IAEhD,iDAAiD;IACjD,UAAU,EAAE,CAAC,EAAE,EAAE,aAAa,KAAK,IAAI,CAAC;IACxC,4CAA4C;IAC5C,YAAY,EAAE,CAAC,SAAS,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACpD,kDAAkD;IAClD,UAAU,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;CAC/C;AAID;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,uDAAuD;IACvD,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACpB;AAID;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,OAAO,EAAE,cAAc,CAAC;CACzB"}

package/dist/types/lib/actions/asyncAction.d.ts

@@ -0,0 +1,4 @@
+import type { AsyncActionOptions, AsyncActionReturnType } from "./asyncActionTypes";
+export type { AsyncActionAfterInterceptor, AsyncActionBeforeInterceptor, AsyncActionOptions, AsyncActionReturnType, AsyncActionStatus, } from "./asyncActionTypes";
+export declare function asyncAction<T extends (...args: any[]) => Promise<any>>(AsyncFn: T, options?: AsyncActionOptions): AsyncActionReturnType<T>;
+//# sourceMappingURL=asyncAction.d.ts.map

package/dist/types/lib/actions/asyncAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncAction.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/asyncAction.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAGV,kBAAkB,EAClB,qBAAqB,EAGtB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAK5B,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EACpE,OAAO,EAAE,CAAC,EACV,OAAO,CAAC,EAAE,kBAAkB,GAC3B,qBAAqB,CAAC,CAAC,CAAC,CAmO1B"}

package/dist/types/lib/actions/asyncActionCache.d.ts

@@ -0,0 +1,16 @@
+import type { AtomType } from "../Mutables/atom/atom";
+import type { AsyncActionOptions, AsyncActionStatus } from "./asyncActionTypes";
+/**
+ * Cache manager interface for async actions
+ */
+export interface CacheManager<T extends (...args: any[]) => Promise<any>> {
+    getCacheKey: (args: Parameters<T>) => string;
+    removeCacheEntry: (cacheKey: string) => void;
+    createCacheMethod: (dataAtom: AtomType<Awaited<ReturnType<T>> | null>, errorAtom: AtomType<Error | null>, statusAtom: AtomType<AsyncActionStatus>, executeAction: (context: any, args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>) => T;
+    createClearCacheMethod: () => (...args: any[]) => void;
+}
+/**
+ * Creates a cache manager for async actions with LRU eviction and expiration support
+ */
+export declare function createCacheManager<T extends (...args: any[]) => Promise<any>>(options?: AsyncActionOptions): CacheManager<T>;
+//# sourceMappingURL=asyncActionCache.d.ts.map

package/dist/types/lib/actions/asyncActionCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncActionCache.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/asyncActionCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC;IACtE,WAAW,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;IAC7C,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,iBAAiB,EAAE,CACjB,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EACjD,SAAS,EAAE,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,EACjC,UAAU,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACvC,aAAa,EAAE,CACb,OAAO,EAAE,GAAG,EACZ,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAChB,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,KACjC,CAAC,CAAC;IACP,sBAAsB,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACxD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAC3E,OAAO,CAAC,EAAE,kBAAkB,GAC3B,YAAY,CAAC,CAAC,CAAC,CAwFjB"}

package/dist/types/lib/actions/asyncActionPolling.d.ts

@@ -0,0 +1,14 @@
+import type { AsyncActionOptions } from "./asyncActionTypes";
+/**
+ * Polling manager interface for async actions
+ */
+export interface PollingManager<T extends (...args: any[]) => Promise<any>> {
+    createStartPollingMethod: (wrapperFn: T) => (...args: Parameters<T>) => void;
+    createStopPollingMethod: () => () => void;
+    stopPolling: () => void;
+}
+/**
+ * Creates a polling manager for async actions with configurable intervals
+ */
+export declare function createPollingManager<T extends (...args: any[]) => Promise<any>>(options?: AsyncActionOptions): PollingManager<T>;
+//# sourceMappingURL=asyncActionPolling.d.ts.map

package/dist/types/lib/actions/asyncActionPolling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncActionPolling.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/asyncActionPolling.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC;IACxE,wBAAwB,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAC7E,uBAAuB,EAAE,MAAM,MAAM,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAC1C,OAAO,CAAC,EAAE,kBAAkB,GAAG,cAAc,CAAC,CAAC,CAAC,CAwCjD"}

package/dist/types/lib/actions/asyncActionTypes.d.ts

@@ -0,0 +1,74 @@
+import type { AtomType } from "../Mutables/atom/atom";
+/**
+ * Represents the current status of an async action
+ */
+export type AsyncActionStatus = "init" | "loading" | "success" | "error";
+/**
+ * Configuration options for async actions
+ */
+export type AsyncFetchOptions = {
+    /** Cache duration in milliseconds. Default: undefined (infinite — cache never expires) */
+    cacheDuration?: number;
+    /** Maximum number of cache entries. Uses LRU eviction when exceeded. Default: 10 */
+    cacheLimit?: number;
+    /** Polling interval in milliseconds. Default: 5000 */
+    pollInterval?: number;
+    allowInRestrictedContext?: boolean;
+};
+/**
+ * Interceptor called before the async action executes.
+ * Receives `next` (the original fn) and the call arguments.
+ * Must call `next` and return its result.
+ */
+export type AsyncActionBeforeInterceptor<T extends (...args: any[]) => Promise<any>> = (next: T, ...args: Parameters<T>) => ReturnType<T>;
+/**
+ * Interceptor called after the async action resolves.
+ * Receives the resolved result and must return a (possibly modified) result.
+ */
+export type AsyncActionAfterInterceptor<T extends (...args: any[]) => Promise<any>> = (result: Awaited<ReturnType<T>>) => Awaited<ReturnType<T>>;
+/**
+ * Return type for asyncAction - combines the original function with state management
+ */
+export type AsyncActionReturnType<T extends (...args: any[]) => Promise<any>> = T & {
+    /** Atom containing the result data */
+    data: AtomType<Awaited<ReturnType<T>> | null>;
+    /** Atom containing any error that occurred */
+    error: AtomType<Error | null>;
+    /** Atom indicating if action is currently loading */
+    isLoading: AtomType<boolean>;
+    /** Atom containing current action status */
+    status: AtomType<AsyncActionStatus>;
+    /** The AbortController for the current in-flight operation, or null if idle */
+    abortController: AbortController | null;
+    /** Get the underlying action function */
+    val: () => T;
+    /** Replace the action function */
+    set: (fn: T) => void;
+    /** Cancel the current operation */
+    cancel: () => void;
+    /** Subscribe to action completion events */
+    subscribe: (fn: () => void, onSuccessOrError?: boolean) => () => void;
+    /** Call action and cache the result */
+    cache: T;
+    /** Clear cached results */
+    clearCache: (...args: any[]) => void;
+    /** Start polling with given arguments */
+    startPolling: (...args: Parameters<T>) => void;
+    /** Stop polling */
+    stopPolling: () => void;
+    /** Set a before-interceptor */
+    interceptBefore: (interceptor: AsyncActionBeforeInterceptor<T>) => void;
+    /** Set an after-interceptor */
+    interceptAfter: (interceptor: AsyncActionAfterInterceptor<T>) => void;
+};
+/**
+ * Subscriber configuration for async action events
+ */
+export type Subscriber = {
+    /** Callback function to execute */
+    fn: () => void;
+    /** Filter: true = success only, false = error only, undefined = both */
+    filter?: boolean;
+};
+export type AsyncActionOptions = AsyncFetchOptions;
+//# sourceMappingURL=asyncActionTypes.d.ts.map

package/dist/types/lib/actions/asyncActionTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncActionTypes.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/asyncActionTypes.ts"],"names":[],"mappings":"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"}

package/dist/types/lib/actions/createTimingFunction.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared state and methods for timing functions (debounce/throttle)
+ */
+export declare class TimingFunctionState<T extends (...args: any[]) => any> {
+    timeoutId: ReturnType<typeof setTimeout> | null;
+    lastResult: ReturnType<T> | undefined;
+    pendingArgs: Parameters<T> | null;
+    pendingContext: any;
+    clearPending(): void;
+    setPending(args: Parameters<T>, context: any): void;
+    clearTimer(): void;
+    setTimer(callback: () => void, delay: number): void;
+    executePending(func: T): ReturnType<T> | undefined;
+}
+/**
+ * Creates cancel method for timing functions
+ */
+export declare function createCancelMethod<T extends (...args: any[]) => any>(state: TimingFunctionState<T>, onCancel?: () => void): () => void;
+/**
+ * Creates flush method for timing functions
+ */
+export declare function createFlushMethod<T extends (...args: any[]) => any>(state: TimingFunctionState<T>, func: T): () => ReturnType<T> | undefined;
+//# sourceMappingURL=createTimingFunction.d.ts.map

package/dist/types/lib/actions/createTimingFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTimingFunction.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/createTimingFunction.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,mBAAmB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;IAChE,SAAS,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAQ;IACvD,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACtC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IACzC,cAAc,EAAE,GAAG,CAAQ;IAE3B,YAAY,IAAI,IAAI;IAKpB,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI;IAKnD,UAAU,IAAI,IAAI;IAOlB,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAInD,cAAc,CAAC,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS;CAOnD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAClE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC7B,QAAQ,CAAC,EAAE,MAAM,IAAI,GACpB,MAAM,IAAI,CAMZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACjE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC7B,IAAI,EAAE,CAAC,GACN,MAAM,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CASjC"}

package/dist/types/lib/actions/debounce.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a debounced function that delays invoking func until after wait milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ * Similar to lodash debounce.
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): T & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+};
+//# sourceMappingURL=debounce.d.ts.map

package/dist/types/lib/actions/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/debounce.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;CAAE,CAmBpE"}

package/dist/types/lib/actions/index.d.ts

@@ -0,0 +1,12 @@
+export { type ActionAfterInterceptor, type ActionBeforeInterceptor, type ActionFn, type ActionReturnType, type ActionSubscriber, action, } from "./action";
+export { blurInPreset, blurOutPreset, bouncePreset, collapseWidthPreset, expandWidthPreset, fadeInPreset, fadeOutPreset, flipInPreset, flipOutPreset, pulsePreset, type SlideDirection, scaleInPreset, scaleOutPreset, shakePreset, slideInPreset, slideOutPreset, spinPreset, springInPreset, withStaggerPreset, } from "./animatePresets";
+export type { AnimateDirectiveConfig, AnimateKeyframes, AnimateOptions, AnimationHandle, AnimationPreset, ElementTarget, } from "./animateTypes";
+export { type AsyncActionAfterInterceptor, type AsyncActionBeforeInterceptor, type AsyncActionOptions, type AsyncActionReturnType, type AsyncActionStatus, asyncAction, } from "./asyncAction";
+export { type CacheManager, createCacheManager, createCacheManager as cache, } from "./asyncActionCache";
+export { createPollingManager, type PollingManager, } from "./asyncActionPolling";
+export { debounce } from "./debounce";
+export { type PaginatedAsyncActionReturnType, paginatedAsyncAction, } from "./paginatedAsyncAction";
+export { type Task, type TaskActionType, type TaskStatus, taskAction, } from "./taskAction";
+export { throttle } from "./throttle";
+export { deleteAction, type FetchActionConfig, type FetchBody, fetchAction, getAction, patchAction, postAction, putAction, } from "../Fetch/Fetch";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,MAAM,GACP,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,EACb,WAAW,EACX,KAAK,cAAc,EACnB,aAAa,EACb,cAAc,EACd,WAAW,EACX,aAAa,EACb,cAAc,EACd,UAAU,EACV,cAAc,EACd,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,YAAY,EACjB,kBAAkB,EAClB,kBAAkB,IAAI,KAAK,GAC5B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,KAAK,8BAA8B,EACnC,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,IAAI,EACT,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,UAAU,GACX,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAKtC,OAAO,EACL,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACd,WAAW,EACX,SAAS,EACT,WAAW,EACX,UAAU,EACV,SAAS,GACV,MAAM,gBAAgB,CAAC"}

package/dist/types/lib/actions/paginatedAsyncAction.d.ts

@@ -0,0 +1,121 @@
+import type { AtomType } from "../Mutables/atom/atom";
+import type { AsyncActionOptions, AsyncActionReturnType } from "./asyncActionTypes";
+/**
+ * Everything `asyncAction` returns, plus a `page` atom and a `next()` method.
+ *
+ * @template T - The wrapped async function type.
+ */
+export type PaginatedAsyncActionReturnType<T extends (...args: any[]) => Promise<any>> = AsyncActionReturnType<T> & {
+    /**
+     * Total number of pages.
+     *
+     * Default is `-1`, meaning unknown. Set it from the API response:
+     *
+     * ```ts
+     * const fetchPosts = paginatedAsyncAction(async () => {
+     *   const res  = await fetch(`/api/posts?page=${fetchPosts.page.val}`);
+     *   const json = await res.json();
+     *   fetchPosts.totalPages.set(json.totalPages);
+     *   return json.items;
+     * });
+     * ```
+     *
+     * When `-1`, `next()` always proceeds (we don't know the limit yet).
+     * Once set, `next()` becomes a no-op when `page >= totalPages`.
+     */
+    totalPages: AtomType<number>;
+    /**
+     * Current page number (1-based).
+     *
+     * It is a plain atom — use `.val` to read, `.set()` / `.update()` to write:
+     *
+     * ```ts
+     * action.page.val        // read
+     * action.page.set(1)     // reset to first page
+     * action.page.set(n)     // jump to any page
+     * ```
+     *
+     * Read it from inside the async callback via closure:
+     *
+     * ```ts
+     * const fetchPosts = paginatedAsyncAction(async () => {
+     *   const page = fetchPosts.page.val;
+     *   const res  = await fetch(`/api/posts?page=${page}`);
+     *   return res.json();
+     * });
+     * ```
+     */
+    page: AtomType<number>;
+    /**
+     * Increment `page` by 1 then call the action with the provided arguments.
+     *
+     * Has the same signature as the wrapped async function so any arguments
+     * the action accepts can be passed straight through:
+     *
+     * ```ts
+     * fetchPosts.next();           // 0-arg action
+     * fetchUserPosts.next(userId); // 1-arg action
+     * ```
+     */
+    next: (...args: Parameters<T>) => ReturnType<T> | undefined;
+};
+/**
+ * `paginatedAsyncAction` — an `asyncAction` with a `page` atom and a `next()`
+ * method for simple pagination.
+ *
+ * The wrapped callback reads the current page via closure rather than receiving
+ * it as a parameter, keeping the function signature clean for any other
+ * arguments the action needs.
+ *
+ * ---
+ *
+ * ### Usage
+ *
+ * ```ts
+ * const fetchPosts = paginatedAsyncAction(async () => {
+ *   const page = fetchPosts.page.val;   // ← closure access
+ *   const res  = await fetch(`/api/posts?_page=${page}&_limit=10`);
+ *   return res.json();
+ * });
+ *
+ * // Load first page on mount
+ * fetchPosts();
+ *
+ * // Advance to next page (e.g. on button click or onVisible sentinel)
+ * fetchPosts.next();
+ *
+ * // Reset to page 1 manually
+ * fetchPosts.page.set(1);
+ * fetchPosts();
+ * ```
+ *
+ * ### With extra arguments
+ *
+ * ```ts
+ * const fetchUserPosts = paginatedAsyncAction(async (userId: number) => {
+ *   const page = fetchUserPosts.page.val;
+ *   const res  = await fetch(`/api/users/${userId}/posts?page=${page}`);
+ *   return res.json();
+ * });
+ *
+ * fetchUserPosts(5);         // userId = 5, page = 1
+ * fetchUserPosts.next(5);    // userId = 5, page = 2
+ * fetchUserPosts.next(5);    // userId = 5, page = 3
+ * fetchUserPosts.page.set(1) // back to page 1
+ * fetchUserPosts(5);         // reload page 1
+ * ```
+ *
+ * ### Infinite scroll sentinel
+ *
+ * ```ts
+ * html`
+ *   ${fetchPosts.data.val?.map(p => html`<li>${p.title}</li>`)}
+ *   <div ${onVisible(() => fetchPosts.next())}></div>
+ * `
+ * ```
+ *
+ * @param fn      - Async function. Read `action.page.val` inside via closure.
+ * @param options - Forwarded to the underlying `asyncAction`.
+ */
+export declare function paginatedAsyncAction<T extends (...args: any[]) => Promise<any>>(fn: T, options?: AsyncActionOptions): PaginatedAsyncActionReturnType<T>;
+//# sourceMappingURL=paginatedAsyncAction.d.ts.map

package/dist/types/lib/actions/paginatedAsyncAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginatedAsyncAction.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/paginatedAsyncAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,oBAAoB,CAAC;AAI5B;;;;GAIG;AACH,MAAM,MAAM,8BAA8B,CACxC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,IACxC,qBAAqB,CAAC,CAAC,CAAC,GAAG;IAC7B;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE7B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAEvB;;;;;;;;;;OAUG;IACH,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CAC7D,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAC1C,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,8BAA8B,CAAC,CAAC,CAAC,CAoCxE"}

package/dist/types/lib/actions/taskAction.d.ts

@@ -0,0 +1,105 @@
+import type { AtomType } from "../Mutables/atom/atom";
+export type TaskStatus = "pending" | "running" | "success" | "failed" | "cancelled";
+export type Task<TInput, TOutput> = {
+    /** Auto-incrementing integer, unique within this taskAction instance. */
+    id: number;
+    /** The value originally passed to add(). */
+    input: TInput;
+    status: TaskStatus;
+    result: {
+        data: TOutput | null;
+        error: Error | null;
+    };
+    /**
+     * Live AbortController while the task is running.
+     * For ZeroPromise-based callbacks this is a synthetic wrapper that
+     * routes .abort() to zp.cancel() and exposes zp.signal.
+     * null when the task is pending, settled, or cancelled.
+     */
+    abortController: AbortController | null;
+};
+export type TaskActionType<TInput, TOutput> = {
+    /**
+     * Append one task or an array of tasks to the list.
+     *
+     * If the session is currently running and a concurrency slot is free the
+     * task(s) are launched immediately. Otherwise they sit as "pending" until
+     * the next available slot (or until start() is called).
+     */
+    add(input: TInput | TInput[]): void;
+    /**
+     * Begin (or resume) processing.
+     *
+     * concurrency controls how many tasks run at the same time:
+     *   1   → one at a time (queue / serial mode)   [default]
+     *   N   → up to N tasks concurrently
+     *  -1   → all pending tasks at once
+     *
+     * No-op if the session is already running.
+     */
+    start(concurrency?: number): void;
+    /**
+     * Soft pause — running tasks are allowed to finish, but once the current
+     * batch settles no new tasks are launched. The session transitions to idle
+     * after the last in-flight task settles. Call start() to resume.
+     */
+    pause(): void;
+    /**
+     * Hard stop — immediately cancels every running task (marks them
+     * "cancelled" and aborts their signal), then transitions to idle.
+     * Pending tasks remain in the list. Call start() to resume.
+     */
+    stop(): void;
+    /**
+     * Remove one or more tasks by identity.
+     * If a matched task is currently running it is cancelled first.
+     */
+    delete(task: Task<TInput, TOutput> | Task<TInput, TOutput>[]): void;
+    /**
+     * stop() + clear the whole task list + add fresh tasks.
+     * Does NOT automatically call start() — the caller decides when to start.
+     */
+    clearAndAdd(input: TInput | TInput[]): void;
+    /**
+     * add() + start() if not already running.
+     * If already running the tasks are simply appended (and launched immediately
+     * if a slot is free).
+     */
+    addAndStart(input: TInput | TInput[], concurrency?: number): void;
+    /**
+     * stop() + clearAndAdd() + start() in one call.
+     * Replaces the entire task list and immediately begins processing.
+     */
+    clearAndStart(input: TInput | TInput[], concurrency?: number): void;
+    /**
+     * Returns true while the session status is "running".
+     * Reads from a reactive atom — reactive when called inside a template or
+     * effect.
+     */
+    isRunning(): boolean;
+    /**
+     * Reactive progress atom (0 – 100).
+     *
+     * Progress formula per task:
+     *   pending   →  0 points
+     *   running   →  0.5 points  (picked up = halfway there)
+     *   settled   →  1 point     (success | failed | cancelled)
+     *
+     * progress = (Σ points / total tasks) × 100, rounded to nearest integer.
+     * Returns 0 when the task list is empty.
+     */
+    progress: AtomType<number>;
+    /**
+     * Atom containing every task regardless of status, in insertion order.
+     * All derived getters and the progress atom derive from this.
+     */
+    tasks: AtomType<Task<TInput, TOutput>[]>;
+    pendingTasks(): Task<TInput, TOutput>[];
+    runningTasks(): Task<TInput, TOutput>[];
+    successTasks(): Task<TInput, TOutput>[];
+    failedTasks(): Task<TInput, TOutput>[];
+    cancelledTasks(): Task<TInput, TOutput>[];
+    __isTaskAction__: true;
+};
+export declare function taskAction<TInput, TOutput>(cb: (input: TInput, signal: AbortSignal) => Promise<TOutput>): TaskActionType<TInput, TOutput>;
+//# sourceMappingURL=taskAction.d.ts.map

package/dist/types/lib/actions/taskAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskAction.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/taskAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAQtD,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,SAAS,GACT,SAAS,GACT,QAAQ,GACR,WAAW,CAAC;AAEhB,MAAM,MAAM,IAAI,CAAC,MAAM,EAAE,OAAO,IAAI;IAClC,yEAAyE;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE;QACN,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;QACrB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;KACrB,CAAC;IACF;;;;;OAKG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,MAAM,EAAE,OAAO,IAAI;IAG5C;;;;;;OAMG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;IAEpC;;;;;;;;;OASG;IACH,KAAK,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC;;;;OAIG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;OAIG;IACH,IAAI,IAAI,IAAI,CAAC;IAEb;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC;IAEpE;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;IAE5C;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAElE;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAIpE;;;;OAIG;IACH,SAAS,IAAI,OAAO,CAAC;IAErB;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAI3B;;;OAGG;IACH,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAMzC,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACxC,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACxC,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACxC,WAAW,IAAI,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACvC,cAAc,IAAI,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAG1C,gBAAgB,EAAE,IAAI,CAAC;CACxB,CAAC;AAIF,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,EACxC,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,GAC3D,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CA6UjC"}

package/dist/types/lib/actions/throttle.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a throttled function that only invokes func at most once per every wait milliseconds.
+ * Similar to lodash throttle.
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number): T & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+};
+//# sourceMappingURL=throttle.d.ts.map

package/dist/types/lib/actions/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../../../../lib/actions/throttle.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;CAAE,CAqCpE"}