@urbicon-ui/sveltekit-utils 7.0.1 → 8.0.0

package/dist/table-view.js

@@ -0,0 +1,241 @@
+/**
+ * URL (de)serialization for the v8 table view vocabulary (`TableView` from
+ * `@urbicon-ui/table`: search, sort, page, pageSize, filters, groupBy).
+ *
+ * The types in this module are a **structural mirror** of the table package's
+ * view types — deliberately not imported, so this package carries no
+ * dependency on `@urbicon-ui/table`. A type-parity test over there guards the
+ * shapes against drift; `bindViewToUrl` accepts any object shaped like
+ * {@link TableViewLike}, which the real `TableView` is.
+ *
+ * The key scheme is the shipped one (`q`, `page`, `size`, `sort`, `dir`,
+ * `group`, `filter`) — deep links written for v7 keep parsing. The write
+ * side adds one compatible extension: an empty `filter=` marker, analogous
+ * to `sort=`, so a cleared filter set elides like every other axis (the
+ * shipped read side already tolerated it).
+ */
+import { TABLE_QUERY_FILTER_OPERATORS } from './table-query.js';
+/** All six view axes, in vocabulary order. */
+export const TABLE_VIEW_AXES = [
+    'search',
+    'sort',
+    'page',
+    'pageSize',
+    'filters',
+    'groupBy'
+];
+/** URL keys per axis, unprefixed — the §3.2 key scheme, grouped by owning axis. */
+const AXIS_KEYS = {
+    search: ['q'],
+    sort: ['sort', 'dir'],
+    page: ['page'],
+    pageSize: ['size'],
+    filters: ['filter'],
+    groupBy: ['group']
+};
+/** The URL keys a set of axes owns, with the configured prefix applied. */
+export function viewAxisKeys(axes, prefix = '') {
+    return axes.flatMap((axis) => AXIS_KEYS[axis].map((key) => `${prefix}${key}`));
+}
+function isFilterOperator(value) {
+    return TABLE_QUERY_FILTER_OPERATORS.includes(value);
+}
+/** Same per-entry tolerance as the table-query parser: malformed → null → skipped. */
+function parseFilterParam(raw) {
+    const parts = raw.split(':');
+    if (parts.length !== 3)
+        return null;
+    const [encodedColumn, operator, encodedValue] = parts;
+    if (!isFilterOperator(operator))
+        return null;
+    try {
+        const column = decodeURIComponent(encodedColumn);
+        if (!column)
+            return null;
+        return { column, operator, value: decodeURIComponent(encodedValue) };
+    }
+    catch {
+        return null;
+    }
+}
+/** The axes a URL names — presence only for params it actually carries. */
+export function viewAxesNamedBy(sp, prefix = '') {
+    const axes = [];
+    if (sp.get(`${prefix}q`) !== null)
+        axes.push('search');
+    if (sp.get(`${prefix}sort`) !== null)
+        axes.push('sort');
+    if (sp.get(`${prefix}page`) !== null)
+        axes.push('page');
+    if (sp.get(`${prefix}size`) !== null)
+        axes.push('pageSize');
+    if (sp.getAll(`${prefix}filter`).length > 0)
+        axes.push('filters');
+    if (sp.get(`${prefix}group`) !== null)
+        axes.push('groupBy');
+    return axes;
+}
+/**
+ * Parse search params into a **partial** view snapshot — a key per axis the
+ * URL actually carries, and nothing else. Read tolerant per key: an
+ * unparsable value on a *present* key falls back to the configured default
+ * for that axis (the key was present, so the axis stays claimed), and
+ * malformed filter entries are skipped individually.
+ */
+export function searchParamsToViewPartial(sp, defaults, prefix = '') {
+    const partial = {};
+    const rawSearch = sp.get(`${prefix}q`);
+    if (rawSearch !== null)
+        partial.search = rawSearch;
+    const rawSort = sp.get(`${prefix}sort`);
+    if (rawSort !== null) {
+        partial.sort =
+            rawSort === ''
+                ? null // `sort: null` — "unsorted" is a value, not a sentinel
+                : { column: rawSort, direction: sp.get(`${prefix}dir`) === 'desc' ? 'desc' : 'asc' };
+    }
+    const rawPage = sp.get(`${prefix}page`);
+    if (rawPage !== null && /^\d+$/.test(rawPage) && Number(rawPage) >= 1) {
+        partial.page = Number(rawPage);
+    }
+    else if (rawPage !== null) {
+        partial.page = defaults.page;
+    }
+    const rawSize = sp.get(`${prefix}size`);
+    if (rawSize !== null && /^\d+$/.test(rawSize) && Number(rawSize) >= 1) {
+        partial.pageSize = Number(rawSize);
+    }
+    else if (rawSize !== null) {
+        partial.pageSize = defaults.pageSize;
+    }
+    // `filter=` (empty marker) and `filter=a:contains:b` both claim the axis;
+    // the empty marker claims it as *empty* — the compatible format extension.
+    const rawFilters = sp.getAll(`${prefix}filter`);
+    if (rawFilters.length > 0) {
+        partial.filters = rawFilters
+            .map(parseFilterParam)
+            .filter((f) => f !== null);
+    }
+    const rawGroup = sp.get(`${prefix}group`);
+    if (rawGroup !== null)
+        partial.groupBy = rawGroup === '' ? null : rawGroup;
+    return partial;
+}
+/**
+ * Resolve a full view snapshot from search params: every axis the URL names
+ * comes from the URL, every other one from `defaults` — the same resolution
+ * the URL binding performs at init, for code that has no view (a server
+ * `load`).
+ */
+export function searchParamsToViewSnapshot(sp, defaults = {}, prefix = '') {
+    const resolved = resolveViewDefaults(defaults);
+    return { ...resolved, ...searchParamsToViewPartial(sp, resolved, prefix) };
+}
+/** Fill an unset axis with the table's own default — never `undefined` anywhere. */
+function resolveViewDefaults(defaults) {
+    return {
+        search: defaults.search ?? '',
+        sort: defaults.sort ?? null,
+        page: defaults.page ?? 1,
+        pageSize: defaults.pageSize ?? 10,
+        filters: defaults.filters ?? [],
+        groupBy: defaults.groupBy || null
+    };
+}
+/**
+ * Project a view snapshot into the wire shape a backend speaks — the same
+ * mapping the table applies before calling a managed `source.query`, so a
+ * server `load` and the table's own fetches send identical field names.
+ */
+export function viewSnapshotToTableQuery(snapshot) {
+    return {
+        page: snapshot.page,
+        itemsPerPage: snapshot.pageSize,
+        sortColumn: snapshot.sort?.column ?? '',
+        sortDirection: snapshot.sort?.direction ?? 'asc',
+        searchTerm: snapshot.search,
+        activeFilters: [...snapshot.filters],
+        groupByKey: snapshot.groupBy
+    };
+}
+/**
+ * The load-path counterpart of the URL binding: parse search params against
+ * the **view's own defaults** and hand back the query a fetch needs.
+ *
+ * The point is the defaults argument. `searchParamsToTableQuery` takes its
+ * baseline in the wire vocabulary (`itemsPerPage`, `sortColumn`/`sortDirection`,
+ * `groupByKey`) and has no field for filters at all, so a `load` had to keep a
+ * second, differently-spelled copy of what `createTableView({ defaults })`
+ * already says — and could not express a default filter set no matter how it
+ * was written (#157 finding 2). This one takes the very object the view takes:
+ * one spelling, all six axes, so the server cannot resolve an absent param
+ * differently from the client.
+ *
+ * @example
+ * ```ts
+ * // shared with the component that calls createTableView({ defaults })
+ * export const invoiceView = { pageSize: 25, sort: { column: 'date', direction: 'desc' } };
+ *
+ * export const load = async ({ url }) => ({
+ *   initialResult: await fetchInvoices(searchParamsToViewQuery(url.searchParams, invoiceView))
+ * });
+ * ```
+ */
+export function searchParamsToViewQuery(sp, defaults = {}, prefix = '') {
+    return viewSnapshotToTableQuery(searchParamsToViewSnapshot(sp, defaults, prefix));
+}
+/**
+ * Serialize a snapshot, eliding every axis that equals the defaults — the
+ * elision baseline *is* the view's defaults, structurally. `axes` restricts
+ * the output to a binding's own axes: an unbound axis never reaches the URL,
+ * no matter what the view holds.
+ */
+export function viewSnapshotToSearchParams(snapshot, defaults, axes = TABLE_VIEW_AXES, prefix = '') {
+    const sp = new URLSearchParams();
+    const bound = (axis) => axes.includes(axis);
+    if (bound('search') && snapshot.search !== defaults.search)
+        sp.set(`${prefix}q`, snapshot.search);
+    if (bound('page') && snapshot.page !== defaults.page)
+        sp.set(`${prefix}page`, String(snapshot.page));
+    if (bound('pageSize') && snapshot.pageSize !== defaults.pageSize)
+        sp.set(`${prefix}size`, String(snapshot.pageSize));
+    // `bound('sort')` gates BOTH branches — gating only the null-mismatch one
+    // let an unbound sort leak into the URL (an operator-precedence slip the
+    // spike caught; pinned by the axis-subset test).
+    const sortDiffers = bound('sort') &&
+        ((snapshot.sort === null) !== (defaults.sort === null) ||
+            (snapshot.sort !== null &&
+                defaults.sort !== null &&
+                (snapshot.sort.column !== defaults.sort.column ||
+                    snapshot.sort.direction !== defaults.sort.direction)));
+    if (sortDiffers) {
+        if (snapshot.sort === null) {
+            sp.set(`${prefix}sort`, ''); // explicitly unsorted — only reachable when defaults sort
+        }
+        else {
+            sp.set(`${prefix}sort`, snapshot.sort.column);
+            if (snapshot.sort.direction === 'desc')
+                sp.set(`${prefix}dir`, 'desc');
+        }
+    }
+    if (bound('groupBy') && snapshot.groupBy !== defaults.groupBy)
+        sp.set(`${prefix}group`, snapshot.groupBy ?? '');
+    const filtersDiffer = bound('filters') &&
+        (snapshot.filters.length !== defaults.filters.length ||
+            snapshot.filters.some((f, i) => f.column !== defaults.filters[i].column ||
+                f.operator !== defaults.filters[i].operator ||
+                f.value !== defaults.filters[i].value));
+    if (filtersDiffer) {
+        if (snapshot.filters.length === 0) {
+            // The format extension: an empty marker, analogous to `sort=`, so a
+            // cleared filter set elides like every other axis.
+            sp.set(`${prefix}filter`, '');
+        }
+        else {
+            for (const filter of snapshot.filters) {
+                sp.append(`${prefix}filter`, `${encodeURIComponent(filter.column)}:${filter.operator}:${encodeURIComponent(filter.value)}`);
+            }
+        }
+    }
+    return sp;
+}

