@kanzo-tech/ui 0.0.1-alpha

package/dist/table/use-data-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table.js","sources":["../../src/table/use-data-table.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  type ColumnDef,\n  type ColumnFiltersState,\n  type OnChangeFn,\n  type PaginationState,\n  type Row,\n  type RowData,\n  type RowSelectionState,\n  type SortingState,\n  type Table,\n  type TableOptions,\n  type VisibilityState,\n  getCoreRowModel,\n  getFacetedRowModel,\n  getFacetedUniqueValues,\n  getFilteredRowModel,\n  getPaginationRowModel,\n  getSortedRowModel,\n  useReactTable,\n} from \"@tanstack/react-table\";\nimport { type Dispatch, type SetStateAction, useState } from \"react\";\n\n// TanStack ships `ColumnMeta` empty for consumers to augment. `label` is the human name of a\n// column whose `header` is a component (a `sortableHeader`), so `DataTableViewOptions` can list it\n// as something other than its raw id.\ndeclare module \"@tanstack/react-table\" {\n  // The two parameters are TanStack's own signature; an augmentation has to repeat it verbatim\n  // even though this field uses neither.\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  interface ColumnMeta<TData extends RowData, TValue> {\n    label?: string;\n  }\n}\n\nexport interface UseDataTableOptions<TData, TValue = unknown>\n  extends Omit<Partial<TableOptions<TData>>, \"columns\" | \"data\"> {\n  columns: ColumnDef<TData, TValue>[];\n  data: TData[];\n  initialColumnFilters?: ColumnFiltersState;\n  initialColumnVisibility?: VisibilityState;\n  initialGlobalFilter?: string;\n  /** Zero-based first page, for deep-linking into a table. Default 0. */\n  initialPage?: number;\n  initialRowSelection?: RowSelectionState;\n  initialSorting?: SortingState;\n  /** Rows per page. Default 20. */\n  pageSize?: number;\n}\n\n/** Feeds our own state and, when the caller supplied one, its `onXChange` too. */\nfunction chain<T>(set: Dispatch<SetStateAction<T>>, next?: OnChangeFn<T>): OnChangeFn<T> {\n  return (updater) => {\n    set(updater);\n    next?.(updater);\n  };\n}\n\n/**\n * `useReactTable` with every row model wired, the filter/sort/visibility/selection slices\n * held as state, and everything else passed straight through — including `manualPagination`\n * / `manualSorting` / `manualFiltering` + `rowCount` for server-driven tables, where the\n * matching row model steps aside on its own.\n *\n * Every slice lives in `useState` and is never derived during render. That is load-bearing,\n * not style: handing TanStack a fresh `columnFilters` array on each render makes the\n * filtered row model always look stale, recomputing it trips `autoReset*`, which resets the\n * page index → re-render → new identity → an infinite loop that hard-freezes the tab. React\n * never reports it, because the cycle runs through the table's own `onStateChange` rather\n * than a setState during render, so there is no \"maximum update depth\" error to catch.\n */\nexport function useDataTable<TData, TValue = unknown>(\n  options: UseDataTableOptions<TData, TValue>,\n): Table<TData> {\n  const {\n    columns,\n    data,\n    initialColumnFilters = [],\n    initialColumnVisibility = {},\n    initialGlobalFilter = \"\",\n    initialPage = 0,\n    initialRowSelection = {},\n    initialSorting = [],\n    onColumnFiltersChange,\n    onColumnVisibilityChange,\n    onGlobalFilterChange,\n    onPaginationChange,\n    onRowSelectionChange,\n    onSortingChange,\n    pageSize = 20,\n    state: stateOverride,\n    ...rest\n  } = options;\n\n  const [sorting, setSorting] = useState<SortingState>(initialSorting);\n  const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>(initialColumnFilters);\n  const [columnVisibility, setColumnVisibility] =\n    useState<VisibilityState>(initialColumnVisibility);\n  const [rowSelection, setRowSelection] = useState<RowSelectionState>(initialRowSelection);\n  const [globalFilter, setGlobalFilter] = useState<string>(initialGlobalFilter);\n  const [pagination, setPagination] = useState<PaginationState>({ pageIndex: initialPage, pageSize });\n\n  return useReactTable({\n    getCoreRowModel: getCoreRowModel(),\n    getFacetedRowModel: getFacetedRowModel(),\n    getFacetedUniqueValues: getFacetedUniqueValues(),\n    getFilteredRowModel: getFilteredRowModel(),\n    getPaginationRowModel: getPaginationRowModel(),\n    getSortedRowModel: getSortedRowModel(),\n    ...rest,\n    columns,\n    data,\n    onColumnFiltersChange: chain(setColumnFilters, onColumnFiltersChange),\n    onColumnVisibilityChange: chain(setColumnVisibility, onColumnVisibilityChange),\n    onGlobalFilterChange: chain(setGlobalFilter, onGlobalFilterChange),\n    onPaginationChange: chain(setPagination, onPaginationChange),\n    onRowSelectionChange: chain(setRowSelection, onRowSelectionChange),\n    onSortingChange: chain(setSorting, onSortingChange),\n    state: {\n      columnFilters,\n      columnVisibility,\n      globalFilter,\n      pagination,\n      rowSelection,\n      sorting,\n      ...stateOverride,\n    },\n  });\n}\n\n/**\n * Column `filterFn` for `DataTableFacetFilter`: keeps rows whose value is one of the\n * selected facets. TanStack's built-in `arrIncludesSome` expects the *cell* to be the\n * array, and on a scalar cell degrades to substring matching (\"inactive\" matches \"active\").\n */\nexport function facetFilterFn<TData>(\n  row: Row<TData>,\n  columnId: string,\n  filterValue: unknown,\n): boolean {\n  if (!Array.isArray(filterValue) || filterValue.length === 0) return true;\n  const value = String(row.getValue(columnId));\n  return filterValue.some((candidate) => String(candidate) === value);\n}\n"],"names":[],"mappings":";;;AAoDA;AACE;AACE;AACO;AAEX;AAeO;AAGL;AAAM;AACJ;AACA;AACuB;AACG;AACJ;AACR;AACQ;AACL;AACjB;AACA;AACA;AACA;AACA;AACA;AACW;AACJ;AACJ;AAWL;AAAqB;AACF;AACG;AACI;AACH;AACE;AACJ;AAChB;AACH;AACA;AACoE;AACS;AACZ;AACN;AACM;AACf;AAC3C;AACL;AACA;AACA;AACA;AACA;AACA;AACG;AAAA;AAGT;AAOO;AAKL;AACA;AACA;AACF;;;;;"}

