@but212/atom-effect-jquery 0.30.1 → 0.32.0

package/dist/index.d.ts

@@ -1,232 +1,30 @@
-import { ComputedAtom } from '@but212/atom-effect';
-import { default as default_2 } from 'jquery';
-import { EffectObject } from '@but212/atom-effect';
-import { ReadonlyAtom } from '@but212/atom-effect';
-import { WritableAtom } from '@but212/atom-effect';
-
-/**
- * An extension of ReactiveValue that also supports Promises and async functions.
- * The binding system automatically handles the promise lifecycle, showing the
- * latest resolved value and ignoring stale ones (race condition protection).
- */
-declare type AsyncReactiveValue<T> = T | ReadonlyAtom<T | Promise<T>> | Promise<T> | (() => T | Promise<T>);
-
-export declare interface BindingOptions<T = unknown> {
-    text?: AsyncReactiveValue<unknown> | [source: AsyncReactiveValue<unknown>, formatter: (v: unknown) => string];
-    html?: AsyncReactiveValue<string>;
-    class?: Record<string, AsyncReactiveValue<boolean>>;
-    css?: CssBindings;
-    attr?: Record<string, AsyncReactiveValue<PrimitiveValue>>;
-    prop?: Record<string, AsyncReactiveValue<unknown>>;
-    show?: AsyncReactiveValue<boolean>;
-    hide?: AsyncReactiveValue<boolean>;
-    val?: WritableAtom<T> | [atom: WritableAtom<T>, options: ValOptions<T>];
-    checked?: WritableAtom<boolean>;
-    form?: WritableAtom<T extends object ? T : unknown> | [
-    atom: WritableAtom<T extends object ? T : unknown>,
-    options: FormOptions<T extends object ? T : unknown>
-    ];
-    on?: Record<string, (e: JQuery.Event) => void>;
-}
-
-/**
- * Central registry mapping DOM elements to their reactive binding records.
- *
- * Design goals:
- * - Zero memory leaks: all collections use WeakMap/WeakSet keyed by Element.
- * - Minimal allocations in the hot tracking path.
- * - O(bound-descendants) cleanup via a single querySelectorAll pass.
- */
-declare class BindingRegistry {
-    private records;
-    private preservedNodes;
-    private ignoredNodes;
-    keep(node: Node): void;
-    isKept(node: Node): boolean;
-    markIgnored(node: Node): void;
-    isIgnored(node: Node): boolean;
-    private getOrCreateRecord;
-    /**
-     * Registers a reactive effect with an element's record.
-     * Effects are automatically disposed when the element is removed from the DOM.
-     *
-     * @param el - The DOM element to bind the effect to.
-     * @param fx - The reactive effect instance.
-     */
-    trackEffect(el: Element, fx: EffectObject): void;
-    /**
-     * Registers an arbitrary cleanup function with an element's record.
-     * Cleanups are executed when the element is removed from the DOM.
-     *
-     * @param el - The DOM element to bind the cleanup to.
-     * @param fn - The cleanup function (e.g., event unbinding, timer clear).
-     */
-    trackCleanup(el: Element, fn: () => void): void;
-    /**
-     * Assigns a component-level cleanup function (e.g., from atomMount).
-     * Unlike generic cleanups, there can only be one component cleanup per element.
-     */
-    setComponentCleanup(el: Element, fn: (() => void) | undefined): void;
-    hasBind(el: Element): boolean;
-    cleanup(el: Node): void;
-    cleanupDescendants(el: Element | DocumentFragment | ShadowRoot): void;
-    cleanupTree(el: Node): void;
-}
-
-export declare type ComponentFn<P = Record<string, unknown>> = ($el: JQuery, props: P) => EffectResult;
-
-export { ComputedAtom }
-
-export declare type CssBindings = Record<string, CssValue>;
-
-export declare type CssValue = AsyncReactiveValue<string | number> | [source: AsyncReactiveValue<number>, unit: string];
-
-export default default_2;
-
-/**
- * Stops all MutationObservers started by `enableAutoCleanup`.
- */
-export declare function disableAutoCleanup(): void;
-
-/**
- * Restores all jQuery methods patched by `enablejQueryOverrides()`.
- * Primarily useful in test environments to reset state between suites.
- */
-export declare function disablejQueryOverrides(): void;
-
-export declare type EffectCleanup = () => void;
-
-export declare type EffectResult = undefined | EffectCleanup;
-
-/**
- * Starts observing `root` for removed elements and automatically disposes
- * their reactive bindings when they leave the DOM.
- *
- * Supports Element, ShadowRoot, and DocumentFragment roots.
- * Multiple roots can be observed concurrently (e.g. for Micro-Frontends).
- */
-export declare function enableAutoCleanup(root: Element | ShadowRoot | DocumentFragment): void;
-
-export declare function enablejQueryOverrides(): void;
-
-export declare type EqualFn<T> = (a: T, b: T) => boolean;
-
-export declare interface FetchOptions<T> {
-    defaultValue: T;
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | (string & {});
-    headers?: Record<string, string>;
-    transform?: (raw: unknown) => T;
-    ajaxOptions?: JQuery.AjaxSettings | (() => JQuery.AjaxSettings);
-    onError?: (err: unknown) => void;
-    eager?: boolean;
-}
-
-/**
- * Options for `atomForm` binding.
- */
-declare interface FormOptions<T> extends ValOptions<T> {
-    /** Custom function to transform field value based on path before atomic sync. */
-    transform?: (path: string, value: unknown) => unknown;
-    /** Callback triggered when a field value changes. */
-    onChange?: (path: string, value: unknown) => void;
-}
-
-/** Checks if a given value is a reactive node (Atom or Computed). */
-export declare const isReactive: (v: unknown) => v is ReadonlyAtom<unknown>;
-
-declare type KeysOfType<T, V> = {
-    [K in keyof T]: T[K] extends V ? K : never;
-}[keyof T];
-
-declare type ListKey = string | number;
-
-declare type ListKeyFn<T> = (item: T, index: number) => ListKey;
-
-export declare interface ListOptions<T> {
-    key: KeysOfType<T, ListKey> | ListKeyFn<T>;
-    render: (item: T, index: number) => ListRenderResult;
-    bind?: ($el: JQuery, item: T, index: number) => void;
-    update?: ($el: JQuery, item: T, index: number) => void;
-    onAdd?: ($el: JQuery) => void;
-    onRemove?: ($el: JQuery) => Promise<void> | void;
-    empty?: ListRenderResult;
-    events?: Record<string, (item: T, index: number, e: JQuery.TriggeredEvent) => void>;
-    isEqual?: (a: T, b: T) => boolean;
-}
-
-declare type ListRenderResult = string | Element | DocumentFragment | JQuery;
-
-/** Resolves after microtask effects flush. Fast Promise-based scheduling. */
-export declare const nextTick: () => Promise<void>;
-
-export declare type PrimitiveValue = string | number | boolean | null | undefined;
-
-/**
- * Represents a value that can be tracked by the reactive system.
- * - T: Static value (one-time bind)
- * - ReadonlyAtom<T>: Reactive value (updates DOM when atom changes)
- * - () => T: Reactive function (updates DOM when any atom read inside changes)
- */
-export declare type ReactiveValue<T> = T | ReadonlyAtom<T> | (() => T);
-
-export { ReadonlyAtom }
-
-export declare const registry: BindingRegistry;
-
-export declare interface RenderRoute extends RouteLifecycle {
-    render: (container: HTMLElement, route: string, params: Record<string, string>, onUnmount: (cleanupFn: () => void) => void, router: Router) => void;
-    template?: never;
-}
-
-export declare interface RouteConfig {
-    target: string;
-    default: string;
-    routes: Record<string, RouteDefinition>;
-    mode?: 'hash' | 'history';
-    basePath?: string;
-    notFound?: string;
-    autoBindLinks?: boolean;
-    activeClass?: string;
-    beforeTransition?: (from: string, to: string) => void;
-    afterTransition?: (from: string, to: string) => void;
-}
-
-export declare type RouteDefinition = TemplateRoute | RenderRoute;
-
-export declare interface RouteLifecycle {
-    onEnter?: (params: Record<string, string>, router: Router) => Record<string, string> | undefined;
-    onLeave?: (router: Router) => boolean | undefined;
-}
-
-export declare interface Router {
-    currentRoute: ReadonlyAtom<string>;
-    queryParams: ReadonlyAtom<Record<string, string>>;
-    navigate: (route: string) => void;
-    destroy: () => void;
-}
-
-export declare interface TemplateRoute extends RouteLifecycle {
-    template: string;
-    render?: never;
-    onMount?: ($content: JQuery, onUnmount: (cleanupFn: () => void) => void, router: Router) => void;
-}
-
-/**
- * Options for `atomVal`, `atomChecked`, and `atomForm` bindings.
- */
-export declare interface ValOptions<T> {
-    /** Debounce duration in milliseconds for DOM -> Atom sync. Defaults to 0. */
-    debounce?: number;
-    /** jQuery event name(s) to listen to. Defaults to "input". */
-    event?: string;
-    /** Custom function to parse DOM string to atom type T. */
-    parse?: (v: string) => T;
-    /** Custom function to format atom type T to DOM string. */
-    format?: (v: T) => string;
-    /** Custom equality check to prevent redundant atom updates. */
-    equal?: EqualFn<T>;
-}
-
-export { WritableAtom }
-
-export { }
+import { default as $ } from 'jquery';
+import { AEJConfig } from './types';
+/**
+ * Initializes Atom-Effect jQuery with the specified configuration.
+ *
+ * This function resets the library's state according to the provided config.
+ * It is safe to call multiple times to reconfigure features at runtime.
+ *
+ * @param config - Configuration options.
+ *
+ * @warning If both `patch` and `autoCleanup` are set to `false`, you are
+ * responsible for calling `cleanup(element)` manually when
+ * elements are removed to prevent memory leaks.
+ */
+export declare function initAEJ(config?: AEJConfig): void;
+export { disablejQueryOverrides, enablejQueryOverrides } from './core/jquery-patch';
+export { disableAutoCleanup, enableAutoCleanup } from './core/registry';
+/**
+ * Performs a deep recursive cleanup on a node and its entire Shadow DOM subtrees.
+ *
+ * When to use:
+ * - Manually cleaning up an element that was removed from the DOM if autoCleanup is disabled.
+ * - Forcing a cleanup cycle on a specific container.
+ *
+ * @param element - The element to clean up.
+ */
+export declare function cleanup(element: HTMLElement | JQuery): void;
+export type { AtomComponentController, AtomNav, AtomNavOptions, BindingOptions, ComponentFn, ComputedAtom, CssBindings, CssValue, EffectCleanup, EffectResult, EqualFn, FetchError, FetchOptions, JQueryScopedSelector, ListOptions, PrimitiveValue, ReactiveValue, ReadonlyAtom, RouteConfig, RouteDefinition, RouteLifecycle, Router, ValOptions, WritableAtom, } from './types';
+export default $;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,kBAAkB,CAAC;AAC1B,OAAO,sBAAsB,CAAC;AAC9B,OAAO,iBAAiB,CAAC;AACzB,OAAO,kBAAkB,CAAC;AAC1B,OAAO,kBAAkB,CAAC;AAC1B,OAAO,kBAAkB,CAAC;AAC1B,OAAO,gBAAgB,CAAC;AACxB,OAAO,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAQzC;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,MAAM,GAAE,SAAc,GAAG,IAAI,CAsBpD;AASD,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAM3D;AAID,YAAY,EACV,uBAAuB,EACvB,OAAO,EACP,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACZ,WAAW,EACX,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,OAAO,EACP,UAAU,EACV,YAAY,EACZ,oBAAoB,EACpB,WAAW,EACX,cAAc,EACd,aAAa,EACb,YAAY,EACZ,WAAW,EACX,eAAe,EACf,cAAc,EACd,MAAM,EACN,UAAU,EACV,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,eAAe,CAAC,CAAC"}