@tumaet/apollon 4.9.0 → 5.0.0

package/dist/react/typings.d.ts

@@ -1,186 +0,0 @@
-import { DiagramEdgeType, IPoint } from './edges/types';
-import { DiagramNodeType } from './nodes/types';
-import { UMLDiagramType } from './types/DiagramType';
-import { Styles } from './styles/theme';
-export { UMLDiagramType, type DiagramNodeType, type DiagramEdgeType };
-export { type Styles };
-export type Unsubscriber = () => void;
-export type Subscribers = {
-    [key: number]: Unsubscriber;
-};
-export type UMLModelElementType = DiagramNodeType | DiagramEdgeType;
-export type CollaborationUser = {
-    name: string;
-    color: string;
-    id?: string;
-    imageUrl?: string;
-};
-export type CollaborationCursor = {
-    x: number;
-    y: number;
-};
-export type CollaborationViewport = {
-    x: number;
-    y: number;
-    zoom: number;
-};
-/**
- * One node a peer is actively dragging or resizing. Broadcast over the
- * ephemeral awareness channel — never written to the Yjs document — so peers
- * can render the in-progress gesture live without growing the CRDT or entering
- * anyone's undo history. The settled position/size is committed once on
- * drop/release through the document like any other edit.
- */
-export type DraggingNode = {
-    id: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    width?: number | null;
-    height?: number | null;
-};
-export type CollaborationState = {
-    user?: CollaborationUser;
-    cursor?: CollaborationCursor | null;
-    viewport?: CollaborationViewport | null;
-    followingClientId?: number | null;
-    selectedElementId?: string | null;
-    draggingNodes?: DraggingNode[] | null;
-};
-export type CollaboratorInfo = {
-    id: string;
-    name: string;
-    color: string;
-    imageUrl?: string;
-    clientIds: number[];
-    isLocal: boolean;
-};
-export type ApollonCollaborationOptions = {
-    enabled?: boolean;
-    user?: CollaborationUser;
-    showPresence?: boolean;
-    showCursors?: boolean;
-    showSelectionHighlights?: boolean;
-    showFollow?: boolean;
-};
-export declare enum Locale {
-    en = "en",
-    de = "de"
-}
-export declare enum ApollonMode {
-    Modelling = "Modelling",
-    Exporting = "Exporting",
-    Assessment = "Assessment"
-}
-export type ApollonNode = {
-    id: string;
-    width: number;
-    height: number;
-    type: DiagramNodeType;
-    position: {
-        x: number;
-        y: number;
-    };
-    data: {
-        [key: string]: unknown;
-    };
-    parentId?: string;
-    measured: {
-        width: number;
-        height: number;
-    };
-};
-export interface OrthogonalEdgeData {
-    [key: string]: unknown;
-    points: IPoint[];
-}
-export type ApollonEdge = {
-    id: string;
-    source: string;
-    target: string;
-    type: DiagramEdgeType;
-    sourceHandle: string;
-    targetHandle: string;
-    data: OrthogonalEdgeData;
-};
-export type InteractiveElements = {
-    elements: {
-        [id: string]: boolean;
-    };
-    relationships: {
-        [id: string]: boolean;
-    };
-};
-export type UMLModel = {
-    version: `4.${number}.${number}`;
-    id: string;
-    title: string;
-    type: UMLDiagramType;
-    nodes: ApollonNode[];
-    edges: ApollonEdge[];
-    assessments: {
-        [id: string]: Assessment;
-    };
-    interactive?: InteractiveElements;
-};
-export declare enum ApollonView {
-    Modelling = "Modelling",
-    Exporting = "Exporting",
-    Highlight = "Highlight"
-}
-export type SvgExportMode = "web" | "compat";
-export type ApollonOptions = {
-    type?: UMLDiagramType;
-    mode?: ApollonMode;
-    view?: ApollonView;
-    availableViews?: ApollonView[];
-    readonly?: boolean;
-    enablePopups?: boolean;
-    model?: UMLModel;
-    locale?: Locale;
-    debug?: boolean;
-    collaborationEnabled?: boolean;
-    collaboration?: ApollonCollaborationOptions;
-    scrollLock?: boolean;
-};
-export type FeedbackCorrectionStatus = {
-    description?: string;
-    status: "CORRECT" | "INCORRECT" | "NOT_VALIDATED";
-};
-export type Assessment = {
-    modelElementId: string;
-    elementType: string;
-    score: number;
-    feedback?: string;
-    dropInfo?: unknown;
-    label?: string;
-    labelColor?: string;
-    correctionStatus?: FeedbackCorrectionStatus;
-};
-export type ExportOptions = {
-    margin?: number | {
-        top?: number;
-        right?: number;
-        bottom?: number;
-        left?: number;
-    };
-    keepOriginalSize?: boolean;
-    include?: string[];
-    exclude?: string[];
-    /**
-     * Controls how SVG output is post-processed.
-     * - "web": keep CSS variables for theme-adaptive rendering in browsers
-     * - "compat": resolve CSS variables + inline attributes for PowerPoint/Inkscape
-     */
-    svgMode?: SvgExportMode;
-};
-export type SVG = {
-    svg: string;
-    clip: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-};