package/dist/table.d.ts

@@ -0,0 +1,15 @@
+export { useDataTable, facetFilterFn } from './table/use-data-table.js';
+export type { UseDataTableOptions } from './table/use-data-table.js';
+export { DataTableRoot, useDataTableContext } from './table/data-table-root.js';
+export type { DataTableRootProps } from './table/data-table-root.js';
+export { DataTableToolbar, DataTableSearch, DataTableFacetFilter, DataTableViewOptions, } from './table/data-table-toolbar.js';
+export type { DataTableSearchProps, DataTableFacetOption, DataTableFacetFilterProps, DataTableViewOptionsProps, } from './table/data-table-toolbar.js';
+export { DataTableContent } from './table/data-table-content.js';
+export type { DataTableContentProps } from './table/data-table-content.js';
+export { DataTablePagination } from './table/data-table-pagination.js';
+export type { DataTablePaginationProps } from './table/data-table-pagination.js';
+export { selectColumn } from './table/select-column.js';
+export type { SelectColumnOptions } from './table/select-column.js';
+export { sortableHeader } from './table/sortableHeader.js';
+export type { CellContext, ColumnDef, HeaderContext, Row, Table, } from '@tanstack/react-table';
+//# sourceMappingURL=table.d.ts.map

package/dist/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../src/table.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACxE,YAAY,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAChF,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,oBAAoB,EACpB,oBAAoB,EACpB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,YAAY,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,YAAY,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAIpE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAK3D,YAAY,EACV,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,GAClD,MAAM,uBAAuB,CAAC"}

package/dist/table.js

@@ -0,0 +1,22 @@
+import { facetFilterFn as t, useDataTable as o } from "./table/use-data-table.js";
+import { DataTableRoot as l, useDataTableContext as b } from "./table/data-table-root.js";
+import { DataTableFacetFilter as D, DataTableSearch as f, DataTableToolbar as m, DataTableViewOptions as n } from "./table/data-table-toolbar.js";
+import { DataTableContent as x } from "./table/data-table-content.js";
+import { DataTablePagination as s } from "./table/data-table-pagination.js";
+import { selectColumn as F } from "./table/select-column.js";
+import { sortableHeader as C } from "./table/sortableHeader.js";
+export {
+  x as DataTableContent,
+  D as DataTableFacetFilter,
+  s as DataTablePagination,
+  l as DataTableRoot,
+  f as DataTableSearch,
+  m as DataTableToolbar,
+  n as DataTableViewOptions,
+  t as facetFilterFn,
+  F as selectColumn,
+  C as sortableHeader,
+  o as useDataTable,
+  b as useDataTableContext
+};
+//# sourceMappingURL=table.js.map

package/dist/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/theme/KanzoTheme.d.ts

