ooxml-core 1.1.0 → 1.2.1

package/dist/diagram/layout/smartart-layout-interpreter-presof-choose.d.ts

@@ -0,0 +1,29 @@
+/**
+ * SmartArt DiagramML interpreter - choose-aware `dgm:presOf` resolution.
+ *
+ * Split out of `smartart-layout-interpreter-when.ts` (the file-size budget):
+ * {@link resolvePresentationOf} is the ONE consumer of `DiagramLayoutNode.
+ * presentationOfCandidates`, layered on top of `evaluateWhen` from that
+ * module. Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramIteratorAttributes, DiagramLayoutNode, DiagramNode } from '../model/index.js';
+/**
+ * The `dgm:presOf` `node` actually resolves to, choose-aware: when
+ * `node.presentationOfCandidates` is populated (2+ real branches, see its
+ * own doc comment - `funnel--flat3.pptx`'s `item1`/`item2`/`item3`, one
+ * literal axis per data-point count), evaluate each candidate's own guard
+ * chain against `flat` in document order and return the FIRST one every
+ * condition holds for (an undecidable condition defaults to "allow", the
+ * same convention `guardAllows`/`collectRawCandidates`
+ * (`smartart-layout-interpreter-composite-choose.ts`) already use elsewhere
+ * in this interpreter - a `dgm:else` candidate's own empty guard chain
+ * always matches, so it is the natural fallback when reached). Falls back to
+ * `node.presentationOf` (the static single guess
+ * `smartart-layout-definition-constraints.ts`'s `choosePresentationOf`
+ * already made at parse time) when there is nothing to choose between, or no
+ * candidate's guard chain resolves - never a behaviour change for the
+ * overwhelming majority of nodes, which carry no `presentationOfCandidates`
+ * at all.
+ */
+export declare function resolvePresentationOf(node: DiagramLayoutNode, flat: DiagramNode[]): DiagramIteratorAttributes | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-presof-choose.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-presof-choose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-presof-choose.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-presof-choose.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG1F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,GACjB,yBAAyB,GAAG,SAAS,CASvC"}

package/dist/diagram/layout/smartart-layout-interpreter-pyramid-bands.d.ts

@@ -0,0 +1,41 @@
+/**
+ * SmartArt DiagramML interpreter - `pyraAcctRatio` pyramid band-splitting
+ * geometry.
+ *
+ * Split out of `smartart-layout-interpreter-pyramid.ts` (the file-size
+ * budget) - see that module's own doc comment for the full COM-verified
+ * derivation this implements: `basic-pyramid`/`inverted-pyramid` declare
+ * `pyraAcctRatio`, shrinking every row's own "level" (self-role) band to
+ * `(1 - pyraAcctRatio)` of its natural width (anchored at the diagram box's
+ * own left edge), with the "accent" (child) role, when present, filling the
+ * remainder of that row's natural slot out to the box's own right edge.
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { BoundingBox, SmartArtLayoutResult } from './smartart-layout-types.js';
+/**
+ * Apply the `pyraAcctRatio` band split (see the module doc comment for the
+ * full COM-verified derivation) as a post-pass over an already-arranged and
+ * already-item-role-expanded pyramid result. `topLevelIds` is `arrangePyramid`'s
+ * own `nodes` argument, in the SAME row order (index = row `i`) - every
+ * "level"/self-role entry's `nodeId` is one of these; every "accent"/
+ * descendant-role entry's `nodeId` is a CHILD of one of these (resolved via
+ * `flatNodes`' own `parentId`).
+ *
+ * `hasAccentSomewhere` (the REAL `func="maxDepth" op="gte" val="2"` condition,
+ * computed by the caller directly from the data tree - "does any top-level
+ * point have a child at all") gates this independently of `pyraAcctRatio`'s
+ * own resolved VALUE: `pyraAcctRatio`'s `dgm:constr` is `dgm:choose`-wrapped,
+ * and the constraint index flattens BOTH branches (the `val="0.32"` `dgm:if`
+ * AND the value-less `dgm:else`) without evaluating the condition (see
+ * `smartart-constraint-solver.ts`'s own doc comment on this limitation) - a
+ * literal scan finds the `0.32` branch's value regardless of which branch
+ * actually applies, wrongly shrinking `basic-pyramid--flat3.pptx`'s own
+ * all-leaf dataset (COM-verified regression: 0.12% -> 31.95% before this
+ * check was added). A no-op (`result` returned unchanged) when EITHER
+ * `pyraAcctRatio` resolves to `0` or `hasAccentSomewhere` is `false`.
+ */
+export declare function repositionPyramidBands(result: SmartArtLayoutResult, box: BoundingBox, planNode: DiagramLayoutNode, topLevelIds: readonly string[], flatNodes: readonly DiagramNode[], hasAccentSomewhere: boolean, index?: ConstraintIndex): SmartArtLayoutResult;
+//# sourceMappingURL=smartart-layout-interpreter-pyramid-bands.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-pyramid-bands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-pyramid-bands.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-pyramid-bands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,OAAO,KAAK,EAAE,WAAW,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AA4D/F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,oBAAoB,EAC5B,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,iBAAiB,EAC3B,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,kBAAkB,EAAE,OAAO,EAC3B,KAAK,GAAE,eAAwC,GAC7C,oBAAoB,CAwDtB"}

