@celldl/editor 0.20260212.0 → 0.20260217.1

package/dist/src/CellDL/components/index.d.ts

@@ -0,0 +1,39 @@
+import { CellDLObject } from '../celldlObjects/index';
+import { MetadataPropertiesMap } from '../../metadata/index';
+import { PointLike } from '../../common/points';
+import { Constructor, StringProperties } from '../../common/types';
+export interface ObjectTemplate {
+    CellDLClass: Constructor<CellDLObject>;
+    description?: string;
+    image?: string;
+    metadataProperties: MetadataPropertiesMap;
+    name?: string;
+}
+export interface LibraryComponentTemplate {
+    id: string;
+    name: string;
+    image: string;
+    selected?: boolean;
+}
+export interface ComponentLibrary {
+    id: string;
+    name: string;
+    templates: LibraryComponentTemplate[];
+}
+export interface ElementTypeName {
+    type: string;
+    name: string;
+}
+export interface NamedProperty {
+    name: string;
+    property: string;
+}
+export interface TemplateProperties {
+    nodeSettings?: StringProperties;
+}
+export type TemplateEventDetails = {
+    id: string;
+    centre: PointLike;
+    offset: PointLike;
+};
+export declare function getTemplateEventDetails(id: string, target: HTMLImageElement, event: DragEvent | MouseEvent | null): TemplateEventDetails;

package/dist/src/CellDL/components/properties.d.ts

@@ -0,0 +1,61 @@
+import { CellDLObject } from '../celldlObjects/index';
+import { IPathStyle } from '../../common/svgUtils';
+import { RdfStore } from '../../metadata/index';
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+import type * as locApi from '@renderer/libopencor/locUIJsonApi';
+export type ItemDetails = locApi.IUiJsonInput & {
+    itemId: string;
+    property: string;
+    value?: string | number;
+    units?: string;
+    optional?: boolean;
+    numeric?: boolean;
+};
+export type StyleObject = {
+    fillColours?: string[];
+    pathStyle?: IPathStyle;
+};
+export interface PropertyGroup {
+    groupId: string;
+    items: ItemDetails[];
+    styling?: StyleObject;
+    title: string;
+}
+export type StylingGroup = PropertyGroup & {
+    styling: StyleObject;
+};
+export interface ValueChange {
+    oldValue: string;
+    newValue: string;
+}
+export declare const METADATA_GROUP_ID = "cd-metadata";
+export declare const STYLING_GROUP_ID = "object-styling";
+export declare const STYLING_GROUP: PropertyGroup;
+export declare function getItemProperty(celldlObject: CellDLObject, itemTemplate: ItemDetails, rdfStore: RdfStore): ItemDetails | undefined;
+export declare function updateItemProperty(property: string, value: ValueChange, celldlObject: CellDLObject, rdfStore: RdfStore): void;
+export declare class ObjectPropertiesPanel {
+    #private;
+    constructor();
+    clearObjectProperties(): void;
+    setObjectProperties(celldlObject: CellDLObject | null, rdfStore: RdfStore): void;
+    updateObjectProperties(celldlObject: CellDLObject | null, itemId: string, value: ValueChange, rdfStore: RdfStore): Promise<void>;
+    updateObjectStyling(celldlObject: CellDLObject | null, objectType: string, styling: StyleObject): Promise<void>;
+}

package/dist/src/CellDL/connections/index.d.ts

@@ -0,0 +1,35 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export declare enum ConnectionStyle {
+    Linear = "linear",
+    Rectilinear = "rectilinear"
+}
+export interface ConnectionStyleDefinition {
+    id: ConnectionStyle;
+    icon: string;
+    name: string;
+}
+export declare const DEFAULT_CONNECTION_STYLE_DEFINITION: {
+    id: ConnectionStyle;
+    name: string;
+    icon: string;
+};
+export declare const DEFAULT_CONNECTION_STYLE: ConnectionStyle;
+export declare const CONNECTION_STYLE_DEFINITIONS: ConnectionStyleDefinition[];

package/dist/src/CellDL/connections/pathmaker.d.ts

