@declarion/react 0.12.3 → 0.15.0

package/dist-lib/{DraggableChildrenTable-CcogMLSZ.js → DraggableChildrenTable-I1gyEEIJ.js}

@@ -1,5 +1,5 @@
 import { s as e } from "./DynamicIcon-DCRdxxZ7.js";
-import { Xt as t, Yt as n, a as r, i, lt as a, n as o, r as s, t as c, xt as l } from "./dataTableStyles-EMyLDQRB.js";
+import { Xt as t, Yt as n, a as r, i, lt as a, n as o, r as s, t as c, xt as l } from "./dataTableStyles-WuxWH5x7.js";
 import { useCallback as u, useMemo as d, useRef as f } from "react";
 import { jsx as p, jsxs as m } from "react/jsx-runtime";
 import { DndContext as h, PointerSensor as g, closestCenter as _, useSensor as v, useSensors as y } from "@dnd-kit/core";

package/dist-lib/{Grid-Cwxca9aO.js → Grid-_7PlIyGn.js}

@@ -1,4 +1,4 @@
-import { _ as e, b as t, d as n, f as r, i, o as a, t as o, v as s, x as c, y as l } from "./value-CrpaObP_.js";
+import { _ as e, b as t, d as n, f as r, i, o as a, t as o, v as s, x as c, y as l } from "./value-YOCedRQq.js";
 import { useCallback as u, useEffect as d, useMemo as f, useRef as p, useState as m } from "react";
 import { Fragment as h, jsx as g, jsxs as _ } from "react/jsx-runtime";
 import { DndContext as v, PointerSensor as y, closestCenter as b, useSensor as x, useSensors as S } from "@dnd-kit/core";

package/dist-lib/api/entities.d.ts

@@ -32,18 +32,24 @@ export declare class EntityClient<T extends Record<string, unknown> = Record<str
     get(id: string): Promise<T & EnrichedRow & RowHelpers>;
     /** List records with cursor-based pagination, field selection, and expansion.
      *
-     * Transparent recovery on cursor-stale signals: when the server returns
-     * `cursor_semantics_mismatch` (sort grammar version bump) or
-     * `cursor_locale_changed` (active locale switched mid-pagination), the
-     * `after` token is dropped and the request is retried once. The caller
-     * receives page 1 of the fresh result set. Both signals indicate that
-     * resuming the cursor would mis-order rows; refetching from the top is
-     * the correct contract. See docs/plans/2026-06-02-multilang-locale-aware-sort.md.
+     * Recovery on cursor-stale signals: when the server returns
+     * `cursor_semantics_mismatch` (sort grammar version bump),
+     * `cursor_locale_changed` (active locale switched mid-pagination), or
+     * `archive_cursor_invalid` (an undecodable cross-store archive cursor), the
+     * `after` token is dropped and the request is retried once from the top.
+     *
+     * CRITICAL for accumulating callers (infinite scroll): the returned
+     * `reset` flag is `true` when this recovery fired. The refetched data is
+     * WINDOW 1, not the next page - an accumulating `useInfiniteQuery` MUST
+     * discard its prior pages and start from this one, never append it as the
+     * next page (which would duplicate the head and drop the middle). Callers
+     * that fetch a single window can ignore `reset`. See Decisions Log #14.
      */
     list(params?: V2ListParams): Promise<{
         data: (T & RowHelpers)[];
         meta: V2Meta;
         $refs: Refs;
+        reset: boolean;
     }>;
     /** Create a single record. Wraps in array, returns unwrapped result. */
     create(item: Partial<T> & Record<string, unknown>): Promise<T & EnrichedRow & RowHelpers>;

package/dist-lib/{dataTableStyles-EMyLDQRB.js → dataTableStyles-WuxWH5x7.js}

@@ -1,5 +1,5 @@
 import { s as e, t } from "./DynamicIcon-DCRdxxZ7.js";
-import { C as n, E as r, T as i, W as a, _ as o, b as s, c, d as l, f as u, g as d, h as f, i as p, k as m, l as h, m as g, n as _, o as ee, p as v, r as y, t as b, u as x, v as S, w as C, x as te, y as ne } from "./value-CrpaObP_.js";
+import { C as n, E as r, T as i, W as a, _ as o, b as s, c, d as l, f as u, g as d, h as f, i as p, k as m, l as h, m as g, n as _, o as ee, p as v, r as y, t as b, u as x, v as S, w as C, x as te, y as ne } from "./value-YOCedRQq.js";
 import { a as w, i as T, o as E, r as D, s as O, t as k } from "./rich-text-CJpzFOG5.js";
 import { Suspense as A, forwardRef as j, lazy as M, useCallback as N, useEffect as P, useLayoutEffect as F, useMemo as I, useRef as L, useState as R } from "react";
 import { useQuery as re } from "@tanstack/react-query";