package/dist/diagram/layout/smartart-layout-interpreter-pyramid.d.ts

@@ -0,0 +1,100 @@
+/**
+ * SmartArt DiagramML interpreter - pyramid (`pyra`) arranger.
+ *
+ * Stacks the data-model points as horizontal trapezoid bands forming a
+ * triangle. Honours the `sibSp` gap constraint between bands.
+ *
+ * Also honours `dgm:param[@type=pyraLvlNode]` (COM-verified against real
+ * PowerPoint's "Basic Pyramid": `ppt/diagrams/layout1.xml`'s root `dgm:alg
+ * type="pyra"` carries `dgm:param type="pyraLvlNode" val="level"`, naming the
+ * nested `dgm:layoutNode name="level"` that represents each band's own
+ * shape). When that named node's own `dgm:constrLst` declares a `w`/`h`
+ * ratio smaller than the full slot (a `fact`, or a sub-1 literal `val`, the
+ * same convention every other ratio constraint in this interpreter uses),
+ * the rendered band shrinks to that fraction of its slot, centred, leaving a
+ * visible gap, so a hand-authored layout that narrows the level node's own
+ * box actually narrows the band instead of always filling its slot. Real
+ * "Basic Pyramid" declares `w val="1"` / `h val="500"` on `level`, neither of
+ * which qualifies as a ratio (`500` is not less than `1`), so this is a
+ * no-op there, verified byte-identical against the shipped layout via a COM
+ * probe.
+ *
+ * ## `pyraAcctPos` (`dgm:param[@type=pyraAcctPos]`, `bef`/`aft`): NOT a
+ * separate accent-box column
+ *
+ * A previous round of this interpreter modelled `pyraAcctPos` as "move this
+ * band's text into a dedicated rect callout beside the band" (a
+ * `bandX`/`acctX` two-column split), reasoning by analogy with the gallery's
+ * "Pyramid List" variant. That model is WRONG, discovered by COM-verified
+ * regression: of the 227-fixture gallery corpus, only `basic-pyramid` and
+ * `inverted-pyramid` ever declare `pyraAcctPos` at all (grepped every
+ * fixture's `layout1.xml`), and "Pyramid List" (`pyramid-list--*.pptx`)
+ * does NOT use `dgm:alg type="pyra"` for its accent at all - it is a
+ * `composite` of a single decorative `triangle` (`alg="sp"`, one static
+ * shape, not per-item bands) beside a `lin`-arranged list of `roundRect`
+ * items, structurally unrelated to this module. `basic-pyramid`/
+ * `inverted-pyramid`'s cached ground truth for an accented row (a data
+ * point with a child) is TWO TRAPEZOID shapes sharing one band's slot
+ * (`trapezoid` for the point's own text, `nonIsoscelesTrapezoid` for the
+ * child's), not a rect sidebar - a fundamentally different shape family from
+ * the old column model, which produced a `rect` accent box that never
+ * matched any real fixture's preset OR geometry.
+ *
+ * The real, per-item, child-driven accent split (populated only when a data
+ * point HAS a child - `levelTx`/`acctTx`-named roles, `axis="self"`/`"des"`
+ * respectively) is handled upstream by the item-roles module
+ * (`smartart-layout-interpreter-item-role-stack.ts`'s `stackRoleContent`),
+ * which resolves per-point role content against the real tree and produces,
+ * per accented row, TWO polygon entries sharing the ORIGINAL (unsplit) band's
+ * `points` - one tagged `itemRoleName` for the point's own text ("levelTx"),
+ * one for the child's ("acctTx"). This arranger emits ONE plain trapezoid
+ * band per top-level point (matching `basic-pyramid--flat3.pptx`'s all-leaf
+ * dataset exactly, 0.12% residual) and takes no `pyraAcctPos` branch at all.
+ *
+ * ## `pyraAcctRatio` band-splitting geometry (COM-verified,
+ *    `repositionPyramidBands`)
+ *
+ * `basic-pyramid`/`inverted-pyramid` also declare `pyraAcctRatio` (gated on
+ * `func="maxDepth" op="gte" val="2"` - true whenever ANY point in the WHOLE
+ * diagram has a child): once active, EVERY row's own "level" (self-role) band
+ * shrinks uniformly to `(1 - pyraAcctRatio)` of its natural width - COM-
+ * verified across all 3 rows of `basic-pyramid--hier5.pptx` (accented AND the
+ * one unaccented row alike): each row's natural top/bottom x-coordinates,
+ * scaled by this SAME factor anchored at the diagram box's own LEFT edge
+ * (`scaledX = (1 - pyraAcctRatio) * naturalX`, in box-LOCAL coordinates where
+ * the left edge is `x=0`), reproduce the cached "level" band's bounding box
+ * to within rounding for every row (`Node One`/`Three`/`Four`, `pyraAcctRatio
+ * =0.32`). The accent (`acctTx`, only present on a row with a child) then
+ * fills the REMAINDER of that row's natural slot: its own top-left/bottom-
+ * left corners are the level band's own (scaled) top-right/bottom-right
+ * corners - the two bands share a slanted boundary - and its top-right/
+ * bottom-right corners are both the diagram box's own right edge (flush,
+ * vertical), matching the cached `nonIsoscelesTrapezoid` preset's own
+ * asymmetric shape (one slanted side, one vertical). Both derivations
+ * verified independently for all 3 rows of `basic-pyramid--hier5.pptx`
+ * (COM-verified bounding-box match to within 1px on every one).
+ *
+ * `stackRoleContent` has no generic way to split a polygon's own `points`
+ * (unlike a rect, which splits by height) - see `RenderedNodeIdentity.
+ * itemRoleName`'s own doc comment - so `repositionPyramidBands` is the
+ * arranger-specific geometry pass that module's doc comment calls for,
+ * applied as a POST-PASS after `expandResultItemRoles` (keyed by
+ * `itemRoleName` and `nodeId`, not by re-deriving anything `stackRoleContent`
+ * itself decided) rather than folded into `arrangePyramid` itself, so it
+ * never double-splits a row `stackRoleContent` already left alone (a row
+ * with no child keeps its single, unsplit entry - `itemRoleName` stays
+ * `undefined` - but STILL needs the same `pyraAcctRatio` width shrink, since
+ * the ratio is diagram-wide, not per-row).
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ArrangementPlan } from './smartart-layout-interpreter-model.js';
+import type { BoundingBox, SmartArtLayoutResult } from './smartart-layout-types.js';
+export declare const DEFAULT_GAP_RATIO = 0;
+export declare const DEFAULT_INSET = 0;
+/** Execute the `pyra` algorithm: stacked trapezoid bands (apex at top). */
+export declare function arrangePyramid(plan: ArrangementPlan, nodes: DiagramNode[], box: BoundingBox, palette: string[], style: DiagramStyleIntensity, elementId: string, index?: ConstraintIndex, childrenOf?: Map<string, DiagramNode[]>, fontName?: string): SmartArtLayoutResult;
+//# sourceMappingURL=smartart-layout-interpreter-pyramid.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-pyramid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-pyramid.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-pyramid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH,OAAO,KAAK,EAAqB,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAI3E,OAAO,KAAK,EAAE,WAAW,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAU/F,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,aAAa,IAAI,CAAC;AAgB/B,2EAA2E;AAC3E,wBAAgB,cAAc,CAC7B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,WAAW,EAAE,EACpB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,qBAAqB,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,GAAE,eAAwC,EAC/C,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACvC,QAAQ,CAAC,EAAE,MAAM,GACf,oBAAoB,CA2GtB"}

