@aglyn/shared-ui-theme 1.0.0-beta.143

package/src/lib/console.theme.js

@@ -0,0 +1,598 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2023 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { lightBlue } from "@mui/material/colors";
+import { buildFontFamilyList } from "./constants.js";
+import { accentTextColor } from "./util/accent-text.js";
+import createResponsiveTheme, { createResponsiveCssVarTheme } from "./util/create-responsive-theme.js";
+const colorScheme = {
+    light: {
+        // Palette rotated 2026-08-03 (AGL-1186): the blue accent that every
+        // component was already opting into is now `primary`, so nothing has to
+        // opt out of a primary that was really a surface tone. Whole colour
+        // objects moved, so each keeps the contrastText it shipped with.
+        primary: {
+            main: '#00b0ff',
+            // The accent rendered AS TEXT — `ACCENT_TEXT_SHADE` in
+            // `util/accent-text.ts`. Links and the labels of text and outlined
+            // buttons read this slot; `main` keeps painting fills, borders and
+            // indicators, which owe 3:1 rather than 4.5:1. The brand blue is
+            // 2.43:1 on white, so as normal-size text it needs the deeper shade:
+            // this one measures 4.95:1 on paper and 4.54:1 on the page.
+            dark: '#0077ad',
+            contrastText: '#FFFFFF'
+        },
+        secondary: {
+            main: '#e040fb',
+            // Same slot, same role. Authored rather than left to derivation so the
+            // value every link resolves to is readable in this file: 6.11:1 on
+            // paper, 5.61:1 on the page.
+            dark: '#9d2db0',
+            contrastText: '#FFFFFF'
+        },
+        tertiary: {
+            main: '#404C5C',
+            contrastText: '#FFFFFF'
+        },
+        surface: {
+            main: `#F8F9FA`,
+            contrastText: '#000000'
+        },
+        // Pale accent washes used as tile/panel FILLS (AGL-1244). Each member is
+        // named after the accent whose icon sits on it — the mega-menu's blue
+        // tiles pair `tint.primary` with a `primary.dark` glyph — so the pairing
+        // is legible from the token names alone. These were the last raw hexes on
+        // the marketing nav; they are not `primary.light` (`#33BFFF`) and never
+        // were, which is why the slot had to be named rather than borrowed.
+        tint: {
+            primary: '#E6F5FF',
+            secondary: '#FBE6FE',
+            tertiary: '#EEF0F2'
+        },
+        // MUI's own outlined-input border weight, promoted to a token so a field
+        // drawn outside MUI can match one drawn by it (see `PaletteOptions`).
+        inputOutline: 'rgba(0, 0, 0, 0.23)',
+        background: {
+            default: '#F5F5F5',
+            paper: '#FFFFFF'
+        },
+        info: {
+            // The deepest blue of this hue that still carries a WHITE label at the
+            // 4.5:1 AA text bar (4.56:1). A lighter info takes every filled
+            // variant sub-AA, and flipping its ink to dark makes an informational
+            // surface read as a warning.
+            main: '#1878cd',
+            contrastText: '#FFFFFF'
+        },
+        error: {
+            // The deepest red of this hue that keeps a white label at AA (4.51:1).
+            // An error surface is a destructive-action affordance, so the fill
+            // carries the contrast and the ink stays white.
+            main: '#e32c27',
+            contrastText: '#FFFFFF'
+        },
+        success: {
+            main: '#4CAF50',
+            contrastText: '#000000DE'
+        },
+        warning: {
+            main: '#FFAB40',
+            contrastText: '#000000DE'
+        },
+        grey: {
+            50: '#FAFAFA',
+            100: '#F5F5F5',
+            200: '#EEEEEE',
+            300: '#E0E0E0',
+            400: '#BDBDBD',
+            500: '#9E9E9E',
+            600: '#757575',
+            700: '#616161',
+            800: '#424242',
+            900: '#212121',
+            A100: '#D5D5D5',
+            A200: '#AAAAAA',
+            A400: '#303030',
+            A700: '#616161'
+        },
+        svgBackground: {
+            main: '#FAFAFA',
+            hover: '#FAFAFA',
+            active: '#FAFAFA',
+            focus: '#FAFAFA'
+        },
+        svgFilled: {
+            main: '#9E9E9E',
+            hover: lightBlue['400'],
+            active: lightBlue['400'],
+            focus: lightBlue['400']
+        },
+        svgStroke: {
+            main: '#FFFFFF',
+            hover: '#FFFFFF',
+            active: '#FFFFFF',
+            focus: '#FFFFFF'
+        }
+    },
+    dark: {
+        primary: {
+            main: '#00b0ff',
+            // The accent-as-text slot, LIGHTER than `main` here and deliberately
+            // so. MUI derives `dark` as `darken(main, 0.3)` in both schemes — it
+            // cannot see that the ground flipped — which lands `#007bb2` at 3.67:1
+            // on this page. Every `dark` shade in this scheme is therefore
+            // authored, and each is the value `ensureAccessibleShades` computes by
+            // walking the accent LIGHTER until it clears 4.5:1 against both
+            // `background.default` and `background.paper`. 9.02:1 / 6.62:1.
+            dark: '#4dc8ff',
+            contrastText: '#FFFFFF'
+        },
+        secondary: {
+            main: '#e040fb',
+            // 7.04:1 on the page, 5.17:1 on a raised panel. The brand magenta
+            // itself is 3.78:1 on paper, so it cannot be the text shade here.
+            dark: '#e979fc',
+            contrastText: '#FFFFFF'
+        },
+        // Dark takes a LIFTED slate, not the brand `#404C5C`: that scores 1.38
+        // against this scheme's page and would just move the old invisibility
+        // bug from primary to tertiary. `#7C8CA3` measures 5.02 vs page and
+        // 3.63 vs a raised panel, and needs dark ink rather than white (6.14
+        // against black, 3.42 against white).
+        tertiary: {
+            main: '#7C8CA3',
+            // 7.73:1 / 5.68:1 — `main` itself is 2.78:1 on the page.
+            dark: '#a3afbf',
+            contrastText: '#000000DE'
+        },
+        surface: {
+            // Held at 1.17:1 from the page even though that is flat for an
+            // elevation step. This token is also the panel the besigner draws its
+            // hierarchy depth cues on, and lifting it toward the page pushes the
+            // active guide — `secondary.main` on this fill — from 4.41:1 down to
+            // 3.89:1. Trading a legible cue for a slightly clearer edge is the
+            // wrong way round; the depth cues are what someone actually reads.
+            main: `#202934`,
+            contrastText: '#FFFFFF'
+        },
+        // The hand-curated dark counterparts the 15 tinted tiles carried in their
+        // `@scheme dark` slices before the token existed (AGL-1244). Carrying the
+        // exact values here is what lets those slices be DELETED without dark mode
+        // shifting: a literal needs a slice, a token flips on its own.
+        tint: {
+            // Tile FILLS, so the bar is separation from the page rather than a
+            // WCAG text ratio: below ~1.5:1 a tinted tile has no visible edge. The
+            // originals sat at 1.13–1.25:1 and disappeared. White ink clears 11:1
+            // on all three.
+            primary: '#193d55',
+            // Magenta cannot reach 1.5:1 without turning purple-grey, so this one
+            // stops at 1.44:1 and the tile carries an `inputOutline` border in
+            // dark instead of pushing the hue further.
+            secondary: '#571e61',
+            tertiary: '#333b44'
+        },
+        inputOutline: 'rgba(255, 255, 255, 0.23)',
+        background: {
+            default: '#161c21',
+            paper: '#2a3440'
+        },
+        info: {
+            main: '#1878cd',
+            // 6.22:1 / 4.57:1.
+            dark: '#5da1dc',
+            contrastText: '#FFFFFF'
+        },
+        error: {
+            main: '#e32c27',
+            // 6.18:1 / 4.54:1.
+            dark: '#ed7876',
+            contrastText: '#FFFFFF'
+        },
+        success: {
+            main: '#4CAF50',
+            // 8.56:1 / 6.29:1.
+            dark: '#82c785',
+            contrastText: '#000000DE'
+        },
+        warning: {
+            main: '#FFAB40',
+            // 10.98:1 / 8.07:1.
+            dark: '#ffc479',
+            contrastText: '#000000DE'
+        },
+        grey: {
+            50: '#FAFAFA',
+            100: '#F5F5F5',
+            200: '#EEEEEE',
+            300: '#E0E0E0',
+            400: '#BDBDBD',
+            500: '#9E9E9E',
+            600: '#757575',
+            700: '#616161',
+            800: '#424242',
+            900: '#212121',
+            A100: '#D5D5D5',
+            A200: '#AAAAAA',
+            A400: '#303030',
+            A700: '#616161'
+        },
+        svgBackground: {
+            main: '#FAFAFA',
+            hover: '#FAFAFA',
+            active: '#FAFAFA',
+            focus: '#FAFAFA'
+        },
+        svgFilled: {
+            main: '#9E9E9E',
+            hover: lightBlue['A100'],
+            active: lightBlue['A100'],
+            focus: lightBlue['A100']
+        },
+        svgStroke: {
+            main: '#FFFFFF',
+            hover: '#FFFFFF',
+            active: '#FFFFFF',
+            focus: '#FFFFFF'
+        }
+    }
+};
+const shadowKeyUmbraOpacity = 0.2;
+const shadowKeyPenumbraOpacity = 0.14;
+const shadowAmbientShadowOpacity = 0.12;
+function createShadowInset(...px) {
+    return [
+        `inset ${px[0]}px ${px[1]}px ${px[2]}px ${px[3]}px rgba(0,0,0,${shadowKeyUmbraOpacity})`,
+        `inset ${px[4]}px ${px[5]}px ${px[6]}px ${px[7]}px rgba(0,0,0,${shadowKeyPenumbraOpacity})`,
+        `inset ${px[8]}px ${px[9]}px ${px[10]}px ${px[11]}px rgba(0,0,0,${shadowAmbientShadowOpacity})`
+    ].join(',');
+}
+const baseOptions = {
+    components: {
+        MuiAppBar: {
+            defaultProps: {
+                enableColorOnDark: true
+            }
+        },
+        MuiAvatar: {
+            styleOverrides: {
+                root: {
+                    width: 32,
+                    height: 32
+                }
+            }
+        },
+        MuiButton: {
+            defaultProps: {
+                color: 'primary'
+            },
+            styleOverrides: {
+                // MUI's own variants set `--variant-textColor` and
+                // `--variant-outlinedColor` to `palette[color].main`, which paints
+                // the brand color as normal-size text — `#00b0ff` at 2.43:1 on
+                // white. Both vars move to the accent-text shade
+                // (`palette[color].dark`, scheme-aware). `--variant-outlinedBorder`
+                // and `--variant-containedBg` are left on `main`: a border and a
+                // fill owe 3:1, and the brand belongs there.
+                //
+                // Resolved per instance rather than baked, because `components` are
+                // evaluated ONCE against the root theme — a literal read here would
+                // freeze the light-scheme hex into dark mode.
+                root: ({ theme, ownerState })=>{
+                    const accent = accentTextColor(theme, ownerState == null ? void 0 : ownerState.color);
+                    return _extends({
+                        '&a[disabled], &.disabled': {
+                            pointerEvents: 'none',
+                            textDecoration: 'none',
+                            filter: 'grayscale(1) opacity(0.65)'
+                        }
+                    }, accent && {
+                        '--variant-textColor': accent,
+                        '--variant-outlinedColor': accent
+                    });
+                }
+            }
+        },
+        /**
+     * Room for a floated label at the top of a dialog (AGL-703).
+     *
+     * MUI zeroes a DialogContent's top padding when it follows a DialogTitle
+     * — `.MuiDialogTitle-root + .MuiDialogContent-root` — and the content box
+     * scrolls (`overflow-y: auto`). So the first field's shrunk outlined
+     * label, which sits ABOVE its own border, is clipped by the scroll
+     * container. It shows on any dialog whose first control has a value on
+     * open: the New author dialog's `Type` select had its label shaved in
+     * half.
+     *
+     * Twenty-seven dialogs tried to fix this themselves with
+     * `sx={{ pt: 1 }}`, and NONE of them worked: MUI's rule is two classes
+     * and `sx` is one, so the adjacent-sibling selector wins on specificity
+     * every time. Matching that selector here is what makes the fix apply —
+     * which is why it belongs in the theme rather than at any call site.
+     *
+     * 12px: the shrunk label rises ~9px above the input's top edge, plus a
+     * little air so it does not sit ON the dialog title.
+     */ MuiDialogContent: {
+            styleOverrides: {
+                root: ({ theme })=>({
+                        '.MuiDialogTitle-root + &': {
+                            paddingTop: theme.spacing(1.5)
+                        }
+                    })
+            }
+        },
+        MuiFab: {
+            defaultProps: {
+                color: 'primary'
+            }
+        },
+        MuiIconButton: {
+            defaultProps: {
+                color: 'primary'
+            },
+            // color: 'inherit', // Default color to inherit
+            styleOverrides: {
+                root: ({ theme })=>({
+                        padding: theme.spacing(1)
+                    })
+            },
+            variants: [
+                {
+                    props: {
+                        variant: 'outlined'
+                    },
+                    style: ({ theme })=>({
+                            border: `1px solid`,
+                            borderColor: `inherit`
+                        })
+                }
+            ]
+        },
+        MuiLink: {
+            defaultProps: {
+                color: 'primary'
+            },
+            styleOverrides: {
+                // A Link is text by definition, so `color="primary"` resolving to
+                // `palette.primary.main` is always measured against the wrong bar.
+                // Only the PaletteColor keys are rewritten — `inherit`,
+                // `textPrimary`, `textSecondary` and `textDisabled` return undefined
+                // from `accentTextColor` and keep MUI's own resolution.
+                root: ({ theme, ownerState })=>{
+                    const accent = accentTextColor(theme, ownerState == null ? void 0 : ownerState.color);
+                    return _extends({
+                        '&[disabled], &.disabled': {
+                            pointerEvents: 'none',
+                            textDecoration: 'none',
+                            filter: 'grayscale(1) opacity(0.65)'
+                        }
+                    }, accent && {
+                        color: accent
+                    });
+                }
+            }
+        },
+        // MuiMenu: {},
+        // No accent defaults live here any more (AGL-1186). Tabs, checkboxes,
+        // radios, switches, sliders, progress and badges each briefly carried
+        // `color: 'secondary'` to escape a `primary` that was a surface tone.
+        // Now that `primary` IS the accent they render correctly on MUI's own
+        // default, and a per-component default is exactly what the rotation
+        // exists to remove.
+        //
+        // That includes the `MuiTabs` default AGL-1181 records as its fix: it
+        // was removed here deliberately, not reverted. The rotation fixed the
+        // root cause the default was papering over, so a reader who finds
+        // nothing at that issue's write-up is looking at the right file.
+        MuiToolbar: {
+            styleOverrides: {
+                // Honour `disableGutters` (AGL-1230). This override targets the ROOT
+                // slot, and `disableGutters` only drops the `gutters` slot — so the
+                // padding survived the prop, app-wide, and the prop silently did
+                // nothing at ≥sm. It cost the marketing nav a 24px offset against the
+                // page container at every width below the container's clamp.
+                root: ({ theme, ownerState })=>(ownerState == null ? void 0 : ownerState.disableGutters) ? {} : {
+                        [theme.breakpoints.up('sm')]: {
+                            paddingLeft: theme.spacing(3),
+                            paddingRight: theme.spacing(3)
+                        }
+                    }
+            }
+        },
+        MuiTooltip: {
+            defaultProps: {
+                arrow: true
+            }
+        }
+    },
+    // mixins: {},
+    shadowsInset: [
+        'none',
+        createShadowInset(0, 2, 1, -1, 0, 1, 1, -0, 0, 1, 3, -0),
+        createShadowInset(0, 3, 1, -2, 0, 2, 2, -0, 0, 1, 5, -0),
+        createShadowInset(0, 3, 3, -2, 0, 3, 4, -0, 0, 1, 8, -0),
+        createShadowInset(0, 2, 4, -1, 0, 4, 5, -0, 0, 1, 10, -0),
+        createShadowInset(0, 3, 5, -1, 0, 5, 8, -0, 0, 1, 14, -0),
+        createShadowInset(0, 3, 5, -1, 0, 6, 10, -0, 0, 1, 18, -0),
+        createShadowInset(0, 4, 5, -2, 0, 7, 10, -1, 0, 2, 16, -1),
+        createShadowInset(0, 5, 5, -3, 0, 8, 10, -1, 0, 3, 14, -2),
+        createShadowInset(0, 5, 6, -3, 0, 9, 12, -1, 0, 3, 16, -2),
+        createShadowInset(0, 6, 6, -3, 0, 10, 14, -1, 0, 4, 18, -3),
+        createShadowInset(0, 6, 7, -4, 0, 11, 15, -1, 0, 4, 20, -3),
+        createShadowInset(0, 7, 8, -4, 0, 12, 17, -2, 0, 5, 22, -4),
+        createShadowInset(0, 7, 8, -4, 0, 13, 19, -2, 0, 5, 24, -4),
+        createShadowInset(0, 7, 9, -4, 0, 14, 21, -2, 0, 5, 26, -4),
+        createShadowInset(0, 8, 9, -5, 0, 15, 22, -2, 0, 6, 28, -5),
+        createShadowInset(0, 8, 10, -5, 0, 16, 24, -2, 0, 6, 30, -5),
+        createShadowInset(0, 8, 11, -5, 0, 17, 26, -2, 0, 6, 32, -5),
+        createShadowInset(0, 9, 11, -5, 0, 18, 28, -2, 0, 7, 34, -6),
+        createShadowInset(0, 9, 12, -6, 0, 19, 29, -2, 0, 7, 36, -6),
+        createShadowInset(0, 10, 13, -6, 0, 20, 31, -3, 0, 8, 38, -7),
+        createShadowInset(0, 10, 13, -6, 0, 21, 33, -3, 0, 8, 40, -7),
+        createShadowInset(0, 10, 14, -6, 0, 22, 35, -3, 0, 8, 42, -7),
+        createShadowInset(0, 11, 14, -7, 0, 23, 36, -3, 0, 9, 44, -8),
+        createShadowInset(0, 11, 15, -7, 0, 24, 38, -3, 0, 9, 46, -8)
+    ],
+    shape: {
+        borderRadius: 4,
+        appIconBorderRadius: `17.544%`
+    },
+    spacing: 8,
+    typography: {
+        fontFamily: buildFontFamilyList().join(','),
+        // The brand's named weights, beyond MUI's four.
+        //
+        // MUI ships Light 300 / Regular 400 / Medium 500 / Bold 700, and the
+        // brand type ramp uses three more: Black for heroes, ExtraBold for H2,
+        // SemiBold below Bold. Without these tokens, reaching 600/800/900 means
+        // typing a raw number, which pins an element to a weight instead of to
+        // the brand and leaves it behind when the ramp moves.
+        //
+        // They are ADDITIVE — `createTypography` deep-merges unknown keys
+        // through its `...other`, so nothing MUI defines changes. And they are
+        // reachable the same way the built-ins are: `@mui/system`'s `style()`
+        // retries a miss as `${prop}${capitalize(value)}`, so `fontWeight:
+        // 'extraBold'` resolves to `typography.fontWeightExtraBold`. The
+        // besigner's weight picker discovers them off the theme rather than
+        // from a list, so they appear in the panel without another edit.
+        //
+        // Roboto Flex is a variable face covering 100–1000, so every rung here
+        // renders as a real weight rather than a synthesised one.
+        fontWeightSemiBold: 600,
+        fontWeightExtraBold: 800,
+        fontWeightBlack: 900,
+        // The brand's display ramp, so `variant="h1"` / `"h2"` MEANS the brand.
+        // MUI's defaults are Light 300 at 96px/60px — a display face for a
+        // Material app, and nothing like the brand's Black heroes and ExtraBold
+        // H2. Left at the defaults, every heading on a built page needs a
+        // hand-written `fontSize` and `fontWeight` to look right, and the ones
+        // that miss render as a Material display face nobody chose while the
+        // markup still says Heading 2.
+        //
+        // Scoped deliberately to h1 and h2. They have ZERO `variant="hN"` usages
+        // in the console and one in the tenant app, so this restyles no product
+        // surface — it only changes what a SITE gets when it asks for a heading,
+        // which is exactly the thing that should follow the brand. h3–h6 carry
+        // 95 usages between them and are left on MUI's scale; `overline` has 19
+        // and is left alone for the same reason.
+        //
+        // `responsiveFontSizes` runs over these afterwards (xs→xl), so these are
+        // the DESKTOP end of a ramp that scales itself down — 56px/40px here
+        // land near the 34px/30px the mobile frames show.
+        // The rung ABOVE h1. h1 is the brand's 56px display size and
+        // stays that; a hero drawn at 72px had nothing to ask for, so every one
+        // hand-wrote `fontSize: '72px'` — and that literal then LOST to h1's own
+        // `responsiveFontSizes` ramp on wide viewports, silently rendering 56px.
+        // Listed in `RAMPED_DISPLAY_VARIANTS` so it scales down like the rest of
+        // the ramp rather than staying 72px on a phone.
+        displayXl: {
+            fontSize: '4.5rem',
+            fontWeight: 900,
+            lineHeight: 1.04,
+            letterSpacing: '-0.028em'
+        },
+        h1: {
+            fontSize: '3.5rem',
+            fontWeight: 900,
+            lineHeight: 1.05,
+            letterSpacing: '-0.025em'
+        },
+        h2: {
+            fontSize: '2.5rem',
+            fontWeight: 800,
+            lineHeight: 1.15,
+            letterSpacing: '-0.02em'
+        },
+        // h3 has to come DOWN with them, or the ramp inverts. Retuning h1/h2 to
+        // the brand (56/40px) while h3 kept MUI's 48px left a Heading 3 LARGER
+        // than a Heading 2 — visible the moment the theme preview listed the
+        // variants in size order. h3 carries zero `variant="h3"` usages, the same
+        // as h1 and h2, so this restyles no product surface; h4-h6 keep MUI's
+        // scale because 95 usages ride on them.
+        h3: {
+            fontSize: '2.25rem',
+            fontWeight: 700,
+            lineHeight: 1.2,
+            letterSpacing: '-0.015em'
+        },
+        // The three text rungs the brand uses that MUI's scale has no name for.
+        // MUI runs 16 / 14 / 12 (`body1` / `body2` / `caption`); the brand's
+        // pages want 17, 13 and 11, and with no token to ask for they write the
+        // pixels instead. One marketing page alone can carry 286 such literals —
+        // 165 of them the same 11px metadata line — each pinned to a size rather
+        // than to the scale.
+        //
+        // Full variant objects rather than bare sizes, so one pick brings the
+        // line height with it: `variant="micro"` or, where the element's own
+        // variant must stay, `fontSize: 'micro.fontSize'` — the token path the
+        // Font Size picker already offers for `h4.fontSize`.
+        //
+        // Named for the job, not the number, so the name survives a retune: a
+        // lede stays the lede if the brand moves it to 18px.
+        lede: {
+            fontSize: '1.0625rem',
+            fontWeight: 400,
+            lineHeight: 1.6
+        },
+        bodyCompact: {
+            fontSize: '0.8125rem',
+            fontWeight: 400,
+            lineHeight: 1.5
+        },
+        micro: {
+            fontSize: '0.6875rem',
+            fontWeight: 400,
+            lineHeight: 1.6
+        }
+    },
+    zIndex: {
+        max: 2147483647,
+        min: -2147483648
+    }
+};
+export const consoleOptions = _extends({}, baseOptions, {
+    palette: _extends({
+        mode: 'light'
+    }, colorScheme.light)
+});
+export const consoleOptionsDark = _extends({}, baseOptions, {
+    palette: _extends({
+        mode: 'dark'
+    }, colorScheme.dark)
+});
+export const consoleThemeLight = createResponsiveTheme({
+    themeOptions: _extends({}, consoleOptions)
+});
+export const consoleThemeDark = createResponsiveTheme({
+    themeOptions: _extends({}, consoleOptionsDark)
+});
+export const consoleThemeCssVar = createResponsiveCssVarTheme(consoleThemeLight, consoleThemeDark);
+export const getConsoleTheme = (mode = 'light')=>{
+    const theme = {
+        light: consoleThemeLight,
+        dark: consoleThemeDark
+    };
+    return theme[mode];
+};
+export const getConsoleMetaThemeColor = (mode = 'light')=>{
+    const themeColor = {
+        light: consoleThemeLight.palette.secondary.main,
+        dark: consoleThemeDark.palette.primary.main
+    };
+    return themeColor[mode];
+};
+export default consoleThemeLight;
+
+//# sourceMappingURL=console.theme.js.map