@trops/dash-core 0.1.604 → 0.1.605

package/dist/index.js

@@ -2567,6 +2567,27 @@ var ThemeWrapper = function ThemeWrapper(_ref) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [chosenTheme, themeVariant, themeName, themesForApplication, rawThemes]);
 
+  // Broadcast the app-level theme to a SEPARATE global so
+  // components rendered OUTSIDE the React theme tree
+  // (WidgetBuilderModal, AppUpdatesModal — they live as siblings
+  // of DashboardStage in dash-electron's Dash.js render) can fall
+  // back to it when no dashboard-specific override is in play.
+  //
+  // We can't share the same global with DashboardThemeProvider's
+  // per-workspace broadcast because React commits child effects
+  // BEFORE parent effects — ThemeWrapper would always run last
+  // and silently overwrite the workspace theme. Two separate
+  // globals avoid the race: consumers read
+  // `__dashThemeContext` (workspace) first, fall back to
+  // `__dashAppThemeContext` (app-level) when no workspace is open.
+  React.useEffect(function () {
+    if (typeof window === "undefined") return undefined;
+    if (contextValue !== null && contextValue !== void 0 && contextValue.currentTheme) {
+      window.__dashAppThemeContext = contextValue;
+      window.dispatchEvent(new Event("dash:theme-changed"));
+    }
+  }, [contextValue]);
+
   // Write the active theme's CSS custom properties to :root so any
   // hex-channel tokens (`bg-[var(--primary-700)]` etc. emitted by
   // ThemeModel) resolve app-wide. Without this, saving a hex theme
@@ -5743,6 +5764,45 @@ function ThemeBroadcast(_ref) {
   return null;
 }
 
+/**
+ * Writes the dashboard theme's cssVars to `:root` while mounted, and
+ * restores the previous values on unmount / theme switch.
+ *
+ * ThemeWrapper writes the APP theme's cssVars at the top of the tree.
+ * Without this helper, a dashboard that overrides the app theme with a
+ * hex-channel theme (like "Slack Generic") would carry the right class
+ * names (`bg-[var(--primary-900)]`) but the `--primary-900` variable
+ * on :root would still be the APP theme's value — or undefined if the
+ * app theme is named-family. Hex-themed surfaces then render with no
+ * background. This effect closes that gap by promoting the dashboard
+ * theme's cssVars to :root for the duration of its mount.
+ */
+function DashboardCssVarsBridge(_ref2) {
+  var cssVars = _ref2.cssVars;
+  React.useEffect(function () {
+    if (!cssVars || typeof document === "undefined") return undefined;
+    var root = document.documentElement;
+    var previous = {};
+    var keys = Object.keys(cssVars);
+    for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
+      var key = _keys[_i];
+      previous[key] = root.style.getPropertyValue(key);
+      root.style.setProperty(key, cssVars[key]);
+    }
+    return function () {
+      for (var _i2 = 0, _keys2 = keys; _i2 < _keys2.length; _i2++) {
+        var _key = _keys2[_i2];
+        if (previous[_key]) {
+          root.style.setProperty(_key, previous[_key]);
+        } else {
+          root.style.removeProperty(_key);
+        }
+      }
+    };
+  }, [cssVars]);
+  return null;
+}
+
 /**
  * DashboardThemeProvider
  *
@@ -5753,9 +5813,10 @@ function ThemeBroadcast(_ref) {
  * App chrome (navbar, tab bar, sidebar) stays OUTSIDE this wrapper
  * and keeps the app theme.
  */
-var DashboardThemeProvider = function DashboardThemeProvider(_ref2) {
-  var themeKey = _ref2.themeKey,
-    children = _ref2.children;
+var DashboardThemeProvider = function DashboardThemeProvider(_ref3) {
+  var _contextValue$current;
+  var themeKey = _ref3.themeKey,
+    children = _ref3.children;
   var parentContext = React.useContext(DashReact.ThemeContext);
   var themes = parentContext.themes,
     themeVariant = parentContext.themeVariant;
@@ -5787,6 +5848,8 @@ var DashboardThemeProvider = function DashboardThemeProvider(_ref2) {
     value: contextValue,
     children: [/*#__PURE__*/jsxRuntime.jsx(ThemeBroadcast, {
       ctx: contextValue
+    }), /*#__PURE__*/jsxRuntime.jsx(DashboardCssVarsBridge, {
+      cssVars: contextValue === null || contextValue === void 0 || (_contextValue$current = contextValue.currentTheme) === null || _contextValue$current === void 0 ? void 0 : _contextValue$current.cssVars
     }), children]
   });
 };