package/dist/diagram/layout/smartart-layout-interpreter-render.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SmartArt DiagramML interpreter - styled node builders.
+ *
+ * Small factory helpers shared by every arranger (linear / cycle / hierarchy /
+ * pyramid / snake) so each arranger file stays focused on geometry rather than
+ * on repeating the fill / stroke / opacity / font wiring. Pure geometry; no
+ * framework code.
+ *
+ * Moved here from `pptx-viewer-shared` so the save/decompose pipeline (which
+ * lives in `pptx-viewer-core`) can call the same interpreter the bindings
+ * render with. See `smartart-layout-types.ts` for the dependency-direction
+ * note.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { RenderedCircleNode, RenderedPolygonNode, RenderedRectNode } from './smartart-layout-types.js';
+/** Resolved stroke width / colour / shadow for a SmartArt style. */
+export interface StyleContext {
+    strokeWidth: number;
+    stroke: string;
+    shadow: string | undefined;
+}
+/** Derive the reusable stroke/shadow context for a style once per layout. */
+export declare function styleContext(style: DiagramStyleIntensity): StyleContext;
+interface RectParams {
+    key: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    node: DiagramNode;
+    index: number;
+    total: number;
+    palette: string[];
+    style: DiagramStyleIntensity;
+    ctx: StyleContext;
+    /** A font size shared by every item in the arranged set; see `presetBoxNode`. */
+    fontSizeOverride?: number | undefined;
+    /** See `RenderedNodeIdentity.descendantFontSize`'s doc comment. */
+    descendantFontSize?: number | undefined;
+}
+/** Build a styled rounded-rect node covering `[x,y,width,height]`. */
+export declare function rectNode(params: RectParams): RenderedRectNode;
+interface CircleParams {
+    key: string;
+    cx: number;
+    cy: number;
+    r: number;
+    /** Independent horizontal/vertical radii for a genuine ellipse; see `RenderedCircleNode.rx`/`.ry`'s doc comment. */
+    rx?: number | undefined;
+    ry?: number | undefined;
+    node: DiagramNode;
+    index: number;
+    total: number;
+    palette: string[];
+    style: DiagramStyleIntensity;
+    ctx: StyleContext;
+    /** A font size shared by every item in the arranged set; see `presetBoxNode`. */
+    fontSizeOverride?: number | undefined;
+    /** See `RenderedNodeIdentity.descendantFontSize`'s doc comment. */
+    descendantFontSize?: number | undefined;
+}
+/** Build a styled circle node centred at `[cx,cy]`. */
+export declare function circleNode(params: CircleParams): RenderedCircleNode;
+interface PolygonParams {
+    key: string;
+    points: string;
+    textX: number;
+    textY: number;
+    fontWidth: number;
+    fontHeight: number;
+    node: DiagramNode;
+    index: number;
+    total: number;
+    palette: string[];
+    style: DiagramStyleIntensity;
+    ctx: StyleContext;
+    /** A font size shared by every item in the arranged set; see `presetBoxNode`. */
+    fontSizeOverride?: number | undefined;
+    /** See `RenderedNodeIdentity.descendantFontSize`'s doc comment. */
+    descendantFontSize?: number | undefined;
+}
+/** Build a styled polygon node from an SVG points string. */
+export declare function polygonNode(params: PolygonParams): RenderedPolygonNode;
+export {};
+//# sourceMappingURL=smartart-layout-interpreter-render.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-render.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAYtD,OAAO,KAAK,EACX,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,MAAM,yBAAyB,CAAC;AAEjC,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,EAAE,qBAAqB,GAAG,YAAY,CAGvE;AAED,UAAU,UAAU;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,qBAAqB,CAAC;IAC7B,GAAG,EAAE,YAAY,CAAC;IAClB,iFAAiF;IACjF,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAwB7D;AAED,UAAU,YAAY;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,oHAAoH;IACpH,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,qBAAqB,CAAC;IAC7B,GAAG,EAAE,YAAY,CAAC;IAClB,iFAAiF;IACjF,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAED,uDAAuD;AACvD,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB,CAsBnE;AAED,UAAU,aAAa;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,qBAAqB,CAAC;IAC7B,GAAG,EAAE,YAAY,CAAC;IAClB,iFAAiF;IACjF,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,mBAAmB,CAqBtE"}

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