package/dist/url.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type TableQueryParams, type TableQueryUrlOptions, type TableQueryViewState } from './table-query.js';
+export { bindViewToUrl, type UrlViewBindingOptions } from './view-binding.svelte.js';
 /**
  * How {@link useUrlArrayParam} maps an array onto the URL:
  * - `repeat` — one entry per key: `?tag=a&tag=b`
@@ -134,103 +134,3 @@ export declare function useUrlArrayParam(key: string, opts: {
     strategy?: UrlArrayStrategy;
     delimiter?: string;
 }): readonly [() => string[], (next: string[]) => void];
-/** Options for {@link createTableQueryUrlSync}. */
-export interface TableQueryUrlSyncOptions extends TableQueryUrlOptions {
-    /**
-     * Replace the current history entry instead of pushing a new one. The
-     * default (`true`) keeps every sort/filter/page interaction from polluting
-     * the back button.
-     * @default true
-     */
-    replaceState?: boolean;
-}
-/**
- * Opt-in URL sync for a table: mirrors the `TableQuery` the table emits onto
- * `?q=…&sort=…&page=…` query params, so the view state survives reloads, can
- * be shared as a link, and — unlike `localStorage` — is visible to the server.
- * Works in client mode as well as server mode; the table emits its query in
- * both.
- *
- * Two directions, both explicit:
- * - **URL → query**: `viewState` carries the axes the URL actually names, and
- *   re-reads the URL on every navigation. Hand it to the table's `query` prop,
- *   which controls exactly those axes — per field, and ahead of both
- *   `persistenceConfig` and the `initial*` seeds. Because a controlled axis is
- *   a derived rather than a write, it resolves during server rendering too,
- *   which is the point: the server renders the view the link asked for instead
- *   of a default one the client swaps out on hydration.
- * - **query → URL**: pass `syncQuery` the query from `onQueryChange`, or call
- *   it inside `queryFn` (when `queryFn` is set, `onQueryChange` does not
- *   fire). It rewrites only its own — optionally prefixed — params via
- *   `goto` (`replaceState`, `noScroll`, `keepFocus`); unrelated params are
- *   preserved. Values equal to `options.defaults` are elided, so a table in
- *   its default state leaves the URL clean.
- *
- * Set `options.defaults` to the table's initial props (`itemsPerPage`,
- * `initialPage`, `initialGroupBy`) so the elision baseline matches the state
- * the table actually starts in.
- *
- * @example Client mode — the whole wiring is two props
- * ```svelte
- * <script lang="ts">
- *   import { Table } from '@urbicon-ui/table';
- *   import { createTableQueryUrlSync } from '@urbicon-ui/sveltekit-utils/url.svelte';
- *
- *   const sync = createTableQueryUrlSync({ defaults: { itemsPerPage: 25 } });
- * </script>
- *
- * <Table {items} {columns} query={sync.viewState} onQueryChange={sync.syncQuery} />
- * ```
- *
- * `query` is a *controlled* prop, which is what makes this work on the server:
- * the URL is parsed during SSR and the table renders the linked view rather
- * than an unfiltered one the client then replaces. It also outranks
- * `persistenceConfig` per axis, so there is no longer a caveat about a stored
- * value beating the link.
- *
- * Pass `viewState`, never `initialQuery`. `initialQuery` describes **every**
- * axis, so as a `query` value it claims every axis — including the ones the URL
- * says nothing about, whose values it filled in from the defaults. A table
- * wired that way ignores `persistenceConfig`, `initialSort`, `initialFilters`
- * and `initialGroupBy` entirely, on any URL, and says nothing about it.
- *
- * @example Server mode — the same two directions, with the fetch in between
- * ```svelte
- * <script lang="ts">
- *   const sync = createTableQueryUrlSync({ defaults: { itemsPerPage: 25 } });
- * </script>
- *
- * <Table
- *   mode="server"
- *   {columns}
- *   itemsPerPage={25}
- *   query={sync.viewState}
- *   queryFn={async (query, { signal }) => {
- *     sync.syncQuery(query);
- *     const res = await fetch(`/api/users?${new URLSearchParams(...)}`, { signal });
- *     const data = await res.json();
- *     return { items: data.results, totalItems: data.total };
- *   }}
- * />
- * ```
- *
- * @param options - Elision defaults, key prefix, history behaviour.
- * @returns `viewState` (the controlled axes, re-read on every navigation),
- *   `initialQuery` (a complete snapshot for a fetch) + `syncQuery` (write a
- *   query back to the URL).
- */
-export declare function createTableQueryUrlSync(options?: TableQueryUrlSyncOptions): {
-    /**
-     * The axes the URL names, re-read on every navigation.
-     *
-     * A getter, not a captured value: `createTableQueryUrlSync` runs once per
-     * page component, and SvelteKit does not remount that component when only
-     * the query string changes. A snapshot would therefore never see the back
-     * button — the table would stay sorted after the user navigated back to a
-     * URL with no sort param. Reading `page.url` here makes every consumer of
-     * this getter a reader of SvelteKit's own reactive page state.
-     */
-    readonly viewState: TableQueryViewState;
-    readonly initialQuery: TableQueryParams;
-    readonly syncQuery: (query: TableQueryParams) => void;
-};

