@askrjs/askr 0.0.92 → 0.0.95

package/dist/index-2bk8nldG.d.ts

@@ -1,241 +0,0 @@
-//#region src/data/types.d.ts
-type QueryConsistency = 'fresh' | 'stale' | 'refreshing' | 'pending-write';
-type QueryStaleReason = 'aborted' | 'error' | 'inconsistent';
-interface DataRuntime {
-  readonly queryCache: Map<string, unknown>;
-  readonly queryData: Map<string, unknown>;
-  /** Test-only query overrides keyed by the canonical query key. */
-  readonly queryTestOverrides: Map<string, unknown>;
-  /** Test-only mutation overrides keyed by the canonical mutation key. */
-  readonly mutationTestOverrides: Map<string, unknown>;
-}
-interface DataRuntimeOptions {
-  queryCache?: Map<string, unknown>;
-  queryData?: Map<string, unknown>;
-  queryTestOverrides?: Map<string, unknown>;
-  mutationTestOverrides?: Map<string, unknown>;
-}
-interface QueryDefinition<TInput, TResult extends {}> {
-  readonly key: (input: TInput) => string;
-  readonly fetch: (context: TInput & {
-    signal: AbortSignal;
-  }) => Promise<TResult>;
-  readonly isConsistent?: (data: TResult) => boolean;
-  readonly reconcile?: (data: TResult, context: {
-    key: string;
-  }) => Promise<boolean> | boolean;
-}
-interface QueryPrefetchContext {
-  readonly runtime: DataRuntime;
-  readonly request?: Request;
-  readonly signal: AbortSignal;
-  readonly mode: 'ssr' | 'spa';
-  prefetch<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>, input: TInput): Promise<boolean>;
-}
-type ServerQueryHandler<TInput, TResult extends {}> = (context: {
-  input: TInput;
-  request?: Request;
-  signal: AbortSignal;
-}) => Promise<TResult> | TResult;
-interface InvalidateOptions {
-  markPendingWrite?: boolean;
-  runtime?: DataRuntime;
-}
-interface InvalidateOnIntervalOptions extends InvalidateOptions {
-  intervalMs: number;
-  activeOn?: string | readonly string[];
-  visibleOnly?: boolean;
-  focusedOnly?: boolean;
-}
-type QueryKeyPart = string | number | boolean | null | undefined | readonly QueryKeyPart[] | {
-  readonly [key: string]: QueryKeyPart;
-};
-interface QueryScope {
-  key(...parts: QueryKeyPart[]): string;
-  prefix(...parts: QueryKeyPart[]): string;
-  invalidate(parts: readonly QueryKeyPart[], options?: InvalidateOptions): void;
-}
-type QueryControls = {
-  refresh(): Promise<void>;
-};
-type QueryLoading = {
-  data: null;
-  error: null;
-  loading: true;
-  refreshing: false;
-  stale: false;
-  consistency: 'fresh';
-  staleReason: null;
-};
-type QueryFresh<T> = {
-  data: T;
-  error: null;
-  loading: false;
-  refreshing: false;
-  stale: false;
-  consistency: 'fresh';
-  staleReason: null;
-};
-type QueryRefreshing<T> = {
-  data: T;
-  error: null;
-  loading: false;
-  refreshing: true;
-  stale: true;
-  consistency: 'refreshing';
-  staleReason: null;
-};
-type QueryPendingWrite<T> = {
-  data: T;
-  error: null;
-  loading: false;
-  refreshing: true;
-  stale: true;
-  consistency: 'pending-write';
-  staleReason: null;
-};
-type QueryStaleValue<T> = {
-  data: T;
-  error: null;
-  loading: false;
-  refreshing: false;
-  stale: true;
-  consistency: 'stale';
-  staleReason: 'aborted' | 'inconsistent';
-};
-type QueryStaleErrorWithValue<T> = {
-  data: T;
-  error: {};
-  loading: false;
-  refreshing: false;
-  stale: true;
-  consistency: 'stale';
-  staleReason: 'error';
-};
-type QueryStaleError = {
-  data: null;
-  error: {};
-  loading: false;
-  refreshing: false;
-  stale: true;
-  consistency: 'stale';
-  staleReason: 'error';
-};
-type Query<T extends {}> = QueryControls & (QueryLoading | QueryFresh<T> | QueryRefreshing<T> | QueryPendingWrite<T> | QueryStaleValue<T> | QueryStaleErrorWithValue<T> | QueryStaleError);
-type MutationControls<TInput, TResult> = {
-  execute(input: TInput): Promise<TResult>;
-  abort(): void;
-  reset(): void;
-};
-type MutationIdle = {
-  status: 'idle';
-  pending: false;
-  error: null;
-  result: null;
-};
-type MutationPending = {
-  status: 'pending';
-  pending: true;
-  error: null;
-  result: null;
-};
-type MutationSuccess<TResult> = {
-  status: 'success';
-  pending: false;
-  error: null;
-  result: TResult;
-};
-type MutationError = {
-  status: 'error';
-  pending: false;
-  error: {};
-  result: null;
-};
-type Mutation<TInput, TResult> = MutationControls<TInput, TResult> & (MutationIdle | MutationPending | MutationSuccess<TResult> | MutationError);
-type QueryOptions<T> = {
-  key: string;
-  fetch: (ctx: {
-    signal: AbortSignal;
-  }) => Promise<T>;
-  isConsistent?: (data: T) => boolean;
-  reconcile?: (data: T, ctx: {
-    key: string;
-  }) => Promise<boolean> | boolean;
-  runtime?: DataRuntime;
-  initialData?: T;
-  skipInitialFetch?: boolean;
-};
-type MutationOptions<TInput, TResult> = {
-  /** Stable identity used by runtime-scoped mutation test overrides. */
-  key?: string;
-  action: (input: TInput, ctx: {
-    signal: AbortSignal;
-  }) => Promise<TResult>;
-  affects?: (input: TInput, result: TResult) => string[];
-  afterSuccess?: 'invalidate';
-  runtime?: DataRuntime;
-};
-//#endregion
-//#region src/common/telemetry.d.ts
-interface TelemetryFields {
-  requestId?: string;
-  traceId?: string;
-  route?: string;
-  action?: string;
-  operation?: string;
-  status?: number;
-  durationMs?: number;
-}
-type TelemetrySpan = <T>(fields: TelemetryFields, work: () => T) => T;
-/**
- * Structural subset implemented by `createTelemetry()` from `@askrjs/otel`.
- * Core does not install an OpenTelemetry SDK, backend, or exporter.
- */
-interface CoreTelemetry {
-  routeMatch?: TelemetrySpan;
-  loader?: TelemetrySpan;
-  queryPrefetch?: TelemetrySpan;
-  ssrRender?: TelemetrySpan;
-}
-//#endregion
-//#region src/data/mutation-cell.d.ts
-declare function createMutation<TInput, TResult>(options: MutationOptions<TInput, TResult>): Mutation<TInput, TResult>;
-//#endregion
-//#region src/data/query-cell.d.ts
-declare function createQuery<T extends {}>(options: QueryOptions<T>): Query<T>;
-declare function createQuery<TInput, TResult extends {}>(definition: QueryDefinition<TInput, TResult>, input: TInput, options?: Omit<QueryOptions<TResult>, 'key' | 'fetch'>): Query<TResult>;
-//#endregion
-//#region src/data/data-runtime.d.ts
-declare function createDataRuntime(options?: DataRuntimeOptions): DataRuntime;
-declare function getDefaultDataRuntime(): DataRuntime;
-//#endregion
-//#region src/data/invalidation.d.ts
-declare function invalidate(prefix: string, options?: InvalidateOptions): void;
-declare function queryScope(namespace: string): QueryScope;
-declare function invalidateOnInterval(prefix: string, options: InvalidateOnIntervalOptions): void;
-//#endregion
-//#region src/data/query-registry.d.ts
-interface ServerQueryRegistry {
-  readonly entries: readonly ServerQueryEntry<unknown, {}>[];
-  get<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>): ServerQueryHandler<TInput, TResult> | undefined;
-}
-interface ServerQueryEntry<TInput, TResult extends {}> {
-  readonly query: QueryDefinition<TInput, TResult>;
-  readonly handler: ServerQueryHandler<TInput, TResult>;
-}
-declare function serveQuery<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>, handler: ServerQueryHandler<TInput, TResult>): ServerQueryEntry<TInput, TResult>;
-declare function defineServerQueries(...entries: readonly ServerQueryEntry<any, any>[]): ServerQueryRegistry;
-declare function defineQuery<TInput, TResult extends {}>(definition: QueryDefinition<TInput, TResult>): QueryDefinition<TInput, TResult>;
-declare function createQueryPrefetchContext(options?: {
-  runtime?: DataRuntime;
-  registry?: ServerQueryRegistry;
-  request?: Request;
-  signal?: AbortSignal;
-  mode?: 'ssr' | 'spa';
-  telemetry?: CoreTelemetry;
-}): QueryPrefetchContext;
-declare function prefetchQuery<TInput, TResult extends {}>(context: QueryPrefetchContext, query: QueryDefinition<TInput, TResult>, input: TInput): Promise<boolean>;
-declare function dehydrateDataRuntime(runtime: DataRuntime): Record<string, unknown>;
-declare function hydrateDataRuntime(runtime: DataRuntime, data: unknown): void;
-//#endregion
-export { QueryStaleReason as A, MutationOptions as C, QueryKeyPart as D, QueryDefinition as E, QueryPrefetchContext as O, Mutation as S, QueryConsistency as T, CoreTelemetry as _, defineServerQueries as a, InvalidateOnIntervalOptions as b, prefetchQuery as c, invalidateOnInterval as d, queryScope as f, createMutation as g, createQuery as h, defineQuery as i, ServerQueryHandler as j, QueryScope as k, serveQuery as l, getDefaultDataRuntime as m, ServerQueryRegistry as n, dehydrateDataRuntime as o, createDataRuntime as p, createQueryPrefetchContext as r, hydrateDataRuntime as s, ServerQueryEntry as t, invalidate as u, DataRuntime as v, Query as w, InvalidateOptions as x, DataRuntimeOptions as y };

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