@@ -0,0 +1,38 @@
+import { PointLike } from '../../common/points';
+import { CellDLConnectedObject, CellDLObject } from '../celldlObjects/index';
+import { CellDLDiagram } from '../diagram/index';
+import { EditorFrame } from '../editor/editorframe';
+import { CellDLSVGElement } from '../SVGElements/index';
+export declare class PathNode {
+    readonly object: CellDLConnectedObject;
+    constructor(object: CellDLConnectedObject);
+    get celldlSvgElement(): CellDLSVGElement | undefined;
+    get id(): string;
+    get uri(): import('../../metadata/index').NamedNode;
+    canConnect(_node: PathNode): boolean;
+}
+/**
+ * A ``PathMaker`` is used to create a ``celldl:Connection``.
+ *
+ * A connection begins with a start object; has a geometric shape, specified by an
+ * SVG path; possibly passes through intermediate objects (conduits); and finishes
+ * with an end object.
+ *
+ * An object may have constraints to determine whether and how it can be connected
+ * to a path.
+ */
+export declare class PathMaker {
+    #private;
+    constructor(editorFrame: EditorFrame, startNode: PathNode, style?: string);
+    get currentSvgPath(): SVGPathElement | null;
+    get empty(): boolean;
+    static validStartObject(celldlObject: CellDLObject): PathNode | null;
+    static startPartialPath(point: PointLike, celldlDiagram: CellDLDiagram): PathNode;
+    close(): void;
+    validPathNode(celldlObject: CellDLObject): PathNode | null;
+    addIntermediate(node: PathNode, shiftKey?: boolean): void;
+    addPoint(point: PointLike, shiftKey?: boolean): void;
+    drawTo(point: PointLike, shiftKey?: boolean): void;
+    finishPath(endNode: PathNode, celldlDiagram: CellDLDiagram, shiftKey?: boolean): void;
+    finishPartialPath(celldlDiagram: CellDLDiagram, shiftKey?: boolean): void;
+}

package/dist/src/CellDL/diagram/index.d.ts

@@ -0,0 +1,45 @@
+import { PointLike } from '../../common/points';
+import { StringProperties } from '../../common/types';
+import { NamedNode, MetadataPropertyValue } from '../../metadata/index';
+import { Bounds } from '../geometry/index';
+import { ContainedObject } from '../geometry/spatialindex';
+import { CellDLConnectedObject, CellDLConnection, CellDLCompartment, CellDLInterface, CellDLObject, CellDLUnconnectedPort } from '../celldlObjects/index.ts';
+import { CellDLEditor } from '../editor/index';
+import { EditorUndoAction } from '../editor/undoredo';
+import { ObjectTemplate } from '../components/index';
+import * as $rdf from '@renderer/metadata/index';
+export declare const CELLDL_VERSION = "1.0";
+export declare class CellDLDiagram {
+    #private;
+    constructor(filePath: string, celldlData: string, celldlEditor: CellDLEditor, importSvg?: boolean);
+    finishSetup(): void;
+    edit(): Promise<void>;
+    get editorFrame(): import('../editor/editorframe').EditorFrame | null;
+    get metadata(): StringProperties;
+    set metadata(data: StringProperties);
+    get rdfStore(): $rdf.RdfStore;
+    get svgDiagram(): SVGSVGElement;
+    get uri(): string;
+    domToSvgCoords(domCoords: PointLike): DOMPoint;
+    svgToDomCoords(svgCoords: PointLike): DOMPoint;
+    makeUri(id: string): NamedNode;
+    removeKnowledge(subject: NamedNode, predicates: NamedNode[]): void;
+    objectById(id: string): CellDLObject | null;
+    export(format: string): {
+        error: string;
+    };
+    serialise(): Promise<string>;
+    addEditorElement(element: SVGElement, prepend?: boolean): void;
+    associatedObjects(object: CellDLObject): CellDLObject[];
+    addConnectedObject(svgElement: SVGGraphicsElement, template: ObjectTemplate): CellDLConnectedObject | null;
+    addNewConnection(svgElement: SVGGraphicsElement, template: ObjectTemplate): CellDLConnection;
+    createCompartment(bounds: Bounds, objects: CellDLObject[]): CellDLCompartment;
+    createInterfacePort(point: PointLike): CellDLInterface;
+    createUnconnectedPort(point: PointLike): CellDLUnconnectedPort;
+    getConnector(connectorNode: MetadataPropertyValue | null): CellDLConnectedObject | null;
+    objectsContainedIn(compartment: Bounds): ContainedObject[];
+    objectMoved(celldlObject: CellDLObject): void;
+    deleteInsertedObject(undoAction: EditorUndoAction): void;
+    insertDeletedObject(undoAction: EditorUndoAction): void;
+    removeObject(celldlObject: CellDLObject): void;
+}

