@contrail/documents 2.4.0-alpha.7e4b381 → 2.4.0-alpha.8be4908

package/CHANGELOG.md

@@ -5,24 +5,33 @@ All notable changes to `@contrail/documents` are documented here.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.4.0] - 2026-09-24
+## [2.4.0] - 2026-09-26
+
+Also shipped on the 1.x line as 1.21.0.
 
 ### Added
 
 - `DocumentContainerService.buildIndex` and `DocumentContainerIndex` — which containers hold which
   elements, for one document, resolved once and read back by lookup. A container is a frame or a
-  section, described by a `ContainerKind` carrying `elementType`, `nests` and `layer`. An element
-  belongs to the container whose box covers its anchor point and which is drawn below it. Nesting
-  gives a path with one container per depth, the later-drawn one winning where two cross. A
-  container is only ever content of a kind layered behind it, so a frame belongs to a section and a
-  section never to a frame. Shapes wider and taller than the container, and groups holding it, are
-  excluded.
-- `SECTION_ELEMENT_TYPE`, `FRAME_ELEMENT_TYPE` and `SHAPE_ELEMENT_TYPES` in
-  `document-element-constants`, so the rule above has one definition rather than one per app.
+  section, described by a `ContainerKind` carrying `elementType` and `nests`. An element belongs to
+  the container whose box covers its anchor point and which is drawn below it, unless the element's
+  own box encloses that container or the element is a group holding it. `nests` decides the shape of
+  the answer: sections nest, so an element in a section inside another is in both, and the chain
+  requires the inner container to be drawn above the outer; frames do not, so an element covered by
+  two frames is in the topmost. A container of another kind is placed by the same rules as any
+  element, so a frame can be in a section and a section drawn above a frame is in that frame. The
+  rule is written out in `src/containers/DOCUMENT_CONTAINERS_SPEC.md`, which the code is measured
+  against.
+- `SECTION_ELEMENT_TYPE` and `FRAME_ELEMENT_TYPE` in `document-element-constants`, so the rule
+  above has one definition rather than one per app. `SHAPE_ELEMENT_TYPES` moved here with them; no
+  container rule reads it, and it is exported for the board's own shape handling.
+- `DocumentContainerUtil.resizeKeepingAnchor` — the size a value needs and the position that keeps
+  the element's anchor where it is, returned together. Applying one without the other drags the
+  drawn corner that membership reads, and `calculateSize` alone let a caller do exactly that.
 - `DocumentContainerUtil` — the container geometry as statics, with `anchorFor` for a caller
   holding an element rather than a measured box.
 - `positionKeepingAnchor` — where an element has to sit for its drawn corner to land where it did
-  before a resize. Rotation turns about the centre and the centre moves with the size, so a rotated
+  before a resize. Prefer `resizeKeepingAnchor` above, which pairs it with the size. Rotation turns about the centre and the centre moves with the size, so a rotated
   element resized about its stored position drags its corner along with it. The board already makes
   this move; a server recomputing a dynamic text has to make the same one, or the corner is not the
   fixed point the anchor rule needs.
@@ -49,10 +58,17 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - The corner is the rotated one (VIBE-9567). A 200x20 text turned on its side draws as a 20x200
   column, and its unrotated `position` can sit well clear of the frame it is visibly on, which
   reported "Move to a frame" for a vertical text the user could see was placed correctly.