@@ -0,0 +1,18 @@
+/**
+ * SmartArt DiagramML interpreter - `snake` arranger.
+ *
+ * Split out of `smartart-layout-interpreter-linear.ts` (which was pushing past
+ * the repo's per-file line budget): `snake` wraps the data-model points into a
+ * boustrophedon grid, honouring `grDir`/`flowDir`/`contDir`/`bkpt`/`off`. Pure
+ * geometry; no framework code. `arrangeLinear` (the `lin` algorithm) stays in
+ * the split-from file; both are re-exported from there so no caller's import
+ * path changes.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ArrangementPlan } from './smartart-layout-interpreter-model.js';
+import type { BoundingBox, SmartArtLayoutResult } from './smartart-layout-types.js';
+/** Execute the `snake` algorithm: a grid honouring `grDir`/`flowDir`/`contDir`/`bkpt`. */
+export declare function arrangeSnake(plan: ArrangementPlan, nodes: DiagramNode[], box: BoundingBox, palette: string[], style: DiagramStyleIntensity, elementId: string, index?: ConstraintIndex, childrenOf?: Map<string, DiagramNode[]>, fontName?: string): SmartArtLayoutResult;
+//# sourceMappingURL=smartart-layout-interpreter-snake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-snake.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-snake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAS3E,OAAO,KAAK,EAAE,WAAW,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE/F,0FAA0F;AAC1F,wBAAgB,YAAY,CAC3B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,WAAW,EAAE,EACpB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,qBAAqB,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,GAAE,eAAwC,EAC/C,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACvC,QAAQ,CAAC,EAAE,MAAM,GACf,oBAAoB,CA0JtB"}