package/dist/react/utils/alignmentUtils.d.ts

@@ -1,32 +0,0 @@
-import { Node } from '@xyflow/react';
-import { AlignmentGuide } from '../store/alignmentGuidesStore';
-export type AlignmentInfo = {
-    horizontalGuides: number[];
-    verticalGuides: number[];
-    snappedPosition?: {
-        x?: number;
-        y?: number;
-    };
-};
-/**
- * Get the bounds of a node (considering its position and dimensions)
- */
-export declare const getNodeBounds: (node: Node, allNodes?: Node[]) => {
-    left: number;
-    right: number;
-    top: number;
-    bottom: number;
-    centerX: number;
-    centerY: number;
-};
-/**
- * Calculate alignment guides based on dragged node and other nodes
- */
-export declare const calculateAlignmentGuides: (draggedNode: Node, allNodes: Node[], threshold?: number) => AlignmentGuide[];
-/**
- * Snap node position to nearby nodes
- */
-export declare const snapNodeToGuides: (draggedNode: Node, guides: AlignmentGuide[], threshold?: number, allNodes?: Node[]) => {
-    x?: number;
-    y?: number;
-};

package/dist/react/utils/bpmnConstraints.d.ts

@@ -1,5 +0,0 @@
-/**
- * Determines if a node type can be dropped into a parent node type
- * based on BPMN rules and constraints
- */
-export declare const canDropIntoParent: (childType: string, parentType: string) => boolean;

package/dist/react/utils/collaboration.d.ts

@@ -1,19 +0,0 @@
-import { CollaborationViewport, DraggingNode } from '../typings';
-export declare const randomCollabName: () => string;
-export declare const collabColorFromName: (name: string) => string;
-/**
- * Narrow an untrusted, peer-supplied viewport before it reaches React Flow's
- * `setViewport`. A `NaN`/`Infinity`/non-positive zoom corrupts the canvas
- * transform, so every field must be a finite number and zoom must be positive.
- * Returns `null` for anything malformed.
- */
-export declare const sanitizeCollaborationViewport: (raw: unknown) => CollaborationViewport | null;
-/**
- * Narrow an untrusted, peer-supplied `draggingNodes` payload before the overlay
- * reader iterates it. A non-array value (or entries missing a string `id` or a
- * finite numeric position) would otherwise throw in the awareness subscription
- * handler and break the live overlay for everyone reading that peer. Returns the
- * well-formed entries only; `null` if the value isn't an array. Per-entry
- * `width`/`height` survive only when finite or explicitly `null`.
- */
-export declare const sanitizeDraggingNodes: (raw: unknown) => DraggingNode[] | null;

package/dist/react/utils/copyPasteUtils.d.ts