-- A dynamic text is also exempt from the oversized-shape exclusion, which keeps a shape wider and
-  taller than a container off it. That rule reads size too, so a dynamic text larger than its frame
-  in both directions had two self-consistent answers and kept whichever it started from. The rule
-  exists to keep a backdrop shape off a frame it covers, which is not what a dynamic text is doing.
+- An element covering a container is not inside it, whatever its type. This replaces a rule that
+  excluded only shapes wider and taller than the container, which let a background image join the
+  frame it covered and needed an exemption for dynamic text, whose size the container decides. An
+  unrotated dynamic text cannot be excluded by enclosure, since its anchor is the corner of the box
+  it would have to cover with.
+- `isDynamicText` requires a `propertyBindings.text` binding, which is the one the value is read
+  from. The text tool creates an element with empty `propertyBindings` and `propertyBindingsMetaData`
+  and both are truthy, so an unconfigured text was anchored at its corner while the canvas centred
+  it.
+- A line or callout is measured from the elements it connects even with no stored `position` of its
+  own, where it was previously left out of the index entirely.
 - `min` and `max` rendered an infinity sign when every member value was empty. The early return
   checked the list length before the empty values were filtered out, so `Math.min` of nothing
   reached the formatter. Both now fall through to `n/a`.
@@ -62,8 +78,19 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ### Changed
 
 - Container membership measures a scaled element from its scaled box, through the new
-  `getBoundingClientRectScaled` above. A scaled element previously measured at its unscaled size
-  and could resolve to the wrong container.
+  `getBoundingClientRectScaled` above. Only a sticky note, a regular iframe, a text-tool text or a
+  table carries `scale` at all; for this work the one that matters is a text-tool dynamic text,
+  which previously measured at its unscaled size and could resolve to the wrong container.
+- `DocumentContainerUtil.anchorFor` measures through the same factory call the index uses, so a
+  caller holding an element gets the answer the index would give it. Reading `size` directly
+  disagreed for the types whose box is not position plus size: a component's box is built from the
+  rows it draws, and a line's comes from its `lineDefinition`.
+- A container path is a containment chain, walked outward from the container the element sits on.
+  Two containers that merely cross are not a chain, so the later-drawn one takes the element rather
+  than both claiming it. `containerPathAtPoint` walks the same chain, so a drop preview agrees with
+  the drop; it applies only the anchor rule, having no element to compare against a container.
+- `buildIndex` scans element types before measuring anything, so a document holding no containers
+  of the kinds asked for returns an empty index without a geometry pass.
 
 ## [2.3.0] - 2026-09-21
 

package/lib/containers/container-kind.d.ts

@@ -3,7 +3,6 @@ export type ContainerElementType = typeof FRAME_ELEMENT_TYPE | typeof SECTION_EL
 export interface ContainerKind {
     elementType: ContainerElementType;
     nests: boolean;
-    layer: number;
 }
 export declare const SECTION_KIND: ContainerKind;
 export declare const FRAME_KIND: ContainerKind;

package/lib/containers/container-kind.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTAINER_KINDS = exports.FRAME_KIND = exports.SECTION_KIND = void 0;
 const document_element_constants_1 = require("../document-element-constants");
-exports.SECTION_KIND = { elementType: document_element_constants_1.SECTION_ELEMENT_TYPE, nests: true, layer: 0 };
-exports.FRAME_KIND = { elementType: document_element_constants_1.FRAME_ELEMENT_TYPE, nests: false, layer: 1 };
+exports.SECTION_KIND = { elementType: document_element_constants_1.SECTION_ELEMENT_TYPE, nests: true };
+exports.FRAME_KIND = { elementType: document_element_constants_1.FRAME_ELEMENT_TYPE, nests: false };
 exports.CONTAINER_KINDS = [exports.SECTION_KIND, exports.FRAME_KIND];

package/lib/containers/document-container-index.d.ts

@@ -10,6 +10,7 @@ export declare class DocumentContainerIndex {
         memberIdsByContainerId: Map<string, string[]>;
         containerIdsByElementType: Map<string, string[]>;
     });
+    static empty(): DocumentContainerIndex;
     getContainer(containerId: string): DocumentContainer | null;
     containersOf(documentElementId: string, elementType: ContainerElementType): DocumentContainer[];
     containerIdsOf(documentElementId: string, elementType: ContainerElementType): readonly string[];
@@ -17,8 +18,8 @@ export declare class DocumentContainerIndex {
     memberIdsOf(containerId: string): readonly string[];
     memberDocumentElementsOf(containerId: string): DocumentElement[];
     containerPathAtPoint(point: PositionDefinition, elementType: ContainerElementType): readonly string[];
-    maxDepth(elementType: ContainerElementType): number;
     private containersOfType;
     private resolveAll;
     private containerPath;
+    private containerPathCopy;
 }

