@tailor-platform/app-shell 1.1.1 → 1.2.0

package/dist/app-shell.d.ts

@@ -22,7 +22,6 @@ import { Select as Select_2 } from '@base-ui/react/select';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { toast } from 'sonner';
 import { Tooltip as Tooltip_2 } from '@base-ui/react/tooltip';
-import { useFilter } from 'node_modules/@base-ui/react/esm/combobox/index.parts';
 import { useLocation } from 'react-router';
 import { useNavigate } from 'react-router';
 import { useParams } from 'react-router';
@@ -503,27 +502,7 @@ export declare type AuthState = {
     isReady: boolean;
 };
 
-export declare const Autocomplete: typeof AutocompleteStandalone & {
-    Async: typeof AutocompleteAsyncStandalone;
-    Parts: {
-        Root: typeof AutocompleteRoot;
-        Value: AutocompleteValue;
-        InputGroup: typeof AutocompleteInputGroup;
-        Input: typeof AutocompleteInput;
-        Trigger: typeof AutocompleteTrigger;
-        Content: typeof AutocompleteContent;
-        List: typeof AutocompleteList;
-        Item: typeof AutocompleteItem;
-        Empty: typeof AutocompleteEmpty;
-        Clear: typeof AutocompleteClear;
-        Group: typeof AutocompleteGroup;
-        GroupLabel: typeof AutocompleteGroupLabel;
-        Collection: typeof AutocompleteCollection;
-        Status: AutocompleteStatus;
-    };
-    useAsync: typeof useAsync_3;
-    useFilter: getFilter;
-};
+export declare const Autocomplete: AutocompleteComponent;
 
 /** Fetcher type for `Autocomplete.Async`. */
 export declare type AutocompleteAsyncFetcher<T> = AsyncFetcher<T>;
@@ -553,6 +532,22 @@ declare namespace AutocompleteCollection {
     var displayName: string;
 }
 
+/**
+ * Keep the exported static API type explicit instead of relying on
+ * `Object.assign(...)` inference.
+ *
+ * Why:
+ * - makes declaration rollup more stable (avoids TS2742/non-portable inferred names)
+ * - keeps public `.d.ts` output resilient to resolver/config changes
+ * - preserves consumer-side callback inference for `Autocomplete` and `Autocomplete.Async`
+ */
+declare type AutocompleteComponent = typeof AutocompleteStandalone & {
+    Async: typeof AutocompleteAsyncStandalone;
+    Parts: typeof AutocompleteParts;
+    useAsync: typeof useAsync_3;
+    useFilter: typeof useFilter_2;
+};
+
 declare function AutocompleteContent({ className, container, ...props }: React_2.ComponentProps<typeof Autocomplete_2.Popup> & {
     container?: React_2.ComponentProps<typeof Autocomplete_2.Portal>["container"];
 }): JSX.Element;
@@ -603,6 +598,25 @@ declare namespace AutocompleteList {
     var displayName: string;
 }
 
+declare const AutocompleteParts: {
+    Root: typeof AutocompleteRoot;
+    Value: typeof AutocompleteValue;
+    InputGroup: typeof AutocompleteInputGroup;
+    Input: typeof AutocompleteInput;
+    Trigger: typeof AutocompleteTrigger;
+    Content: typeof AutocompleteContent;
+    List: typeof AutocompleteList;
+    Item: typeof AutocompleteItem;
+    Empty: typeof AutocompleteEmpty;
+    Clear: typeof AutocompleteClear;
+    Group: typeof AutocompleteGroup;
+    GroupLabel: typeof AutocompleteGroupLabel;
+    Collection: typeof AutocompleteCollection;
+    Status: typeof AutocompleteStatus;
+};
+
+declare type AutocompleteParts = typeof AutocompleteParts;
+
 declare type AutocompletePickedRootProps<Value> = Pick<AutocompleteRootProps<Value>, "value" | "defaultValue" | "onValueChange" | "filter" | "disabled" | "children"> & {
     items?: readonly Value[];
 };