package/dist/diagram/layout/smartart-layout-interpreter-tree-location.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SmartArt DiagramML interpreter - flattened layout-node tree walk.
+ *
+ * Split out of `smartart-layout-interpreter-model.ts` (the repo's per-file
+ * line budget) so `discoverArrangement` can give each visited `dgm:choose`
+ * its declaring node's position among its siblings, sibling count, depth,
+ * and the tree's max depth - the context `dgm:if` needs to decide
+ * `func="pos"`/`"revPos"`/`"posEven"`/`"posOdd"`/`"depth"`/`"maxDepth"` (see
+ * `smartart-layout-interpreter-when.ts`'s `WhenContext`). Pure TypeScript -
+ * no framework code, no DOM.
+ *
+ * @module smartart-layout-interpreter-tree-location
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+/** A node's location within the flattened layout-node tree, for `dgm:if` position/depth functions. */
+export interface TreeLocation {
+    /** 1-based ordinal among this node's own siblings (the parent's `children` array). */
+    position: number;
+    /** Sibling count `position` is measured against (for `revPos`). */
+    total: number;
+    /** 0-based depth from the root. */
+    depth: number;
+}
+/** Depth-first walk of the flattened layout-node tree, tracking each node's {@link TreeLocation}. */
+export declare function walkWithTreeLocation<R>(node: DiagramLayoutNode<R>, visit: (node: DiagramLayoutNode<R>, location: TreeLocation) => void, location?: TreeLocation): void;
+/** Deepest `depth` reached by {@link walkWithTreeLocation} over the whole tree, for `dgm:if func="maxDepth"`. */
+export declare function treeMaxDepth(node: DiagramLayoutNode, depth?: number): number;
+//# sourceMappingURL=smartart-layout-interpreter-tree-location.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-tree-location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-tree-location.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-tree-location.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,sGAAsG;AACtG,MAAM,WAAW,YAAY;IAC5B,sFAAsF;IACtF,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;CACd;AAED,qGAAqG;AACrG,wBAAgB,oBAAoB,CAAC,CAAC,EACrC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,YAAY,KAAK,IAAI,EACnE,QAAQ,GAAE,YAAkD,GAC1D,IAAI,CAUN;AAED,iHAAiH;AACjH,wBAAgB,YAAY,CAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,SAAI,GAAG,MAAM,CAMvE"}

package/dist/diagram/layout/smartart-layout-interpreter-when-numeric.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SmartArt DiagramML interpreter - shared numeric-compare helpers for
+ * `dgm:if` (`ST_FunctionType`) evaluation.
+ *
+ * Split out of `smartart-layout-interpreter-when.ts` (the repo's per-file
+ * line budget): both that file's `evaluateWhen` and
+ * `smartart-layout-interpreter-when-var.ts`'s `evaluateVar` need the same
+ * "parse a branch threshold" and "apply `@op` to a numeric pair" logic.
+ * Pure TypeScript - no framework code, no DOM.
+ */
+/** Parse a numeric branch threshold, or `undefined` when non-numeric. */
+export declare function toNumber(value: string): number | undefined;
+/** Apply `when.operator` to compare `actual` against a numeric `threshold`. */
+export declare function compareNumeric(actual: number, operator: string, threshold: number): boolean | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-when-numeric.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-when-numeric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-when-numeric.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-when-numeric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG1D;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAC7B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GACf,OAAO,GAAG,SAAS,CAiBrB"}

package/dist/diagram/layout/smartart-layout-interpreter-when-var.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:if/@func="var"` evaluation.
+ *
+ * Split out of `smartart-layout-interpreter-when.ts` (the repo's per-file
+ * line budget): compares a diagram's own `presLayoutVars` (`dgm:varLst`)
+ * against a `dgm:if`'s `@arg`/`@val`. Pure TypeScript - no framework code,
+ * no DOM.
+ */
+import type { DiagramPresLayoutVars, DiagramWhen } from '../model/index.js';
+/** Evaluate `func="var"`: compare `presLayoutVars[@arg]` against `when.value`. */
+export declare function evaluateVar(when: DiagramWhen, presLayoutVars: DiagramPresLayoutVars): boolean | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-when-var.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-when-var.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-when-var.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-when-var.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAqCnE,kFAAkF;AAClF,wBAAgB,WAAW,CAC1B,IAAI,EAAE,WAAW,EACjB,cAAc,EAAE,qBAAqB,GACnC,OAAO,GAAG,SAAS,CAuBrB"}

package/dist/diagram/layout/smartart-layout-interpreter-when.d.ts

@@ -0,0 +1,69 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:if` (`ST_FunctionType`) evaluation.
+ *
+ * Split out of `smartart-layout-interpreter-flow.ts` to keep that file under
+ * the repo's per-file line budget. Implements ECMA-376's 8 `dgm:if/@func`
+ * values (`cnt`/`pos`/`revPos`/`posEven`/`posOdd`/`var`/`depth`/`maxDepth`)
+ * against every comparison operator (`equ`/`neq`/`gt`/`lt`/`gte`/`lte`).
+ * Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramNode, DiagramPresLayoutVars, DiagramWhen } from '../model/index.js';
+/**
+ * Extra evaluation context beyond the node count, letting {@link evaluateWhen}
+ * decide the `func` values ECMA-376 defines against a specific point's
+ * position/depth or the diagram's own `presLayoutVars`, when a caller has that
+ * context available. Every field is optional: `discoverArrangement`
+ * (`smartart-layout-interpreter-model.ts`) supplies the declaring layout
+ * node's own tree location (position among siblings, sibling count, depth,
+ * the tree's max depth) for every `choose` it walks, so `pos`/`revPos`/
+ * `posEven`/`posOdd`/`depth`/`maxDepth` are decidable in production, not just
+ * in unit tests. A caller with no tree location to offer (e.g. a bare
+ * `chooseAlgType` call from a test) simply omits these fields and those
+ * functions stay undecidable, exactly as before - no regression.
+ */
+export interface WhenContext {
+    /** 1-based ordinal position of the point being evaluated, for `pos`/`revPos`/`posEven`/`posOdd`. */
+    position?: number | undefined;
+    /** Sibling count the position is measured against, for `revPos`. */
+    total?: number | undefined;
+    /** Depth of the point/node being evaluated, for `func="depth"`. */
+    depth?: number | undefined;
+    /** Maximum depth of the tree, for `func="maxDepth"`. */
+    maxDepth?: number | undefined;
+    /** Diagram presentation layout variables, for `func="var"` (`@arg` names the variable). */
+    presLayoutVars?: DiagramPresLayoutVars | undefined;
+    /**
+     * The diagram's own flat data-model node array (`parentId`-linked), for a
+     * `func="cnt"` `dgm:if` whose `@axis` is declared at all - a single bare
+     * hop (`axis="ch"`, "the context point's own children"), a sub-range
+     * select (`@st`/`@cnt`), or a compound multi-hop chain (`axis="ch ch"`,
+     * "my first child's own children") - see {@link resolveAxisCount}.
+     * Omitted by a caller with no data-model tree to offer keeps the older,
+     * coarser `nodeCount`-only behaviour for `cnt` exactly as before (no
+     * regression for a caller that never had this).
+     */
+    nodes?: DiagramNode[] | undefined;
+    /**
+     * The point(s) a `dgm:if`'s own enclosing `dgm:forEach` bound (its
+     * `DiagramLayoutNode.forEachOrigin`, already resolved to real data
+     * nodes), for a `func="maxDepth"` `dgm:if` whose `@axis` needs anchor-
+     * relative navigation rather than the diagram root - see {@link
+     * resolveAxisMaxDepth}'s own doc comment (`smartart-layout-interpreter-
+     * axis-depth.ts`) for the derivation. Omitted by a caller with no anchor
+     * to offer keeps the older `context.maxDepth`-only behaviour for
+     * `maxDepth` exactly as before (no regression for a caller that never had
+     * this - no existing caller populates this field yet).
+     */
+    anchor?: DiagramNode[] | undefined;
+}
+/**
+ * Evaluate a single `dgm:if`. `func="cnt"` (against `resolveAxisCount` when
+ * `when.axis` is declared and real tree navigation is available, else the
+ * caller's own flat `nodeCount`) is always decidable; `pos`/`revPos`/
+ * `posEven`/`posOdd`/`depth`/`maxDepth`/`var` are decidable only when
+ * `context` supplies the matching field - otherwise this returns `undefined`
+ * so the caller keeps its blind first-alg behaviour.
+ */
+export declare function evaluateWhen(when: DiagramWhen, nodeCount: number, context: WhenContext): boolean | undefined;
+export { resolvePresentationOf } from './smartart-layout-interpreter-presof-choose.js';
+//# sourceMappingURL=smartart-layout-interpreter-when.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-when.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-when.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-when.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAMhF;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW;IAC3B,oGAAoG;IACpG,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,2FAA2F;IAC3F,cAAc,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACnD;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,WAAW,EAAE,GAAG,SAAS,CAAC;IAClC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,WAAW,EAAE,GAAG,SAAS,CAAC;CACnC;AAcD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,GAClB,OAAO,GAAG,SAAS,CAiIrB;AAMD,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC"}

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