package/lib/containers/document-container-index.js

@@ -6,6 +6,15 @@ class DocumentContainerIndex {
     constructor(data) {
         this.data = data;
     }
+    static empty() {
+        return new DocumentContainerIndex({
+            documentElementsById: new Map(),
+            containersById: new Map(),
+            containerPathsByDocumentElementId: new Map(),
+            memberIdsByContainerId: new Map(),
+            containerIdsByElementType: new Map(),
+        });
+    }
     getContainer(containerId) {
         var _a;
         return (_a = this.data.containersById.get(containerId)) !== null && _a !== void 0 ? _a : null;
@@ -14,7 +23,7 @@ class DocumentContainerIndex {
         return this.resolveAll(this.containerIdsOf(documentElementId, elementType));
     }
     containerIdsOf(documentElementId, elementType) {
-        return this.containerPath(documentElementId, elementType);
+        return this.containerPathCopy(documentElementId, elementType);
     }
     innermostContainerIdOf(documentElementId, elementType) {
         const path = this.containerPath(documentElementId, elementType);
@@ -22,7 +31,7 @@ class DocumentContainerIndex {
     }
     memberIdsOf(containerId) {
         var _a;
-        return (_a = this.data.memberIdsByContainerId.get(containerId)) !== null && _a !== void 0 ? _a : [];
+        return [...((_a = this.data.memberIdsByContainerId.get(containerId)) !== null && _a !== void 0 ? _a : [])];
     }
     memberDocumentElementsOf(containerId) {
         const members = [];
@@ -35,11 +44,12 @@ class DocumentContainerIndex {
         return members;
     }
     containerPathAtPoint(point, elementType) {
-        const covering = this.containersOfType(elementType).filter((container) => document_container_1.DocumentContainerUtil.containsPoint(container.box, point));
-        return document_container_1.DocumentContainerUtil.topmostPerDepth(covering).map((container) => container.id);
-    }
-    maxDepth(elementType) {
-        return this.containersOfType(elementType).reduce((max, container) => Math.max(max, container.depth + 1), 0);
+        var _a, _b;
+        const containers = this.containersOfType(elementType);
+        const covering = containers.filter((container) => document_container_1.DocumentContainerUtil.containsPoint(container.box, point));
+        const nests = (_b = (_a = containers[0]) === null || _a === void 0 ? void 0 : _a.kind.nests) !== null && _b !== void 0 ? _b : true;
+        const path = nests ? document_container_1.DocumentContainerUtil.chain(covering) : document_container_1.DocumentContainerUtil.topmost(covering);
+        return path.map((container) => container.id);
     }
     containersOfType(elementType) {
         var _a;
@@ -59,5 +69,8 @@ class DocumentContainerIndex {
         var _a, _b;
         return (_b = (_a = this.data.containerPathsByDocumentElementId.get(documentElementId)) === null || _a === void 0 ? void 0 : _a.get(elementType)) !== null && _b !== void 0 ? _b : [];
     }
+    containerPathCopy(documentElementId, elementType) {
+        return [...this.containerPath(documentElementId, elementType)];
+    }
 }
 exports.DocumentContainerIndex = DocumentContainerIndex;

package/lib/containers/document-container.d.ts

@@ -3,10 +3,8 @@ import { ContainerKind } from './container-kind';
 export interface DocumentContainer {
     id: string;
     kind: ContainerKind;
-    name: string;
     documentElement: DocumentElement;
     box: CoordinateBox;
-    depth: number;
     drawOrder: number;
 }
 export interface MeasuredDocumentElement {
@@ -19,9 +17,13 @@ export declare class DocumentContainerUtil {
     static centerOf(box: CoordinateBox): PositionDefinition;
     static anchorOf(documentElement: DocumentElement, box: CoordinateBox): PositionDefinition;
     static positionKeepingAnchor(documentElement: DocumentElement, newSize: SizeDefinition): PositionDefinition;
-    static anchorFor(documentElement: DocumentElement, position?: PositionDefinition): PositionDefinition;
+    static resizeKeepingAnchor(dynamicTextElement: DocumentElement, entityType: any, text: string): {
+        size: SizeDefinition;
+        position: PositionDefinition;
+    };
+    static anchorFor(documentElement: DocumentElement, position?: PositionDefinition, startElement?: DocumentElement, endElement?: DocumentElement): PositionDefinition;
     static containsPoint(box: CoordinateBox, point: PositionDefinition): boolean;
     static encloses(outer: CoordinateBox, inner: CoordinateBox): boolean;
-    static isWiderAndTallerThan(box: CoordinateBox, other: CoordinateBox): boolean;
-    static topmostPerDepth(containers: DocumentContainer[]): DocumentContainer[];
+    static chain(candidates: DocumentContainer[]): DocumentContainer[];
+    static topmost(containers: DocumentContainer[]): DocumentContainer[];
 }

package/lib/containers/document-container.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentContainerUtil = void 0;
 const rotation_math_1 = require("../util/mask/rotation-math");
 const dynamic_text_util_1 = require("../util/dynamic-text/dynamic-text-util");
+const document_element_factory_1 = require("../document-element-factory");
 class DocumentContainerUtil {
     static toCoordinateBox(x, y, width, height) {
         return { x, y, width, height, left: x, right: x + width, top: y, bottom: y + height };
@@ -37,15 +38,23 @@ class DocumentContainerUtil {
         const after = cornerOffset(newSize);
         return { x: position.x + before.x - after.x, y: position.y + before.y - after.y };
     }
-    static anchorFor(documentElement, position) {
-        var _a, _b, _c, _d, _e;
+    static resizeKeepingAnchor(dynamicTextElement, entityType, text) {
+        const size = dynamic_text_util_1.DynamicTextUtil.calculateSize(dynamicTextElement, entityType, text);
+        return { size, position: DocumentContainerUtil.positionKeepingAnchor(dynamicTextElement, size) };
+    }
+    static anchorFor(documentElement, position, startElement, endElement) {
         const at = position !== null && position !== void 0 ? position : documentElement === null || documentElement === void 0 ? void 0 : documentElement.position;
         if (!at) {
             return null;
         }
-        const size = (_a = documentElement === null || documentElement === void 0 ? void 0 : documentElement.size) !== null && _a !== void 0 ? _a : { width: 0, height: 0 };
-        const box = DocumentContainerUtil.toCoordinateBox(at.x, at.y, size.width * ((_c = (_b = documentElement === null || documentElement === void 0 ? void 0 : documentElement.scale) === null || _b === void 0 ? void 0 : _b.x) !== null && _c !== void 0 ? _c : 1), size.height * ((_e = (_d = documentElement === null || documentElement === void 0 ? void 0 : documentElement.scale) === null || _d === void 0 ? void 0 : _d.y) !== null && _e !== void 0 ? _e : 1));
-        return DocumentContainerUtil.anchorOf(documentElement, box);
+        try {
+            const measured = document_element_factory_1.DocumentElementFactory.getBoundingClientRectScaled(Object.assign(Object.assign({}, documentElement), { position: at }), startElement, endElement);
+            const box = DocumentContainerUtil.toCoordinateBox(measured.x, measured.y, measured.width, measured.height);
+            return DocumentContainerUtil.anchorOf(documentElement, box);
+        }
+        catch (_a) {
+            return null;
+        }
     }
     static containsPoint(box, point) {
         return point.x >= box.left && point.x <= box.right && point.y >= box.top && point.y <= box.bottom;
@@ -58,18 +67,25 @@ class DocumentContainerUtil {
             outer.bottom === inner.bottom;
         return covers && !identical;
     }
-    static isWiderAndTallerThan(box, other) {
-        return box.width > other.width && box.height > other.height;
-    }
-    static topmostPerDepth(containers) {
-        const byDepth = [];
-        for (const container of containers) {
-            const existing = byDepth[container.depth];
-            if (!existing || container.drawOrder > existing.drawOrder) {
-                byDepth[container.depth] = container;
+    static chain(candidates) {
+        if (!candidates.length) {
+            return [];
+        }
+        const topmostOf = (of) => of.reduce((topmost, container) => (container.drawOrder > topmost.drawOrder ? container : topmost));
+        const path = [topmostOf(candidates)];
+        for (;;) {
+            const current = path[0];
+            const enclosing = candidates.filter((container) => !path.includes(container) && this.encloses(container.box, current.box));
+            if (!enclosing.length) {
+                return path;
             }
+            path.unshift(topmostOf(enclosing));
         }
-        return byDepth.filter(Boolean);
+    }
+    static topmost(containers) {
+        return containers.length
+            ? [containers.reduce((topmost, container) => (container.drawOrder > topmost.drawOrder ? container : topmost))]
+            : [];
     }
 }
 exports.DocumentContainerUtil = DocumentContainerUtil;

package/lib/containers/document-container.service.d.ts

@@ -6,9 +6,8 @@ export declare class DocumentContainerService {
     static isContainer(documentElement: DocumentElement, kinds?: ContainerKind[]): boolean;
     private static measureDocumentElements;
     private static measure;
-    private static buildNesting;
-    private static resolveContainerPath;
-    private static resolveInnermostOnTop;
-    private static toContainerPath;
+    private static collectContainers;
+    private static resolvePath;
+    private static enclosersOf;
     private static candidateContainers;
 }

package/lib/containers/document-container.service.js

@@ -2,29 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentContainerService = void 0;
 const document_element_factory_1 = require("../document-element-factory");
-const dynamic_text_util_1 = require("../util/dynamic-text/dynamic-text-util");
-const document_element_constants_1 = require("../document-element-constants");
 const container_kind_1 = require("./container-kind");
 const document_container_index_1 = require("./document-container-index");
 const document_container_1 = require("./document-container");
 class DocumentContainerService {
     static buildIndex(documentElements, kinds = container_kind_1.CONTAINER_KINDS) {
-        const measuredDocumentElements = this.measureDocumentElements(documentElements !== null && documentElements !== void 0 ? documentElements : []);
-        const nestingByElementType = new Map(kinds.map((kind) => [kind.elementType, this.buildNesting(measuredDocumentElements, kind)]));
+        var _a, _b;
+        const elements = (documentElements !== null && documentElements !== void 0 ? documentElements : []).filter((element) => !!element);
+        const containerElementTypes = new Set(kinds.map((kind) => kind.elementType));
+        if (!elements.some((element) => containerElementTypes.has(element.type))) {
+            return document_container_index_1.DocumentContainerIndex.empty();
+        }
+        const documentElementsById = new Map(elements.map((element) => [element.id, element]));
+        const measuredDocumentElements = this.measureDocumentElements(elements, documentElementsById);
+        const containersByElementType = new Map(kinds.map((kind) => [kind.elementType, this.collectContainers(measuredDocumentElements, kind)]));
         const containersById = new Map();
         const containerIdsByElementType = new Map();
-        nestingByElementType.forEach((nesting, elementType) => {
-            containerIdsByElementType.set(elementType, nesting.containers.map((container) => container.id));
-            nesting.containers.forEach((container) => containersById.set(container.id, container));
+        containersByElementType.forEach((containers, elementType) => {
+            containerIdsByElementType.set(elementType, containers.map((container) => container.id));
+            containers.forEach((container) => containersById.set(container.id, container));
         });
+        const pathsByMeasured = new Map();
+        for (const measured of measuredDocumentElements) {
+            const byElementType = new Map();
+            for (const kind of kinds) {
+                byElementType.set(kind.elementType, this.resolvePath(measured, kind, (_a = containersByElementType.get(kind.elementType)) !== null && _a !== void 0 ? _a : []));
+            }
+            pathsByMeasured.set(measured, byElementType);
+        }
         const containerPathsByDocumentElementId = new Map();
         const memberIdsByContainerId = new Map();
         for (const measured of measuredDocumentElements) {
             const documentElementId = measured.documentElement.id;
             const pathsByElementType = new Map();
-            for (const kind of kinds) {
-                const path = this.resolveContainerPath(measured, kind, kinds, nestingByElementType.get(kind.elementType));
-                pathsByElementType.set(kind.elementType, path);
+            ((_b = pathsByMeasured.get(measured)) !== null && _b !== void 0 ? _b : new Map()).forEach((path, elementType) => pathsByElementType.set(elementType, path.map((container) => container.id)));
+            for (const path of pathsByElementType.values()) {
                 for (const containerId of path) {
                     const members = memberIdsByContainerId.get(containerId);
                     if (members) {
@@ -38,7 +50,7 @@ class DocumentContainerService {
             containerPathsByDocumentElementId.set(documentElementId, pathsByElementType);
         }
         return new document_container_index_1.DocumentContainerIndex({
-            documentElementsById: new Map(measuredDocumentElements.map((measured) => [measured.documentElement.id, measured.documentElement])),
+            documentElementsById,
             containersById,
             containerPathsByDocumentElementId,
             memberIdsByContainerId,
@@ -48,8 +60,7 @@ class DocumentContainerService {
     static isContainer(documentElement, kinds = container_kind_1.CONTAINER_KINDS) {
         return kinds.some((kind) => kind.elementType === (documentElement === null || documentElement === void 0 ? void 0 : documentElement.type));
     }
-    static measureDocumentElements(documentElements) {
-        const documentElementsById = new Map(documentElements.map((documentElement) => [documentElement.id, documentElement]));
+    static measureDocumentElements(documentElements, documentElementsById) {
         return documentElements.map((documentElement, drawOrder) => ({
             documentElement,
             drawOrder,
@@ -58,12 +69,9 @@ class DocumentContainerService {
     }
     static measure(documentElement, documentElementsById) {
         var _a, _b;
-        if (!(documentElement === null || documentElement === void 0 ? void 0 : documentElement.position)) {
-            return null;
-        }
         try {
-            const start = ((_a = documentElement.start) === null || _a === void 0 ? void 0 : _a.id) ? documentElementsById.get(documentElement.start.id) : undefined;
-            const end = ((_b = documentElement.end) === null || _b === void 0 ? void 0 : _b.id) ? documentElementsById.get(documentElement.end.id) : undefined;
+            const start = ((_a = documentElement === null || documentElement === void 0 ? void 0 : documentElement.start) === null || _a === void 0 ? void 0 : _a.id) ? documentElementsById.get(documentElement.start.id) : undefined;
+            const end = ((_b = documentElement === null || documentElement === void 0 ? void 0 : documentElement.end) === null || _b === void 0 ? void 0 : _b.id) ? documentElementsById.get(documentElement.end.id) : undefined;
             const { x, y, width, height } = document_element_factory_1.DocumentElementFactory.getBoundingClientRectScaled(documentElement, start, end);
             return document_container_1.DocumentContainerUtil.toCoordinateBox(x, y, width, height);
         }
@@ -71,73 +79,47 @@ class DocumentContainerService {
             return null;
         }
     }
-    static buildNesting(measuredDocumentElements, kind) {
-        const containers = measuredDocumentElements
+    static collectContainers(measuredDocumentElements, kind) {
+        return measuredDocumentElements
             .filter((measured) => measured.documentElement.type === kind.elementType && measured.box)
             .map((measured) => ({
             id: measured.documentElement.id,
             kind,
-            name: measured.documentElement.name,
             documentElement: measured.documentElement,
             box: measured.box,
-            depth: 0,
             drawOrder: measured.drawOrder,
         }));
-        const ancestorsById = new Map();
-        for (const container of containers) {
-            const ancestors = kind.nests
-                ? containers.filter((other) => other !== container && document_container_1.DocumentContainerUtil.encloses(other.box, container.box))
-                : [];
-            ancestorsById.set(container.id, ancestors);
-            container.depth = ancestors.length;
-        }
-        return { containers, ancestorsById };
     }
-    static resolveContainerPath(measured, kind, kinds, nesting) {
-        var _a, _b;
-        if (!(nesting === null || nesting === void 0 ? void 0 : nesting.containers.length) || !measured.box) {
+    static resolvePath(measured, kind, containers) {
+        if (!containers.length || !measured.box) {
             return [];
         }
-        const ownKind = kinds.find((candidate) => candidate.elementType === measured.documentElement.type);
-        if (ownKind) {
-            if (ownKind.elementType === kind.elementType) {
-                return kind.nests ? this.toContainerPath((_a = nesting.ancestorsById.get(measured.documentElement.id)) !== null && _a !== void 0 ? _a : []) : [];
-            }
-            if (kind.layer > ownKind.layer) {
-                return [];
-            }
-        }
-        const candidates = this.candidateContainers(measured, nesting.containers);
-        if (!candidates.length) {
-            return [];
+        if (measured.documentElement.type === kind.elementType) {
+            return kind.nests ? document_container_1.DocumentContainerUtil.chain(this.enclosersOf(measured, containers)) : [];
         }
-        const innermostOnTop = this.resolveInnermostOnTop(candidates, nesting);
-        const candidateIds = new Set(candidates.map((container) => container.id));
-        const ancestors = ((_b = nesting.ancestorsById.get(innermostOnTop.id)) !== null && _b !== void 0 ? _b : []).filter((container) => candidateIds.has(container.id));
-        return this.toContainerPath([...ancestors, innermostOnTop]);
+        const candidates = this.candidateContainers(measured, containers);
+        return kind.nests ? document_container_1.DocumentContainerUtil.chain(candidates) : document_container_1.DocumentContainerUtil.topmost(candidates);
     }
-    static resolveInnermostOnTop(candidates, nesting) {
-        const enclosingIds = new Set(candidates.flatMap((container) => { var _a; return (_a = nesting.ancestorsById.get(container.id)) !== null && _a !== void 0 ? _a : []; }).map((ancestor) => ancestor.id));
-        return candidates
-            .filter((container) => !enclosingIds.has(container.id))
-            .reduce((topmost, container) => (container.drawOrder > topmost.drawOrder ? container : topmost));
-    }
-    static toContainerPath(containers) {
-        return document_container_1.DocumentContainerUtil.topmostPerDepth(containers).map((container) => container.id);
+    static enclosersOf(measured, containers) {
+        return containers.filter((container) => {
+            var _a;
+            return container.documentElement !== measured.documentElement &&
+                document_container_1.DocumentContainerUtil.encloses(container.box, measured.box) &&
+                measured.drawOrder > container.drawOrder &&
+                !((_a = measured.documentElement.elementIds) === null || _a === void 0 ? void 0 : _a.includes(container.id));
+        });
     }
     static candidateContainers(measured, containers) {
         const anchor = document_container_1.DocumentContainerUtil.anchorOf(measured.documentElement, measured.box);
-        const isShape = document_element_constants_1.SHAPE_ELEMENT_TYPES.includes(measured.documentElement.type) &&
-            !dynamic_text_util_1.DynamicTextUtil.isDynamicText(measured.documentElement);
         return containers.filter((container) => {
             var _a;
-            if (container.id === measured.documentElement.id || measured.drawOrder <= container.drawOrder) {
+            if (container.documentElement === measured.documentElement || measured.drawOrder <= container.drawOrder) {
                 return false;
             }
             if (!document_container_1.DocumentContainerUtil.containsPoint(container.box, anchor)) {
                 return false;
             }
-            if (isShape && document_container_1.DocumentContainerUtil.isWiderAndTallerThan(measured.box, container.box)) {
+            if (document_container_1.DocumentContainerUtil.encloses(measured.box, container.box)) {
                 return false;
             }
             return !((_a = measured.documentElement.elementIds) === null || _a === void 0 ? void 0 : _a.includes(container.id));

package/lib/util/dynamic-text/dynamic-text-util.d.ts

@@ -48,6 +48,7 @@ export declare const HARD_CODED_TEXT: {
     'section.itemOptionCount': string;
     'section.colorCount': string;
 };
+export declare function isContainerBinding(bindingProperty: string | null | undefined): boolean;
 export declare class DynamicTextUtil {
     static isDynamicText(documentElement: DocumentElement): boolean;
     static takesValueFromContainer(bindingProperty: string | null | undefined): boolean;

package/lib/util/dynamic-text/dynamic-text-util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicTextUtil = exports.HARD_CODED_TEXT = exports.CLICK_TO_CONFIGURE = exports.MOVE_TO_SECTION_TEXT = exports.MOVE_TO_FRAME_TEXT = exports.DynamicTextDisplayFunction = exports.DYNAMIC_TEXT_DATA_SOURCE = void 0;
+exports.isContainerBinding = isContainerBinding;
 const types_1 = require("@contrail/types");
 const util_1 = require("@contrail/util");
 const document_util_1 = require("@contrail/document-util");
@@ -50,10 +51,14 @@ exports.HARD_CODED_TEXT = {
 };
 const CONTAINER_PROPERTY_SLUGS = ['name', 'count', 'itemFamilyCount', 'itemOptionCount', 'colorCount'];
 const CONTAINER_SOURCES = [DYNAMIC_TEXT_DATA_SOURCE.FRAME, DYNAMIC_TEXT_DATA_SOURCE.SECTION];
+function isContainerBinding(bindingProperty) {
+    return DynamicTextUtil.takesValueFromContainer(bindingProperty);
+}
 class DynamicTextUtil {
     static isDynamicText(documentElement) {
+        var _a;
         return ((documentElement === null || documentElement === void 0 ? void 0 : documentElement.type) === 'text' &&
-            !!documentElement.propertyBindings &&
+            !!((_a = documentElement.propertyBindings) === null || _a === void 0 ? void 0 : _a.text) &&
             !!documentElement.propertyBindingsMetaData);
     }
     static takesValueFromContainer(bindingProperty) {
@@ -172,8 +177,9 @@ class DynamicTextUtil {
             bold,
             italic,
         };
-        if (!dynamicTextElement.isTextTool) {
-            measureTextSettings.width = size.width - padding * 2;
+        const fixedWidth = size.width - padding * 2;
+        if (!dynamicTextElement.isTextTool && fixedWidth > 0) {
+            measureTextSettings.width = fixedWidth;
         }
         try {
             const dimensions = document_util_1.DocumentTextUtil.measureText(text, measureTextSettings);
@@ -203,7 +209,7 @@ class DynamicTextUtil {
         }
         else if (displayFunction === DynamicTextDisplayFunction.UNIQUE_ARRAY) {
             text = Array.from(new Set(memberValues
-                .filter((e) => e !== null && e !== undefined)
+                .filter((e) => e !== null && e !== undefined && e !== '')
                 .flat()
                 .map((e) => formatter.formatValueForProperty(e, property))))
                 .sort()
@@ -218,7 +224,10 @@ class DynamicTextUtil {
         }
         else if (displayFunction === DynamicTextDisplayFunction.MIN ||
             displayFunction === DynamicTextDisplayFunction.MAX) {
-            const present = memberValues.filter((e) => e !== null && e !== undefined);
+            const present = memberValues
+                .filter((e) => e !== null && e !== undefined && e !== '')
+                .map(Number)
+                .filter((e) => !Number.isNaN(e));
             if (!present.length) {
                 return '';
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/documents",
-  "version": "2.4.0-alpha.7e4b381",
+  "version": "2.4.0-alpha.8be4908",
   "description": "Documents library for contrail platform",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",