@statelyai/layout 0.0.1 → 0.0.2

package/src/layered/elk-enum-values.ts

@@ -0,0 +1,171 @@
+import type { ElkLayeredOptionName } from "./elk-options.generated";
+
+/** Every ELK 0.11.1 enum constant, source-locked to its Java declaration. */
+export const elkLayeredEnumValues = {
+  "wrapping.strategy": ["OFF", "SINGLE_EDGE", "MULTI_EDGE"],
+  "wrapping.cutting.strategy": ["ARD", "MSD", "MANUAL"],
+  "wrapping.validify.strategy": ["NO", "GREEDY", "LOOK_BACK"],
+  "layerUnzipping.strategy": ["NONE", "ALTERNATING"],
+  "nodePlacement.networkSimplex.nodeFlexibility": [
+    "NONE",
+    "PORT_POSITION",
+    "NODE_SIZE_WHERE_SPACE_PERMITS",
+    "NODE_SIZE",
+  ],
+  "nodePlacement.networkSimplex.nodeFlexibility.default": [
+    "NONE",
+    "PORT_POSITION",
+    "NODE_SIZE_WHERE_SPACE_PERMITS",
+    "NODE_SIZE",
+  ],
+  "edgeRouting.splines.mode": ["CONSERVATIVE", "CONSERVATIVE_SOFT", "SLOPPY"],
+  "topdown.nodeType": ["PARALLEL_NODE", "HIERARCHICAL_NODE", "ROOT_NODE"],
+  edgeRouting: ["UNDEFINED", "POLYLINE", "ORTHOGONAL", "SPLINES"],
+  portConstraints: ["UNDEFINED", "FREE", "FIXED_SIDE", "FIXED_ORDER", "FIXED_RATIO", "FIXED_POS"],
+  "port.side": ["UNDEFINED", "NORTH", "EAST", "SOUTH", "WEST"],
+  alignment: ["AUTOMATIC", "LEFT", "RIGHT", "TOP", "BOTTOM", "CENTER"],
+  hierarchyHandling: ["INHERIT", "INCLUDE_CHILDREN", "SEPARATE_CHILDREN"],
+  "nodeSize.constraints": ["PORTS", "PORT_LABELS", "NODE_LABELS", "MINIMUM_SIZE"],
+  "nodeSize.options": [
+    "DEFAULT_MINIMUM_SIZE",
+    "MINIMUM_SIZE_ACCOUNTS_FOR_PADDING",
+    "COMPUTE_PADDING",
+    "OUTSIDE_NODE_LABELS_OVERHANG",
+    "PORTS_OVERHANG",
+    "UNIFORM_PORT_SPACING",
+    "SPACE_EFFICIENT_PORT_LABELS",
+    "FORCE_TABULAR_NODE_LABELS",
+    "ASYMMETRICAL",
+  ],
+  direction: ["UNDEFINED", "RIGHT", "LEFT", "DOWN", "UP"],
+  "nodeLabels.placement": [
+    "H_LEFT",
+    "H_CENTER",
+    "H_RIGHT",
+    "V_TOP",
+    "V_CENTER",
+    "V_BOTTOM",
+    "INSIDE",
+    "OUTSIDE",
+    "H_PRIORITY",
+  ],
+  "portLabels.placement": [
+    "OUTSIDE",
+    "INSIDE",
+    "NEXT_TO_PORT_IF_POSSIBLE",
+    "ALWAYS_SAME_SIDE",
+    "ALWAYS_OTHER_SAME_SIDE",
+    "SPACE_EFFICIENT",
+  ],
+  "portAlignment.default": ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"],
+  "portAlignment.north": ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"],
+  "portAlignment.south": ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"],
+  "portAlignment.west": ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"],
+  "portAlignment.east": ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"],
+  "layering.strategy": [
+    "NETWORK_SIMPLEX",
+    "LONGEST_PATH",
+    "LONGEST_PATH_SOURCE",
+    "COFFMAN_GRAHAM",
+    "INTERACTIVE",
+    "STRETCH_WIDTH",
+    "MIN_WIDTH",
+    "BF_MODEL_ORDER",
+    "DF_MODEL_ORDER",
+  ],
+  "layering.nodePromotion.strategy": [
+    "NONE",
+    "NIKOLOV",
+    "NIKOLOV_PIXEL",
+    "NIKOLOV_IMPROVED",
+    "NIKOLOV_IMPROVED_PIXEL",
+    "DUMMYNODE_PERCENTAGE",
+    "NODECOUNT_PERCENTAGE",
+    "NO_BOUNDARY",
+    "MODEL_ORDER_LEFT_TO_RIGHT",
+    "MODEL_ORDER_RIGHT_TO_LEFT",
+  ],
+  "layering.layerConstraint": ["NONE", "FIRST", "FIRST_SEPARATE", "LAST", "LAST_SEPARATE"],
+  "cycleBreaking.strategy": [
+    "GREEDY",
+    "DEPTH_FIRST",
+    "INTERACTIVE",
+    "MODEL_ORDER",
+    "GREEDY_MODEL_ORDER",
+    "SCC_CONNECTIVITY",
+    "SCC_NODE_TYPE",
+    "DFS_NODE_ORDER",
+    "BFS_NODE_ORDER",
+  ],
+  "crossingMinimization.strategy": ["LAYER_SWEEP", "MEDIAN_LAYER_SWEEP", "INTERACTIVE", "NONE"],
+  "crossingMinimization.greedySwitch.type": ["ONE_SIDED", "TWO_SIDED", "OFF"],
+  "crossingMinimization.greedySwitchHierarchical.type": ["ONE_SIDED", "TWO_SIDED", "OFF"],
+  interactiveReferencePoint: ["CENTER", "TOP_LEFT"],
+  "nodePlacement.strategy": [
+    "SIMPLE",
+    "INTERACTIVE",
+    "LINEAR_SEGMENTS",
+    "BRANDES_KOEPF",
+    "NETWORK_SIMPLEX",
+  ],
+  "nodePlacement.bk.fixedAlignment": [
+    "NONE",
+    "LEFTUP",
+    "RIGHTUP",
+    "LEFTDOWN",
+    "RIGHTDOWN",
+    "BALANCED",
+  ],
+  "edgeRouting.selfLoopDistribution": ["EQUALLY", "NORTH", "NORTH_SOUTH"],
+  "edgeRouting.selfLoopOrdering": ["STACKED", "REVERSE_STACKED", "SEQUENCED"],
+  contentAlignment: ["V_TOP", "V_CENTER", "V_BOTTOM", "H_LEFT", "H_CENTER", "H_RIGHT"],
+  "nodePlacement.bk.edgeStraightening": ["NONE", "IMPROVE_STRAIGHTNESS"],
+  "compaction.postCompaction.strategy": [
+    "NONE",
+    "LEFT",
+    "RIGHT",
+    "LEFT_RIGHT_CONSTRAINT_LOCKING",
+    "LEFT_RIGHT_CONNECTION_LOCKING",
+    "EDGE_LENGTH",
+  ],
+  "compaction.postCompaction.constraints": ["QUADRATIC", "SCANLINE"],
+  "edgeLabels.placement": ["CENTER", "HEAD", "TAIL"],
+  "edgeLabels.sideSelection": [
+    "ALWAYS_UP",
+    "ALWAYS_DOWN",
+    "DIRECTION_UP",
+    "DIRECTION_DOWN",
+    "SMART_UP",
+    "SMART_DOWN",
+  ],
+  "edgeLabels.centerLabelPlacementStrategy": [
+    "MEDIAN_LAYER",
+    "TAIL_LAYER",
+    "HEAD_LAYER",
+    "SPACE_EFFICIENT_LAYER",
+    "WIDEST_LAYER",
+    "CENTER_LAYER",
+  ],
+  directionCongruency: ["READING_DIRECTION", "ROTATION"],
+  portSortingStrategy: ["INPUT_ORDER", "PORT_DEGREE"],
+  "considerModelOrder.strategy": ["NONE", "NODES_AND_EDGES", "PREFER_EDGES", "PREFER_NODES"],
+  "considerModelOrder.longEdgeStrategy": ["DUMMY_NODE_OVER", "DUMMY_NODE_UNDER", "EQUAL"],
+  "considerModelOrder.components": [
+    "NONE",
+    "INSIDE_PORT_SIDE_GROUPS",
+    "GROUP_MODEL_ORDER",
+    "MODEL_ORDER",
+  ],
+  "considerModelOrder.groupModelOrder.cbGroupOrderStrategy": [
+    "ONLY_WITHIN_GROUP",
+    "MODEL_ORDER",
+    "ENFORCED",
+  ],
+  "considerModelOrder.groupModelOrder.cmGroupOrderStrategy": [
+    "ONLY_WITHIN_GROUP",
+    "MODEL_ORDER",
+    "ENFORCED",
+  ],
+} as const satisfies Partial<Record<ElkLayeredOptionName, readonly string[]>>;
+
+export type ElkLayeredEnumOptionName = keyof typeof elkLayeredEnumValues;

