@trackunit/react-components 3.12.4-alpha-07efa4379b2.0 → 4.0.1

package/translation4.cjs.js

@@ -2,7 +2,6 @@
 
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "uitklappen",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation4.esm.js

@@ -1,6 +1,5 @@
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "uitklappen",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation5.cjs.js

@@ -2,7 +2,6 @@
 
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "développer",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation5.esm.js

@@ -1,6 +1,5 @@
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "développer",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation6.cjs.js

@@ -2,7 +2,6 @@
 
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "laajenna",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation6.esm.js

@@ -1,6 +1,5 @@
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "laajenna",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation7.cjs.js

@@ -2,7 +2,6 @@
 
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "kibontás",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation7.esm.js

@@ -1,6 +1,5 @@
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "kibontás",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation8.cjs.js

@@ -2,7 +2,6 @@
 
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "espandi",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation8.esm.js

@@ -1,6 +1,5 @@
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "espandi",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation9.cjs.js

@@ -2,7 +2,6 @@
 
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "utvid",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/translation9.esm.js

@@ -1,6 +1,5 @@
 var translation = {
 	"breadcrumb.backButton": "Back",
-	"breadcrumb.expandButton": "utvid",
 	"copyableValue.copyValue": "Copy {{value}}",
 	"copyButton.copied": "Copied!",
 	"copyButton.copy": "Copy",

package/src/components/Breadcrumb/Breadcrumb.d.ts

@@ -1,39 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbProps } from "./utils/types";
-/**
- * The breadcrumb component shows a user's location in a website or application. Breadcrumbs are particularly useful when a large amount of content is organized in a hierarchical manner. They streamline navigation, minimize the steps required to revisit previous pages, and offer contextual insights to the users.
- *
- * All items except the last are rendered as clickable links. The last item is rendered as plain text representing the current page.
- * The component automatically adapts to the screen size: on large screens all items are visible, on medium screens middle items collapse behind an ellipsis button, and on small screens only the current page is shown.
- *
- * ### When to use
- * Use breadcrumbs when deep navigation is available, on apps or pages where users might dive into content and could benefit from a quick way to return to higher levels. Breadcrumbs display the current screen as the final item in the list to make it clear where the user is.
- *
- * ### When not to use
- * Do not use on the first hierarchal level, such as a home page or a main page, as there is no previous step the user can get to.
- * Avoid using breadcrumbs to indicate forthcoming steps. For processes with sequential steps, use a wizard flow instead.
- *
- * @example Basic breadcrumb navigation
- * ```tsx
- * import { Breadcrumb } from "@trackunit/react-components";
- * import { useNavigate } from "@tanstack/react-router";
- *
- * const AssetDetailBreadcrumb = () => {
- *   const navigate = useNavigate();
- *
- *   return (
- *     <Breadcrumb
- *       breadcrumbItems={[
- *         { label: "Fleet", to: "/fleet" },
- *         { label: "Assets", to: "/fleet/assets" },
- *         { label: "Excavator 001", to: "/fleet/assets/123" },
- *       ]}
- *       onClickBack={() => navigate({ to: "/fleet/assets" })}
- *     />
- *   );
- * };
- * ```
- * @param {BreadcrumbProps} props - The props for the Breadcrumb component
- * @returns {ReactElement} Breadcrumb component
- */
-export declare const Breadcrumb: ({ className, "data-testid": dataTestId, breadcrumbItems, onClickBack, style, ref, }: BreadcrumbProps) => ReactElement;

package/src/components/Breadcrumb/Breadcrumb.variant.d.ts