package/dist/src/CellDL/editor/alerts.d.ts

@@ -0,0 +1,27 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export declare namespace alert {
+    function clear(): void;
+    function error(msg: string): void;
+    function info(msg: string): void;
+    function tooltip(msg: string): void;
+    function warn(msg: string): void;
+    function elementError(msg: string, svgElement?: SVGGraphicsElement): void;
+}

package/dist/src/CellDL/editor/editguides.d.ts

@@ -0,0 +1,31 @@
+import { ViewState } from '../../common/EditorTypes';
+import { Point, PointLike } from '../../common/points';
+import { CellDLDiagram } from '../diagram/index';
+import { CellDLMoveableObject } from '../celldlObjects/index';
+import { Extent } from '../geometry/index';
+export declare const EDITOR_GRID_CLASS = "alignment-grid";
+export declare const GRID_SNAP_RESOLUTION = 0.5;
+export declare const GRID_SPACING = 10;
+export type GridAlignOptions = {
+    fullSnap?: boolean;
+    noAlign?: boolean;
+    noAlignX?: boolean;
+    noAlignY?: boolean;
+    resolution?: number;
+    snapGrid?: boolean;
+};
+export declare const DEFAULT_VIEW_STATE: ViewState;
+declare class EditGuides {
+    #private;
+    private constructor();
+    static get instance(): EditGuides;
+    gridAlign(point: PointLike, options?: GridAlignOptions): Point;
+    addGuide(component: CellDLMoveableObject): void;
+    matchGuide(component: CellDLMoveableObject): Array<number | null>;
+    newDiagram(celldlDiagram: CellDLDiagram, showGrid: boolean): void;
+    setState(state: ViewState): void;
+    viewboxUpdated(viewbox: Extent): void;
+    removeGuide(component: CellDLMoveableObject): void;
+}
+export declare const editGuides: EditGuides;
+export {};

package/dist/src/CellDL/editor/editorframe.d.ts

@@ -0,0 +1,13 @@
+import { PointLike } from '../../common/points';
+import { ObjectTemplate } from '../components/index';
+export declare const EDITOR_FRAME_ID = "celldl-editor-selection-frame";
+export declare class EditorFrame {
+    #private;
+    constructor(svgDiagram: SVGSVGElement);
+    get svgGroup(): SVGGElement;
+    addElementAsString(element: string): SVGGraphicsElement | null;
+    addSvgElement(template: ObjectTemplate, topLeft: PointLike): SVGGElement;
+    clear(): void;
+    contains(feature: SVGGraphicsElement): boolean;
+    removeElement(element: SVGGraphicsElement | null): void;
+}

package/dist/src/CellDL/editor/index.d.ts

@@ -0,0 +1,40 @@
+import { CellDLDiagram } from '../diagram/index';
+import { EditorFrame } from './editorframe';
+export declare enum EDITOR_TOOL_IDS {
+    SelectTool = "select-tool",
+    DrawConnectionTool = "draw-connection-tool",
+    AddComponentTool = "add-component-tool"
+}
+export declare const DEFAULT_EDITOR_TOOL_ID = EDITOR_TOOL_IDS.SelectTool;
+export declare enum PANEL_IDS {
+    PropertyPanel = "property-panel"
+}
+export declare enum CONTEXT_MENU {
+    DELETE = "menu-delete",
+    EDIT_GROUP = "menu-edit-group",
+    INFO = "menu-info",
+    GROUP_OBJECTS = "menu-group",
+    UNGROUP_OBJECTS = "menu-ungroup"
+}
+export declare function notifyChanges(): void;
+export declare function getElementId(element: SVGGraphicsElement): string;
+export declare class CellDLEditor {
+    #private;
+    static instance: CellDLEditor | null;
+    constructor();
+    mount(svgContainer: HTMLElement): void;
+    get celldlDiagram(): CellDLDiagram | null;
+    get dirty(): boolean;
+    get editorFrame(): EditorFrame | null;
+    get status(): string;
+    set status(text: string);
+    get windowSize(): [number, number];
+    setDirty(): void;
+    markClean(): void;
+    editDiagram(celldlDiagram: CellDLDiagram): Promise<void>;
+    closeDiagram(): void;
+    resetObjectStates(): void;
+    enableContextMenuItem(_itemId: string, _enable?: boolean): void;
+    showMessage(msg: string, style?: string): void;
+    showTooltip(msg: string, style?: string): void;
+}

