@wix/himalaya-cli 0.1318.0 → 0.1319.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/theme.mjs

@@ -0,0 +1,189 @@
+// ../../core/sdk/dispatch/src/index.ts
+function dispatch(handlerId, params, _options) {
+  const himalaya = globalThis.himalaya;
+  if (!himalaya) {
+    return Promise.reject(
+      new Error("@himalaya/dispatch: called outside a Himalaya runtime. This bundle must run inside a JSWorker (Tier 5).")
+    );
+  }
+  const stringParams = {};
+  if (params) {
+    for (const [k, v] of Object.entries(params)) stringParams[k] = String(v);
+  }
+  return himalaya.dispatch(handlerId, stringParams);
+}
+
+// ../../core/ts/src/brand-color-math.ts
+function channel(hex, offset) {
+  return Number.parseInt(hex.slice(offset, offset + 2), 16);
+}
+function toHex(r, g, b) {
+  return `#${[r, g, b].map((value) => Math.round(value).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+}
+function mix(color, background, colorWeight) {
+  const values = [1, 3, 5].map((offset) => channel(color, offset) * colorWeight + channel(background, offset) * (1 - colorWeight));
+  return toHex(values[0], values[1], values[2]);
+}
+function relativeLuminance(color) {
+  const linear = [1, 3, 5].map((offset) => {
+    const value = channel(color, offset) / 255;
+    return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2];
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function lstar(color) {
+  const y = relativeLuminance(color);
+  return y <= 8856e-6 ? y * 903.3 : 116 * Math.cbrt(y) - 16;
+}
+var ACCENT_SURFACE_MIN_DELTA = 1.08;
+var ACCENT_SURFACE_LIGHT_WEIGHT = 0.12;
+function deriveAccentSurface(accent, surface, weight) {
+  const tint = mix(accent, surface, weight);
+  if (contrastRatio(tint, surface) >= ACCENT_SURFACE_MIN_DELTA) return tint;
+  const away = relativeLuminance(surface) < 0.5 ? "#FFFFFF" : "#000000";
+  for (let w = 0.02; w <= 0.5; w += 0.02) {
+    const candidate = mix(away, surface, w);
+    if (contrastRatio(candidate, surface) >= ACCENT_SURFACE_MIN_DELTA) return candidate;
+  }
+  return tint;
+}
+var SECONDARY_SHADE_WEIGHT = 0.72;
+var SECONDARY_MIN_LSTAR = 22;
+function deriveSecondaryAccent(primary) {
+  const shade = mix(primary, "#000000", SECONDARY_SHADE_WEIGHT);
+  if (lstar(shade) >= SECONDARY_MIN_LSTAR) return shade;
+  return mix(primary, "#FFFFFF", SECONDARY_SHADE_WEIGHT);
+}
+function textOn(color) {
+  const luminance = relativeLuminance(color);
+  const whiteContrast = 1.05 / (luminance + 0.05);
+  const blackContrast = (luminance + 0.05) / 0.05;
+  return whiteContrast >= blackContrast ? "#FFFFFF" : "#000000";
+}
+var DARK_ARM_MIN_LIFT = 0.08;
+var DARK_ARM_TARGET_CONTRAST = 3.4;
+var DARK_ARM_FLOOR_CONTRAST = 3;
+var DARK_ARM_LSTAR_CAP = 80;
+function tuneDarkAccent(brand, darkSurface, lightSurface) {
+  const kitInherentlyDark = lstar(lightSurface) < 50;
+  if (kitInherentlyDark && contrastRatio(brand, darkSurface) >= DARK_ARM_TARGET_CONTRAST && lstar(brand) <= DARK_ARM_LSTAR_CAP) {
+    return brand;
+  }
+  let lift = DARK_ARM_MIN_LIFT;
+  let candidate = mix(brand, "#FFFFFF", 1 - lift);
+  while (contrastRatio(candidate, darkSurface) < DARK_ARM_TARGET_CONTRAST && lift < 0.6) {
+    lift += 0.04;
+    candidate = mix(brand, "#FFFFFF", 1 - lift);
+  }
+  while (lstar(candidate) > DARK_ARM_LSTAR_CAP) {
+    const darker = mix(candidate, "#000000", 0.94);
+    if (contrastRatio(darker, darkSurface) < DARK_ARM_FLOOR_CONTRAST) break;
+    candidate = darker;
+  }
+  return candidate;
+}
+function textOnArm(accent) {
+  return contrastRatio("#FFFFFF", accent) >= 4.5 ? "#FFFFFF" : textOn(accent);
+}
+var HIGH_CONTRAST_TARGET = 8.5;
+function tuneHighContrastAccent(brand, surface) {
+  const towards = relativeLuminance(surface) < 0.5 ? "#FFFFFF" : "#000000";
+  let candidate = brand;
+  for (let lift = 0; lift <= 0.9 && contrastRatio(candidate, surface) < HIGH_CONTRAST_TARGET; lift += 0.04) {
+    candidate = mix(brand, towards, 1 - lift);
+  }
+  return candidate;
+}
+var ACCENT_TEXT_MIN_CONTRAST = 4.5;
+var MID_GREY_LUMINANCE = 0.179;
+function deriveAccentText(accent, surfaces) {
+  const all = (typeof surfaces === "string" ? [surfaces] : [...surfaces]).map((s) => s.slice(0, 7));
+  const page = all[0];
+  const worst = (color) => Math.min(...all.map((s) => contrastRatio(color, s)));
+  const opaque = accent.length === 9 ? mix(accent.slice(0, 7), page, channel(accent, 7) / 255) : accent;
+  if (worst(opaque) >= ACCENT_TEXT_MIN_CONTRAST) return opaque;
+  const pole = worst("#FFFFFF") >= worst("#000000") ? "#FFFFFF" : "#000000";
+  for (let step = 1; step <= 100; step++) {
+    const candidate = mix(pole, opaque, step / 100);
+    if (worst(candidate) >= ACCENT_TEXT_MIN_CONTRAST) return candidate;
+  }
+  if (all.length > 1) {
+    const side = (hex) => relativeLuminance(hex) > MID_GREY_LUMINANCE;
+    const sameSide = all.filter((s) => side(s) === side(page));
+    return deriveAccentText(accent, sameSide.length < all.length ? sameSide : [page]);
+  }
+  return pole;
+}
+function deriveAccentFamily(primary, secondary, surfaces, textSurfaces = {}) {
+  const primaryDark = tuneDarkAccent(primary, surfaces.dark, surfaces.light);
+  const secondaryDark = tuneDarkAccent(secondary, surfaces.dark, surfaces.light);
+  const primaryHigh = tuneHighContrastAccent(primary, surfaces.highContrast);
+  const secondaryHigh = tuneHighContrastAccent(secondary, surfaces.highContrast);
+  return {
+    accentPrimary: { light: primary, dark: primaryDark, highContrast: primaryHigh },
+    accentSecondary: { light: secondary, dark: secondaryDark, highContrast: secondaryHigh },
+    accentSurface: {
+      light: deriveAccentSurface(primary, surfaces.light, ACCENT_SURFACE_LIGHT_WEIGHT),
+      dark: deriveAccentSurface(primaryDark, surfaces.dark, 0.24),
+      highContrast: deriveAccentSurface(primaryHigh, surfaces.highContrast, 0.24)
+    },
+    textOnAccent: {
+      light: textOnArm(primary),
+      dark: textOnArm(primaryDark),
+      highContrast: textOn(primaryHigh)
+    },
+    accentText: {
+      light: deriveAccentText(primary, [surfaces.light, ...textSurfaces.light ?? []]),
+      dark: deriveAccentText(primaryDark, [surfaces.dark, ...textSurfaces.dark ?? []]),
+      highContrast: deriveAccentText(primaryHigh, [surfaces.highContrast, ...textSurfaces.highContrast ?? []])
+    }
+  };
+}
+
+// ../../core/sdk/theme/src/index.ts
+var HEX = /^#[0-9A-Fa-f]{6}$/;
+function decode(v) {
+  if (typeof v === "string") {
+    try {
+      return JSON.parse(v);
+    } catch {
+      return null;
+    }
+  }
+  return v && typeof v === "object" ? v : null;
+}
+async function applyBrand(brand) {
+  const primary = brand?.primaryColor;
+  const secondaryIn = brand?.secondaryColor;
+  if (typeof primary !== "string" || !HEX.test(primary)) return { applied: false, reason: "invalid_color" };
+  if (secondaryIn !== void 0 && (typeof secondaryIn !== "string" || !HEX.test(secondaryIn))) {
+    return { applied: false, reason: "invalid_color" };
+  }
+  const s = decode(await dispatch("capability.theme.surfaces")) ?? {};
+  const sp = s.surfacePrimary ?? {};
+  const surfaces = {
+    light: sp.light ?? "#FFFFFF",
+    dark: sp.dark ?? "#0D1117",
+    highContrast: sp.highContrast ?? "#000000"
+  };
+  const family = deriveAccentFamily(primary, secondaryIn ?? deriveSecondaryAccent(primary), surfaces, s.textSurfaces ?? {});
+  const params = { colors: JSON.stringify(family) };
+  if (s.hasGlow) params.glow = primary;
+  const r = decode(await dispatch("capability.theme.applyOverlay", params));
+  return r && typeof r.applied === "boolean" ? r : { applied: false, reason: "no_answer" };
+}
+async function clearBrand() {
+  await dispatch("capability.theme.clearOverlay");
+}
+var version = 1;
+export {
+  applyBrand,
+  clearBrand,
+  version
+};
+//# sourceMappingURL=theme.mjs.map

package/dist/authoring-runtime/node_modules/@wix/himalaya/package.json

@@ -82,6 +82,10 @@
       "types": "./dist/_types/core/ts/src/index.d.ts",
       "import": "./dist/core.mjs"
     },
+    "./core/brand-color-math": {
+      "types": "./dist/_types/core/ts/src/brand-color-math.d.ts",
+      "import": "./dist/core/brand-color-math.mjs"
+    },
     "./core/validation": {
       "types": "./dist/_types/core/ts/src/validation.d.ts",
       "import": "./dist/core/validation.mjs"
@@ -234,6 +238,10 @@
       "types": "./dist/_types/stdlib/telemetry/console/src/index.d.ts",
       "import": "./dist/telemetry-console.mjs"
     },
+    "./theme": {
+      "types": "./dist/_types/core/sdk/theme/src/index.d.ts",
+      "import": "./dist/theme.mjs"
+    },
     "./time": {
       "types": "./dist/_types/core/sdk/time/src/index.d.ts",
       "import": "./dist/time.mjs"