@@ -1,32 +0,0 @@
-import { Node, Edge } from '@xyflow/react';
-export interface ClipboardData {
-    nodes: Node[];
-    edges: Edge[];
-    parentChildRelations: Array<{
-        parentId: string;
-        childId: string;
-        relativePosition: {
-            x: number;
-            y: number;
-        };
-    }>;
-    timestamp: number;
-}
-export declare const calculateRelativePosition: (childNode: Node, parentNode: Node) => {
-    x: number;
-    y: number;
-};
-export declare const getAllDescendants: (nodeIds: string[], allNodes: Node[]) => Node[];
-export declare const getAllNodesToInclude: (selectedElementIds: string[], allNodes: Node[]) => Node[];
-export declare const getRelevantEdges: (selectedElementIds: string[], allEdges: Edge[]) => Edge[];
-export declare const buildParentChildRelations: (nodesToInclude: Node[], nodeIds: string[]) => {
-    parentId: string;
-    childId: string;
-    relativePosition: {
-        x: number;
-        y: number;
-    };
-}[];
-export declare const getEdgesToRemove: (selectedElementIds: string[], expandedNodeIds: string[], allEdges: Edge[]) => Set<string>;
-export declare const createClipboardData: (selectedElementIds: string[], allNodes: Node[], allEdges: Edge[]) => ClipboardData;
-export declare const createNewNodeDataWithNewIds: (originalNodeData: any) => any;

package/dist/react/utils/deepPartial.d.ts

@@ -1,3 +0,0 @@
-export type DeepPartial<T> = {
-    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
-};

package/dist/react/utils/diagramTypeUtils.d.ts

@@ -1,6 +0,0 @@
-import { UMLDiagramType } from '../types';
-import { ApollonEdge, ApollonNode } from '../typings';
-import { Node, Edge } from '@xyflow/react';
-export declare const parseDiagramType: (value: unknown, fallback?: UMLDiagramType) => UMLDiagramType;
-export declare const mapFromReactFlowNodeToApollonNode: (node: Node) => ApollonNode;
-export declare const mapFromReactFlowEdgeToApollonEdge: (edge: Edge) => ApollonEdge;

package/dist/react/utils/edgeUtils.d.ts

