najm-kit 2.6.2 → 2.6.4

package/dist/NajmUIProvider-x4chK0io.d.ts

@@ -0,0 +1,425 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+
+type NajmMode = 'light' | 'dark';
+type NajmAccent = 'neutral' | 'emerald' | 'green' | 'slate' | 'blue' | 'violet';
+type NajmPreset = 'light' | 'dark' | 'dark-emerald' | 'dark-green' | 'dark-slate' | 'dark-blue' | 'dark-violet';
+interface NajmAppearance {
+    /** Global border thickness, e.g. `'0'`, `'1px'`, `'2px'`. `'0'` hides borders. */
+    borderWidth?: string;
+}
+interface NajmThemeTokens {
+    background?: string;
+    foreground?: string;
+    card?: string;
+    'card-foreground'?: string;
+    popover?: string;
+    'popover-foreground'?: string;
+    primary?: string;
+    'primary-foreground'?: string;
+    secondary?: string;
+    'secondary-foreground'?: string;
+    tertiary?: string;
+    'tertiary-foreground'?: string;
+    muted?: string;
+    'muted-foreground'?: string;
+    accent?: string;
+    'accent-foreground'?: string;
+    destructive?: string;
+    'destructive-foreground'?: string;
+    border?: string;
+    input?: string;
+    ring?: string;
+    sidebar?: string;
+    'sidebar-foreground'?: string;
+    'sidebar-primary'?: string;
+    'sidebar-primary-foreground'?: string;
+    'sidebar-accent'?: string;
+    'sidebar-accent-foreground'?: string;
+    'sidebar-border'?: string;
+    'sidebar-ring'?: string;
+    'chart-1'?: string;
+    'chart-2'?: string;
+    'chart-3'?: string;
+    'chart-4'?: string;
+    'chart-5'?: string;
+    radius?: string;
+}
+/** Serializable theme settings suitable for JSON files, APIs, or local storage. */
+interface NajmThemeConfig {
+    preset?: NajmPreset;
+    mode?: NajmMode;
+    accent?: NajmAccent;
+    tokens?: NajmThemeTokens;
+    /**
+     * Per-mode token overrides authored on top of the composed preset. Keeps
+     * light and dark customizations independent: editing a token in one mode
+     * records it here so it survives switching to the other mode and back.
+     * Providers resolve this field on top of the composed mode/accent preset.
+     */
+    overrides?: Partial<Record<NajmMode, NajmThemeTokens>>;
+    accentOnly?: boolean;
+    appearance?: NajmAppearance;
+    radius?: string;
+}
+interface NajmThemeProviderProps {
+    /** Serializable theme settings. Explicit provider props override this config. */
+    config?: NajmThemeConfig;
+    preset?: NajmPreset;
+    mode?: NajmMode;
+    accent?: NajmAccent;
+    tokens?: NajmThemeTokens;
+    /** When true, only inject accent tokens (primary, ring, accent and their foregrounds).
+     *  Everything else (bg, card, fg…) is inherited from the parent cascade. */
+    accentOnly?: boolean;
+    /** App-wide UI preferences (currently global border width). */
+    appearance?: NajmAppearance;
+    /** Global base radius, for example `0`, `0.5rem`, or `0.75rem`. */
+    radius?: string;
+    className?: string;
+    asChild?: boolean;
+    children: React.ReactNode;
+}
+
+type NajmDensity = "compact" | "default" | "comfortable";
+/** Tailwind's mobile-first viewport breakpoints, plus the default value. */
+type NajmResponsiveBreakpoint = "base" | "sm" | "md" | "lg" | "xl" | "2xl";
+/**
+ * A scalar value for every viewport, or mobile-first breakpoint overrides.
+ * For example: `{ base: 164, lg: 200, xl: 240 }`.
+ */
+type NajmResponsiveValue<T> = T | Partial<Record<NajmResponsiveBreakpoint, T>>;
+type NajmComponentRadius = "inherit" | "none" | "xs" | "sm" | "md" | "lg" | "xl" | "full" | string;
+interface NajmSlotStyle {
+    className?: string;
+    radius?: NajmComponentRadius;
+    borderWidth?: string;
+    padding?: string;
+    paddingTop?: string;
+}
+interface NajmVariantStyle {
+    /** Reuse another variant's recipe. Example: primary badge uses secondary. */
+    use?: string;
+    className?: string;
+    tokens?: Record<string, string>;
+}
+interface NajmComponentStyleConfig {
+    /** Render components that support it as a card-like surface. */
+    card?: boolean;
+    /** Sidebar-only: render section titles above grouped nav items. */
+    showSectionLabels?: boolean;
+    /** Sidebar-only: render separator lines between nav item sections. */
+    showSectionSeparators?: boolean;
+    /** Sidebar-only: expanded width in px (default 240). Supports responsive overrides. */
+    expandedWidth?: NajmResponsiveValue<number>;
+    /** Sidebar-only: collapsed width in px (default 64). Supports responsive overrides. */
+    collapsedWidth?: NajmResponsiveValue<number>;
+    /** Sidebar-only: mobile drawer width in px. Defaults to the expanded width. */
+    mobileWidth?: NajmResponsiveValue<number>;
+    defaultVariant?: string;
+    defaultSize?: string;
+    density?: NajmDensity;
+    /** NTable-only: CSS color used for the table header and add button. */
+    headerColor?: string;
+    /** NTable-only: CSS color used for table header text and add button text. */
+    headerTextColor?: string;
+    /** NTable-only: CSS color used for table container and row borders. */
+    borderColor?: string;
+    radius?: NajmComponentRadius;
+    borderWidth?: string;
+    slots?: Record<string, NajmSlotStyle>;
+    variants?: Record<string, NajmVariantStyle>;
+}
+type NajmComponentName = "button" | "badge" | "card" | "table" | "tabs" | "dialog" | "alert" | "sidebar" | "pageHeader" | "input" | "select" | "dropdown" | "sheet" | "popover" | "tooltip" | "progress" | "avatar";
+type NajmComponentThemeConfig = Partial<Record<NajmComponentName, NajmComponentStyleConfig>>;
+interface NajmTypographyConfig {
+    fontSans?: string;
+    fontHeading?: string;
+    fontMono?: string;
+    baseSize?: string;
+    scale?: "compact" | "default" | "comfortable";
+    lineHeight?: string;
+    letterSpacing?: string;
+}
+interface NajmLayoutConfig {
+    /** Page inline padding, usually used by NPageLayout. */
+    pageGutter?: string;
+    /** Vertical page padding and stacked section gap, usually used by NPageLayout. */
+    sectionGap?: string;
+}
+interface NajmDesignConfig {
+    version: 1;
+    theme: NajmThemeConfig;
+    typography?: NajmTypographyConfig;
+    components?: NajmComponentThemeConfig;
+    layout?: NajmLayoutConfig;
+}
+declare const NAJM_COMPONENT_NAMES: readonly NajmComponentName[];
+/** Maps a NajmComponentRadius keyword to a CSS value (or var). */
+declare const RADIUS_VALUE_MAP: Record<string, string>;
+declare function resolveRadiusValue(radius: NajmComponentRadius | undefined): string | undefined;
+
+/**
+ * How the page controls present position within the result.
+ *
+ * `numbered` renders a windowed list of page buttons. `compact` renders the
+ * `Page X of Y` text with first/previous/next/last controls.
+ *
+ * `numbered` needs a trustworthy page count. Under `manualPagination` that
+ * means the application must pass a `pageCount` derived from a real result
+ * total, or — when its endpoint reports no total — pass `hasNextPage` and no
+ * `pageCount` at all, which renders the unbounded bar described on the NTable
+ * prop. With neither, the bar falls back to `compact` on its own rather than
+ * inviting clicks on pages that may not exist.
+ *
+ * What it must never be handed is a `pageCount` that is really a lower bound,
+ * such as `pageIndex + 2`. That reads as a two-page result on page one and a
+ * three-page result on page two, so the bar grows a number per click with
+ * nothing to say why. NTable warns in development when it catches a count
+ * moving in lockstep with the page index.
+ */
+type NTablePaginationVariant = "numbered" | "compact";
+/**
+ * Accessible names and visible copy for the page controls.
+ *
+ * Every field is optional and falls back to English. Supply them to localize —
+ * the numbered variant is mostly digits, but its controls still need names.
+ */
+interface NTablePaginationLabels {
+    /** Labels the rows-per-page select. Defaults to `"Rows/page"`. */
+    rowsPerPage?: string;
+    /** Accessible name of the whole page control group. Defaults to `"Pagination"`. */
+    pagination?: string;
+    /** Accessible name for one page button, given a 1-based page. */
+    goToPage?: (page: number) => string;
+    /** Accessible name of the current page button, given a 1-based page. */
+    currentPage?: (page: number) => string;
+    firstPage?: string;
+    previousPage?: string;
+    nextPage?: string;
+    lastPage?: string;
+    /** The `compact` variant's position text, given 1-based values. */
+    pageOf?: (page: number, pageCount: number) => string;
+    /**
+     * The position text when the result has no known total, given the 1-based
+     * page. Defaults to `"Page X"` — there is no `of Y` to state, and repeating
+     * the moving lower bound there would be the same lie the numbered bar avoids.
+     */
+    pageOfUnknown?: (page: number) => string;
+    /** The selection summary, given selected and total row counts. */
+    rowsSelected?: (selected: number, total: number) => string;
+}
+interface NTableLoadMorePagination {
+    /** Render the supplied rows as one card list with an explicit continuation control. */
+    mode: "load-more";
+    /** Whether the owning application has another server page available. */
+    hasNextPage: boolean;
+    /** True while the owning application is appending the next page. */
+    loadingMore?: boolean;
+    /** A controlled append error. Existing rows remain rendered and the control becomes Retry. */
+    loadMoreError?: ReactNode;
+    /** Fetch exactly one additional page. Najm Kit never constructs or owns the request. */
+    onLoadMore: () => unknown | Promise<unknown>;
+    loadMoreLabel?: string;
+    loadingMoreLabel?: string;
+    retryLabel?: string;
+    endLabel?: string;
+    loadMoreErrorLabel?: string;
+    /** Localize the polite announcement made after appended rows arrive. */
+    itemsLoadedLabel?: (count: number) => string;
+}
+interface NTableInfinitePagination {
+    /**
+     * Render the supplied rows as one card list that continues automatically when
+     * the end of the list scrolls into view. No control and no end-of-list
+     * element are rendered while the list is healthy; the continuation button
+     * appears only after an append failure, as the retry target.
+     */
+    mode: "infinite";
+    /** Whether the owning application has another server page available. */
+    hasNextPage: boolean;
+    /** True while the owning application is appending the next page. */
+    loadingMore?: boolean;
+    /** A controlled append error. Existing rows remain rendered and Retry appears. */
+    loadMoreError?: ReactNode;
+    /** Fetch exactly one additional page. Najm Kit never constructs or owns the request. */
+    onLoadMore: () => unknown | Promise<unknown>;
+    /**
+     * Distance ahead of the list end at which the next page is requested.
+     * Defaults to `"80px"`.
+     */
+    rootMargin?: string;
+    loadingMoreLabel?: string;
+    retryLabel?: string;
+    loadMoreErrorLabel?: string;
+    /** Localize the polite announcement made after appended rows arrive. */
+    itemsLoadedLabel?: (count: number) => string;
+}
+/**
+ * Presentation policy used while NTable is actually rendering cards.
+ *
+ * `paged` preserves the existing page controls. `all` renders every supplied
+ * row without a footer, in card and table modes alike. `load-more` renders
+ * every supplied row and adds a guarded, accessible continuation control.
+ * `infinite` renders every supplied row and continues on scroll instead.
+ *
+ * Applications remain responsible for fetching, accumulating, filtering,
+ * sorting, authorization, and privacy. `all` renders exactly the rows it is
+ * given and never fetches, so a caller that has not loaded the whole set must
+ * not select it.
+ */
+type NTableCardPagination = {
+    mode?: "paged";
+} | {
+    mode: "all";
+} | NTableLoadMorePagination | NTableInfinitePagination;
+
+/**
+ * Defaults every `NTable` beneath the provider inherits.
+ *
+ * Localized copy is the motivating case: an application with more than a couple
+ * of tables should not repeat the same label bundle at every render site, and
+ * an application with more than one locale should not have to remember to.
+ */
+interface NTableDefaults {
+    paginationLabels?: NTablePaginationLabels;
+}
+/**
+ * Supply table defaults to everything below.
+ *
+ * `value` is passed straight through, so memoize it in the caller — an inline
+ * object literal rebuilds on every render of the shell and re-renders every
+ * table beneath it. Most label fields are functions, so `useMemo` on the
+ * translator is usually the whole job.
+ */
+declare function NTableDefaultsProvider({ children, value, }: {
+    children: React__default.ReactNode;
+    value: NTableDefaults;
+}): react_jsx_runtime.JSX.Element;
+declare function useNTableDefaults(): NTableDefaults;
+
+/**
+ * Theme and time zone, the two preferences that outlive a render.
+ *
+ * Both are *uncontrolled*: the `initial*` props seed state the provider owns
+ * from then on, and later changes to those props are ignored. That is the
+ * shape the server hand-off wants — the page is rendered once against a cookie,
+ * and every change after that originates here.
+ *
+ * Persistence is not this provider's business. It applies the change to the
+ * document, then hands the new value to a callback the application supplies.
+ * See `NajmNextUIProvider` in `najm-kit/next` for the cookie-endpoint wiring.
+ */
+interface NajmPreferencesContextValue {
+    theme: NajmMode;
+    setTheme: (theme: NajmMode) => Promise<void>;
+    timeZone: string;
+    setTimeZone: (timeZone: string) => Promise<void>;
+}
+declare const DEFAULT_TIME_ZONE = "UTC";
+interface NajmPreferencesProviderProps {
+    children: React$1.ReactNode;
+    /** Seeds theme state; ignored after mount. Defaults to `"light"`. */
+    initialTheme?: NajmMode;
+    /** Seeds time zone state; ignored after mount. Defaults to `"UTC"`. */
+    initialTimeZone?: string;
+    /** Persist the new theme. Rejections propagate to the `setTheme` caller. */
+    onThemeChange?: (theme: NajmMode) => void | Promise<void>;
+    /** Persist the new time zone. Rejections propagate to `setTimeZone`. */
+    onTimeZoneChange?: (timeZone: string) => void | Promise<void>;
+    /** Sanitize a time zone before it is stored. Defaults to identity. */
+    normalizeTimeZone?: (value: string) => string;
+}
+/**
+ * Standalone preferences, without the design and table layers.
+ *
+ * `NajmUIProvider` renders this internally, so most applications never name it.
+ * It is exported for the case where something *above* the design layer needs to
+ * read the theme — a runtime theme editor, typically, which owns the design
+ * config and therefore has to sit above the provider consuming it. Hoisting
+ * preferences out is then a reorder rather than a fork.
+ */
+declare function NajmPreferencesProvider({ children, initialTheme, initialTimeZone, onThemeChange, onTimeZoneChange, normalizeTimeZone, }: NajmPreferencesProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Returns the context when one is mounted, or `null`.
+ *
+ * `NajmUIProvider` uses this to defer to an outer `NajmPreferencesProvider`
+ * instead of shadowing it, so nesting the two is well-defined rather than
+ * quietly producing two disagreeing themes.
+ */
+declare function useNajmPreferencesContext(): NajmPreferencesContextValue | null;
+/** The live theme and a setter that persists through `onThemeChange`. */
+declare function useNajmTheme(): Pick<NajmPreferencesContextValue, "theme" | "setTheme">;
+/** The live time zone and a setter that persists through `onTimeZoneChange`. */
+declare function useNajmTimeZone(): Pick<NajmPreferencesContextValue, "timeZone" | "setTimeZone">;
+
+/**
+ * The translator shape `NajmUIProvider` accepts.
+ *
+ * Deliberately structural rather than an import from `najm-i18n`: the kit
+ * depends on no `najm-*` package, and this signature is satisfied by every
+ * mainstream i18n library. The application keeps its catalog and its own
+ * language provider.
+ */
+type NajmTranslate = (key: string, params?: Record<string, string | number>) => string;
+declare const DEFAULT_PAGINATION_KEY_PREFIX = "common.pagination";
+/**
+ * Projects a translator onto the ten pagination labels.
+ *
+ * Keys are `<prefix>.<field>`, matching the `NTablePaginationLabels` field
+ * names one-for-one, so a catalog is readable next to the type. Interpolation
+ * params are named for what they are: `page`, `pageCount`, `selected`, `total`.
+ *
+ * No result is inspected or second-guessed. A translator that echoes missing
+ * keys will render those keys — that is the translator's contract to define,
+ * and quietly swapping in English would hide the missing entry rather than
+ * surface it. Applications that want the packaged English for a given label
+ * should omit the key from the prefix and override it via `tableDefaults`.
+ */
+declare function buildPaginationLabels(t: NajmTranslate, prefix?: string): NTablePaginationLabels;
+
+interface NajmUIProviderProps extends Omit<NajmPreferencesProviderProps, "children"> {
+    children: React$1.ReactNode;
+    /** The design config handed to `NajmDesignProvider`. */
+    design: NajmDesignConfig;
+    /** Forwarded to `NajmDesignProvider`. */
+    className?: string;
+    /**
+     * Translator for the pagination labels. Omit it and the packaged English
+     * applies — the provider is still worth mounting for design and preferences.
+     *
+     * Memoize it. The labels are rebuilt whenever its identity changes, and
+     * rebuilding them re-renders every table beneath.
+     */
+    t?: NajmTranslate;
+    /** Catalog prefix for the labels. Defaults to `"common.pagination"`. */
+    paginationKeyPrefix?: string;
+    /**
+     * Per-key overrides layered over the translated labels. Memoize it, for the
+     * same reason as `t`.
+     */
+    tableDefaults?: NTableDefaults;
+}
+/**
+ * The one provider a Najm application mounts for UI concerns.
+ *
+ * Composes three things that otherwise get copied between projects: theme and
+ * time zone state with async persistence, a `NajmDesignProvider` fed the live
+ * theme, and `NTable` pagination labels derived from the application's
+ * translator.
+ *
+ * What it deliberately does not own: auth, react-query, and the translation
+ * catalog. Those stay in the application — folding them in would make a UI
+ * package depend on `najm-auth` and `@tanstack/react-query` and turn it into a
+ * framework. Persistence is injected as callbacks so this entry imports
+ * nothing from `next`; see `NajmNextUIProvider` in `najm-kit/next`.
+ *
+ * Rendering this under an existing `NajmPreferencesProvider` is supported: the
+ * outer one wins and the preference props here are ignored. That is what lets
+ * an application with a runtime theme editor hoist preferences above its
+ * design context without forking this component.
+ */
+declare function NajmUIProvider({ children, design, className, t, paginationKeyPrefix, tableDefaults, initialTheme, initialTimeZone, onThemeChange, onTimeZoneChange, normalizeTimeZone, }: NajmUIProviderProps): react_jsx_runtime.JSX.Element;
+
+export { type NajmDensity as A, type NajmPreferencesContextValue as B, NajmPreferencesProvider as C, DEFAULT_PAGINATION_KEY_PREFIX as D, type NajmPreferencesProviderProps as E, type NajmSlotStyle as F, type NajmTranslate as G, NajmUIProvider as H, buildPaginationLabels as I, resolveRadiusValue as J, useNTableDefaults as K, useNajmPreferencesContext as L, useNajmTheme as M, type NajmUIProviderProps as N, useNajmTimeZone as O, RADIUS_VALUE_MAP as R, type NajmThemeProviderProps as a, type NajmAppearance as b, type NajmMode as c, type NajmDesignConfig as d, type NajmThemeConfig as e, type NajmAccent as f, type NajmThemeTokens as g, type NajmPreset as h, type NajmComponentName as i, type NajmComponentStyleConfig as j, type NajmComponentThemeConfig as k, type NajmTypographyConfig as l, type NajmLayoutConfig as m, type NajmVariantStyle as n, type NTablePaginationVariant as o, type NTablePaginationLabels as p, type NTableCardPagination as q, type NajmResponsiveBreakpoint as r, type NajmResponsiveValue as s, DEFAULT_TIME_ZONE as t, NAJM_COMPONENT_NAMES as u, type NTableDefaults as v, NTableDefaultsProvider as w, type NTableInfinitePagination as x, type NTableLoadMorePagination as y, type NajmComponentRadius as z };

package/dist/adapters/next.d.ts

@@ -1,4 +1,6 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import React__default from 'react';
+import { N as NajmUIProviderProps } from '../NajmUIProvider-x4chK0io.js';
 
 interface NextLinkAdapterProps extends Record<string, any> {
     href: string;
@@ -16,5 +18,34 @@ declare function useNextNavigationAdapter(): {
     push: (path: string) => void;
     replace: (path: string) => void;
 };
+/** Where `NajmNextUIProvider` POSTs each preference. */
+interface NajmNextUIEndpoints {
+    /** Defaults to `/api/ui-theme`. Receives `{ theme }`. */
+    theme?: string;
+    /** Defaults to `/api/ui-timezone`. Receives `{ timeZone }`. */
+    timeZone?: string;
+}
+interface NajmNextUIProviderProps extends Omit<NajmUIProviderProps, 'onThemeChange' | 'onTimeZoneChange'> {
+    endpoints?: NajmNextUIEndpoints;
+    /**
+     * Call `router.refresh()` after a preference is persisted, so server
+     * components re-render against the new cookie. Defaults to `true`.
+     */
+    refreshOnChange?: boolean;
+}
+/**
+ * `NajmUIProvider` with the Next wiring supplied: preferences are POSTed to
+ * cookie route handlers and the router is refreshed so server components see
+ * the change.
+ *
+ * The route handlers are the application's — this package calls them, it does
+ * not ship them. Each takes a JSON body (`{ theme }` / `{ timeZone }`), sets
+ * its cookie, and returns any 2xx.
+ *
+ * This is the only module in the package that imports `next`, which is why
+ * `next` is an *optional* peer dependency: consumers of the root entry never
+ * reach this file.
+ */
+declare function NajmNextUIProvider({ endpoints, refreshOnChange, ...props }: NajmNextUIProviderProps): react_jsx_runtime.JSX.Element;
 
-export { NextLinkAdapter, type NextLinkAdapterProps, useNextNavigationAdapter };
+export { type NajmNextUIEndpoints, NajmNextUIProvider, type NajmNextUIProviderProps, NextLinkAdapter, type NextLinkAdapterProps, useNextNavigationAdapter };

package/dist/adapters/next.mjs

@@ -1,6 +1,9 @@
+import { NajmUIProvider } from '../chunk-JZJCQBOH.mjs';
+import '../chunk-YBM5CTE6.mjs';
 import React from 'react';
+import { useRouter } from 'next/navigation';
+import { jsx } from 'react/jsx-runtime';
 
-// src/adapters/next.tsx
 function NextLinkAdapter({ children, ...props }) {
   return React.createElement("a", props, children);
 }
@@ -19,5 +22,51 @@ function useNextNavigationAdapter() {
     }
   };
 }