@@ -0,0 +1,74 @@
+import { Appearance } from '@kanzo-tech/theme';
+import * as React from "react";
+/**
+ * A theme scoped to a subtree — Radix Themes' nested `<Theme>`, and daisyUI's nestable `data-theme`.
+ *
+ * The same attributes {@link KanzoThemeProvider} writes to `<html>`, written to a `<div>` instead,
+ * so one page can paint two palettes at once. It became possible when a document stopped being a
+ * stylesheet the server serves: `compile(doc, { scope })` emits a two-member selector list whose
+ * unqualified member exists precisely so it can match an element that is not `<html>`.
+ *
+ * ```tsx
+ * {palettes.map((p) => (
+ *   <KanzoTheme key={p.id} palette={p.id}>
+ *     <PaletteCard />
+ *   </KanzoTheme>
+ * ))}
+ * ```
+ *
+ * ## What this is for, and what it is not for
+ *
+ * **Previews.** A palette picker showing five documents side by side, a docs page demonstrating a
+ * brand, an onboarding screen putting a client's colours next to the default.
+ *
+ * **Not the chrome of an app.** Ark's overlays — Dialog, Popover, Menu, Select, Tooltip, Toast —
+ * portal to `document.body`, which is outside any wrapper, so they inherit `<html>`'s theme and not
+ * this one. A Select inside a scoped preview opens its listbox in the *page's* palette. That is not
+ * a bug to be fixed here — it is why `KanzoThemeProvider` writes to `document.documentElement` in
+ * the first place — and `KanzoTheme.test.tsx` asserts it, so the limit stays written down rather
+ * than rediscovered by whoever ships the first scoped dropdown.
+ *
+ * ## `appearance` works in both directions
+ *
+ * A first version of this component refused the prop, because forcing *light* inside a dark page was
+ * impossible: `compile` emitted `.dark [data-palette="x"]` as a descendant, so a scope carrying
+ * `.light` tied with it at (0,2,0) and lost or won on emit order. Offering a prop that worked one way
+ * only — with the failing direction looking exactly like the working one — was worse than offering
+ * none.
+ *
+ * The fix was in `compile`, not here: appearance is now a class on the element that carries the
+ * theme, never on an ancestor, which is what Radix Themes does and what makes every case resolve on
+ * specificity with no pair tied. So the prop exists, and both directions are asserted.
+ *
+ * **The class is always written**, not only when the prop is given: a scope that named a palette but
+ * left the side to inheritance would match the light block on a dark page — an island of light
+ * Dracula nobody asked for. Absent a prop it is the appearance the context reports, so a scope
+ * follows the page unless told otherwise.
+ *
+ * ## What it inherits
+ *
+ * Everything not named. A scope that gives only `palette` keeps the surrounding radius, fonts and
+ * density: the attributes for axes it does not override are not written at all, so the cascade
+ * reaches whatever `<html>` carries.
+ *
+ * `set` is **not** re-pointed: a control rendered inside a scope still edits the real preferences. A
+ * preview has no controls in it, and a scope that silently swallowed writes would be a worse
+ * surprise than one that does not.
+ */
+export interface KanzoThemeProps extends React.ComponentPropsWithoutRef<"div"> {
+    /** Which published theme paints this subtree. Omit to inherit. */
+    theme?: string;
+    /**
+     * Which side paints here — a *side*, never `null`.
+     *
+     * There is no "ask the OS" at this level and its absence is deliberate: the OS question is answered
+     * once, by the provider, and a scope either pins a side or follows the answer.
+     */
+    appearance?: Appearance;
+    radius?: string;
+    font?: string;
+    monoFont?: string;
+    density?: string;
+}
+export declare function KanzoTheme({ theme, appearance, radius, font, monoFont, density, children, className, ...rest }: KanzoThemeProps): React.JSX.Element;
+//# sourceMappingURL=KanzoTheme.d.ts.map

package/dist/theme/KanzoTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KanzoTheme.d.ts","sourceRoot":"","sources":["../../src/theme/KanzoTheme.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAMpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,WAAW,eAAgB,SAAQ,KAAK,CAAC,wBAAwB,CAAC,KAAK,CAAC;IAC5E,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAWD,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,UAAU,EACV,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,SAAS,EACT,GAAG,IAAI,EACR,EAAE,eAAe,qBAmEjB"}

package/dist/theme/KanzoTheme.js

@@ -0,0 +1,61 @@
+"use client";
+import { jsx as f } from "react/jsx-runtime";
+import * as u from "react";
+import { AXES as y } from "@kanzo-tech/theme";
+import { useKanzoThemeOptional as z, ThemeContext as B } from "./theme-context.js";
+const b = y.filter(({ attr: o }) => !!o);
+function K({
+  theme: o,
+  appearance: a,
+  radius: c,
+  font: l,
+  monoFont: p,
+  density: i,
+  children: A,
+  className: h,
+  ...T
+}) {
+  const e = z(), r = a ?? (e == null ? void 0 : e.resolvedAppearance), n = u.useMemo(
+    () => ({
+      // A scope names ONE theme for its whole subtree, so both sides carry it: the axis is keyed
+      // by appearance because a *user* may want a different theme by day and by night, and a
+      // preview forcing one is not that user making a choice. `{}` when the prop is absent, which
+      // is what "inherit the page's" spells one level up.
+      themeByAppearance: o ? { light: o, dark: o } : {},
+      radius: c,
+      font: l,
+      monoFont: p,
+      density: i
+    }),
+    [o, c, l, p, i]
+  ), m = {};
+  for (const { attr: x, byAppearance: g, key: k } of b) {
+    const t = n[k], s = g ? t == null ? void 0 : t[r ?? "light"] : t;
+    typeof s == "string" && s !== "" && (m[x] = s);
+  }
+  const v = u.useMemo(() => e ? {
+    ...e,
+    ...n,
+    appearance: a ?? e.appearance,
+    resolvedAppearance: r ?? e.resolvedAppearance,
+    // A scope reports what it PAINTS, and this is the line that matters most: `useThemeTick` reads
+    // `resolvedTheme` during render, so a chart inside a scoped preview re-resolves its colours
+    // against the scope. Without it the chart would hold the page's theme in its buffers and
+    // quietly paint the wrong brand — the same defect a swapped stylesheet caused before.
+    resolvedTheme: o || e.resolvedTheme
+  } : null, [e, n, o, a, r]), d = /* @__PURE__ */ f(
+    "div",
+    {
+      ...T,
+      ...m,
+      className: [h, r].filter(Boolean).join(" ") || void 0,
+      "data-slot": "kanzo-theme",
+      children: A
+    }
+  );
+  return v ? /* @__PURE__ */ f(B.Provider, { value: v, children: d }) : d;
+}
+export {
+  K as KanzoTheme
+};
+//# sourceMappingURL=KanzoTheme.js.map