package/dist/src/CellDL/editor/panzoom.d.ts

@@ -0,0 +1,30 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export default class PanZoom {
+    #private;
+    constructor(container: HTMLElement);
+    get panning(): boolean;
+    get scale(): number;
+    enable(svgDiagram: SVGSVGElement): void;
+    disable(): void;
+    pointerDown(event: PointerEvent): void;
+    pointerMove(event: PointerEvent): boolean;
+    pointerUp(_event: PointerEvent): void;
+}

package/dist/src/CellDL/editor/selectionbox.d.ts

@@ -0,0 +1,17 @@
+import { CellDLObject } from '../celldlObjects';
+import { Bounds } from '../geometry';
+import { CellDLEditor } from '.';
+export declare class SelectionBox {
+    #private;
+    constructor(editor: CellDLEditor, startPoint: DOMPoint);
+    get bounds(): Bounds;
+    get count(): number;
+    get selectedObjects(): CellDLObject[];
+    pointInside(point: DOMPoint): boolean;
+    makeCompartment(): void;
+    pointerEvent(event: any, point: DOMPoint): boolean;
+    close(): void;
+    clearControlHandles(): void;
+    drawControlHandles(): void;
+    updateSelectedObjects(): void;
+}

package/dist/src/CellDL/editor/undoredo.d.ts

@@ -0,0 +1,46 @@
+import { CellDLDiagram } from '../diagram/index';
+import { CellDLObject } from '../celldlObjects/index';
+import { Point, PointLike } from '../../common/points';
+import { Statement } from '../../metadata/index';
+declare enum Action {
+    DELETE = 1,
+    INSERT = 2,
+    MOVE = 3
+}
+declare enum MovePosition {
+    LAST = 1,
+    CURRENT = 2
+}
+export type UndoMovePosition = [number, Point | null] | null;
+declare class ObjectDetails {
+    #private;
+    constructor(object: CellDLObject);
+    get object(): CellDLObject;
+    insertSvg(svgDiagram: SVGSVGElement): void;
+}
+export declare class EditorUndoAction {
+    #private;
+    readonly action: Action;
+    readonly position: Point | null;
+    constructor(action: Action, position?: Point | null);
+    get knowledge(): Statement[];
+    get objectDetails(): ObjectDetails[];
+    addKnowledge(statements: Statement[]): void;
+    addObjectDetails(object: CellDLObject): void;
+    moveDetails(position: MovePosition): UndoMovePosition;
+    startMove(controlIndex: number, position: PointLike): void;
+    endMove(controlIndex: number, position: PointLike): void;
+}
+declare class UndoRedo {
+    #private;
+    private constructor();
+    static get instance(): UndoRedo;
+    clean(): void;
+    redo(diagram: CellDLDiagram): void;
+    undo(diagram: CellDLDiagram): void;
+    undoDeleteAction(): EditorUndoAction;
+    undoInsertAction(): EditorUndoAction;
+    undoMoveAction(): EditorUndoAction;
+}
+export declare const undoRedo: UndoRedo;
+export {};

package/dist/src/CellDL/geometry/controls.d.ts