package/dist/url.svelte.js

@@ -1,7 +1,15 @@
 import { building } from '$app/environment';
 import { goto } from '$app/navigation';
 import { page } from '$app/state';
-import { applyTableQueryToSearchParams, searchParamsToTableQuery, searchParamsToTableViewState } from './table-query.js';
+// The v8 view-object binding lives in its own module; re-exported here so the
+// documented import path (`@urbicon-ui/sveltekit-utils/url.svelte`) carries it.
+// The mirror types (TableViewLike, TableViewSnapshot, …) are exported from the
+// package root via `table-view` — not re-exported here, which would make the
+// root's star exports ambiguous and silently drop them. The v7
+// `createTableQueryUrlSync` factory is gone with the table's `query` prop —
+// the URL home of a table view is `bindViewToUrl`; the load-path serializers
+// (`searchParamsToTableQuery` & friends) live on in `table-query`.
+export { bindViewToUrl } from './view-binding.svelte.js';
 /**
  * Low-level escape hatch to update several params at once via `goto` (without a
  * full navigation). Starts from the current URL, applies `next`, and keeps
@@ -175,112 +183,3 @@ export function useUrlArrayParam(key, opts) {
     };
     return useUrlParam(key, { parse, serialize, initial: opts.initial });
 }
-/**
- * Opt-in URL sync for a table: mirrors the `TableQuery` the table emits onto
- * `?q=…&sort=…&page=…` query params, so the view state survives reloads, can
- * be shared as a link, and — unlike `localStorage` — is visible to the server.
- * Works in client mode as well as server mode; the table emits its query in
- * both.
- *
- * Two directions, both explicit:
- * - **URL → query**: `viewState` carries the axes the URL actually names, and
- *   re-reads the URL on every navigation. Hand it to the table's `query` prop,
- *   which controls exactly those axes — per field, and ahead of both
- *   `persistenceConfig` and the `initial*` seeds. Because a controlled axis is
- *   a derived rather than a write, it resolves during server rendering too,
- *   which is the point: the server renders the view the link asked for instead
- *   of a default one the client swaps out on hydration.
- * - **query → URL**: pass `syncQuery` the query from `onQueryChange`, or call
- *   it inside `queryFn` (when `queryFn` is set, `onQueryChange` does not
- *   fire). It rewrites only its own — optionally prefixed — params via
- *   `goto` (`replaceState`, `noScroll`, `keepFocus`); unrelated params are
- *   preserved. Values equal to `options.defaults` are elided, so a table in
- *   its default state leaves the URL clean.
- *
- * Set `options.defaults` to the table's initial props (`itemsPerPage`,
- * `initialPage`, `initialGroupBy`) so the elision baseline matches the state
- * the table actually starts in.
- *
- * @example Client mode — the whole wiring is two props
- * ```svelte
- * <script lang="ts">
- *   import { Table } from '@urbicon-ui/table';
- *   import { createTableQueryUrlSync } from '@urbicon-ui/sveltekit-utils/url.svelte';
- *
- *   const sync = createTableQueryUrlSync({ defaults: { itemsPerPage: 25 } });
- * </script>
- *
- * <Table {items} {columns} query={sync.viewState} onQueryChange={sync.syncQuery} />
- * ```
- *
- * `query` is a *controlled* prop, which is what makes this work on the server:
- * the URL is parsed during SSR and the table renders the linked view rather
- * than an unfiltered one the client then replaces. It also outranks
- * `persistenceConfig` per axis, so there is no longer a caveat about a stored
- * value beating the link.
- *
- * Pass `viewState`, never `initialQuery`. `initialQuery` describes **every**
- * axis, so as a `query` value it claims every axis — including the ones the URL
- * says nothing about, whose values it filled in from the defaults. A table
- * wired that way ignores `persistenceConfig`, `initialSort`, `initialFilters`
- * and `initialGroupBy` entirely, on any URL, and says nothing about it.
- *
- * @example Server mode — the same two directions, with the fetch in between
- * ```svelte
- * <script lang="ts">
- *   const sync = createTableQueryUrlSync({ defaults: { itemsPerPage: 25 } });
- * </script>
- *
- * <Table
- *   mode="server"
- *   {columns}
- *   itemsPerPage={25}
- *   query={sync.viewState}
- *   queryFn={async (query, { signal }) => {
- *     sync.syncQuery(query);
- *     const res = await fetch(`/api/users?${new URLSearchParams(...)}`, { signal });
- *     const data = await res.json();
- *     return { items: data.results, totalItems: data.total };
- *   }}
- * />
- * ```
- *
- * @param options - Elision defaults, key prefix, history behaviour.
- * @returns `viewState` (the controlled axes, re-read on every navigation),
- *   `initialQuery` (a complete snapshot for a fetch) + `syncQuery` (write a
- *   query back to the URL).
- */
-export function createTableQueryUrlSync(options = {}) {
-    // Same prerender rule as `useUrlParam`: no query string exists while
-    // building, so both readers parse from empty params instead of throwing.
-    const currentParams = () => (building ? new URLSearchParams() : page.url.searchParams);
-    // Parsed once, on purpose — a snapshot to seed a fetch with, not a source of
-    // truth. `viewState` below is the one the table binds to.
-    const initialQuery = searchParamsToTableQuery(currentParams(), options);
-    function syncQuery(query) {
-        const next = applyTableQueryToSearchParams(page.url.searchParams, query, options);
-        const qs = next.toString();
-        goto(`${page.url.pathname}${qs ? `?${qs}` : ''}${page.url.hash}`, {
-            replaceState: options.replaceState ?? true,
-            noScroll: true,
-            keepFocus: true
-        });
-    }
-    return {
-        /**
-         * The axes the URL names, re-read on every navigation.
-         *
-         * A getter, not a captured value: `createTableQueryUrlSync` runs once per
-         * page component, and SvelteKit does not remount that component when only
-         * the query string changes. A snapshot would therefore never see the back
-         * button — the table would stay sorted after the user navigated back to a
-         * URL with no sort param. Reading `page.url` here makes every consumer of
-         * this getter a reader of SvelteKit's own reactive page state.
-         */
-        get viewState() {
-            return searchParamsToTableViewState(currentParams(), options);
-        },
-        initialQuery,
-        syncQuery
-    };
-}