@@ -0,0 +1,80 @@
+/**
+ * SmartArt DiagramML interpreter - public entry point + dispatch.
+ *
+ * Walks a parsed `dgm:layoutDef` (`DiagramLayoutDefinition`) and, when it
+ * recognises the primary `dgm:alg` family, executes a real (partial) layout for
+ * the actual data-model nodes: linear (`lin`), cycle (`cycle`), hierarchy
+ * (`hierRoot`/`hierChild`), pyramid (`pyra`), snake (`snake`), composite
+ * (`composite`), and the auxiliary connector/spacer/text leaves (`conn`/`sp`/
+ * `tx`). Otherwise it returns `undefined` so the caller keeps the legacy family
+ * approximation.
+ *
+ * This is intentionally a *partial* interpreter (see
+ * `smartart-layout-interpreter-model.ts` for the honest scope note): it
+ * honours the arrangement algorithm, direction/angle params, and scalar
+ * `dgm:constr` factors, and executes the decidable parts of `dgm:forEach`
+ * (st/cnt/step + hideLastTrans) and `dgm:choose` (count-decidable branch
+ * selection), but does not run the full recursive constraint-reference solver.
+ *
+ * Lives in `pptx-viewer-core` (moved from `pptx-viewer-shared`) so it is the
+ * SINGLE interpreter used both by the SVG-fallback preview path (every
+ * binding, via `pptx-viewer-shared`'s re-export) and by this package's own
+ * save/decompose pipeline (`smartart-decompose.ts`,
+ * `smartart-interpreter-drawing-bridge.ts`). Only runs on the path with no
+ * cached `dsp` drawing part; a pre-existing cache still wins (see
+ * `PptxHandlerRuntimeSaveDocumentParts.ts`).
+ */
+import type { DiagramLayoutDefinition, DiagramNode, DiagramPresLayoutVars } from '../model/index.js';
+import type { DiagramConnection } from '../types.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { BoundingBox, SmartArtLayoutResult } from './smartart-layout-types.js';
+import type { SmartArtColorRoleMap } from './smartart-node-role-colors.js';
+import type { RawXmlView } from './smartart-choose-xml.js';
+/** Inputs for a single interpreter run. */
+export interface InterpretLayoutInput {
+    /** Parsed layout definition (from `DiagramData.layoutDefinition`). */
+    layoutDefinition: DiagramLayoutDefinition | undefined;
+    /** Original (possibly nested) data-model nodes - used for hierarchy. */
+    nodes: DiagramNode[];
+    /** Depth-first flattened nodes - used for flat arrangements. */
+    flat: DiagramNode[];
+    box: BoundingBox;
+    palette: string[];
+    style: DiagramStyleIntensity;
+    elementId: string;
+    /** Presentation layout variables (direction / hierBranch / orgChart). */
+    presLayoutVars?: DiagramPresLayoutVars;
+    /**
+     * Per-styleLbl-role resolved colour lists (from
+     * `PptxSmartArtColorTransform.roleColors`): a node whose {@link
+     * DiagramNode.styleRole} matches a key gets that role's own cycled
+     * fill colour instead of the generic `palette` cycling - see
+     * `smartart-node-role-colors.ts`.
+     */
+    colorRoles?: SmartArtColorRoleMap;
+    /**
+     * Data-model connections (from `DiagramData.connections`): labels a
+     * hierarchy `parOf` edge's connector from its `parTrans` text, and
+     * resolves a transition-bound item role's ordinal text (a numbered badge)
+     * from its `sibTrans`/`parTrans` text - via `connection.label`.
+     */
+    connections?: DiagramConnection[];
+    /**
+     * The deck's own theme minor-Latin font (`DiagramData.themeMinorFont`),
+     * threaded through to every arranger's font-fit so text is measured
+     * against the REAL font PowerPoint renders it in. `undefined` falls back
+     * to the default in `smartart-layout-item-font-size.ts`.
+     */
+    fontName?: string;
+}
+/**
+ * Interpret the layout definition, or return `undefined` when it is not
+ * understood (no recognised arrangement algorithm, or no nodes to place).
+ *
+ * When an arrangement is produced, every node's manual `dgm:pt/dgm:prSet`
+ * `cust*` override (drag/resize/rotate/flip performed in PowerPoint's own
+ * diagram editor) is applied as a final transform, so a manually-placed node
+ * does not revert to its algorithmic position.
+ */
+export declare function interpretSmartArtLayout(view: RawXmlView<unknown>, input: InterpretLayoutInput): SmartArtLayoutResult | undefined;
+//# sourceMappingURL=smartart-layout-interpreter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AA2BtD,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAWxD,2CAA2C;AAC3C,MAAM,WAAW,oBAAoB;IACpC,sEAAsE;IACtE,gBAAgB,EAAE,uBAAuB,GAAG,SAAS,CAAC;IACtD,wEAAwE;IACxE,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,gEAAgE;IAChE,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,GAAG,EAAE,WAAW,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,qBAAqB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAsJD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,KAAK,EAAE,oBAAoB,GACzB,oBAAoB,GAAG,SAAS,CAOlC"}