package/dist/theme/KanzoTheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KanzoTheme.js","sources":["../../src/theme/KanzoTheme.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport type { Appearance } from \"@kanzo-tech/theme\";\n// Straight from the theme package: `prefs-config.ts` was a re-export of exactly this and\n// nothing else, and it went the way shims go here.\nimport { AXES, type ThemePrefs } from \"@kanzo-tech/theme\";\nimport { ThemeContext, useKanzoThemeOptional, type ThemeContextValue } from \"./theme-context.js\";\n\n/**\n * A theme scoped to a subtree — Radix Themes' nested `<Theme>`, and daisyUI's nestable `data-theme`.\n *\n * The same attributes {@link KanzoThemeProvider} writes to `<html>`, written to a `<div>` instead,\n * so one page can paint two palettes at once. It became possible when a document stopped being a\n * stylesheet the server serves: `compile(doc, { scope })` emits a two-member selector list whose\n * unqualified member exists precisely so it can match an element that is not `<html>`.\n *\n * ```tsx\n * {palettes.map((p) => (\n *   <KanzoTheme key={p.id} palette={p.id}>\n *     <PaletteCard />\n *   </KanzoTheme>\n * ))}\n * ```\n *\n * ## What this is for, and what it is not for\n *\n * **Previews.** A palette picker showing five documents side by side, a docs page demonstrating a\n * brand, an onboarding screen putting a client's colours next to the default.\n *\n * **Not the chrome of an app.** Ark's overlays — Dialog, Popover, Menu, Select, Tooltip, Toast —\n * portal to `document.body`, which is outside any wrapper, so they inherit `<html>`'s theme and not\n * this one. A Select inside a scoped preview opens its listbox in the *page's* palette. That is not\n * a bug to be fixed here — it is why `KanzoThemeProvider` writes to `document.documentElement` in\n * the first place — and `KanzoTheme.test.tsx` asserts it, so the limit stays written down rather\n * than rediscovered by whoever ships the first scoped dropdown.\n *\n * ## `appearance` works in both directions\n *\n * A first version of this component refused the prop, because forcing *light* inside a dark page was\n * impossible: `compile` emitted `.dark [data-palette=\"x\"]` as a descendant, so a scope carrying\n * `.light` tied with it at (0,2,0) and lost or won on emit order. Offering a prop that worked one way\n * only — with the failing direction looking exactly like the working one — was worse than offering\n * none.\n *\n * The fix was in `compile`, not here: appearance is now a class on the element that carries the\n * theme, never on an ancestor, which is what Radix Themes does and what makes every case resolve on\n * specificity with no pair tied. So the prop exists, and both directions are asserted.\n *\n * **The class is always written**, not only when the prop is given: a scope that named a palette but\n * left the side to inheritance would match the light block on a dark page — an island of light\n * Dracula nobody asked for. Absent a prop it is the appearance the context reports, so a scope\n * follows the page unless told otherwise.\n *\n * ## What it inherits\n *\n * Everything not named. A scope that gives only `palette` keeps the surrounding radius, fonts and\n * density: the attributes for axes it does not override are not written at all, so the cascade\n * reaches whatever `<html>` carries.\n *\n * `set` is **not** re-pointed: a control rendered inside a scope still edits the real preferences. A\n * preview has no controls in it, and a scope that silently swallowed writes would be a worse\n * surprise than one that does not.\n */\nexport interface KanzoThemeProps extends React.ComponentPropsWithoutRef<\"div\"> {\n  /** Which published theme paints this subtree. Omit to inherit. */\n  theme?: string;\n  /**\n   * Which side paints here — a *side*, never `null`.\n   *\n   * There is no \"ask the OS\" at this level and its absence is deliberate: the OS question is answered\n   * once, by the provider, and a scope either pins a side or follows the answer.\n   */\n  appearance?: Appearance;\n  radius?: string;\n  font?: string;\n  monoFont?: string;\n  density?: string;\n}\n\n/**\n * The axes a scope may override.\n *\n * Read off `AXES` rather than listed here, so an axis added to the table is scopable the same day it\n * is applicable — the drift this whole table exists to prevent. `identityByPalette` is not an axis\n * (it is the memory behind one) and carries no attribute, so it never appears.\n */\nconst SCOPED = AXES.filter(({ attr }) => Boolean(attr));\n\nexport function KanzoTheme({\n  theme,\n  appearance,\n  radius,\n  font,\n  monoFont,\n  density,\n  children,\n  className,\n  ...rest\n}: KanzoThemeProps) {\n  const parent = useKanzoThemeOptional();\n  const resolvedAppearance = appearance ?? parent?.resolvedAppearance;\n\n  const overrides = React.useMemo(\n    () =>\n      ({\n        // A scope names ONE theme for its whole subtree, so both sides carry it: the axis is keyed\n        // by appearance because a *user* may want a different theme by day and by night, and a\n        // preview forcing one is not that user making a choice. `{}` when the prop is absent, which\n        // is what \"inherit the page's\" spells one level up.\n        themeByAppearance: theme ? { light: theme, dark: theme } : {},\n        radius,\n        font,\n        monoFont,\n        density,\n      }) as Partial<ThemePrefs>,\n    [theme, radius, font, monoFont, density],\n  );\n\n  // Rendered as props rather than written in an effect: a scope is declarative and has no OS to\n  // consult, so there is nothing to resolve after mount — and rendering them means the server emits\n  // them too, which is what stops a scoped preview from painting the page's palette on first paint\n  // and then correcting itself.\n  const attributes: Record<string, string> = {};\n  for (const { attr, byAppearance, key } of SCOPED) {\n    // A keyed axis holds a map, indexed by the side this scope is about to paint — the same\n    // expression the provider and the pre-hydration script run, off the same row.\n    const stored = overrides[key];\n    // `resolvedAppearance` is undefined outside a provider with no `appearance` prop — the scope\n    // paints, inherits the page's side and writes no class. Either key answers the same here,\n    // because a scope writes both, so the fallback picks one rather than inventing a side.\n    const value = byAppearance\n      ? (stored as Record<string, string> | undefined)?.[resolvedAppearance ?? \"light\"]\n      : stored;\n    if (typeof value === \"string\" && value !== \"\") attributes[attr] = value;\n  }\n\n  const ctx = React.useMemo<ThemeContextValue | null>(() => {\n    if (!parent) return null;\n    return {\n      ...parent,\n      ...overrides,\n      appearance: appearance ?? parent.appearance,\n      resolvedAppearance: resolvedAppearance ?? parent.resolvedAppearance,\n      // A scope reports what it PAINTS, and this is the line that matters most: `useThemeTick` reads\n      // `resolvedTheme` during render, so a chart inside a scoped preview re-resolves its colours\n      // against the scope. Without it the chart would hold the page's theme in its buffers and\n      // quietly paint the wrong brand — the same defect a swapped stylesheet caused before.\n      resolvedTheme: theme || parent.resolvedTheme,\n    };\n  }, [parent, overrides, theme, appearance, resolvedAppearance]);\n\n  const scoped = (\n    <div\n      {...rest}\n      {...attributes}\n      className={[className, resolvedAppearance].filter(Boolean).join(\" \") || undefined}\n      data-slot=\"kanzo-theme\"\n    >\n      {children}\n    </div>\n  );\n\n  // Outside a provider there is nothing to inherit into context — but the attributes still paint,\n  // because the cascade does not need React to work.\n  return ctx ? <ThemeContext.Provider value={ctx}>{scoped}</ThemeContext.Provider> : scoped;\n}\n"],"names":[],"mappings":";;;;;AAuFA;AAEO;AAAoB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEF;AACE;AAGwB;AAEnB;AAAA;AAAA;AAAA;AAAA;AAK4D;AAC3D;AACA;AACA;AACA;AAAA;AAEmC;AAQzC;AAGE;AAOA;AAAkE;AAGpE;AAES;AACF;AACA;AAC8B;AACgB;AAAA;AAAA;AAAA;AAAA;AAKlB;AAKjC;AAAC;AAAA;AACK;AACA;AACoE;AAC9D;AAET;AAAA;AAML;AACF;;;;"}