package/dist/view-binding.svelte.d.ts

@@ -0,0 +1,73 @@
+import { type TableViewAxis, type TableViewLike } from './table-view.js';
+/**
+ * Reset the module-scope writer between tests. The writer's pending-set and
+ * memo are keyed to a page's navigation stream; a test runner reusing the
+ * module across tests would otherwise leak one test's in-flight markers into
+ * the next.
+ * @internal test-only — not part of the public API.
+ */
+export declare function __resetUrlWriterForTests(): void;
+/**
+ * Size of the writer's live-key registry — lets the SSR suite assert that
+ * the module-global registry does not grow across simulated server requests.
+ * @internal test-only — not part of the public API.
+ */
+export declare function __urlWriterLiveKeyCountForTests(): number;
+/** Options for {@link bindViewToUrl}. */
+export interface UrlViewBindingOptions {
+    /** Axes to bind. @default all six */
+    axes?: readonly TableViewAxis[];
+    /** Debounce for view → URL writes in ms. @default 300 */
+    debounceMs?: number;
+    /**
+     * Replace the current history entry instead of pushing a new one, so rapid
+     * sort/filter/page edits do not flood the back button.
+     *
+     * Decided for v8: this default covers **all** binding writes — v7
+     * continuity, keeping interactions from polluting the back button — and
+     * there is deliberately no per-interaction-type history mapping (a page
+     * turn pushing while a keystroke replaces); this one global option is the
+     * whole knob. Mirror-only writes (`reflectExternal`) always replace,
+     * whatever this is set to.
+     * @default true
+     */
+    replaceState?: boolean;
+    /**
+     * Key prefix (`prefix: 't_'` → `?t_q=…&t_page=…`) — namespace for a second
+     * bound table on the same page.
+     * @default ''
+     */
+    prefix?: string;
+    /**
+     * Whether *external* changes (a storage seed) are mirrored into the URL.
+     *
+     * - `false` (default): the address bar does not change without a reader
+     *   interaction — a restored "yesterday's view" stays out of the URL until
+     *   the reader's first edit, which then serializes the full snapshot.
+     * - `true`: an external application reaches the URL immediately, always
+     *   via `replaceState` (a mirror is not a reader action, so it never
+     *   mints a history entry) — the restored state becomes shareable without
+     *   an interaction.
+     * @default false
+     */
+    reflectExternal?: boolean;
+}
+/**
+ * Bind a view to the page URL. Call during component initialisation: the
+ * init half runs synchronously (SSR-safe — a `?sort=…` link renders sorted
+ * server HTML), the runtime halves are effects.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { Table, createTableView } from '@urbicon-ui/table';
+ *   import { bindViewToUrl } from '@urbicon-ui/sveltekit-utils/url.svelte';
+ *
+ *   const view = createTableView({ defaults: { pageSize: 25 } });
+ *   bindViewToUrl(view);
+ * </script>
+ *
+ * <Table {items} {columns} {view} />
+ * ```
+ */
+export declare function bindViewToUrl(view: TableViewLike, options?: UrlViewBindingOptions): void;