package/dist/diagram/layout/smartart-layout-item-font-role.d.ts

@@ -0,0 +1,80 @@
+/**
+ * SmartArt DiagramML interpreter - `primFontSz` bounds resolution.
+ *
+ * Split out of `smartart-layout-item-font-size.ts` (the file-size budget):
+ * this half resolves WHICH layoutNode a font-fit call should key its
+ * `primFontSz` ceiling/floor off, and what those bounds are in pixels; that
+ * module's `resolveSharedItemFontSize`/`resolveRoleFontSize` consume
+ * {@link nodeFontBounds}, `smartart-layout-interpreter-linear.ts` consumes
+ * {@link primFontSzCeilingPx} directly.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ArrangementPlan } from './smartart-layout-interpreter-model.js';
+/**
+ * The item template's OWN self-scoped `h`/`w` aspect ratio (`<dgm:constr
+ * type="h" refType="w" fact="0.6"/>`, no `for` attribute at all - a
+ * self-reference, not an arranger-declared per-item constraint), when one is
+ * declared. `undefined` when the item declares no such self-scoped aspect.
+ *
+ * This is DELIBERATELY a different question from `arrangeLinear`'s own
+ * `itemAspect` (`smartart-layout-interpreter-linear.ts`), which intentionally
+ * ignores this exact same self-scoped constraint for DISPLAY geometry: measured
+ * against `basic-process--flat3.pptx`, a genuinely UNCONSTRAINED (no
+ * arranger-declared aspect) item's cached box spans the container's FULL
+ * cross-axis extent, so applying its OWN self-scoped `h refType="w" fact="0.6"`
+ * there would shrink the DISPLAYED box wrongly (regressing the ~2-4% geometry
+ * deviation to 70-90%, per `resolveConstraintDeclaredBy`'s doc comment). Font
+ * FIT, however, is a SEPARATE question PowerPoint solves against a smaller
+ * effective text box even when the displayed box fills the container: using
+ * this self-scoped aspect as a font-fit-only height cap (instead of the full
+ * cross-axis extent) moves the computed size from roughly 2x the cached
+ * `a:rPr/@sz` to within a few points of it on that same fixture.
+ *
+ * A layoutDef can declare this SAME self-scoped relationship in either
+ * direction: `h refType="w"` (height as a factor of width, `factor` IS the
+ * h/w aspect directly) or the inverse, `w refType="h"` (width as a factor of
+ * height, so the h/w aspect is `1/factor`) - "Vertical Process"'s real
+ * `layout1.xml` declares `<dgm:constr type="w" refType="h" fact="1.8"/>`
+ * (self-scoped, no `for`), which the h-only search above always missed,
+ * leaving `naturalAspect` `undefined` and the font fitter solving against
+ * the item's full, un-capped column height instead - measured: this item's
+ * font landed at ~34pt against a cached 24pt (`smartart-gallery-ground-
+ * truth.test.ts`), NOT the `dgm:choose`-branch-selection bug round 4
+ * originally suspected (this layoutDef declares no `primFontSz` `dgm:choose`
+ * at all; there is exactly one ceiling, `val="65"`, for the `node` role).
+ * Recognising the inverted form too (`1.8` -> aspect `1/1.8` = `0.5556`)
+ * fixes it generally, for any layoutDef using either authoring direction.
+ */
+export declare function resolveItemSelfAspect(item: DiagramLayoutNode | undefined): number | undefined;
+/** The `primFontSz` ceiling and `dgm:ruleLst` shrink floor for a resolved role, in PIXELS. */
+export interface FontBounds {
+    ceilingPx: number;
+    floorPx: number;
+    role: string;
+}
+/**
+ * The `primFontSz` ceiling and `dgm:ruleLst` shrink floor for `fontRoleCandidate`
+ * (or the first genuine text-role descendant found under it, see
+ * {@link findFontRoleNode}), in PIXELS. `arranger` supplies the fallback role
+ * name when nothing resolves, and the ARRANGER-scoped floor-rule extension
+ * ({@link primFontSzFloorRuleValues}'s `for="ch"` search) - for a per-role
+ * caller (`resolveRoleFontSize` in `smartart-layout-item-font-size.ts`) that
+ * has no separate arranger node to offer, passing the role node itself for
+ * both parameters is safe: a self-scoped `dgm:rule` carries no `for`
+ * attribute, so the arranger-scoped search over the SAME node's own rules
+ * simply finds nothing extra.
+ */
+export declare function nodeFontBounds(fontRoleCandidate: DiagramLayoutNode | undefined, arranger: DiagramLayoutNode, index: ConstraintIndex): FontBounds;
+/** The item role's declared `primFontSz` ceiling and `dgm:ruleLst` shrink floor, in PIXELS. */
+export declare function itemFontBoundsPx(plan: ArrangementPlan, index: ConstraintIndex): FontBounds;
+/**
+ * The item role's declared `primFontSz` ceiling, in PIXELS - exposed for a
+ * caller (`smartart-layout-interpreter-linear.ts`) that needs the SAME
+ * ceiling `resolveSharedItemFontSize` uses, to convert an ABSOLUTE
+ * `refType="primFontSz"` main-axis gap/extent (e.g. "Vertical Bullet List"'s
+ * `spacer` role, `<dgm:constr type="h" ... refType="primFontSz" fact="0.08"/>`)
+ * into pixels before it participates in that axis's geometry.
+ */
+export declare function primFontSzCeilingPx(plan: ArrangementPlan, index: ConstraintIndex): number;
+//# sourceMappingURL=smartart-layout-item-font-role.d.ts.map

package/dist/diagram/layout/smartart-layout-item-font-role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-item-font-role.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-item-font-role.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAS3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAsB7F;AA+ED,8FAA8F;AAC9F,MAAM,WAAW,UAAU;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC7B,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,EAChD,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,eAAe,GACpB,UAAU,CAUZ;AAED,+FAA+F;AAC/F,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAE1F;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM,CAEzF"}