@@ -1,167 +0,0 @@
-import { IPoint } from '../edges/Connection';
-import { DiagramEdgeType, UMLDiagramType } from '../typings';
-import { Position, Rect, XYPosition, ConnectionLineType } from '@xyflow/react';
-/**
- * Adjusts the target coordinates based on the position and marker padding.
- */
-export declare const adjustTargetCoordinates: (targetX: number, targetY: number, targetPosition: Position, markerPadding: number) => {
-    targetX: number;
-    targetY: number;
-};
-/**
- * Adjusts the source coordinates based on the position and marker padding.
- */
-export declare const adjustSourceCoordinates: (sourceX: number, sourceY: number, sourcePosition: Position, sourcePadding: number) => {
-    sourceX: number;
-    sourceY: number;
-};
-export declare const calculateDynamicEdgeLabels: (x: number, y: number, direction: string) => {
-    roleX: number;
-    roleY: number;
-    roleTextAnchor: "end";
-    multiplicityX: number;
-    multiplicityY: number;
-    multiplicityTextAnchor: "start";
-} | {
-    roleX: number;
-    roleY: number;
-    roleTextAnchor: "end";
-    multiplicityX: number;
-    multiplicityY: number;
-    multiplicityTextAnchor: "end";
-} | {
-    roleX: number;
-    roleY: number;
-    roleTextAnchor: "start";
-    multiplicityX: number;
-    multiplicityY: number;
-    multiplicityTextAnchor: "start";
-} | {
-    roleX: number;
-    roleY: number;
-    roleTextAnchor: "middle";
-    multiplicityX: number;
-    multiplicityY: number;
-    multiplicityTextAnchor: "middle";
-};
-export interface EdgeMarkerStyles {
-    markerEnd?: string;
-    markerStart?: string;
-    markerPadding?: number;
-    strokeDashArray?: string;
-    offset?: number;
-}
-export declare function getEdgeMarkerStyles(edgeType: string): EdgeMarkerStyles;
-interface FindClosestHandleParams {
-    point: XYPosition;
-    rect: Rect;
-    useFourHandles?: boolean;
-}
-export declare function getNormalizedHandleOffset(axisLength: number, ratio: number): number;
-export declare function getNormalizedHandleOffsetPercent(axisLength: number, ratio: number): string;
-export type AxisHandlePlan = {
-    offsets: [
-        number,
-        number,
-        number,
-        number,
-        number,
-        number,
-        number,
-        number,
-        number
-    ];
-    visibleArcCount: 1 | 3 | 5;
-};
-export declare function getAxisHandlePlan(axisLength: number): AxisHandlePlan;
-/**
- * Reduce how many arcs a side actually shows so adjacent visible arcs never
- * overlap ON SCREEN. The slot offsets stay fixed (handles don't move); we just
- * hide arcs when, at the current zoom, two neighbours would be closer than an
- * arc's on-screen length apart. Arcs counter-scale to a constant on-screen size
- * when zoomed out and grow when zoomed in, so the required flow spacing is
- * ARC_LENGTH_PX / min(zoom, 1): bigger (fewer arcs) when zoomed out, constant
- * at and above 1x.
- *
- * Returns 5, 3, or 1 — always <= the size-based `baseVisibleArcCount`.
- */
-export declare function reduceVisibleArcCountForZoom(offsets: AxisHandlePlan["offsets"], baseVisibleArcCount: 1 | 3 | 5, zoom: number): 1 | 3 | 5;
-export declare function getDistributedHandleOffsets(axisLength: number): number[];
-export declare function getDistributedHandleOffsetPercents(axisLength: number): [string, string, string, string, string, string, string, string, string];
-type HandleSide = "top" | "right" | "bottom" | "left";
-export declare function getHandleIdForSideSlot(side: HandleSide, slotIndex: number, slotCount: number): string;
-export declare function findClosestHandle({ point, rect, useFourHandles, }: FindClosestHandleParams): string;
-/**
- * Helper function to get handle position on ellipse perimeter
- */
-export declare function getEllipseHandlePosition(centerX: number, centerY: number, radiusX: number, radiusY: number, handle: string): {
-    x: number;
-    y: number;
-};
-export type Orientation = "horizontal" | "vertical";
-export type AxisAlignedSegment = {
-    index: number;
-    start: IPoint;
-    end: IPoint;
-    orientation: Orientation;
-    fixed: number;
-    min: number;
-    max: number;
-};
-export declare function getAxisAlignedSegments(points: IPoint[], tolerance?: number): AxisAlignedSegment[];
-export type LineJumpHit = {
-    segmentIndex: number;
-    point: IPoint;
-    orientation: Orientation;
-};
-export declare function findLineJumpIntersections(baseSegments: AxisAlignedSegment[], otherSegments: AxisAlignedSegment[], jumpWidth: number, preferredOrientation?: Orientation | "any", tolerance?: number): LineJumpHit[];
-export declare function buildPathWithLineJumps(points: IPoint[], jumps: LineJumpHit[], jumpHeight: number, jumpWidth?: number): string;
-/**
- * Collects the crossings an edge should bridge over. Uses the layout-stable
- * "horizontal hops vertical" convention (yEd / yFiles' `BridgeManager` default
- * `HORIZONTAL_BRIDGES_VERTICAL`): the bridge is always drawn on the HORIZONTAL
- * segment of a crossing. Consequences that make this the right default for a
- * declarative editor:
- *  - exactly one edge of any H×V pair hops (the horizontal one),
- *  - the assignment is independent of edge array order / z-index, so it never
- *    flips when an edge is selected (React Flow's `elevateEdgesOnSelect`) or
- *    reordered — unlike a render-order rule.
- * Diagonal segments yield no axis-aligned segments, so they neither hop nor are
- * hopped (line jumps are orthogonal-only, matching mxGraph/ELK/yFiles).
- *
- * @param geometryMap each OTHER edge's actual rendered polyline, keyed by id
- *   (from the edge-geometry registry)
- */
-export declare function computeLineJumpsForEdge(edgeId: string, basePoints: IPoint[], edges: ReadonlyArray<{
-    id: string;
-}>, geometryMap: ReadonlyMap<string, IPoint[]>): LineJumpHit[];
-export declare function calculateOverlayPath(sourceX: number, sourceY: number, targetX: number, targetY: number, type: string): string;
-export declare function calculateStraightPath(sourceX: number, sourceY: number, targetX: number, targetY: number, type: string): string;
-export declare function simplifySvgPath(path: string): string;
-export declare function simplifyPoints(points: IPoint[]): IPoint[];
-export declare function parseSvgPath(path: string): IPoint[];
-export declare function removeDuplicatePoints(points: IPoint[]): IPoint[];
-export declare function resolveReconnectPreviewBasePoints(storedPoints: IPoint[] | undefined, localPoints: IPoint[] | undefined, fallbackPoints: IPoint[]): IPoint[];
-/**
- * Returns true when source and target stubs point toward each other and would
- * overlap or leave no room between them. This catches the "narrow U" case —
- * where the two arms of a U-shape almost touch — before the geometry has
- * actually inverted (which hasCollapsingSegments catches too late).
- *
- * Only applies to facing-stub configurations where both stubs exit into the
- * same space and can collide. Diverging pairs are handled by later validation.
- */
-export declare const stubsWouldOverlap: (sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position, stubLength: number) => boolean;
-export declare function isInvalidOrthogonalEdgeRelease(points: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): boolean;
-export declare function normalizeOrthogonalEdgePoints(points: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): IPoint[];
-export declare function resolveOrthogonalEdgeReleasePoints(releasedPoints: IPoint[], lastValidPoints: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): IPoint[];
-export declare function preserveOrthogonalEdgePoints(points: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): IPoint[];
-export declare function getMarkerSegmentPath(points: IPoint[], offset: number, targetPosition: "top" | "bottom" | "left" | "right"): string;
-export declare const getDefaultEdgeType: (diagramType: UMLDiagramType) => DiagramEdgeType;
-/**
- * Determines the appropriate connection line type based on the diagram type
- * @param diagramType - The type of diagram being rendered
- * @returns The corresponding ConnectionLineType
- */
-export declare function getConnectionLineType(diagramType: UMLDiagramType): ConnectionLineType;
-export {};

