@contrail/documents 2.0.1-alpha.0 → 2.1.0-alpha.4325cd8

package/CHANGELOG.md

@@ -5,6 +5,28 @@ 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.1.0] - 2026-09-09
+
+### 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 measured centre 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.
+
+## [1.17.0] - 2026-09-09
+
+### Added
+
+- `DocumentChange.skipUndo?: boolean` — optional marker a producer sets on a forward
+  change definition to keep the action out of undo history.
+
 ## [1.16.0] - 2026-08-28
 
 ### Added

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

@@ -0,0 +1,10 @@
+import { FRAME_ELEMENT_TYPE, SECTION_ELEMENT_TYPE } from '../document-element-constants';
+export type ContainerElementType = typeof FRAME_ELEMENT_TYPE | typeof SECTION_ELEMENT_TYPE;
+export interface ContainerKind {
+    elementType: ContainerElementType;
+    nests: boolean;
+    layer: number;
+}
+export declare const SECTION_KIND: ContainerKind;
+export declare const FRAME_KIND: ContainerKind;
+export declare const CONTAINER_KINDS: ContainerKind[];

package/lib/containers/container-kind.js

@@ -0,0 +1,7 @@
+"use strict";
+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.CONTAINER_KINDS = [exports.SECTION_KIND, exports.FRAME_KIND];

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

