@iyulab/flex-table 0.58.0 → 0.60.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.60.0] - 2026-10-07
+
+### Added
+
+- **`fetchAll(options?)` on both data sources and both hooks** — the whole result of the current sort, search and
+  fixed filter, for exporting what a list shows. A server-paged table holds one page, so its export was one page: a
+  1,240-row register came out as 20 rows with nothing saying so. The OData source asks without `$top`/`$skip` and
+  follows `@odata.nextLink` to the end (the same origin and repeat checks as a page read). `maxRows` (default
+  `100000`, `DEFAULT_MAX_ROWS`) rejects with `RowLimitError` instead of cutting — on the first response when the server
+  counts (`@odata.count`). `signal` and `onProgress(loaded, total)` too. It leaves the source state alone and needs no
+  subscriber. The array source returns the searched and sorted rows under the same contract.
+- **The table exports rows it is given**: `exportToString` / `exportToBlob` / `exportToFile` take `{ rows }` — those
+  rows with the table's visible columns and formats (`exportToFile` gained an `options` argument). With the above:
+  `table.exportToFile('xlsx', 'x.xlsx', { rows: await source.fetchAll() })`.
+- `exportDataBlob` (compressed XLSX) and `downloadBlob` are exported from the root entry, for an export without a table.
+- `SourceRequestError` (its `failure` is the `SourceError`) and `RowLimitError` are exported from `./odata` and
+  `./react` (`RowLimitError` also from `./array`), and `SourceError` / `SourceErrorDetail` types from `./odata`.
+- `buildODataQuery` builds the whole-result query when `pageSize` is left out (`page` and `pageSize` are optional).
+
+## [0.59.0] - 2026-10-07
+
+### Changed (breaking)
+
+- **A plain click on a body cell fires `row-activate`** (`via: 'click'`), as Enter on a non-editable cell does
+  (`via: 'keyboard'`) and as `u-rich-table` does. A read-only list had no pointer way to open a row, so it opened rows on
+  `cell-select` — which is focus and also fires when Tab arrives on the grid: one Tab into the table opened the first
+  row. A Shift / Ctrl / Cmd click (extends the selection), the click that ends a drag, and a click on a control the
+  cell renders (a link, a button, a field) do not activate. A listener that only wants Enter checks
+  `e.detail.via === 'keyboard'`.
+- `cell-select` carries the row's `id` — `row` is the visible position, which is not the row in `data` once a client
+  sort or filter is on.
+- Requires `@iyulab/components` 2.15.0 (the shared «pressed a control» test, `isFromControl`).
+
+### Migration
+
+- Open rows on `row-activate`, not `cell-select`.
+- If you listened to `row-activate` for Enter only (a picker that confirms on Enter), add
+  `if (e.detail.via !== 'keyboard') return;`.
+
 ## [0.58.0] - 2026-10-07
 
 ### Added

package/README.md

@@ -288,9 +288,29 @@ Default is `false`, matching `clear-undo-on-data-change`.
 
 | Method | Returns | Description |
 |--------|---------|-------------|
-| `exportToString(format, options?)` | `string \| Uint8Array` | Export to `'csv'` / `'tsv'` / `'json'` (a string) or `'xlsx'` (bytes, uncompressed). Pass `{ selectionOnly: true }` for selection range |
+| `exportToString(format, options?)` | `string \| Uint8Array` | Export to `'csv'` / `'tsv'` / `'json'` (a string) or `'xlsx'` (bytes, uncompressed). Pass `{ selectionOnly: true }` for selection range, or `{ rows }` to export rows the table does not hold (see below) |
 | `exportToBlob(format, options?)` | `Promise<Blob>` | The same export as a `Blob` of the format's MIME type — `'xlsx'` is DEFLATE-compressed |
-| `exportToFile(format, filename?)` | `Promise<void>` | Export and trigger browser file download (`'xlsx'` compressed) |
+| `exportToFile(format, filename?, options?)` | `Promise<void>` | Export and trigger browser file download (`'xlsx'` compressed) |
+
+The table exports the rows it holds — the filtered rows in sort order, or the selection. **A server-paged table
+(`data-mode="server"`) holds one page**, so its export is one page. To export what the list shows — the whole result
+of the current sort, search and filter — read it from the source and hand it to the table, which keeps its own
+columns and formats:
+
+```ts
+import { RowLimitError } from '@iyulab/flex-table/odata';
+
+try {
+  const rows = await orders.fetchAll({ maxRows: 50_000 });   // follows @odata.nextLink to the end
+  await table.exportToFile('xlsx', 'orders.xlsx', { rows });
+} catch (e) {
+  if (e instanceof RowLimitError) showMessage(e.failure.message); // more rows than maxRows — nothing is cut silently
+  else throw e;
+}
+```
+
+Without a table, `exportDataBlob(rows, columns, format)` and `downloadBlob(blob, filename)` (root entry) do the same
+— `exportData` stays synchronous and writes XLSX uncompressed.
 
 ## Events
 
