@focus.matters/diagrams 0.1.2 → 0.2.20

package/dist/src/Diagrams/custom/mr/MRDiagram.d.ts

@@ -0,0 +1,17 @@
+import { TDiagramSettings } from '../../store/Diagram';
+import { EditableDiagram } from '../editable/EditableDiagram';
+import { MRForeignKeyEdge } from './edges/MRForeignKeyEdge';
+import { MRTableNode } from './nodes/MRTableNode';
+import { MRForeignKeyModel, MRTableKind } from './types';
+/** Configures an editable relational/UML data model with tables and foreign keys. */
+export declare class MRDiagram extends EditableDiagram {
+    constructor(settings?: TDiagramSettings);
+    /** Creates and selects one table centered on an exact client-space point. */
+    createTableFromClientPoint(kind: MRTableKind, clientX: number, clientY: number, label?: string): MRTableNode;
+    /** Creates and selects one table centered on an exact canvas-space point. */
+    createTableAtCanvasPoint(kind: MRTableKind, x: number, y: number, label?: string): MRTableNode;
+    /** Arranges relational dependencies in readable left-to-right Dagre layers. */
+    autoLayout(): boolean;
+    /** Connects a dependent table to a referenced table with foreign-key metadata. */
+    connectForeignKey(source: MRTableNode, target: MRTableNode, model?: Partial<MRForeignKeyModel>): MRForeignKeyEdge;
+}

package/dist/src/Diagrams/custom/mr/bindAttributeRelationshipHover.d.ts

@@ -0,0 +1,3 @@
+import { MRDiagram } from './MRDiagram';
+/** Highlights connections and adjacent tables for hovered attributes, including custom table renderers. */
+export declare function bindAttributeRelationshipHover(root: HTMLElement, diagram: MRDiagram): () => void;

package/dist/src/Diagrams/custom/mr/edges/MRForeignKeyEdge.d.ts