package/dist/theme/KanzoThemeProvider.d.ts

@@ -0,0 +1,144 @@
+import { Appearance, ThemeOption, SectionManifest, SectionPolicy, ThemePrefs } from '@kanzo-tech/theme';
+import { FontOption } from './theme-context.js';
+import * as React from "react";
+export { useKanzoTheme, useKanzoThemeOptional, type FontOption, type ThemeContextValue, } from './theme-context.js';
+export type { ThemePrefs } from '@kanzo-tech/theme';
+/**
+ * KanzoThemeProvider — owns the runtime theme PREFERENCES and applies them as `data-*`
+ * attributes on `<html>`. It exposes the state via {@link useKanzoTheme} so a `Preferences`
+ * selector drives the whole app live.
+ *
+ * It is framework-agnostic and works in two modes:
+ * · **Controlled** — pass `value` + `onChange` (e.g. keasy bridges its server-persisted prefs).
+ * · **Uncontrolled** — internal state persisted via a pluggable `storage` (default localStorage).
+ *
+ * **Colour is not a free preference.** A tenant's identity is a palette DOCUMENT, compiled to one
+ * stylesheet the server inlines. Nothing here writes a colour VALUE: the six preferences are the
+ * four non-colour axes, `appearance` (which of the document's two blocks applies) and `identity`
+ * (which of the blocks the TENANT published applies). A user who has never been given a second
+ * identity has the same five preferences they had before, and the same `<html>`.
+ *
+ * `.dark` therefore follows the PREFERENCE directly. It used to be derived from the applied
+ * palette, so a partnerless palette could overrule the user; a document carries both modes, so
+ * there is nothing left to contradict them. A host theme manager may supply the preference (see
+ * {@link AppearanceController}) — if it also writes the class (next-themes with
+ * `attribute: "class"`) it must be disabled, or the two fight over the same class.
+ *
+ * Attributes are written to `document.documentElement` (NOT a wrapper `<div>`): Ark overlays
+ * (Dialog, Popover, Menu, Select, Tooltip…) portal to `document.body`, OUTSIDE any wrapper, so
+ * the tokens must live on `<html>` for portaled surfaces to inherit them.
+ */
+/**
+ * A host theme manager (next-themes) as the source of the appearance PREFERENCE.
+ *
+ * A host that also writes `.dark` must be turned off (`RootProvider theme={{ enabled: false }}`
+ * in fumadocs, `enableColorScheme: false` + no `attribute: "class"` elsewhere), or two owners
+ * write the same class. What the controller provides is the preference and the OS resolution,
+ * which is all this provider reads from it. Shape matches next-themes.
+ */
+export interface AppearanceController {
+    /**
+     * The host's preference, in the HOST's vocabulary; next-themes exposes this as `theme`.
+     *
+     * `string`, not `Appearance`, because this is where a foreign model enters. next-themes' third
+     * value is the string `"system"`, ours is `""`, and the translation happens once, below — no
+     * other line in this package knows that `"system"` is a word.
+     */
+    theme?: string;
+    /** The applied value (`light` | `dark`), already resolved against the OS by the host. */
+    resolvedTheme?: string;
+    setTheme: (theme: string) => void;
+}
+/** Pluggable persistence for the uncontrolled mode. */
+export interface ThemeStorage {
+    get: () => Partial<ThemePrefs> | null;
+    /** What the user chose — sparse. A key is absent because nobody has written it. */
+    set: (prefs: Partial<ThemePrefs>) => void;
+}
+/**
+ * Cookie-backed persistence — use this in SSR apps so the SAME source the {@link themeScript}
+ * reads before hydration is also written by the client, and the server can read it from the
+ * request `Cookie` header to render the correct theme. Pair with `themeScript({ storageKey })`.
+ */
+export declare const cookieStorageAdapter: (key?: string, { maxAgeDays, path, sameSite }?: {
+    maxAgeDays?: number | undefined;
+    path?: string | undefined;
+    sameSite?: "Lax" | undefined;
+}) => ThemeStorage;
+export interface KanzoThemeProviderProps {
+    children: React.ReactNode;
+    /** Override the built-in defaults (unpinned / md / system / system / default / the document's). */
+    defaults?: Partial<ThemePrefs>;
+    /** Controlled mode: supply value + onChange (host owns persistence). */
+    value?: Partial<ThemePrefs>;
+    onChange?: (next: Partial<ThemePrefs>) => void;
+    /** Uncontrolled persistence. `undefined` = localStorage; `null` = no persistence. */
+    storage?: ThemeStorage | null;
+    storageKey?: string;
+    /** Host-configurable option lists surfaced by the Preferences panel. */
+    fonts?: FontOption[];
+    monoFonts?: FontOption[];
+    /**
+     * The themes the TENANT published. Usually `themeIndex` from `@kanzo-tech/theme`, or a tenant's
+     * own list mapped on the server.
+     *
+     * **Wiring this applies it.** A theme is a flat block of CSS that travels in the page under its
+     * own `[data-theme]`, so this provider writes the attribute like any other axis. A host still has
+     * to *load* the themes — import the sheets, or inline them — but it never chooses one per request,
+     * and a user switching theme never needs a round trip.
+     *
+     * **It is one prop where there were two.** `palettes` carried documents and each document carried
+     * its brands as `children`, so a host published a tree and the panel flattened it. A brand is a
+     * theme, so the tree is a list.
+     */
+    themes?: ThemeOption[];
+    /**
+     * The name applied when the preference is empty. Defaults to the first published one.
+     *
+     * **A pair, when the two sides differ.** A theme carries its own light or dark palette, so one
+     * name cannot answer for both sides: naming a night theme here paints it in daylight too, with
+     * `.dark` off. Pass `{ light, dark }` to say which theme each side defers to — the same shape the
+     * preference already stores, and the same reason it is a map there.
+     */
+    defaultTheme?: string | Partial<Record<Appearance, string>>;
+    /** Called once, at most, when the stored theme is no longer published — somebody chose gold and is
+     *  about to be looking at blue, and silence makes that read as a bug in our product rather than a
+     *  change in their client's. The provider renders no notice itself; say it where the app says
+     *  things. */
+    onThemeRetired?: (theme: string) => void;
+    /**
+     * The section manifests of the packages this host installed.
+     *
+     * **The host registers, and that is what keeps the one-way door shut.** Nothing in
+     * `@kanzo-tech/theme` or in this file names an optional package, so the arrow points host → core:
+     * a host that never installed the graph literally cannot pass its manifest, and
+     * `packages/theme/src/boundary.test.ts` keeps passing because there is nothing to import.
+     * Registration by import into the core would be the same mechanism with the dependency inverted.
+     */
+    sections?: SectionManifest[];
+    /**
+     * What the TENANT says about every choice — pinned, withheld, or merely started elsewhere.
+     *
+     * Keyed by namespace, and **the core is the namespace `theme`** ({@link CORE_NAMESPACE}):
+     *
+     * ```ts
+     * policy={{ theme: { density: { default: "compact" }, radius: { pinned: "sm" } },
+     *           graph: { look: { hidden: true } } }}
+     * ```
+     *
+     * This is the white-label half, and it used to reach only half the product: a tenant could pin the
+     * graph's look and could not pin the radius, because the newer mechanism had a resolution chain
+     * and the older one had a whitelist read. Now a client ships *our product is compact and square*
+     * as the starting point their users move from — which is daisyUI's theme-carries-the-geometry,
+     * expressed as a policy over declarations rather than as a second document format.
+     *
+     * It selects among the options a declaration published; it cannot author one. That line is the
+     * same one the colour layer holds, and it is why this is not the retired runtime palette coming
+     * back under a new name.
+     */
+    policy?: Record<string, SectionPolicy>;
+    /** Delegate dark to a host theme manager (e.g. next-themes). Omit to use the built-in fallback. */
+    appearance?: AppearanceController;
+}
+export declare function KanzoThemeProvider({ children, defaults, value, onChange, storage, storageKey, fonts, monoFonts, themes, defaultTheme, onThemeRetired, sections, policy, appearance, }: KanzoThemeProviderProps): React.JSX.Element;
+//# sourceMappingURL=KanzoThemeProvider.d.ts.map