package/dist/react/utils/exportFonts.d.ts

@@ -1,11 +0,0 @@
-/**
- * Inter `@font-face` (base64 woff2) for self-contained `compat`-mode SVG
- * exports, so the file renders in Inter when opened away from the editor
- * (browser, Inkscape, PowerPoint). The woff2 is the same file `fonts.css`
- * bundles. resvg does not resolve data-URI `@font-face` (resvg#541) — pass the
- * font via its `fontFiles` instead; the embedded face is harmlessly ignored.
- *
- * Data-only and loaded lazily (dynamic `import()` in `exportModelAsSvg`) so the
- * woff2 lands in its own chunk instead of the main bundle.
- */
-export declare const INTER_FONT_FACE_CSS: string;

package/dist/react/utils/exportStyles.d.ts

@@ -1,30 +0,0 @@
-/**
- * Layout CSS the off-screen export mount needs to be self-contained, so a
- * consumer rendering headlessly never has to import `@tumaet/apollon/style.css`
- * for the export to be correct.
- *
- * The load-bearing rule is React Flow's `base.css` `.react-flow__node {
- * position: absolute }`: Apollon positions each connection `<Handle>` with an
- * inline `left/top: "X%"` (see `DefaultNodeWrapper`), and a percentage offset
- * resolves against the nearest *positioned* ancestor. React Flow sets the
- * node's transform/size inline but not `position` — that comes only from
- * `base.css`. Without it `.react-flow__node` is `position: static`, the handle
- * `%` offsets resolve against the wrong box, React Flow's on-mount
- * `getBoundingClientRect` handle measurement is wrong, and edges route through
- * the node boxes (the symptom reported for browser/Playwright exports). The
- * same `base.css` also positions `.react-flow__viewport/.react-flow__edges`,
- * which the `getBoundingClientRect`-based bounds math in `exportUtils` relies on.
- *
- * `app.css` adds `.apollon-canvas { flex: 1; ... }` so the canvas fills the
- * 4000×4000 mount container.
- *
- * WARNING: `app.css` is inlined verbatim into this lazy chunk. It must stay
- * free of `@font-face`, `url(...)`, and `@import`, or those assets leak into
- * this chunk (the Inter font is shipped separately, see `exportFonts.ts`).
- *
- * Reached only via a dynamic `import()` in `exportModelAsSvg`, so Rollup emits
- * it as its own chunk and these ~26 KB of CSS-as-string stay out of the main
- * bundle (mirrors the `exportFonts.ts` pattern). The chunk is emitted per build
- * entry (`dist/` and `dist/react/`).
- */
-export declare const EXPORT_LAYOUT_CSS: string;