@@ -708,17 +722,36 @@ export declare const avatarVariants: (props?: ({
 
 export declare function Badge({ className, variant, children, ...props }: BadgeProps): JSX.Element;
 
+/** Options for `type: "badge"` cells. */
+declare interface BadgeCellOptions {
+    /**
+     * Maps each cell value (stringified) to a Badge variant. Values not in the
+     * map fall back to `defaultBadgeVariant`.
+     */
+    badgeVariantMap?: Record<string, BadgeVariant>;
+    /**
+     * Maps each cell value (stringified) to a display label. Values not in the
+     * map render the raw cell value.
+     */
+    badgeLabelMap?: Record<string, string>;
+    /** Variant used when the value is not in `badgeVariantMap`. Default: `"neutral"`. */
+    defaultBadgeVariant?: BadgeVariant;
+}
+
 export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }
 
+/** Variant union accepted by the app-shell `<Badge>` component. */
+declare type BadgeVariant = NonNullable<BadgeProps["variant"]>;
+
 export declare const badgeVariants: (props?: ({
-    variant?: "default" | "error" | "success" | "warning" | "neutral" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
+    variant?: "default" | "error" | "success" | "warning" | "neutral" | "subtle-success" | "subtle-warning" | "subtle-error" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 /**
  * Badge variant mapping for automatic status coloring
  */
-declare type BadgeVariantType = "default" | "success" | "warning" | "error" | "neutral" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral";
+declare type BadgeVariantType = "default" | "success" | "warning" | "error" | "neutral" | "subtle-success" | "subtle-warning" | "subtle-error" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral";
 
 /** The table body section (`<tbody>`). */
 declare function Body_2({ className, ...props }: React_2.ComponentProps<"tbody">): JSX.Element;
@@ -916,13 +949,38 @@ export declare interface CollectionVariables {
 }
 
 /**
- * A column definition for DataTable.
+ * A column definition for DataTable. Use one of the built-in `type` values
+ * (`text`, `number`, `money`, `date`, `badge`, `link`) for automatic
+ * rendering, or pass `render` to draw the cell yourself.
+ *
+ * `Column` is a discriminated union on `type`, so wrong-shape `typeOptions`
+ * are a compile error rather than silently ignored at runtime.
+ */
+export declare type Column<TRow extends Record<string, unknown>> = ColumnBase<TRow> & ColumnTypeBranch<TRow>;
+
+/**
+ * Supported area values for Layout.Column
+ */
+declare type ColumnArea = "left" | "main" | "right";
+
+/**
+ * Fields shared by every `Column` regardless of `type`. Prefer `Column<TRow>`
+ * in most cases; this is exported so consumers can compose more specific
+ * column types (e.g. `type MoneyColumn<TRow> = ColumnBase<TRow> & { type: "money"; … }`).
  */
-export declare interface Column<TRow extends Record<string, unknown>> {
+declare interface ColumnBase<TRow extends Record<string, unknown>> {
     /** Column header text. Omit for action or icon-only columns. */
     label?: string;
-    /** Renders the cell content for a given row. Required. */
-    render: (row: TRow) => ReactNode;
+    /**
+     * Renders the cell content for a given row. Optional — when omitted, the
+     * built-in renderer for `type` takes over (or an `—` placeholder if no
+     * `type` is set). Always wins over the built-in renderer when both are
+     * present.
+     *
+     * Kept on the base (not per-branch) so callback contextual typing works
+     * across spread-then-override patterns like `column({ ...inferred, render })`.
+     */
+    render?: (row: TRow) => ReactNode;
     /**
      * Stable identifier used for column visibility toggling and as the React key.
      * Falls back to `label` when omitted. Set this explicitly when `label` is
@@ -932,10 +990,24 @@ export declare interface Column<TRow extends Record<string, unknown>> {
     /** Fixed column width in pixels. When omitted the column sizes naturally. */
     width?: number;
     /**
-     * Extracts the raw value from a row for purposes such as sorting or
-     * clipboard copying. Not used for rendering — use `render` for that.
+     * Horizontal alignment for the header and body cell. When omitted, numeric
+     * `type` values (`"number"` and `"money"`) default to `"right"` so digits
+     * align along their decimal place; everything else defaults to `"left"`.
+     * Pass `"left"` explicitly to opt a numeric column out.
      */
-    accessor?: (row: TRow) => unknown;
+    align?: "left" | "right";
+    /**
+     * When `true`, the cell content is truncated with an ellipsis when it
+     * overflows. A `<Tooltip>` is wired up automatically when `accessor`
+     * returns a string or number, so hovering the cell reveals the full
+     * value.
+     *
+     * Truncation requires the cell to be shrinkable — the body cell sets
+     * `max-w-0`, which collapses unless another column anchors the row width.
+     * Pair with `width` on neighboring columns, or rely on the natural width
+     * of fixed-size columns (selection / row actions).
+     */
+    truncate?: boolean;
     /**
      * Sort configuration. When set, the column header becomes clickable and
      * cycles through `Asc → Desc → undefined`.
@@ -950,11 +1022,6 @@ export declare interface Column<TRow extends Record<string, unknown>> {
     filter?: FilterConfig;
 }
 
-/**
- * Supported area values for Layout.Column
- */
-declare type ColumnArea = "left" | "main" | "right";
-
 /**
  * Supported column count options
  */
@@ -1011,7 +1078,7 @@ declare interface ColumnHelper<TRow extends Record<string, unknown>> {
  * @param options - Optional per-column overrides (label, width, sort, filter).
  * @throws {Error} If `dataKey` is not found in the metadata passed to `inferColumns`.
  */
-declare type ColumnInferFn<TRow extends Record<string, unknown>, TTable extends TableMetadata = TableMetadata> = (dataKey: TableFieldName<TTable>, options?: MetadataFieldOptions) => Column<TRow>;
+declare type ColumnInferFn<TRow extends Record<string, unknown>, TTable extends TableMetadata = TableMetadata> = (dataKey: TableFieldName<TTable>, options?: MetadataFieldOptions) => InferredColumn<TRow>;
 
 /**
  * Props for individual Layout.Column component
@@ -1038,32 +1105,56 @@ declare interface ColumnProps {
  */
 declare type Columns = 3 | 4;
 
-export declare const Combobox: typeof ComboboxStandalone & {
-    Async: typeof ComboboxAsyncStandalone;
-    Parts: {
-        Root: typeof ComboboxRoot;
-        InputGroup: typeof ComboboxInputGroup;
-        Input: typeof ComboboxInput;
-        Trigger: typeof ComboboxTrigger;
-        Content: typeof ComboboxContent;
-        List: typeof ComboboxList;
-        Item: typeof ComboboxItem;
-        Empty: typeof ComboboxEmpty;
-        Group: typeof ComboboxGroup;
-        GroupLabel: typeof ComboboxGroupLabel;
-        Clear: typeof ComboboxClear;
-        Chips: typeof ComboboxChips;
-        Chip: typeof ComboboxChip;
-        ChipRemove: typeof ComboboxChipRemove;
-        Value: typeof ComboboxValue;
-        Collection: typeof ComboboxCollection;
-        Status: ComboboxStatus;
-    };
-    useAsync: typeof useAsync_2;
-    useFilter: useFilter;
-    useCreatable: typeof useCreatable;
+/**
+ * Discriminated branches keyed off `type`. Each branch narrows `typeOptions`
+ * and `accessor`'s return type to the values its renderer can display.
+ *
+ * - `type: "link"` requires `typeOptions.href`.
+ * - `type: "text"` rejects `typeOptions` entirely.
+ *
+ * `accessor` lives on each branch (rather than `ColumnBase`) so the built-in
+ * renderers can constrain what a column produces. Returning an array or a
+ * non-Date object is a compile error on a typed branch, instead of silently
+ * rendering `[object Object]`. Untyped columns (`type?: undefined`) still
+ * accept `unknown` — they're rendered by an explicit `render`. `null` and
+ * `undefined` are always allowed: every built-in renderer maps them to the
+ * `—` placeholder.
+ *
+ * Prefer `Column<TRow>` in most cases; this is exported so consumers can
+ * compose more specific column types.
+ */
+declare type ColumnTypeBranch<TRow extends Record<string, unknown>> = {
+    type?: undefined;
+    typeOptions?: never;
+    accessor?: (row: TRow) => unknown;
+} | {
+    type: "text";
+    typeOptions?: never;
+    accessor?: (row: TRow) => string | number | boolean | bigint | null | undefined;
+} | {
+    type: "number";
+    typeOptions?: NumberCellOptions;
+    accessor?: (row: TRow) => number | null | undefined;
+} | {
+    type: "money";
+    typeOptions?: MoneyCellOptions<TRow>;
+    accessor?: (row: TRow) => number | null | undefined;
+} | {
+    type: "date";
+    typeOptions?: DateCellOptions;
+    accessor?: (row: TRow) => Date | string | number | null | undefined;
+} | {
+    type: "badge";
+    typeOptions?: BadgeCellOptions;
+    accessor?: (row: TRow) => string | number | boolean | null | undefined;
+} | {
+    type: "link";
+    typeOptions: LinkCellOptions<TRow>;
+    accessor?: (row: TRow) => string | number | boolean | null | undefined;
 };
 
+export declare const Combobox: ComboboxComponent;
+
 declare type ComboboxAsyncCreatableProps<T extends object> = (ComboboxAsyncOwnProps<T> & CreatableProps<T> & Omit<ComboboxPropsSingle<T>, "mapItem">) | (ComboboxAsyncOwnProps<T> & CreatableProps<T> & Omit<ComboboxPropsMultiple<T>, "mapItem">);
 
 /** Fetcher type for `Combobox.Async`. */
@@ -1112,6 +1203,23 @@ declare namespace ComboboxCollection {
     var displayName: string;
 }
 
+/**
+ * Keep the exported static API type explicit instead of relying on
+ * `Object.assign(...)` inference.
+ *
+ * Why:
+ * - makes declaration rollup more stable (avoids TS2742/non-portable inferred names)
+ * - keeps public `.d.ts` output resilient to resolver/config changes
+ * - preserves consumer-side callback inference for `Combobox` and `Combobox.Async`
+ */
+declare type ComboboxComponent = typeof ComboboxStandalone & {
+    Async: typeof ComboboxAsyncStandalone;
+    Parts: typeof ComboboxParts;
+    useAsync: typeof useAsync_2;
+    useFilter: typeof useFilter;
+    useCreatable: typeof useCreatable;
+};
+
 declare function ComboboxContent({ className, container, ...props }: React_2.ComponentProps<typeof Combobox_2.Popup> & {
     container?: React_2.ComponentProps<typeof Combobox_2.Portal>["container"];
 }): JSX.Element;
@@ -1162,6 +1270,28 @@ declare namespace ComboboxList {
     var displayName: string;
 }
 
+declare const ComboboxParts: {
+    Root: typeof ComboboxRoot;
+    InputGroup: typeof ComboboxInputGroup;
+    Input: typeof ComboboxInput;
+    Trigger: typeof ComboboxTrigger;
+    Content: typeof ComboboxContent;
+    List: typeof ComboboxList;
+    Item: typeof ComboboxItem;
+    Empty: typeof ComboboxEmpty;
+    Group: typeof ComboboxGroup;
+    GroupLabel: typeof ComboboxGroupLabel;
+    Clear: typeof ComboboxClear;
+    Chips: typeof ComboboxChips;
+    Chip: typeof ComboboxChip;
+    ChipRemove: typeof ComboboxChipRemove;
+    Value: typeof ComboboxValue;
+    Collection: typeof ComboboxCollection;
+    Status: typeof ComboboxStatus;
+};
+
+declare type ComboboxParts = typeof ComboboxParts;
+
 declare interface ComboboxPropsBase<T> {
     /** Placeholder text for the input */
     placeholder?: string;
@@ -1821,6 +1951,17 @@ declare namespace DataTableToolbar {
     var displayName: string;
 }
 
+/** Options for `type: "date"` cells. */
+declare interface DateCellOptions {
+    /**
+     * Format style. `"short"` → `Apr 9, 2026`; `"long"` → `April 9, 2026`;
+     * `"datetime"` → `Apr 9, 2026, 3:45 PM`. Default: `"short"`.
+     */
+    dateFormat?: "short" | "long" | "datetime";
+    /** BCP 47 locale tag. Defaults to the runtime locale. */
+    locale?: string;
+}
+
 /**
  * Date format options
  */
@@ -2828,6 +2969,16 @@ export declare type InferCsvRow<T extends CsvSchema> = {
     } ? O : unknown;
 };
 
+/**
+ * The return type of an infer function — contains the base column fields
+ * without the discriminated `type`/`typeOptions`/`accessor` branches.
+ *
+ * This makes spread-then-override patterns like
+ * `column({ ...infer("stock"), type: "number" })` type-safe without
+ * requiring an explicit accessor cast.
+ */
+declare type InferredColumn<TRow extends Record<string, unknown>> = ColumnBase<TRow>;
+
 /**
  * A styled input component.
  *
@@ -3009,6 +3160,15 @@ declare namespace Legend {
 
 export { Link }
 
+/** Options for `type: "link"` cells. `href` is required. */
+declare interface LinkCellOptions<TRow extends Record<string, unknown>> {
+    /**
+     * Extracts the link target. Returning `null` / `undefined` renders the cell
+     * value as plain text instead of a link.
+     */
+    href: (row: TRow) => string | null | undefined;
+}
+
 /** A link item in the menu that can be used to navigate to a different page. */
 declare function LinkItem({ className, ...props }: React_2.ComponentProps<typeof Menu_2.LinkItem>): JSX.Element;
 
@@ -3148,6 +3308,23 @@ declare type Module = Omit<CommonPageResource, "meta"> & {
 
 declare type Modules = Array<Module>;
 
+/** Options for `type: "money"` cells. */
+declare interface MoneyCellOptions<TRow extends Record<string, unknown>> {
+    /**
+     * ISO 4217 currency code. Pass a string for a static currency or a function
+     * to read it from the row. Default: `"USD"`.
+     */
+    currency?: string | ((row: TRow) => string);
+    /**
+     * Maximum decimals. Raises the cap above the currency default while keeping
+     * the minimum at the currency default (e.g. USD stays at ≥2, but a price
+     * column can show up to 4).
+     */
+    maxDecimals?: number;
+    /** BCP 47 locale tag. Defaults to the runtime locale. */
+    locale?: string;
+}
+
 /**
  * Extract the node type from a cursor connection result.
  */
@@ -3157,6 +3334,16 @@ export declare type NodeType<T extends {
     }[];
 } | null | undefined> = NonNullable<T>["edges"][number]["node"];
 
+/** Options for `type: "number"` cells. */
+declare interface NumberCellOptions {
+    /** Minimum decimal places. Default: `0`. */
+    minDecimals?: number;
+    /** Maximum decimal places. Default: `minDecimals` (or `0`). */
+    maxDecimals?: number;
+    /** BCP 47 locale tag. Defaults to the runtime locale. */
+    locale?: string;
+}
+
 /**
  * Resolve the operator union for a specific field within a filter type.
  */
@@ -3634,34 +3821,7 @@ export declare type SearchSource = {
     }) => Promise<CommandPaletteSearchResult[]>;
 };
 
-export declare const Select: typeof SelectStandalone & {
-    /**
-     * Async select that fetches items when the dropdown opens.
-     *
-     * **Limitation:** This component defaults to `modal={false}` and
-     * `alignItemWithTrigger={false}` to work around Base UI scroll-lock bugs
-     * with dynamically loaded items. As a result, it may not function correctly
-     * inside focus-trapping containers such as `Dialog` or `Sheet` — the
-     * focus trap can block interaction with the dropdown, or the portal may
-     * render outside the modal's visible area.
-     *
-     * If you need an async dropdown inside a `Dialog` or `Sheet`, prefer
-     * `Combobox.Async` which uses Popover-based positioning and does not
-     * suffer from these constraints.
-     */
-    Async: typeof SelectAsyncStandalone;
-    Parts: {
-        Root: typeof SelectRoot;
-        Trigger: typeof SelectTrigger;
-        Value: typeof SelectValue;
-        Content: typeof SelectContent;
-        Item: typeof SelectItem;
-        Group: typeof SelectGroup;
-        GroupLabel: typeof SelectGroupLabel;
-        Separator: SelectSeparator;
-    };
-    useAsync: typeof useAsync;
-};
+export declare const Select: SelectComponent;
 
 /**
  * Fetcher type for `Select.Async`.
@@ -3711,6 +3871,21 @@ declare type SelectAsyncProps<T> = (SelectAsyncOwnProps<T> & SelectPropsSingle<T
 
 declare function SelectAsyncStandalone<T>(props: SelectAsyncProps<T>): JSX.Element;
 
+/**
+ * Keep the exported static API type explicit instead of relying on
+ * `Object.assign(...)` inference.
+ *
+ * Why:
+ * - makes declaration rollup more stable (avoids TS2742/non-portable inferred names)
+ * - keeps public `.d.ts` output resilient to resolver/config changes
+ * - preserves consumer-side callback inference for `Select` and `Select.Async`
+ */
+declare type SelectComponent = typeof SelectStandalone & {
+    Async: typeof SelectAsyncStandalone;
+    Parts: typeof SelectParts;
+    useAsync: typeof useAsync;
+};
+
 declare function SelectContent({ className, container, alignItemWithTrigger, ...props }: React_2.ComponentProps<typeof Select_2.Popup> & {
     container?: React_2.ComponentProps<typeof Select_2.Portal>["container"];
     alignItemWithTrigger?: React_2.ComponentProps<typeof Select_2.Positioner>["alignItemWithTrigger"];
@@ -3746,6 +3921,19 @@ export declare interface SelectOption {
     label: string;
 }
 
+declare const SelectParts: {
+    Root: typeof SelectRoot;
+    Trigger: typeof SelectTrigger;
+    Value: typeof SelectValue;
+    Content: typeof SelectContent;
+    Item: typeof SelectItem;
+    Group: typeof SelectGroup;
+    GroupLabel: typeof SelectGroupLabel;
+    Separator: typeof SelectSeparator;
+};
+
+declare type SelectParts = typeof SelectParts;
+
 declare interface SelectPropsBase<T> {
     /** Placeholder text shown when no value is selected */
     placeholder?: string;
@@ -4150,6 +4338,20 @@ export declare type SidebarLayoutProps = {
      * ```
      */
     sidebar?: React.ReactNode;
+    /**
+     * Whether the sidebar is open by default on desktop.
+     *
+     * @default true
+     */
+    defaultOpen?: boolean;
+    /**
+     * Whether the sidebar can be collapsed.
+     * When set to `false`, the sidebar is always visible and cannot be toggled.
+     * `defaultOpen` is ignored when this is `false`.
+     *
+     * @default true
+     */
+    collapsible?: boolean;
 };
 
 /**
@@ -5067,6 +5269,48 @@ export declare interface UseDataTableReturn<TRow extends Record<string, unknown>
     isIndeterminate: boolean;
 }
 
+/**
+ * Hook for robust string matching using `Intl.Collator`.
+ *
+ * Returns an object with `contains`, `startsWith`, and `endsWith` methods
+ * that can be passed to the `filter` prop of `<Combobox.Parts.Root>`
+ * to customize how items are filtered against the input value.
+ *
+ * Accepts `Intl.CollatorOptions` (e.g. `sensitivity`, `usage`) plus
+ * an optional `locale` for locale-aware matching.
+ *
+ * @example
+ * ```tsx
+ * const filter = Combobox.useFilter({ sensitivity: "base" });
+ *
+ * <Combobox.Parts.Root filter={filter.contains}>
+ *   ...
+ * </Combobox.Parts.Root>
+ * ```
+ */
+declare const useFilter: typeof Combobox_2.useFilter;
+
+/**
+ * Hook for robust string matching using `Intl.Collator`.
+ *
+ * Returns an object with `contains`, `startsWith`, and `endsWith` methods
+ * that can be passed to the `filter` prop of `<Autocomplete.Parts.Root>`
+ * to customize how suggestions are filtered against the input value.
+ *
+ * Accepts `Intl.CollatorOptions` (e.g. `sensitivity`, `usage`) plus
+ * an optional `locale` for locale-aware matching.
+ *
+ * @example
+ * ```tsx
+ * const filter = Autocomplete.useFilter({ sensitivity: "base" });
+ *
+ * <Autocomplete.Parts.Root filter={filter.contains}>
+ *   ...
+ * </Autocomplete.Parts.Root>
+ * ```
+ */
+declare const useFilter_2: getFilter;
+
 export { useLocation }
 
 export { useNavigate }