@@ -28976,6 +29039,36 @@ var WorkspaceModel = function WorkspaceModel(workspaceItem) {
 function ownKeys$H(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$H(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$H(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$H(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 
+/**
+ * Last-resort family for ANY channel whose value can't be resolved
+ * (unknown name, missing palette entry, missing shade, …). Picked
+ * because it's universally safelist-covered, has every shade from
+ * 50..950, and is visually neutral — so a misconfigured theme
+ * renders "muted" rather than blank/transparent.
+ *
+ * Slack Generic etc. exposed this: when a channel value was missing
+ * or unrecognized, ThemeModel silently emitted `bg-undefined-700`
+ * (not in any safelist) → Tailwind dropped the class → the
+ * dropdown popover rendered transparent. Falling back here means
+ * no token can be "missing" by the time `getStylesForItem` reads it.
+ */
+var FALLBACK_FAMILY = "gray";
+
+/**
+ * Resolve a channel value to a safelist-covered Tailwind family
+ * name. Returns the original value when it's a hex (the caller
+ * handles those via CSS variables) or a recognized palette family;
+ * otherwise returns FALLBACK_FAMILY so the resulting class always
+ * renders.
+ */
+function resolveChannelFamily(channelValue) {
+  if (DashReact.isHexColor(channelValue)) return channelValue;
+  if (typeof channelValue === "string" && channelValue.length > 0 && DashReact.TAILWIND_PALETTE && DashReact.TAILWIND_PALETTE[channelValue]) {
+    return channelValue;
+  }
+  return FALLBACK_FAMILY;
+}
+
 /**
  * getNextLevel
  * Need to generate the levels for tailwind
@@ -28994,6 +29087,11 @@ function invert(shade) {
  * shade. Routes to the arbitrary-value syntax (`bg-[var(--type-shade)]`)
  * when the channel's value is a hex.
  *
+ * Layer 1 fallback (audit follow-up to the Slack Generic bug): if
+ * `channelValue` isn't a hex AND isn't a recognized Tailwind palette
+ * family, fall back to FALLBACK_FAMILY so the emitted class is
+ * always safelist-covered and never resolves to `bg-undefined-700`.
+ *
  * @param {"bg"|"text"|"border"} prefix
  * @param {string} type             channel name (primary | secondary | …)
  * @param {number} shade            tailwind shade (100..950)
@@ -29003,10 +29101,11 @@ function invert(shade) {
 function classFor(prefix, type, shade, channelValue) {
   var hover = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   var h = hover ? "hover:" : "";
-  if (DashReact.isHexColor(channelValue)) {
+  var resolved = resolveChannelFamily(channelValue);
+  if (DashReact.isHexColor(resolved)) {
     return "".concat(h).concat(prefix, "-[var(--").concat(type, "-").concat(shade, ")]");
   }
-  return "".concat(h).concat(prefix, "-").concat(channelValue, "-").concat(shade);
+  return "".concat(h).concat(prefix, "-").concat(resolved, "-").concat(shade);
 }
 
 /**
@@ -29019,8 +29118,10 @@ function classFor(prefix, type, shade, channelValue) {
  * produce a `var(--{type}-{shade})` reference that resolves against
  * the CSS custom properties ThemePreviewProvider writes to :root.
  *
- * Returns null for unknown named-color families or shades — caller
- * falls back to className-only reactivity for that token.
+ * Layer 1 fallback: when the channel value or shade can't be
+ * resolved, fall back to FALLBACK_FAMILY's shade so cssValue is
+ * never null. Pairs with classFor's same fallback to guarantee
+ * every (type, shade) tuple yields a renderable token.
  */
 function cssValueFor(type, shade, channelValue) {
   if (DashReact.isHexColor(channelValue)) {
@@ -29033,12 +29134,17 @@ function cssValueFor(type, shade, channelValue) {
       var _hex = shades[shade] || shades[String(shade)];
       if (_hex) return _hex;
     }
-    return null;
+    return fallbackCssValue(shade);
   }
   var family = DashReact.TAILWIND_PALETTE && DashReact.TAILWIND_PALETTE[channelValue];
-  if (!family) return null;
+  if (!family) return fallbackCssValue(shade);
   var hex = family[shade] || family[String(shade)];
-  return hex || null;
+  return hex || fallbackCssValue(shade);
+}
+function fallbackCssValue(shade) {
+  var fallback = DashReact.TAILWIND_PALETTE && DashReact.TAILWIND_PALETTE[FALLBACK_FAMILY];
+  if (!fallback) return null;
+  return fallback[shade] || fallback[String(shade)] || null;
 }
 function gradientFor(direction, type, fromShade, viaShade, toShade, channelValue) {
   if (DashReact.isHexColor(channelValue)) {
@@ -35223,11 +35329,25 @@ var ChannelEditorModal = function ChannelEditorModal(_ref) {
   var nearest = React.useMemo(function () {
     return nearestSwatch(selectedHex, families);
   }, [selectedHex, families]);
+
+  // Auto-switch the family tab when the underlying selected color
+  // changes (user picked a different channel/shade or the theme
+  // mutated). Track the last hex we synced for so we don't fight
+  // the user's manual tab clicks — without this guard, every
+  // re-render rebuilds `nearest` as a new object reference and the
+  // effect snaps activeFamily back to the family containing the
+  // current color, making it impossible to browse other families.
+  var lastSyncedHexRef = React.useRef(null);
   React.useEffect(function () {
-    if (!isOpen) return;
+    if (!isOpen) {
+      lastSyncedHexRef.current = null;
+      return;
+    }
+    if (lastSyncedHexRef.current === selectedHex) return;
+    lastSyncedHexRef.current = selectedHex;
     if (nearest) setActiveFamily(nearest.family);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isOpen, nearest]);
+  }, [isOpen, selectedHex, nearest]);
   function expandChannel(channelKey) {
     setActiveChannel(channelKey);
     setActiveSlot("base");