@@ -1,2 +0,0 @@
-import "./types-BA9FJtfR.js";
-import "./jsx-runtime-Cfb2umb4.js";

package/dist/scheduler-CmLO4Dfm.d.ts

@@ -1,65 +0,0 @@
-//#region src/runtime/scheduler.d.ts
-/**
- * Serialized update scheduler — safer design (no inline execution, explicit flush)
- *
- * Key ideas:
- * - Never execute a task inline from `enqueue`.
- * - `flush()` is explicit and non-reentrant.
- * - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks
- *   inline; it runs `fn` and then does an explicit `flush()`.
- * - `waitForFlush()` is race-free with a monotonic `flushVersion`.
- */
-type Task = () => void;
-type SchedulerLane = 'derived' | 'component' | 'reactive' | 'post';
-type SchedulerBulkCommitProbe = () => boolean;
-declare class Scheduler {
-  private bulkCommitProbe;
-  private lanes;
-  private running;
-  private inHandler;
-  private depth;
-  private executionDepth;
-  private flushVersion;
-  private kickScheduled;
-  private allowSyncProgress;
-  private waiters;
-  private taskCount;
-  setBulkCommitProbe(probe: SchedulerBulkCommitProbe): void;
-  private isBulkCommitActive;
-  private hasPendingTasks;
-  private getPendingTaskCount;
-  private compactLane;
-  private scheduleFlushKick;
-  enqueue(task: Task): void;
-  enqueueInLane(lane: SchedulerLane, task: Task): void;
-  flush(): void;
-  runWithSyncProgress<T>(fn: () => T): T;
-  waitForFlush(targetVersion?: number, timeoutMs?: number): Promise<void>;
-  getState(): {
-    queueLength: number;
-    running: boolean;
-    depth: number;
-    executionDepth: number;
-    taskCount: number;
-    flushVersion: number;
-    laneQueues: {
-      derived: number;
-      component: number;
-      reactive: number;
-      post: number;
-    };
-    inHandler: boolean;
-    allowSyncProgress: boolean;
-  };
-  getFlushVersion(): number;
-  flushIfQueued(): void;
-  runInHandlerScope<T>(fn: () => T, flushMode?: 'defer' | 'sync'): T;
-  setInHandler(v: boolean): void;
-  isInHandler(): boolean;
-  isExecuting(): boolean;
-  clearPendingSyncTasks(): number;
-  private resolveWaiters;
-}
-declare function scheduleEventHandler(handler: EventListener): EventListener;
-//#endregion
-export { scheduleEventHandler as n, Scheduler as t };