package/dist/react/utils/exportUtils.d.ts

@@ -1,11 +0,0 @@
-import { ReactFlowInstance, Node, Edge, Rect } from '@xyflow/react';
-type SvgExportMode = "web" | "compat";
-type ExportFilterOptions = {
-    include?: string[];
-    exclude?: string[];
-    svgMode?: SvgExportMode;
-};
-export declare function filterRenderedElements(container: HTMLElement, options?: ExportFilterOptions): void;
-export declare const getSVG: (container: HTMLElement, clip: Rect, options?: ExportFilterOptions, fontFaceCss?: string) => string;
-export declare function getRenderedDiagramBounds(reactFlow: ReactFlowInstance<Node, Edge>, container: HTMLElement): Rect;
-export {};

package/dist/react/utils/geometry/bendHandles.d.ts

@@ -1,42 +0,0 @@
-import { Position } from '@xyflow/react';
-import { IPoint } from '../../edges/Connection';
-export declare function collapseCollinearPoints(points: IPoint[]): IPoint[];
-export type SegmentKind = "source-terminal" | "target-terminal" | "inner";
-export interface BendHandle {
-    segmentIndex: number;
-    position: IPoint;
-    orientation: "H" | "V";
-    kind: SegmentKind;
-}
-export declare function hasArmCollapse(points: IPoint[], proximityPx: number): boolean;
-export declare function getSegmentOrientation(points: IPoint[], segmentIndex: number): "H" | "V";
-export declare function getSegmentKind(segmentIndex: number, totalPoints: number): SegmentKind;
-export declare function getSegmentEffectiveLength(points: IPoint[], segmentIndex: number, stubLength: number): number;
-/**
- * Whether a flow-space length is long enough to host an interactive handle,
- * judged by its ON-SCREEN size. Screen-based so the rule matches what the user
- * sees: zooming in always reveals more handles (a short segment becomes
- * editable once it is `minScreenLength` px long on screen) and never hides
- * them. `minScreenLength` is a screen-px budget (handle size + clearance).
- */
-export declare function isLengthEditableAtZoom(canvasLength: number, minScreenLength: number, zoom: number): boolean;
-export declare function getStubExit(nodePoint: IPoint, position: Position, stubLength: number): IPoint;
-export declare function getBendHandlePosition(points: IPoint[], segmentIndex: number): IPoint;
-/**
- * Bend handles for every segment with enough ON-SCREEN room to host one.
- *
- * The "safe area" next to each node (`safeAreaPx`) is excluded: a terminal
- * segment loses that length at its node end, both for deciding whether a handle
- * fits AND for where the handle sits. The handle is placed at the midpoint of
- * the *bendable* region (past the safe area), never inside the locked stub —
- * so dragging always grabs a real, bendable slice instead of a detached sliver
- * hugging the node.
- *
- * Availability is judged on the bendable region's ON-SCREEN length
- * (bendable * zoom >= `minSegmentScreenLength`), so zooming in reveals handles
- * on shorter segments and never hides them.
- */
-export declare function getBendableSegments(points: IPoint[], _sourcePosition: Position, _targetPosition: Position, safeAreaPx: number, minSegmentScreenLength: number, zoom?: number): BendHandle[];
-export declare function applyInnerSegmentBend(points: IPoint[], segmentIndex: number, delta: IPoint, snapGrid: number): IPoint[];
-export declare function computeToolbarPosition(pathMiddlePosition: IPoint, isMiddlePathHorizontal: boolean): IPoint;
-export declare function applyTerminalSegmentBend(points: IPoint[], handle: BendHandle, delta: IPoint, sourcePosition: Position, targetPosition: Position, stubLength: number, snapGrid: number): IPoint[];