@@ -303,7 +323,7 @@ type-checks without a cast. The React wrapper's `on*` props carry the same types
 
 | Event | Detail | Description |
 |-------|--------|-------------|
-| `cell-select` | `{ row, col }` or `null` | Cell focus changed (`null` when no cell is active) |
+| `cell-select` | `{ row, col, id }` or `null` | Cell focus changed (`null` when no cell is active). `row`/`col` are visible positions, `id` the row's id. Fires when keyboard focus arrives on the grid too — it is focus, not a choice: open rows on `row-activate` |
 | `cell-edit-start` | `{ row, col, key, value }` | Cell editing started |
 | `cell-edit-commit` | `{ row, col, key, oldValue, newValue }` | Cell value committed |
 | `cell-edit-cancel` | `{ row, col }` | Cell edit cancelled (Escape, or its row left `data`). `row` is the data index (`-1` once the row is gone) |
@@ -315,7 +335,7 @@ type-checks without a cast. The React wrapper's `on*` props carry the same types
 |-------|--------|-------------|
 | `row-add` | `{ row, index }` | Row added |
 | `row-delete` | `{ indices, rows }` | Rows deleted |
-| `row-activate` | `{ row, id, index, col, key }` | Enter pressed on a non-editable cell — the grid's own contract for "activate this row" (e.g. navigate to a detail view), guaranteed even though the internal Enter handler prevents the keystroke from reliably reaching a listener the host attaches to the same element |
+| `row-activate` | `{ row, id, via, index, col, key }` | "Open this row" (e.g. navigate to a detail view): a plain click on a body cell (`via: 'click'`), or Enter on a non-editable cell (`via: 'keyboard'`). Not a Shift / Ctrl / Cmd click (those extend the selection), the click that ends a drag, or a click on a control the cell renders (a link, a button). The grid's own contract — its Enter handler keeps the keystroke from reliably reaching a listener the host attaches to the same element |
 | `batch-update` | `{ changes: [{ row, key, oldValue, newValue }] }` | Batch update applied |
 | `row-reorder` | `{ from, to }` | Row dragged to a new place (data indices) |
 | `data-import` | `{ count }` | Rows imported from a file |
@@ -834,6 +854,7 @@ The hook returns:
 | `sortCriteria` / `onSortChange` | Bind `onSortChange` to the table's `sort-change` event |
 | `search` / `setSearch` | Current search term and its setter (resets to page 0) |
 | `refresh` | Re-run the current request |
+| `fetchAll` | The whole result of the current conditions — the source's `fetchAll` (below), for exporting what the list shows |
 
 #### Search semantics
 
@@ -888,6 +909,7 @@ off();                                                          // the last unsu
 | `setSort(criteria)` / `setSearch(term)` | Change the sort or search and go back to page 0 |
 | `refresh()` | Re-read with the same conditions (nothing while `enabled: false`) |
 | `update(url, options)` | New options. Only a changed request re-reads; a changed `fixedFilter` value goes back to page 0; a changed `pageSize` value takes effect (page 0), the same value again keeps the size `setPageSize` set; `initial*` are read at creation only |
+| `fetchAll(options?)` | `Promise<T[]>` — **the whole result of the current sort, search and fixed filter**: no `$top`/`$skip`, following `@odata.nextLink` to the end. For an export of what the list shows. Leaves the state alone and needs no subscriber. Options: `maxRows` (default `100000` — past it, it rejects with `RowLimitError` instead of cutting; when the server counts, on the first response), `signal`, `onProgress(loaded, total)`. A failed request rejects with `SourceRequestError` (`failure` is the `SourceError`) |
 
 Changes made in the same tick become one request with the final conditions, so `setSearch` followed by `setPage` does not send the intermediate one.
 
