pixelize-design-library 2.4.1-beta.11 → 2.4.1-beta.13

package/dist/esm/Theme/chakra/componentStyles.js

@@ -0,0 +1,221 @@
+import { cssVar } from "@chakra-ui/react";
+import { Button } from "../../Components/Button/Button.styles";
+import { Checkbox } from "../../Components/Checkbox/Checkbox.styles";
+import { Input } from "../../Components/Input/TextInput.styles";
+import { Select } from "../../Components/Select/Select.styles";
+import { Tag } from "../../Components/Tag/Tag.styles";
+import { Textarea } from "../../Components/InputTextArea/InputTextArea.style";
+import { NumberInput } from "../../Components/NumberInput/NumberInput.styles";
+import { accentTextOnCanvas, isDarkCanvas, onFilled } from "../tokens/builders/accentText";
+import { contrastRatio } from "../tokens/builders/color";
+import { resolveHoverTint } from "../tokens/builders/outlineRung";
+import { Drawer } from "./Drawer.styles";
+import { Menu } from "./Menu.styles";
+import { Modal } from "./Modal.styles";
+import { Popover } from "./Popover.styles";
+import { Slider } from "./Slider.styles";
+import { Switch } from "./Switch.styles";
+import { Tabs } from "./Tabs.styles";
+import { Avatar } from "./Avatar.styles";
+// `colorScheme` accepts any Chakra scale, including built-ins we never themed (blackAlpha,
+// whiteAlpha) whose rungs are translucent `rgba(...)` strings, not opaque hex — our contrast
+// math (hexToRgb) throws on those on purpose (see color.ts). Guard so those scales fall back to
+// Chakra's own original fixed rung instead of computing contrast on a color it can't parse.
+const isHexColor = (color) => typeof color === "string" && /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(color);
+// Badge isn't its own component family (no Components/Badge/), so its style config lives here —
+// Chakra's stock `solid` variant hardcodes a white label on a variable fill, same AA gap Tag had.
+const Badge = {
+    variants: {
+        solid: ({ theme, colorScheme = "gray" }) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const swatch = (_d = (_b = (_a = theme.colors) === null || _a === void 0 ? void 0 : _a[colorScheme]) !== null && _b !== void 0 ? _b : (_c = theme.colors) === null || _c === void 0 ? void 0 : _c.gray) !== null && _d !== void 0 ? _d : {};
+            const bg = swatch === null || swatch === void 0 ? void 0 : swatch[500];
+            const white = (_f = (_e = theme.colors) === null || _e === void 0 ? void 0 : _e.white) !== null && _f !== void 0 ? _f : "#fff";
+            const black = (_h = (_g = theme.colors) === null || _g === void 0 ? void 0 : _g.black) !== null && _h !== void 0 ? _h : "#000";
+            return {
+                bg,
+                color: isHexColor(bg) ? onFilled(bg, white, black) : swatch === null || swatch === void 0 ? void 0 : swatch[800],
+            };
+        },
+        // Chakra's stock `subtle` picks its bg/color pair via `mode()`, keyed to Chakra's own
+        // colorMode — which this app never toggles (dark mode swaps the palette object instead), so
+        // it always takes the light-mode branch. Applied to our mode-reversed dark scales, that
+        // branch's fixed rung pair (100/800) measures 4.06 in dark mode, just under AA.
+        subtle: ({ theme, colorScheme = "gray" }) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const swatch = (_d = (_b = (_a = theme.colors) === null || _a === void 0 ? void 0 : _a[colorScheme]) !== null && _b !== void 0 ? _b : (_c = theme.colors) === null || _c === void 0 ? void 0 : _c.gray) !== null && _d !== void 0 ? _d : {};
+            const bg = (_e = swatch === null || swatch === void 0 ? void 0 : swatch[100]) !== null && _e !== void 0 ? _e : swatch === null || swatch === void 0 ? void 0 : swatch[50];
+            if (!isHexColor(bg))
+                return { bg, color: swatch === null || swatch === void 0 ? void 0 : swatch[800] };
+            // accentTextOnCanvas keeps brand hue by trying this scale's own rungs first, but some
+            // narrow-gamut hues (e.g. yellow) don't reach far enough at either end to clear AA against
+            // every bg they can land on in dark mode (measured 4.42 for a reversed-yellow badge) — its
+            // own doc admits it falls back to "the most extreme rung" rather than guaranteeing AA. Verify
+            // the candidate actually clears AA; if not, drop brand hue for the guaranteed white/black ink
+            // (onFilled is provably >=4.5 against any bg) rather than ship a near-miss.
+            const accent = accentTextOnCanvas(swatch, bg);
+            if (contrastRatio(accent, bg) >= 4.5)
+                return { bg, color: accent };
+            const white = (_g = (_f = theme.colors) === null || _f === void 0 ? void 0 : _f.white) !== null && _g !== void 0 ? _g : "#fff";
+            const black = (_j = (_h = theme.colors) === null || _h === void 0 ? void 0 : _h.black) !== null && _j !== void 0 ? _j : "#000";
+            return { bg, color: onFilled(bg, white, black) };
+        },
+    },
+    defaultProps: {
+        variant: "subtle",
+        colorScheme: "gray",
+    },
+};
+// Chakra's stock FormErrorMessage hardcodes `colors.red.500` (our own `red[500]`, since
+// `createBrandTheme` sets `theme.colors = palette`) — same AA gap as our own ErrorMessage/
+// ErrorComponent, fixed the same way rather than leaving Chakra's raw usage (e.g. FeedbackForm)
+// unfixed.
+const FormError = {
+    baseStyle: ({ theme }) => {
+        var _a, _b, _c, _d;
+        // `icon` (FormErrorIcon) shares the same AA gap as `text` — both must be fixed together or
+        // the icon stays on Chakra's raw `red.500`.
+        const color = accentTextOnCanvas((_a = theme.colors) === null || _a === void 0 ? void 0 : _a.red, (_d = (_c = (_b = theme.colors) === null || _b === void 0 ? void 0 : _b.backgroundColor) === null || _c === void 0 ? void 0 : _c.main) !== null && _d !== void 0 ? _d : "#ffffff");
+        return {
+            text: { color },
+            icon: { color },
+        };
+    },
+};
+const $tooltipBg = cssVar("tooltip-bg");
+const $tooltipFg = cssVar("tooltip-fg");
+/**
+ * Chakra's own Tooltip baseStyle hardcodes `--tooltip-bg`/`--tooltip-fg` to `colors.gray.700`/
+ * `colors.whiteAlpha.900` (gated behind `_dark`, which this theme-swap app never triggers — see
+ * Menu.styles.ts / createBrandTheme's colorMode comment). Our reversed dark gray ramp makes
+ * `gray.700` LIGHT (~L79), so every bare `<Tooltip>` renders a near-white bubble with near-white
+ * text on the dark canvas — invisible. A tooltip floats over arbitrary content in either mode, so
+ * unlike Menu/Modal/Drawer (which follow the canvas) it needs a FIXED high-contrast chip that
+ * doesn't invert with the palette — `black`/`white` are exactly the two tokens `buildDarkPalette`
+ * deliberately never remaps, so they stay a stable dark-bg/white-text pair in both modes.
+ */
+const Tooltip = {
+    baseStyle: ({ theme }) => {
+        var _a, _b, _c, _d;
+        return ({
+            [$tooltipBg.variable]: (_b = (_a = theme.colors) === null || _a === void 0 ? void 0 : _a.black) !== null && _b !== void 0 ? _b : "colors.gray.700",
+            [$tooltipFg.variable]: (_d = (_c = theme.colors) === null || _c === void 0 ? void 0 : _c.white) !== null && _d !== void 0 ? _d : "colors.whiteAlpha.900",
+        });
+    },
+};
+const $skeletonStart = cssVar("skeleton-start-color");
+const $skeletonEnd = cssVar("skeleton-end-color");
+/**
+ * Chakra's own Skeleton baseStyle hardcodes `--skeleton-start-color`/`--skeleton-end-color` to
+ * `colors.gray.100`/`colors.gray.400` the same `_dark`-gated way Menu/Popover did (Wave G/H), so
+ * every bare `<Skeleton>` shimmers between two near-white tones on the dark canvas. Fixed at the
+ * theme level rather than in `Skeletons.tsx`: Chakra's `Skeleton` only writes these vars from its
+ * `startColor`/`endColor` PROPS when a caller actually passes them (`useToken` on an empty string
+ * resolves to `undefined`, so the prop-driven `cssVarStyles` object stays empty) — an explicit
+ * prop still wins via that mechanism, this only supplies the default the base style already owns.
+ */
+const Skeleton = {
+    baseStyle: ({ theme }) => {
+        var _a, _b, _c, _d, _e, _f;
+        return ({
+            [$skeletonStart.variable]: (_c = (_b = (_a = theme.colors) === null || _a === void 0 ? void 0 : _a.gray) === null || _b === void 0 ? void 0 : _b[100]) !== null && _c !== void 0 ? _c : "colors.gray.100",
+            [$skeletonEnd.variable]: (_f = (_e = (_d = theme.colors) === null || _d === void 0 ? void 0 : _d.gray) === null || _e === void 0 ? void 0 : _e[300]) !== null && _f !== void 0 ? _f : "colors.gray.400",
+            background: $skeletonStart.reference,
+            borderColor: $skeletonEnd.reference,
+        });
+    },
+};
+// Chakra's `extendTheme` does not REPLACE a component's stock baseStyle when ours is also a
+// function — it calls BOTH and deep-merges the two returned plain objects, key by key. Chakra's
+// own stock Radio (@chakra-ui/theme radio.mjs) writes its checked dot with the shorthand style
+// props `bg`/`w`/`h`/`pos`; an earlier version of this override used the full CSS property names
+// (`background`/`width`/`height`/`position`). A deep merge treats those as DIFFERENT keys, so
+// both survived into the final style object instead of one cleanly overwriting the other — and
+// in practice Chakra's own `bg: "currentColor"` rung won, leaving a hardcoded-black dot. Using
+// the exact same keys Chakra's stock style uses makes every one of ours a scalar overwrite, and
+// `!important` on the two colour-bearing declarations removes any remaining doubt about which
+// value survives serialization — verified against the actual rendered cascade, not just this
+// function's return value (see componentStyles.radioDotMerge.test.ts, which asserts the merge
+// behavior directly rather than only the function output).
+const Radio = {
+    baseStyle: ({ theme, colorScheme }) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const swatch = (_a = theme.colors) === null || _a === void 0 ? void 0 : _a[colorScheme];
+        const fill = (_b = swatch === null || swatch === void 0 ? void 0 : swatch[500]) !== null && _b !== void 0 ? _b : (_d = (_c = theme.colors) === null || _c === void 0 ? void 0 : _c.primary) === null || _d === void 0 ? void 0 : _d[500];
+        const white = (_f = (_e = theme.colors) === null || _e === void 0 ? void 0 : _e.white) !== null && _f !== void 0 ? _f : "#ffffff";
+        const black = (_h = (_g = theme.colors) === null || _g === void 0 ? void 0 : _g.black) !== null && _h !== void 0 ? _h : "#000000";
+        const dot = onFilled(fill, white, black);
+        // A browser probe found the checked radio's hover repeating its own resting `fill` —
+        // Chakra's stock checked._hover (inherited from checkbox) lands on the SAME `bg`/`borderColor`
+        // keys we do, so extendTheme's merge is a scalar overwrite here, not a coexisting selector;
+        // ours must supply a value that actually differs from resting, same fix shape as
+        // NavigationBar/OrgSwitcher's "hand a fill its own resting bg as the backdrop" pattern.
+        const hoverFill = resolveHoverTint(fill, fill);
+        return {
+            control: {
+                borderColor: (_k = (_j = theme.colors) === null || _j === void 0 ? void 0 : _j.boxborder) === null || _k === void 0 ? void 0 : _k[500],
+                _checked: {
+                    bg: `${fill} !important`,
+                    borderColor: `${fill} !important`,
+                    color: `${dot} !important`,
+                    _before: {
+                        content: `""`,
+                        display: "inline-block",
+                        pos: "relative",
+                        w: "50%",
+                        h: "50%",
+                        borderRadius: "50%",
+                        bg: `${dot} !important`,
+                    },
+                    _hover: { bg: `${hoverFill} !important`, borderColor: `${hoverFill} !important` },
+                },
+            },
+        };
+    },
+    defaultProps: { colorScheme: "primary" },
+};
+const $closeButtonBg = cssVar("close-button-bg");
+/**
+ * Chakra's stock CloseButton hover/active wash (`blackAlpha.100`/`.200`) only swaps to
+ * `whiteAlpha.100`/`.200` under `_dark` — dead in this app (see createBrandTheme's colorMode
+ * comment) — so a CloseButton on a dark canvas keeps the light-mode blackAlpha wash, which reads
+ * as almost no affordance against a dark surface. The light-mode values themselves also measure
+ * borderline against `background[50]` (1.14/1.19, under `MIN_PERCEPTIBLE_STEP`). Branch on the
+ * palette's own actual canvas (`isDarkCanvas`), not Chakra's dead colorMode, and step one rung up
+ * each scale (`.200`/`.300`) — verified >=1.19 across all 9 brands x both modes
+ * (closeButtonHover.test.ts).
+ */
+const CloseButton = {
+    baseStyle: ({ theme }) => {
+        var _a, _b, _c, _d, _e;
+        const dark = isDarkCanvas((_c = (_b = (_a = theme.colors) === null || _a === void 0 ? void 0 : _a.backgroundColor) === null || _b === void 0 ? void 0 : _b.main) !== null && _c !== void 0 ? _c : "#ffffff");
+        const alpha = dark ? (_d = theme.colors) === null || _d === void 0 ? void 0 : _d.whiteAlpha : (_e = theme.colors) === null || _e === void 0 ? void 0 : _e.blackAlpha;
+        return {
+            _hover: { [$closeButtonBg.variable]: alpha === null || alpha === void 0 ? void 0 : alpha[200] },
+            _active: { [$closeButtonBg.variable]: alpha === null || alpha === void 0 ? void 0 : alpha[300] },
+        };
+    },
+};
+export const componentStyles = {
+    Checkbox,
+    Radio,
+    Input,
+    Button,
+    Select,
+    Tag,
+    Textarea,
+    NumberInput,
+    Badge,
+    FormError,
+    Drawer,
+    Menu,
+    Modal,
+    Popover,
+    Slider,
+    Switch,
+    Tabs,
+    Avatar,
+    Skeleton,
+    Tooltip,
+    CloseButton,
+};