+var DEFAULT_THEME_ENDPOINT = "/api/ui-theme";
+var DEFAULT_TIME_ZONE_ENDPOINT = "/api/ui-timezone";
+async function postPreference(endpoint, body) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    credentials: "same-origin",
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to persist preference to ${endpoint}: ${response.status}`
+    );
+  }
+}
+function NajmNextUIProvider({
+  endpoints,
+  refreshOnChange = true,
+  ...props
+}) {
+  const router = useRouter();
+  const themeEndpoint = endpoints?.theme ?? DEFAULT_THEME_ENDPOINT;
+  const timeZoneEndpoint = endpoints?.timeZone ?? DEFAULT_TIME_ZONE_ENDPOINT;
+  const onThemeChange = React.useCallback(
+    async (theme) => {
+      await postPreference(themeEndpoint, { theme });
+      if (refreshOnChange) router.refresh();
+    },
+    [themeEndpoint, refreshOnChange, router]
+  );
+  const onTimeZoneChange = React.useCallback(
+    async (timeZone) => {
+      await postPreference(timeZoneEndpoint, { timeZone });
+      if (refreshOnChange) router.refresh();
+    },
+    [timeZoneEndpoint, refreshOnChange, router]
+  );
+  return /* @__PURE__ */ jsx(
+    NajmUIProvider,
+    {
+      ...props,
+      onThemeChange,
+      onTimeZoneChange
+    }
+  );
+}
 
-export { NextLinkAdapter, useNextNavigationAdapter };
+export { NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter };