@epoch32/visage 1.0.0 → 1.1.1

package/dist/{src/jsx-runtime → jsx-runtime}/index.js

@@ -848,10 +848,12 @@ class Signal {
   _value;
   _subscribers = new Set;
   _equals;
+  _onSet;
   version = 0;
-  constructor(initialValue, equals) {
+  constructor(initialValue, equals, onSet) {
     this._value = initialValue;
     this._equals = equals ?? Object.is;
+    this._onSet = onSet;
   }
   get() {
     if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
@@ -876,6 +878,9 @@ class Signal {
     }
     this._value = newValue;
     this.version++;
+    if (this._onSet) {
+      this._onSet(newValue);
+    }
     batch(() => {
       this.notify();
     });
@@ -901,11 +906,91 @@ class Signal {
     }
   }
 }
+function resolveStorage(storageOption) {
+  if (storageOption && typeof storageOption === "object") {
+    return storageOption;
+  }
+  if (storageOption === "session") {
+    try {
+      if (typeof sessionStorage !== "undefined")
+        return sessionStorage;
+    } catch {}
+    try {
+      if (typeof window !== "undefined" && window.sessionStorage) {
+        return window.sessionStorage;
+      }
+    } catch {}
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+        return globalThis.sessionStorage;
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    if (typeof localStorage !== "undefined")
+      return localStorage;
+  } catch {}
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+  } catch {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+  } catch {}
+  return null;
+}
 function signal(initialValue, optionsOrEquals) {
   const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
   const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
   const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const s = new Signal(initialValue, equals);
+  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
+  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
+  let effectiveInitial = initialValue;
+  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
+  const serialize = persistConfig?.serialize ?? JSON.stringify;
+  const deserialize = persistConfig?.deserialize ?? JSON.parse;
+  if (persistConfig && storage) {
+    try {
+      const stored = storage.getItem(persistConfig.key);
+      if (stored !== null) {
+        effectiveInitial = deserialize(stored);
+      }
+    } catch {}
+  }
+  let isSyncing = false;
+  const onSet = persistConfig && storage ? (val) => {
+    if (isSyncing)
+      return;
+    try {
+      storage.setItem(persistConfig.key, serialize(val));
+    } catch {}
+  } : undefined;
+  const s = new Signal(effectiveInitial, equals, onSet);
+  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    const onStorage = (e) => {
+      if (e.key === persistConfig.key) {
+        try {
+          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
+          isSyncing = true;
+          try {
+            s.set(nextVal);
+          } finally {
+            isSyncing = false;
+          }
+        } catch {}
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        window.removeEventListener("storage", onStorage);
+      });
+    }
+  }
   const accessor = (...args) => {
     if (args.length === 0) {
       return s.get();

package/dist/jsx-runtime/jsx.d.ts

@@ -0,0 +1,278 @@
+import type { Child } from "../dom";
+import type { ReadonlySignal } from "../signals";
+
+/**
+ * Fine-grained reactive property value.
+ *
+ * Can be a static value `T`, a reactive `ReadonlySignal<T>`, or a dynamic getter function `() => T`.
+ * Visage binds reactive props directly to the DOM attribute or property via fine-grained effects,
+ * updating only the exact target attribute when the signal changes without re-rendering the component.
+ *
+ * @example
+ * ```tsx
+ * const count = signal(5);
+ *
+ * // Direct signal
+ * <input disabled={count} />
+ *
+ * // Getter function
+ * <div title={() => `Item count: ${count()}`} />
+ * ```
+ */
+export type ReactiveProp<T> = T | ReadonlySignal<T> | (() => T);
+
+/**
+ * Flexible reactive class value supporting strings, conditional objects, arrays, and getters.
+ */
+export type ClassValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | (() => any)
+  | ClassValue[]
+  | Record<string, any>;
+
+/**
+ * Reactive class / className property.
+ *
+ * @example
+ * ```tsx
+ * // Object conditional syntax
+ * <div class={{ active: isActive(), hidden: isHidden() }} />
+ *
+ * // Array syntax
+ * <div class={["btn", isPrimary() ? "btn-primary" : "btn-secondary"]} />
+ *
+ * // Signal / Getter syntax
+ * <div class={() => `theme-${theme()}`} />
+ * ```
+ */
+export type ClassProp = ReactiveProp<
+  string | number | boolean | undefined | null | ClassValue[] | Record<string, any>
+>;
+
+/**
+ * Standard HTML Element attributes with fine-grained reactive property bindings.
+ */
+export type HTMLAttributes<T extends HTMLElement = HTMLElement> = {
+  [K in keyof HTMLElementTagNameMap[keyof HTMLElementTagNameMap]]?: any;
+} & {
+  class?: ClassProp;
+  className?: ClassProp;
+  id?: ReactiveProp<string | undefined | null>;
+  title?: ReactiveProp<string | undefined | null>;
+  tabIndex?: ReactiveProp<number | undefined | null>;
+  role?: ReactiveProp<string | undefined | null>;
+  hidden?: ReactiveProp<boolean | undefined | null>;
+  disabled?: ReactiveProp<boolean | undefined | null>;
+  style?: ReactiveProp<
+    string | Record<string, ReactiveProp<string | number | undefined | null>> | undefined | null
+  >;
+  ref?: (el: T) => void;
+  dangerouslySetInnerHTML?: { __html: string };
+
+  // Events
+  onClick?: (e: MouseEvent) => void;
+  onDblClick?: (e: MouseEvent) => void;
+  onMouseDown?: (e: MouseEvent) => void;
+  onMouseUp?: (e: MouseEvent) => void;
+  onMouseMove?: (e: MouseEvent) => void;
+  onMouseEnter?: (e: MouseEvent) => void;
+  onMouseLeave?: (e: MouseEvent) => void;
+  onKeyDown?: (e: KeyboardEvent) => void;
+  onKeyUp?: (e: KeyboardEvent) => void;
+  onKeyPress?: (e: KeyboardEvent) => void;
+  onInput?: (e: InputEvent & { target: T }) => void;
+  onChange?: (e: Event & { target: T }) => void;
+  onSubmit?: (e: SubmitEvent) => void;
+  onFocus?: (e: FocusEvent) => void;
+  onBlur?: (e: FocusEvent) => void;
+  onScroll?: (e: Event) => void;
+
+  children?: Child;
+  [attr: string]: any;
+};
+
+export type InputAttributes = HTMLAttributes<HTMLInputElement> & {
+  type?: ReactiveProp<string>;
+  value?: ReactiveProp<string | number | readonly string[] | undefined | null>;
+  checked?: ReactiveProp<boolean | undefined | null>;
+  placeholder?: ReactiveProp<string | undefined | null>;
+  name?: ReactiveProp<string | undefined | null>;
+  disabled?: ReactiveProp<boolean | undefined | null>;
+  readOnly?: ReactiveProp<boolean | undefined | null>;
+  required?: ReactiveProp<boolean | undefined | null>;
+  min?: ReactiveProp<string | number | undefined | null>;
+  max?: ReactiveProp<string | number | undefined | null>;
+  step?: ReactiveProp<string | number | undefined | null>;
+  pattern?: ReactiveProp<string | undefined | null>;
+  autoFocus?: ReactiveProp<boolean | undefined | null>;
+  autoComplete?: ReactiveProp<string | undefined | null>;
+};
+
+export type ButtonAttributes = HTMLAttributes<HTMLButtonElement> & {
+  type?: ReactiveProp<"button" | "submit" | "reset" | undefined>;
+  disabled?: ReactiveProp<boolean | undefined | null>;
+  name?: ReactiveProp<string | undefined | null>;
+  value?: ReactiveProp<string | number | undefined | null>;
+};
+
+export type AnchorAttributes = HTMLAttributes<HTMLAnchorElement> & {
+  href?: ReactiveProp<string | undefined | null>;
+  target?: ReactiveProp<"_blank" | "_self" | "_parent" | "_top" | string | undefined | null>;
+  rel?: ReactiveProp<string | undefined | null>;
+  download?: ReactiveProp<any>;
+};
+
+export interface VisageIntrinsicElements {
+  // HTML tags
+  div: HTMLAttributes<HTMLDivElement>;
+  span: HTMLAttributes<HTMLSpanElement>;
+  p: HTMLAttributes<HTMLParagraphElement>;
+  a: AnchorAttributes;
+  button: ButtonAttributes;
+  input: InputAttributes;
+  textarea: HTMLAttributes<HTMLTextAreaElement> & {
+    value?: ReactiveProp<string | number | undefined | null>;
+    placeholder?: ReactiveProp<string | undefined | null>;
+    rows?: ReactiveProp<number | undefined | null>;
+    cols?: ReactiveProp<number | undefined | null>;
+  };
+  select: HTMLAttributes<HTMLSelectElement> & {
+    value?: ReactiveProp<any>;
+    multiple?: ReactiveProp<boolean | undefined | null>;
+  };
+  option: HTMLAttributes<HTMLOptionElement> & {
+    value?: ReactiveProp<any>;
+    selected?: ReactiveProp<boolean | undefined | null>;
+  };
+  form: HTMLAttributes<HTMLFormElement> & {
+    action?: ReactiveProp<string | undefined | null>;
+    method?: ReactiveProp<string | undefined | null>;
+  };
+  label: HTMLAttributes<HTMLLabelElement> & {
+    htmlFor?: ReactiveProp<string | undefined | null>;
+    for?: ReactiveProp<string | undefined | null>;
+  };
+  h1: HTMLAttributes<HTMLHeadingElement>;
+  h2: HTMLAttributes<HTMLHeadingElement>;
+  h3: HTMLAttributes<HTMLHeadingElement>;
+  h4: HTMLAttributes<HTMLHeadingElement>;
+  h5: HTMLAttributes<HTMLHeadingElement>;
+  h6: HTMLAttributes<HTMLHeadingElement>;
+  header: HTMLAttributes<HTMLElement>;
+  footer: HTMLAttributes<HTMLElement>;
+  main: HTMLAttributes<HTMLElement>;
+  nav: HTMLAttributes<HTMLElement>;
+  section: HTMLAttributes<HTMLElement>;
+  article: HTMLAttributes<HTMLElement>;
+  aside: HTMLAttributes<HTMLElement>;
+  ul: HTMLAttributes<HTMLUListElement>;
+  ol: HTMLAttributes<HTMLOListElement>;
+  li: HTMLAttributes<HTMLLIElement>;
+  table: HTMLAttributes<HTMLTableElement>;
+  thead: HTMLAttributes<HTMLTableSectionElement>;
+  tbody: HTMLAttributes<HTMLTableSectionElement>;
+  tfoot: HTMLAttributes<HTMLTableSectionElement>;
+  tr: HTMLAttributes<HTMLTableRowElement>;
+  td: HTMLAttributes<HTMLTableCellElement>;
+  th: HTMLAttributes<HTMLTableCellElement>;
+  img: HTMLAttributes<HTMLImageElement> & {
+    src?: ReactiveProp<string | undefined | null>;
+    alt?: ReactiveProp<string | undefined | null>;
+    width?: ReactiveProp<number | string | undefined | null>;
+    height?: ReactiveProp<number | string | undefined | null>;
+    loading?: ReactiveProp<"lazy" | "eager" | undefined | null>;
+  };
+  iframe: HTMLAttributes<HTMLIFrameElement> & {
+    src?: ReactiveProp<string | undefined | null>;
+    title?: ReactiveProp<string | undefined | null>;
+  };
+  canvas: HTMLAttributes<HTMLCanvasElement> & {
+    width?: ReactiveProp<number | undefined | null>;
+    height?: ReactiveProp<number | undefined | null>;
+  };
+  code: HTMLAttributes<HTMLElement>;
+  pre: HTMLAttributes<HTMLPreElement>;
+  blockquote: HTMLAttributes<HTMLQuoteElement>;
+  strong: HTMLAttributes<HTMLElement>;
+  em: HTMLAttributes<HTMLElement>;
+  small: HTMLAttributes<HTMLElement>;
+  hr: HTMLAttributes<HTMLHRElement>;
+  br: HTMLAttributes<HTMLBRElement>;
+
+  // SVG Tags
+  svg: HTMLAttributes<SVGElement> & {
+    viewBox?: ReactiveProp<string>;
+    xmlns?: ReactiveProp<string>;
+    width?: ReactiveProp<number | string>;
+    height?: ReactiveProp<number | string>;
+    fill?: ReactiveProp<string>;
+    stroke?: ReactiveProp<string>;
+  };
+  path: HTMLAttributes<SVGElement> & {
+    d?: ReactiveProp<string>;
+    fill?: ReactiveProp<string>;
+    stroke?: ReactiveProp<string>;
+    strokeWidth?: ReactiveProp<number | string>;
+  };
+  circle: HTMLAttributes<SVGElement> & {
+    cx?: ReactiveProp<number | string>;
+    cy?: ReactiveProp<number | string>;
+    r?: ReactiveProp<number | string>;
+    fill?: ReactiveProp<string>;
+  };
+  rect: HTMLAttributes<SVGElement> & {
+    x?: ReactiveProp<number | string>;
+    y?: ReactiveProp<number | string>;
+    width?: ReactiveProp<number | string>;
+    height?: ReactiveProp<number | string>;
+    fill?: ReactiveProp<string>;
+  };
+
+  // Catch-all for other tags
+  [elemName: string]: HTMLAttributes<HTMLElement>;
+}
+
+/**
+ * Visage JSX Namespace Definitions
+ */
+export namespace JSX {
+  /**
+   * Represents any valid JSX element in Visage (DOM Node, Signal, Function Getter, VNode, string, number, null, undefined).
+   */
+  export type Element = Node | Child;
+
+  export interface ElementChildrenAttribute {
+    children: unknown;
+  }
+
+  export interface IntrinsicAttributes {
+    key?: any;
+    [key: string]: any;
+  }
+
+  export interface IntrinsicElements extends VisageIntrinsicElements {}
+}
+
+declare global {
+  namespace JSX {
+    /**
+     * Represents any valid JSX element in Visage (DOM Node, Signal, Function Getter, VNode, string, number, null, undefined).
+     */
+    type Element = Node | Child;
+
+    interface ElementChildrenAttribute {
+      children: unknown;
+    }
+
+    interface IntrinsicAttributes {
+      key?: any;
+      [key: string]: any;
+    }
+
+    interface IntrinsicElements extends VisageIntrinsicElements {}
+  }
+}

package/dist/query/create-mutation.d.ts

@@ -0,0 +1,3 @@
+import { type QueryClient } from "./query-client";
+import type { MutationOptions, MutationResult } from "./types";
+export declare function createMutation<TData = unknown, TError = any, TVariables = void, TContext = unknown>(options: MutationOptions<TData, TError, TVariables, TContext> | (() => MutationOptions<TData, TError, TVariables, TContext>), client?: QueryClient): MutationResult<TData, TError, TVariables, TContext>;

package/dist/query/create-query.d.ts

@@ -0,0 +1,4 @@
+import { type QueryClient } from "./query-client";
+import type { CreateQueryOptions, InfiniteData, InfiniteQueryOptions, InfiniteQueryResult, QueryKey, QueryResult } from "./types";
+export declare function createQuery<TData = unknown, TError = any, TSelected = TData, TQueryKey extends QueryKey = QueryKey>(options: CreateQueryOptions<TData, TError, TSelected, TQueryKey> | (() => CreateQueryOptions<TData, TError, TSelected, TQueryKey>), client?: QueryClient): QueryResult<TSelected, TError>;
+export declare function createInfiniteQuery<TData = unknown, TError = any, TPageParam = unknown, TSelected = InfiniteData<TData, TPageParam>, TQueryKey extends QueryKey = QueryKey>(options: InfiniteQueryOptions<TData, TError, TPageParam, TSelected, TQueryKey> | (() => InfiniteQueryOptions<TData, TError, TPageParam, TSelected, TQueryKey>), client?: QueryClient): InfiniteQueryResult<TData, TError, TPageParam>;

package/dist/query/focus-manager.d.ts

@@ -0,0 +1,14 @@
+export type FocusListener = (focused: boolean) => void;
+export declare class FocusManager {
+    private _focused?;
+    private _listeners;
+    private _cleanup?;
+    constructor();
+    private setupEventListener;
+    setFocused(focused?: boolean): void;
+    isFocused(): boolean;
+    subscribe(listener: FocusListener): () => void;
+    private notify;
+    cleanup(): void;
+}
+export declare const focusManager: FocusManager;

package/dist/query/index.d.ts

@@ -0,0 +1,9 @@
+export { createMutation } from "./create-mutation";
+export { createInfiniteQuery, createQuery } from "./create-query";
+export { type FocusListener, FocusManager, focusManager } from "./focus-manager";
+export { Mutation, MutationCache } from "./mutation-cache";
+export { type OnlineListener, OnlineManager, onlineManager } from "./online-manager";
+export { Query, QueryCache, type QueryObserver } from "./query-cache";
+export { QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, useQueryClient } from "./query-client";
+export type { CreateQueryOptions, DefaultOptions, FetchStatus, InfiniteData, InfiniteQueryOptions, InfiniteQueryResult, MutateOptions, MutationFunction, MutationOptions, MutationResult, MutationStatus, QueryFilters, QueryFunction, QueryFunctionContext, QueryKey, QueryOptions, QueryResult, QueryState, QueryStatus, RefetchOptions, RetryDelayValue, RetryValue } from "./types";
+export { deepEqual, hashKey, isPlainObject, matchQuery, partialDeepEqual, sleep } from "./utils";

package/dist/{src/query → query}/index.js

@@ -848,10 +848,12 @@ class Signal {
   _value;
   _subscribers = new Set;
   _equals;
+  _onSet;
   version = 0;
-  constructor(initialValue, equals) {
+  constructor(initialValue, equals, onSet) {
     this._value = initialValue;
     this._equals = equals ?? Object.is;
+    this._onSet = onSet;
   }
   get() {
     if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
@@ -876,6 +878,9 @@ class Signal {
     }
     this._value = newValue;
     this.version++;
+    if (this._onSet) {
+      this._onSet(newValue);
+    }
     batch(() => {
       this.notify();
     });
@@ -901,11 +906,91 @@ class Signal {
     }
   }
 }
+function resolveStorage(storageOption) {
+  if (storageOption && typeof storageOption === "object") {
+    return storageOption;
+  }
+  if (storageOption === "session") {
+    try {
+      if (typeof sessionStorage !== "undefined")
+        return sessionStorage;
+    } catch {}
+    try {
+      if (typeof window !== "undefined" && window.sessionStorage) {
+        return window.sessionStorage;
+      }
+    } catch {}
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+        return globalThis.sessionStorage;
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    if (typeof localStorage !== "undefined")
+      return localStorage;
+  } catch {}
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+  } catch {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+  } catch {}
+  return null;
+}
 function signal(initialValue, optionsOrEquals) {
   const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
   const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
   const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const s = new Signal(initialValue, equals);
+  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
+  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
+  let effectiveInitial = initialValue;
+  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
+  const serialize = persistConfig?.serialize ?? JSON.stringify;
+  const deserialize = persistConfig?.deserialize ?? JSON.parse;
+  if (persistConfig && storage) {
+    try {
+      const stored = storage.getItem(persistConfig.key);
+      if (stored !== null) {
+        effectiveInitial = deserialize(stored);
+      }
+    } catch {}
+  }
+  let isSyncing = false;
+  const onSet = persistConfig && storage ? (val) => {
+    if (isSyncing)
+      return;
+    try {
+      storage.setItem(persistConfig.key, serialize(val));
+    } catch {}
+  } : undefined;
+  const s = new Signal(effectiveInitial, equals, onSet);
+  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    const onStorage = (e) => {
+      if (e.key === persistConfig.key) {
+        try {
+          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
+          isSyncing = true;
+          try {
+            s.set(nextVal);
+          } finally {
+            isSyncing = false;
+          }
+        } catch {}
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        window.removeEventListener("storage", onStorage);
+      });
+    }
+  }
   const accessor = (...args) => {
     if (args.length === 0) {
       return s.get();

package/dist/query/mutation-cache.d.ts

@@ -0,0 +1,24 @@
+import { type ReadonlySignal, type WritableSignal } from "../signals";
+import type { MutateOptions, MutationOptions, MutationStatus } from "./types";
+export declare class Mutation<TData = unknown, TError = any, TVariables = void, TContext = unknown> {
+    readonly options: MutationOptions<TData, TError, TVariables, TContext>;
+    readonly data: WritableSignal<TData | undefined>;
+    readonly error: WritableSignal<TError | null>;
+    readonly status: WritableSignal<MutationStatus>;
+    readonly submittedAt: WritableSignal<number>;
+    readonly variables: WritableSignal<TVariables | undefined>;
+    readonly isIdle: ReadonlySignal<boolean>;
+    readonly isPending: ReadonlySignal<boolean>;
+    readonly isLoading: ReadonlySignal<boolean>;
+    readonly isSuccess: ReadonlySignal<boolean>;
+    readonly isError: ReadonlySignal<boolean>;
+    constructor(options: MutationOptions<TData, TError, TVariables, TContext>);
+    execute(variables: TVariables, mutateOptions?: MutateOptions<TData, TError, TVariables, TContext>): Promise<TData>;
+    reset(): void;
+}
+export declare class MutationCache {
+    mutations: Set<Mutation<any, any, any, any>>;
+    build<TData, TError, TVariables, TContext>(options: MutationOptions<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext>;
+    remove(mutation: Mutation<any, any, any, any>): void;
+    clear(): void;
+}

package/dist/query/online-manager.d.ts

@@ -0,0 +1,14 @@
+export type OnlineListener = (online: boolean) => void;
+export declare class OnlineManager {
+    private _online?;
+    private _listeners;
+    private _cleanup?;
+    constructor();
+    private setupEventListener;
+    setOnline(online?: boolean): void;
+    isOnline(): boolean;
+    subscribe(listener: OnlineListener): () => void;
+    private notify;
+    cleanup(): void;
+}
+export declare const onlineManager: OnlineManager;

package/dist/query/query-cache.d.ts

@@ -0,0 +1,69 @@
+import { type WritableSignal } from "../signals";
+import type { QueryClient } from "./query-client";
+import type { FetchStatus, QueryFilters, QueryKey, QueryOptions, QueryState, QueryStatus } from "./types";
+export interface QueryObserver<TData = any, TError = any> {
+    onQueryUpdate(): void;
+    options: QueryOptions<TData, TError, any>;
+}
+export declare class Query<TData = unknown, TError = any> {
+    readonly queryKey: QueryKey;
+    readonly queryHash: string;
+    cache: QueryCache;
+    readonly data: WritableSignal<TData | undefined>;
+    readonly error: WritableSignal<TError | null>;
+    readonly status: WritableSignal<QueryStatus>;
+    readonly fetchStatus: WritableSignal<FetchStatus>;
+    readonly dataUpdatedAt: WritableSignal<number>;
+    readonly errorUpdatedAt: WritableSignal<number>;
+    readonly failureCount: WritableSignal<number>;
+    readonly isInvalidated: WritableSignal<boolean>;
+    observers: Set<QueryObserver<TData, TError>>;
+    private _gcTimeout;
+    private _abortController;
+    promise: Promise<TData> | null;
+    defaultGcTime: number;
+    constructor(options: {
+        queryKey: QueryKey;
+        queryHash: string;
+        cache: QueryCache;
+        initialData?: TData | (() => TData);
+        initialDataUpdatedAt?: number | (() => number);
+    });
+    get state(): QueryState<TData, TError>;
+    isStale(staleTime?: number): boolean;
+    addObserver(observer: QueryObserver<TData, TError>): void;
+    removeObserver(observer: QueryObserver<TData, TError>): void;
+    scheduleGc(gcTime?: number): void;
+    clearGcTimeout(): void;
+    setData(updater: TData | ((prev: TData | undefined) => TData), options?: {
+        updatedAt?: number;
+    }): TData;
+    invalidate(): void;
+    cancel(): void;
+    reset(): void;
+    fetch(options?: Partial<QueryOptions<TData, TError, any>>, fetchOptions?: {
+        cancelRefetch?: boolean;
+    }): Promise<TData>;
+    private notifyObservers;
+    destroy(): void;
+}
+export declare class QueryCache {
+    queries: Map<string, Query<any, any>>;
+    private _subscribers;
+    subscribe(listener: (event: {
+        type: string;
+        query?: Query<any, any>;
+    }) => void): () => void;
+    notify(event: {
+        type: string;
+        query?: Query<any, any>;
+    }): void;
+    getAll(): Query<any, any>[];
+    build<TData, TError>(_client: QueryClient, options: QueryOptions<TData, TError, any>): Query<TData, TError>;
+    get<TData = unknown, TError = any>(queryHash: string): Query<TData, TError> | undefined;
+    add(query: Query<any, any>): void;
+    remove(query: Query<any, any>): void;
+    find<TData = unknown, TError = any>(filters: QueryFilters): Query<TData, TError> | undefined;
+    findAll<TData = unknown, TError = any>(filters?: QueryFilters): Query<TData, TError>[];
+    clear(): void;
+}