@cube-dev/ui-kit 0.0.0-canary-34ce1a4 → 0.0.0-canary-7dc6906

package/dist/components/data/TableBase/use-column-order.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-column-order.js","names":[],"sources":["../../../../src/components/data/TableBase/use-column-order.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { CubeResolvedColumn, CubeTableColumn } from './types';\nimport type { useTableStorage } from './use-table-storage';\n\n/**\n * Reorders the source columns to match `order`.\n *\n * Rank-based rather than filter-then-concat, because `order` is routinely\n * *stale*: it was persisted or lifted into page state before the current\n * `columns` array existed. A column missing from it inherits the rank of the\n * nearest preceding known column plus a half step, so it lands immediately after\n * the neighbour it had in the source array instead of being swept to the end. A\n * new leading column keeps its lead.\n *\n * Applied to the SOURCE array, before `useTableColumns` — so hidden-column\n * filtering, structural injection, pinned hoisting and `aria-colindex` all still\n * happen downstream, and `columnOrder` can never fight `pin`.\n */\nexport function applyColumnOrder<T>(\n  columns: CubeTableColumn<T>[],\n  order?: readonly string[],\n): CubeTableColumn<T>[] {\n  if (!order?.length) return columns;\n\n  const present = new Set(columns.map((column) => column.key));\n  const rank = new Map<string, number>();\n\n  order.forEach((key, index) => {\n    // A key for a column that no longer exists is ignored rather than treated as\n    // a gap, and a duplicate keeps its first position.\n    if (present.has(key) && !rank.has(key)) rank.set(key, index);\n  });\n\n  if (!rank.size) return columns;\n\n  let carried = -1;\n\n  return columns\n    .map((column, sourceIndex) => {\n      const own = rank.get(column.key);\n\n      if (own != null) carried = own;\n\n      return { column, sourceIndex, rank: own ?? carried + 0.5 };\n    })\n    .sort((a, b) => a.rank - b.rank || a.sourceIndex - b.sourceIndex)\n    .map((entry) => entry.column);\n}\n\n/**\n * Whether a column can be picked up and moved.\n *\n * The single shared predicate: `DataTable` builds the draggable key list from\n * it and `TableView` decides which `<th>` is a drag source from it, so the two\n * cannot drift. A renderer disagreeing with the state behind it is exactly how\n * the drop indicator that never matched its selector happened.\n *\n * Pinned columns are excluded, for three reasons that all point the same way: a\n * pinned `<th>` is `position: sticky`, so under horizontal scroll its rect sits\n * on top of columns it is nowhere near and React Aria's drop-target binary\n * search goes wrong; `use-table-columns` hoists pinned columns to the edges\n * regardless of source order, so a cross-boundary drop would be undone\n * immediately; and `pin` is already the ordering authority there. What that buys\n * is a draggable set that is one contiguous, non-sticky run — every permutation\n * of which stays monotonic, which is what the delegate needs.\n */\nexport function isColumnDraggable<T>(\n  column: Pick<CubeResolvedColumn<T>, 'isStructural' | 'pin' | 'isReorderable'>,\n  isEnabled: boolean,\n): boolean {\n  return (\n    isEnabled &&\n    !column.isStructural &&\n    column.pin == null &&\n    (column.isReorderable ?? true)\n  );\n}\n\nexport function getDraggableColumnKeys<T>(\n  columns: readonly CubeResolvedColumn<T>[],\n  isEnabled: boolean,\n): string[] {\n  return columns\n    .filter((column) => isColumnDraggable(column, isEnabled))\n    .map((column) => column.key);\n}\n\n/**\n * Folds a permutation of the draggable subset back into the full order.\n *\n * Only the slots the draggable keys already occupy are rewritten, so a hidden\n * column, a pinned one, or one that opted out keeps its absolute index and\n * cannot be displaced by a drag it took no part in.\n *\n * The visible consequence, worth knowing: a hidden column between two draggable\n * ones keeps its slot rather than following a neighbour, so it may come back\n * between different columns than it left. Predictable beats clever.\n */\nexport function projectReorder(\n  fullOrder: readonly string[],\n  nextDraggable: readonly string[],\n): string[] {\n  const draggable = new Set(nextDraggable);\n  const next = [...fullOrder];\n  let cursor = 0;\n\n  for (let slot = 0; slot < next.length; slot++) {\n    if (draggable.has(next[slot])) next[slot] = nextDraggable[cursor++];\n  }\n\n  return next;\n}\n\nconst EMPTY_ORDER: string[] = [];\n\nexport interface UseColumnOrderOptions<T> {\n  columns: CubeTableColumn<T>[];\n  columnOrder?: string[];\n  defaultColumnOrder?: string[];\n  onColumnOrderChange?: (order: string[]) => void;\n  storage: ReturnType<typeof useTableStorage>;\n}\n\nexport interface UseColumnOrderResult<T> {\n  /** `columns`, reordered. Feed this to `useTableColumns`. */\n  columns: CubeTableColumn<T>[];\n  /** The full key list in its current order, including hidden and pinned keys. */\n  order: string[];\n  /** Takes the reordered DRAGGABLE keys and commits the full order. */\n  reorder: (nextDraggable: string[]) => void;\n}\n\nexport function useColumnOrder<T>({\n  columns,\n  columnOrder,\n  defaultColumnOrder,\n  onColumnOrderChange,\n  storage,\n}: UseColumnOrderOptions<T>): UseColumnOrderResult<T> {\n  // Seeded once, like `ownColumnWidths`: a controlled `columnOrder` belongs to\n  // the page, so restoring over it would fight the page's own source of truth.\n  const [storedOrder] = useState(() =>\n    columnOrder === undefined && storage.has('columnOrder')\n      ? storage.initial.columnOrder\n      : undefined,\n  );\n\n  // An empty array means \"no order\", which `applyColumnOrder` treats as a\n  // no-op — same shape `useTableSorts` uses for its own empty default, and it\n  // keeps `useControlledState` off the `undefined` overload.\n  const [order, setOrder] = useControlledState<string[]>(\n    columnOrder as string[],\n    defaultColumnOrder ?? storedOrder ?? EMPTY_ORDER,\n    onColumnOrderChange as (value: string[]) => void,\n  );\n\n  const ordered = useMemo(\n    () => applyColumnOrder(columns, order),\n    [columns, order],\n  );\n\n  // Always the FULL source key list, in current order — so a key never drops out\n  // of persisted state just because its column happened to be hidden.\n  const fullOrder = useMemo(\n    () => ordered.map((column) => column.key),\n    [ordered],\n  );\n\n  const reorder = useEvent((nextDraggable: string[]) => {\n    const next = projectReorder(fullOrder, nextDraggable);\n\n    setOrder(next);\n\n    // Only what the table OWNS is persisted — a controlled order belongs to the\n    // page, and storing it would fight the page on the next mount. Same rule\n    // `handleColumnResizeEnd` follows for widths.\n    if (columnOrder === undefined) storage.write({ columnOrder: next });\n  });\n\n  return { columns: ordered, order: fullOrder, reorder };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,iBACd,SACA,OACsB;AACtB,KAAI,CAAC,OAAO,OAAQ,QAAO;CAE3B,MAAM,UAAU,IAAI,IAAI,QAAQ,KAAK,WAAW,OAAO,IAAI,CAAC;CAC5D,MAAM,uBAAO,IAAI,KAAqB;AAEtC,OAAM,SAAS,KAAK,UAAU;AAG5B,MAAI,QAAQ,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAE,MAAK,IAAI,KAAK,MAAM;GAC5D;AAEF,KAAI,CAAC,KAAK,KAAM,QAAO;CAEvB,IAAI,UAAU;AAEd,QAAO,QACJ,KAAK,QAAQ,gBAAgB;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,IAAI;AAEhC,MAAI,OAAO,KAAM,WAAU;AAE3B,SAAO;GAAE;GAAQ;GAAa,MAAM,OAAO,UAAU;GAAK;GAC1D,CACD,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,YAAY,CAChE,KAAK,UAAU,MAAM,OAAO;;;;;;;;;;;;;;;;;;;AAoBjC,SAAgB,kBACd,QACA,WACS;AACT,QACE,aACA,CAAC,OAAO,gBACR,OAAO,OAAO,SACb,OAAO,iBAAiB;;AAI7B,SAAgB,uBACd,SACA,WACU;AACV,QAAO,QACJ,QAAQ,WAAW,kBAAkB,QAAQ,UAAU,CAAC,CACxD,KAAK,WAAW,OAAO,IAAI;;;;;;;;;;;;;AAchC,SAAgB,eACd,WACA,eACU;CACV,MAAM,YAAY,IAAI,IAAI,cAAc;CACxC,MAAM,OAAO,CAAC,GAAG,UAAU;CAC3B,IAAI,SAAS;AAEb,MAAK,IAAI,OAAO,GAAG,OAAO,KAAK,QAAQ,OACrC,KAAI,UAAU,IAAI,KAAK,MAAM,CAAE,MAAK,QAAQ,cAAc;AAG5D,QAAO;;AAGT,MAAM,cAAwB,EAAE;AAmBhC,SAAgB,eAAkB,EAChC,SACA,aACA,oBACA,qBACA,WACoD;CAGpD,MAAM,CAAC,eAAe,eACpB,gBAAgB,UAAa,QAAQ,IAAI,cAAc,GACnD,QAAQ,QAAQ,cAChB,OACL;CAKD,MAAM,CAAC,OAAO,YAAY,mBACxB,aACA,sBAAsB,eAAe,aACrC,oBACD;CAED,MAAM,UAAU,cACR,iBAAiB,SAAS,MAAM,EACtC,CAAC,SAAS,MAAM,CACjB;CAID,MAAM,YAAY,cACV,QAAQ,KAAK,WAAW,OAAO,IAAI,EACzC,CAAC,QAAQ,CACV;AAaD,QAAO;EAAE,SAAS;EAAS,OAAO;EAAW,SAX7B,UAAU,kBAA4B;GACpD,MAAM,OAAO,eAAe,WAAW,cAAc;AAErD,YAAS,KAAK;AAKd,OAAI,gBAAgB,OAAW,SAAQ,MAAM,EAAE,aAAa,MAAM,CAAC;IACnE;EAEoD"}

package/dist/tokens/color-theme.d.ts

@@ -1,86 +0,0 @@
-
-import { Styles } from "@tenphi/tasty";
-import { ColorMap } from "@tenphi/glaze";
-
-//#region src/tokens/color-theme.d.ts
-interface ColorThemeConfig {
-  /**
-   * A hue in 0–360, or any colour Glaze parses — hex, `rgb()`, `hsl()`,
-   * `okhsl()`, `okhst()`, `oklch()`.
-   *
-   * From a colour only the HUE and SATURATION are taken; the lightness is
-   * discarded and re-derived per scheme. That is what makes the result adaptive
-   * rather than a value that happens to work in one theme.
-   */
-  hue: number | string;
-  /** 0–100. @default the palette's own saturation seed */
-  saturation?: number;
-  pastel?: boolean;
-  /**
-   * Extra colour definitions, merged over {@link TINT_RECIPE}. Anything Glaze's
-   * `theme.colors()` accepts, including `contrast` floors against a sibling.
-   */
-  colors?: ColorMap;
-}
-interface ColorTheme {
-  /**
-   * A hash of the config, and the token prefix — `'tint-1a2b3c'`.
-   *
-   * Content-addressed rather than positional so two components asking for the
-   * same colour name the same theme, and therefore share one injection. Also
-   * makes it safe to stamp on the DOM as an identifier.
-   */
-  name: string;
-  /**
-   * Tasty token declarations, one state map per colour:
-   * `{ '#tint-1a2b3c-surface': { '': …, '@dark': …, '@hc': …, '@dark & @hc': … } }`
-   */
-  tokens: Styles;
-  /** Token references by their unprefixed name — `{ surface: '#tint-1a2b3c-surface' }`. */
-  colors: Record<string, string>;
-}
-/**
- * The hue and saturation of a colour, for use as a theme seed.
- *
- * ```ts
- * colorThemeSeed('#0ea5e9'); // → { hue: 237.32, saturation: 98.19 }
- * ```
- */
-declare function colorThemeSeed(value: string): {
-  hue: number;
-  saturation: number;
-};
-/**
- * Build (or reuse) an adaptive theme from a hue.
- *
- * Pure and memoized: the same config returns the same object identity until the
- * palette is re-seeded. Registering the tokens is {@link useColorTheme}'s job —
- * this only computes them, so it is safe to call while rendering or from a test.
- */
-declare function getColorTheme(config: ColorThemeConfig): ColorTheme;
-/**
- * Register an adaptive theme's tokens once per document, and get it back.
- *
- * The tokens land on `body` under a slot keyed by the theme's name, which is a
- * hash of the config — so every component asking for the same colour shares one
- * injection no matter how many of them there are. Tasty's global-style slots are
- * also permanent, which is what makes that safe: one component unmounting cannot
- * strip tokens another is still referencing.
- *
- * `body` rather than `:root`, which emits nothing at all — the same selector
- * `GlobalStyles` uses for the palette's own tokens. Custom properties inherit, so
- * anything rendered inside the document sees them; the one thing this cannot
- * reach is content portalled outside `<body>`, which nothing does.
- *
- * Because the slot id hashes the CONFIG rather than the resolved values,
- * re-seeding the palette replaces the same slot instead of leaking a new one.
- *
- * ```tsx
- * const theme = useColorTheme({ hue: '#0ea5e9' });
- * // theme.colors.surface → '#tint-1a2b3c-surface'
- * ```
- */
-declare function useColorTheme(config: ColorThemeConfig): ColorTheme;
-//#endregion
-export { ColorTheme, ColorThemeConfig, colorThemeSeed, getColorTheme, useColorTheme };
-//# sourceMappingURL=color-theme.d.ts.map

package/dist/tokens/color-theme.js

@@ -1,156 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-34ce1a4 | Cube Dev Team */
-import { DEFAULT_SATURATION, getPaletteConfig, getPaletteVersion, usePaletteVersion } from "./palette-config.js";
-import { TINT_RECIPE } from "./palette.js";
-import { useGlobalStyles } from "@tenphi/tasty";
-import { glaze } from "@tenphi/glaze";
-
-//#region src/tokens/color-theme.ts
-/**
-* FNV-1a, base36. Short, stable and dependency-free.
-*
-* These hashes name CSS custom properties and land in DOM attributes, so they
-* have to be deterministic across processes (SSR and the client must agree) and
-* safe as identifiers — but not cryptographic.
-*/
-function hashString(input) {
-	let hash = 2166136261;
-	for (let i = 0; i < input.length; i++) {
-		hash ^= input.charCodeAt(i);
-		hash = Math.imul(hash, 16777619) >>> 0;
-	}
-	return hash.toString(36);
-}
-/**
-* Hashes the RESOLVED seed, not the config as written.
-*
-* `{ hue: '#0ea5e9' }` and `{ hue: 237.32, saturation: 98.19 }` are the same
-* colour said two ways; hashing the input would give them two names, two
-* injections and two sets of generated rules. Rounded, because a seed that
-* differs in the twelfth decimal is the same colour to every eye and every
-* renderer — and an unrounded float would defeat the deduplication it is here to
-* provide.
-*/
-function hashSeed(seed) {
-	return `tint-${hashString(JSON.stringify([
-		seed.hue.toFixed(4),
-		seed.saturation.toFixed(4),
-		seed.pastel,
-		seed.colors ? stableStringify(seed.colors) : null
-	]))}`;
-}
-/** Key order must not change the hash, or two identical configs get two slots. */
-function stableStringify(value) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
-}
-/**
-* The hue and saturation of a colour, for use as a theme seed.
-*
-* ```ts
-* colorThemeSeed('#0ea5e9'); // → { hue: 237.32, saturation: 98.19 }
-* ```
-*/
-function colorThemeSeed(value) {
-	const light = glaze.color(value).resolve().light;
-	return {
-		hue: light.h,
-		saturation: light.s * 100
-	};
-}
-/**
-* Cached by `${paletteVersion}:${name}`.
-*
-* The palette version is in the KEY rather than triggering a clear, so a stale
-* entry is simply unreachable. `lastVersion` still clears the map on a change,
-* or repeated `setPaletteConfig` calls would grow it without bound.
-*/
-const cache = /* @__PURE__ */ new Map();
-let lastVersion = -1;
-/**
-* Build (or reuse) an adaptive theme from a hue.
-*
-* Pure and memoized: the same config returns the same object identity until the
-* palette is re-seeded. Registering the tokens is {@link useColorTheme}'s job —
-* this only computes them, so it is safe to call while rendering or from a test.
-*/
-function getColorTheme(config) {
-	const version = getPaletteVersion();
-	if (version !== lastVersion) {
-		cache.clear();
-		lastVersion = version;
-	}
-	const paletteConfig = getPaletteConfig();
-	const parsed = typeof config.hue === "string" ? colorThemeSeed(config.hue) : null;
-	const seed = {
-		hue: parsed ? parsed.hue : config.hue,
-		saturation: config.saturation ?? parsed?.saturation ?? paletteConfig.saturation ?? DEFAULT_SATURATION,
-		pastel: config.pastel ?? paletteConfig.pastel ?? false,
-		colors: config.colors
-	};
-	const name = hashSeed(seed);
-	const cached = cache.get(name);
-	if (cached) return cached;
-	const { hue, saturation } = seed;
-	const overrides = {
-		...paletteConfig.contrastLevel != null ? { contrastLevel: paletteConfig.contrastLevel } : null,
-		...seed.pastel ? { pastel: true } : null
-	};
-	const theme = glaze(hue, saturation, Object.keys(overrides).length ? overrides : void 0);
-	theme.colors({
-		...TINT_RECIPE,
-		...config.colors
-	});
-	const raw = theme.tasty({ format: "oklch" });
-	const tokens = {};
-	const colors = {};
-	for (const [key, value] of Object.entries(raw)) {
-		if (!key.startsWith("#")) {
-			tokens[key] = value;
-			continue;
-		}
-		const bare = key.slice(1);
-		const token = `#${name}-${bare}`;
-		tokens[token] = value;
-		colors[bare] = token;
-	}
-	const result = {
-		name,
-		tokens,
-		colors
-	};
-	cache.set(name, result);
-	return result;
-}
-/**
-* Register an adaptive theme's tokens once per document, and get it back.
-*
-* The tokens land on `body` under a slot keyed by the theme's name, which is a
-* hash of the config — so every component asking for the same colour shares one
-* injection no matter how many of them there are. Tasty's global-style slots are
-* also permanent, which is what makes that safe: one component unmounting cannot
-* strip tokens another is still referencing.
-*
-* `body` rather than `:root`, which emits nothing at all — the same selector
-* `GlobalStyles` uses for the palette's own tokens. Custom properties inherit, so
-* anything rendered inside the document sees them; the one thing this cannot
-* reach is content portalled outside `<body>`, which nothing does.
-*
-* Because the slot id hashes the CONFIG rather than the resolved values,
-* re-seeding the palette replaces the same slot instead of leaking a new one.
-*
-* ```tsx
-* const theme = useColorTheme({ hue: '#0ea5e9' });
-* // theme.colors.surface → '#tint-1a2b3c-surface'
-* ```
-*/
-function useColorTheme(config) {
-	usePaletteVersion();
-	const theme = getColorTheme(config);
-	useGlobalStyles("body", theme.tokens, { id: `cube-color-theme-${theme.name}` });
-	return theme;
-}
-
-//#endregion
-export { colorThemeSeed, getColorTheme, hashString, useColorTheme };
-//# sourceMappingURL=color-theme.js.map

package/dist/tokens/color-theme.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"color-theme.js","names":[],"sources":["../../src/tokens/color-theme.ts"],"sourcesContent":["import { glaze } from '@tenphi/glaze';\nimport { useGlobalStyles } from '@tenphi/tasty';\n\n// Imported for its SIDE EFFECT as much as for `TINT_RECIPE`.\n//\n// `palette.ts` runs `glaze.configure({ states: { dark: '@dark', highContrast:\n// '@hc' }, modes: …, darkTone: … })` at module scope, and that global config is\n// what makes a theme emit `'@dark'` / `'@hc'` keys at all. Without this import\n// a runtime theme falls back to Glaze's defaults — `@media(prefers-color-scheme:\n// dark)` keys and NO high-contrast tier — which still renders, so the failure is\n// silent. `color-theme.test.ts` asserts the `'@hc'` key exists to catch it.\nimport { TINT_RECIPE } from './palette';\nimport {\n  DEFAULT_SATURATION,\n  getPaletteConfig,\n  getPaletteVersion,\n  usePaletteVersion,\n} from './palette-config';\n\nimport type { ColorMap, GlazeConfigOverride } from '@tenphi/glaze';\nimport type { Styles } from '@tenphi/tasty';\n\nexport interface ColorThemeConfig {\n  /**\n   * A hue in 0–360, or any colour Glaze parses — hex, `rgb()`, `hsl()`,\n   * `okhsl()`, `okhst()`, `oklch()`.\n   *\n   * From a colour only the HUE and SATURATION are taken; the lightness is\n   * discarded and re-derived per scheme. That is what makes the result adaptive\n   * rather than a value that happens to work in one theme.\n   */\n  hue: number | string;\n  /** 0–100. @default the palette's own saturation seed */\n  saturation?: number;\n  pastel?: boolean;\n  /**\n   * Extra colour definitions, merged over {@link TINT_RECIPE}. Anything Glaze's\n   * `theme.colors()` accepts, including `contrast` floors against a sibling.\n   */\n  colors?: ColorMap;\n}\n\nexport interface ColorTheme {\n  /**\n   * A hash of the config, and the token prefix — `'tint-1a2b3c'`.\n   *\n   * Content-addressed rather than positional so two components asking for the\n   * same colour name the same theme, and therefore share one injection. Also\n   * makes it safe to stamp on the DOM as an identifier.\n   */\n  name: string;\n  /**\n   * Tasty token declarations, one state map per colour:\n   * `{ '#tint-1a2b3c-surface': { '': …, '@dark': …, '@hc': …, '@dark & @hc': … } }`\n   */\n  tokens: Styles;\n  /** Token references by their unprefixed name — `{ surface: '#tint-1a2b3c-surface' }`. */\n  colors: Record<string, string>;\n}\n\n/**\n * FNV-1a, base36. Short, stable and dependency-free.\n *\n * These hashes name CSS custom properties and land in DOM attributes, so they\n * have to be deterministic across processes (SSR and the client must agree) and\n * safe as identifiers — but not cryptographic.\n */\nexport function hashString(input: string): string {\n  let hash = 0x811c9dc5;\n\n  for (let i = 0; i < input.length; i++) {\n    hash ^= input.charCodeAt(i);\n    // >>> 0 keeps it an unsigned 32-bit int; `Math.imul` is the 32-bit multiply.\n    hash = Math.imul(hash, 0x01000193) >>> 0;\n  }\n\n  return hash.toString(36);\n}\n\n/**\n * Hashes the RESOLVED seed, not the config as written.\n *\n * `{ hue: '#0ea5e9' }` and `{ hue: 237.32, saturation: 98.19 }` are the same\n * colour said two ways; hashing the input would give them two names, two\n * injections and two sets of generated rules. Rounded, because a seed that\n * differs in the twelfth decimal is the same colour to every eye and every\n * renderer — and an unrounded float would defeat the deduplication it is here to\n * provide.\n */\nfunction hashSeed(seed: ResolvedSeed): string {\n  return `tint-${hashString(\n    JSON.stringify([\n      seed.hue.toFixed(4),\n      seed.saturation.toFixed(4),\n      seed.pastel,\n      seed.colors ? stableStringify(seed.colors) : null,\n    ]),\n  )}`;\n}\n\ninterface ResolvedSeed {\n  hue: number;\n  saturation: number;\n  pastel: boolean;\n  colors?: ColorMap;\n}\n\n/** Key order must not change the hash, or two identical configs get two slots. */\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value);\n\n  if (Array.isArray(value)) {\n    return `[${value.map(stableStringify).join(',')}]`;\n  }\n\n  const entries = Object.entries(value as Record<string, unknown>).sort(\n    ([a], [b]) => (a < b ? -1 : a > b ? 1 : 0),\n  );\n\n  return `{${entries\n    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)\n    .join(',')}}`;\n}\n\n/**\n * The hue and saturation of a colour, for use as a theme seed.\n *\n * ```ts\n * colorThemeSeed('#0ea5e9'); // → { hue: 237.32, saturation: 98.19 }\n * ```\n */\nexport function colorThemeSeed(value: string): {\n  hue: number;\n  saturation: number;\n} {\n  const light = glaze.color(value).resolve().light;\n\n  // Glaze reports saturation as a 0–1 factor; the palette's seeds are 0–100.\n  return { hue: light.h, saturation: light.s * 100 };\n}\n\n/**\n * Cached by `${paletteVersion}:${name}`.\n *\n * The palette version is in the KEY rather than triggering a clear, so a stale\n * entry is simply unreachable. `lastVersion` still clears the map on a change,\n * or repeated `setPaletteConfig` calls would grow it without bound.\n */\nconst cache = new Map<string, ColorTheme>();\nlet lastVersion = -1;\n\n/**\n * Build (or reuse) an adaptive theme from a hue.\n *\n * Pure and memoized: the same config returns the same object identity until the\n * palette is re-seeded. Registering the tokens is {@link useColorTheme}'s job —\n * this only computes them, so it is safe to call while rendering or from a test.\n */\nexport function getColorTheme(config: ColorThemeConfig): ColorTheme {\n  const version = getPaletteVersion();\n\n  if (version !== lastVersion) {\n    cache.clear();\n    lastVersion = version;\n  }\n\n  const paletteConfig = getPaletteConfig();\n  const parsed =\n    typeof config.hue === 'string' ? colorThemeSeed(config.hue) : null;\n  const seed: ResolvedSeed = {\n    hue: parsed ? parsed.hue : (config.hue as number),\n    saturation:\n      config.saturation ??\n      parsed?.saturation ??\n      paletteConfig.saturation ??\n      DEFAULT_SATURATION,\n    pastel: config.pastel ?? paletteConfig.pastel ?? false,\n    colors: config.colors,\n  };\n\n  const name = hashSeed(seed);\n  const cached = cache.get(name);\n\n  if (cached) return cached;\n\n  const { hue, saturation } = seed;\n\n  // `pastel` and `contrastLevel` are instance-level in Glaze, not settable\n  // through `glaze.configure`, so a runtime theme has to carry them itself or it\n  // would ignore a pastel palette. Omitted entirely when off, so the default\n  // output is provably the same as passing nothing.\n  const overrides: GlazeConfigOverride = {\n    ...(paletteConfig.contrastLevel != null\n      ? { contrastLevel: paletteConfig.contrastLevel }\n      : null),\n    ...(seed.pastel ? { pastel: true } : null),\n  };\n\n  const theme = glaze(\n    hue,\n    saturation,\n    Object.keys(overrides).length ? overrides : undefined,\n  );\n\n  theme.colors({ ...TINT_RECIPE, ...config.colors });\n\n  // `prefix` is a palette-only option, so the keys are renamed here. `oklch`\n  // because that is what the palette emits; tasty converts to the configured\n  // colour space on the way out either way.\n  const raw = theme.tasty({ format: 'oklch' }) as Record<string, unknown>;\n  const tokens: Styles = {};\n  const colors: Record<string, string> = {};\n\n  for (const [key, value] of Object.entries(raw)) {\n    // Only the `#colour` entries are renamed; `splitHue` is off, so there are no\n    // `$…-hue` companions to worry about, but a future one must not be mangled.\n    if (!key.startsWith('#')) {\n      (tokens as Record<string, unknown>)[key] = value;\n      continue;\n    }\n\n    const bare = key.slice(1);\n    const token = `#${name}-${bare}`;\n\n    (tokens as Record<string, unknown>)[token] = value;\n    colors[bare] = token;\n  }\n\n  const result: ColorTheme = { name, tokens, colors };\n\n  cache.set(name, result);\n\n  return result;\n}\n\n/**\n * Register an adaptive theme's tokens once per document, and get it back.\n *\n * The tokens land on `body` under a slot keyed by the theme's name, which is a\n * hash of the config — so every component asking for the same colour shares one\n * injection no matter how many of them there are. Tasty's global-style slots are\n * also permanent, which is what makes that safe: one component unmounting cannot\n * strip tokens another is still referencing.\n *\n * `body` rather than `:root`, which emits nothing at all — the same selector\n * `GlobalStyles` uses for the palette's own tokens. Custom properties inherit, so\n * anything rendered inside the document sees them; the one thing this cannot\n * reach is content portalled outside `<body>`, which nothing does.\n *\n * Because the slot id hashes the CONFIG rather than the resolved values,\n * re-seeding the palette replaces the same slot instead of leaking a new one.\n *\n * ```tsx\n * const theme = useColorTheme({ hue: '#0ea5e9' });\n * // theme.colors.surface → '#tint-1a2b3c-surface'\n * ```\n */\nexport function useColorTheme(config: ColorThemeConfig): ColorTheme {\n  // Subscribes this component to a re-seed. `getColorTheme` reads the version\n  // itself for its cache, so the value is unused here — the subscription is the\n  // point, and it is what makes the tokens below re-inject.\n  usePaletteVersion();\n\n  const theme = getColorTheme(config);\n\n  useGlobalStyles('body', theme.tokens, {\n    id: `cube-color-theme-${theme.name}`,\n  });\n\n  return theme;\n}\n"],"mappings":"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"}