@@ -0,0 +1,53 @@
+import { CellDLConnection, CellDLObject } from '../celldlObjects/index';
+import { EditorFrame } from '../editor/editorframe';
+import { Point, PointLike } from '../../common/points';
+import { StringProperties } from '../../common/types';
+import { FixedValue, RestrictedPoint, RestrictedValue } from './index.ts';
+export declare class ControlPoint extends RestrictedPoint {
+    #private;
+    constructor(xValue: RestrictedValue, yValue: RestrictedValue, celldlObject?: CellDLObject | null);
+    get celldlObject(): CellDLObject | null;
+    get fixed(): boolean;
+    get isConduit(): boolean;
+    static fromPoint(point: PointLike): ControlPoint;
+    static fromValue(x: number, y: number): ControlPoint;
+    colinear(p1: ControlPoint, p2: ControlPoint): boolean;
+    copy(): ControlPoint;
+    createSvgElement(editorFrame: EditorFrame, style?: string, connection?: CellDLConnection | null): SVGGraphicsElement;
+    removeSvgElement(): void;
+    reassignPosition(position: PointLike): void;
+    redraw(): boolean;
+    toString(): string;
+}
+export declare class FixedControlPoint extends ControlPoint {
+    readonly celldlObject: CellDLObject | null;
+    constructor(xValue: FixedValue, yValue: FixedValue, celldlObject?: CellDLObject | null);
+    copy(): FixedControlPoint;
+    toString(): string;
+}
+export declare class ControlRect {
+    #private;
+    constructor(corner_0: RestrictedPoint, corner_1: RestrictedPoint, centroidOffset?: Point | null);
+    set gridAligned(align: boolean);
+    get centroid(): RestrictedPoint;
+    get dirty(): boolean;
+    get fixed(): boolean;
+    get svgElement(): SVGRectElement | null;
+    get topLeftPoint(): Point;
+    clean(): void;
+    copy(): ControlRect;
+    setCornerPositions(corner_0: RestrictedPoint, corner_1: RestrictedPoint): void;
+    setCentroidOffset(centroidOffset: Point): void;
+    startMove(point: PointLike): void;
+    move(point: PointLike): void;
+    /**
+     * Reposition the rectangle.
+     *
+     * @param centroid - The new position of the rectangle's centroid.
+     */
+    reposition(centroid: PointLike): void;
+    svg(attributes?: StringProperties): string;
+}
+export declare class FixedControlRect extends ControlRect {
+    constructor(bounds: [number, number, number, number]);
+}

package/dist/src/CellDL/geometry/index.d.ts

@@ -0,0 +1,92 @@
+import { GridAlignOptions } from '../editor/editguides';
+import { Transform } from './transforms';
+import { Point, PointLike } from '../../common/points';
+export type PointMoveOptions = GridAlignOptions & {
+    noOffset?: boolean;
+};
+/**
+ * [left, top, width, height]
+ */
+export type Extent = [number, number, number, number];
+export declare class Bounds {
+    #private;
+    constructor(left: number, top: number, right: number, bottom: number);
+    get left(): number;
+    get right(): number;
+    get top(): number;
+    get bottom(): number;
+    static fromPoints(pt0: PointLike, pt1: PointLike): Bounds;
+    static fromSvg(svgElement: SVGGraphicsElement, globalTransform?: Transform | null): Bounds;
+    get height(): number;
+    get topLeft(): Point;
+    get width(): number;
+    asArray(): [number, number, number, number];
+    asPoints(): [Point, Point];
+    equal(bounds: Bounds, epsilon?: number): boolean;
+    expand(margin: number): Bounds;
+    inContainer(container: Bounds): boolean;
+}
+interface NumericRange {
+    minimum: number;
+    maximum: number;
+}
+export declare class RestrictedValue implements NumericRange {
+    #private;
+    readonly id: string;
+    constructor(value?: number, rangeStart?: number | RestrictedValue, rangeEnd?: number | RestrictedValue);
+    clean(): void;
+    get dirty(): boolean;
+    get fixed(): boolean;
+    get minimum(): number;
+    get maximum(): number;
+    get value(): number;
+    set value(value: number);
+    copy(): RestrictedValue;
+    adjustValue(delta: number): void;
+    narrowRange(minimum: number | RestrictedValue, maximum: number | RestrictedValue): void;
+    reassignMaximum(maximum: number | RestrictedValue): void;
+    reassignMinimum(minimum: number | RestrictedValue): void;
+    reassignValue(value: number): void;
+    toString(): string;
+}
+export declare class FixedValue extends RestrictedValue {
+    constructor(value: number);
+    get fixed(): boolean;
+    copy(): FixedValue;
+    narrowRange(_minimum: number, _maximum: number): void;
+    reassignValue(value: number): void;
+}
+export declare class ComputedValue extends RestrictedValue {
+    #private;
+    constructor(value: () => number, minimum?: number | RestrictedValue, maximum?: number | RestrictedValue);
+    get dirty(): boolean;
+    get value(): number;
+    set value(_: number);
+}
+export declare class RestrictedPoint {
+    #private;
+    constructor(xValue: RestrictedValue, yValue: RestrictedValue);
+    static fromPoint(point: PointLike): RestrictedPoint;
+    get dirty(): boolean;
+    get fixed(): boolean;
+    get point(): Point;
+    set point(point: PointLike);
+    get x(): number;
+    get y(): number;
+    get xValue(): RestrictedValue;
+    set xValue(value: RestrictedValue);
+    get yValue(): RestrictedValue;
+    set yValue(value: RestrictedValue);
+    clean(): void;
+    adjustValue(delta: PointLike): void;
+    copy(): RestrictedPoint;
+    move(point: PointLike, options?: PointMoveOptions): void;
+    offsetPoint(point: PointLike): Point;
+    reassignValue(point: PointLike): void;
+    startMove(point: PointLike): void;
+    toString(): string;
+}
+export declare class FixedPoint extends RestrictedPoint {
+    constructor(xValue: FixedValue, yValue: FixedValue);
+}
+export {};