package/dist/esm/Theme/chakra/createBrandTheme.js

@@ -0,0 +1,118 @@
+import { extendTheme } from "@chakra-ui/react";
+import common from "./common.web";
+import fonts from "./fonts.web";
+import { componentStyles } from "./componentStyles";
+import { onFilled } from "../tokens/builders/accentText";
+/**
+ * Builds a Chakra theme from a pure brand palette.
+ *
+ * Replaces the seven byte-identical `<Brand>/theme.ts` files — they differed only in
+ * which palette they imported.
+ *
+ * Dark mode works by swapping which palette the theme carries: `componentStyles` variants
+ * are functions of `({ theme })` and `useCustomTheme()` reads `theme.colors`, so both follow
+ * the palette automatically without any per-component `_dark` overrides.
+ */
+export const createBrandTheme = (palette, options = {}) => {
+    var _a;
+    const colorMode = (_a = options.colorMode) !== null && _a !== void 0 ? _a : "light";
+    const brand = {
+        colors: palette,
+        ...fonts,
+        ...common,
+    };
+    return extendTheme({
+        ...brand,
+        config: {
+            ...common.config,
+            // Deliberately ALWAYS "light", even for the dark theme — this is not a bug.
+            //
+            // Dark works by swapping the palette, so the palette is ALREADY mode-adapted by the time
+            // Chakra sees it. Telling Chakra it is in dark mode makes it adapt a second time: its
+            // built-ins carry `_dark` blocks that reach for `gray.700`/`gray.800` assuming a scale where
+            // those rungs are dark. Our dark gray ramp runs dark -> light, so those rungs are LIGHT —
+            // producing a light Card/Skeleton/Menu on a dark canvas. Adapting twice cancels out.
+            //
+            // Keeping Chakra on its `_light` branch is what makes the swap work: those defaults are
+            // gray-RUNG references (`gray.100`, `gray.200`, `gray.600`), and our reversed ramp already
+            // maps each rung to the right value per mode. `semanticTokens` below patches the one default
+            // that hardcodes a literal color instead of a rung.
+            initialColorMode: "light",
+            useSystemColorMode: false,
+        },
+        // `chakra-body-bg` is the only stock semantic token that resolves to a LITERAL (`white`)
+        // rather than a gray rung, so it is the only one the palette swap cannot correct on its own —
+        // it is what paints a white Card/Modal/Menu on the dark canvas. `background[50]` is the
+        // canvas-following equivalent: byte-identical `#ffffff` in light, the canvas in dark.
+        // `chakra-inverse-text` is the same literal-`white` problem in text form.
+        semanticTokens: {
+            colors: {
+                "chakra-body-bg": palette.background[50],
+                "chakra-inverse-text": palette.background[50],
+            },
+        },
+        // Light themes intentionally declare no global styles — that is the pre-existing
+        // behavior, and adding any would shift every consuming app's light rendering.
+        // Dark needs a canvas, otherwise the page stays white behind the components.
+        ...(colorMode === "dark"
+            ? {
+                styles: {
+                    global: {
+                        // Native widgets the page cannot style — the `<select>` dropdown list and the
+                        // time/date picker popups — are painted by the browser, which defaults to light
+                        // and produced white popups on the dark canvas. `color-scheme` is the only way to
+                        // tell it otherwise.
+                        html: {
+                            colorScheme: "dark",
+                        },
+                        body: {
+                            bg: palette.backgroundColor.main,
+                            color: palette.text[900],
+                        },
+                        // Text selection is another browser-painted surface `color-scheme` doesn't cover —
+                        // the UA default `::selection` stays a light highlight regardless of theme, so
+                        // selecting text anywhere (e.g. a table cell) shows a stray white/lavender patch on
+                        // the dark canvas. Brand it instead, with WCAG-safe ink via the same `onFilled` math
+                        // used for buttons/badges.
+                        "::selection": {
+                            background: palette.primary[500],
+                            color: onFilled(palette.primary[500], palette.white, palette.black),
+                        },
+                        "::-moz-selection": {
+                            background: palette.primary[500],
+                            color: onFilled(palette.primary[500], palette.white, palette.black),
+                        },
+                        // `color-scheme: dark` gives WebKit/Blink a dark scrollbar by default, but it's the
+                        // OS's generic dark gray, not brand-aware — style it explicitly so it matches the
+                        // canvas instead of floating as a mismatched gray bar.
+                        "::-webkit-scrollbar": {
+                            width: "10px",
+                            height: "10px",
+                        },
+                        "::-webkit-scrollbar-track": {
+                            background: palette.backgroundColor.main,
+                        },
+                        "::-webkit-scrollbar-thumb": {
+                            background: palette.gray[600],
+                            borderRadius: "6px",
+                        },
+                        "::-webkit-scrollbar-thumb:hover": {
+                            background: palette.gray[500],
+                        },
+                        // Chrome/Edge autofill paints its own opaque yellow/white fill behind the input
+                        // text via `-webkit-box-shadow` (not `background`), so a plain `bg` override never
+                        // reaches it — a bright light box survives on every dark autofilled field unless
+                        // overridden with the same trick.
+                        "input:-webkit-autofill, input:-webkit-autofill:hover, input:-webkit-autofill:focus": {
+                            WebkitBoxShadow: `0 0 0px 1000px ${palette.backgroundColor.secondary} inset`,
+                            WebkitTextFillColor: palette.text[900],
+                            caretColor: palette.text[900],
+                        },
+                    },
+                },
+            }
+            : {}),
+        components: componentStyles,
+    });
+};
+export default createBrandTheme;