package/src/layered/elk-options.generated.ts

@@ -0,0 +1,315 @@
+// Generated by scripts/generate-elk-layered-options.ts from elkjs 0.11.1.
+// Do not edit manually.
+
+export interface ElkLayeredOptionValueByName {
+  "spacing.commentComment"?: number;
+  "spacing.commentNode"?: number;
+  "spacing.componentComponent"?: number;
+  "spacing.edgeEdge"?: number;
+  "spacing.edgeLabel"?: number;
+  "spacing.edgeNode"?: number;
+  "spacing.labelLabel"?: number;
+  "spacing.labelPortHorizontal"?: number;
+  "spacing.labelPortVertical"?: number;
+  "spacing.labelNode"?: number;
+  "spacing.node"?: number;
+  "spacing.nodeSelfLoop"?: number;
+  "spacing.portPort"?: number;
+  "spacing.individual"?: unknown;
+  "spacing.baseValue"?: number;
+  "spacing.edgeEdgeBetweenLayers"?: number;
+  "spacing.edgeNodeBetweenLayers"?: number;
+  "spacing.layer"?: number;
+  "priority"?: number;
+  "priority.direction"?: number;
+  "priority.shortness"?: number;
+  "priority.straightness"?: number;
+  "wrapping.strategy"?: string;
+  "wrapping.additionalEdgeSpacing"?: number;
+  "wrapping.correctionFactor"?: number;
+  "wrapping.cutting.strategy"?: string;
+  "wrapping.cutting.cuts"?: unknown;
+  "wrapping.cutting.msd.freedom"?: number;
+  "wrapping.validify.strategy"?: string;
+  "wrapping.validify.forbiddenIndices"?: unknown;
+  "wrapping.multiEdge.improveCuts"?: boolean;
+  "wrapping.multiEdge.distancePenalty"?: number;
+  "wrapping.multiEdge.improveWrappedEdges"?: boolean;
+  "layerUnzipping.strategy"?: string;
+  "layerUnzipping.minimizeEdgeLength"?: boolean;
+  "layerUnzipping.layerSplit"?: number;
+  "layerUnzipping.resetOnLongEdges"?: boolean;
+  "nodePlacement.networkSimplex.nodeFlexibility"?: string;
+  "nodePlacement.networkSimplex.nodeFlexibility.default"?: string;
+  "edgeRouting.splines.mode"?: string;
+  "edgeRouting.splines.sloppy.layerSpacingFactor"?: number;
+  "topdownLayout"?: boolean;
+  "topdown.scaleFactor"?: number;
+  "topdown.hierarchicalNodeWidth"?: number;
+  "topdown.hierarchicalNodeAspectRatio"?: number;
+  "topdown.nodeType"?: string;
+  "padding"?: unknown;
+  "edgeRouting"?: string;
+  "port.borderOffset"?: number;
+  "randomSeed"?: number;
+  "aspectRatio"?: number;
+  "noLayout"?: boolean;
+  "portConstraints"?: string;
+  "port.side"?: string;
+  "debugMode"?: boolean;
+  "alignment"?: string;
+  "hierarchyHandling"?: string;
+  "separateConnectedComponents"?: boolean;
+  "insideSelfLoops.activate"?: boolean;
+  "insideSelfLoops.yo"?: boolean;
+  "nodeSize.constraints"?: string;
+  "nodeSize.options"?: string;
+  "nodeSize.fixedGraphSize"?: boolean;
+  "direction"?: string;
+  "nodeLabels.placement"?: string;
+  "nodeLabels.padding"?: unknown;
+  "portLabels.placement"?: string;
+  "portLabels.nextToPortIfPossible"?: boolean;
+  "portLabels.treatAsGroup"?: boolean;
+  "portAlignment.default"?: string;
+  "portAlignment.north"?: string;
+  "portAlignment.south"?: string;
+  "portAlignment.west"?: string;
+  "portAlignment.east"?: string;
+  "unnecessaryBendpoints"?: boolean;
+  "layering.strategy"?: string;
+  "layering.nodePromotion.strategy"?: string;
+  "thoroughness"?: number;
+  "layering.layerConstraint"?: string;
+  "cycleBreaking.strategy"?: string;
+  "crossingMinimization.strategy"?: string;
+  "crossingMinimization.forceNodeModelOrder"?: boolean;
+  "crossingMinimization.greedySwitch.activationThreshold"?: number;
+  "crossingMinimization.greedySwitch.type"?: string;
+  "crossingMinimization.greedySwitchHierarchical.type"?: string;
+  "crossingMinimization.semiInteractive"?: boolean;
+  "mergeEdges"?: boolean;
+  "mergeHierarchyEdges"?: boolean;
+  "interactiveReferencePoint"?: string;
+  "nodePlacement.strategy"?: string;
+  "nodePlacement.bk.fixedAlignment"?: string;
+  "feedbackEdges"?: boolean;
+  "nodePlacement.linearSegments.deflectionDampening"?: number;
+  "edgeRouting.selfLoopDistribution"?: string;
+  "edgeRouting.selfLoopOrdering"?: string;
+  "contentAlignment"?: string;
+  "nodePlacement.bk.edgeStraightening"?: string;
+  "compaction.postCompaction.strategy"?: string;
+  "compaction.postCompaction.constraints"?: string;
+  "compaction.connectedComponents"?: boolean;
+  "highDegreeNodes.treatment"?: boolean;
+  "highDegreeNodes.threshold"?: number;
+  "highDegreeNodes.treeHeight"?: number;
+  "nodeSize.minimum"?: unknown;
+  "junctionPoints"?: unknown;
+  "edge.thickness"?: number;
+  "edgeLabels.placement"?: string;
+  "edgeLabels.inline"?: boolean;
+  "crossingMinimization.hierarchicalSweepiness"?: number;
+  "port.index"?: number;
+  "commentBox"?: boolean;
+  "hypernode"?: boolean;
+  "port.anchor"?: unknown;
+  "partitioning.activate"?: boolean;
+  "partitioning.partition"?: number;
+  "layering.minWidth.upperBoundOnWidth"?: number;
+  "layering.minWidth.upperLayerEstimationScalingFactor"?: number;
+  "position"?: unknown;
+  "allowNonFlowPortsToSwitchSides"?: boolean;
+  "layering.nodePromotion.maxIterations"?: number;
+  "edgeLabels.sideSelection"?: string;
+  "edgeLabels.centerLabelPlacementStrategy"?: string;
+  "margins"?: unknown;
+  "layering.coffmanGraham.layerBound"?: number;
+  "nodePlacement.favorStraightEdges"?: boolean;
+  "spacing.portsSurrounding"?: unknown;
+  "directionCongruency"?: string;
+  "portSortingStrategy"?: string;
+  "edgeRouting.polyline.slopedEdgeZoneWidth"?: number;
+  "crossingMinimization.inLayerPredOf"?: string;
+  "crossingMinimization.inLayerSuccOf"?: string;
+  "layering.layerChoiceConstraint"?: number;
+  "crossingMinimization.positionChoiceConstraint"?: number;
+  "interactiveLayout"?: boolean;
+  "layering.layerId"?: number;
+  "crossingMinimization.positionId"?: number;
+  "considerModelOrder.strategy"?: string;
+  "considerModelOrder.longEdgeStrategy"?: string;
+  "considerModelOrder.crossingCounterNodeInfluence"?: number;
+  "considerModelOrder.crossingCounterPortInfluence"?: number;
+  "considerModelOrder.noModelOrder"?: boolean;
+  "considerModelOrder.components"?: string;
+  "considerModelOrder.portModelOrder"?: boolean;
+  "considerModelOrder.groupModelOrder.cycleBreakingId"?: number;
+  "considerModelOrder.groupModelOrder.crossingMinimizationId"?: number;
+  "considerModelOrder.groupModelOrder.componentGroupId"?: number;
+  "considerModelOrder.groupModelOrder.cbGroupOrderStrategy"?: string;
+  "considerModelOrder.groupModelOrder.cmGroupOrderStrategy"?: string;
+  "considerModelOrder.groupModelOrder.cmEnforcedGroupOrders"?: unknown;
+  "considerModelOrder.groupModelOrder.cbPreferredSourceId"?: number;
+  "considerModelOrder.groupModelOrder.cbPreferredTargetId"?: number;
+  "generatePositionAndLayerIds"?: boolean;
+}
+
+export const elkLayeredOptionDefinitions = [
+  { name: "spacing.commentComment", elkId: "org.eclipse.elk.spacing.commentComment", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.commentNode", elkId: "org.eclipse.elk.spacing.commentNode", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.componentComponent", elkId: "org.eclipse.elk.spacing.componentComponent", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.edgeEdge", elkId: "org.eclipse.elk.spacing.edgeEdge", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.edgeLabel", elkId: "org.eclipse.elk.spacing.edgeLabel", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.edgeNode", elkId: "org.eclipse.elk.spacing.edgeNode", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.labelLabel", elkId: "org.eclipse.elk.spacing.labelLabel", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.labelPortHorizontal", elkId: "org.eclipse.elk.spacing.labelPortHorizontal", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.labelPortVertical", elkId: "org.eclipse.elk.spacing.labelPortVertical", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.labelNode", elkId: "org.eclipse.elk.spacing.labelNode", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.node", elkId: "org.eclipse.elk.spacing.nodeNode", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.nodeSelfLoop", elkId: "org.eclipse.elk.spacing.nodeSelfLoop", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.portPort", elkId: "org.eclipse.elk.spacing.portPort", type: "DOUBLE", targets: ["PARENTS","NODES"] },
+  { name: "spacing.individual", elkId: "org.eclipse.elk.spacing.individual", type: "OBJECT", targets: ["NODES","EDGES","PORTS","LABELS"] },
+  { name: "spacing.baseValue", elkId: "org.eclipse.elk.layered.spacing.baseValue", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.edgeEdgeBetweenLayers", elkId: "org.eclipse.elk.layered.spacing.edgeEdgeBetweenLayers", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.edgeNodeBetweenLayers", elkId: "org.eclipse.elk.layered.spacing.edgeNodeBetweenLayers", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "spacing.layer", elkId: "org.eclipse.elk.layered.spacing.nodeNodeBetweenLayers", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "priority", elkId: "org.eclipse.elk.priority", type: "INT", targets: ["NODES","EDGES"] },
+  { name: "priority.direction", elkId: "org.eclipse.elk.layered.priority.direction", type: "INT", targets: ["EDGES"] },
+  { name: "priority.shortness", elkId: "org.eclipse.elk.layered.priority.shortness", type: "INT", targets: ["EDGES"] },
+  { name: "priority.straightness", elkId: "org.eclipse.elk.layered.priority.straightness", type: "INT", targets: ["EDGES"] },
+  { name: "wrapping.strategy", elkId: "org.eclipse.elk.layered.wrapping.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "wrapping.additionalEdgeSpacing", elkId: "org.eclipse.elk.layered.wrapping.additionalEdgeSpacing", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "wrapping.correctionFactor", elkId: "org.eclipse.elk.layered.wrapping.correctionFactor", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "wrapping.cutting.strategy", elkId: "org.eclipse.elk.layered.wrapping.cutting.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "wrapping.cutting.cuts", elkId: "org.eclipse.elk.layered.wrapping.cutting.cuts", type: "OBJECT", targets: ["PARENTS"] },
+  { name: "wrapping.cutting.msd.freedom", elkId: "org.eclipse.elk.layered.wrapping.cutting.msd.freedom", type: "INT", targets: ["PARENTS"] },
+  { name: "wrapping.validify.strategy", elkId: "org.eclipse.elk.layered.wrapping.validify.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "wrapping.validify.forbiddenIndices", elkId: "org.eclipse.elk.layered.wrapping.validify.forbiddenIndices", type: "OBJECT", targets: ["PARENTS"] },
+  { name: "wrapping.multiEdge.improveCuts", elkId: "org.eclipse.elk.layered.wrapping.multiEdge.improveCuts", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "wrapping.multiEdge.distancePenalty", elkId: "org.eclipse.elk.layered.wrapping.multiEdge.distancePenalty", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "wrapping.multiEdge.improveWrappedEdges", elkId: "org.eclipse.elk.layered.wrapping.multiEdge.improveWrappedEdges", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "layerUnzipping.strategy", elkId: "org.eclipse.elk.layered.layerUnzipping.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "layerUnzipping.minimizeEdgeLength", elkId: "org.eclipse.elk.layered.layerUnzipping.minimizeEdgeLength", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "layerUnzipping.layerSplit", elkId: "org.eclipse.elk.layered.layerUnzipping.layerSplit", type: "INT", targets: ["NODES"] },
+  { name: "layerUnzipping.resetOnLongEdges", elkId: "org.eclipse.elk.layered.layerUnzipping.resetOnLongEdges", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "nodePlacement.networkSimplex.nodeFlexibility", elkId: "org.eclipse.elk.layered.nodePlacement.networkSimplex.nodeFlexibility", type: "ENUM", targets: ["NODES"] },
+  { name: "nodePlacement.networkSimplex.nodeFlexibility.default", elkId: "org.eclipse.elk.layered.nodePlacement.networkSimplex.nodeFlexibility.default", type: "ENUM", targets: ["PARENTS"] },
+  { name: "edgeRouting.splines.mode", elkId: "org.eclipse.elk.layered.edgeRouting.splines.mode", type: "ENUM", targets: ["PARENTS"] },
+  { name: "edgeRouting.splines.sloppy.layerSpacingFactor", elkId: "org.eclipse.elk.layered.edgeRouting.splines.sloppy.layerSpacingFactor", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "topdownLayout", elkId: "org.eclipse.elk.topdownLayout", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "topdown.scaleFactor", elkId: "org.eclipse.elk.topdown.scaleFactor", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "topdown.hierarchicalNodeWidth", elkId: "org.eclipse.elk.topdown.hierarchicalNodeWidth", type: "DOUBLE", targets: ["PARENTS","NODES"] },
+  { name: "topdown.hierarchicalNodeAspectRatio", elkId: "org.eclipse.elk.topdown.hierarchicalNodeAspectRatio", type: "DOUBLE", targets: ["PARENTS","NODES"] },
+  { name: "topdown.nodeType", elkId: "org.eclipse.elk.topdown.nodeType", type: "ENUM", targets: ["NODES"] },
+  { name: "padding", elkId: "org.eclipse.elk.padding", type: "OBJECT", targets: ["PARENTS","NODES"] },
+  { name: "edgeRouting", elkId: "org.eclipse.elk.edgeRouting", type: "ENUM", targets: ["PARENTS"] },
+  { name: "port.borderOffset", elkId: "org.eclipse.elk.port.borderOffset", type: "DOUBLE", targets: ["PORTS"] },
+  { name: "randomSeed", elkId: "org.eclipse.elk.randomSeed", type: "INT", targets: ["PARENTS"] },
+  { name: "aspectRatio", elkId: "org.eclipse.elk.aspectRatio", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "noLayout", elkId: "org.eclipse.elk.noLayout", type: "BOOLEAN", targets: ["NODES","EDGES","PORTS","LABELS"] },
+  { name: "portConstraints", elkId: "org.eclipse.elk.portConstraints", type: "ENUM", targets: ["NODES"] },
+  { name: "port.side", elkId: "org.eclipse.elk.port.side", type: "ENUM", targets: ["PORTS"] },
+  { name: "debugMode", elkId: "org.eclipse.elk.debugMode", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "alignment", elkId: "org.eclipse.elk.alignment", type: "ENUM", targets: ["NODES"] },
+  { name: "hierarchyHandling", elkId: "org.eclipse.elk.hierarchyHandling", type: "ENUM", targets: ["PARENTS","NODES"] },
+  { name: "separateConnectedComponents", elkId: "org.eclipse.elk.separateConnectedComponents", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "insideSelfLoops.activate", elkId: "org.eclipse.elk.insideSelfLoops.activate", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "insideSelfLoops.yo", elkId: "org.eclipse.elk.insideSelfLoops.yo", type: "BOOLEAN", targets: ["EDGES"] },
+  { name: "nodeSize.constraints", elkId: "org.eclipse.elk.nodeSize.constraints", type: "ENUMSET", targets: ["NODES"] },
+  { name: "nodeSize.options", elkId: "org.eclipse.elk.nodeSize.options", type: "ENUMSET", targets: ["NODES"] },
+  { name: "nodeSize.fixedGraphSize", elkId: "org.eclipse.elk.nodeSize.fixedGraphSize", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "direction", elkId: "org.eclipse.elk.direction", type: "ENUM", targets: ["PARENTS"] },
+  { name: "nodeLabels.placement", elkId: "org.eclipse.elk.nodeLabels.placement", type: "ENUMSET", targets: ["NODES","LABELS"] },
+  { name: "nodeLabels.padding", elkId: "org.eclipse.elk.nodeLabels.padding", type: "OBJECT", targets: ["PARENTS"] },
+  { name: "portLabels.placement", elkId: "org.eclipse.elk.portLabels.placement", type: "ENUMSET", targets: ["NODES"] },
+  { name: "portLabels.nextToPortIfPossible", elkId: "org.eclipse.elk.portLabels.nextToPortIfPossible", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "portLabels.treatAsGroup", elkId: "org.eclipse.elk.portLabels.treatAsGroup", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "portAlignment.default", elkId: "org.eclipse.elk.portAlignment.default", type: "ENUM", targets: ["NODES"] },
+  { name: "portAlignment.north", elkId: "org.eclipse.elk.portAlignment.north", type: "ENUM", targets: ["NODES"] },
+  { name: "portAlignment.south", elkId: "org.eclipse.elk.portAlignment.south", type: "ENUM", targets: ["NODES"] },
+  { name: "portAlignment.west", elkId: "org.eclipse.elk.portAlignment.west", type: "ENUM", targets: ["NODES"] },
+  { name: "portAlignment.east", elkId: "org.eclipse.elk.portAlignment.east", type: "ENUM", targets: ["NODES"] },
+  { name: "unnecessaryBendpoints", elkId: "org.eclipse.elk.layered.unnecessaryBendpoints", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "layering.strategy", elkId: "org.eclipse.elk.layered.layering.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "layering.nodePromotion.strategy", elkId: "org.eclipse.elk.layered.layering.nodePromotion.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "thoroughness", elkId: "org.eclipse.elk.layered.thoroughness", type: "INT", targets: ["PARENTS"] },
+  { name: "layering.layerConstraint", elkId: "org.eclipse.elk.layered.layering.layerConstraint", type: "ENUM", targets: ["NODES"] },
+  { name: "cycleBreaking.strategy", elkId: "org.eclipse.elk.layered.cycleBreaking.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "crossingMinimization.strategy", elkId: "org.eclipse.elk.layered.crossingMinimization.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "crossingMinimization.forceNodeModelOrder", elkId: "org.eclipse.elk.layered.crossingMinimization.forceNodeModelOrder", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "crossingMinimization.greedySwitch.activationThreshold", elkId: "org.eclipse.elk.layered.crossingMinimization.greedySwitch.activationThreshold", type: "INT", targets: ["PARENTS"] },
+  { name: "crossingMinimization.greedySwitch.type", elkId: "org.eclipse.elk.layered.crossingMinimization.greedySwitch.type", type: "ENUM", targets: ["PARENTS"] },
+  { name: "crossingMinimization.greedySwitchHierarchical.type", elkId: "org.eclipse.elk.layered.crossingMinimization.greedySwitchHierarchical.type", type: "ENUM", targets: ["PARENTS"] },
+  { name: "crossingMinimization.semiInteractive", elkId: "org.eclipse.elk.layered.crossingMinimization.semiInteractive", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "mergeEdges", elkId: "org.eclipse.elk.layered.mergeEdges", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "mergeHierarchyEdges", elkId: "org.eclipse.elk.layered.mergeHierarchyEdges", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "interactiveReferencePoint", elkId: "org.eclipse.elk.layered.interactiveReferencePoint", type: "ENUM", targets: ["PARENTS"] },
+  { name: "nodePlacement.strategy", elkId: "org.eclipse.elk.layered.nodePlacement.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "nodePlacement.bk.fixedAlignment", elkId: "org.eclipse.elk.layered.nodePlacement.bk.fixedAlignment", type: "ENUM", targets: ["PARENTS"] },
+  { name: "feedbackEdges", elkId: "org.eclipse.elk.layered.feedbackEdges", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "nodePlacement.linearSegments.deflectionDampening", elkId: "org.eclipse.elk.layered.nodePlacement.linearSegments.deflectionDampening", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "edgeRouting.selfLoopDistribution", elkId: "org.eclipse.elk.layered.edgeRouting.selfLoopDistribution", type: "ENUM", targets: ["NODES"] },
+  { name: "edgeRouting.selfLoopOrdering", elkId: "org.eclipse.elk.layered.edgeRouting.selfLoopOrdering", type: "ENUM", targets: ["NODES"] },
+  { name: "contentAlignment", elkId: "org.eclipse.elk.contentAlignment", type: "ENUMSET", targets: ["PARENTS"] },
+  { name: "nodePlacement.bk.edgeStraightening", elkId: "org.eclipse.elk.layered.nodePlacement.bk.edgeStraightening", type: "ENUM", targets: ["PARENTS"] },
+  { name: "compaction.postCompaction.strategy", elkId: "org.eclipse.elk.layered.compaction.postCompaction.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "compaction.postCompaction.constraints", elkId: "org.eclipse.elk.layered.compaction.postCompaction.constraints", type: "ENUM", targets: ["PARENTS"] },
+  { name: "compaction.connectedComponents", elkId: "org.eclipse.elk.layered.compaction.connectedComponents", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "highDegreeNodes.treatment", elkId: "org.eclipse.elk.layered.highDegreeNodes.treatment", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "highDegreeNodes.threshold", elkId: "org.eclipse.elk.layered.highDegreeNodes.threshold", type: "INT", targets: ["PARENTS"] },
+  { name: "highDegreeNodes.treeHeight", elkId: "org.eclipse.elk.layered.highDegreeNodes.treeHeight", type: "INT", targets: ["PARENTS"] },
+  { name: "nodeSize.minimum", elkId: "org.eclipse.elk.nodeSize.minimum", type: "OBJECT", targets: ["NODES"] },
+  { name: "junctionPoints", elkId: "org.eclipse.elk.junctionPoints", type: "OBJECT", targets: ["EDGES"] },
+  { name: "edge.thickness", elkId: "org.eclipse.elk.edge.thickness", type: "DOUBLE", targets: ["EDGES"] },
+  { name: "edgeLabels.placement", elkId: "org.eclipse.elk.edgeLabels.placement", type: "ENUM", targets: ["LABELS"] },
+  { name: "edgeLabels.inline", elkId: "org.eclipse.elk.edgeLabels.inline", type: "BOOLEAN", targets: ["LABELS"] },
+  { name: "crossingMinimization.hierarchicalSweepiness", elkId: "org.eclipse.elk.layered.crossingMinimization.hierarchicalSweepiness", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "port.index", elkId: "org.eclipse.elk.port.index", type: "INT", targets: ["PORTS"] },
+  { name: "commentBox", elkId: "org.eclipse.elk.commentBox", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "hypernode", elkId: "org.eclipse.elk.hypernode", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "port.anchor", elkId: "org.eclipse.elk.port.anchor", type: "OBJECT", targets: ["PORTS"] },
+  { name: "partitioning.activate", elkId: "org.eclipse.elk.partitioning.activate", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "partitioning.partition", elkId: "org.eclipse.elk.partitioning.partition", type: "INT", targets: ["PARENTS","NODES"] },
+  { name: "layering.minWidth.upperBoundOnWidth", elkId: "org.eclipse.elk.layered.layering.minWidth.upperBoundOnWidth", type: "INT", targets: ["PARENTS"] },
+  { name: "layering.minWidth.upperLayerEstimationScalingFactor", elkId: "org.eclipse.elk.layered.layering.minWidth.upperLayerEstimationScalingFactor", type: "INT", targets: ["PARENTS"] },
+  { name: "position", elkId: "org.eclipse.elk.position", type: "OBJECT", targets: ["NODES","PORTS","LABELS"] },
+  { name: "allowNonFlowPortsToSwitchSides", elkId: "org.eclipse.elk.layered.allowNonFlowPortsToSwitchSides", type: "BOOLEAN", targets: ["PORTS"] },
+  { name: "layering.nodePromotion.maxIterations", elkId: "org.eclipse.elk.layered.layering.nodePromotion.maxIterations", type: "INT", targets: ["PARENTS"] },
+  { name: "edgeLabels.sideSelection", elkId: "org.eclipse.elk.layered.edgeLabels.sideSelection", type: "ENUM", targets: ["PARENTS"] },
+  { name: "edgeLabels.centerLabelPlacementStrategy", elkId: "org.eclipse.elk.layered.edgeLabels.centerLabelPlacementStrategy", type: "ENUM", targets: ["PARENTS","LABELS"] },
+  { name: "margins", elkId: "org.eclipse.elk.margins", type: "OBJECT", targets: ["NODES"] },
+  { name: "layering.coffmanGraham.layerBound", elkId: "org.eclipse.elk.layered.layering.coffmanGraham.layerBound", type: "INT", targets: ["PARENTS"] },
+  { name: "nodePlacement.favorStraightEdges", elkId: "org.eclipse.elk.layered.nodePlacement.favorStraightEdges", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "spacing.portsSurrounding", elkId: "org.eclipse.elk.spacing.portsSurrounding", type: "OBJECT", targets: ["PARENTS"] },
+  { name: "directionCongruency", elkId: "org.eclipse.elk.layered.directionCongruency", type: "ENUM", targets: ["PARENTS"] },
+  { name: "portSortingStrategy", elkId: "org.eclipse.elk.layered.portSortingStrategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "edgeRouting.polyline.slopedEdgeZoneWidth", elkId: "org.eclipse.elk.layered.edgeRouting.polyline.slopedEdgeZoneWidth", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "crossingMinimization.inLayerPredOf", elkId: "org.eclipse.elk.layered.crossingMinimization.inLayerPredOf", type: "STRING", targets: ["NODES"] },
+  { name: "crossingMinimization.inLayerSuccOf", elkId: "org.eclipse.elk.layered.crossingMinimization.inLayerSuccOf", type: "STRING", targets: ["NODES"] },
+  { name: "layering.layerChoiceConstraint", elkId: "org.eclipse.elk.layered.layering.layerChoiceConstraint", type: "INT", targets: ["NODES"] },
+  { name: "crossingMinimization.positionChoiceConstraint", elkId: "org.eclipse.elk.layered.crossingMinimization.positionChoiceConstraint", type: "INT", targets: ["NODES"] },
+  { name: "interactiveLayout", elkId: "org.eclipse.elk.interactiveLayout", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "layering.layerId", elkId: "org.eclipse.elk.layered.layering.layerId", type: "INT", targets: ["NODES"] },
+  { name: "crossingMinimization.positionId", elkId: "org.eclipse.elk.layered.crossingMinimization.positionId", type: "INT", targets: ["NODES"] },
+  { name: "considerModelOrder.strategy", elkId: "org.eclipse.elk.layered.considerModelOrder.strategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "considerModelOrder.longEdgeStrategy", elkId: "org.eclipse.elk.layered.considerModelOrder.longEdgeStrategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "considerModelOrder.crossingCounterNodeInfluence", elkId: "org.eclipse.elk.layered.considerModelOrder.crossingCounterNodeInfluence", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "considerModelOrder.crossingCounterPortInfluence", elkId: "org.eclipse.elk.layered.considerModelOrder.crossingCounterPortInfluence", type: "DOUBLE", targets: ["PARENTS"] },
+  { name: "considerModelOrder.noModelOrder", elkId: "org.eclipse.elk.layered.considerModelOrder.noModelOrder", type: "BOOLEAN", targets: ["NODES"] },
+  { name: "considerModelOrder.components", elkId: "org.eclipse.elk.layered.considerModelOrder.components", type: "ENUM", targets: ["PARENTS"] },
+  { name: "considerModelOrder.portModelOrder", elkId: "org.eclipse.elk.layered.considerModelOrder.portModelOrder", type: "BOOLEAN", targets: ["PARENTS"] },
+  { name: "considerModelOrder.groupModelOrder.cycleBreakingId", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cycleBreakingId", type: "INT", targets: ["NODES"] },
+  { name: "considerModelOrder.groupModelOrder.crossingMinimizationId", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.crossingMinimizationId", type: "INT", targets: ["NODES","EDGES","PORTS"] },
+  { name: "considerModelOrder.groupModelOrder.componentGroupId", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.componentGroupId", type: "INT", targets: ["NODES","EDGES","PORTS"] },
+  { name: "considerModelOrder.groupModelOrder.cbGroupOrderStrategy", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cbGroupOrderStrategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "considerModelOrder.groupModelOrder.cmGroupOrderStrategy", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cmGroupOrderStrategy", type: "ENUM", targets: ["PARENTS"] },
+  { name: "considerModelOrder.groupModelOrder.cmEnforcedGroupOrders", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cmEnforcedGroupOrders", type: "OBJECT", targets: ["PARENTS"] },
+  { name: "considerModelOrder.groupModelOrder.cbPreferredSourceId", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cbPreferredSourceId", type: "INT", targets: ["PARENTS"] },
+  { name: "considerModelOrder.groupModelOrder.cbPreferredTargetId", elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cbPreferredTargetId", type: "INT", targets: ["PARENTS"] },
+  { name: "generatePositionAndLayerIds", elkId: "org.eclipse.elk.layered.generatePositionAndLayerIds", type: "BOOLEAN", targets: ["PARENTS"] },
+] as const;
+
+export type ElkLayeredOptionName = keyof ElkLayeredOptionValueByName;
+export type ElkLayeredOptionId = (typeof elkLayeredOptionDefinitions)[number]["elkId"];

package/src/layered/elk-options.ts

@@ -0,0 +1,98 @@
+import type { LayoutDirection } from "../types";
+import {
+  elkLayeredOptionDefinitions,
+  type ElkLayeredOptionId,
+  type ElkLayeredOptionName,
+  type ElkLayeredOptionValueByName,
+} from "./elk-options.generated";
+import { elkLayeredEnumValues } from "./elk-enum-values";
+import type { LayeredLayoutOptions, LayoutPadding } from "./types";
+export { elkLayeredEnumValues, type ElkLayeredEnumOptionName } from "./elk-enum-values";
+
+export {
+  elkLayeredOptionDefinitions,
+  type ElkLayeredOptionId,
+  type ElkLayeredOptionName,
+  type ElkLayeredOptionValueByName,
+};
+
+export type CycleBreakingStrategy = (typeof elkLayeredEnumValues)["cycleBreaking.strategy"][number];
+export type LayeringStrategy = (typeof elkLayeredEnumValues)["layering.strategy"][number];
+export type CrossingMinimizationStrategy =
+  (typeof elkLayeredEnumValues)["crossingMinimization.strategy"][number];
+export type NodePlacementStrategy = (typeof elkLayeredEnumValues)["nodePlacement.strategy"][number];
+export type EdgeRoutingStyle = (typeof elkLayeredEnumValues)["edgeRouting"][number];
+
+type StrictElkLayeredOptionValueByName = Omit<
+  ElkLayeredOptionValueByName,
+  keyof typeof elkLayeredEnumValues
+> & {
+  [Name in keyof typeof elkLayeredEnumValues]?: (typeof elkLayeredEnumValues)[Name][number];
+};
+
+export type LayeredAdvancedOptions = Omit<
+  StrictElkLayeredOptionValueByName,
+  | "direction"
+  | "padding"
+  | "spacing.node"
+  | "spacing.layer"
+  | "cycleBreaking.strategy"
+  | "layering.strategy"
+  | "crossingMinimization.strategy"
+  | "nodePlacement.strategy"
+  | "edgeRouting"
+> & {
+  "cycleBreaking.strategy"?: CycleBreakingStrategy;
+  "layering.strategy"?: LayeringStrategy;
+  "crossingMinimization.strategy"?: CrossingMinimizationStrategy;
+  "nodePlacement.strategy"?: NodePlacementStrategy;
+  edgeRouting?: EdgeRoutingStyle;
+};
+
+const definitionByName = new Map(
+  elkLayeredOptionDefinitions.map((definition) => [definition.name, definition]),
+);
+
+function formatPadding(padding: number | Partial<LayoutPadding>): string {
+  if (typeof padding === "number") {
+    return `[top=${padding},right=${padding},bottom=${padding},left=${padding}]`;
+  }
+  return `[top=${padding.top ?? 0},right=${padding.right ?? 0},bottom=${padding.bottom ?? 0},left=${padding.left ?? 0}]`;
+}
+
+function formatDirection(direction: LayoutDirection): Uppercase<LayoutDirection> {
+  return direction.toUpperCase() as Uppercase<LayoutDirection>;
+}
+
+/** Translate every simplified layered setting to its exact ELK 0.11.1 option ID. */
+export function toElkLayeredOptions(
+  options: LayeredLayoutOptions,
+): Partial<Record<ElkLayeredOptionId, unknown>> {
+  const result: Partial<Record<ElkLayeredOptionId, unknown>> = {};
+  if (options.direction !== undefined) {
+    result["org.eclipse.elk.direction"] = formatDirection(options.direction);
+  }
+  if (options.padding !== undefined) {
+    result["org.eclipse.elk.padding"] = formatPadding(options.padding);
+  }
+  if (options.spacing?.node !== undefined) {
+    result["org.eclipse.elk.spacing.nodeNode"] = options.spacing.node;
+  }
+  if (options.spacing?.layer !== undefined) {
+    result["org.eclipse.elk.layered.spacing.nodeNodeBetweenLayers"] = options.spacing.layer;
+  }
+  for (const [name, value] of Object.entries(options.settings ?? {})) {
+    if (value === undefined) continue;
+    const definition = definitionByName.get(name as ElkLayeredOptionName);
+    if (!definition) throw new Error(`Unknown layered setting: ${name}`);
+    result[definition.elkId] = value;
+  }
+  return result;
+}
+
+/** Return the simplified public name for an exact ELK layered option ID. */
+export function fromElkLayeredOptionId(id: ElkLayeredOptionId): ElkLayeredOptionName {
+  const definition = elkLayeredOptionDefinitions.find((candidate) => candidate.elkId === id);
+  if (!definition) throw new Error(`Unknown ELK layered option: ${id}`);
+  return definition.name;
+}

package/src/layered/flexible-ports.ts

@@ -0,0 +1,11 @@
+import type { GraphPort } from "@statelyai/graph";
+
+const positionByPort = new WeakMap<object, { x: number; y: number }>();
+
+export function setFlexiblePortPosition(port: GraphPort, x: number, y: number): void {
+  positionByPort.set(port, { x, y });
+}
+
+export function getFlexiblePortPosition(port: GraphPort): { x: number; y: number } | undefined {
+  return positionByPort.get(port);
+}