ooxml-core 0.20.0 → 0.21.0

package/dist/pptx/ui/index.mjs

@@ -0,0 +1,499 @@
+// src/color/color-primitives.ts
+function clampUnitInterval(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function normalizeHexColor(value, fallback = "#111827") {
+  if (!value || value === "transparent") {
+    return fallback;
+  }
+  const candidate = value.startsWith("#") ? value : `#${value}`;
+  return /^#[0-9A-Fa-f]{6}$/.test(candidate) ? candidate : fallback;
+}
+function hexToRgbChannels(color) {
+  const normalized = color.replace("#", "");
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
+    return null;
+  }
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function percentDivisorFor(text) {
+  return text.endsWith("%") ? 100 : 1e5;
+}
+function parseOoxmlPercent(value) {
+  const text = String(value ?? "").trim();
+  const divisor = percentDivisorFor(text);
+  const magnitude = Number.parseFloat(divisor === 100 ? text.slice(0, -1) : text);
+  if (!Number.isFinite(magnitude)) {
+    return void 0;
+  }
+  return magnitude / divisor;
+}
+function parseDrawingPercent(value) {
+  const parsed = parseOoxmlPercent(value);
+  return parsed === void 0 ? void 0 : clampUnitInterval(parsed);
+}
+function toHex(value) {
+  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+function rgbToHsl(r, g, b) {
+  const rN = r / 255;
+  const gN = g / 255;
+  const bN = b / 255;
+  const cMax = Math.max(rN, gN, bN);
+  const cMin = Math.min(rN, gN, bN);
+  const delta = cMax - cMin;
+  const l = (cMax + cMin) / 2;
+  let s = 0;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+  }
+  let h = 0;
+  if (delta !== 0) {
+    if (cMax === rN) {
+      h = 60 * ((gN - bN) / delta % 6);
+    } else if (cMax === gN) {
+      h = 60 * ((bN - rN) / delta + 2);
+    } else {
+      h = 60 * ((rN - gN) / delta + 4);
+    }
+  }
+  if (h < 0) {
+    h += 360;
+  }
+  return { h, s: clampUnitInterval(s), l: clampUnitInterval(l) };
+}
+function hslToRgb(h, s, l) {
+  const sC = clampUnitInterval(s);
+  const lC = clampUnitInterval(l);
+  const hN = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * lC - 1)) * sC;
+  const x = c * (1 - Math.abs(hN / 60 % 2 - 1));
+  const m = lC - c / 2;
+  let rP = 0;
+  let gP = 0;
+  let bP = 0;
+  if (hN < 60) {
+    rP = c;
+    gP = x;
+    bP = 0;
+  } else if (hN < 120) {
+    rP = x;
+    gP = c;
+    bP = 0;
+  } else if (hN < 180) {
+    rP = 0;
+    gP = c;
+    bP = x;
+  } else if (hN < 240) {
+    rP = 0;
+    gP = x;
+    bP = c;
+  } else if (hN < 300) {
+    rP = x;
+    gP = 0;
+    bP = c;
+  } else {
+    rP = c;
+    gP = 0;
+    bP = x;
+  }
+  return {
+    r: Math.round((rP + m) * 255),
+    g: Math.round((gP + m) * 255),
+    b: Math.round((bP + m) * 255)
+  };
+}
+function parseDrawingFraction(value) {
+  return parseOoxmlPercent(value);
+}
+function parseDrawingHueDegrees(value) {
+  const parsed = Number.parseFloat(String(value ?? "").trim());
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed / 6e4;
+}
+
+// src/color/color-linear.ts
+function srgb255ToLinear(channel) {
+  const c = clampUnitInterval(channel / 255);
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb255(linear) {
+  const c = clampUnitInterval(linear);
+  return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
+}
+
+// src/pptx/core/color/color-transforms.ts
+function applyDrawingColorTransforms(baseColor, colorNode) {
+  const rgb = hexToRgbChannels(baseColor);
+  if (!rgb) {
+    return baseColor;
+  }
+  let r = rgb.r;
+  let g = rgb.g;
+  let b = rgb.b;
+  const getVal = (key) => colorNode[key]?.["@_val"];
+  if (colorNode["a:gamma"] !== void 0) {
+    const out = applySrgbGammaEncode(r, g, b);
+    r = out.r;
+    g = out.g;
+    b = out.b;
+  }
+  if (colorNode["a:invGamma"] !== void 0) {
+    const out = applySrgbGammaDecode(r, g, b);
+    r = out.r;
+    g = out.g;
+    b = out.b;
+  }
+  if (colorNode["a:comp"] !== void 0) {
+    const hsl = rgbToHsl(r, g, b);
+    hsl.h = (hsl.h + 180) % 360;
+    const out = hslToRgb(hsl.h, hsl.s, hsl.l);
+    r = out.r;
+    g = out.g;
+    b = out.b;
+  }
+  if (colorNode["a:inv"] !== void 0) {
+    r = 255 - r;
+    g = 255 - g;
+    b = 255 - b;
+  }
+  if (colorNode["a:gray"] !== void 0) {
+    const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+    r = gray;
+    g = gray;
+    b = gray;
+  }
+  const shade = parseDrawingPercent(getVal("a:shade"));
+  if (shade !== void 0) {
+    r = linearToSrgb255(srgb255ToLinear(r) * shade);
+    g = linearToSrgb255(srgb255ToLinear(g) * shade);
+    b = linearToSrgb255(srgb255ToLinear(b) * shade);
+  }
+  const tint = parseDrawingPercent(getVal("a:tint"));
+  if (tint !== void 0) {
+    r = linearToSrgb255(1 - (1 - srgb255ToLinear(r)) * tint);
+    g = linearToSrgb255(1 - (1 - srgb255ToLinear(g)) * tint);
+    b = linearToSrgb255(1 - (1 - srgb255ToLinear(b)) * tint);
+  }
+  const hslKeys = [
+    "a:hue",
+    "a:hueMod",
+    "a:hueOff",
+    "a:sat",
+    "a:satMod",
+    "a:satOff",
+    "a:lum",
+    "a:lumMod",
+    "a:lumOff"
+  ];
+  const hasHsl = hslKeys.some((k) => colorNode[k] !== void 0);
+  if (hasHsl) {
+    const hsl = rgbToHsl(r, g, b);
+    const hueAbs = parseDrawingHueDegrees(getVal("a:hue"));
+    if (hueAbs !== void 0) {
+      hsl.h = (hueAbs % 360 + 360) % 360;
+    }
+    const hueMod = parseDrawingFraction(getVal("a:hueMod"));
+    if (hueMod !== void 0) {
+      hsl.h = (hsl.h * hueMod % 360 + 360) % 360;
+    }
+    const hueOff = parseDrawingHueDegrees(getVal("a:hueOff"));
+    if (hueOff !== void 0) {
+      hsl.h = ((hsl.h + hueOff) % 360 + 360) % 360;
+    }
+    const satAbs = parseDrawingFraction(getVal("a:sat"));
+    if (satAbs !== void 0) {
+      hsl.s = clampUnitInterval(satAbs);
+    }
+    const satMod = parseDrawingFraction(getVal("a:satMod"));
+    if (satMod !== void 0) {
+      hsl.s = clampUnitInterval(hsl.s * satMod);
+    }
+    const satOff = parseDrawingFraction(getVal("a:satOff"));
+    if (satOff !== void 0) {
+      hsl.s = clampUnitInterval(hsl.s + satOff);
+    }
+    const lumAbs = parseDrawingFraction(getVal("a:lum"));
+    if (lumAbs !== void 0) {
+      hsl.l = clampUnitInterval(lumAbs);
+    }
+    const lumMod = parseDrawingFraction(getVal("a:lumMod"));
+    if (lumMod !== void 0) {
+      hsl.l = clampUnitInterval(hsl.l * lumMod);
+    }
+    const lumOff = parseDrawingFraction(getVal("a:lumOff"));
+    if (lumOff !== void 0) {
+      hsl.l = clampUnitInterval(hsl.l + lumOff);
+    }
+    const out = hslToRgb(hsl.h, hsl.s, hsl.l);
+    r = out.r;
+    g = out.g;
+    b = out.b;
+  }
+  const redAbs = parseDrawingFraction(getVal("a:red"));
+  if (redAbs !== void 0) {
+    r = Math.round(clampUnitInterval(redAbs) * 255);
+  }
+  const redMod = parseDrawingFraction(getVal("a:redMod"));
+  if (redMod !== void 0) {
+    r = Math.min(255, Math.max(0, Math.round(r * redMod)));
+  }
+  const redOff = parseDrawingFraction(getVal("a:redOff"));
+  if (redOff !== void 0) {
+    r = Math.min(255, Math.max(0, Math.round(r + 255 * redOff)));
+  }
+  const greenAbs = parseDrawingFraction(getVal("a:green"));
+  if (greenAbs !== void 0) {
+    g = Math.round(clampUnitInterval(greenAbs) * 255);
+  }
+  const greenMod = parseDrawingFraction(getVal("a:greenMod"));
+  if (greenMod !== void 0) {
+    g = Math.min(255, Math.max(0, Math.round(g * greenMod)));
+  }
+  const greenOff = parseDrawingFraction(getVal("a:greenOff"));
+  if (greenOff !== void 0) {
+    g = Math.min(255, Math.max(0, Math.round(g + 255 * greenOff)));
+  }
+  const blueAbs = parseDrawingFraction(getVal("a:blue"));
+  if (blueAbs !== void 0) {
+    b = Math.round(clampUnitInterval(blueAbs) * 255);
+  }
+  const blueMod = parseDrawingFraction(getVal("a:blueMod"));
+  if (blueMod !== void 0) {
+    b = Math.min(255, Math.max(0, Math.round(b * blueMod)));
+  }
+  const blueOff = parseDrawingFraction(getVal("a:blueOff"));
+  if (blueOff !== void 0) {
+    b = Math.min(255, Math.max(0, Math.round(b + 255 * blueOff)));
+  }
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function srgbEncodeChannel(channel) {
+  const linear = Math.min(1, Math.max(0, channel / 255));
+  const companded = linear <= 31308e-7 ? 12.92 * linear : 1.055 * linear ** (1 / 2.4) - 0.055;
+  return Math.min(255, Math.max(0, Math.round(companded * 255)));
+}
+function srgbDecodeChannel(channel) {
+  const companded = Math.min(1, Math.max(0, channel / 255));
+  const linear = companded <= 0.04045 ? companded / 12.92 : ((companded + 0.055) / 1.055) ** 2.4;
+  return Math.min(255, Math.max(0, Math.round(linear * 255)));
+}
+function applySrgbGammaEncode(r, g, b) {
+  return { r: srgbEncodeChannel(r), g: srgbEncodeChannel(g), b: srgbEncodeChannel(b) };
+}
+function applySrgbGammaDecode(r, g, b) {
+  return { r: srgbDecodeChannel(r), g: srgbDecodeChannel(g), b: srgbDecodeChannel(b) };
+}
+
+// src/pptx/core/color/theme-color-ref.ts
+var DEFAULT_ALIASES = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2"
+};
+function percentVal(fraction) {
+  return String(Math.round(fraction * 1e5));
+}
+function themeColorRefToXml(ref) {
+  const node = { "@_val": ref.scheme };
+  if (ref.tint !== void 0) {
+    node["a:tint"] = { "@_val": percentVal(ref.tint) };
+  }
+  if (ref.shade !== void 0) {
+    node["a:shade"] = { "@_val": percentVal(ref.shade) };
+  }
+  if (ref.lumMod !== void 0) {
+    node["a:lumMod"] = { "@_val": percentVal(ref.lumMod) };
+  }
+  if (ref.lumOff !== void 0) {
+    node["a:lumOff"] = { "@_val": percentVal(ref.lumOff) };
+  }
+  if (ref.alpha !== void 0) {
+    node["a:alpha"] = { "@_val": percentVal(ref.alpha) };
+  }
+  return node;
+}
+function resolveThemeColorRef(ref, themeColorMap) {
+  if (!themeColorMap) {
+    return void 0;
+  }
+  const base = themeColorMap[ref.scheme] ?? themeColorMap[DEFAULT_ALIASES[ref.scheme] ?? ""];
+  if (!base) {
+    return void 0;
+  }
+  const node = themeColorRefToXml(ref);
+  delete node["a:alpha"];
+  return normalizeHexColor(
+    applyDrawingColorTransforms(normalizeHexColor(base), node)
+  ).toLowerCase();
+}
+
+// src/pptx/core/types/color-ref.ts
+var THEME_COLOR_PALETTE_COLUMNS = [
+  "bg1",
+  "tx1",
+  "bg2",
+  "tx2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6"
+];
+
+// src/pptx/ui/theme-color-swatches.ts
+var COLUMN_LABELS = {
+  bg1: "Background 1",
+  tx1: "Text 1",
+  bg2: "Background 2",
+  tx2: "Text 2",
+  accent1: "Accent 1",
+  accent2: "Accent 2",
+  accent3: "Accent 3",
+  accent4: "Accent 4",
+  accent5: "Accent 5",
+  accent6: "Accent 6",
+  dk1: "Text 1",
+  lt1: "Background 1",
+  dk2: "Text 2",
+  lt2: "Background 2",
+  hlink: "Hyperlink",
+  folHlink: "Followed Hyperlink"
+};
+function lighter(percent) {
+  return { kind: "lighter", percent };
+}
+function darker(percent) {
+  return { kind: "darker", percent };
+}
+function themeColorVariantsForLuminance(l) {
+  if (l < 0.05) {
+    return [lighter(50), lighter(35), lighter(25), lighter(15), lighter(5)];
+  }
+  if (l < 0.25) {
+    return [lighter(90), lighter(75), lighter(50), lighter(25), lighter(10)];
+  }
+  if (l < 0.75) {
+    return [lighter(80), lighter(60), lighter(40), darker(25), darker(50)];
+  }
+  if (l < 0.95) {
+    return [darker(10), darker(25), darker(50), darker(75), darker(90)];
+  }
+  return [darker(5), darker(15), darker(25), darker(35), darker(50)];
+}
+function themeColorVariantToRef(scheme, variant) {
+  const fraction = variant.percent / 100;
+  const lumMod = Math.round((1 - fraction) * 1e5) / 1e5;
+  return variant.kind === "lighter" ? { scheme, lumMod, lumOff: fraction } : { scheme, lumMod };
+}
+function describeThemeColorSwatch(ref, variant) {
+  const column = COLUMN_LABELS[ref.scheme] ?? ref.scheme;
+  if (!variant) {
+    return column;
+  }
+  const word = variant.kind === "lighter" ? "Lighter" : "Darker";
+  return `${column}, ${word} ${variant.percent}%`;
+}
+function themeColorVariantOfRef(ref) {
+  if (ref.lumMod === void 0 || ref.tint !== void 0 || ref.shade !== void 0) {
+    return void 0;
+  }
+  const percent = Math.round((1 - ref.lumMod) * 100);
+  if (ref.lumOff !== void 0) {
+    return Math.round(ref.lumOff * 100) === percent ? lighter(percent) : void 0;
+  }
+  return darker(percent);
+}
+function buildThemeColorSwatchGrid(themeColorMap) {
+  if (!themeColorMap) {
+    return [];
+  }
+  const columns = [];
+  for (const scheme of THEME_COLOR_PALETTE_COLUMNS) {
+    const baseRef = { scheme };
+    const baseHex = resolveThemeColorRef(baseRef, themeColorMap);
+    const rgb = baseHex ? hexToRgbChannels(baseHex) : null;
+    if (!baseHex || !rgb) {
+      continue;
+    }
+    const { l } = rgbToHsl(rgb.r, rgb.g, rgb.b);
+    const variants = [];
+    for (const variant of themeColorVariantsForLuminance(l)) {
+      const ref = themeColorVariantToRef(scheme, variant);
+      const hex = resolveThemeColorRef(ref, themeColorMap);
+      if (hex) {
+        variants.push({ ref, hex, label: describeThemeColorSwatch(ref, variant), variant });
+      }
+    }
+    columns.push({
+      scheme,
+      base: {
+        ref: baseRef,
+        hex: baseHex,
+        label: describeThemeColorSwatch(baseRef, void 0),
+        variant: void 0
+      },
+      variants
+    });
+  }
+  return columns;
+}
+
+// src/pptx/ui/theme-color-picker-state.ts
+function themeColorRefsEqual(a, b) {
+  if (!a || !b) {
+    return a === b;
+  }
+  return a.scheme === b.scheme && a.lumMod === b.lumMod && a.lumOff === b.lumOff && a.tint === b.tint && a.shade === b.shade;
+}
+function findSelectedThemeSwatch(columns, ref, hex) {
+  if (ref) {
+    for (const column of columns) {
+      const swatches = [column.base, ...column.variants];
+      const match = swatches.find((swatch) => themeColorRefsEqual(swatch.ref, ref));
+      if (match) {
+        return match;
+      }
+    }
+    return void 0;
+  }
+  if (!hex) {
+    return void 0;
+  }
+  const normalized = hex.trim().toLowerCase();
+  for (const column of columns) {
+    const swatches = [column.base, ...column.variants];
+    const match = swatches.find((swatch) => swatch.hex.toLowerCase() === normalized);
+    if (match) {
+      return match;
+    }
+  }
+  return void 0;
+}
+function themeSwatchCommit(swatch) {
+  return { hex: swatch.hex, ref: swatch.ref };
+}
+function customColorCommit(hex) {
+  return { hex, ref: void 0 };
+}
+function themeColorSwatchRows(columns) {
+  if (columns.length === 0) {
+    return [];
+  }
+  const variantRowCount = Math.max(...columns.map((column) => column.variants.length));
+  const rows = [columns.map((column) => column.base)];
+  for (let i = 0; i < variantRowCount; i++) {
+    rows.push(columns.map((column) => column.variants[i]));
+  }
+  return rows;
+}
+
+export { buildThemeColorSwatchGrid, customColorCommit, describeThemeColorSwatch, findSelectedThemeSwatch, themeColorRefsEqual, themeColorSwatchRows, themeColorVariantOfRef, themeColorVariantToRef, themeColorVariantsForLuminance, themeSwatchCommit };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ooxml-core",
-	"version": "0.20.0",
+	"version": "0.21.0",
 	"description": "Shared OOXML logic for the Word, PowerPoint and Excel viewers: everything except the UI",
 	"keywords": [
 		"charts",
@@ -31,7 +31,13 @@
 		"pptx": "./dist/pptx/cli/index.mjs"
 	},
 	"workspaces": [
-		"packages/*"
+		"packages/*",
+		"viewers/*",
+		"viewers/*/packages/*",
+		"viewers/*/mcp",
+		"viewers/*/docs",
+		"viewers/teams/server",
+		"viewers/teams/demos/*"
 	],
 	"files": [
 		"dist",
@@ -191,6 +197,11 @@
 			"import": "./dist/pptx/automation/index.mjs",
 			"require": "./dist/pptx/automation/index.cjs"
 		},
+		"./pptx/ui": {
+			"types": "./dist/pptx/ui/index.d.ts",
+			"import": "./dist/pptx/ui/index.mjs",
+			"require": "./dist/pptx/ui/index.cjs"
+		},
 		"./docx/ui": {
 			"types": "./dist/docx/ui/index.d.ts",
 			"import": "./dist/docx/ui/index.mjs",
@@ -224,8 +235,8 @@
 		"release:publish": "node scripts/publish-released.mjs",
 		"changelog:unreleased": "bunx git-cliff --config cliff.toml --tag-pattern \"^ooxml-core@\" --unreleased",
 		"test:mcp": "node --test mcp/test/*.test.js",
-		"lint": "oxlint",
-		"lint:fix": "oxlint --fix"
+		"lint": "oxlint --ignore-pattern=viewers/",
+		"lint:fix": "oxlint --fix --ignore-pattern=viewers/"
 	},
 	"dependencies": {
 		"@xmldom/xmldom": "^0.9.12",