@@ -0,0 +1,21 @@
+import { PositionDefinition } from '../types';
+import { ContainerElementType } from './container-kind';
+import { DocumentContainer } from './document-container';
+export declare class DocumentContainerIndex {
+    private readonly data;
+    constructor(data: {
+        containersById: Map<string, DocumentContainer>;
+        containerPathsByDocumentElementId: Map<string, Map<string, string[]>>;
+        memberIdsByContainerId: Map<string, string[]>;
+        containerIdsByElementType: Map<string, string[]>;
+    });
+    getContainer(containerId: string): DocumentContainer | null;
+    containersOf(documentElementId: string, elementType: ContainerElementType): DocumentContainer[];
+    containerIdsOf(documentElementId: string, elementType: ContainerElementType): string[];
+    innermostContainerIdOf(documentElementId: string, elementType: ContainerElementType): string | null;
+    memberIdsOf(containerId: string): string[];
+    containerPathAtPoint(point: PositionDefinition, elementType: ContainerElementType): string[];
+    maxDepth(elementType: ContainerElementType): number;
+    private containersOfType;
+    private containerPath;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentContainerIndex = void 0;
+const document_container_1 = require("./document-container");
+class DocumentContainerIndex {
+    constructor(data) {
+        this.data = data;
+    }
+    getContainer(containerId) {
+        var _a;
+        return (_a = this.data.containersById.get(containerId)) !== null && _a !== void 0 ? _a : null;
+    }
+    containersOf(documentElementId, elementType) {
+        return this.containerIdsOf(documentElementId, elementType)
+            .map((containerId) => this.data.containersById.get(containerId))
+            .filter(Boolean);
+    }
+    containerIdsOf(documentElementId, elementType) {
+        return this.containerPath(documentElementId, elementType);
+    }
+    innermostContainerIdOf(documentElementId, elementType) {
+        const path = this.containerPath(documentElementId, elementType);
+        return path.length ? path[path.length - 1] : null;
+    }
+    memberIdsOf(containerId) {
+        var _a;
+        return (_a = this.data.memberIdsByContainerId.get(containerId)) !== null && _a !== void 0 ? _a : [];
+    }
+    containerPathAtPoint(point, elementType) {
+        const covering = this.containersOfType(elementType).filter((container) => (0, document_container_1.containsPoint)(container.box, point));
+        return (0, document_container_1.topmostPerDepth)(covering).map((container) => container.id);
+    }
+    maxDepth(elementType) {
+        return this.containersOfType(elementType).reduce((max, container) => Math.max(max, container.depth + 1), 0);
+    }
+    containersOfType(elementType) {
+        var _a;
+        return ((_a = this.data.containerIdsByElementType.get(elementType)) !== null && _a !== void 0 ? _a : [])
+            .map((containerId) => this.data.containersById.get(containerId))
+            .filter(Boolean);
+    }
+    containerPath(documentElementId, elementType) {
+        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 : [];
+    }
+}
+exports.DocumentContainerIndex = DocumentContainerIndex;

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

@@ -0,0 +1,22 @@
+import { CoordinateBox, DocumentElement, PositionDefinition } from '../types';
+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 {
+    documentElement: DocumentElement;
+    box: CoordinateBox | null;
+    drawOrder: number;
+}
+export declare function toCoordinateBox(x: number, y: number, width: number, height: number): CoordinateBox;
+export declare function centerOf(box: CoordinateBox): PositionDefinition;
+export declare function containsPoint(box: CoordinateBox, point: PositionDefinition): boolean;
+export declare function encloses(outer: CoordinateBox, inner: CoordinateBox): boolean;
+export declare function isWiderAndTallerThan(box: CoordinateBox, other: CoordinateBox): boolean;
+export declare function topmostPerDepth(containers: DocumentContainer[]): DocumentContainer[];

package/lib/containers/document-container.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCoordinateBox = toCoordinateBox;
+exports.centerOf = centerOf;
+exports.containsPoint = containsPoint;
+exports.encloses = encloses;
+exports.isWiderAndTallerThan = isWiderAndTallerThan;
+exports.topmostPerDepth = topmostPerDepth;
+function toCoordinateBox(x, y, width, height) {
+    return { x, y, width, height, left: x, right: x + width, top: y, bottom: y + height };
+}
+function centerOf(box) {
+    return { x: box.left + box.width / 2, y: box.top + box.height / 2 };
+}
+function containsPoint(box, point) {
+    return point.x >= box.left && point.x <= box.right && point.y >= box.top && point.y <= box.bottom;
+}
+function encloses(outer, inner) {
+    const covers = outer.left <= inner.left && outer.right >= inner.right && outer.top <= inner.top && outer.bottom >= inner.bottom;
+    const identical = outer.left === inner.left &&
+        outer.right === inner.right &&
+        outer.top === inner.top &&
+        outer.bottom === inner.bottom;
+    return covers && !identical;
+}
+function isWiderAndTallerThan(box, other) {
+    return box.width > other.width && box.height > other.height;
+}
+function topmostPerDepth(containers) {
+    const byDepth = [];
+    for (const container of containers) {
+        const existing = byDepth[container.depth];
+        if (!existing || container.drawOrder > existing.drawOrder) {
+            byDepth[container.depth] = container;
+        }
+    }
+    return byDepth.filter(Boolean);
+}

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

@@ -0,0 +1,14 @@
+import { DocumentElement } from '../types';
+import { ContainerKind } from './container-kind';
+import { DocumentContainerIndex } from './document-container-index';
+export declare class DocumentContainerService {
+    static buildIndex(documentElements: readonly DocumentElement[], kinds?: ContainerKind[]): DocumentContainerIndex;
+    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 candidateContainers;
+}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentContainerService = void 0;
+const document_element_factory_1 = require("../document-element-factory");
+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)]));
+        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));
+        });
+        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);
+                for (const containerId of path) {
+                    const members = memberIdsByContainerId.get(containerId);
+                    if (members) {
+                        members.push(documentElementId);
+                    }
+                    else {
+                        memberIdsByContainerId.set(containerId, [documentElementId]);
+                    }
+                }
+            }
+            containerPathsByDocumentElementId.set(documentElementId, pathsByElementType);
+        }
+        return new document_container_index_1.DocumentContainerIndex({
+            containersById,
+            containerPathsByDocumentElementId,
+            memberIdsByContainerId,
+            containerIdsByElementType,
+        });
+    }
+    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]));
+        return documentElements.map((documentElement, drawOrder) => ({
+            documentElement,
+            drawOrder,
+            box: this.measure(documentElement, documentElementsById),
+        }));
+    }
+    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 { x, y, width, height } = document_element_factory_1.DocumentElementFactory.getBoundingClientRect(documentElement, start, end);
+            return (0, document_container_1.toCoordinateBox)(x, y, width, height);
+        }
+        catch (_c) {
+            return null;
+        }
+    }
+    static buildNesting(measuredDocumentElements, kind) {
+        const containers = 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 && (0, document_container_1.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) {
+            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 [];
+        }
+        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]);
+    }
+    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 (0, document_container_1.topmostPerDepth)(containers).map((container) => container.id);
+    }
+    static candidateContainers(measured, containers) {
+        const center = (0, document_container_1.centerOf)(measured.box);
+        const isShape = document_element_constants_1.SHAPE_ELEMENT_TYPES.includes(measured.documentElement.type);
+        return containers.filter((container) => {
+            var _a;
+            if (container.id === measured.documentElement.id || measured.drawOrder <= container.drawOrder) {
+                return false;
+            }
+            if (!(0, document_container_1.containsPoint)(container.box, center)) {
+                return false;
+            }
+            if (isShape && (0, document_container_1.isWiderAndTallerThan)(measured.box, container.box)) {
+                return false;
+            }
+            return !((_a = measured.documentElement.elementIds) === null || _a === void 0 ? void 0 : _a.includes(container.id));
+        });
+    }
+}
+exports.DocumentContainerService = DocumentContainerService;

