ooxml-core 1.0.0 → 1.2.0

package/dist/diagram/layout/smartart-layout-snake-grid.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SmartArt DiagramML interpreter - `snake` grid geometry.
+ *
+ * Split out of `smartart-layout-interpreter-linear.ts` (which was pushing
+ * past the repo's per-file line budget): resolves the `snake` algorithm's
+ * `(cols, rows)` grid dimensions and maps a flat data-point index to a
+ * `(col, row)` cell, honouring `grDir`/`flowDir`/`contDir`/`bkpt`. Pure
+ * geometry; no framework code.
+ */
+import type { ArrangementPlan } from './smartart-layout-interpreter-model.js';
+/** `dgm:param[@type=flowDir]`: which axis fills first (`row`, the default, or `col`). */
+export type SnakeFlowDir = 'row' | 'col';
+/**
+ * `dgm:param[@type=grDir]`: starting corner + growth axes. `tL` (top-left,
+ * default) grows right/down; `tR` mirrors the column axis, `bL` the row axis,
+ * `bR` both - matching the same four-corner vocabulary PowerPoint's own grid
+ * layouts (picture/table grids) use for "grow direction".
+ */
+export type SnakeGrowDir = 'tL' | 'tR' | 'bL' | 'bR';
+/** Grid cell counts along the fill axis (`primary`) and the wrap axis (`secondary`). */
+export interface SnakeGridDims {
+    cols: number;
+    rows: number;
+}
+/**
+ * Resolve the grid's column/row counts. `bkpt="fixed"` (with the `bkPtFixedVal`
+ * constraint giving the fixed line length) breaks to a new row/column after
+ * exactly that many items, honouring `flowDir` for which axis it counts along.
+ * Any other `bkpt` (`bal`/`endCnt`/absent) keeps the existing area-based grid
+ * guess, computed against whichever box dimension is the fill axis.
+ */
+export declare function snakeGridDims(plan: ArrangementPlan, n: number, w: number, h: number, flowDir: SnakeFlowDir): SnakeGridDims;
+/**
+ * Map data-point index `i` to a `(col, row)` grid cell honouring `flowDir` (which
+ * axis is walked first), `contDir` (whether alternate lines reverse - the
+ * boustrophedon "snake" the algorithm is named for - or every line reads the
+ * same direction), and `grDir` (which corner the grid grows from).
+ */
+export declare function snakeCell(i: number, dims: SnakeGridDims, flowDir: SnakeFlowDir, sameDir: boolean, grDir: SnakeGrowDir): {
+    col: number;
+    row: number;
+};
+//# sourceMappingURL=smartart-layout-snake-grid.d.ts.map

package/dist/diagram/layout/smartart-layout-snake-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-snake-grid.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-snake-grid.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAG3E,yFAAyF;AACzF,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,eAAe,EACrB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,YAAY,GACnB,aAAa,CAkBf;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACxB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,YAAY,GACjB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAgB9B"}

package/dist/diagram/layout/smartart-layout-style-helpers.d.ts

@@ -0,0 +1,84 @@
+/**
+ * SmartArt DiagramML interpreter - pure colour / style / text helpers.
+ *
+ * Back the interpreter's node builders (`smartart-layout-interpreter-render.ts`)
+ * and its arrangers. No framework code, no DOM.
+ *
+ * Moved here from `pptx-viewer-shared` (`smartart-layout-helpers.ts`) so the
+ * save/decompose pipeline in this package can call the same interpreter the
+ * bindings render with; `pptx-viewer-core` cannot import `pptx-viewer-shared`
+ * (shared depends on core), so the single copy now lives in core and shared
+ * re-exports it. Tree helpers (`buildTree`/`treeWidth`/`treeDepth`) stay in
+ * `smartart-helpers.ts`, which already defined equivalent core-native
+ * versions; duplicating a second copy here would recreate the exact drift
+ * this move is meant to end.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { RenderedNodeTextStyle } from './smartart-layout-types.js';
+/** Pick a colour from the palette, cycling for any index. */
+export declare function colour(index: number, palette: string[]): string;
+/**
+ * Resolve the effective fill for a node: an explicit per-node
+ * `node.style.fillColor` override wins, otherwise the cycled palette colour.
+ */
+export declare function nodeFill(node: DiagramNode, index: number, palette: string[]): string;
+/**
+ * Resolve the effective outline stroke for a node: an explicit per-node
+ * `node.style.lineColor` override wins, otherwise the style-derived default.
+ */
+export declare function nodeStroke(node: DiagramNode, defaultStroke: string): string;
+/**
+ * Resolve the per-node label styling from an explicit `node.style` override.
+ *
+ * Returns only the fields the node actually overrides, so spreading the result
+ * into a `RenderedNode` leaves the binding defaults (white, no weight, no
+ * italic) in place for an unstyled node.
+ */
+export declare function nodeTextStyle(node: DiagramNode): RenderedNodeTextStyle;
+/** Compute a fading opacity for progressive nodes. */
+export declare function nodeOpacity(index: number, total: number, style: DiagramStyleIntensity): number;
+/** Drop-shadow filter string for the given style. */
+export declare function styleShadow(style: DiagramStyleIntensity): string | undefined;
+/** Stroke width for node outlines. */
+export declare function styleStroke(style: DiagramStyleIntensity): number;
+/** Truncate text at `max` chars, appending an ellipsis. */
+export declare function truncate(text: string, max: number): string;
+/**
+ * Fit font size to available space.
+ * Uses a 0.6 char-width heuristic; clamps to `minSize` (6pt by default).
+ */
+export declare function fitFontSize(text: string, maxWidth: number, maxHeight: number, baseSize: number, minSize?: number): number;
+/**
+ * SVG polygon `points` for a chevron / arrow inscribed in the box at (`x`, `y`)
+ * sized `w` x `h`: a notch on the left edge and a tip on the right.
+ *
+ * @param x - Left edge.
+ * @param y - Top edge.
+ * @param w - Box width.
+ * @param h - Box height.
+ * @returns Space-separated `"x,y"` pairs.
+ */
+export declare function chevronPoints(x: number, y: number, w: number, h: number): string;
+/**
+ * SVG polygon `points` for a cog wheel centred at (`cx`, `cy`).
+ *
+ * Vertices alternate between `outerR` (tooth tip) and `innerR` (tooth valley),
+ * two vertices per tooth. Emitted as polygon points rather than a path so the
+ * gear rides the existing `RenderedPolygonNode` contract every binding already
+ * renders; the outline is identical either way because the teeth are straight
+ * segments.
+ *
+ * @param cx     - Centre x.
+ * @param cy     - Centre y.
+ * @param outerR - Tooth-tip radius.
+ * @param innerR - Tooth-valley radius.
+ * @param teeth  - Number of teeth.
+ * @returns Space-separated `"x,y"` pairs.
+ */
+export declare function gearPoints(cx: number, cy: number, outerR: number, innerR: number, teeth: number): string;
+/** Outline-stroke colour for a node given its computed stroke width. */
+export declare function strokeFor(sw: number): string;
+/** Depth-first flatten of a nested node forest. */
+export declare function flattenNodes<S>(roots: DiagramNode<S>[]): DiagramNode<S>[];
+//# sourceMappingURL=smartart-layout-style-helpers.d.ts.map

package/dist/diagram/layout/smartart-layout-style-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-style-helpers.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-style-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAIrE,6DAA6D;AAC7D,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE/D;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAGpF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAG3E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,qBAAqB,CAgBtE;AAED,sDAAsD;AACtD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAM9F;AAED,qDAAqD;AACrD,wBAAgB,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,GAAG,SAAS,CAQ5E;AAED,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAQhE;AAED,2DAA2D;AAC3D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAK1D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,SAAI,GACT,MAAM,CAKR;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAUhF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACzB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,MAAM,CAUR;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,mDAAmD;AACnD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAYzE"}

package/dist/diagram/layout/smartart-layout-types.d.ts

@@ -0,0 +1,253 @@
+/**
+ * SmartArt DiagramML interpreter - pure geometry types.
+ *
+ * Describes the styled view-model geometry produced by the interpreter
+ * (`smartart-layout-interpreter.ts` and its arrangers). No framework code, no
+ * DOM. Consumed by:
+ *  - the SVG-fallback preview path (re-exported from `pptx-viewer-shared` for
+ *    the React/Vue/Angular/Svelte/Vanilla bindings), and
+ *  - the save/decompose pipeline in this package (`smartart-decompose.ts`,
+ *    `smartart-interpreter-drawing-bridge.ts`), which converts this geometry
+ *    into `PptxElement[]` / `PptxSmartArtDrawingShape[]` for the fabricated
+ *    cached diagram drawing.
+ *
+ * Moved here from `pptx-viewer-shared` so the same interpreter can be shared
+ * by the save pipeline: `pptx-viewer-core` cannot import `pptx-viewer-shared`
+ * (shared depends on core, not the other way around), so the single
+ * interpreter now lives in core and shared re-exports it.
+ */
+/** Axis-aligned rectangle. */
+export interface LayoutRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Per-node label styling resolved from `DiagramNode.style` (the overrides
+ * the inspector's node style bar writes).
+ *
+ * Every field is optional and every field has a documented binding default, so
+ * a renderer that ignores them keeps its historic output:
+ * `fontColor` -> `white`, `fontWeight` / `fontStyle` -> unset.
+ */
+export interface RenderedNodeTextStyle {
+    /** Label colour. Default `white`. */
+    fontColor?: string | undefined;
+    /** SVG `font-weight` (`700` when the node is bold). Default unset. */
+    fontWeight?: number | undefined;
+    /** SVG `font-style`. Default unset. */
+    fontStyle?: 'italic' | undefined;
+}
+/**
+ * Fields shared by every rendered node kind, carrying the source data-model
+ * node identity and a final-transform rotation.
+ *
+ * `nodeId` lets a consumer (the manual `cust*`-override pass, or the
+ * save-pipeline bridge that needs the node's full untruncated text) join a
+ * rendered shape back to its `DiagramNode`. `rotation` is additive
+ * degrees applied by a `dgm:pt/dgm:prSet/@custAng` manual override; it is
+ * `undefined` (no rotation) unless such an override is present.
+ */
+export interface RenderedNodeIdentity {
+    /** The `DiagramNode.id` this shape represents. */
+    nodeId?: string | undefined;
+    /** Additional rotation in degrees from a `custAng` manual override. */
+    rotation?: number | undefined;
+    /**
+     * Explicit DrawingML preset geometry name (`rect`, `roundRect`, ...) for
+     * the save-pipeline bridge (`smartart-interpreter-drawing-bridge.ts`) to
+     * use verbatim instead of its own kind-based default. Set by
+     * `smartart-layout-interpreter-item-roles.ts` when a per-item role
+     * template (e.g. a list layout's `childText`) declares its own `dgm:shape`
+     * distinct from the arranger's hardcoded family shape. `undefined` keeps
+     * the bridge's pre-existing behaviour.
+     */
+    presetOverride?: string | undefined;
+    /**
+     * Additional `DiagramNode.id`s whose text folds into THIS shape as
+     * extra paragraphs (see `projectFoldedNodeText` in the drawing bridge),
+     * pre-resolved by `smartart-layout-interpreter-item-roles.ts` for a
+     * `des`/`ch`-axis role that combines more than one descendant's text into
+     * one box. `undefined` keeps the bridge's own descendant-folding
+     * inference (nearest rendered ancestor absorbs any node without a box).
+     */
+    foldedNodeIds?: string[] | undefined;
+    /**
+     * Pre-resolved, verbatim display text for a role bound to a TRANSITION
+     * point (`dgm:presOf ptType="sibTrans"|"parTrans"`) rather than a real
+     * data node - e.g. a numbered-badge layout's ordinal "1"/"2"/"3" text,
+     * which PowerPoint stores on the `sibTrans` point of the item's own
+     * `parOf` edge (`DiagramConnection.label`), not on any
+     * `DiagramNode` `nodeId` can resolve. Set by
+     * `smartart-layout-interpreter-item-roles.ts`. When present, the
+     * save-pipeline bridge (`smartart-interpreter-drawing-bridge.ts`) uses it
+     * verbatim instead of resolving `nodeId` against the node array (which
+     * would find nothing and render blank text).
+     */
+    literalText?: string | undefined;
+    /**
+     * The `dgm:layoutNode/@name` of the per-item text role this entry was
+     * split from (e.g. a pyramid's `level` vs `acctTx`), set by
+     * `smartart-layout-interpreter-item-role-shared.ts`'s `stackRoleContent`
+     * for EVERY split entry (rect or polygon), not only ones an arranger
+     * needs to distinguish. A `polygon` split (`arrangePyramid`'s
+     * parent+child pyramid accent) starts as an unchanged copy of the
+     * original geometry per role - this is the one field an arranger-specific
+     * geometry pass can key off to reposition/resize each entry by name,
+     * since `stackRoleContent` itself has no generic way to split a
+     * polygon's own `points`. `undefined` on an unsplit node.
+     */
+    itemRoleName?: string | undefined;
+    /**
+     * The font size (px) a FOLDED descendant paragraph (`collectFoldedDescendants`
+     * in the drawing bridge) should render at, when it differs from this
+     * shape's own `fontSize` - see `smartart-layout-item-font-tier.ts`'s
+     * module doc comment for why a folded descendant renders SMALLER than its
+     * ancestor's own top-level text. `undefined` keeps the bridge's
+     * pre-existing behaviour of reusing `fontSize` for every folded paragraph.
+     */
+    descendantFontSize?: number | undefined;
+    /**
+     * The presentation style label (`presStyleLbl`) of the layout node this
+     * shape was laid out from (`node1`, `revTx`, `sibTrans2D1`, ...), when the
+     * engine knows it. A regenerated shape takes its quick-style 3D from this
+     * label (`smartart-quick-style-3d.ts`), so a decorative or transition shape
+     * that presents no node is not styled as `node1`.
+     */
+    styleLabel?: string | undefined;
+    /** Preset adjustments (`a:avLst`) to cache, e.g. a connector arrow's `adj1`/`adj2`. */
+    shapeAdjustments?: Record<string, number> | undefined;
+}
+/** A node rendered as an SVG rect (rounded or flat). */
+export interface RenderedRectNode extends RenderedNodeTextStyle, RenderedNodeIdentity {
+    kind: 'rect';
+    key: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+    text: string;
+    fontSize: number;
+    /** Centre x for text anchor. */
+    textX: number;
+    /** Centre y for text anchor. */
+    textY: number;
+}
+/** A node rendered as an SVG circle. */
+export interface RenderedCircleNode extends RenderedNodeTextStyle, RenderedNodeIdentity {
+    kind: 'circle';
+    key: string;
+    cx: number;
+    cy: number;
+    r: number;
+    /**
+     * Optional independent horizontal/vertical radii for a genuinely elliptical
+     * node (e.g. the `cycle` arranger's "Basic Cycle" ring, whose real
+     * PowerPoint output is a non-circular ellipse - see
+     * `smartart-layout-interpreter-cycle.ts`). Additive: every existing
+     * producer that never sets these keeps rendering as the plain circle `r`
+     * always described; a consumer that does not know about `rx`/`ry` still
+     * gets a sensible circle (`r`) rather than an error. Only
+     * `smartart-interpreter-drawing-bridge.ts`'s geometry conversion currently
+     * reads them.
+     */
+    rx?: number | undefined;
+    ry?: number | undefined;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+    text: string;
+    fontSize: number;
+    /**
+     * Label anchor x. Defaults to `cx`; set when the label sits away from the
+     * circle (target leader labels, timeline captions).
+     */
+    textX?: number | undefined;
+    /** Label anchor y. Defaults to `cy`. */
+    textY?: number | undefined;
+    /** SVG `text-anchor` for the label. Defaults to `middle`. */
+    textAnchor?: 'start' | 'middle' | 'end' | undefined;
+    /**
+     * How the label block sits relative to `textY`: `middle` centres it (the
+     * default), `bottom` puts the last baseline on `textY` (label above the
+     * node), `top` puts the first line's top on `textY` (label below).
+     */
+    textBaseline?: 'top' | 'middle' | 'bottom' | undefined;
+}
+/** A node rendered as an SVG polygon (chevron, trapezoid, etc.). */
+export interface RenderedPolygonNode extends RenderedNodeTextStyle, RenderedNodeIdentity {
+    kind: 'polygon';
+    key: string;
+    points: string;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+    text: string;
+    fontSize: number;
+    /** Centre x for text anchor. */
+    textX: number;
+    /** Centre y for text anchor. */
+    textY: number;
+}
+export type RenderedNode = RenderedRectNode | RenderedCircleNode | RenderedPolygonNode;
+/**
+ * A connector line between two rendered nodes.
+ *
+ * The paint fields are optional and carry the values every binding already
+ * hardcodes, so a renderer that ignores them is unchanged:
+ * `stroke` -> `#94a3b8`, `strokeWidth` -> `1.5`, `opacity` -> `0.5`,
+ * `dash` -> solid.
+ */
+export interface RenderedConnector {
+    key: string;
+    /** SVG path data string. */
+    d: string;
+    /** Stroke colour. Default `#94a3b8`. */
+    stroke?: string | undefined;
+    /** Stroke width. Default `1.5`. */
+    strokeWidth?: number | undefined;
+    /** Stroke opacity. Default `0.5`. */
+    opacity?: number | undefined;
+    /** SVG `stroke-dasharray`. Default solid. */
+    dash?: string | undefined;
+    /**
+     * Connector label text, from a `dgm:pt/@type="parTrans"` transition
+     * point's `dgm:t` (`DiagramConnection.label`). PowerPoint's own
+     * diagram editor lets a user type text directly onto an org-chart
+     * relationship connector. `undefined` when the connector carries no text
+     * (the overwhelming majority).
+     */
+    text?: string | undefined;
+}
+/** The layout family applied to a SmartArt element. */
+export type LayoutFamily = 'list' | 'process' | 'cycle' | 'hierarchy' | 'matrix' | 'radial' | 'pyramid' | 'venn' | 'funnel' | 'target' | 'gear' | 'timeline' | 'bending';
+/** Complete layout output for a single SmartArt family. */
+export interface SmartArtLayoutResult {
+    /** Rendered geometry nodes. */
+    nodes: RenderedNode[];
+    /** Connector lines (may be empty). */
+    connectors: RenderedConnector[];
+    /** SVG filter string for drop shadows, e.g. `"drop-shadow(…)"`. */
+    shadowFilter: string | undefined;
+    /**
+     * Suggested viewBox string `"0 0 W H"`.
+     * Callers should use the element's actual pixel dimensions.
+     */
+    viewBox: string;
+    /** The layout family that was applied. */
+    family: LayoutFamily;
+}
+/** Bounding box passed to every layout function. */
+export interface BoundingBox {
+    width: number;
+    height: number;
+}
+//# sourceMappingURL=smartart-layout-types.d.ts.map

package/dist/diagram/layout/smartart-layout-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-types.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-types.ts"],"names":[],"mappings":"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"}

package/dist/diagram/layout/smartart-line-pitch.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The line height SmartArt text is laid out with, per font.
+ *
+ * Every cached SmartArt paragraph carries `a:lnSpc 90%`, and PowerPoint
+ * applies that 90% to the font's own line height (ascent + descent), not to
+ * the 1.2em a plain text box's single spacing uses: COM
+ * `TextRange.BoundHeight` on the gallery fixtures' SmartArt shapes reads
+ * 1.099-1.100 x size per line at 19, 20, 26, 36 and 43pt ("Basic Process",
+ * "Basic Chevron Process", "Tab List", "Basic Block List", "Lined List"),
+ * i.e. `0.9 x 1.2207em` for Aptos, where a text box with the same 90%
+ * spacing reads `0.9 x 1.2 = 1.08` (the advance table's `lineHeightRatio`).
+ *
+ * Only fonts measured this way are listed; any other font keeps its table's
+ * own `lineHeightRatio`.
+ */
+import type { FontAdvanceTable } from '../../text/font-metrics/font-advance-widths.generated';
+/**
+ * A laid-out text block is taller than its lines by a fixed 0.00695em of the
+ * first line's size: COM `TextRange.BoundHeight` of Aptos at 10, 20, 37 and
+ * 100pt reads `lines x pitch + 0.00695 x size` for one, two and four lines
+ * alike (100pt: 108.695, 216.695, 432.695). Across the gallery corpus it is
+ * what separates PowerPoint's chosen size from the next point up in 11 more
+ * `equ` groups whose one-point-larger fit would otherwise clear by under
+ * 0.3pt, with no cached size failing to fit because of it.
+ */
+export declare const SMARTART_TEXT_BLOCK_EXTRA_EM = 0.00695;
+/** SmartArt line height (em, before the 90% line spacing) for text measured with `table`. */
+export declare function smartArtLineEm(table: FontAdvanceTable): number;
+//# sourceMappingURL=smartart-line-pitch.d.ts.map

package/dist/diagram/layout/smartart-line-pitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-line-pitch.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-line-pitch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uDAAuD,CAAC;AAc9F;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,UAAU,CAAC;AAEpD,6FAA6F;AAC7F,wBAAgB,cAAc,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAE9D"}

package/dist/diagram/layout/smartart-node-role-colors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Overlay each node's own quick-style role colour onto the DiagramML
+ * interpreter's output.
+ *
+ * `nodeFill` (`smartart-layout-style-helpers.ts`) cycles every rendered node
+ * through ONE flat palette by rendered-order index, regardless of the node's
+ * own role: an org-chart's assistant nodes (`presStyleLbl="asst1"`, etc.) get
+ * the same generic cycled colour as an ordinary report instead of the "asst"
+ * role's own colour list from `ppt/diagrams/colors*.xml`. This post-pass
+ * corrects that, joining each rendered node back to its source
+ * `DiagramNode` by {@link RenderedNode.nodeId} (every arranger sets it)
+ * and swapping in the resolved role's own cycled fill colour - without
+ * disturbing an EXPLICIT per-node `node.style.fillColor` override (still
+ * applied earlier, inside `nodeFill`) or a node with no recognised role.
+ *
+ * @module smartart-node-role-colors
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { SmartArtLayoutResult } from './smartart-layout-types.js';
+/** Per-styleLbl-role resolved colour lists (from a diagram colour transform). */
+export type SmartArtColorRoleMap = Record<string, {
+    fill: string[];
+    line: string[];
+}>;
+/**
+ * Overlay each node's own quick-style role fill colour onto the interpreter
+ * output. Returns `result` unchanged when `colorRoles` is empty/absent.
+ */
+export declare function applySmartArtRoleColors(result: SmartArtLayoutResult, flat: DiagramNode[], colorRoles: SmartArtColorRoleMap | undefined): SmartArtLayoutResult;
+//# sourceMappingURL=smartart-node-role-colors.d.ts.map

package/dist/diagram/layout/smartart-node-role-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-node-role-colors.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-node-role-colors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAElF,iFAAiF;AACjF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AAEtF;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,WAAW,EAAE,EACnB,UAAU,EAAE,oBAAoB,GAAG,SAAS,GAC1C,oBAAoB,CAqBtB"}

package/dist/diagram/layout/smartart-node-tree-axis.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Depth/parent helpers for the DiagramML interpreter's `axis="ch"` handling.
+ *
+ * `DiagramData.nodes` has TWO possible shapes depending on where it came
+ * from: the real PowerPoint loader (`PptxHandlerRuntimeSmartArt.ts`) always
+ * emits a FLAT array with a `parentId` back-reference (never populates
+ * `.children`); some hand-built fixtures and SDK call sites instead build a
+ * genuinely nested tree (`.children` populated, no `parentId` needed). Both
+ * representations describe the same tree; these helpers read whichever one is
+ * present so callers do not need to know which shape they were handed (see
+ * `buildTree` in `smartart-helpers.ts`, which already makes the same choice
+ * for hierarchy arrangement).
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { DiagramConnection } from '../types.js';
+/**
+ * The DIRECT top-level nodes: depth 0, i.e. the `axis="ch"` set relative to
+ * the diagram's document root. For a flat (`parentId`) representation this is
+ * every node with no parent or a parent outside the given set; for a nested
+ * (`.children`) representation the given array already IS just the roots.
+ *
+ * This is the set a built-in layoutDef's driving `dgm:forEach axis="ch"
+ * ptType="node"` iterates (one rendered box per top-level node): see
+ * `smartart-layout-interpreter-flow.ts`'s `selectArrangedNodes`. A node added
+ * one level deeper (the SmartArt text pane's Tab/"Add Bullet") is NOT in this
+ * set; PowerPoint folds it into its nearest top-level ancestor's box instead
+ * of giving it a sibling box (`smartart-interpreter-drawing-bridge.ts`'s
+ * `collectFoldedDescendants`/`projectFoldedNodeText`).
+ */
+export declare function topLevelSmartArtNodes<S>(nodes: DiagramNode<S>[]): DiagramNode<S>[];
+/**
+ * All of `node`'s descendants (any depth), document order, trimmed to drop
+ * LEADING/TRAILING empty-text ones but keeping an INTERIOR empty-text node
+ * (between two text-bearing descendants) as a blank-paragraph placeholder.
+ * Shared by `smartart-layout-interpreter-item-roles.ts` (a `des`-axis
+ * per-item role, e.g. a list layout's `childText`) and
+ * `smartart-layout-interpreter-composite.ts` (a `des`-axis composite slot,
+ * e.g. `gear`'s `gear1ch`) - both fold the SAME thing (a `dgm:presOf
+ * axis="des"` role's content), just for a differently-shaped arranger.
+ *
+ * `text-card-short-line--hier8.pptx`'s "Branch A" shape (COM-verified): a
+ * doc-order-empty, non-text GROUP-WRAPPER point sits BETWEEN two real
+ * descendants (`Branch A Child`, then `Branch A Grandchild with long text`)
+ * that fold into the SAME "des" role box. The cached drawing renders that
+ * box's text as `"Branch A Child\n\nBranch A Grandchild..."` (a BLANK line
+ * between them, from the skipped wrapper's own empty paragraph) - dropping
+ * every empty-text descendant unconditionally (the prior behaviour)
+ * collapsed it to `"Branch A Child\nBranch A Grandchild..."` instead
+ * (measured: `meet-the-team--hier8`/`small-dots-horizontal--hier8`/
+ * `text-card-short-line--hier8.pptx` all share this exact shape). Trimming
+ * only the LEADING/TRAILING empty run (never an interior one) keeps every
+ * pre-existing caller's own "any real content at all" check
+ * (`.length > 0`) exactly as before: an interior blank can only ever exist
+ * BETWEEN two already-real entries, so it never turns a genuinely-empty
+ * result non-empty.
+ */
+export declare function smartArtDescendantsWithText<S>(node: DiagramNode<S>, childrenOf: Map<string, DiagramNode<S>[]>): DiagramNode<S>[];
+/**
+ * Map from a node's id to its direct children, reading `.children` when
+ * populated (nested representation) or grouping by `parentId` across `nodes`
+ * (flat, `parentId`-only representation, the real PowerPoint loader's shape).
+ *
+ * `connections`, when supplied, reorders each group's own children by their
+ * `dgm:cxn` `srcOrd` (`buildChildOrder`, the SAME source of truth already
+ * used for hierarchy sibling order and hub satellites) instead of raw
+ * `nodes` array (`dgm:ptLst` declaration) order - the two are NOT guaranteed
+ * to agree (`gear--hier5.pptx`'s "Node Two" declares its children "Node
+ * Three" then "Node Five" in `dgm:ptLst`, but their real `srcOrd` is
+ * Five=0, Three=1; a composite `des`-axis slot folding both into one box via
+ * `smartArtDescendantsWithText` then joins them in the WRONG order without
+ * this - COM-verified against `gear--hier5.pptx`'s own cached drawing,
+ * `"Node Five\nNode Three"`). Sorts EACH already-grouped list directly
+ * (every entry in one list shares the SAME parent by construction) rather
+ * than reusing `applyChildOrder`'s whole-array comparator: that comparator
+ * returns 0 for a pair from DIFFERENT parents, which is correct for
+ * STABILITY but breaks transitively when two same-parent siblings are
+ * separated in the source array by an unrelated node the comparator treats
+ * as "equal" to both (`Array.prototype.sort` is not guaranteed to compare
+ * every pair directly, so the two same-parent siblings' own relative
+ * `srcOrd` order is never actually applied in that shape) - measured
+ * directly against `gear--hier5.pptx` (`applyChildOrder` alone left
+ * "Node Three"/"Node Five" unchanged, separated by "Node Four", a
+ * different-parent node). Grouping first sidesteps this entirely: sorting
+ * within an already-homogeneous-parent list never needs a "0 = unrelated"
+ * escape hatch. Omitted (the default) keeps the pre-existing `dgm:ptLst`-
+ * order behaviour for every caller that does not have connection data, and
+ * the nested (`.children`) representation is never reordered here (it
+ * already reflects whatever order its own producer chose).
+ */
+export declare function smartArtChildrenOf<S>(nodes: DiagramNode<S>[], connections?: DiagramConnection[]): Map<string, DiagramNode<S>[]>;
+//# sourceMappingURL=smartart-node-tree-axis.d.ts.map

package/dist/diagram/layout/smartart-node-tree-axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-node-tree-axis.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-node-tree-axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAOlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAC5C,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EACpB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,GACvC,WAAW,CAAC,CAAC,CAAC,EAAE,CAkBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EACnC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EACvB,WAAW,CAAC,EAAE,iBAAiB,EAAE,GAC/B,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAiC/B"}

package/dist/diagram/layout/smartart-text-wrap-fit.d.ts

@@ -0,0 +1,84 @@
+/**
+ * SmartArt DiagramML interpreter - word-wrapped font-size fit, using REAL
+ * PowerPoint-measured glyph metrics.
+ *
+ * A `lin`/`snake` item box is a real multi-line text frame (PowerPoint wraps
+ * long labels across several lines rather than shrinking them to fit one
+ * line), so sizing it needs an actual word-wrap line count, not a one-line
+ * assumption. This greedily word-wraps `text` at a candidate font size using
+ * per-glyph advance widths from `font-advance-widths.generated.ts` (measured
+ * from real PowerPoint via `scripts/pptx/make-font-advance-table.ps1`, not a flat
+ * char-width guess), counts the lines it needs, and binary-searches for the
+ * largest size (bounded by `[floor, ceiling]`) whose wrapped line count still
+ * fits `maxHeight` at that font's own measured line-height ratio.
+ */
+import type { FontAdvanceTable } from '../../text/font-metrics/font-advance-widths.generated';
+/**
+ * PowerPoint's own baked-in SmartArt paragraph line spacing: every gallery
+ * fixture's cached `dsp:txBody` carries `<a:lnSpc><a:spcPct val="90000"/>`
+ * (90%) - confirmed universal across a dozen fixtures spanning list/process/
+ * pyramid/cycle/hierarchy families (`basic-block-list`, `basic-process`,
+ * `vertical-bullet-list`, `text-card-short-line`, `vertical-action-list`,
+ * `basic-chevron-process`, `segmented-pyramid`, `pyramid-list`,
+ * `basic-timeline`), never anything else. COM-verified directly (a real
+ * 3-line "Node Two has a longer label" Aptos 48pt run,
+ * `TextRange.ParagraphFormat.SpaceWithin`/`LineRuleWithin`): content height
+ * goes from 174.56pt (default 100% spacing) to 157.45pt at `SpaceWithin=0.9`
+ * - a ratio of 0.902, i.e. this constant scales the WHOLE multi-line block,
+ * not just the gaps between lines. See `smartart-layout-item-font-size.test.ts`/
+ * `smartart-text-wrap-fit.test.ts` for the exact fixtures and cached sizes
+ * this is pinned against; the numbers drift as the advance tables and other
+ * fitting terms are corrected, so are not repeated here.
+ *
+ * Exported (not just a private default) because a caller solving font-fit
+ * against an item's own SELF-SCOPED `h`/`w` aspect as a stand-in "natural"
+ * height (`smartart-layout-item-font-size.ts`'s `resolveItemSelfAspect` -
+ * that box is not the arranger's real declared height, only an approximation
+ * of it) measures BEST at the RAW line-height ratio with no further
+ * reduction: `basic-process--flat3.pptx`, whose item declares exactly such a
+ * self-scoped aspect, converges to its cached 19pt exactly without this
+ * factor, and OVERSHOOTS to 20pt with it (this factor's own relief already
+ * approximates room the aspect estimate does not otherwise account for).
+ */
+export declare const SMARTART_LINE_SPACING_FACTOR = 0.9;
+/**
+ * `text`'s rendered width at `fontSize` (same unit as `table`'s advances were
+ * measured in per-em), with each glyph's advance snapped to PowerPoint's own
+ * 1/6-CSS-px hinting grid, plus the table's pair kerning (each adjustment
+ * snapped the same way) at 12pt/16px and above - see `font-kerning.ts`.
+ */
+export declare function measureTextWidth(text: string, fontSize: number, table: FontAdvanceTable): number;
+/**
+ * Greedy word-wrap line count for `text` at `fontSize`/`maxWidth`, honouring
+ * explicit `\n` breaks. Exported (beyond the module's own `fitWrappedFontSize`
+ * use) so a diagnostic script can query the SAME production wrap logic the
+ * fitter itself uses, rather than a hand-rolled reimplementation that could
+ * silently diverge from it.
+ */
+export declare function wrappedLineCount(text: string, maxWidth: number, fontSize: number, table: FontAdvanceTable): number;
+/**
+ * The widest single wrapped line's own rendered width (same unit as
+ * `maxWidth`), from the SAME greedy wrap `wrappedLineCount` uses. Used by
+ * `smartart-layout-item-font-tier-fit.ts`'s `itemFits` (round 16) to reject
+ * a candidate size outright when a single word cannot fit `maxWidth` at
+ * all (the widest "line" is then that one overlong word, which by
+ * construction the greedy wrap never further breaks) - distinct from an
+ * ordinary wrap boundary, where every line's own width is `<= maxWidth`.
+ */
+export declare function wrappedWidestLineWidth(text: string, maxWidth: number, fontSize: number, table: FontAdvanceTable): number;
+/**
+ * Largest font size in `[floor, ceiling]` whose greedy word-wrap of `text`,
+ * using `table`'s REAL per-glyph advances and line-height ratio, fits within
+ * `[maxWidth, maxHeight]`. Returns `floor` when even the floor size
+ * overflows (the best available compromise), and `ceiling` when the ceiling
+ * size already fits without any shrinking. `maxWidth`/`maxHeight`/`ceiling`/
+ * `floor` must all share the SAME unit as `table` was measured in (this
+ * interpreter uses pixels throughout; see `smartart-layout-item-font-size.ts`
+ * for the points-to-pixels conversion at the call site).
+ *
+ * @param lineSpacingFactor - PowerPoint's own baked-in SmartArt line spacing
+ *   (see `SMARTART_LINE_SPACING_FACTOR`'s doc comment for why a caller using
+ *   a self-scoped-aspect "natural height" estimate should pass `1` instead).
+ */
+export declare function fitWrappedFontSize(text: string, maxWidth: number, maxHeight: number, ceiling: number, floor: number, table?: FontAdvanceTable, lineSpacingFactor?: number): number;
+//# sourceMappingURL=smartart-text-wrap-fit.d.ts.map