package/dist/src/CellDL/geometry/intersections.d.ts

@@ -0,0 +1,6 @@
+import { Point2D } from 'svg-intersections';
+export declare class ShapeIntersections {
+    #private;
+    constructor(element: Element);
+    intersections(element: Element): Point2D[];
+}

package/dist/src/CellDL/geometry/pathutils.d.ts

@@ -0,0 +1,12 @@
+import { NormalArray } from 'svg-path-commander';
+import { PointLike } from '../../common/points';
+export type FoundPoint = {
+    point: PointLike;
+    offset: number | null;
+    segment: number | null;
+};
+export declare class PointFinder {
+    #private;
+    constructor(pathArray: NormalArray);
+    findPoint(point: PointLike): FoundPoint;
+}

package/dist/src/CellDL/geometry/spatialindex.d.ts

@@ -0,0 +1,22 @@
+import { CellDLObject } from '../celldlObjects/index';
+import { Bounds } from './index';
+export type ContainedObject = {
+    object: CellDLObject;
+    exact: boolean;
+};
+export declare class CellDLSpatialIndex {
+    #private;
+    add(celldlObject: CellDLObject): void;
+    remove(celldlObject: CellDLObject): void;
+    update(celldlObject: CellDLObject): void;
+    objectsContainedIn(bounds: Bounds): ContainedObject[];
+}
+export type SpatialSearchResult = {
+    object: CellDLObject;
+    bounds: Bounds;
+};
+export declare class SpatialObjectIndex {
+    #private;
+    constructor(celldlObjects: CellDLObject[]);
+    search(bounds: Bounds): SpatialSearchResult[];
+}

package/dist/src/CellDL/geometry/transforms.d.ts

@@ -0,0 +1,21 @@
+import { Matrix } from 'transformation-matrix';
+import { Point, PointLike } from '../../common/points';
+export declare class NormalTransform {
+    #private;
+    constructor(p0: PointLike, p1: PointLike);
+    normalise(point: PointLike): Point;
+    invert(point: PointLike): Point;
+}
+export declare class Transform {
+    #private;
+    constructor(matrix: Matrix);
+    static fromString(matrix: string): Transform;
+    static Identity(): Transform;
+    get isIdentity(): boolean;
+    inverse(): Transform;
+    leftMultiply(transform: Transform): Transform;
+    toString(): string;
+    transformPoint(point: PointLike): Point;
+    transformPoints(points: PointLike[]): Point[];
+    static Translate(tx: number, ty: number): Transform;
+}

package/dist/src/CellDL/geometry/units.d.ts

@@ -0,0 +1,23 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export declare const EM_SIZE = 16;
+export declare const EX_SIZE: number;
+export declare function lengthToPixels(length: string | number | null): number | null;
+export declare function pixelsToLength(pixels: string | number, units: string): string | null;