package/dist/esm/Theme/chakra/fonts.web.js

@@ -0,0 +1,10 @@
+/** Self-hosted Inter Variable (wght 100–900); required for theme fontWeights to render correctly. */
+import "@fontsource-variable/inter/index.css";
+import typography from "../tokens/primitives/typography";
+/**
+ * Web font binding: loads the Inter font face (CSS side-effect) and re-exports the pure
+ * typography tokens. The CSS import lives here rather than in `tokens/` so the token
+ * layer stays portable to mobile.
+ */
+const fonts = typography;
+export default fonts;

package/dist/esm/Theme/index.js

@@ -0,0 +1,63 @@
+import createBrandTheme from "./chakra/createBrandTheme";
+import { lightPalettes, darkPalettes } from "./tokens/brands";
+/**
+ * Chakra themes per brand, built from the pure palettes in `tokens/brands`.
+ *
+ * These used to be seven near-identical `<Brand>/theme.ts` files that differed only in
+ * which palette they imported; `createBrandTheme` is that shared body.
+ */
+const lavender = createBrandTheme(lightPalettes.lavender);
+const meadow = createBrandTheme(lightPalettes.meadow);
+const radiant = createBrandTheme(lightPalettes.radiant);
+const skyline = createBrandTheme(lightPalettes.skyline);
+const slate = createBrandTheme(lightPalettes.slate);
+const emerald = createBrandTheme(lightPalettes.emerald);
+const rosewood = createBrandTheme(lightPalettes.rosewood);
+const storefront = createBrandTheme(lightPalettes.storefront);
+const zinc = createBrandTheme(lightPalettes.zinc);
+export { skyline, meadow, radiant, lavender, slate, emerald, rosewood, storefront, zinc };
+/**
+ * Published contract — consumers iterate this to render theme pickers, so both the keys
+ * and their order are load-bearing. Stays light-only: these are the exact theme objects
+ * apps already pass to `withTheme`, and dark is opt-in via `PixelizeThemeProvider`.
+ * `storefront`/`zinc` are appended at the end — additive, doesn't reorder existing entries.
+ */
+export const ThemesList = {
+    lavender: lavender,
+    meadow: meadow,
+    skyline: skyline,
+    emerald: emerald,
+    rosewood: rosewood,
+    slate: slate,
+    radiant: radiant,
+    storefront: storefront,
+    zinc: zinc,
+};
+/**
+ * `dark` is built on first read, not at import. Nine `createBrandTheme` calls measure ~15ms on a
+ * dev machine, and a light-only app (tickets, and every app before it opts in) never reads one.
+ * A getter — rather than a lazy map — keeps `Object.keys(brandThemes)` and its order intact,
+ * which `ThemeSwitcher` iterates to render the brand picker.
+ */
+const withLazyDark = (brand, light) => {
+    let dark;
+    return {
+        light,
+        get dark() {
+            dark !== null && dark !== void 0 ? dark : (dark = createBrandTheme(darkPalettes[brand], { colorMode: "dark" }));
+            return dark;
+        },
+    };
+};
+/** Light + dark theme per brand. `PixelizeThemeProvider` swaps between these. */
+export const brandThemes = {
+    lavender: withLazyDark("lavender", lavender),
+    meadow: withLazyDark("meadow", meadow),
+    radiant: withLazyDark("radiant", radiant),
+    skyline: withLazyDark("skyline", skyline),
+    slate: withLazyDark("slate", slate),
+    emerald: withLazyDark("emerald", emerald),
+    rosewood: withLazyDark("rosewood", rosewood),
+    storefront: withLazyDark("storefront", storefront),
+    zinc: withLazyDark("zinc", zinc),
+};