@@ -2398,8 +2398,8 @@ function zn({ field: e, fieldName: t, value: n, mode: r, onChange: i, record: a,
 }
 //#endregion
 //#region src/hooks/useEntityData.ts
-function Bn(e, t) {
-	let n = {
+function Bn(e, t, n = !0) {
+	let r = {
 		...t,
 		count: "window"
 	};
@@ -2407,15 +2407,15 @@ function Bn(e, t) {
 		queryKey: [
 			"entity-data",
 			e,
-			n
+			r
 		],
-		queryFn: ({ signal: t }) => Qt(e, n, { signal: t }),
-		enabled: !!e,
+		queryFn: ({ signal: t }) => Qt(e, r, { signal: t }),
+		enabled: !!e && n,
 		placeholderData: (t, n) => n?.queryKey?.[1] === e ? t : void 0
 	});
 }
-function Vn(e, t) {
-	let n = {
+function Vn(e, t, n = !0) {
+	let r = {
 		...t,
 		count: "only",
 		page: void 0,
@@ -2428,10 +2428,10 @@ function Vn(e, t) {
 		queryKey: [
 			"entity-count",
 			e,
-			n
+			r
 		],
-		queryFn: ({ signal: t }) => Qt(e, n, { signal: t }),
-		enabled: !!e,
+		queryFn: ({ signal: t }) => Qt(e, r, { signal: t }),
+		enabled: !!e && n,
 		retry: 1,
 		staleTime: 3e4,
 		placeholderData: (t, n) => n?.queryKey?.[1] === e ? t : void 0
@@ -3451,7 +3451,7 @@ function Or(e) {
 }
 //#endregion
 //#region src/components/file-widgets/GridLazy.tsx
-var kr = M(() => import("./Grid-Cwxca9aO.js").then((e) => ({ default: e.Grid })));
+var kr = M(() => import("./Grid-_7PlIyGn.js").then((e) => ({ default: e.Grid })));
 function Ar() {
 	return /* @__PURE__ */ B("div", { className: "h-24 w-full rounded-md bg-muted animate-pulse" });
 }

package/dist-lib/hooks/useCursorEntityData.d.ts

@@ -0,0 +1,57 @@
+import type { FilterNodeParam, Refs, V2Meta } from "../types/api";
+/**
+ * Query-key root for the cursor (infinite) entity list. Distinct from the
+ * offset list's `"entity-data"` so the SSE handler can RESET it (drop pages,
+ * refetch window 1) instead of invalidating it - invalidating an infinite query
+ * refetches every accumulated page with its now-stale cursor and corrupts the
+ * list. See useSSE.ts.
+ */
+export declare const CURSOR_ENTITY_DATA_KEY = "entity-data-cursor";
+export interface CursorEntityDataParams {
+    sort?: string;
+    filters?: FilterNodeParam[];
+    search?: string;
+    select?: string[];
+    expand?: string[];
+    includeDeleted?: boolean;
+    screen?: string;
+    preview?: boolean;
+    limit: number;
+}
+/**
+ * useCursorEntityData drives the cursor-native admin list for an archive entity
+ * whose `list_pagination` is `cursor` (Postgres-hot + ClickHouse-cold). It
+ * accumulates windows with `useInfiniteQuery` over `EntityClient.list` (so the
+ * stale-cursor `reset` signal is available), requests the estimated count on
+ * the FIRST window only, and resets to window 1 when a stale cursor is hit
+ * mid-scroll. Realtime resets are driven centrally by the SSE handler via
+ * resetQueries on CURSOR_ENTITY_DATA_KEY.
+ *
+ * `enabled` gates the query so a NON-cursor entity (offset mode) pays nothing -
+ * the page calls both this and useEntityData and enables exactly one.
+ */
+export declare function useCursorEntityData(entity: string | undefined, params: CursorEntityDataParams, enabled: boolean): {
+    rows: (Record<string, unknown> & import("../api/entities").RowHelpers)[];
+    refs: Refs | undefined;
+    total: number | undefined;
+    countMode: string | undefined;
+    countUnknown: boolean;
+    hasMore: boolean;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: (Record<string, unknown> & import("../api/entities").RowHelpers)[];
+        meta: V2Meta;
+        $refs: Refs;
+        reset: boolean;
+    }, unknown>, Error>>;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: (Record<string, unknown> & import("../api/entities").RowHelpers)[];
+        meta: V2Meta;
+        $refs: Refs;
+        reset: boolean;
+    }, unknown>, Error>>;
+};

package/dist-lib/hooks/useEntityData.d.ts

@@ -8,7 +8,7 @@ import type { ListParams, ListResponse } from "../types/api";
  * is fetched separately by `useEntityCount`; the table renders rows the
  * moment this query resolves, independent of count latency.
  */
-export declare function useEntityData(entity: string | undefined, params: ListParams): import("@tanstack/react-query").UseQueryResult<NoInfer<ListResponse<Record<string, unknown>>>, Error>;
+export declare function useEntityData(entity: string | undefined, params: ListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<ListResponse<Record<string, unknown>>>, Error>;
 /**
  * useEntityCount fetches the total row count for a list view in a SEPARATE
  * request from the window (`count: "only"` - the server skips the data
@@ -23,4 +23,4 @@ export declare function useEntityData(entity: string | undefined, params: ListPa
  * to render. A count failure does NOT break the table: callers treat a
  * failed/absent count as "unknown" and fall back to the loaded row count.
  */
-export declare function useEntityCount(entity: string | undefined, params: ListParams): import("@tanstack/react-query").UseQueryResult<NoInfer<ListResponse<Record<string, unknown>>>, Error>;
+export declare function useEntityCount(entity: string | undefined, params: ListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<ListResponse<Record<string, unknown>>>, Error>;