package/dist/theme/KanzoThemeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KanzoThemeProvider.d.ts","sourceRoot":"","sources":["../../src/theme/KanzoThemeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EACV,UAAU,EAGV,WAAW,EAGX,eAAe,EACf,aAAa,EAGd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EASL,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAgB,KAAK,UAAU,EAA0B,MAAM,oBAAoB,CAAC;AAE3F,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,KAAK,UAAU,EACf,KAAK,iBAAiB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yFAAyF;IACzF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,uDAAuD;AACvD,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IACtC,mFAAmF;IACnF,GAAG,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;CAC3C;AAqBD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAK,MAAoB,EACzB;;;;CAAgE,KAC/D,YAmBD,CAAC;AA6FH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,mGAAmG;IACnG,QAAQ,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IAC/C,qFAAqF;IACrF,OAAO,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC;IACzB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5D;;;kBAGc;IACd,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvC,mGAAmG;IACnG,UAAU,CAAC,EAAE,oBAAoB,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,UAAwB,EACxB,KAAqB,EACrB,SAA8B,EAC9B,MAAkB,EAIlB,YAAqC,EACrC,cAAc,EACd,QAAsB,EACtB,MAAkB,EAClB,UAAU,GACX,EAAE,uBAAuB,qBAoazB"}

package/dist/theme/KanzoThemeProvider.js

