@voyant-travel/admin 0.111.0

package/dist/navigation/destinations.d.ts

@@ -0,0 +1,83 @@
+import * as React from "react";
+/**
+ * Semantic admin navigation destinations (packaged-admin RFC §4.7).
+ *
+ * Package-owned admin pages cannot import a host's typed route tree, so they
+ * never navigate by route path. Instead they navigate to a semantic
+ * destination KEY; the host registers a key → href resolver map once.
+ *
+ * This interface ships empty. Domain packages declare the destinations their
+ * pages need via TypeScript declaration merging (the same `Register` trick
+ * TanStack Router uses):
+ *
+ * ```ts
+ * // inside @voyant-travel/catalog-react
+ * declare module "@voyant-travel/admin" {
+ *   interface AdminDestinations {
+ *     "supplier.detail": { supplierId: string }
+ *   }
+ * }
+ * ```
+ *
+ * Naming convention: `<entity>.<action>` (e.g. `"product.detail"`,
+ * `"bookingJourney.start"`). The host then provides a resolver per declared
+ * key — `satisfies AdminDestinationResolvers` makes the map exhaustive.
+ */
+export interface AdminDestinations {
+}
+/** Union of all declared destination keys (empty until packages augment). */
+export type AdminDestinationKey = keyof AdminDestinations & string;
+/**
+ * The host's resolver map: one `params → href` function per declared
+ * destination key. Mapped over {@link AdminDestinations}, so `satisfies
+ * AdminDestinationResolvers` fails to compile when a declared key is missing
+ * a resolver — exhaustiveness is the host's proof of contract.
+ */
+export type AdminDestinationResolvers = {
+    [K in AdminDestinationKey]: (params: AdminDestinations[K]) => string;
+};
+/** Resolve a destination key + params to an href. Returned by {@link useAdminHref}. */
+export type AdminHrefResolver = <K extends AdminDestinationKey>(key: K, params: AdminDestinations[K]) => string;
+/**
+ * History options for a destination navigation. Packaged pages that REDIRECT
+ * (an alias route forwarding to its canonical page, a deep link that resolves
+ * straight into another flow) pass `replace: true` so the intermediate URL
+ * never lands in history — the same semantics a route-level redirect has.
+ */
+export interface AdminNavigateOptions {
+    /** Replace the current history entry instead of pushing a new one. */
+    replace?: boolean;
+}
+/** Navigate to a destination key + params. Returned by {@link useAdminNavigate}. */
+export type AdminDestinationNavigator = <K extends AdminDestinationKey>(key: K, params: AdminDestinations[K], options?: AdminNavigateOptions) => void;
+export interface AdminNavigationProviderProps {
+    /** Host resolver map covering every destination key the mounted packages declare. */
+    resolvers: AdminDestinationResolvers;
+    /**
+     * Host-injected navigation primitive — typically the app router's
+     * href-based navigate. Keeping it injected keeps this package
+     * router-agnostic. Hosts should honor `options.replace` (map it onto the
+     * router's history-replace mode) so packaged redirects behave like route
+     * redirects; ignoring it only costs an extra history entry.
+     */
+    navigate: (href: string, options?: AdminNavigateOptions) => void;
+    children: React.ReactNode;
+}
+/**
+ * Provides destination resolution + navigation to packaged admin pages.
+ * Hosts mount it once around the workspace (e.g. via `AdminWorkspaceShell`'s
+ * `destinations` prop in `@voyant-travel/admin/app/workspace`).
+ */
+export declare function AdminNavigationProvider({ resolvers, navigate, children, }: AdminNavigationProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Resolve destination keys to hrefs (for `<a href>` / link props). When a key
+ * cannot be resolved, warns once per key and returns `"#"` — render paths
+ * never throw over a missing link target.
+ */
+export declare function useAdminHref(): AdminHrefResolver;
+/**
+ * Navigate to a destination: resolve the href, then call the host-injected
+ * `navigate`. When the key cannot be resolved, warns once per key and no-ops.
+ */
+export declare function useAdminNavigate(): AdminDestinationNavigator;
+//# sourceMappingURL=destinations.d.ts.map

package/dist/navigation/destinations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destinations.d.ts","sourceRoot":"","sources":["../../src/navigation/destinations.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,iBAAiB;CAAG;AAErC,6EAA6E;AAC7E,MAAM,MAAM,mBAAmB,GAAG,MAAM,iBAAiB,GAAG,MAAM,CAAA;AAElE;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG;KACrC,CAAC,IAAI,mBAAmB,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,MAAM;CACrE,CAAA;AAED,uFAAuF;AACvF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,SAAS,mBAAmB,EAC5D,GAAG,EAAE,CAAC,EACN,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,KACzB,MAAM,CAAA;AAEX;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,sEAAsE;IACtE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,oFAAoF;AACpF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,SAAS,mBAAmB,EACpE,GAAG,EAAE,CAAC,EACN,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC5B,OAAO,CAAC,EAAE,oBAAoB,KAC3B,IAAI,CAAA;AAST,MAAM,WAAW,4BAA4B;IAC3C,qFAAqF;IACrF,SAAS,EAAE,yBAAyB,CAAA;IACpC;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,IAAI,CAAA;IAChE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,SAAS,EACT,QAAQ,EACR,QAAQ,GACT,EAAE,4BAA4B,2CAI9B;AAoDD;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,iBAAiB,CAOhD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,yBAAyB,CAW5D"}

package/dist/navigation/destinations.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+const AdminNavigationContext = React.createContext(null);
+/**
+ * Provides destination resolution + navigation to packaged admin pages.
+ * Hosts mount it once around the workspace (e.g. via `AdminWorkspaceShell`'s
+ * `destinations` prop in `@voyant-travel/admin/app/workspace`).
+ */
+export function AdminNavigationProvider({ resolvers, navigate, children, }) {
+    const value = React.useMemo(() => ({ resolvers, navigate }), [resolvers, navigate]);
+    return _jsx(AdminNavigationContext.Provider, { value: value, children: children });
+}
+/** Keys already warned about — unresolvable destinations warn once, not per render. */
+const warnedDestinationKeys = new Set();
+function warnOnce(key, message, ...rest) {
+    if (warnedDestinationKeys.has(key))
+        return;
+    warnedDestinationKeys.add(key);
+    console.warn(message, ...rest);
+}
+/**
+ * Resolve a destination to an href, or `null` when unresolvable (no provider,
+ * no resolver for the key, or a throwing resolver). Never throws — these run
+ * in render paths, and a broken link must not take the page down with it.
+ */
+function resolveDestinationHref(context, key, params) {
+    if (!context) {
+        warnOnce(key, `[voyant-admin] Destination "${key}" was resolved outside an <AdminNavigationProvider>; falling back to "#".`);
+        return null;
+    }
+    const resolver = context.resolvers[key];
+    if (!resolver) {
+        warnOnce(key, `[voyant-admin] No resolver registered for destination "${key}"; falling back to "#". Add it to the host's AdminNavigationProvider resolvers.`);
+        return null;
+    }
+    try {
+        return resolver(params);
+    }
+    catch (error) {
+        warnOnce(key, `[voyant-admin] Resolver for destination "${key}" threw; falling back to "#".`, error);
+        return null;
+    }
+}
+/**
+ * Resolve destination keys to hrefs (for `<a href>` / link props). When a key
+ * cannot be resolved, warns once per key and returns `"#"` — render paths
+ * never throw over a missing link target.
+ */
+export function useAdminHref() {
+    const context = React.useContext(AdminNavigationContext);
+    return React.useCallback((key, params) => resolveDestinationHref(context, key, params) ?? "#", [context]);
+}
+/**
+ * Navigate to a destination: resolve the href, then call the host-injected
+ * `navigate`. When the key cannot be resolved, warns once per key and no-ops.
+ */
+export function useAdminNavigate() {
+    const context = React.useContext(AdminNavigationContext);
+    return React.useCallback((key, params, options) => {
+        const href = resolveDestinationHref(context, key, params);
+        if (href === null || context === null)
+            return;
+        context.navigate(href, options);
+    }, [context]);
+}

package/dist/navigation/operator-navigation.d.ts

@@ -0,0 +1,10 @@
+import type { OperatorAdminMessages } from "../providers/operator-admin-messages.js";
+import type { NavItem } from "../types.js";
+export type OperatorAdminNavigationIconName = "availability" | "bookings" | "catalog" | "channelSync" | "dashboard" | "finance" | "flights" | "legal" | "notifications" | "organizations" | "people" | "products" | "resources" | "settings" | "suppliers";
+export type OperatorAdminNavigationIcons = Partial<Record<OperatorAdminNavigationIconName, NavItem["icon"]>>;
+export interface CreateOperatorAdminNavigationOptions {
+    messages: OperatorAdminMessages["nav"];
+    icons?: OperatorAdminNavigationIcons;
+}
+export declare function createOperatorAdminNavigation({ icons, messages, }: CreateOperatorAdminNavigationOptions): NavItem[];
+//# sourceMappingURL=operator-navigation.d.ts.map

package/dist/navigation/operator-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-navigation.d.ts","sourceRoot":"","sources":["../../src/navigation/operator-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAA;AACpF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,+BAA+B,GACvC,cAAc,GACd,UAAU,GACV,SAAS,GACT,aAAa,GACb,WAAW,GACX,SAAS,GACT,SAAS,GACT,OAAO,GACP,eAAe,GACf,eAAe,GACf,QAAQ,GACR,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,CAAA;AAEf,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,MAAM,CAAC,+BAA+B,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CACzD,CAAA;AAED,MAAM,WAAW,oCAAoC;IACnD,QAAQ,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAA;IACtC,KAAK,CAAC,EAAE,4BAA4B,CAAA;CACrC;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,KAAU,EACV,QAAQ,GACT,EAAE,oCAAoC,GAAG,OAAO,EAAE,CA8LlD"}

package/dist/navigation/operator-navigation.js

@@ -0,0 +1,191 @@
+export function createOperatorAdminNavigation({ icons = {}, messages, }) {
+    return [
+        {
+            id: "dashboard",
+            title: messages.dashboard,
+            url: "/",
+            icon: icons.dashboard,
+        },
+        {
+            id: "catalog",
+            title: messages.catalog,
+            url: "/catalog/products",
+            icon: icons.catalog,
+            items: [
+                {
+                    id: "catalog-products",
+                    title: messages.catalogProducts,
+                    url: "/catalog/products",
+                },
+                {
+                    id: "catalog-excursions",
+                    title: messages.catalogExcursions,
+                    url: "/catalog/excursions",
+                },
+                {
+                    id: "catalog-tours",
+                    title: messages.catalogTours,
+                    url: "/catalog/tours",
+                },
+                {
+                    id: "catalog-cruises",
+                    title: messages.catalogCruises,
+                    url: "/catalog/cruises",
+                },
+                {
+                    id: "catalog-accommodations",
+                    title: messages.catalogAccommodations,
+                    url: "/catalog/accommodations",
+                },
+            ],
+        },
+        {
+            id: "flights",
+            title: messages.flights,
+            url: "/flights",
+            icon: icons.flights,
+        },
+        {
+            id: "products",
+            title: messages.products,
+            url: "/products",
+            icon: icons.products,
+            items: [
+                {
+                    id: "product-categories",
+                    title: messages.categories,
+                    url: "/products/categories",
+                },
+            ],
+        },
+        {
+            id: "availability",
+            title: messages.availability,
+            url: "/operations/availability",
+            icon: icons.availability,
+        },
+        {
+            id: "bookings",
+            title: messages.bookings,
+            url: "/bookings",
+            icon: icons.bookings,
+        },
+        {
+            id: "notifications",
+            title: messages.notifications,
+            url: "/notifications/templates",
+            icon: icons.notifications,
+            items: [
+                {
+                    id: "notification-templates",
+                    title: messages.notificationTemplates,
+                    url: "/notifications/templates",
+                },
+                {
+                    id: "notification-reminder-rules",
+                    title: messages.notificationReminderRules,
+                    url: "/notifications/reminder-rules",
+                },
+                {
+                    id: "notification-deliveries",
+                    title: messages.notificationDeliveries,
+                    url: "/notifications/deliveries",
+                },
+                {
+                    id: "notification-reminder-runs",
+                    title: messages.notificationReminderRuns,
+                    url: "/notifications/reminder-runs",
+                },
+                {
+                    id: "notification-preview",
+                    title: messages.notificationPreview,
+                    url: "/notifications/preview",
+                },
+                {
+                    id: "notification-settings",
+                    title: messages.notificationSettings,
+                    url: "/notifications/settings",
+                },
+            ],
+        },
+        {
+            id: "suppliers",
+            title: messages.suppliers,
+            url: "/suppliers",
+            icon: icons.suppliers,
+        },
+        {
+            id: "people",
+            title: messages.people,
+            url: "/people",
+            icon: icons.people,
+        },
+        {
+            id: "organizations",
+            title: messages.organizations,
+            url: "/organizations",
+            icon: icons.organizations,
+        },
+        {
+            id: "resources",
+            title: messages.resources,
+            url: "/operations/resources",
+            icon: icons.resources,
+        },
+        {
+            id: "finance",
+            title: messages.finance,
+            url: "/finance/invoices",
+            icon: icons.finance,
+            items: [
+                { id: "invoices", title: messages.invoices, url: "/finance/invoices" },
+                {
+                    id: "invoice-number-series",
+                    title: messages.invoiceNumberSeries,
+                    url: "/finance/invoice-number-series",
+                },
+                { id: "payments", title: messages.payments, url: "/finance/payments" },
+                {
+                    id: "supplier-invoices",
+                    title: messages.supplierInvoices,
+                    url: "/finance/supplier-invoices",
+                },
+                {
+                    id: "profitability",
+                    title: messages.profitability,
+                    url: "/finance/profitability",
+                },
+            ],
+        },
+        {
+            id: "legal",
+            title: messages.legal,
+            url: "/legal/contracts",
+            icon: icons.legal,
+            items: [
+                { id: "contracts", title: messages.contracts, url: "/legal/contracts" },
+                {
+                    id: "contract-templates",
+                    title: messages.contractTemplates,
+                    url: "/legal/templates",
+                },
+                {
+                    id: "policies",
+                    title: messages.policies,
+                    url: "/legal/policies",
+                },
+                {
+                    id: "number-series",
+                    title: messages.contractNumberSeries,
+                    url: "/legal/number-series",
+                },
+            ],
+        },
+        {
+            id: "channel-sync",
+            title: messages.channelSync,
+            url: "/channel-sync",
+            icon: icons.channelSync,
+        },
+    ];
+}

package/dist/providers/admin-extensions.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { AdminExtension } from "../extensions.js";
+export interface AdminExtensionsProviderProps {
+    children: ReactNode;
+    extensions?: ReadonlyArray<AdminExtension>;
+}
+export declare function AdminExtensionsProvider({ children, extensions, }: AdminExtensionsProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAdminExtensions(): ReadonlyArray<AdminExtension>;
+//# sourceMappingURL=admin-extensions.d.ts.map

package/dist/providers/admin-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-extensions.d.ts","sourceRoot":"","sources":["../../src/providers/admin-extensions.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,SAAS,EAAc,MAAM,OAAO,CAAA;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAItD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,SAAS,CAAA;IACnB,UAAU,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;CAC3C;AAED,wBAAgB,uBAAuB,CAAC,EACtC,QAAQ,EACR,UAAe,GAChB,EAAE,4BAA4B,2CAI9B;AAED,wBAAgB,kBAAkB,IAAI,aAAa,CAAC,cAAc,CAAC,CAElE"}

package/dist/providers/admin-extensions.js

@@ -0,0 +1,10 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const AdminExtensionsContext = createContext([]);
+export function AdminExtensionsProvider({ children, extensions = [], }) {
+    return (_jsx(AdminExtensionsContext.Provider, { value: extensions, children: children }));
+}
+export function useAdminExtensions() {
+    return useContext(AdminExtensionsContext);
+}

package/dist/providers/admin-provider.d.ts

@@ -0,0 +1,53 @@
+import { type QueryClient } from "@tanstack/react-query";
+import { type ReactNode } from "react";
+import type { ThemeMode } from "../types.js";
+export interface AdminProviderProps {
+    children: ReactNode;
+    /**
+     * Pre-built QueryClient. If not provided, one is created per render-tree
+     * via `makeQueryClient()`. Pass your own for server-rendering setups where
+     * the client should be created outside React.
+     */
+    queryClient?: QueryClient;
+    /** Initial theme. Defaults to "system". */
+    defaultTheme?: ThemeMode;
+    /**
+     * localStorage key for theme persistence. Pass `null` to disable.
+     * Defaults to `"theme"`.
+     */
+    themeStorageKey?: string | null;
+    /** Initial locale. Defaults to browser locale with `en` fallback. */
+    defaultLocale?: string;
+    /** Initial timezone. Defaults to browser timezone. */
+    defaultTimeZone?: string | null;
+    /**
+     * localStorage key for locale persistence. Pass `null` to disable.
+     * Defaults to `"admin-locale"`.
+     */
+    localeStorageKey?: string | null;
+    /**
+     * localStorage key for timezone persistence. Pass `null` to disable.
+     * Defaults to `"admin-timezone"`.
+     */
+    timeZoneStorageKey?: string | null;
+    /** Supported admin locales. Defaults to `["en", "ro"]`. */
+    supportedLocales?: readonly string[];
+    /** Fallback locale when no supported locale is resolved. Defaults to `"en"`. */
+    fallbackLocale?: string;
+}
+/**
+ * Composes the shared admin providers — QueryClient, Theme, and Locale — so
+ * starters don't have to wire each one individually. Note: this does NOT include
+ * `<VoyantReactProvider>` (from `@voyant-travel/react`) because its API base
+ * URL is starter-specific. Wrap AdminProvider's children with your
+ * VoyantReactProvider at the same level.
+ *
+ * @example
+ * <AdminProvider>
+ *   <VoyantReactProvider baseUrl="/api">
+ *     <App />
+ *   </VoyantReactProvider>
+ * </AdminProvider>
+ */
+export declare function AdminProvider({ children, queryClient, defaultTheme, themeStorageKey, defaultLocale, defaultTimeZone, localeStorageKey, timeZoneStorageKey, supportedLocales, fallbackLocale, }: AdminProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=admin-provider.d.ts.map

package/dist/providers/admin-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-provider.d.ts","sourceRoot":"","sources":["../../src/providers/admin-provider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,KAAK,SAAS,EAAY,MAAM,OAAO,CAAA;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAK5C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,SAAS,CAAA;IACnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,SAAS,CAAA;IACxB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,sDAAsD;IACtD,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,gFAAgF;IAChF,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,WAAW,EACX,YAAuB,EACvB,eAAyB,EACzB,aAAa,EACb,eAAsB,EACtB,gBAAiC,EACjC,kBAAqC,EACrC,gBAAgB,EAChB,cAAc,GACf,EAAE,kBAAkB,2CAoBpB"}

package/dist/providers/admin-provider.js

@@ -0,0 +1,26 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { useState } from "react";
+import { LocaleProvider } from "./locale.js";
+import { makeQueryClient } from "./query-client.js";
+import { ThemeProvider } from "./theme.js";
+/**
+ * Composes the shared admin providers — QueryClient, Theme, and Locale — so
+ * starters don't have to wire each one individually. Note: this does NOT include
+ * `<VoyantReactProvider>` (from `@voyant-travel/react`) because its API base
+ * URL is starter-specific. Wrap AdminProvider's children with your
+ * VoyantReactProvider at the same level.
+ *
+ * @example
+ * <AdminProvider>
+ *   <VoyantReactProvider baseUrl="/api">
+ *     <App />
+ *   </VoyantReactProvider>
+ * </AdminProvider>
+ */
+export function AdminProvider({ children, queryClient, defaultTheme = "system", themeStorageKey = "theme", defaultLocale, defaultTimeZone = null, localeStorageKey = "admin-locale", timeZoneStorageKey = "admin-timezone", supportedLocales, fallbackLocale, }) {
+    // Keep a single QueryClient instance per mount when one isn't passed in.
+    const [client] = useState(() => queryClient ?? makeQueryClient());
+    return (_jsx(QueryClientProvider, { client: client, children: _jsx(ThemeProvider, { defaultTheme: defaultTheme, storageKey: themeStorageKey, children: _jsx(LocaleProvider, { defaultLocale: defaultLocale, defaultTimeZone: defaultTimeZone, localeStorageKey: localeStorageKey, timeZoneStorageKey: timeZoneStorageKey, supportedLocales: supportedLocales, fallbackLocale: fallbackLocale, children: children }) }) }));
+}

package/dist/providers/locale-preferences.d.ts

@@ -0,0 +1,12 @@
+export interface AdminLocalePreferenceSource {
+    locale?: string | null;
+    timeZone?: string | null;
+    timezone?: string | null;
+}
+export interface AdminLocalePreferenceSyncProps {
+    source: AdminLocalePreferenceSource | null | undefined;
+    localeStorageKey?: string | null;
+    timeZoneStorageKey?: string | null;
+}
+export declare function AdminLocalePreferenceSync({ source, localeStorageKey, timeZoneStorageKey, }: AdminLocalePreferenceSyncProps): null;
+//# sourceMappingURL=locale-preferences.d.ts.map

package/dist/providers/locale-preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-preferences.d.ts","sourceRoot":"","sources":["../../src/providers/locale-preferences.tsx"],"names":[],"mappings":"AAMA,MAAM,WAAW,2BAA2B;IAC1C,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,2BAA2B,GAAG,IAAI,GAAG,SAAS,CAAA;IACtD,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC;AAED,wBAAgB,yBAAyB,CAAC,EACxC,MAAM,EACN,gBAAiC,EACjC,kBAAqC,GACtC,EAAE,8BAA8B,QAoChC"}

package/dist/providers/locale-preferences.js

@@ -0,0 +1,32 @@
+"use client";
+import { useEffect } from "react";
+import { useLocale } from "./locale.js";
+export function AdminLocalePreferenceSync({ source, localeStorageKey = "admin-locale", timeZoneStorageKey = "admin-timezone", }) {
+    const { locale, setLocale, setTimeZone, timeZone } = useLocale();
+    const preferredTimeZone = source?.timeZone ?? source?.timezone ?? null;
+    useEffect(() => {
+        if (!source || typeof window === "undefined") {
+            return;
+        }
+        if (source.locale &&
+            source.locale !== locale &&
+            (!localeStorageKey || !window.localStorage.getItem(localeStorageKey))) {
+            setLocale(source.locale);
+        }
+        if (preferredTimeZone &&
+            preferredTimeZone !== timeZone &&
+            (!timeZoneStorageKey || !window.localStorage.getItem(timeZoneStorageKey))) {
+            setTimeZone(preferredTimeZone);
+        }
+    }, [
+        locale,
+        localeStorageKey,
+        preferredTimeZone,
+        setLocale,
+        setTimeZone,
+        source,
+        timeZone,
+        timeZoneStorageKey,
+    ]);
+    return null;
+}

package/dist/providers/locale.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+export declare const DEFAULT_ADMIN_LOCALES: readonly ["en", "ro"];
+export declare const DEFAULT_ADMIN_LOCALE = "en";
+export interface LocaleContextValue {
+    locale: string;
+    resolvedLocale: string;
+    setLocale: (locale: string) => void;
+    timeZone: string | null;
+    setTimeZone: (timeZone: string | null) => void;
+}
+export interface LocaleProviderProps {
+    children: ReactNode;
+    defaultLocale?: string;
+    defaultTimeZone?: string | null;
+    localeStorageKey?: string | null;
+    timeZoneStorageKey?: string | null;
+    supportedLocales?: readonly string[];
+    fallbackLocale?: string;
+}
+export declare function LocaleProvider({ children, defaultLocale, defaultTimeZone, localeStorageKey, timeZoneStorageKey, supportedLocales, fallbackLocale, }: LocaleProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useLocale(): LocaleContextValue;
+export declare function resolveAdminLocale(locale: string | null | undefined, supportedLocales?: readonly string[], fallbackLocale?: string): string;
+//# sourceMappingURL=locale.d.ts.map

package/dist/providers/locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/providers/locale.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,OAAO,CAAA;AAEd,eAAO,MAAM,qBAAqB,uBAAwB,CAAA;AAC1D,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;CAC/C;AA6CD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,SAAS,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,aAAa,EACb,eAAsB,EACtB,gBAAiC,EACjC,kBAAqC,EACrC,gBAAwC,EACxC,cAAqC,GACtC,EAAE,mBAAmB,2CAgFrB;AAED,wBAAgB,SAAS,IAAI,kBAAkB,CAO9C;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,gBAAgB,GAAE,SAAS,MAAM,EAA0B,EAC3D,cAAc,SAAuB,GACpC,MAAM,CAER"}

package/dist/providers/locale.js

@@ -0,0 +1,98 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from "react";
+export const DEFAULT_ADMIN_LOCALES = ["en", "ro"];
+export const DEFAULT_ADMIN_LOCALE = "en";
+const LocaleContext = createContext(undefined);
+function pickSupportedLocale(locale, supportedLocales, fallbackLocale) {
+    if (!locale) {
+        return fallbackLocale;
+    }
+    const normalized = locale.trim().toLowerCase();
+    if (!normalized) {
+        return fallbackLocale;
+    }
+    const directMatch = supportedLocales.find((candidate) => candidate.toLowerCase() === normalized);
+    if (directMatch) {
+        return directMatch;
+    }
+    const languageMatch = supportedLocales.find((candidate) => candidate.toLowerCase() === normalized.split("-")[0]);
+    return languageMatch ?? fallbackLocale;
+}
+function readStoredValue(storageKey) {
+    if (typeof window === "undefined" || storageKey === null) {
+        return null;
+    }
+    return window.localStorage.getItem(storageKey);
+}
+function getBrowserLocale() {
+    if (typeof navigator === "undefined") {
+        return null;
+    }
+    return navigator.language ?? null;
+}
+export function LocaleProvider({ children, defaultLocale, defaultTimeZone = null, localeStorageKey = "admin-locale", timeZoneStorageKey = "admin-timezone", supportedLocales = DEFAULT_ADMIN_LOCALES, fallbackLocale = DEFAULT_ADMIN_LOCALE, }) {
+    const [locale, setLocaleState] = useState(() => {
+        const storedLocale = readStoredValue(localeStorageKey);
+        if (storedLocale) {
+            return storedLocale;
+        }
+        if (defaultLocale) {
+            return defaultLocale;
+        }
+        const browserLocale = getBrowserLocale();
+        return browserLocale ?? fallbackLocale;
+    });
+    const [timeZone, setTimeZoneState] = useState(() => {
+        const storedTimeZone = readStoredValue(timeZoneStorageKey);
+        if (storedTimeZone) {
+            return storedTimeZone;
+        }
+        if (defaultTimeZone !== undefined) {
+            return defaultTimeZone;
+        }
+        return Intl.DateTimeFormat().resolvedOptions().timeZone ?? null;
+    });
+    const resolvedLocale = useMemo(() => pickSupportedLocale(locale, supportedLocales, fallbackLocale), [fallbackLocale, locale, supportedLocales]);
+    const setLocale = useCallback((nextLocale) => {
+        setLocaleState(nextLocale);
+        if (typeof window !== "undefined" && localeStorageKey !== null) {
+            window.localStorage.setItem(localeStorageKey, nextLocale);
+        }
+    }, [localeStorageKey]);
+    const setTimeZone = useCallback((nextTimeZone) => {
+        setTimeZoneState(nextTimeZone);
+        if (typeof window === "undefined" || timeZoneStorageKey === null) {
+            return;
+        }
+        if (nextTimeZone) {
+            window.localStorage.setItem(timeZoneStorageKey, nextTimeZone);
+        }
+        else {
+            window.localStorage.removeItem(timeZoneStorageKey);
+        }
+    }, [timeZoneStorageKey]);
+    useEffect(() => {
+        if (typeof document === "undefined") {
+            return;
+        }
+        document.documentElement.lang = resolvedLocale;
+    }, [resolvedLocale]);
+    return (_jsx(LocaleContext.Provider, { value: {
+            locale,
+            resolvedLocale,
+            setLocale,
+            timeZone,
+            setTimeZone,
+        }, children: children }));
+}
+export function useLocale() {
+    const context = useContext(LocaleContext);
+    if (!context) {
+        throw new Error("useLocale must be used within <LocaleProvider>");
+    }
+    return context;
+}
+export function resolveAdminLocale(locale, supportedLocales = DEFAULT_ADMIN_LOCALES, fallbackLocale = DEFAULT_ADMIN_LOCALE) {
+    return pickSupportedLocale(locale, supportedLocales, fallbackLocale);
+}