@@ -1,45 +0,0 @@
-export declare const cvaBreadcrumb: import("cva").CVAComponent<Omit<{
-    base: string[];
-}, "defaultVariants"> & {
-    variants: unknown;
-    defaultVariants: Omit<{}, never>;
-}, unknown>;
-export declare const cvaBreadcrumbItem: import("cva").CVAComponent<Omit<{
-    base: string[];
-}, "defaultVariants"> & {
-    variants: unknown;
-    defaultVariants: Omit<{}, never>;
-}, unknown>;
-export declare const cvaBreadcrumbForLargeScreen: import("cva").CVAComponent<Omit<{
-    base: string[];
-}, "defaultVariants"> & {
-    variants: unknown;
-    defaultVariants: Omit<{}, never>;
-}, unknown>;
-export declare const cvaBreadcrumbForMediumScreen: import("cva").CVAComponent<Omit<{
-    base: string[];
-    variants: {
-        expanded: {
-            true: string;
-            false: string;
-        };
-    };
-    defaultVariants: {
-        expanded: false;
-    };
-}, "defaultVariants"> & {
-    variants: {
-        expanded: {
-            true: string;
-            false: string;
-        };
-    };
-    defaultVariants: Omit<{}, "expanded"> & {
-        expanded: false;
-    };
-}, {
-    expanded: {
-        true: string;
-        false: string;
-    };
-}>;

package/src/components/Breadcrumb/BreadcrumbContainer.d.ts

@@ -1,8 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbContainerProps } from "./utils/types";
-/**
- * BreadcrumbContainer is a helper component that renders the breadcrumb items based on the screen size.
- *
- * @param {BreadcrumbContainerProps} props - The props for the BreadcrumbContainer component
- */
-export declare const BreadcrumbContainer: ({ className, "data-testid": dataTestId, breadcrumbItems, style, ref, }: BreadcrumbContainerProps) => ReactElement;

package/src/components/Breadcrumb/BreadcrumbForLargeScreen.d.ts

@@ -1,6 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbContainerProps } from "./utils/types";
-/**
- * BreadcrumbForLargeScreen is a helper component that renders the breadcrumb items for large screens.
- */
-export declare const BreadcrumbForLargeScreen: ({ "data-testid": dataTestId, breadcrumbItems, className, style, }: BreadcrumbContainerProps) => ReactElement;

package/src/components/Breadcrumb/BreadcrumbForMediumScreen.d.ts

@@ -1,6 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbForMediumScreenProps } from "./utils/types";
-/**
- * BreadcrumbForMediumScreen is a helper component that renders the breadcrumb items for medium screens.
- */
-export declare const BreadcrumbForMediumScreen: ({ "data-testid": dataTestId, breadcrumbItems, className, style, }: BreadcrumbForMediumScreenProps) => ReactElement;

package/src/components/Breadcrumb/BreadcrumbForSmallScreen.d.ts

@@ -1,6 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbContainerProps } from "./utils/types";
-/**
- * BreadcrumbForSmallScreen is a helper component that renders the breadcrumb items for small screens.
- */
-export declare const BreadcrumbForSmallScreen: ({ "data-testid": dataTestId, breadcrumbItems, className, style, }: BreadcrumbContainerProps) => ReactElement;

package/src/components/Breadcrumb/BreadcrumbItem.d.ts

@@ -1,6 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbItemRenderProps } from "./utils/types";
-/**
- * BreadcrumbItem is a helper component that renders the individual breadcrumb item.
- */
-export declare const BreadcrumbItem: ({ item, "data-testid": dataTestId, className, style, }: BreadcrumbItemRenderProps) => ReactElement;

package/src/components/Breadcrumb/utils/types.d.ts

@@ -1,28 +0,0 @@
-import { MouseEventHandler, ReactElement } from "react";
-import { CommonProps } from "../../../common/CommonProps";
-import { Refable } from "../../../common/Refable";
-import type { Styleable } from "../../../common/Styleable";
-export interface BreadcrumbItemProps {
-    /** The display text for this breadcrumb item. */
-    label: string;
-    /** The route path this breadcrumb item links to. */
-    to: string;
-}
-export interface BreadcrumbProps extends CommonProps, Styleable, Refable<HTMLDivElement> {
-    /**
-     * The ordered list of breadcrumb items representing the navigation hierarchy.
-     * The last item is rendered as plain text (the current page), all preceding items are rendered as clickable links.
-     */
-    breadcrumbItems: Array<BreadcrumbItemProps>;
-    /**
-     * Click handler for the back arrow button. Typically navigates to the previous breadcrumb item (second-to-last in the list).
-     */
-    onClickBack: MouseEventHandler<HTMLButtonElement>;
-}
-export interface BreadcrumbContainerProps extends CommonProps, Styleable, Refable<HTMLDivElement> {
-    breadcrumbItems: Array<ReactElement<BreadcrumbItemProps>>;
-}
-export type BreadcrumbForMediumScreenProps = BreadcrumbContainerProps;
-export interface BreadcrumbItemRenderProps extends CommonProps, Styleable {
-    item: ReactElement<BreadcrumbItemProps>;
-}