package/lib/document-element-constants.d.ts

@@ -3,3 +3,6 @@ export declare const ANNOTATION_PADDING_Y = 8;
 export declare const COLOR_PADDING = 5;
 export declare const COLOR_FONT_SIZE = 8;
 export declare const COLOR_WIDTH = 140;
+export declare const SECTION_ELEMENT_TYPE = "section";
+export declare const FRAME_ELEMENT_TYPE = "frame";
+export declare const SHAPE_ELEMENT_TYPES: string[];

package/lib/document-element-constants.js

@@ -1,8 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COLOR_WIDTH = exports.COLOR_FONT_SIZE = exports.COLOR_PADDING = exports.ANNOTATION_PADDING_Y = exports.ANNOTATION_IMG_SIZE = void 0;
+exports.SHAPE_ELEMENT_TYPES = exports.FRAME_ELEMENT_TYPE = exports.SECTION_ELEMENT_TYPE = exports.COLOR_WIDTH = exports.COLOR_FONT_SIZE = exports.COLOR_PADDING = exports.ANNOTATION_PADDING_Y = exports.ANNOTATION_IMG_SIZE = void 0;
 exports.ANNOTATION_IMG_SIZE = 15;
 exports.ANNOTATION_PADDING_Y = 8;
 exports.COLOR_PADDING = 5;
 exports.COLOR_FONT_SIZE = 8;
 exports.COLOR_WIDTH = 140;
+exports.SECTION_ELEMENT_TYPE = 'section';
+exports.FRAME_ELEMENT_TYPE = 'frame';
+exports.SHAPE_ELEMENT_TYPES = [
+    'text',
+    'line',
+    'arrow',
+    'circle',
+    'rectangle',
+    'round_rectangle',
+    'triangle',
+    'diamond',
+    'star',
+    'heart',
+    'double_arrow',
+    'right_arrow',
+    'rhombus',
+    'cloud',
+    'callout',
+    'draw_frame',
+    'draw_section',
+];

package/lib/index.d.ts

@@ -13,3 +13,7 @@ export * from './util/curved-line/point';
 export * from './util/curved-line/curved-line';
 export * from './util/callout/callout';
 export * from './document-frame.service';
+export * from './containers/container-kind';
+export * from './containers/document-container';
+export * from './containers/document-container-index';
+export * from './containers/document-container.service';

package/lib/index.js

@@ -29,3 +29,7 @@ __exportStar(require("./util/curved-line/point"), exports);
 __exportStar(require("./util/curved-line/curved-line"), exports);
 __exportStar(require("./util/callout/callout"), exports);
 __exportStar(require("./document-frame.service"), exports);
+__exportStar(require("./containers/container-kind"), exports);
+__exportStar(require("./containers/document-container"), exports);
+__exportStar(require("./containers/document-container-index"), exports);
+__exportStar(require("./containers/document-container.service"), exports);

package/lib/types/document-change.d.ts

@@ -17,4 +17,5 @@ export interface DocumentChange {
     documentGenerationConfig?: any;
     backingAssortmentItemData?: any;
     targetSortIndex?: number;
+    skipUndo?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/documents",
-  "version": "2.0.1-alpha.0",
+  "version": "2.1.0-alpha.4325cd8",
   "description": "Documents library for contrail platform",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -22,7 +22,7 @@
     "tslint": "^5.11.0",
     "tslint-config-prettier": "^1.18.0",
     "typescript": "^5.8.3",
-    "@contrail/telemetry": "^3.0.1-alpha.1"
+    "@contrail/telemetry": "^2.0.0"
   },
   "jest": {
     "moduleFileExtensions": [
@@ -39,17 +39,14 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@contrail/actions": "^2.0.1-alpha.0",
-    "@contrail/document-table": "^2.0.1-alpha.0",
-    "@contrail/document-util": "^2.0.1-alpha.1",
-    "@contrail/types": "^4.0.1-alpha.1",
+    "@contrail/actions": "^1.0.18",
+    "@contrail/document-table": "^1.2.3",
+    "@contrail/document-util": "^1.2.0",
+    "@contrail/types": "^3.4.0",
     "fractional-indexing": "^2.1.0",
     "reflect-metadata": "^0.1.13"
   },
   "peerDependencies": {
-    "@contrail/telemetry": "^3.0.1-alpha.1"
-  },
-  "engines": {
-    "node": ">=24"
+    "@contrail/telemetry": "^2.0.0"
   }
 }