@@ -0,0 +1,77 @@
+import { Edge } from '../../../store/elements/Edge';
+import { Element } from '../../../store/elements/Element';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { TEdgeState } from '../../../store/types';
+import { MRCardinality, MRForeignKeyModel, MRMatchType, MRReferentialAction } from '../types';
+type MRForeignKeyEdgeState = Partial<TEdgeState> & Partial<MRForeignKeyModel>;
+/** Models one relational foreign-key constraint on top of a routed diagram edge. */
+export declare class MRForeignKeyEdge extends Edge {
+    constraintId: string;
+    mappingIndex: number;
+    name: string;
+    sourceAttributeIds: string[];
+    targetAttributeIds: string[];
+    sourceCardinality: MRCardinality;
+    targetCardinality: MRCardinality;
+    onDelete: MRReferentialAction;
+    onUpdate: MRReferentialAction;
+    matchType: MRMatchType;
+    identifying: boolean;
+    deferrable: boolean;
+    initiallyDeferred: boolean;
+    constructor(parent: Element | null, state: MRForeignKeyEdgeState);
+    /** Updates foreign-key semantics and refreshes its identifying line style. */
+    updateModel(patch: Partial<MRForeignKeyModel>): void;
+    /** Stores a first route and positions the generated constraint label at its midpoint. */
+    setSteps(steps: Coordinates[]): void;
+    private applyStyle;
+    /** Serializes every referential action, mapping, cardinality, and edge route. */
+    serialize(): {
+        constraintId: string;
+        mappingIndex: number;
+        name: string;
+        sourceAttributeIds: string[];
+        targetAttributeIds: string[];
+        sourceCardinality: MRCardinality;
+        targetCardinality: MRCardinality;
+        onDelete: MRReferentialAction;
+        onUpdate: MRReferentialAction;
+        matchType: MRMatchType;
+        identifying: boolean;
+        deferrable: boolean;
+        initiallyDeferred: boolean;
+        arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+        arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+        displacementEnd: [number, number] | undefined;
+        displacementStart: [number, number] | undefined;
+        lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+        labels: {
+            alignment: "right" | "left" | "center";
+            id: string;
+            size: {
+                height: number;
+                width: number;
+            };
+            text: string;
+            position: [number, number];
+        }[];
+        pathType: import('../../../store/types').EdgePathType;
+        startAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        endAnchor: {
+            mode: import('../../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    /** Restores foreign-key semantics after generic edge routing has been imported. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}
+export {};

package/dist/src/Diagrams/custom/mr/extensions/MRModelerExtension.d.ts

@@ -0,0 +1,45 @@
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { EdgePathType } from '../../../store/types';
+import { MRForeignKeyEdge } from '../edges/MRForeignKeyEdge';
+import { MRTableNode } from '../nodes/MRTableNode';
+import { MRAttribute, MRConstraint, MRConstraintKind, MRForeignKeyModel, MRShowcaseElement, MRTableKind } from '../types';
+/** Coordinates relational-model creation and every inspector-driven schema mutation. */
+export declare class MRModelerExtension extends DiagramExtension {
+    RenderUI: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<MRModelerExtension>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    /** Initializes this stateless modeler extension for fixed inspector rendering. */
+    init(): void;
+    /** Creates a table node centered at an exact canvas-space point and selects it. */
+    createTable(position: Coordinates, kind?: MRTableKind, label?: string): MRTableNode;
+    /** Adds any catalog element, applying embedded elements to the selected table. */
+    addShowcaseElement(kind: MRShowcaseElement): MRTableNode | MRForeignKeyEdge;
+    /** Returns the only selected relational table, or null for mixed selections. */
+    get selectedTable(): MRTableNode | null;
+    /** Renames one relational table while preserving the generic node contract. */
+    renameTable(node: MRTableNode, name: string): void;
+    /** Updates schema, description, or table-kind metadata in one history mutation. */
+    updateTable(node: MRTableNode, patch: Parameters<MRTableNode["updateModel"]>[0]): void;
+    /** Adds one fully editable column definition to the supplied relational table. */
+    addAttribute(node: MRTableNode, overrides?: Partial<MRAttribute>): MRAttribute;
+    /** Applies a partial column update and synchronizes foreign-key references. */
+    updateAttribute(node: MRTableNode, id: string, patch: Partial<MRAttribute>): void;
+    /** Removes one column plus foreign keys that would otherwise reference it. */
+    removeAttribute(node: MRTableNode, id: string): void;
+    /** Reorders one table attribute and preserves all column-specific edge anchors. */
+    moveAttribute(node: MRTableNode, attributeId: string, beforeAttributeId: string | null): void;
+    /** Adds a table-level primary, unique, check, or index constraint with metadata. */
+    addConstraint(node: MRTableNode, kind: MRConstraintKind, overrides?: Partial<MRConstraint>): MRConstraint;
+    /** Updates all editable metadata stored by one table-level relational constraint. */
+    updateConstraint(node: MRTableNode, id: string, patch: Partial<MRConstraint>): void;
+    /** Removes one table-level constraint in a single history-aware operation. */
+    removeConstraint(node: MRTableNode, id: string): void;
+    /** Updates mappings, actions, cardinalities, and integrity flags of a foreign key. */
+    updateForeignKey(edge: MRForeignKeyEdge, patch: Partial<MRForeignKeyModel>): void;
+    /** Changes the routing family used to draw one relational foreign-key connection. */
+    updateForeignKeyPath(edge: MRForeignKeyEdge, pathType: EdgePathType): void;
+    private createForeignKeyExample;
+    private rewireForeignKey;
+    private recordChange;
+}

package/dist/src/Diagrams/custom/mr/extensions/MRPropertyChangeEvent.d.ts

@@ -0,0 +1,4 @@
+import { DChangeEvent } from '../../../store/elements/Events';
+/** Marks property-inspector mutations in the relational model as undoable changes. */
+export declare class MRPropertyChangeEvent extends DChangeEvent {
+}

package/dist/src/Diagrams/custom/mr/layout/applyMRAutoLayout.d.ts

@@ -0,0 +1,3 @@
+import { MRDiagram } from '../MRDiagram';
+/** Applies Dagre's layered directed-graph algorithm to relational tables and FKs. */
+export declare function applyMRAutoLayout(diagram: MRDiagram): boolean;

package/dist/src/Diagrams/custom/mr/nodes/MRTableNode.d.ts

@@ -0,0 +1,105 @@
+import { Diagram } from '../../../store/Diagram';
+import { Element } from '../../../store/elements/Element';
+import { Gateway } from '../../../store/elements/Gateway';
+import { Node, TNodeConstructorProps } from '../../../store/elements/Node';
+import { MRAttribute, MRConstraint, MRConstraintKind, MRTableModel } from '../types';
+type MRTableNodeState = TNodeConstructorProps & {
+    model?: Partial<MRTableModel>;
+};
+/** Models and renders one relational table or UML data class with its full schema. */
+export declare class MRTableNode extends Node<any> {
+    model: MRTableModel;
+    constructor(parent: Element | null, state: MRTableNodeState);
+    protected initializeGateways(): void;
+    /** Attaches the table and recalculates row geometry from the diagram grid size. */
+    setDiagram(diagram: Diagram): void;
+    /** Adds one column definition and expands the rendered table when necessary. */
+    addAttribute(overrides?: Partial<MRAttribute>): MRAttribute;
+    /** Updates selected column properties while enforcing primary-key nullability. */
+    updateAttribute(id: string, patch: Partial<MRAttribute>): void;
+    /** Removes one column and clears every table constraint referencing that column. */
+    removeAttribute(id: string): void;
+    /** Moves one attribute before another row and reroutes every affected column edge. */
+    moveAttribute(attributeId: string, beforeAttributeId: string | null): void;
+    /** Adds a named table constraint with optional columns and expression metadata. */
+    addConstraint(kind: MRConstraintKind, overrides?: Partial<MRConstraint>): MRConstraint;
+    /** Updates one table-level primary, unique, check, or index constraint definition. */
+    updateConstraint(id: string, patch: Partial<MRConstraint>): void;
+    /** Removes one table constraint without changing any of its referenced columns. */
+    removeConstraint(id: string): void;
+    /** Updates table metadata and keeps the visual kind modifier synchronized. */
+    updateModel(patch: Partial<Omit<MRTableModel, "attributes" | "constraints">>): void;
+    private fitHeightToContent;
+    private get attributeRowHeight();
+    private syncAttributeGateways;
+    private syncAttributeGatewayPositions;
+    /** Returns the exact left or right gateway anchored to one relational attribute row. */
+    gatewayForAttribute(attributeId: string, side: "left" | "right"): Gateway | undefined;
+    /** Resolves persisted attribute gateways early enough for cross-table edge imports. */
+    getGateway(which: any): Gateway | undefined;
+    /** Serializes relational metadata together with generic node geometry and edges. */
+    serialize(): {
+        model: MRTableModel;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores relational metadata and recalculates the minimum visual table height. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    RenderScreen: null;
+}
+export {};

package/dist/src/Diagrams/custom/mr/types.d.ts

@@ -0,0 +1,51 @@
+export type MRTableKind = "table" | "view" | "junction";
+export type MRAttribute = {
+    id: string;
+    name: string;
+    dataType: string;
+    length: string;
+    nullable: boolean;
+    primaryKey: boolean;
+    unique: boolean;
+    autoIncrement: boolean;
+    defaultValue: string;
+    generatedExpression: string;
+    checkExpression: string;
+    comment: string;
+};
+export type MRConstraintKind = "primary-key" | "unique" | "check" | "index";
+export type MRConstraint = {
+    id: string;
+    kind: MRConstraintKind;
+    name: string;
+    attributeIds: string[];
+    expression: string;
+    indexMethod: string;
+};
+export type MRTableModel = {
+    schemaName: string;
+    tableKind: MRTableKind;
+    description: string;
+    attributes: MRAttribute[];
+    constraints: MRConstraint[];
+};
+export type MRReferentialAction = "no-action" | "restrict" | "cascade" | "set-null" | "set-default";
+export type MRCardinality = "zero-one" | "one" | "zero-many" | "one-many";
+export type MRMatchType = "simple" | "full" | "partial";
+export type MRForeignKeyModel = {
+    constraintId: string;
+    mappingIndex: number;
+    name: string;
+    sourceAttributeIds: string[];
+    targetAttributeIds: string[];
+    sourceCardinality: MRCardinality;
+    targetCardinality: MRCardinality;
+    onDelete: MRReferentialAction;
+    onUpdate: MRReferentialAction;
+    matchType: MRMatchType;
+    identifying: boolean;
+    deferrable: boolean;
+    initiallyDeferred: boolean;
+};
+export type MRShowcaseElement = "table" | "view" | "junction" | "attribute" | "primary-key" | "foreign-key" | "unique" | "check" | "index";
+export declare const MR_DATA_TYPES: readonly ["BIGINT", "INTEGER", "SMALLINT", "DECIMAL", "NUMERIC", "REAL", "DOUBLE PRECISION", "BOOLEAN", "CHAR", "VARCHAR", "TEXT", "DATE", "TIME", "TIMESTAMP", "TIMESTAMPTZ", "UUID", "JSON", "JSONB", "BINARY", "BLOB"];

package/dist/src/Diagrams/custom/mr/ui/MRPropertiesPanel.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { MRModelerExtension } from '../extensions/MRModelerExtension';
+/** Renders the relational-model inspector for one selected table or foreign key. */
+export declare const MRPropertiesPanel: (({ diagram, extension }: TDiagramExtensionRenderProps<MRModelerExtension>) => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/src/Diagrams/store/Canvas.d.ts

@@ -10,11 +10,23 @@ export type ScaleEvent = {
 /** Owns viewport scale, displacement, interaction sessions, and rendered canvas bounds. */
 export declare class Canvas extends Element {
     private unbindDocumentEvents;
+    private readonly detachHandlers;
     private mouseSessionStartedInFrame;
+    private keyboardSessionActive;
     private centerAnimationFrame;
     protected _displacement: Coordinates;
     _scale: number;
     private gridSize;
+    private minimumScale;
+    private maximumScale;
+    private wheelSensitivity;
+    private animatedZoom;
+    private zoomFrame;
+    private zoomTarget;
+    private zoomDeadline;
+    private zoomLastFrame;
+    private zoomCenter;
+    private applyingZoomFrame;
     size: Coordinates;
     get scale(): number;
     element: HTMLElement | null;
@@ -26,6 +38,8 @@ export declare class Canvas extends Element {
     constructor(parent: Diagram);
     /** Releases document listeners and cancels any viewport animation still in flight. */
     dispose(): void;
+    /** Registers cleanup for decorations owned by a currently attached canvas surface. */
+    onDetach(callback: () => void): () => void;
     /** Marks programmatic pointer sessions as eligible for the canvas drag lifecycle. */
     markMouseSessionStartedInFrame(): void;
     get dragging(): boolean;
@@ -35,6 +49,11 @@ export declare class Canvas extends Element {
     protected bound(): void;
     /** Centers a world point in the viewport and optionally animates the pan. */
     centerOnPoint(c: Coordinates, animated?: boolean): void;
+    /**
+     * Minimally pans the viewport until a world-space box has the requested margin.
+     */
+    ensureVisible(box: Dimensions, padding?: number, animated?: boolean): boolean;
+    private visibleOriginForInterval;
     private animateDisplacement;
     private cancelCenterAnimation;
     private applyDisplacement;
@@ -42,6 +61,27 @@ export declare class Canvas extends Element {
     displace(c: Coordinates): Coordinates;
     /** Replaces the viewport displacement while respecting configured canvas bounds. */
     setDisplacement(c: Coordinates): void;
+    /** Configures validated viewport limits and a constant scale increment per wheel pixel. */
+    configureZoom(options: {
+        minimumScale?: number;
+        maximumScale?: number;
+        wheelSensitivity?: number;
+        animated?: boolean;
+    }): void;
+    /** Applies the same configured limits to manual zoom, fitted content and restored cameras. */
+    clampScale(value: number): number;
+    /** Captures serializable camera coordinates without choosing an application storage backend. */
+    getCamera(): {
+        x: number;
+        y: number;
+        scale: number;
+    };
+    /** Restores a validated camera snapshot using the same limits as interactive viewport zoom. */
+    restoreCamera(camera: {
+        x: number;
+        y: number;
+        scale: number;
+    }): void;
     /** Changes viewport scale around a screen-space focus point and preserves alignment. */
     setScale(newScale: number, zoomCenter?: Coordinates): void;
     /**
@@ -72,8 +112,13 @@ export declare class Canvas extends Element {
     protected handleClick(originalEvent: MouseEvent): void;
     protected handleMouseUp(originalEvent: MouseEvent): void;
     protected handleMouseDown(originalEvent: MouseEvent): void;
+    protected handleFocusIn(originalEvent: FocusEvent): void;
     protected handleKeyDown(originalEvent: KeyboardEvent): void;
     protected handleKeyUp(originalEvent: KeyboardEvent): void;
     protected handleKeyPress(originalEvent: KeyboardEvent): void;
+    private cancelZoomAnimation;
+    private animateWheelZoom;
+    private advanceWheelZoom;
+    private applyWheelZoom;
     protected handleWheel(originalEvent: WheelEvent): void;
 }

package/dist/src/Diagrams/store/Diagram.d.ts

@@ -48,6 +48,12 @@ export type TDefaultExensions = {
 };
 export type TDiagramSettings = Partial<{
     extensions: TDefaultExensions;
+    zoom: {
+        minimumScale?: number;
+        maximumScale?: number;
+        wheelSensitivity?: number;
+        animated?: boolean;
+    };
 }>;
 /** Owns diagram elements, extensions, camera state, and application interactions. */
 export declare class Diagram extends Element {

package/dist/src/Diagrams/store/elements/Events.d.ts

@@ -142,8 +142,9 @@ export declare class DNodeConnectionIntentEvent extends DNodesConnectionEvent {
 export declare class DNodesConnectActionEvent extends DNodesConnectionEvent {
     origin: Node<any>;
     target: Node<any>;
+    edge?: Edge | undefined;
     protected readonly __brand: void;
-    constructor(src: Element, origin: Node<any>, target: Node<any>);
+    constructor(src: Element, origin: Node<any>, target: Node<any>, edge?: Edge | undefined);
 }
 export declare class DNodeChangeTypeEvent extends DChangeEvent {
     protected readonly __brand: void;

package/dist/src/Diagrams/store/revealDiagramNode.d.ts

@@ -0,0 +1,10 @@
+import { Diagram } from './Diagram';
+import { Node } from './elements/Node';
+import { Coordinates } from './primitives/Coordinates';
+/** Selects, frames and persistently highlights a reference destination until a click outside it. */
+export declare function revealDiagramNode(diagram: Diagram, node: Node, options?: {
+    point?: Coordinates;
+    attributeId?: string;
+    padding?: number;
+    preferredScale?: number;
+}): boolean;

package/dist/src/index.d.ts

@@ -5,7 +5,33 @@ export { BPMDiagram } from './Diagrams/custom/bpmn/BPMDiagram';
 export type { BPMDiagramSettings } from './Diagrams/custom/bpmn/BPMDiagram';
 export { BPMN_LABELS, configureBPMNLabels } from './Diagrams/custom/bpmn/config/BPMNLabels';
 export type { BPMNLabelOverrides, BPMNLabels } from './Diagrams/custom/bpmn/config/BPMNLabels';
+export { BPMNExecutionDiagram } from './Diagrams/custom/bpmnExecution/BPMNExecutionDiagram';
+export type { BPMNExecutionDiagramSettings } from './Diagrams/custom/bpmnExecution/BPMNExecutionDiagram';
+export { BPMNExecutionEdge } from './Diagrams/custom/bpmnExecution/BPMNExecutionEdge';
+export { BPMNExecutionMarker } from './Diagrams/custom/bpmnExecution/BPMNExecutionMarker';
+export { BPMNNodeExecutionState } from './Diagrams/custom/bpmnExecution/BPMNNodeExecutionState';
+export { BPMNExecutionBlackBoxPoolNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionBlackBoxPoolNode';
+export { BPMNExecutionDataStoreNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionDataStoreNode';
+export { BPMNExecutionDocumentAnnotationNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionDocumentAnnotationNode';
+export { BPMNExecutionDocumentNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionDocumentNode';
+export { BPMNExecutionEventNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionEventNode';
+export { BPMNExecutionGateNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionGateNode';
+export { BPMNExecutionLanes } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionLanes';
+export { BPMNExecutionTaskNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionTaskNode';
+export { BPMNExecutionTextAnnotationNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionTextAnnotationNode';
+export { BPMNExecutionUnknownNode } from './Diagrams/custom/bpmnExecution/nodes/BPMNExecutionUnknownNode';
+export type * from './Diagrams/custom/bpmnExecution/types';
 export { CommunicationDiagram } from './Diagrams/custom/communication/CommunicationDiagram';
 export type { CommunicationNodeType } from './Diagrams/custom/communication/types';
+export { MRForeignKeyEdge } from './Diagrams/custom/mr/edges/MRForeignKeyEdge';
+export { MRDiagram } from './Diagrams/custom/mr/MRDiagram';
+export { MRTableNode } from './Diagrams/custom/mr/nodes/MRTableNode';
+export type * from './Diagrams/custom/mr/types';
 export { DiagramEditor } from './Diagrams/DiagramEditor';
 export { Diagram } from './Diagrams/store/Diagram';
+export { customRendererProps } from './Diagrams/components/objects/customRendererProps';
+export { stopDiagramControlEvent } from './Diagrams/components/stopDiagramControlEvent';
+export { useDiagramPointerCapture } from './Diagrams/components/useDiagramPointerCapture';
+export { bindAttributeRelationshipHover } from './Diagrams/custom/mr/bindAttributeRelationshipHover';
+export { Coordinates } from './Diagrams/store/primitives/Coordinates';
+export { revealDiagramNode } from './Diagrams/store/revealDiagramNode';

package/package.json

@@ -1,45 +1,50 @@
-{
-  "name": "@focus.matters/diagrams",
-  "version": "0.1.2",
-  "type": "module",
-  "files": [
-    "dist"
-  ],
-  "main": "./dist/index.umd.js",
-  "module": "./dist/index.es.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.es.js",
-      "require": "./dist/index.umd.js"
-    },
-    "./diagrams.css": "./dist/diagrams.css"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "peerDependencies": {
-    "html2canvas": "^1.4.1",
-    "mobx": "^6.13.7",
-    "mobx-react-lite": "^4.1.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "react-icons": "^5.0.0",
-    "svg-path-bbox": "^2.1.0"
-  },
-  "devDependencies": {
-    "html2canvas": "^1.4.1",
-    "mobx": "^6.13.7",
-    "mobx-react-lite": "^4.1.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "react-icons": "^5.0.0",
-    "svg-path-bbox": "^2.1.0"
-  },
-  "gitHead": "f866b7ee0e0b98b4d9525fcb71185029df8a4996",
-  "scripts": {
-    "build": "vite build",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  }
-}
+{
+  "name": "@focus.matters/diagrams",
+  "version": "0.2.20",
+  "private": false,
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.umd.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.umd.js"
+    },
+    "./diagrams.css": "./dist/diagrams.css"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "html2canvas": "^1.4.1",
+    "mobx": "^6.13.7",
+    "mobx-react-lite": "^4.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-icons": "^5.0.0",
+    "svg-path-bbox": "^2.1.0"
+  },
+  "devDependencies": {
+    "html2canvas": "^1.4.1",
+    "mobx": "^6.13.7",
+    "mobx-react-lite": "^4.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-icons": "^5.0.0",
+    "svg-path-bbox": "^2.1.0"
+  },
+  "gitHead": "f866b7ee0e0b98b4d9525fcb71185029df8a4996",
+  "dependencies": {
+    "@dagrejs/dagre": "^3.0.0"
+  },
+  "candidateSourceCommit": "f71a92ce06888e913044f4ef56d1680b0b19ce70"
+}

package/dist/DirectedPoint-BcpEj8ub.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DirectedPoint-BcpEj8ub.js","sources":["../src/Diagrams/store/primitives/DirectedPoint.ts"],"sourcesContent":["import type { TOrientation } from \"../types\";\r\nimport { Coordinates } from \"./Coordinates\";\r\n\r\nexport class DirectedPoint extends Coordinates {\r\n  direction: TOrientation = \"left\";\r\n\r\n  get rawDirectedPoint() {\r\n    return {\r\n      x: this.x,\r\n      y: this.y,\r\n      direction: this.direction,\r\n    };\r\n  }\r\n\r\n  stepBack() {\r\n    switch (this.direction) {\r\n      case \"down\":\r\n        this.y--;\r\n        break;\r\n      case \"left\":\r\n        this.x++;\r\n        break;\r\n      case \"right\":\r\n        this.x--;\r\n        break;\r\n      case \"up\":\r\n        this.y++;\r\n        break;\r\n    }\r\n    return this;\r\n  }\r\n\r\n  stepForward() {\r\n    switch (this.direction) {\r\n      case \"down\":\r\n        this.y++;\r\n        break;\r\n      case \"left\":\r\n        this.x--;\r\n        break;\r\n      case \"right\":\r\n        this.x++;\r\n        break;\r\n      case \"up\":\r\n        this.y--;\r\n        break;\r\n    }\r\n    return this;\r\n  }\r\n}\r\n"],"names":["_DirectedPoint","Coordinates","__name","DirectedPoint"],"mappings":";;;AAGO,MAAMA,IAAN,MAAMA,UAAsBC,EAAY;AAAA,EAC7C,YAA0B;AAAA,EAE1B,IAAI,mBAAmB;AACrB,WAAO;AAAA,MACL,GAAG,KAAK;AAAA,MACR,GAAG,KAAK;AAAA,MACR,WAAW,KAAK;AAAA,IAAA;AAAA,EAEpB;AAAA,EAEA,WAAW;AACT,YAAQ,KAAK,WAAA;AAAA,MACX,KAAK;AACH,aAAK;AACL;AAAA,MACF,KAAK;AACH,aAAK;AACL;AAAA,MACF,KAAK;AACH,aAAK;AACL;AAAA,MACF,KAAK;AACH,aAAK;AACL;AAAA,IAAA;AAEJ,WAAO;AAAA,EACT;AAAA,EAEA,cAAc;AACZ,YAAQ,KAAK,WAAA;AAAA,MACX,KAAK;AACH,aAAK;AACL;AAAA,MACF,KAAK;AACH,aAAK;AACL;AAAA,MACF,KAAK;AACH,aAAK;AACL;AAAA,MACF,KAAK;AACH,aAAK;AACL;AAAA,IAAA;AAEJ,WAAO;AAAA,EACT;AACF;AA9C+CC,EAAAF,GAAA;AAAxC,IAAMG,IAANH;"}