package/src/components/Breadcrumb/utils/useBreadcrumbItemsToRender.d.ts

@@ -1,6 +0,0 @@
-import { ReactElement } from "react";
-import { BreadcrumbItemProps } from "./types";
-/**
- * useBreadcrumbItemsToRender is a custom hook that takes an array of BreadcrumbItemProps and returns an array of React.ReactElement
- */
-export declare const useBreadcrumbItemsToRender: (breadcrumbItems: Array<BreadcrumbItemProps>) => Array<ReactElement<BreadcrumbItemProps>>;

package/src/hooks/persistence/hashFragment.d.ts

@@ -1,70 +0,0 @@
-/**
- * Pure utilities for reading and writing single named entries inside a URL
- * fragment (the part after `#`).
- *
- * # Format contract
- *
- * The fragment body (after the leading `#`) is treated as a sequence of
- * `&`-separated tokens. A token may be:
- *  - **A named entry** — `<key>=<value>` (the first `=` separates key from
- *    value; later `=` chars are part of the value).
- *  - **Foreign content** — anything else (bare scroll anchors like
- *    `section`, hash routes, third-party data, malformed tokens). Foreign
- *    tokens are preserved byte-for-byte, in their original positions.
- *
- * # Single-key ownership
- *
- * Callers operate on **one** named key per invocation. Every token whose
- * key does not match the supplied key is foreign — the utility never
- * categorises or rewrites it. This mirrors how `useSearchParamSync`
- * treats a single named search param.
- *
- * # Value-encoding invariant
- *
- * Values passed to {@link writeHashKey} must not contain `&`, `=`, or `#`.
- * The standard producer for this codebase is `useCustomEncoding`, whose
- * base64url alphabet (`[A-Za-z0-9_-]`) satisfies the invariant by
- * construction. Keys are restricted by the existing persistence-key
- * schema (camelCase, ≤15 chars), so they are likewise safe.
- *
- * # Anchor-scroll caveat
- *
- * Browsers locate scroll targets by matching the entire fragment string
- * against element IDs. Appending a named entry to a fragment containing
- * a bare anchor (e.g. `#section` becoming `#section&userTableTp=...`)
- * therefore breaks anchor scrolling on that page. This is unavoidable
- * for any hash-backed shared state. Consumers that rely on scroll
- * anchors should not also persist state to the hash on the same route.
- */
-/**
- * Reads the value of a single named entry from a URL fragment.
- *
- * @param hash - The fragment string, with or without the leading `#`.
- * @param key - The entry key to look up.
- * @returns {string | undefined} The raw value (everything after the first
- *   `=` in the matching token), or `undefined` when the key is absent. An
- *   entry whose token has no `=` is treated as foreign content and ignored.
- */
-export declare const readHashKey: (hash: string, key: string) => string | undefined;
-/**
- * Lists the key of every named entry in a URL fragment, in order of first
- * appearance. Foreign tokens (no `=`) are skipped and duplicates collapse.
- *
- * @param hash - The fragment string, with or without the leading `#`.
- * @returns {Array<string>} The distinct entry keys.
- */
-export declare const listHashKeys: (hash: string) => Array<string>;
-/**
- * Returns a new fragment string with the named entry written, replaced,
- * or removed. Foreign tokens are preserved in their original order; the
- * named entry retains its position if it already exists, and is appended
- * to the end when newly inserted. Empty tokens (e.g. produced by
- * consecutive `&`) are dropped on the way out.
- *
- * @param hash - The current fragment string, with or without the leading `#`.
- * @param key - The entry key to write.
- * @param value - The value to set, or `undefined` to remove the entry.
- * @returns {string} The new fragment string, including a leading `#` when
- *   non-empty, or an empty string when the result has no tokens left.
- */
-export declare const writeHashKey: (hash: string, key: string, value: string | undefined) => string;

