@contrail/documents 2.4.0-alpha.a5c4d62 → 2.4.0-alpha.bce8caa

package/CHANGELOG.md

@@ -13,54 +13,80 @@ Also shipped on the 1.x line as 1.21.0.
 
 - `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; membership is geometry, draw order and kind, with nothing inherited and nothing stored.
-  The rule is written out in `src/containers/DOCUMENT_CONTAINERS_SPEC.md`, which the code is
-  measured against.
-- `DocumentContainerUtil` — the container geometry as statics. `anchorFor` answers "which point is
-  this element placed by" for a caller holding an element rather than a measured box, and
-  `resizeKeepingAnchor` returns the size a new value needs with the position that keeps that point
-  still. Applying one without the other drags the corner membership reads.
-- `SECTION_ELEMENT_TYPE` and `FRAME_ELEMENT_TYPE` in `document-element-constants`, alongside
-  `SHAPE_ELEMENT_TYPES`, which moved here for the board's shape handling.
+  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`, `FRAME_ELEMENT_TYPE` and `SHAPE_ELEMENT_TYPES` in
+  `document-element-constants`, so the rule above has one definition rather than one per app.
+- `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
+  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.
 - `DocumentElementFactory.getBoundingClientRectScaled` — the space an element covers on the canvas,
-  with `scale` applied. `getBoundingClientRect` still returns the unscaled box, which is what layout
-  works in: `@contrail/document-table` places table members from it, and scaling it moves a scaled
-  member into a different cell. Anything deciding what an element overlaps or sits on wants the
-  scaled one.
+  with `scale` applied. `getBoundingClientRect` keeps returning the element's own box before scale,
+  which is what layout works in: `@contrail/document-table` places table members from it, and
+  scaling it moves a scaled member into a different cell. Anything deciding what an element overlaps
+  or sits on wants the scaled one.
 
 ### Deprecated
 
 - `isContainerBinding()` in favour of `DynamicTextUtil.takesValueFromContainer()`. Same rule, named
-  for what it decides. The old name still works and delegates to the new one.
+  for what it decides: whether the binding's value comes from the container rather than a type
+  property. The old name still works and delegates to the new one.
 
 ### Fixed
 
-- A dynamic text is anchored at its drawn top-left corner rather than its centre. Its size comes
-  from the value it resolves to and that value comes from its container, so an anchor that moved
-  with the size let the two choose each other: near an edge they never settled, flipping between a
-  value and "Move to a frame" on every read. The corner is the rotated one, so a text turned on its
-  side anchors where it appears (VIBE-9567).
-- `isDynamicText` requires a `propertyBindings.text` binding, the one the value is read from. The
-  text tool creates an element with empty bindings and empty metadata, both truthy, so an
-  unconfigured text was anchored at its corner while the canvas centred it.
-- An element covering a container is not inside it, whatever its type. The rule it replaces looked
-  only at shapes wider and taller than the container, so a background image joined the frame it
-  covered.
-- A line or callout is measured from the elements it connects even with no stored `position`, where
-  it was previously left out of the index entirely.
-- `min` and `max` rendered an infinity sign when every member value was empty; both fall through to
-  `n/a`. `calculateSize` no longer throws on an element that reaches it without a `size`, which on
-  the server failed the read for the whole document.
+- A dynamic text is now anchored at its drawn top-left corner rather than its centre when deciding
+  which container it belongs to, and `DynamicTextUtil.isDynamicText` is the shared test for one. Its
+  size comes from the value it resolves to, and that value depends on the container, so letting its
+  width feed membership meant its own text could choose its container: near an edge the two answers
+  disagreed indefinitely, flipping between a value and "Move to a frame" on every read. Everything
+  else still resolves on its centre.
+- 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.
+- 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`.
+- `DynamicTextUtil.calculateSize` threw on an element that reached it without a `size`, which on
+  the server failed the read for the whole document. It now measures from a zero size instead.
 
 ### Changed
 
-- `anchorFor` and the index measure through the same factory call, 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 container path is a containment chain, walked outward from the container the element sits on, so
-  two containers that merely cross no longer both claim it.
-- `buildIndex` scans element types before measuring, so a document with no containers of the kinds
-  asked for returns an empty index without a geometry pass.
+- Container membership measures a scaled element from its scaled box, through the new
+  `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/document-container-index.js

@@ -23,7 +23,7 @@ class DocumentContainerIndex {
         return this.resolveAll(this.containerIdsOf(documentElementId, elementType));
     }
     containerIdsOf(documentElementId, elementType) {
-        return [...this.containerPath(documentElementId, elementType)];
+        return this.containerPath(documentElementId, elementType);
     }
     innermostContainerIdOf(documentElementId, elementType) {
         const path = this.containerPath(documentElementId, elementType);
@@ -31,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 = [];

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

@@ -17,10 +17,6 @@ export declare class DocumentContainerUtil {
     static centerOf(box: CoordinateBox): PositionDefinition;
     static anchorOf(documentElement: DocumentElement, box: CoordinateBox): PositionDefinition;
     static positionKeepingAnchor(documentElement: DocumentElement, newSize: SizeDefinition): 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;

package/lib/containers/document-container.js

@@ -38,23 +38,14 @@ class DocumentContainerUtil {
         const after = cornerOffset(newSize);
         return { x: position.x + before.x - after.x, y: position.y + before.y - after.y };
     }
-    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;
         }
-        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;
-        }
+        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);
     }
     static containsPoint(box, point) {
         return point.x >= box.left && point.x <= box.right && point.y >= box.top && point.y <= box.bottom;

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

@@ -8,9 +8,9 @@ const document_container_1 = require("./document-container");
 class DocumentContainerService {
     static buildIndex(documentElements, kinds = container_kind_1.CONTAINER_KINDS) {
         var _a, _b;
-        const elements = (documentElements !== null && documentElements !== void 0 ? documentElements : []).filter((element) => !!element);
+        const elements = documentElements !== null && documentElements !== void 0 ? documentElements : [];
         const containerElementTypes = new Set(kinds.map((kind) => kind.elementType));
-        if (!elements.some((element) => containerElementTypes.has(element.type))) {
+        if (!elements.some((element) => containerElementTypes.has(element === null || element === void 0 ? void 0 : element.type))) {
             return document_container_index_1.DocumentContainerIndex.empty();
         }
         const documentElementsById = new Map(elements.map((element) => [element.id, element]));

package/package.json

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