@@ -0,0 +1,271 @@
+"use client";
+import { jsx as ne } from "react/jsx-runtime";
+import * as o from "react";
+import { STORAGE_KEY as G, DEFAULT_PREFS as H, CORE_NAMESPACE as se, CORE_PREFS as P, resolvePref as D, AXES as U, themeData as X, prefOptions as ce } from "@kanzo-tech/theme";
+import { ThemeContext as re } from "./theme-context.js";
+import { useKanzoTheme as Te, useKanzoThemeOptional as Pe } from "./theme-context.js";
+const ue = (r) => ({
+  get: () => {
+    if (typeof localStorage > "u") return null;
+    try {
+      const n = localStorage.getItem(r);
+      return n ? JSON.parse(n) : null;
+    } catch {
+      return null;
+    }
+  },
+  set: (n) => {
+    try {
+      localStorage.setItem(r, JSON.stringify(n));
+    } catch {
+    }
+  }
+}), ke = (r = G, { maxAgeDays: n = 365, path: u = "/", sameSite: f = "Lax" } = {}) => ({
+  get: () => {
+    if (typeof document > "u") return null;
+    try {
+      const a = document.cookie.match(new RegExp("(?:^|; )" + r + "=([^;]*)"));
+      return a != null && a[1] ? JSON.parse(decodeURIComponent(a[1])) : null;
+    } catch {
+      return null;
+    }
+  },
+  set: (a) => {
+    if (!(typeof document > "u"))
+      try {
+        const y = encodeURIComponent(JSON.stringify(a));
+        document.cookie = `${r}=${y}; Max-Age=${n * 86400}; Path=${u}; SameSite=${f}`;
+      } catch {
+      }
+  }
+}), fe = Object.keys(H);
+function ie(r) {
+  const n = {};
+  for (const u of fe) r[u] !== void 0 && (n[u] = r[u]);
+  return n;
+}
+const Q = (r, n) => (ce(P[r]) ?? []).map((u) => ({
+  ...u,
+  preview: n[u.value]
+})), le = Q("font", X.fonts), me = Q("monoFont", X.monoFonts), ae = [], de = [], ve = {}, q = {}, pe = {};
+function Ee(r, n, u, f) {
+  const [a, y] = o.useState(null), A = o.useRef(!1);
+  return o.useEffect(() => {
+    A.current || !r || n.length === 0 || n.some((w) => w.value === r) || (A.current = !0, y(r), u(), f == null || f(r));
+  }, [u, r, n, f]), a;
+}
+function he({
+  children: r,
+  defaults: n,
+  value: u,
+  onChange: f,
+  storage: a,
+  storageKey: y = G,
+  fonts: A = le,
+  monoFonts: w = me,
+  themes: S = ae,
+  // The first published one. `themeIndex` carries no `isDefault`
+  // flag, but it belongs to the host's mapper: a `ThemeOption` is what a CONTROL needs, and a
+  // control has no use for which one the server would have served anyway.
+  defaultTheme: M = ((W) => (W = S[0]) == null ? void 0 : W.value)() ?? "",
+  onThemeRetired: V,
+  sections: N = de,
+  policy: _ = ve,
+  appearance: i
+}) {
+  var z;
+  const k = u !== void 0, v = o.useMemo(
+    () => a === void 0 ? ue(y) : a,
+    [a, y]
+  ), [Z, $] = o.useState(() => {
+    if (k) return { ...u };
+    const e = (v == null ? void 0 : v.get()) ?? null;
+    return e ? ie(e) : {};
+  }), d = k ? u ?? pe : Z, p = o.useMemo(
+    () => ({ ...H, ...n, ...d }),
+    [n, d]
+  ), F = o.useRef(d);
+  F.current = d;
+  const O = o.useCallback(
+    (e) => {
+      const t = { ...F.current, ...e };
+      F.current = t, k ? f == null || f(t) : ($(t), v == null || v.set(t));
+    },
+    [k, f, v]
+  ), g = o.useCallback(() => {
+    F.current = {}, k ? f == null || f({}) : ($({}), v == null || v.set({}));
+  }, [k, f, v]), R = o.useMemo(() => {
+    var c;
+    const e = _[se] ?? q;
+    if (!n) return e;
+    const t = { ...e };
+    for (const s of Object.keys(P)) {
+      const l = n[s];
+      typeof l != "string" || ((c = t[s]) == null ? void 0 : c.default) !== void 0 || (t[s] = { ...t[s], default: l });
+    }
+    return t;
+  }, [n, _]), [ee, te] = o.useState(
+    () => {
+      var e;
+      return typeof window < "u" && !!((e = window.matchMedia) != null && e.call(window, "(prefers-color-scheme: dark)").matches);
+    }
+  ), B = o.useMemo(
+    () => D(
+      P.appearance,
+      i ? i.theme ?? i.resolvedTheme : d.appearance,
+      R.appearance
+    ),
+    [i, R, d.appearance]
+  ), T = B.value;
+  o.useEffect(() => {
+    if (i || T || typeof window > "u" || !window.matchMedia) return;
+    const e = window.matchMedia("(prefers-color-scheme: dark)"), t = () => te(e.matches);
+    return t(), e.addEventListener("change", t), () => e.removeEventListener("change", t);
+  }, [i, T]);
+  const E = T || ((i == null ? void 0 : i.resolvedTheme) === "dark" || !(i != null && i.resolvedTheme) && ee ? "dark" : "light"), j = o.useCallback(
+    (e) => typeof M == "string" ? M : M[e] ?? "",
+    [M]
+  ), h = o.useMemo(() => {
+    const e = { appearance: { ...B, decl: P.appearance } };
+    for (const { key: t } of U) {
+      const c = P[t], s = d[t], l = c.byAppearance ? s == null ? void 0 : s[E] : s;
+      e[t] = { ...D(c, l, R[t]), decl: c };
+    }
+    return e;
+  }, [
+    B,
+    R,
+    E,
+    d.radius,
+    d.font,
+    d.monoFont,
+    d.density,
+    d.themeByAppearance
+  ]), C = ((z = h.themeByAppearance) == null ? void 0 : z.value) || j(E), I = o.useCallback(
+    (e, t = {}) => {
+      const c = t.appearance ?? E;
+      O({ themeByAppearance: { ...p.themeByAppearance, [c]: e } });
+    },
+    [p.themeByAppearance, E, O]
+  ), L = o.useMemo(
+    () => ({ themes: S.map(({ label: e, value: t }) => ({ label: e, value: t })) }),
+    [S]
+  ), J = Ee(
+    C,
+    S,
+    o.useCallback(() => I(""), [I]),
+    V
+  );
+  o.useEffect(() => {
+    var t;
+    const e = document.documentElement;
+    for (const { attr: c, def: s, key: l } of U) {
+      const m = (t = h[l]) == null ? void 0 : t.value;
+      m === void 0 || m === s ? e.removeAttribute(c) : e.setAttribute(c, m);
+    }
+    e.classList.toggle("dark", E === "dark");
+  }, [h, E]), o.useEffect(
+    () => () => {
+      const e = document.documentElement;
+      for (const { attr: t } of U) e.removeAttribute(t);
+    },
+    []
+  );
+  const K = o.useCallback(
+    (e) => {
+      i ? i.setTheme(e || "system") : O({ appearance: e });
+    },
+    [i, O]
+  ), x = o.useMemo(() => {
+    const e = {};
+    for (const t of N) {
+      const c = p.sections[t.namespace] ?? {}, s = _[t.namespace] ?? q, l = {};
+      for (const [m, b] of Object.entries(t.prefs ?? {}))
+        l[m] = { ...D(b, c[m], s[m], L), decl: b };
+      Object.keys(l).length > 0 && (e[t.namespace] = l);
+    }
+    return e;
+  }, [p.sections, _, N, L]), Y = o.useCallback(
+    (e, t) => {
+      const c = { ...p.sections[e] ?? {} };
+      for (const [s, l] of Object.entries(t))
+        l === void 0 ? delete c[s] : c[s] = l;
+      O({ sections: { ...p.sections, [e]: c } });
+    },
+    [p.sections, O]
+  );
+  o.useEffect(() => {
+    var c;
+    const e = document.documentElement, t = [];
+    for (const s of N)
+      for (const [l, m] of Object.entries(s.prefs ?? {})) {
+        if (!m.attr) continue;
+        t.push(m.attr);
+        const b = (c = x[s.namespace]) == null ? void 0 : c[l];
+        !b || b.value === m.default ? e.removeAttribute(m.attr) : e.setAttribute(m.attr, b.value);
+      }
+    return () => {
+      for (const s of t) e.removeAttribute(s);
+    };
+  }, [x, N]);
+  const oe = o.useMemo(
+    () => ({
+      ...p,
+      // The resolved values overwrite the stored ones, and that is the point of this phase: what a
+      // control shows and what the page is painted with are the same number. A tenant pinning
+      // `density` means every reader sees `"compact"`, while storage keeps whatever this user chose
+      // and hands it back the day the tenant stops pinning it.
+      ...Object.fromEntries(Object.entries(h).map(([e, { value: t }]) => [e, t])),
+      // …except the one that is a map. `themeByAppearance` stores a side→theme map and the chain
+      // answers for ONE side, so writing the resolved string over it would change the field's shape
+      // under every reader. `resolvedTheme` is where the answer belongs, and it is below.
+      themeByAppearance: p.themeByAppearance,
+      corePrefs: h,
+      sources: L,
+      set: O,
+      reset: g,
+      fonts: A,
+      monoFonts: w,
+      sectionPrefs: x,
+      setSectionPref: Y,
+      appearance: T,
+      resolvedAppearance: E,
+      setAppearance: K,
+      themes: S,
+      // The applied side's default. The pair is behind `defaultThemeFor`, because a panel drawing
+      // the OTHER side needs that side's answer and a single string cannot give it.
+      defaultTheme: j(E),
+      defaultThemeFor: j,
+      resolvedTheme: C,
+      setTheme: I,
+      retiredTheme: J
+    }),
+    [
+      p,
+      O,
+      A,
+      w,
+      T,
+      E,
+      K,
+      S,
+      j,
+      C,
+      I,
+      J,
+      x,
+      Y,
+      h,
+      L,
+      g
+    ]
+  );
+  return /* @__PURE__ */ ne(re.Provider, { value: oe, children: r });
+}
+export {
+  he as KanzoThemeProvider,
+  ke as cookieStorageAdapter,
+  Te as useKanzoTheme,
+  Pe as useKanzoThemeOptional
+};
+//# sourceMappingURL=KanzoThemeProvider.js.map