package/src/hooks/persistence/readPrimitiveSearchParam.d.ts

@@ -1,8 +0,0 @@
-/**
- * Reads one search param from a TanStack `useSearch({ strict: false })` result.
- *
- * The registered route tree often has an empty or closed search schema, so a
- * string key cannot index that type. Parsing to a string record keeps the
- * lookup valid for every app router.
- */
-export declare const readPrimitiveSearchParam: (search: unknown, key: string) => string | undefined;

package/src/hooks/persistence/urlIdentity.d.ts

@@ -1,64 +0,0 @@
-/**
- * Pure utilities for stamping a URL-persisted value with the identity that
- * wrote it.
- *
- * A URL (hash or search param) is shared by every account that uses the same
- * browser: it survives login redirects, history and bookmarks, and it takes
- * precedence over per-user localStorage when a page loads. Without a stamp
- * there is no way to tell "a colleague shared this link" from "the previous
- * account on this PC left its layout in the address bar" — and the second
- * case silently replaces the current user's saved state (GLU-2396).
- *
- * The stamp is a short, non-reversible fingerprint of `clientSideUserId`.
- * It is not a secret and not a security boundary; it only lets a reader
- * recognise a value written by a *different* identity on the same device.
- */
-import { z } from "zod";
-/**
- * Wire shape of a stamped URL value: `{ o: <fingerprint>, v: <payload> }`.
- * Values written before stamping existed are bare payloads and decode as
- * unowned (see {@link unwrapUrlOwner}).
- */
-declare const stampedUrlValueSchema: z.ZodObject<{
-    o: z.ZodString;
-    v: z.ZodUnknown;
-}, "strip", z.ZodTypeAny, {
-    o: string;
-    v?: unknown;
-}, {
-    o: string;
-    v?: unknown;
-}>;
-type StampedUrlValue = z.infer<typeof stampedUrlValueSchema>;
-/**
- * 32-bit FNV-1a of `identity`, rendered in base36 (≤ 7 chars).
- *
- * Synchronous and dependency-free so it can run inside a `useState`
- * initializer. Collisions are possible in theory but irrelevant here: a
- * collision can only make a foreign value look like the reader's own, which
- * is today's behaviour for every value.
- *
- * @param identity - The client-side user id to fingerprint.
- * @returns {string} A short stable fingerprint of `identity`.
- */
-export declare const identityFingerprint: (identity: string) => string;
-/**
- * Wraps a URL payload with the fingerprint of the identity writing it.
- *
- * @param value - The payload that would otherwise be encoded into the URL.
- * @param owner - Fingerprint of the writing identity (see {@link identityFingerprint}).
- * @returns {StampedUrlValue} The payload wrapped in its ownership envelope.
- */
-export declare const wrapUrlOwner: (value: unknown, owner: string) => StampedUrlValue;
-/**
- * Splits a decoded URL value into its owner fingerprint and payload.
- * Bare (pre-stamping) payloads come back with `owner: undefined`.
- *
- * @param decoded - The decoded URL value, stamped or bare.
- * @returns {{ owner: string | undefined; value: unknown }} The owner fingerprint (if any) and the payload.
- */
-export declare const unwrapUrlOwner: (decoded: unknown) => {
-    readonly owner: string | undefined;
-    readonly value: unknown;
-};
-export {};

package/src/hooks/persistence/usePersistedState.d.ts

