ooxml-core 1.1.0 → 1.2.0

package/dist/diagram/layout/smartart-layout-interpreter-composite-group-slots.d.ts

@@ -0,0 +1,92 @@
+/**
+ * SmartArt DiagramML interpreter - choose-aware candidate grouping + slot
+ * resolution.
+ *
+ * Split out of `smartart-layout-interpreter-composite-choose.ts` (the
+ * repo's per-file line budget): {@link resolveGroupedSlots} groups the raw
+ * candidates `collectRawCandidates` collects there by their resolved
+ * content (several layoutNodes can anchor to the EXACT same point set - see
+ * this module's own doc comment on the decorative/text pairing), then
+ * resolves ONE rect per group.
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { Slot } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox } from './smartart-layout-types.js';
+/** One resolved choose-aware slot: its final rect, the node(s) it renders
+ * (the first is primary, the rest fold in as extra paragraphs), the
+ * WINNING candidate's own layoutNode (round 28: for `findCompositeItemShape`
+ * to resolve the slot's real declared preset from, instead of the caller's
+ * own hardcoded family default - `arrangeByChooseAwareSlots` never had
+ * access to this before, so every slot silently fell through to the same
+ * generic `roundRect`/`rect` fallback regardless of what the layout actually
+ * declared), and the candidate's own `declaringRole` (round 29: the NAME of
+ * the nearest enclosing bare-wrapper `layoutNode` this slot was discovered
+ * under - `child1group` vs `circle` in `cycle-matrix`, or a single shared
+ * count-branch wrapper for `upward-arrow`'s `textBoxN`/`arrowDiagramN` -
+ * for per-group font-fit, see `arrangeByChooseAwareSlots`'s own doc
+ * comment). */
+export interface ChooseAwareSlot {
+    rect: Slot;
+    content: DiagramNode[];
+    node: DiagramLayoutNode;
+    declaringRole: string;
+}
+/** A choose-live, `presOf`-bearing candidate found by `collectRawCandidates` (`smartart-layout-interpreter-composite-choose.ts`), not yet resolved to a rect. */
+export interface RawSlotCandidate {
+    node: DiagramLayoutNode;
+    declaringRole: string;
+    /**
+     * Round 32: every ancestor role (nearest first, `declaringRole` itself
+     * included) between `node` and the composite root, for a `node` reached
+     * through a bare pass-through wrapper that has no `constrLst` of its own
+     * (`linV` inside `linH` - see `smartart-layout-interpreter-composite-
+     * slots.ts`'s `dimDeclaredBy`). `undefined` for every pre-existing
+     * candidate path (unaffected) - `readSlots` falls back to `declaringRole`
+     * alone in that case.
+     */
+    declaringRoleChain?: readonly string[] | undefined;
+    content: DiagramNode[];
+    /** This candidate's 0-based position among every candidate `resolveAnchoredContentPerAnchor` produced for the SAME `node` (0/1 for a single-anchor or root-relative slot, unchanged from before per-iteration splitting existed). */
+    iteration: number;
+    /** How many total candidates `resolveAnchoredContentPerAnchor` produced for the SAME `node` - see {@link resolveIterationRect}. */
+    iterationCount: number;
+}
+/**
+ * Group `candidates` by their resolved content (several layoutNodes can
+ * anchor to the EXACT same point set - `Basic Venn`'s `circ1` (`dgm:alg
+ * type="sp"`, the real, PAINTED ellipse) and `circ1Tx` (`alg="tx"`, `dgm:shape
+ * type="rect" hideGeom="1"`, a text-only sizing box) share the exact SAME
+ * `forEachOrigin` anchor, so both resolve to the SAME content - without
+ * merging, that content would be folded in TWICE), then resolve ONE rect per
+ * group: try each member's OWN `readSlots` in turn, preferring a VISIBLE
+ * (non-`hideGeom`) shape first - PowerPoint's own cached drawing renders the
+ * data point's text INSIDE the painted shape's own box (`dsp:sp`'s `a:xfrm`),
+ * using a `hideGeom` sibling's box only to size/wrap the TEXT internally
+ * (`dsp:txXfrm`, a separate field this interpreter does not model), never as
+ * a second shape - `Basic Venn`'s cached `circ1` ellipse carries "Alpha"
+ * directly; there is no separate `circ1Tx` shape in the cache at all. Both
+ * `circ1` and `circ1Tx` resolve a REAL slot here (the arranger's own
+ * `dgm:choose` declares `for="ch" forName="circ1"` AND `forName="circ1Tx"`
+ * geometry), so ordering purely by algorithm type (the pre-existing rule)
+ * picked the `hideGeom` text box's small inset rect instead of the visible
+ * shape's own box - wrong preset (`rect` instead of `ellipse`) and wrong
+ * geometry. Falls back to a `hideGeom` member's slot when no visible member
+ * has one - `Staggered Process`'s `ThreeNodes_3_text` (`hideGeom`) has no
+ * `readSlots`-resolvable constraint of its own at all; only its visible `sp`
+ * sibling `ThreeNodes_3` does, so visibility ordering reaches the same
+ * member this rule already preferred. Among members that tie on visibility,
+ * keep the pre-existing non-`sp`-first tiebreak. Merging also RECOVERS
+ * geometry a text-only member lacks - dropping `sp` candidates outright (an
+ * earlier, simpler version of this fix) lost that geometry along with the
+ * duplicate, silently dropping the whole slot instead of just de-duplicating
+ * it. A group with NO positioned member anywhere is dropped (matches the
+ * pre-existing "no slot resolves -> no content" behaviour). A group born
+ * from a multi-anchor forEach split (see `collectRawCandidates`) is sliced
+ * within its shared container via {@link resolveIterationRect} instead of
+ * resolved at the container's own full size.
+ */
+export declare function resolveGroupedSlots(candidates: RawSlotCandidate[], box: BoundingBox, index: ConstraintIndex): ChooseAwareSlot[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-group-slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-group-slots.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-group-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,+CAA+C,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;;;;;;;;;;eAYe;AACf,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,IAAI,EAAE,iBAAiB,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,iKAAiK;AACjK,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,iBAAiB,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACnD,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,qOAAqO;IACrO,SAAS,EAAE,MAAM,CAAC;IAClB,mIAAmI;IACnI,cAAc,EAAE,MAAM,CAAC;CACvB;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,gBAAgB,EAAE,EAC9B,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,eAAe,GACpB,eAAe,EAAE,CAgDnB"}

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

@@ -0,0 +1,45 @@
+/**
+ * SmartArt DiagramML interpreter - per-`forEach`-iteration slot geometry.
+ *
+ * Split out of `smartart-layout-interpreter-composite-choose.ts` (the
+ * repo's per-file line budget): {@link resolveIterationRect} slices ONE
+ * shared container rect for a candidate born from a multi-anchor
+ * `forEachOrigin` split (see that module's `collectRawCandidates` - a
+ * genuine "one item template, N `dgm:forEach` iterations" instance,
+ * `nested-target--hier5.pptx`'s `oChild`).
+ *
+ * Pure geometry; no framework code.
+ */
+import type { Slot, SlotDims } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox } from './smartart-layout-types.js';
+/**
+ * One `readSlots`-resolved `dims`, resolved to a rect and - for a candidate
+ * from a multi-anchor `forEachOrigin` split (`iterationCount > 1`) - SLICED
+ * for `iteration`-of-`iterationCount`. Every iteration of the SAME
+ * layoutNode shares the identical `dims` (one physical template,
+ * instantiated N times, positioned only as a group by whatever arranges its
+ * CONTAINER - `nested-target--hier5.pptx`'s `oChild` has no `l`/`t`/`ctrX`/
+ * `ctrY` of its own at all, only a `w`/`h` reference to its wrapper), so the
+ * unsliced rect is the shared area every iteration must tile: divided
+ * evenly along whichever axis is longer (a `dgm:alg type="lin"` container
+ * arranges its items along its own longer axis in every fixture measured).
+ * Resolving the container's OWN, often choose-wrapped, `linDir` param
+ * precisely instead of inferring direction from aspect ratio is a separate,
+ * deeper gap: the container's own positioning constraint chain
+ * (`smartart-constraint-solver.ts`/`smartart-constraint-declared-by.ts`) is
+ * not itself `chooseGuard`-aware yet, so a choose-wrapped container
+ * constraint (`nested-target`'s `outerBoxChildren`, whose own `l`/`t`/`w`/`h`
+ * are declared inside a `dir`-conditioned `dgm:choose` on its parent) can
+ * resolve to the WRONG branch's numbers - measured on `nested-target`
+ * itself: its container rect resolves to the diagram's full bounding box
+ * rather than the ~0.95x0.45 sub-rect the live branch declares, so this
+ * slicing still lands well outside the gate's 1% geometry tolerance for
+ * that fixture even though the shape COUNT and per-shape TEXT are now
+ * correct. Not fixed here (Track L/R's `smartart-constraint-solver.ts`
+ * ownership, and a materially bigger fix than this module's own scope);
+ * this is the best a `composite*.ts`-scoped fix can do until that lands.
+ * `iterationCount <= 1` is the pre-existing single-instance behaviour,
+ * byte-for-byte unchanged.
+ */
+export declare function resolveIterationRect(dims: SlotDims, box: BoundingBox, iteration: number, iterationCount: number): Slot;
+//# sourceMappingURL=smartart-layout-interpreter-composite-iteration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-iteration.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-iteration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,GACpB,IAAI,CAWN"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-nested-cycle.d.ts