@@ -954,8 +976,8 @@ count after search (not a server-reported total), and `loading`/`error` are alwa
 "refresh" button wired unconditionally against either hook doesn't need a branch.
 
 Without React, `createArraySource(rows, options)` (`@iyulab/flex-table/array`) is the same source with the same
-members as `createODataSource` — `getState()`, `subscribe()`, `setPage`, `setPageSize`, `setSort`, `setSearch`, `refresh` (no-op) —
-plus `update(rows, options)` when the rows change. `ArraySourceController` binds it to a Lit element (from rows, or an existing source):
+members as `createODataSource` — `getState()`, `subscribe()`, `setPage`, `setPageSize`, `setSort`, `setSearch`, `refresh` (no-op),
+`fetchAll` (the whole searched and sorted result, same options and `RowLimitError`) — plus `update(rows, options)` when the rows change. `ArraySourceController` binds it to a Lit element (from rows, or an existing source):
 
 ```ts
 import { LitElement } from 'lit';

package/dist/array/index.d.ts

@@ -2,3 +2,6 @@ export { computeArrayView } from './view.js';
 export type { ComputeArrayViewOptions } from './view.js';
 export { createArraySource, ArraySourceController } from './source.js';
 export type { ArraySource, ArraySourceOptions } from './source.js';
+export { DEFAULT_MAX_ROWS } from '../core/fetch-all.js';
+export type { FetchAllOptions } from '../core/fetch-all.js';
+export { RowLimitError } from '../core/source-error.js';

package/dist/array/index.js

@@ -1,65 +1,73 @@
-import { i as e } from "../query-Dw4iO0ir.js";
-import { t } from "../view-DiLr-TdY.js";
+import { n as e, t, u as n } from "../fetch-all-J37bOtgc.js";
+import { n as r, t as i } from "../view-BtoXdUGF.js";
 //#region src/array/source.ts
-function n(n, r = {}) {
-	let i = n, a = r, o = e({
-		defaultOrderBy: r.defaultOrderBy,
-		initialPage: r.initialPage ?? 0,
-		initialSearch: r.initialSearch ?? "",
-		initialSort: r.initialSort
-	}), s = o.page, c = o.sortCriteria, l = o.search, u = r.pageSize ?? 20, d = p(), f = /* @__PURE__ */ new Set();
-	function p() {
-		let e = t(i, {
-			search: l,
-			sortCriteria: c,
-			page: s,
-			pageSize: u,
-			columns: a.columns,
-			searchFields: a.searchFields
-		}), n = e.totalCount === 0 ? 0 : Math.ceil(e.totalCount / u) - 1;
-		return s > n && (s = n), {
+function a(e, t = {}) {
+	let a = e, o = t, s = n({
+		defaultOrderBy: t.defaultOrderBy,
+		initialPage: t.initialPage ?? 0,
+		initialSearch: t.initialSearch ?? "",
+		initialSort: t.initialSort
+	}), c = s.page, l = s.sortCriteria, u = s.search, d = t.pageSize ?? 20, f = m(), p = /* @__PURE__ */ new Set();
+	function m() {
+		let e = i(a, {
+			search: u,
+			sortCriteria: l,
+			page: c,
+			pageSize: d,
+			columns: o.columns,
+			searchFields: o.searchFields
+		}), t = e.totalCount === 0 ? 0 : Math.ceil(e.totalCount / d) - 1;
+		return c > t && (c = t), {
 			data: e.data,
 			totalCount: e.totalCount,
 			loading: !1,
 			error: null,
-			page: s,
-			pageSize: u,
-			sortCriteria: c,
-			search: l
+			page: c,
+			pageSize: d,
+			sortCriteria: l,
+			search: u
 		};
 	}
-	function m() {
-		d = p();
-		for (let e of [...f]) e();
+	function h() {
+		f = m();
+		for (let e of [...p]) e();
 	}
 	return {
-		getState: () => d,
+		getState: () => f,
 		subscribe(e) {
-			return f.add(e), () => {
-				f.delete(e);
+			return p.add(e), () => {
+				p.delete(e);
 			};
 		},
 		setPage(e) {
-			s = e, m();
+			c = e, h();
 		},
 		setPageSize(e) {
-			e !== u && (u = e, s = 0, m());
+			e !== d && (d = e, c = 0, h());
 		},
 		setSort(e) {
-			c = e, s = 0, m();
+			l = e, c = 0, h();
 		},
 		setSearch(e) {
-			l = e, s = 0, m();
+			u = e, c = 0, h();
 		},
 		refresh() {},
+		fetchAll(e) {
+			return r(a, {
+				search: u,
+				sortCriteria: l,
+				columns: o.columns,
+				searchFields: o.searchFields
+			}, e);
+		},
 		update(e, t = {}) {
-			t.pageSize !== void 0 && t.pageSize !== a.pageSize && t.pageSize !== u && (u = t.pageSize, s = 0), i = e, a = t, m();
+			t.pageSize !== void 0 && t.pageSize !== o.pageSize && t.pageSize !== d && (d = t.pageSize, c = 0), a = e, o = t, h();
 		}
 	};
 }
-var r = class {
-	constructor(e, t, r = {}) {
-		this.host = e, this.source = Array.isArray(t) ? n(t, r) : t, e.addController(this);
+var o = class {
+	constructor(e, t, n = {}) {
+		this.host = e, this.source = Array.isArray(t) ? a(t, n) : t, e.addController(this);
 	}
 	get state() {
 		return this.source.getState();
@@ -72,4 +80,4 @@ var r = class {
 	}
 };
 //#endregion
-export { r as ArraySourceController, t as computeArrayView, n as createArraySource };
+export { o as ArraySourceController, t as DEFAULT_MAX_ROWS, e as RowLimitError, i as computeArrayView, a as createArraySource };

package/dist/array/source.d.ts

@@ -3,6 +3,7 @@ import type { SortCriteria } from '../core/sorting.js';
 import type { DataRow } from '../models/types.js';
 import type { ODataSourceState } from '../odata/source.js';
 import type { UseArraySourceOptions } from './types.js';
+import type { FetchAllOptions } from '../core/fetch-all.js';
 /** 메모리 소스의 설정 — `useArraySource` 의 옵션과 같다(`initial*` 은 만들 때만 읽는다). */
 export type ArraySourceOptions<T> = UseArraySourceOptions<T>;
 /** 메모리 소스 — `createODataSource` 와 같은 상태·조작 모양이라 같은 표 배선이 두 소스에서 돈다. */
@@ -23,6 +24,8 @@ export interface ArraySource<T> {
     refresh(): void;
     /** 행이나 설정이 바뀌었다 — 다시 계산한다. 결과가 줄어 지금 페이지가 없어지면 마지막 페이지로 내려온다. */
     update(data: T[], options?: ArraySourceOptions<T>): void;
+    /** 지금 검색·정렬의 결과 전체(페이지 없이) — `createODataSource` 의 `fetchAll` 과 같은 계약(상한 · 취소 · 진행). */
+    fetchAll(options?: FetchAllOptions): Promise<T[]>;
 }
 /**
  * 이미 메모리에 있는 행의 데이터 소스 — 검색·정렬·페이지 나누기를 로컬에서 한다(`computeArrayView`). React 없이 쓴다;

package/dist/array/types.d.ts

@@ -1,5 +1,6 @@
 import type { SortCriteria } from '../core/sorting.js';
 import type { SourceError } from '../core/source-error.js';
+import type { FetchAllOptions } from '../core/fetch-all.js';
 export interface UseArraySourceOptions<T> {
     /** 페이지당 행 수. `useODataSource`와 동일 기본값. */
     pageSize?: number;
@@ -51,4 +52,6 @@ export interface UseArraySourceResult<T> {
     /** no-op — 로컬 배열에는 다시 불러올 원격 상태가 없다. 소비자가 `useODataSource`와
      *  같은 자리에 무조건 배선한 refresh 버튼이 있어도 안전하게 아무 일도 하지 않는다. */
     refresh: () => void;
+    /** 지금 검색·정렬의 결과 전체(페이지 없이) — `useODataSource` 의 `fetchAll` 과 같은 계약. 내보내기에 쓴다. */
+    fetchAll: (options?: FetchAllOptions) => Promise<T[]>;
 }

package/dist/array/view.d.ts

@@ -1,5 +1,6 @@
 import type { SortCriteria } from '../core/sorting.js';
 import type { ColumnDefinition, DataRow } from '../models/types.js';
+import { type FetchAllOptions } from '../core/fetch-all.js';
 export interface ComputeArrayViewOptions<T> {
     search: string;
     sortCriteria: SortCriteria[];
@@ -22,3 +23,8 @@ export declare function computeArrayView<T extends DataRow>(data: T[], { search,
     data: T[];
     totalCount: number;
 };
+/**
+ * 페이지 없이 — 검색·정렬만 적용한 결과 전체. 메모리 소스의 `fetchAll`(소스·훅 둘 다)이 이것을 부른다. OData 소스와
+ * 같은 계약이다: 상한을 넘으면 `RowLimitError`, 거둔 신호면 `AbortError`, 진행 콜백은 한 번(전부 한 «페이지»).
+ */
+export declare function readAllArrayRows<T extends DataRow>(data: T[], view: Omit<ComputeArrayViewOptions<T>, 'page' | 'pageSize'>, { maxRows, signal, onProgress }?: FetchAllOptions): Promise<T[]>;

package/dist/core/fetch-all.d.ts

@@ -0,0 +1,14 @@
+/** `fetchAll` 의 옵션 — 두 소스가 같은 모양이다. */
+export interface FetchAllOptions {
+    /**
+     * 읽을 수 있는 행의 상한. 기본값 `100000`(`DEFAULT_MAX_ROWS`). 결과가 이보다 크면 **잘라서 주지 않고**
+     * `RowLimitError` 로 거절한다 — OData 소스는 서버가 센 개수(`@odata.count`)로 첫 응답에서 알면 더 읽지 않는다.
+     */
+    maxRows?: number;
+    /** 취소. 거두면 `AbortError` 로 거절한다. */
+    signal?: AbortSignal;
+    /** 페이지를 하나 받을 때마다 — 받은 행 수와 전체(서버가 세지 않았으면 `undefined`). */
+    onProgress?: (loaded: number, total: number | undefined) => void;
+}
+/** «전부 읽기» 의 기본 상한 — 브라우저 메모리와 서버 부하를 지키는 선. 넘으면 조용히 자르지 않고 거절한다. */
+export declare const DEFAULT_MAX_ROWS = 100000;

package/dist/core/source-error.d.ts

@@ -31,11 +31,23 @@ export interface SourceError {
 }
 /** 실패 응답을 `SourceError` 로 읽는다. 본문을 읽을 수 없어도 상태와 기본 문장은 남긴다. */
 export declare function readFailedResponse(res: Response): Promise<SourceError>;
-/** 실패 응답을 실어 나르는 내부 예외 — `catch` 가 상태를 잃지 않고 `SourceError` 를 꺼낸다. */
+/**
+ * 소스 요청의 실패 — `failure` 가 `SourceError`(상태 · 거절 코드 · 상세)다. `fetchAll` 은 이것으로 거절한다(상한을 넘으면
+ * 하위 `RowLimitError`). 화면에는 `failure.message`. 상태로 드러나는 실패(`error`)는 이 `failure` 그대로다.
+ */
 export declare class SourceRequestError extends Error {
     readonly failure: SourceError;
     constructor(failure: SourceError);
 }
+/**
+ * 조회 결과가 «전부 읽기» 의 상한(`maxRows`)을 넘었다 — 잘라서 주지 않고 거절한 것이다. 화면에는 `failure.message` 를
+ * 그린다(로케일 `tooManyRows`). `total` 은 서버가 센 행 수(`@odata.count`)이고, 서버가 세지 않았으면 없다.
+ */
+export declare class RowLimitError extends SourceRequestError {
+    readonly total: number | undefined;
+    readonly maxRows: number;
+    constructor(maxRows: number, total?: number);
+}
 /** 전송이 응답 없이 던진 실패(네트워크 · 오프라인)를 `SourceError` 로 — 브라우저마다 다른 예외 문구 대신 로케일 문장. */
 export declare function networkFailure(cause: unknown): SourceRequestError;
 /** 잡힌 예외를 `SourceError` 로 — 응답이 있던 실패는 그 구조 그대로, 나머지는 메시지만. */

package/dist/events.d.ts

@@ -84,11 +84,16 @@ export interface FlexTableEventMap {
         from: number;
         to: number;
     }>;
-    /** Enter on a non-editable cell — "activate this row". `index` is the data index, `col` the visible column index. */
-    /** `id` — the row's id (`getRowId`); `index` — its position in `data`; `key` — the active column's key. */
+    /**
+     * "Open this row": a plain click on a body cell, or Enter on a non-editable cell. `via` tells them apart.
+     * Not a click that selects a range (Shift / Ctrl / Cmd), ends a drag, or presses a control the cell renders.
+     * `id` — the row's id (`getRowId`); `index` — its position in `data`; `col` — the visible column index;
+     * `key` — that column's key.
+     */
     'row-activate': CustomEvent<{
         row: DataRow;
         id: string;
+        via: 'click' | 'keyboard';
         index: number;
         col: number;
         key: string | undefined;
@@ -97,8 +102,13 @@ export interface FlexTableEventMap {
     'batch-update': CustomEvent<{
         changes: CellChange[];
     }>;
-    /** The active cell moved; `null` when there is none. */
-    'cell-select': CustomEvent<CellPosition | null>;
+    /**
+     * The active cell moved — by pointer, keyboard, or focus arriving on the grid; `null` when there is none.
+     * `row`/`col` are visible positions, `id` the row's id. This is focus, not a choice: open a row on `row-activate`.
+     */
+    'cell-select': CustomEvent<(CellPosition & {
+        id: string;
+    }) | null>;
     /** `row` is the data index, `col` the visible column index. */
     'cell-edit-start': CustomEvent<{
         row: number;

package/dist/fetch-all-J37bOtgc.js

@@ -0,0 +1,86 @@
+import { n as e } from "./locale-D9g0ksXq.js";
+import t from "odata-query";
+//#region src/odata/query.ts
+function n(e) {
+	let t = e.split(/\s+/).map((e) => e.replace(/"/g, "")).filter((e) => e.length > 0);
+	if (t.length !== 0) return t.map((e) => `"${e}"`).join(" AND ");
+}
+function r(e) {
+	let { defaultOrderBy: t, initialPage: n = 0, initialSearch: r = "", initialSort: a } = e;
+	return {
+		page: n,
+		search: r,
+		sortCriteria: a ?? (t ? i(t) : [])
+	};
+}
+function i(e) {
+	return e.split(",").map((e) => {
+		let t = e.trim().split(/\s+/);
+		return {
+			key: t[0],
+			direction: t[1]?.toLowerCase() === "desc" ? "desc" : "asc"
+		};
+	});
+}
+function a(e) {
+	let { page: r = 0, pageSize: i, sortCriteria: a = [], defaultOrderBy: o, search: s, fixedFilter: c } = e, l = a.length > 0 ? a.map((e) => `${e.key} ${e.direction}`).join(", ") : o, u = i === void 0 ? { count: !0 } : {
+		top: i,
+		skip: r * i,
+		count: !0
+	};
+	if (l && (u.orderBy = l), c && (u.filter = c), s) {
+		let e = n(s);
+		e && (u.search = e);
+	}
+	return t(u);
+}
+//#endregion
+//#region src/core/source-error.ts
+async function o(t) {
+	let n = await t.text().catch(() => ""), r = {
+		message: e("requestFailed", { status: t.status }),
+		status: t.status
+	};
+	if (!n) return r;
+	let i = n;
+	try {
+		i = JSON.parse(n);
+	} catch {}
+	if (r.body = i, !i || typeof i != "object") return r;
+	let a = i, o = a.error && typeof a.error == "object" ? a.error : a;
+	typeof o.message == "string" && o.message ? r.message = o.message : typeof a.message == "string" && a.message && (r.message = a.message), typeof o.code == "string" && o.code && (r.code = o.code);
+	let c = s(o.details);
+	return c && (r.details = c), r;
+}
+function s(e) {
+	if (!Array.isArray(e)) return;
+	let t = e.filter((e) => {
+		if (!e || typeof e != "object") return !1;
+		let t = e;
+		return typeof t.code == "string" && typeof t.message == "string";
+	});
+	return t.length > 0 ? t : void 0;
+}
+var c = class extends Error {
+	constructor(e) {
+		super(e.message), this.name = "SourceRequestError", this.failure = e;
+	}
+}, l = class extends c {
+	constructor(t, n) {
+		super({ message: e("tooManyRows", { maxRows: t }) }), this.name = "RowLimitError", this.total = n, this.maxRows = t;
+	}
+};
+function u(t) {
+	return new c({
+		message: e("networkFailed"),
+		cause: t
+	});
+}
+function d(e) {
+	return e instanceof c ? e.failure : e instanceof Error ? { message: e.message } : { message: String(e) };
+}
+//#endregion
+//#region src/core/fetch-all.ts
+var f = 1e5;
+//#endregion
+export { o as a, n as c, u as i, i as l, l as n, d as o, c as r, a as s, f as t, r as u };