@@ -1,117 +0,0 @@
-import { type UrlParamLocation } from "./useUrlParamSync";
-/**
- * Selects which part of the URL backs the persisted state.
- *
- * - `"search"` (default): `?<key>=<encoded>`. Subject to the AWS WAF
- *   managed-rule cap (~5000 bytes) — large states are dropped from the URL.
- * - `"hash"`: `#<key>=<encoded>`. Stays on the client, so the cap is
- *   driven only by browser URL limits.
- */
-export type UrlPersistenceLocation = UrlParamLocation;
-type UsePersistedStateOptions<TState> = {
-    readonly key: string;
-    readonly validate: (raw: unknown) => TState | undefined;
-    readonly toUrlValue?: (state: TState) => string | object | Array<object>;
-    readonly fromUrlValue?: (decoded: unknown) => unknown;
-    readonly localStorageEnabled?: boolean;
-    readonly replace?: boolean;
-    readonly clientSideUserId?: string;
-    /**
-     * When `true` and both URL and localStorage have valid state, the read
-     * returns a shallow merge `{ ...storage, ...url }` where URL fields take
-     * precedence and storage fills in fields the URL omits.
-     *
-     * Use this when `toUrlValue` deliberately omits some fields from the URL
-     * (e.g. per-user layout details that shouldn't be shareable) so the
-     * omitted fields still survive reloads via localStorage.
-     *
-     * Default is `false`: URL state fully replaces localStorage state on read.
-     */
-    readonly mergeWithStorageOnRead?: boolean;
-    /**
-     * Which slot of the URL backs the persisted value. Default `"search"`.
-     * See {@link UrlPersistenceLocation} for the trade-offs.
-     */
-    readonly urlLocation?: UrlPersistenceLocation;
-    /**
-     * When `true`, every URL write is stamped with a fingerprint of
-     * `clientSideUserId` (`{ o: <fingerprint>, v: <payload> }`). Reads are
-     * unaffected: the URL still wins on load for everyone, so links and
-     * bookmarks render for whoever opens them.
-     *
-     * The stamp exists for the login redirect. The URL is shared by every
-     * account that signs in from the same browser and `redirectToLogin`
-     * carries it through to the next account, which is how one account's
-     * state replaced another's on a shared PC (GLU-2396). At that boundary
-     * `useStripForeignIdentityHash` drops entries stamped by a different
-     * identity that has state stored in this browser. Default `false`.
-     */
-    readonly stampUrlWithIdentity?: boolean;
-};
-type UsePersistedStateReturn<TState> = {
-    readonly initialState: TState | undefined;
-    /** Writes `state` to localStorage and the URL; each slot skips a value equal to its last write. */
-    readonly persistState: (state: TState) => void;
-    /**
-     * Writes `state` to localStorage only; `undefined` removes the entry.
-     * Use together with `persistToUrl` when the two writes should not share a
-     * schedule — e.g. storage immediately, URL debounced.
-     */
-    readonly persistToStorage: (state: TState | undefined) => void;
-    /** Writes `state` to the URL only; `undefined` removes the entry. */
-    readonly persistToUrl: (state: TState | undefined) => void;
-};
-/**
- * Generic persistence hook that loads state from a URL slot (search param
- * or hash fragment, depending on `urlLocation`) with localStorage fallback,
- * and writes changes to both.
- *
- * On mount the hook resolves the initial state as follows:
- *  - If the URL slot holds a value, decode it and pass through `validate`.
- *  - If localStorage is enabled, read and validate its value.
- *  - When `mergeWithStorageOnRead` is `false` (default): URL state wins
- *    entirely when present, otherwise fall back to localStorage.
- *  - When `mergeWithStorageOnRead` is `true`: shallow-merge URL fields over
- *    localStorage so fields stripped by `toUrlValue` survive via storage.
- *
- * A value that comes only from localStorage is never written to the URL on
- * load. Copying it left a layout in history, bookmarks, and login redirects,
- * which then replayed an older layout over the saved one (GLU-2396). The URL
- * is written when the consumer persists a change.
- *
- * `persistState` writes to localStorage (`storageSerializer`) and to the URL
- * (via `toUrlValue` + encoding).
- * Each slot skips a value equal to its last write. The URL side compares what
- * would land in the URL (the `toUrlValue` projection and the identity stamp),
- * starting from the projection of the hydrated state and the stamp the URL
- * carries: echoing `initialState`, or changing only a field the projection
- * strips, writes no URL entry, while an equal state persisted after the
- * identity resolves rewrites the URL with its stamp. The storage side starts
- * from what localStorage held, so a consumer that persists `initialState`
- * after opening a link saves that link's state for the account that opened
- * it, and a reload of the account's own link writes nothing.
- * `persistToStorage` and `persistToUrl` are the same two halves exposed
- * separately for consumers that schedule them differently; passing `undefined`
- * removes the entry rather than writing an empty value.
- *
- * The snapshot is re-read when the storage key or the storage/merge options
- * change, in the same render, so a write in that commit already sees the
- * state for the new key.
- *
- * @param options - Configuration for the persisted state.
- * @param options.key - Unique identifier used for both the URL slot and the localStorage key.
- * @param options.validate - Called with the decoded/parsed value; must return `TState` or `undefined`.
- * @param options.toUrlValue - Transform applied before URL encoding (default: encode state as-is).
- * @param options.fromUrlValue - Transform applied after URL decoding, before validation (default: identity).
- * @param options.localStorageEnabled - When `false` localStorage is neither read nor written (default `true`).
- * @param options.replace - Forwarded to the underlying URL sync hook.
- * @param options.clientSideUserId - The user ID to use for the localStorage key.
- * @param options.mergeWithStorageOnRead - Merge URL state on top of localStorage
- *   state on read (URL wins on shared keys). Use when `toUrlValue` deliberately
- *   omits fields so they still survive via localStorage. Default `false`.
- * @param options.urlLocation - Which URL slot backs the value (`"search"` or `"hash"`). Default `"search"`.
- * @param options.stampUrlWithIdentity - Stamp URL writes with the current identity so the login
- *   redirect can drop entries left by another account on this browser. Default `false`.
- */
-export declare const usePersistedState: <TState extends object>({ key, validate, toUrlValue, fromUrlValue, localStorageEnabled, replace, clientSideUserId, mergeWithStorageOnRead, urlLocation, stampUrlWithIdentity, }: UsePersistedStateOptions<TState>) => UsePersistedStateReturn<TState>;
-export {};