@@ -0,0 +1,57 @@
+/**
+ * SmartArt DiagramML interpreter - nested cycle (hub-and-satellite ring)
+ * dispatch for a composite child-repeater slot.
+ *
+ * `radial-cluster--hier5.pptx`'s `cycle_3` is a bare-`presOf` child-repeater
+ * slot (see `smartart-layout-interpreter-composite-children.ts`) whose own
+ * `dgm:alg` (direct or choose-wrapped) is ITSELF a `cycle` - a genuine
+ * 2-level nested hub-and-satellite ring, not a flat per-child repeat: its
+ * own child `childCenter3` (`presOf axis="self"`) resolves to exactly ONE
+ * anchor's child, which in turn has children of ITS OWN. Rather than
+ * reimplementing ring/hub geometry, this recurses into the EXISTING
+ * `arrangeCycle` arranger (`smartart-layout-interpreter-cycle.ts`): its
+ * pre-existing `ctrShpMap="fNode"` hub-peeling already places one anchor at
+ * the ring centre and its children around it - exactly the same mechanism a
+ * genuine top-level hub-and-satellite diagram (`basic-radial`/
+ * `diverging-radial`) already uses, just invoked one level deeper. Pure
+ * geometry; no framework code.
+ */
+import type { DiagramLayoutNode, DiagramNode, DiagramPresLayoutVars } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { SlotStyleContext } from './smartart-layout-interpreter-composite-render.js';
+import type { SlottedDims } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox, RenderedNode } from './smartart-layout-types.js';
+import type { RawXmlView } from './smartart-choose-xml.js';
+/**
+ * `wrapper`'s own nested-cycle anchor: when it is a bare-`presOf`
+ * child-repeater slot (see {@link collectChildRepeaterItems}) that resolves
+ * to EXACTLY ONE item, AND that item's own data-model point has further
+ * children of its own (`childrenOf`), that item is a genuine nested
+ * hub-and-satellite anchor - `radial-cluster--hier5.pptx`'s `cycle_3`
+ * resolving to "Four" (`anchor`'s 3rd child, "Node One"), itself the parent
+ * of "Five". `undefined` for every other shape: no items resolved, 2+ items
+ * (a flat per-child repeat, not a nested ring), or a childless single item
+ * (nothing to ring-arrange around it).
+ */
+export declare function resolveNestedCycleAnchor(wrapper: DiagramLayoutNode, anchor: DiagramNode, childrenOf: Map<string, DiagramNode[]>): DiagramNode | undefined;
+/**
+ * Render `wrapperSlot` as a nested cycle, or `undefined` when it is not one
+ * (the caller falls back to `renderChildRepeaterSlot`'s flat per-child
+ * repeat). `anchor` is the OUTER composite's own currently-arranged point
+ * (`arrangeByPresentationOf`'s own loop variable) - both the point
+ * `resolveNestedCycleAnchor` resolves `wrapper`'s own item against, AND the
+ * `WhenContext.anchor` a `func="cnt"` condition in `wrapper`'s own
+ * `dgm:choose` needs (`cycle_3`'s own `stAng`/`spanAng` choose counts
+ * `anchor`'s OWN children, not the resolved nested anchor's).
+ */
+export declare function arrangeNestedCycleSlot(view: RawXmlView<unknown>, wrapperSlot: SlottedDims, anchor: DiagramNode, box: BoundingBox, absX: number, absY: number, childrenOf: Map<string, DiagramNode[]>, nodeCount: number, flat: DiagramNode[], presLayoutVars: DiagramPresLayoutVars | undefined, index: ConstraintIndex, palette: string[], style: DiagramStyleIntensity, elementId: string, fontName: string | undefined, declaringRoleChain?: readonly string[], sizeBox?: BoundingBox): RenderedNode[] | undefined;
+/**
+ * `arrangeNestedCycleSlot`, falling back to the plain flat per-child repeat
+ * (`renderChildRepeaterSlot`) when `wrapperSlot` is not a nested cycle -
+ * the one call `arrangeByPresentationOf`'s own childRepeaterSlots loop makes
+ * per wrapper slot (`smartart-layout-interpreter-composite.ts`, split out
+ * here for the file-size budget).
+ */
+export declare function renderChildRepeaterOrNestedCycle(view: RawXmlView<unknown>, wrapperSlot: SlottedDims, anchor: DiagramNode, anchorIndex: number, box: BoundingBox, absX: number, absY: number, childrenOf: Map<string, DiagramNode[]>, flat: DiagramNode[], presLayoutVars: DiagramPresLayoutVars | undefined, index: ConstraintIndex, ctx: SlotStyleContext, fontName: string | undefined, declaringRoleChain?: readonly string[], sizeBox?: BoundingBox): RenderedNode[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-nested-cycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-nested-cycle.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-nested-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAQpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AAEvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAGjF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACpC,WAAW,GAAG,SAAS,CAQzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,WAAW,EAAE,EACnB,cAAc,EAAE,qBAAqB,GAAG,SAAS,EACjD,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,qBAAqB,EAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,EACtC,OAAO,CAAC,EAAE,WAAW,GACnB,YAAY,EAAE,GAAG,SAAS,CAgC5B;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC/C,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,IAAI,EAAE,WAAW,EAAE,EACnB,cAAc,EAAE,qBAAqB,GAAG,SAAS,EACjD,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,EACtC,OAAO,CAAC,EAAE,WAAW,GACnB,YAAY,EAAE,CAyChB"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-order-fallback.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SmartArt DiagramML interpreter - order-based composite slot fallback.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` (the repo's
+ * per-file line budget): {@link arrangeByOrder} is the LAST-resort mapping
+ * `arrangeComposite` falls back to when no slot carries a `dgm:presOf` at
+ * all - pre-existing behaviour: one arranged point per positioned slot, in
+ * document order. Pure geometry; no framework code.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { FontFitContext } from './smartart-layout-interpreter-composite-fontfit.js';
+import type { SlotStyleContext } from './smartart-layout-interpreter-composite-render.js';
+import type { SlottedDims } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox, RenderedNode } from './smartart-layout-types.js';
+/**
+ * Pre-existing behaviour: one arranged point per positioned slot, in
+ * document order. `representativeSlotsPerPoint` (round 40) collapses a
+ * repeated per-point template's multiple positioned roles (text + accent +
+ * picture + picture-accent, `hexagon-cluster`-family composites) down to one
+ * slot per point FIRST, so this still zips 1:1 against `nodes` - see that
+ * function's own doc comment.
+ */
+export declare function arrangeByOrder(slotted: SlottedDims[], nodes: DiagramNode[], box: BoundingBox, absX: number, absY: number, ctx: SlotStyleContext, fontCtx: FontFitContext | undefined): RenderedNode[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-order-fallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-order-fallback.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-order-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AAGtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AAEvF,OAAO,KAAK,EAAQ,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAGvF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAMzE;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,KAAK,EAAE,WAAW,EAAE,EACpB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,cAAc,GAAG,SAAS,GACjC,YAAY,EAAE,CAwChB"}

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

@@ -0,0 +1,41 @@
+/**
+ * SmartArt DiagramML interpreter - order-based composite slot de-duplication.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` (the repo's
+ * per-file line budget): {@link representativeSlotsPerPoint} is a helper for
+ * `arrangeByOrder`, the "one arranged point per positioned slot, in document
+ * order" fallback used when neither `arrangeByPresentationOf` nor
+ * `arrangeByChooseAwareSlots` resolves the composite (see that module's own
+ * doc comment).
+ *
+ * `hexagon-cluster--hier5.pptx` (and the whole "transition-nested repeated
+ * template" family sharing its authoring idiom: `bubble-picture-list`,
+ * `circle-process`, `theme-picture-accent`, ...) declares, per top-level
+ * point, FOUR separate positioned roles under one `dgm:choose` count-branch:
+ * `textN` (the real, text-bearing hexagon), `textaccentN`/`imageN`/
+ * `imageaccentN` (decorative accent/picture-placeholder hexagons for the
+ * SAME point, positioned by their own `for="ch" forName="textaccentN"`-style
+ * constraints declared on the SAME composite root). `readSlots` (called once,
+ * composite-root-wide) returns all four PER POINT as separate `SlottedDims`
+ * entries with no data-anchor of their own - `arrangeByOrder` previously
+ * zipped `slotted[i]` <-> `nodes[i]` positionally, so for 3 real points it
+ * consumed `text1, textaccent1, image1` (point 1's own four roles) instead of
+ * `text1, text2, text3` (one representative role per point) - point 2's
+ * label rendered inside point 1's tiny accent box, point 3's inside point
+ * 1's picture box. Confirmed against `hexagon-cluster--hier5.pptx`'s cached
+ * drawing: `Node Three` (point 2) belongs in a 234x202 hexagon at
+ * `x=469,y=341`, not the 27x24 accent-sized box the old zip produced.
+ */
+import type { SlottedDims } from './smartart-layout-interpreter-composite-slots.js';
+/**
+ * When `slotted` carries MORE positioned entries than there are points, and
+ * splits evenly into `pointCount` equal-sized runs (the repeated
+ * per-point-template shape described above), collapse each run down to ONE
+ * representative slot: the run's own text role when it has one, else its
+ * first non-`hideGeom` member, else its first member outright. Returns
+ * `slotted` UNCHANGED whenever it does not already carry (a whole multiple
+ * of) more entries than points - the ordinary "one slot per point" case
+ * every other composite relies on, so this is a no-op there.
+ */
+export declare function representativeSlotsPerPoint(slotted: SlottedDims[], pointCount: number): SlottedDims[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-order.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-order.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-order.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AASjF;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAChB,WAAW,EAAE,CAkBf"}

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

@@ -0,0 +1,34 @@
+/**
+ * SmartArt DiagramML interpreter - `self`+`des` slot pairing for the
+ * `composite` arranger's `dgm:presOf`-aware mapping.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` (the repo's
+ * per-file line budget): `arrangeByPresentationOf` needs this same
+ * self-rect/des-fold resolution BEFORE it can run the shared font-fit
+ * (round 18, `smartart-layout-interpreter-composite-fontfit.ts`) - the fit
+ * needs every item's box and descendant text up front, not discovered one
+ * at a time while rendering.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { Slot, SlottedDims } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox } from './smartart-layout-types.js';
+/** One `self`-anchored point, its resolved rect, and its paired `des` fold (when any). */
+export interface SelfDesPair {
+    node: DiagramNode;
+    selfRect: Slot;
+    /**
+     * The `self` slot's OWN layoutNode (round 28: for `findCompositeItemShape`
+     * to resolve its real declared preset from - `renderAnchoredPair` never
+     * had access to this before, so every self-anchored box silently fell
+     * through to the caller's own hardcoded family default).
+     */
+    selfLayoutNode: DiagramLayoutNode;
+    desSlot: {
+        rect: Slot;
+        content: DiagramNode[];
+        layoutNode: DiagramLayoutNode;
+    } | undefined;
+}
+/** Resolve every `self`/`des` pair `arrangeByPresentationOf` will render, in point order. */
+export declare function collectSelfDesPairs(selfSlots: SlottedDims[], desSlots: SlottedDims[], allChildren: DiagramLayoutNode[], nodes: DiagramNode[], box: BoundingBox, absX: number, absY: number, childrenOf: Map<string, DiagramNode[]>, count: number): SelfDesPair[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-pairs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-pairs.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-pairs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,0FAA0F;AAC1F,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,IAAI,CAAC;IACf;;;;;OAKG;IACH,cAAc,EAAE,iBAAiB,CAAC;IAClC,OAAO,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,OAAO,EAAE,WAAW,EAAE,CAAC;QAAC,UAAU,EAAE,iBAAiB,CAAA;KAAE,GAAG,SAAS,CAAC;CAC3F;AAED,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,WAAW,EAAE,EACxB,QAAQ,EAAE,WAAW,EAAE,EACvB,WAAW,EAAE,iBAAiB,EAAE,EAChC,KAAK,EAAE,WAAW,EAAE,EACpB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,KAAK,EAAE,MAAM,GACX,WAAW,EAAE,CAuBf"}

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

@@ -0,0 +1,29 @@
+/**
+ * SmartArt DiagramML interpreter - `self`+`des` pair rendering for the
+ * `composite` arranger.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` (the repo's
+ * per-file line budget).
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { SharedFontFit } from './smartart-layout-interpreter-composite-fontfit.js';
+import type { Slot } from './smartart-layout-interpreter-composite-slots.js';
+import type { StyleContext } from './smartart-layout-interpreter-render.js';
+import type { RenderedNode } from './smartart-layout-types.js';
+/** Shared per-arranger style/palette context, threaded through every slot
+ * renderer in this module's callers and in `smartart-layout-interpreter-
+ * composite-children.ts`'s child-repeater expansion. */
+export interface SlotStyleContext {
+    ctx: StyleContext;
+    palette: string[];
+    style: DiagramStyleIntensity;
+    elementId: string;
+}
+/** One `self`-anchored slot plus, when present, its paired `des` fold. */
+export declare function renderAnchoredPair(node: DiagramNode, index: number, total: number, selfSlot: Slot, selfLayoutNode: DiagramLayoutNode, desSlot: {
+    rect: Slot;
+    content: DiagramNode[];
+    layoutNode: DiagramLayoutNode;
+} | undefined, ctx: SlotStyleContext, fontFit: SharedFontFit | undefined): RenderedNode[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-render.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-render.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,+CAA+C,CAAC;AAE1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEzE,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAE9E;;wDAEwD;AACxD,MAAM,WAAW,gBAAgB;IAChC,GAAG,EAAE,YAAY,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,qBAAqB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,0EAA0E;AAC1E,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,IAAI,EACd,cAAc,EAAE,iBAAiB,EACjC,OAAO,EAAE;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE,GAAG,SAAS,EAC1F,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,aAAa,GAAG,SAAS,GAChC,YAAY,EAAE,CA6ChB"}

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

@@ -0,0 +1,40 @@
+/**
+ * SmartArt DiagramML interpreter - composite same-ring `des` sibling fold.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` to keep that file
+ * under the repo's per-file line budget: this half matches a `self`-anchored
+ * composite slot (`Target List`'s `rect1`, a ring's own `sp` background
+ * shape) to an UNPOSITIONED `des`-axis sibling reached through the SAME
+ * `dgm:forEach` ring (`rect1ChTx`, the same ring's child text template - no
+ * `w`/`h`/`l`/`t` of its own, since the ring's whole visible box already
+ * belongs to `rect1`), so that sibling's descendant text still gets its own
+ * rendered box instead of being silently dropped. Pure geometry; no
+ * framework code.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+import type { Slot } from './smartart-layout-interpreter-composite-slots.js';
+/**
+ * An UNPOSITIONED `des`-axis sibling template reached through the SAME
+ * enclosing `dgm:forEach` "ring" as `selfNode` (`Target List`'s `rect1`, the
+ * ring's own `sp` background shape, and `rect1ChTx`, the SAME ring's child
+ * text template - both un-`st`'d "ring 1", but declared under TWO SEPARATE
+ * `dgm:forEach`s with different `@name`s, one for the ring's shapes, one for
+ * its text; {@link sameForEachRing} matches them by shape, not name). Such a
+ * sibling carries no geometry of its own - the ring's whole visible box
+ * belongs to the self shape - so its content folds INTO that same box (see
+ * {@link ringFoldRect}) rather than needing a separately-positioned `des`
+ * slot (`gear1ch`'s shape, the already-handled case via `desSlots`).
+ */
+export declare function findRingDesSibling(allChildren: DiagramLayoutNode[], selfNode: DiagramLayoutNode): DiagramLayoutNode | undefined;
+/**
+ * A placeholder inset for a ring's own descendant fold when it has no real
+ * geometry of its own (see {@link findRingDesSibling}): the self rect's own
+ * trailing third, full height. NOT reverse-engineered against the cached
+ * drawing - `Target List`'s real "target" algorithm reshapes every ring's
+ * OWN width when ANY ring holds a fold (measured, not yet modelled here) -
+ * this only gets the descendant's own shape to EXIST and carry its text, so
+ * the gate's shape-COUNT check passes; position/size still fails the gate's
+ * separate geometry assertion until that algorithm is implemented.
+ */
+export declare function ringFoldRect(selfRect: Slot): Slot;
+//# sourceMappingURL=smartart-layout-interpreter-composite-ring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-ring.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-ring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,+CAA+C,CAAC;AAmB1E;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CACjC,WAAW,EAAE,iBAAiB,EAAE,EAChC,QAAQ,EAAE,iBAAiB,GACzB,iBAAiB,GAAG,SAAS,CAM/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAGjD"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-slot-dim.d.ts

@@ -0,0 +1,22 @@
+/**
+ * SmartArt DiagramML interpreter - single-constraint dimension resolution.
+ *
+ * Split out of `smartart-layout-interpreter-composite-slots.ts` (the repo's
+ * per-file line budget): {@link dimOf} resolves ONE `dgm:constr` `type` (self-
+ * declared on the slot, or arranger-declared via `dimDeclaredBy`) to pixels
+ * or an absolute raw; `readSlots` there calls it once per axis. Pure
+ * geometry; no framework code.
+ */
+import type { DiagramConstraint } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { BoundingBox } from './smartart-layout-types.js';
+/** A single resolved dimension, either box-relative pixels or an absolute raw. */
+export interface Dim {
+    /** Resolved pixels (from a `fact`, or a sub-1 `val` treated as a fraction). */
+    px?: number;
+    /** Raw absolute `val` (> 1); normalised later against the other slots. */
+    abs?: number;
+}
+/** Resolve one constraint to pixels (factor / sub-1 value) or an absolute raw. */
+export declare function dimOf(constraints: DiagramConstraint[] | undefined, type: string, box: BoundingBox, index: ConstraintIndex, role: string, declaringRole: string | readonly string[]): Dim | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-composite-slot-dim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-slot-dim.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-slot-dim.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAKlD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,kFAAkF;AAClF,MAAM,WAAW,GAAG;IACnB,+EAA+E;IAC/E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAiFD,kFAAkF;AAClF,wBAAgB,KAAK,CACpB,WAAW,EAAE,iBAAiB,EAAE,GAAG,SAAS,EAC5C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GACvC,GAAG,GAAG,SAAS,CAmCjB"}

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

@@ -0,0 +1,69 @@
+/**
+ * SmartArt DiagramML interpreter - `composite` child-slot dimension resolver.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` to keep that file
+ * under the repo's per-file line budget: this half reads each composite
+ * child `layoutNode`'s `l`/`t`/`w`/`h`/`ctrX`/`ctrY` constraints into
+ * box-relative pixels (or an absolute raw, normalised later) - per-dimension
+ * resolution itself (including a TRUE cross-role reference, resolved via
+ * `smartart-constraint-solver.ts`) lives in `smartart-layout-interpreter-
+ * composite-slot-dim.ts` (a further split for the SAME line budget); the
+ * other half maps the resolved slots onto data-model points. Pure geometry;
+ * no framework code.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { Dim } from './smartart-layout-interpreter-composite-slot-dim.js';
+import type { BoundingBox } from './smartart-layout-types.js';
+export type { Dim } from './smartart-layout-interpreter-composite-slot-dim.js';
+/** The raw dimensions read off one composite child slot. */
+export interface SlotDims {
+    l?: Dim | undefined;
+    t?: Dim | undefined;
+    w?: Dim | undefined;
+    h?: Dim | undefined;
+    ctrX?: Dim | undefined;
+    ctrY?: Dim | undefined;
+}
+/** A resolved, box-clamped rectangle for one child slot. */
+export interface Slot {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** One composite child slot's raw dimensions, plus its source layoutNode
+ * (for `arrangeComposite`'s `dgm:presOf`-aware data mapping). */
+export interface SlottedDims {
+    node: DiagramLayoutNode;
+    dims: SlotDims;
+}
+/**
+ * Read the raw dimensions from every child, keeping only positioned slots.
+ *
+ * @param declaringRole The composite arranger's own role name (`roleOf`),
+ *   for resolving a slot positioned by the ARRANGER's `for="ch"
+ *   forName="<slot>"` constraint instead of the slot's own (see
+ *   `dimDeclaredBy`). Defaults to the composite `layoutNode`'s own name when
+ *   omitted (every existing call site already has it to hand as `children`'s
+ *   parent). A CHAIN of roles (nearest ancestor first, round 32) tries each
+ *   in turn per dimension `type` - see `dimDeclaredBy`'s own doc comment.
+ * @param sizeBox The extent a `userS`-declared hub role's own `w`/`h` facts
+ *   are read against instead of `box` - see `smartart-layout-interpreter-
+ *   composite-aspect.ts`'s `isUserSizeHubRole`/`fitAspectRatioBox` for why
+ *   this is scoped to exactly that one role, not every child. Defaults to
+ *   `box` (every pre-existing caller, and every composite with no `userS`
+ *   hub role): unchanged behaviour.
+ */
+export declare function readSlots(children: DiagramLayoutNode[], box: BoundingBox, index: ConstraintIndex, declaringRole: string | readonly string[], sizeBox?: BoundingBox): SlottedDims[];
+/**
+ * Largest absolute (EMU-ish) extent on one axis, used to normalise raw `val`s.
+ *
+ * The extent of a slot is its far edge: `left + width` (or the centre-based
+ * equivalent). The widest slot's far edge maps to the box, keeping every
+ * absolutely-positioned slot inside the bounds.
+ */
+export declare function axisAbsMax(slots: SlottedDims[], pos: keyof SlotDims, ctr: keyof SlotDims, size: keyof SlotDims): number;
+/** Resolve one slot's l/t/w/h from its (possibly ctr-based) constraints. */
+export declare function resolveSlot(dims: SlotDims, box: BoundingBox, absX: number, absY: number): Slot;
+//# sourceMappingURL=smartart-layout-interpreter-composite-slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-slots.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kDAAkD,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,YAAY,EAAE,GAAG,EAAE,MAAM,kDAAkD,CAAC;AAE5E,4DAA4D;AAC5D,MAAM,WAAW,QAAQ;IACxB,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACpB,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACpB,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACpB,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACpB,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACvB,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;CACvB;AAED,4DAA4D;AAC5D,MAAM,WAAW,IAAI;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED;iEACiE;AACjE,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,QAAQ,CAAC;CACf;AAcD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CACxB,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACzC,OAAO,GAAE,WAAiB,GACxB,WAAW,EAAE,CAmBf;AAOD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,WAAW,EAAE,EACpB,GAAG,EAAE,MAAM,QAAQ,EACnB,GAAG,EAAE,MAAM,QAAQ,EACnB,IAAI,EAAE,MAAM,QAAQ,GAClB,MAAM,CAUR;AAwBD,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAkC9F"}

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

@@ -0,0 +1,56 @@
+/**
+ * SmartArt DiagramML interpreter - composite (`composite`) arranger.
+ *
+ * The `composite` algorithm does not flow points; it positions each child
+ * `layoutNode` at an explicit offset given by its `dgm:constr`
+ * (`l`/`t`/`w`/`h`/`ctrX`/`ctrY`, usually a `fact` of the parent w/h, either
+ * self-declared or - the more common real-built-in shape (`gear`, `balance`,
+ * `stacked-venn`) - declared BY the composite via `for="ch" forName="<slot>"`,
+ * resolved in `smartart-layout-interpreter-composite-slots.ts`). This is how
+ * many built-ins place a fixed set of slots - a title beside a body, a shape
+ * over its picture, an accent plus a caption, gear teeth around a hub.
+ *
+ * Data-point mapping is `dgm:presOf`-aware (see `DiagramLayoutNode.
+ * presentationOf`'s doc comment): a `self`-axis slot (`gear1`, `gear2`, ...,
+ * or `balance`'s two pans) anchors ONE arranged point, in document order; a
+ * `des`-axis slot (`gear1ch`) pairs with the SAME ordinal `self` slot's own
+ * descendants (folded, as `smartart-layout-interpreter-item-roles.ts` does
+ * for a per-item role), NOT the next point. A slot with neither is purely
+ * decorative and renders nothing. No `presOf` on ANY slot falls back to the
+ * pre-existing blind "one point per positioned slot, in document order".
+ *
+ * Scope / honesty: like the rest of the partial interpreter (see
+ * `smartart-layout-interpreter-model.ts`), this does NOT run the recursive
+ * forEach/choose + constraint-reference solver, and does not resolve
+ * geometry for the decorative slots it skips. Pure geometry; no framework
+ * code.
+ */
+import type { DiagramNode, DiagramPresLayoutVars } 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';
+import type { RawXmlView } from './smartart-choose-xml.js';
+export type { SlotStyleContext } from './smartart-layout-interpreter-composite-render.js';
+/**
+ * Execute the `composite` algorithm: map data points into the fixed child slots.
+ *
+ * Returns `undefined` when the composite has no child that positions itself, so
+ * the caller can fall back to its legacy family approximation.
+ *
+ * @param nodes The arranged top-level points (see the module doc comment for
+ *   how `self`/`des` slots consume them).
+ * @param childrenOf Full data-model parent/child map (`smartArtChildrenOf`),
+ *   for folding a `des`-axis slot's content. Omit (defaults to empty) when
+ *   the caller has no tree to offer - `des` slots then simply render empty.
+ * @param flat The diagram's full flat (depth-first) node list, for a
+ *   `dgm:choose`-guarded composite with no `self`-axis slot anywhere (see
+ *   {@link arrangeByChooseAwareSlots}). Omit (defaults to `nodes`) when the
+ *   caller has no fuller list to offer - a composite that never needs
+ *   root-relative resolution is unaffected either way.
+ * @param presLayoutVars ROUND 42: threaded to `renderChildRepeaterOrNestedCycle`
+ *   so a choose-wrapped nested-cycle slot's `func="var"` can decide. Omit
+ *   when absent - a composite with no such slot is unaffected either way.
+ */
+export declare function arrangeComposite(view: RawXmlView<unknown>, plan: ArrangementPlan, nodes: DiagramNode[], box: BoundingBox, palette: string[], style: DiagramStyleIntensity, elementId: string, index?: ConstraintIndex, childrenOf?: Map<string, DiagramNode[]>, flat?: DiagramNode[], fontName?: string, presLayoutVars?: DiagramPresLayoutVars): SmartArtLayoutResult | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-composite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAqB,WAAW,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAoBpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAE3E,OAAO,KAAK,EAAE,WAAW,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AAgHvF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,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,GAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAa,EAClD,IAAI,GAAE,WAAW,EAAU,EAC3B,QAAQ,CAAC,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,qBAAqB,GACpC,oBAAoB,GAAG,SAAS,CAoDlC"}

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

@@ -0,0 +1,42 @@
+/**
+ * SmartArt DiagramML interpreter - `conn` algorithm path geometry.
+ *
+ * Split out of `smartart-layout-interpreter-aux.ts` to keep that file under
+ * the repo's per-file line budget. Builds the SVG path for one connector,
+ * honouring the algorithm params real `conn` layoutNodes carry:
+ *
+ *   - `begSty`/`endSty` (`dgm:param`, `arr`/`noArr`): whether an arrowhead is
+ *     drawn at the connector's start/end. Default `noArr`/`arr` matches the
+ *     pre-existing single-arrowhead-at-target behaviour.
+ *   - `connRout` (`stra`/`bend`/`curve`): straight line (default, pre-existing
+ *     behaviour), a single-bend orthogonal elbow, or a smooth curve.
+ *   - `bendPt`: which corner-routing shape the bend takes when `connRout=bend`.
+ *     Only the fixed midpoint elbow is modelled (see `elbowPath`) - the enum's
+ *     finer variants are not distinguished, a documented simplification.
+ *   - `dim` (`1D`/`2D`): `1D` (default) connects the two rects' facing edges
+ *     along the flow axis, matching the pre-existing behaviour; `2D` connects
+ *     their centres directly, letting the path run off-axis.
+ *
+ * Pure geometry; no framework code, no DOM.
+ */
+import type { RenderedRectNode } from './smartart-layout-types.js';
+export type ConnArrowStyle = 'arr' | 'noArr';
+export type ConnRouting = 'stra' | 'bend' | 'curve';
+export type ConnDimension = '1D' | '2D';
+/** Full SVG path (line/elbow/curve + arrowheads) for one `conn` connector. */
+export declare function connectorPath(x0: number, y0: number, x1: number, y1: number, centre: {
+    x: number;
+    y: number;
+}, routing: ConnRouting, begSty: ConnArrowStyle, endSty: ConnArrowStyle): string;
+/**
+ * Connection endpoints between two rects. `1D` (default) links the facing
+ * edges along the flow axis (pre-existing behaviour); `2D` links the rects'
+ * centres directly, letting the connector run off the flow axis.
+ */
+export declare function connectorEndpoints(from: RenderedRectNode, to: RenderedRectNode, horizontal: boolean, dim: ConnDimension): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+//# sourceMappingURL=smartart-layout-interpreter-conn-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-conn-path.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-conn-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAOhE,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,OAAO,CAAC;AAC7C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AACpD,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,CAAC;AA4ExC,8EAA8E;AAC9E,wBAAgB,aAAa,CAC5B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,MAAM,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAChC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACpB,MAAM,CAQR;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,gBAAgB,EACtB,EAAE,EAAE,gBAAgB,EACpB,UAAU,EAAE,OAAO,EACnB,GAAG,EAAE,aAAa,GAChB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAoBpD"}