@openpresentation/opf-pptx 0.13.1 → 0.14.0

package/dist/chart-highlight.js

@@ -0,0 +1,113 @@
+// FA-14: chart emphasis (`chart.highlight`) in the PPTX export.
+//
+// Core owns what is highlighted (`resolveChartOptions(...).highlight`, `chartHighlightMarks`) and the two colours
+// (`chartHighlightColors`); the preview (opf-render) calls the same functions, so both engines colour the same marks the same way.
+// This module writes them natively into the generated classic chart part:
+//
+//   column, bar, area, scatter, radar   the series colour (c:ser/c:spPr, and c:marker/c:spPr) of every series, accent when the
+//                                       series is named, muted otherwise; clustered and stacked alike;
+//   column and bar, category highlight  one c:dPt (idx, invertIfNegative, bubble3D, spPr) per point whose colour differs from its
+//                                       series' colour;
+//   line                                the series line and marker colour, and for a category highlight one c:dPt with a circular
+//                                       c:marker per highlighted point (a line without markers shows markers only there);
+//   pie, doughnut                       the fill of the c:dPt of every slice, accent for a highlighted category, muted otherwise.
+//
+// The highlight colour is the deck primary: `a:schemeClr val="accent1"` when the deck theme holds exactly that colour (so a theme
+// edit in PowerPoint recolours it), the literal sRGB otherwise (a primary that needed a contrast adjustment against the chart panel).
+// The muted colour is a mix of the panel and the text colour, which no single scheme colour with lumMod/lumOff reproduces, so it is
+// an sRGB literal. A chart without a highlight never reaches this module, so its parts are unchanged.
+import {chartHighlightColors, chartHighlightMarks} from '@openpresentation/opf/composition';
+
+const srgb = hex => `<a:srgbClr val="${String(hex).replace(/^#/, '').toUpperCase()}"/>`;
+
+/**
+ * The highlight of an exported chart: `{kind, marks, accent, muted, seriesFills, pointFills}` or undefined.
+ * `options` is core's `resolveChartOptions` result, `data` the resolved chart data (`columns`, `hasX`, `rows`), `kind` the chart's option
+ * kind, `panelFill` and `labelColor` the chart panel and text colours (as the preview uses them), `primary` the deck primary and
+ * `scheme` its scheme value when the theme holds it exactly (core's colour for the accent is compared with it here).
+ *
+ * Colours are `{hex, xml}`: `hex` (RRGGBB) feeds the data label contrast, `xml` is the DrawingML colour element.
+ */
+export function chartHighlightPlan({options, data, kind, panelFill, labelColor, primary, schemeFor}) {
+  if (!options?.highlight || !data) return undefined;
+  const marks = chartHighlightMarks(options.highlight, data);
+  if (!marks) return undefined;
+  const colors = chartHighlightColors(panelFill, primary, `#${labelColor}`);
+  const accentHex = colors.accent.replace(/^#/, '').toUpperCase();
+  const scheme = schemeFor?.(colors.accent);
+  const accent = {hex: accentHex, xml: scheme ? `<a:schemeClr val="${scheme}"/>` : srgb(accentHex)};
+  const muted = {hex: colors.muted.replace(/^#/, '').toUpperCase(), xml: srgb(colors.muted)};
+  const seriesColor = index => marks.series[index] ? accent : muted;
+  const markColor = (series, row) => marks.series[series] || marks.categories[row] ? accent : muted;
+  const circular = kind === 'pie' || kind === 'doughnut';
+  return {
+    kind, marks, accent, muted, seriesColor, markColor, circular,
+    // The series colours (data label contrast of a series-level label) and, where marks differ within a series, the point colours.
+    seriesFills: Array.from({length: marks.series.length}, (_, index) => seriesColor(index).hex),
+    pointFills: series => circular ? marks.categories.map(row => (row ? accent : muted).hex)
+      : kind === 'bar' && marks.categories.some(Boolean) ? marks.categories.map((_, row) => markColor(series, row).hex) : undefined,
+  };
+}
+
+const fill = color => `<a:solidFill>${color.xml}</a:solidFill>`;
+const recolor = (block, color) => block.replace(/<a:solidFill>[\s\S]*?<\/a:solidFill>/g, fill(color));
+
+// The series' own c:spPr: the first one, which precedes c:marker, c:dPt, c:dLbls and the data references in CT_*Ser.
+function seriesProperties(ser) {
+  const at = ser.indexOf('<c:spPr>');
+  const limit = ['<c:marker>', '<c:dPt>', '<c:dLbls>', '<c:cat>', '<c:xVal>', '<c:val>'].map(tag => ser.indexOf(tag)).filter(index => index >= 0);
+  if (at < 0 || limit.some(index => index < at)) throw new Error('A generated chart series carries no series properties.');
+  return at;
+}
+
+function recolorSeries(ser, color) {
+  const at = seriesProperties(ser);
+  const end = ser.indexOf('</c:spPr>', at) + '</c:spPr>'.length;
+  let out = ser.slice(0, at) + recolor(ser.slice(at, end), color) + ser.slice(end);
+  out = out.replace(/<c:marker>[\s\S]*?<\/c:marker>/, marker => recolor(marker, color));
+  return out;
+}
+
+const barPoint = (row, color) => `<c:dPt><c:idx val="${row}"/><c:invertIfNegative val="0"/><c:bubble3D val="0"/><c:spPr>${fill(color)}<a:effectLst/></c:spPr></c:dPt>`;
+const linePoint = (row, color) => `<c:dPt><c:idx val="${row}"/><c:marker><c:symbol val="circle"/><c:size val="6"/><c:spPr>${fill(color)}<a:ln w="9525" cap="flat">${fill(color)}<a:prstDash val="solid"/><a:round/></a:ln><a:effectLst/></c:spPr></c:marker><c:bubble3D val="0"/></c:dPt>`;
+
+/**
+ * Rewrite the series of a generated classic chart for the highlight plan (see the module comment). `xml` is the chart part text.
+ * Series are matched to the plan by position, which is how core orders them (the columns after the category, and after the X
+ * column of a scatter chart): the generated part has one c:ser per plotted series, in that order.
+ */
+export function applyChartHighlight(xml, plan) {
+  const {kind, marks, accent, muted} = plan;
+  let seriesIndex = 0;
+  return xml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => {
+    const index = seriesIndex++;
+    if (plan.circular) {
+      return ser.replace(/<c:dPt>([\s\S]*?)<\/c:dPt>/g, (point, inner) => {
+        const row = Number(/<c:idx val="(\d+)"\/>/.exec(inner)?.[1]);
+        return marks.categories[row] === undefined ? point : recolor(point, marks.categories[row] ? accent : muted);
+      });
+    }
+    if (index >= marks.series.length) return ser;
+    let out = recolorSeries(ser, plan.seriesColor(index));
+    if (kind === 'bar' && marks.categories.some(Boolean)) {
+      const points = marks.categories.flatMap((_, row) => plan.markColor(index, row) === plan.seriesColor(index) ? [] : [barPoint(row, plan.markColor(index, row))]).join('');
+      if (points) out = out.replace(/<c:dLbls>|<c:cat>/, anchor => `${points}${anchor}`);
+    } else if (kind === 'line' && marks.categories.some(Boolean)) {
+      // A line shows a marker at every highlighted category: on a line with markers only where the series colour is not already the
+      // accent, on a line without markers (symbol none) at every highlighted point.
+      const hasMarkers = !/<c:marker>\s*<c:symbol val="none"\/>/.test(out);
+      const points = marks.categories.flatMap((highlighted, row) => highlighted && (!hasMarkers || plan.markColor(index, row) !== plan.seriesColor(index)) ? [linePoint(row, plan.markColor(index, row))] : []).join('');
+      if (points) {
+        // CT_LineSer: marker, dPt, dLbls, trendline, errBars, cat. The generator writes c:dLbls before c:marker; it moves behind the points.
+        const labels = /<c:dLbls>[\s\S]*?<\/c:dLbls>/.exec(out);
+        const markerEnd = out.indexOf('</c:marker>') + '</c:marker>'.length;
+        if (labels && labels.index < markerEnd) {
+          out = out.slice(0, labels.index) + out.slice(labels.index + labels[0].length);
+          const end = out.indexOf('</c:marker>') + '</c:marker>'.length;
+          out = `${out.slice(0, end)}${points}${labels[0]}${out.slice(end)}`;
+        } else out = `${out.slice(0, markerEnd)}${points}${out.slice(markerEnd)}`;
+      }
+    }
+    return out;
+  });
+}

package/dist/chart-options.js

@@ -8,17 +8,14 @@
 //   chartex charts   cx:axis/cx:title, cx:legend pos and cx:dataLabels pos (see chartex.js, which calls the helpers here).
 //
 // A chart that carries none of the three fields resolves to `active: false`; nothing below runs and its parts are unchanged.
-import * as opfCore from '@openpresentation/opf';
+import {chartOptionSupport, chartOptionTarget, resolveChartOptions, textColorForFill} from '@openpresentation/opf/composition';
 
 const INACTIVE = Object.freeze({active: false, axisTitles: {}, diagnostics: []});
 
-/** True when the installed core knows the chart option fields (older cores ignore them on export and import). */
-export const coreKnowsChartOptions = () => typeof opfCore.resolveChartOptions === 'function' && typeof opfCore.chartOptionSupport === 'function';
-
-/** The resolved options of a chart (an older core without `resolveChartOptions` ignores the fields). */
+/** The resolved options of a chart. */
 export function resolveChartOptionsFor(chart) {
-  if (typeof opfCore.resolveChartOptions !== 'function' || !chart || typeof chart !== 'object') return INACTIVE;
-  return opfCore.resolveChartOptions(chart, opfCore.chartOptionTarget(chart.type));
+  if (!chart || typeof chart !== 'object') return INACTIVE;
+  return resolveChartOptions(chart, chartOptionTarget(chart.type));
 }
 
 export function reportChartOptionDiagnostics(resolved, path, onDiagnostic) {
@@ -79,17 +76,33 @@ const dLbl = (index, color, labels, {size, font}) =>
  *   - the label text colour: the chart text colour outside a mark, the contrasting colour (core's `textColorForFill`, as the
  *     preview) inside one, per series, and per point on pie and doughnut charts.
  *
- * `info`: {resolved, kind, palette (series colours, hex without #), labelColor, font, textSize, pointCount}.
+ * FA-14: with a chart highlight (`info.highlight`, src/chart-highlight.js) `palette` holds the highlight-aware series colours, and a
+ * label inside a mark whose colour differs per point (pie and doughnut slices, columns and bars with a category highlight) is written
+ * per point with the colour that contrasts with that point's fill.
+ *
+ * `info`: {resolved, kind, palette (series colours, hex without #), labelColor, font, textSize, pointCount, highlight?}.
  */
 export function applyDataLabels(xml, info) {
-  const {resolved, kind, palette, labelColor, font, textSize, pointCount} = info;
+  // FA-15: a combo chart labels its column group like clustered columns and its line groups like line points (core's
+  // `linePosition`); the series colours run on across the groups.
+  if (info.kind === 'combo') {
+    let offset = 0;
+    return xml.replace(/<c:(barChart|lineChart)>[\s\S]*?<\/c:\1>/g, (group, element) => {
+      const line = element === 'lineChart';
+      const dataLabels = line ? {...info.resolved.dataLabels, position: info.resolved.dataLabels.linePosition ?? 'above'} : info.resolved.dataLabels;
+      const palette = info.palette.slice(offset).concat(info.palette.slice(0, offset));
+      offset = (offset + (group.match(/<c:ser>/g)?.length ?? 0)) % Math.max(1, info.palette.length);
+      return applyDataLabels(group, {...info, kind: line ? 'line' : 'bar', palette, resolved: {...info.resolved, dataLabels}});
+    });
+  }
+  const {resolved, kind, palette, labelColor, font, textSize, pointCount, highlight} = info;
   const labels = resolved.dataLabels;
   // Where the label sits on its mark: a bar or pie label placed inside the mark, and the labels of an area or a doughnut ring,
   // take the colour that contrasts with the mark; every other label keeps the chart text colour (as the preview does).
   const inside = kind === 'area' || kind === 'doughnut' || (['bar', 'pie', 'histogram', 'pareto', 'waterfall'].includes(kind) && INSIDE.has(labels.position));
-  const contrast = fill => typeof opfCore.textColorForFill === 'function' ? String(opfCore.textColorForFill(`#${fill}`, `#${labelColor}`)).replace(/^#/, '').toUpperCase() : labelColor;
-  const block = (color, {points = 0, leaderLines = false} = {}) =>
-    `<c:dLbls>${Array.from({length: points}, (_, index) => dLbl(index, inside ? contrast(palette[index % palette.length]) : labelColor, labels, {size: textSize, font})).join('')}` +
+  const contrast = fill => String(textColorForFill(`#${fill}`, `#${labelColor}`)).replace(/^#/, '').toUpperCase();
+  const block = (color, {points = 0, leaderLines = false, fills} = {}) =>
+    `<c:dLbls>${Array.from({length: points}, (_, index) => dLbl(index, inside ? contrast(fills?.[index] ?? palette[index % palette.length]) : labelColor, labels, {size: textSize, font})).join('')}` +
     `<c:numFmt formatCode="General" sourceLinked="0"/><c:spPr><a:noFill/><a:ln><a:noFill/></a:ln></c:spPr>${labelText(color, textSize, font)}${labelFlags(labels, {leaderLines})}</c:dLbls>`;
   const circular = kind === 'pie' || kind === 'doughnut';
   const replaceBlocks = (text, make) => text.replace(/<c:dLbls>[\s\S]*?<\/c:dLbls>/g, existing => make(existing));
@@ -98,7 +111,9 @@ export function applyDataLabels(xml, info) {
   const withSeries = xml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => {
     const index = seriesIndex++;
     const color = inside && !circular ? contrast(palette[index % palette.length]) : labelColor;
-    return replaceBlocks(ser, existing => block(color, {points: circular ? pointCount : 0, leaderLines: /<c:showLeaderLines\b/.test(existing)}));
+    const fills = highlight?.pointFills(index);
+    const points = circular ? pointCount : inside && fills ? fills.length : 0;
+    return replaceBlocks(ser, existing => block(color, {points, fills, leaderLines: /<c:showLeaderLines\b/.test(existing)}));
   });
   const outside = withSeries.split(/(<c:ser>[\s\S]*?<\/c:ser>)/);
   const groupLevel = outside.map((part, index) => index % 2 ? part : replaceBlocks(part, existing => block(labelColor, {leaderLines: /<c:showLeaderLines\b/.test(existing)}))).join('');
@@ -133,9 +148,7 @@ function titleString(title) {
  * plus `notes` naming what the three fields cannot express. `defaults` is what an export writes without the field:
  * `{legend: 'right' | undefined}` (a legend at the right of multi-series, pie and doughnut charts) and the chart kind.
  */
-export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCount, circular, scatter, seriesFormats = []}) {
-  // An older core's schema has no such fields (additionalProperties is false), so nothing is added to the imported chart.
-  if (!coreKnowsChartOptions()) return {options: {}, notes: []};
+export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCount, circular, scatter, seriesFormats = [], combo}) {
   const chart = chartSpace?.['c:chart'];
   const plotArea = chart?.['c:plotArea'];
   const out = {};
@@ -151,6 +164,9 @@ export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCo
     const category = titleString(asArray(plotArea?.['c:catAx'])[0]?.['c:title']), value = titleString(asArray(plotArea?.['c:valAx'])[0]?.['c:title']);
     if (category) axisTitles.category = category;
     if (value) axisTitles.value = value;
+    // FA-15: a combo chart's secondary value axis title.
+    const secondary = titleString(combo?.secondaryValueAxis?.['c:title']);
+    if (secondary) axisTitles.secondary = secondary;
   }
   if (Object.keys(axisTitles).length) out.axisTitles = axisTitles;
 
@@ -164,12 +180,12 @@ export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCo
     if (!(defaultLegend && position === 'right')) out.legend = position;
   } else if (defaultLegend) out.legend = 'none';
 
-  const dataLabels = classicDataLabels(chartNode, target, notes, seriesFormats);
+  const dataLabels = classicDataLabels(chartNode, target, notes, seriesFormats, combo);
   if (dataLabels !== undefined) out.dataLabels = dataLabels;
   return {options: out, notes};
 }
 
-function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
+function classicDataLabels(chartNode, target, notes, seriesFormats = [], combo) {
   const series = asArray(chartNode?.['c:ser']);
   // The labels the chart shows: the first series' block when it has one (PptxGenJS writes pie and doughnut visibility as per
   // point overrides), else the chart group's block.
@@ -186,12 +202,19 @@ function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
   for (const hidden of ['c:showSerName', 'c:showLegendKey', 'c:showBubbleSize']) {
     if (flag(source[hidden])) notes.push({option: 'dataLabels', message: `Data labels that show ${hidden.slice(6)} cannot be expressed; only category, value and percent import.`});
   }
-  const support = target && typeof opfCore.chartOptionSupport === 'function' ? opfCore.chartOptionSupport(target) : undefined;
+  const support = target ? chartOptionSupport(target) : undefined;
   const numberFormat = source['c:numFmt']?.formatCode ?? block['c:numFmt']?.formatCode;
   // RR-54: a label format that is a series' own number format imports with that column's format (or its own note).
   if (numberFormat && numberFormat !== 'General' && numberFormat !== '#,##0' && numberFormat !== '0%' && !seriesFormats.includes(numberFormat)) notes.push({option: 'dataLabels', message: `The label number format '${numberFormat}' cannot be expressed; labels import in the General format.`});
   const out = {};
-  const position = DLBL_POS_BACK[source['c:dLblPos']?.val ?? block['c:dLblPos']?.val];
+  let position = DLBL_POS_BACK[source['c:dLblPos']?.val ?? block['c:dLblPos']?.val];
+  if (combo) {
+    // FA-15: one OPF position covers both parts. A line position the columns cannot take (below, left, right) was asked for the
+    // lines; otherwise the column position (center, inside-end, inside-base) is the one, and 'center' is written to both.
+    const lineSeries = asArray(combo.lineNode?.['c:ser']).map(entry => entry?.['c:dLbls']).find(entry => entry !== undefined) ?? combo.lineNode?.['c:dLbls'];
+    const linePosition = DLBL_POS_BACK[lineSeries?.['c:dLblPos']?.val];
+    if (['below', 'left', 'right'].includes(linePosition)) position = linePosition;
+  }
   const supported = support?.dataLabels.positions ?? [];
   if (position && position !== support?.dataLabels.defaultPosition) {
     if (!support || supported.includes(position)) out.position = position;
@@ -204,9 +227,9 @@ function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
   return Object.keys(out).length ? out : true;
 }
 
-/** The core option target of a chart type id (undefined for an id outside the catalog or an older core). */
+/** The core option target of a chart type id (undefined for an id outside the catalog). */
 export function chartTargetFor(typeId) {
-  return typeof opfCore.chartOptionTarget === 'function' ? opfCore.chartOptionTarget(typeId) : undefined;
+  return chartOptionTarget(typeId);
 }
 
 // ---------------------------------------------------------------------------
@@ -233,7 +256,6 @@ function axisTitleText(axis) {
  * on a funnel), so only what differs from them is returned.
  */
 export function chartOptionsFromChartex(space, {type, seriesCount}) {
-  if (!coreKnowsChartOptions()) return {options: {}, notes: []};
   const chart = space?.['cx:chart'];
   const out = {};
   const notes = [];
@@ -262,7 +284,7 @@ export function chartOptionsFromChartex(space, {type, seriesCount}) {
     if (cxFlag(visibility.value)) content.push('value');
     if (cxFlag(visibility.seriesName)) notes.push({option: 'dataLabels', message: 'Chartex data labels that show the series name cannot be expressed; only category and value import.'});
     const position = CX_POSITION_BACK[labels.pos];
-    const support = typeof opfCore.chartOptionSupport === 'function' && typeof opfCore.chartOptionTarget === 'function' ? opfCore.chartOptionSupport(opfCore.chartOptionTarget(type) ?? {kind: type}) : undefined;
+    const support = chartOptionSupport(chartOptionTarget(type) ?? {kind: type});
     const isDefault = defaultContent && content.length === defaultContent.length && content.every((part, index) => part === defaultContent[index]) && (!position || position === 'center');
     const separator = text(labels['cx:separator']);
     const result = {};

package/dist/chart-types.js

@@ -1,34 +1,35 @@
 // OPF chart type ids -> native PowerPoint chart constructs (FF-22).
 //
 // The core catalog keeps one chart type per Aspose.Slides ChartType
-// (spec/catalogs/chart-types, OpenPresentation/opf#121) and deprecates the
-// rest with a replacement id. The published core package this exporter
-// depends on predates that metadata, so the mapping is carried here. Kept ids
-// map to the exact Office construct; deprecated ids resolve to their
-// replacement; any other id keeps the legacy substring heuristic.
+// (spec/catalogs/chart-types, OpenPresentation/opf#121). The mapping is carried
+// here so the exporter stays self-contained. A catalog id maps to the exact
+// Office construct; any other id keeps the legacy substring heuristic.
 
 const category = (pptx, extra = {}) => ({ family: 'category', pptx, ...extra });
 
 export const CHART_TYPES = Object.freeze({
   column: category('bar', { aspose: 'ClusteredColumn', barDir: 'col', grouping: 'clustered' }),
-  'stacked-column-3x': category('bar', { aspose: 'StackedColumn', barDir: 'col', grouping: 'stacked' }),
-  '100pct-stacked-column-3x': category('bar', { aspose: 'PercentsStackedColumn', barDir: 'col', grouping: 'percentStacked' }),
+  'stacked-column': category('bar', { aspose: 'StackedColumn', barDir: 'col', grouping: 'stacked' }),
+  '100pct-stacked-column': category('bar', { aspose: 'PercentsStackedColumn', barDir: 'col', grouping: 'percentStacked' }),
   bar: category('bar', { aspose: 'ClusteredBar', barDir: 'bar', grouping: 'clustered' }),
-  'stacked-bar-3x': category('bar', { aspose: 'StackedBar', barDir: 'bar', grouping: 'stacked' }),
-  '100pct-stacked-bar-3x': category('bar', { aspose: 'PercentsStackedBar', barDir: 'bar', grouping: 'percentStacked' }),
+  'stacked-bar': category('bar', { aspose: 'StackedBar', barDir: 'bar', grouping: 'stacked' }),
+  '100pct-stacked-bar': category('bar', { aspose: 'PercentsStackedBar', barDir: 'bar', grouping: 'percentStacked' }),
   line: category('line', { aspose: 'Line', grouping: 'standard', markers: false }),
   'line-with-markers': category('line', { aspose: 'LineWithMarkers', grouping: 'standard', markers: true }),
-  'stacked-line-3x': category('line', { aspose: 'StackedLine', grouping: 'stacked', markers: false }),
-  'stacked-line-with-markers-3x': category('line', { aspose: 'StackedLineWithMarkers', grouping: 'stacked', markers: true }),
+  'stacked-line': category('line', { aspose: 'StackedLine', grouping: 'stacked', markers: false }),
+  'stacked-line-with-markers': category('line', { aspose: 'StackedLineWithMarkers', grouping: 'stacked', markers: true }),
   area: category('area', { aspose: 'Area', grouping: 'standard' }),
-  'stacked-area-3x': category('area', { aspose: 'StackedArea', grouping: 'stacked' }),
-  '100pct-stacked-area-3x': category('area', { aspose: 'PercentsStackedArea', grouping: 'percentStacked' }),
+  'stacked-area': category('area', { aspose: 'StackedArea', grouping: 'stacked' }),
+  '100pct-stacked-area': category('area', { aspose: 'PercentsStackedArea', grouping: 'percentStacked' }),
   pie: { family: 'circular', pptx: 'pie', aspose: 'Pie' },
   doughnut: { family: 'circular', pptx: 'doughnut', aspose: 'Doughnut' },
   scatter: { family: 'xy', pptx: 'scatter', aspose: 'ScatterWithMarkers' },
   radar: category('radar', { aspose: 'Radar', radarStyle: 'standard', markers: false }),
   'radar-with-markers': category('radar', { aspose: 'RadarWithMarkers', radarStyle: 'marker', markers: true }),
   'filled-radar': category('radar', { aspose: 'FilledRadar', radarStyle: 'filled', markers: false }),
+  // FA-15: clustered columns (a c:barChart on the primary axes) with line series with markers (a c:lineChart per value axis;
+  // the secondary one crosses at the right on a deleted second c:catAx). Core's resolveChartData says which series is which.
+  combo: { family: 'combo', pptx: 'bar', aspose: 'ClusteredColumn', barDir: 'col', grouping: 'clustered', markers: true },
   // Office 2016 chartex constructs (cx:chartSpace, one cx:series per plot,
   // named by layoutId). `requires` is the markup-compatibility namespace the
   // slide's mc:Choice names, so older readers take the classic fallback.
@@ -75,51 +76,13 @@ export function chartTypeFromChartex(layoutIds) {
   return null;
 }
 
-const variants = (base, target) => Object.fromEntries([base, `${base}-2x`, `${base}-3x`].map((id) => [id, target]));
-
-// Deprecated core ids (opf 0.12.0 removes them) -> replacement id.
-export const DEPRECATED_CHART_TYPES = Object.freeze({
-  ...variants('100pct-bullet-bar', '100pct-stacked-bar-3x'),
-  '100pct-progress-bar': '100pct-stacked-bar-3x',
-  '100pct-stacked-bar-2x': '100pct-stacked-bar-3x',
-  ...variants('100pct-bullet-column', '100pct-stacked-column-3x'),
-  '100pct-stacked-column-2x': '100pct-stacked-column-3x',
-  '100pct-stacked-area-2x': '100pct-stacked-area-3x',
-  australia: 'world',
-  canada: 'world',
-  'united-kingdom': 'world',
-  'united-states': 'world',
-  'box-and-whisker-2x': 'box-and-whisker',
-  'box-and-whisker-3x': 'box-and-whisker',
-  ...variants('bullet-bar', 'bar'),
-  'clustered-bar-2x': 'bar',
-  ...variants('bullet-column', 'column'),
-  'clustered-column': 'column',
-  ...Object.fromEntries(['', '-2x', '-3x', '-4x', '-5x', '-6x'].map((suffix) => [`dot-plot${suffix}`, 'scatter'])),
-  dumbbell: 'scatter',
-  'line-2x': 'line',
-  'line-3x': 'line',
-  'line-with-high-low': 'line',
-  ...Object.fromEntries(['', '-2x', '-3x', '-4x', '-5x', '-6x'].map((suffix) => [`sparkline${suffix}`, 'line'])),
-  'line-with-high-low-and-markers': 'line-with-markers',
-  'line-with-markers-2x': 'line-with-markers',
-  'line-with-markers-3x': 'line-with-markers',
-  'stacked-area-2x': 'stacked-area-3x',
-  'stacked-bar-2x': 'stacked-bar-3x',
-  'stacked-column-2x': 'stacked-column-3x',
-  'stacked-line-2x': 'stacked-line-3x',
-  'stacked-line-with-markers-2x': 'stacked-line-with-markers-3x',
-  'treemap-2x': 'treemap',
-  'treemap-3x': 'treemap',
-});
-
 const ALIASES = Object.freeze({ donut: 'doughnut' });
 
-// Resolve an OPF chart type id to {id, spec}. Kept and deprecated ids resolve
-// to a kept id; anything else returns the legacy heuristic with id: null.
+// Resolve an OPF chart type id to {id, spec}. A catalog id resolves to itself;
+// anything else returns the legacy heuristic with id: null.
 export function resolveChartType(type) {
   const raw = String(type ?? '').trim().toLowerCase();
-  const id = ALIASES[raw] ?? DEPRECATED_CHART_TYPES[raw] ?? raw;
+  const id = ALIASES[raw] ?? raw;
   if (Object.hasOwn(CHART_TYPES, id)) return { id, spec: CHART_TYPES[id] };
   return { id: null, spec: legacyChartType(raw) };
 }
@@ -149,17 +112,17 @@ export function chartTypeFromNative(element, node) {
     case 'barChart':
     case 'bar3DChart': {
       const direction = attr('barDir') === 'bar' ? 'bar' : 'column';
-      if (percent) return `100pct-stacked-${direction}-3x`;
-      if (stacked) return `stacked-${direction}-3x`;
+      if (percent) return `100pct-stacked-${direction}`;
+      if (stacked) return `stacked-${direction}`;
       return direction;
     }
     case 'lineChart':
     case 'line3DChart':
-      if (stacked) return markers ? 'stacked-line-with-markers-3x' : 'stacked-line-3x';
+      if (stacked) return markers ? 'stacked-line-with-markers' : 'stacked-line';
       return markers ? 'line-with-markers' : 'line';
     case 'areaChart':
     case 'area3DChart':
-      return percent ? '100pct-stacked-area-3x' : stacked ? 'stacked-area-3x' : 'area';
+      return percent ? '100pct-stacked-area' : stacked ? 'stacked-area' : 'area';
     case 'pieChart':
     case 'pie3DChart':
     case 'ofPieChart':
@@ -179,6 +142,25 @@ export function chartTypeFromNative(element, node) {
   }
 }
 
+/**
+ * A combo chart in a parsed c:plotArea: exactly one clustered (or standard) column c:barChart and one or two standard
+ * c:lineChart groups, and no other chart group. Returns {bar, lines: [{node, secondary}]} (a line group is secondary when it
+ * plots against an axis the column group does not use) or null for any other plot area.
+ */
+export function comboFromNative(plotArea) {
+  if (!plotArea) return null;
+  const bars = asArray(plotArea['c:barChart']);
+  const lines = asArray(plotArea['c:lineChart']);
+  if (bars.length !== 1 || lines.length < 1 || lines.length > 2) return null;
+  if (NATIVE_CHART_ELEMENTS.some((element) => element !== 'barChart' && element !== 'lineChart' && plotArea[`c:${element}`] !== undefined)) return null;
+  const [bar] = bars;
+  if ((bar['c:barDir']?.val ?? 'col') !== 'col' || !['clustered', 'standard'].includes(bar['c:grouping']?.val ?? 'clustered')) return null;
+  if (lines.some((line) => !['standard', undefined].includes(line['c:grouping']?.val))) return null;
+  const axes = (node) => asArray(node['c:axId']).map((axis) => String(axis?.val));
+  const primary = axes(bar);
+  return { bar, lines: lines.map((node) => ({ node, secondary: axes(node).some((id) => !primary.includes(id)) })) };
+}
+
 export const NATIVE_CHART_ELEMENTS = Object.freeze([
   'barChart', 'bar3DChart', 'lineChart', 'line3DChart', 'pieChart', 'pie3DChart', 'ofPieChart',
   'doughnutChart', 'areaChart', 'area3DChart', 'scatterChart', 'radarChart',
@@ -191,6 +173,7 @@ function asArray(value) {
 // PptxGenJS omits or cannot express parts of these constructs. Rewrite only
 // the generated chart-type element so the part states the exact grouping.
 export function applyChartConstruct(xml, spec) {
+  if (spec?.family === 'combo') return applyComboConstruct(xml);
   // ScatterWithMarkers: the core catalog records scatterStyle "marker" (markers, no connecting line). PptxGenJS writes lineMarker and relies on the series line being noFill.
   if (spec?.family === 'xy') return xml.replace(/<c:scatterStyle val="[^"]*"\/>/, '<c:scatterStyle val="marker"/>');
   if (!spec || spec.family !== 'category') return xml;
@@ -214,3 +197,21 @@ export function applyChartConstruct(xml, spec) {
   }
   return xml.slice(0, start) + open + body + xml.slice(end);
 }
+
+// FA-15: PptxGenJS writes each c:lineChart of a multi-type chart without the c:grouping CT_LineChart requires, gives its series
+// the bar-only c:invertIfNegative, and writes c:dLbls before c:marker (CT_LineSer orders marker, dPt, dLbls). Rewrite every line
+// group of a combo chart into schema order; the c:barChart already states barDir and grouping.
+export function applyComboConstruct(xml) {
+  return xml.replace(/<c:lineChart>([\s\S]*?)<\/c:lineChart>/g, (_, body) => {
+    let next = `<c:grouping val="standard"/>${body.replace(/<c:grouping val="[^"]*"\/>/g, '')}`;
+    next = next.replace(/<c:invertIfNegative val="[^"]*"\/>/g, '');
+    next = next.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, (ser) => {
+      const marker = /<c:marker>[\s\S]*?<\/c:marker>/.exec(ser)?.[0];
+      const labels = /<c:dLbls>[\s\S]*?<\/c:dLbls>/.exec(ser);
+      if (!marker || !labels || ser.indexOf(marker) < labels.index) return ser;
+      const without = ser.replace(marker, '');
+      return without.replace(/<c:dLbls>/, `${marker}<c:dLbls>`);
+    });
+    return `<c:lineChart>${next}</c:lineChart>`;
+  });
+}

package/dist/code-provenance.js

@@ -19,8 +19,8 @@ function unhex(value) {
   return JSON.parse(dec.decode(Uint8Array.from(value.match(/../g),byte=>parseInt(byte,16))));
 }
 
-export function codeManifest(value, layout, group) {
-  return {v:1, group, role:'panel', value, parts:layout.parts.map(part=>({role:part.role, generated:part.generated === true,
+export function codeManifest(value, layout, group, bands) {
+  return {v:1, group, role:'panel', value, ...(bands ? {bands} : {}), parts:layout.parts.map(part=>({role:part.role, generated:part.generated === true,
     lines:part.fit.sourceLines.map(({start,end,nextStart,boundary})=>({start,end,nextStart,boundary}))}))};
 }
 
@@ -126,11 +126,16 @@ function sourceFor(value, role, generated) {
 function validateManifest(manifest) {
   const {value,parts} = manifest;
   const object = value && typeof value === 'object' && !Array.isArray(value);
-  if (typeof value !== 'string' && (!object || typeof value.source !== 'string' || Object.keys(value).some(key=>!['source','filename','language'].includes(key)) || ['filename','language'].some(key=>value[key] !== undefined && typeof value[key] !== 'string'))) throw new Error('Invalid source value.');
+  if (typeof value !== 'string' && (!object || typeof value.source !== 'string' || Object.keys(value).some(key=>!['source','filename','language','highlight'].includes(key)) || ['filename','language'].some(key=>value[key] !== undefined && typeof value[key] !== 'string'))) throw new Error('Invalid source value.');
+  // FA-13: code.highlight is a list of line numbers and [start, end] pairs from 1.
+  const line = entry => Number.isSafeInteger(entry) && entry >= 1;
+  if (object && value.highlight !== undefined && (!Array.isArray(value.highlight) || !value.highlight.length || !value.highlight.every(entry => line(entry) || (Array.isArray(entry) && entry.length === 2 && entry.every(line))))) throw new Error('Invalid highlight value.');
   // Empty metadata is preserved in the manifest but does not produce a label.
   const roles = [...(object && value.filename ? ['filename'] : []), ...(object && value.language ? ['language'] : []), 'body'];
   if (roles.length === 1) roles.unshift('language');
   if (!Array.isArray(parts) || parts.length !== roles.length) throw new Error('Invalid code parts.');
+  // FA-13: the number of native highlight bands the export drew behind the lines.
+  if (manifest.bands !== undefined && (!Number.isSafeInteger(manifest.bands) || manifest.bands < 1 || manifest.bands > 100000 || !object || value.highlight === undefined)) throw new Error('Invalid highlight bands.');
   parts.forEach((part,i)=>{
     const generated = roles.length === 2 && roles[0] === 'language' && !(object && (value.filename || value.language)) && i === 0;
     if (part.role !== roles[i] || part.generated !== generated || !Array.isArray(part.lines) || !part.lines.length) throw new Error('Invalid source part.');
@@ -180,10 +185,21 @@ export function importCodeGroups(shapes, paragraphs, relationships, entries, rep
       if (panels.length !== 1 || panels[0].text !== '') throw new Error('Missing, duplicated or edited panel.');
       const panel = panels[0], manifest = panel.data;
       validateManifest(manifest);
+      // FA-13: highlight bands are decoration. The panel and every line are required; a band may be missing (someone removed it in
+      // PowerPoint) without losing the source, and code.highlight itself comes from the manifest value.
       const expectedCount = 1 + manifest.parts.reduce((sum,part)=>sum+part.lines.length,0);
-      if (group.length !== expectedCount || new Set(group.map(item=>item.shape)).size !== group.length) throw new Error('Incomplete or duplicated code shapes.');
+      const bandCount = group.filter(item=>item.data.role === 'highlight').length;
+      if (group.length !== expectedCount + bandCount || new Set(group.map(item=>item.shape)).size !== group.length) throw new Error('Incomplete or duplicated code shapes.');
       const nativeLines = new Map();
+      const seenBands = new Set();
       for (const item of group) if (item !== panel) {
+        // FA-13: a highlight band holds no text; it only has to be one of the manifest's bands.
+        if (item.data.role === 'highlight') {
+          const {index} = item.data;
+          if (!Number.isSafeInteger(index) || index < 0 || index >= (manifest.bands ?? 0) || seenBands.has(index) || item.text !== '') throw new Error('Ambiguous highlight band.');
+          seenBands.add(index);
+          continue;
+        }
         const {role,part,line} = item.data, key = `${part}:${line}`;
         if (role !== 'line' || !Number.isSafeInteger(part) || !Number.isSafeInteger(line) || !manifest.parts[part]?.lines[line] || nativeLines.has(key)) throw new Error('Ambiguous source line.');
         nativeLines.set(key,item.text);

package/dist/color-ref.js

@@ -1,7 +1,7 @@
 // Export ColorRef through published core resolveColorRef(). Keep 8-digit hex
 // alpha locally: normalizeHexColor() strips the AA byte, which PptxGenJS needs.
 
-import { resolveColorRef as resolveCoreColorRef } from "@openpresentation/opf";
+import { resolveColorRef as resolveCoreColorRef } from "@openpresentation/opf/composition";
 
 const UNRESOLVED = "";
 
@@ -38,14 +38,19 @@ export function resolveVariableColors(variables) {
   return isPlainObject(variables) ? variables : {};
 }
 
+// The color roles a ColorRef names. An export context carries them resolved (core resolveColorRoles); a bare
+// context with only `colors` maps those fields (the exporter's colors.accent is the primary color).
 function coreRoles(ctx) {
   const colors = ctx.colors ?? {};
+  const roles = ctx.roles;
   return {
-    background: withHash(colors.background),
-    surface: withHash(colors.surface),
-    text: withHash(colors.text),
-    textSecondary: withHash(colors.mutedText),
-    accent: withHash(colors.accent),
+    primary: withHash(roles?.primary),
+    secondary: withHash(roles?.secondary),
+    accent: withHash(roles ? roles.accent : colors.accent),
+    background: withHash(roles?.background ?? colors.background),
+    surface: withHash(roles?.surface ?? colors.surface),
+    text: withHash(roles?.text ?? colors.text),
+    textSecondary: withHash(roles?.textSecondary ?? colors.mutedText),
   };
 }
 
@@ -76,6 +81,7 @@ export function colorContext(context, fallback) {
   return {
     colorScheme: context.colorScheme,
     colors: context.colors,
+    roles: context.roles,
     variables: context.variables ?? {},
     fallback: fallback ?? context.colors?.text ?? "000000",
   };