package/src/hooks/persistence/useSearchParamSync.d.ts

@@ -1,17 +0,0 @@
-import { type UseUrlParamSyncOptions, type UseUrlParamSyncReturn } from "./useUrlParamSync";
-export { MAX_URL_LENGTH } from "./useUrlParamSync";
-type UseSearchParamSyncOptions = Omit<UseUrlParamSyncOptions, "location">;
-/**
- * Syncs an encoded string value with a URL search parameter via Tanstack Router.
- *
- * Thin wrapper over {@link useUrlParamSync} with `location: "search"`; see it
- * for the write queue, the size guard (`MAX_URL_LENGTH`), and external-change
- * detection.
- *
- * @param options - Configuration for the search param sync.
- * @param options.key - The URL search parameter name.
- * @param options.enabled - Set to `false` to disable all URL interaction (default `true`).
- * @param options.onExternalChange - Called when the param changes externally.
- * @param options.replace - `true` to always use `replaceState`.
- */
-export declare const useSearchParamSync: (options: UseSearchParamSyncOptions) => UseUrlParamSyncReturn;

package/src/hooks/persistence/useUrlParamSync.d.ts

@@ -1,71 +0,0 @@
-/**
- * Maximum full URL length after adding one persisted search param before the
- * URL write is skipped (localStorage still persists the full state).
- *
- * Sized to stay safely below the AWS WAF managed-rule default
- * `SizeRestrictions_QUERYSTRING` cap of 5000 bytes for the entire
- * host + path + query + hash string.
- */
-export declare const MAX_URL_LENGTH = 5000;
-/**
- * Maximum length of the URL fragment after adding one persisted entry.
- * Oversized new entries are skipped; oversized replacements remove the stale
- * entry so localStorage remains authoritative.
- *
- * The fragment is never sent to the server, so the WAF cap above does not
- * apply. 64 KB stays well below typical browser URL limits (Chromium ≳ 100 KB,
- * Firefox ≳ 64 KB on the address bar) while leaving generous headroom for any
- * realistic table state.
- */
-export declare const MAX_HASH_LENGTH: number;
-/**
- * Which part of the URL a persisted value lives in.
- *
- * - `"search"`: `?<key>=<encoded>`. Subject to the AWS WAF cap
- *   ({@link MAX_URL_LENGTH}); large states are dropped from the URL.
- * - `"hash"`: `#<key>=<encoded>`. Client-only, capped by
- *   {@link MAX_HASH_LENGTH}.
- */
-export type UrlParamLocation = "search" | "hash";
-export type UseUrlParamSyncOptions = {
-    readonly key: string;
-    readonly location: UrlParamLocation;
-    readonly enabled?: boolean;
-    readonly onExternalChange?: () => void;
-    readonly replace?: boolean;
-};
-export type UseUrlParamSyncReturn = {
-    /** The raw encoded value currently in the URL slot, or `undefined` when absent or disabled. */
-    readonly searchValue: string | undefined;
-    /** Writes `encodedValue` into the URL slot; `undefined` removes the entry. */
-    readonly updateSearchParam: (encodedValue: string | undefined) => void;
-};
-/**
- * Syncs an encoded string value with a single named entry in the URL — either
- * a search param or an entry inside the hash fragment — via Tanstack Router.
- *
- * Writes go through the application router so other search params and
- * foreign fragment content are preserved. Each slot has a size guard
- * ({@link MAX_URL_LENGTH} for search, {@link MAX_HASH_LENGTH} for hash); an
- * oversized value is dropped from the URL and localStorage stays
- * authoritative. External changes to the entry (browser back/forward, a
- * pasted link, a foreign router push) fire `onExternalChange`.
- *
- * Writes are dispatched via a pending-write queue rather than calling
- * `navigate` directly. Tanstack Router's `router.state.status === "pending"`
- * is common during the first paint of a route (loaders, suspense), and an
- * implementation that simply returned in that case lost the write outright.
- * `updateSearchParam` stores the latest attempted write and schedules an rAF
- * flush; the flush only navigates when the router is idle, and an effect
- * retries whenever the router settles. A queued write is dropped on unmount so
- * it cannot drain onto the next route.
- *
- * @param options - Configuration for the URL entry sync.
- * @param options.key - The search param name or fragment entry name.
- * @param options.location - `"search"` or `"hash"`.
- * @param options.enabled - Set to `false` to disable all URL interaction (default `true`).
- * @param options.onExternalChange - Called when the entry changes externally.
- * @param options.replace - `true` to always use `replaceState`; `false` to always push.
- *   Default: replace when the entry is being added, push when it already has a value.
- */
-export declare const useUrlParamSync: ({ key, location: urlLocation, enabled, onExternalChange, replace: replaceOption, }: UseUrlParamSyncOptions) => UseUrlParamSyncReturn;

package/src/hooks/useCursorUrlSync.d.ts

@@ -1,23 +0,0 @@
-type UseCursorUrlSyncOptions = {
-    readonly paramName?: string;
-    readonly debounceMs?: number;
-};
-type UseCursorUrlSyncResult = {
-    readonly initialCursor: string | undefined;
-    readonly updateCursor: (cursor: string | undefined) => void;
-};
-/**
- * Reads a cursor from the URL search params on mount and provides a debounced
- * updater for writing it back. Uses `replace: true` to avoid polluting browser
- * history with every scroll position change.
- *
- * Wire `initialCursor` into `usePaginationQuery` and `updateCursor` into
- * `useBidirectionalScroll`'s `onTopItemChange` callback (mapping index to cursor).
- *
- * A pending write is dropped whenever a path-changing navigation starts or the
- * location has moved on: the write targets `to: "."`, so landing it after the
- * user opened a row would replace their destination with the list they came
- * from.
- */
-export declare const useCursorUrlSync: ({ paramName, debounceMs, }?: UseCursorUrlSyncOptions) => UseCursorUrlSyncResult;
-export {};