package/dist/esm/Theme/provider/PixelizeThemeProvider.js

@@ -0,0 +1,204 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { ChakraProvider, extendTheme } from "@chakra-ui/react";
+import { brandThemes } from "../index";
+import ToasterProvider from "../../Components/Toaster/Toaster";
+import { getSystemColorMode, readStoredTheme, subscribeToSystemColorMode, writeStoredTheme, } from "./colorModeStorage";
+const DEFAULT_BRAND = "lavender";
+const DEFAULT_MODE = "system";
+const DEFAULT_STORAGE_KEY = "pixelize-theme";
+/**
+ * Chakra's default `colorModeManager` reads/writes its OWN `localStorage["chakra-ui-color-mode"]`
+ * key — entirely separate from this app's `storageKey` above — and that stored value wins over
+ * `theme.config.initialColorMode` on every load. `createBrandTheme` sets `initialColorMode: "light"`
+ * on every theme object specifically so Chakra's native dark mode (and every un-migrated built-in
+ * `_dark:` block — Card's "elevated" variant reaches for `gray.700`, which our reversed dark ramp
+ * makes LIGHT) never fires. But a stale `"dark"` value in that key — from Chakra's own toggle ever
+ * having been used on this origin, by this app or a prior version of it — silently overrides that
+ * default and reintroduces exactly the bug `initialColorMode: "light"` was meant to prevent: a
+ * washed-out light Card on an otherwise-correct dark canvas, while everything reading the palette
+ * directly (i.e. everything else) stays right. Forcing this manager to always report `"light"` and
+ * never persist removes Chakra's native color mode from the equation entirely, so no stray
+ * `_dark:` block anywhere (present or future) can ever fire, regardless of what's in storage.
+ */
+const forcedLightColorModeManager = {
+    type: "localStorage",
+    ssr: false,
+    get: () => "light",
+    set: () => { },
+};
+export const ThemeModeContext = createContext(undefined);
+/**
+ * Chakra's own color mode is deliberately NOT synced to `resolvedMode`, and must not be.
+ *
+ * This provider adapts for dark by swapping the palette, so `theme.colors` is already correct for
+ * the active mode. Putting Chakra into dark mode on top of that adapts a second time: its built-in
+ * `_dark` blocks reach for `gray.700`/`gray.800` expecting those rungs to be dark, but our dark
+ * ramp runs dark -> light, so they resolve LIGHT — a white Card/Skeleton/Menu on a dark canvas.
+ * A previous revision synced it to keep `useColorModeValue()` working and shipped exactly that.
+ *
+ * Consequence for consumers: `useColorModeValue(light, dark)` always returns its LIGHT argument.
+ * That is correct here — the palette has already resolved the mode, so the "light" argument is
+ * whatever the active palette says. Read the mode from `useThemeMode()` instead. Existing apps are
+ * unaffected: they are light-only, where that argument was always the one returned anyway.
+ */
+export const PixelizeThemeProvider = ({ children, brand: brandProp = DEFAULT_BRAND, onBrandChange, defaultMode = DEFAULT_MODE, onModeChange, storageKey = DEFAULT_STORAGE_KEY, disablePersistence = false, themeOverrides, }) => {
+    const [mode, setModeState] = useState(defaultMode);
+    const [brand, setBrandState] = useState(brandProp);
+    // Deterministic on the server and on the first client render — the real OS value lands in
+    // the effect below, so hydration always matches.
+    const [systemMode, setSystemMode] = useState("light");
+    useEffect(() => {
+        setSystemMode(getSystemColorMode());
+        return subscribeToSystemColorMode(setSystemMode);
+    }, []);
+    useEffect(() => {
+        if (disablePersistence)
+            return;
+        const stored = readStoredTheme(storageKey);
+        if (stored.mode)
+            setModeState(stored.mode);
+        if (stored.brand)
+            setBrandState(stored.brand);
+    }, [disablePersistence, storageKey]);
+    // `brandProp` only seeds initial state above, so a consumer that re-renders with a new
+    // `brand` prop after mount (e.g. persisting the pick through its own store, like tickets'
+    // Settings page dispatching Redux instead of calling `setBrand`) would otherwise never see
+    // it applied. Sync it here instead so every consumer gets it for free.
+    const isFirstBrandPropRun = useRef(true);
+    useEffect(() => {
+        if (isFirstBrandPropRun.current) {
+            isFirstBrandPropRun.current = false;
+            return;
+        }
+        // Only re-sync when the prop itself changes — not on every local `setBrand` call (that
+        // would fight the user's own in-session brand picking, e.g. via ThemeSwitcher).
+        setBrandState(brandProp);
+    }, [brandProp]);
+    // Same prop-sync for the mode, so an app owning it in its own store no longer needs the
+    // `mode` -> store mirror effect that deadlocks against this one.
+    const isFirstModePropRun = useRef(true);
+    useEffect(() => {
+        if (isFirstModePropRun.current) {
+            isFirstModePropRun.current = false;
+            return;
+        }
+        setModeState(defaultMode);
+    }, [defaultMode]);
+    // Skipping the mount run keeps the defaults from being written over a stored value before
+    // the rehydrate effect above has applied it.
+    const isFirstPersistRun = useRef(true);
+    useEffect(() => {
+        if (isFirstPersistRun.current) {
+            isFirstPersistRun.current = false;
+            return;
+        }
+        if (disablePersistence)
+            return;
+        writeStoredTheme(storageKey, { mode, brand });
+    }, [mode, brand, disablePersistence, storageKey]);
+    const resolvedMode = mode === "system" ? systemMode : mode;
+    /**
+     * Native browser UI (the `<select>` dropdown popup chrome, the `<input type="date">` calendar
+     * picker) is painted by the browser's own UA stylesheet keyed off the CSS `color-scheme`
+     * property, entirely separate from Chakra/React theming — no component style or palette swap
+     * above can reach it. Without this, that chrome always renders light, even on an otherwise dark
+     * page. Scoped to this provider (not a global stylesheet) so `withTheme` consumers — deliberately
+     * light-only, see the module doc's "Key rules" — are untouched.
+     */
+    useEffect(() => {
+        document.documentElement.style.colorScheme = resolvedMode;
+    }, [resolvedMode]);
+    // Held in refs so a caller's inline arrow never re-creates `setMode`/`setBrand`, which would
+    // invalidate the context value on every render of the consuming app. Written in a layout
+    // effect, not during render — a render-phase write is unsafe under StrictMode's double
+    // invocation, and this still lands before any click handler can fire.
+    const onModeChangeRef = useRef(onModeChange);
+    const onBrandChangeRef = useRef(onBrandChange);
+    useLayoutEffect(() => {
+        onModeChangeRef.current = onModeChange;
+        onBrandChangeRef.current = onBrandChange;
+    }, [onModeChange, onBrandChange]);
+    const setMode = useCallback((next) => {
+        var _a;
+        setModeState(next);
+        (_a = onModeChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onModeChangeRef, next);
+    }, []);
+    const setBrand = useCallback((next) => {
+        var _a;
+        setBrandState(next);
+        (_a = onBrandChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onBrandChangeRef, next);
+    }, []);
+    // From "system", flip to the opposite of what the OS currently gives, so a click always
+    // visibly changes the UI.
+    const toggle = useCallback(() => setMode(resolvedMode === "dark" ? "light" : "dark"), [resolvedMode, setMode]);
+    const value = useMemo(() => ({ mode, resolvedMode, setMode, toggle, brand, setBrand }), [mode, resolvedMode, setMode, toggle, brand, setBrand]);
+    // `themeOverrides` is caller-supplied, and the idiomatic way to pass it is an inline object
+    // literal — a new identity every render. Keying the memo on identity would re-run `extendTheme`
+    // and hand `ChakraProvider` a new theme on every render of the consuming app, invalidating
+    // emotion's style resolution for everything beneath it. Compare by value instead.
+    const overridesKey = themeOverrides ? JSON.stringify(themeOverrides) : "";
+    const resolvedTheme = useMemo(() => {
+        const base = brandThemes[brand][resolvedMode];
+        return themeOverrides ? extendTheme(base, themeOverrides) : base;
+        // Keyed on the serialized overrides, not their identity. `brand`/`resolvedMode` must stay:
+        // overrides re-layer onto the CURRENT palette (see the prop's doc comment above).
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [brand, resolvedMode, overridesKey]);
+    /**
+     * The library ships its `var(--color-*)` tokens light-only on `:root` (global.css), so any
+     * consumer that styles with those CSS vars rather than Chakra tokens stays light in dark mode —
+     * invisible text on the dark canvas, white panels. In dark, re-point every used var at the
+     * already-dark-correct resolved palette; in light, clear them so the static `:root` values apply
+     * unchanged (so a light-only app is byte-identical to before). Also mirror the mode to
+     * `data-mode` for consumers that want to hook their own dark CSS.
+     */
+    useEffect(() => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const root = document.documentElement;
+        root.dataset.mode = resolvedMode;
+        const colors = resolvedTheme.colors;
+        const sem = (_a = colors.semantic) !== null && _a !== void 0 ? _a : {};
+        const gray = colors.gray;
+        const HUE_SCALES = [
+            "primary", "gray", "red", "orange", "yellow",
+            "green", "teal", "blue", "cyan", "purple", "pink",
+        ];
+        const SEMANTIC_SCALES = ["success", "error", "warning", "info"]; // nested under colors.semantic
+        const RUNGS = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+        // Single-value semantic vars → palette scale+rung. The dark gray ramp runs dark(50) → light(900),
+        // so low rungs read as surfaces and high rungs as text — correct in dark, cleared in light.
+        const SEMANTIC_VARS = {
+            "text-heading": gray === null || gray === void 0 ? void 0 : gray[900], "text-body": gray === null || gray === void 0 ? void 0 : gray[700],
+            "text-subtle": gray === null || gray === void 0 ? void 0 : gray[500], "text-input": gray === null || gray === void 0 ? void 0 : gray[500],
+            "bg-main": gray === null || gray === void 0 ? void 0 : gray[50], "bg-secondary": gray === null || gray === void 0 ? void 0 : gray[100], "bg-tertiary": gray === null || gray === void 0 ? void 0 : gray[100],
+            "bg-quaternary": gray === null || gray === void 0 ? void 0 : gray[200], "bg-light": gray === null || gray === void 0 ? void 0 : gray[50], "bg-medium": gray === null || gray === void 0 ? void 0 : gray[100],
+            "bg-accent": gray === null || gray === void 0 ? void 0 : gray[200], "bg-subtle": gray === null || gray === void 0 ? void 0 : gray[100], "bg-muted": gray === null || gray === void 0 ? void 0 : gray[200],
+            "bg-neutral": gray === null || gray === void 0 ? void 0 : gray[100], "bg-base": gray === null || gray === void 0 ? void 0 : gray[50], "bg-table-header": gray === null || gray === void 0 ? void 0 : gray[100],
+            "border-default": gray === null || gray === void 0 ? void 0 : gray[200], "border-light": gray === null || gray === void 0 ? void 0 : gray[100],
+            "border-dark": gray === null || gray === void 0 ? void 0 : gray[300], "border-input": gray === null || gray === void 0 ? void 0 : gray[300],
+            "border-error": (_b = sem.error) === null || _b === void 0 ? void 0 : _b[500], "border-success": (_c = sem.success) === null || _c === void 0 ? void 0 : _c[500],
+            "border-warning": (_d = sem.warning) === null || _d === void 0 ? void 0 : _d[500], "border-info": (_e = sem.info) === null || _e === void 0 ? void 0 : _e[500],
+        };
+        const set = (name, val) => val && root.style.setProperty(`--color-${name}`, val);
+        const clear = (name) => root.style.removeProperty(`--color-${name}`);
+        const allRampNames = [...HUE_SCALES, ...SEMANTIC_SCALES].flatMap((s) => RUNGS.map((r) => `${s}-${r}`));
+        if (resolvedMode === "dark") {
+            for (const s of HUE_SCALES)
+                for (const r of RUNGS)
+                    set(`${s}-${r}`, (_f = colors[s]) === null || _f === void 0 ? void 0 : _f[r]);
+            for (const s of SEMANTIC_SCALES)
+                for (const r of RUNGS)
+                    set(`${s}-${r}`, (_g = sem[s]) === null || _g === void 0 ? void 0 : _g[r]);
+            for (const [name, val] of Object.entries(SEMANTIC_VARS))
+                set(name, val);
+        }
+        else {
+            for (const name of allRampNames)
+                clear(name);
+            for (const name of Object.keys(SEMANTIC_VARS))
+                clear(name);
+        }
+    }, [resolvedMode, resolvedTheme]);
+    return (_jsx(ThemeModeContext.Provider, { value: value, children: _jsx(ChakraProvider, { theme: resolvedTheme, colorModeManager: forcedLightColorModeManager, children: _jsx(ToasterProvider, { children: children }) }) }));
+};