@world-engines/authoring-ui 0.1.0-alpha.0

package/dist/ladybug/entity-props.js

@@ -0,0 +1,363 @@
+import { SERIALIZED_PROP_ENVELOPE_MARKER, isSerializedPropEnvelope } from "@world-engines/protocol-ts/entity-prop-envelope";
+const isPlainObject = (input) => input !== null && typeof input === "object" && !Array.isArray(input);
+export const isPropScalar = (v) => typeof v === "string";
+export const isEntityReferenceValue = (value) => {
+    if (!isPlainObject(value) || !isPlainObject(value.$ref))
+        return false;
+    const ref = value.$ref;
+    if (ref.kind !== "node" && ref.kind !== "edge" && ref.kind !== "attr")
+        return false;
+    if (typeof ref.id !== "string" || ref.id.length === 0)
+        return false;
+    if (ref.kind === "attr") {
+        return typeof ref.attr_key === "string" && ref.attr_key.length > 0;
+    }
+    return ref.attr_key === undefined;
+};
+export const isScenarioAssetReferenceValue = (value) => isPlainObject(value) &&
+    Object.keys(value).length === 1 &&
+    typeof value.$asset === "string" &&
+    /^asset:[0-9a-f]{32}$/.test(value.$asset);
+export const isPropArray = (v) => Array.isArray(v);
+export const isPropReference = (v) => isEntityReferenceValue(v);
+export const isPropRichText = (v) => isPlainObject(v) && Array.isArray(v.$rich) && v.$rich.every((segment) => (isPlainObject(segment) && typeof segment.text === "string") || isEntityReferenceValue(segment));
+export const isPropTree = (v) => !isPropScalar(v) &&
+    !isPropArray(v) &&
+    !isPropReference(v) &&
+    !isScenarioAssetReferenceValue(v) &&
+    !isPropRichText(v);
+export const propValueToText = (v) => {
+    if (isPropScalar(v))
+        return v;
+    if (isPropReference(v)) {
+        const suffix = v.$ref.kind === "attr" ? `/${v.$ref.attr_key ?? ""}` : "";
+        return `@${v.$ref.kind}:${v.$ref.id}${suffix}`;
+    }
+    if (isScenarioAssetReferenceValue(v))
+        return v.$asset;
+    if (isPropRichText(v)) {
+        return v.$rich.map((segment) => "text" in segment ? segment.text : propValueToText(segment)).join("");
+    }
+    if (isPropArray(v)) {
+        return v.map((item) => propValueToText(item.value)).join(" 路 ");
+    }
+    return Object.entries(v)
+        .map(([subKey, sub]) => `${subKey}: ${propValueToText(sub.value)}`)
+        .join(" · ");
+};
+export const propShape = (v) => isPropRichText(v)
+    ? "richtext"
+    : isPropReference(v)
+        ? "reference"
+        : isPropArray(v)
+            ? "array"
+            : isPropTree(v)
+                ? "tree"
+                : "scalar";
+const stringifyValue = (input) => {
+    if (input === null || input === undefined)
+        return "";
+    if (typeof input === "string")
+        return input;
+    if (typeof input === "number" || typeof input === "boolean")
+        return String(input);
+    try {
+        return JSON.stringify(input);
+    }
+    catch {
+        return "";
+    }
+};
+const sanitizeTriggerDef = (input) => {
+    if (input === undefined)
+        return undefined;
+    if (!isPlainObject(input))
+        throw new Error("entity_prop_trigger_invalid");
+    if (typeof input.id !== "string" || input.id.length === 0) {
+        throw new Error("entity_prop_trigger_invalid");
+    }
+    if (!isPlainObject(input.tree) && !(typeof input.tree === "object" && input.tree !== null)) {
+        throw new Error("entity_prop_trigger_invalid");
+    }
+    return input;
+};
+const tryParseObject = (raw) => {
+    if (raw.length === 0 || raw[0] !== "{")
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isPlainObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const parsePropValue = (raw) => {
+    if (typeof raw === "string")
+        return raw;
+    if (Array.isArray(raw))
+        return raw.map(wrapToEntityProp);
+    if (isScenarioAssetReferenceValue(raw))
+        return raw;
+    if (isEntityReferenceValue(raw))
+        return raw;
+    if (isPlainObject(raw) && Array.isArray(raw.$rich)) {
+        const segments = [];
+        for (const segment of raw.$rich) {
+            if (isPlainObject(segment) && typeof segment.text === "string")
+                segments.push({ text: segment.text });
+            else if (isEntityReferenceValue(segment))
+                segments.push(segment);
+        }
+        return { $rich: segments };
+    }
+    if (isPlainObject(raw)) {
+        const tree = {};
+        for (const [subKey, subRaw] of Object.entries(raw)) {
+            tree[subKey] = wrapToEntityProp(subRaw);
+        }
+        return tree;
+    }
+    return stringifyValue(raw);
+};
+const parseAttrState = (raw) => {
+    if (!isPlainObject(raw))
+        return null;
+    if (typeof raw.id !== "string" || raw.id === "")
+        return null;
+    const value = parsePropValue(raw.value);
+    const out = {
+        id: raw.id,
+        value
+    };
+    if (typeof raw.enter_when_trigger_id === "string") {
+        out.enter_when_trigger_id = raw.enter_when_trigger_id;
+    }
+    if (typeof raw.locked_until_trigger_id === "string") {
+        out.locked_until_trigger_id = raw.locked_until_trigger_id;
+    }
+    if (raw.dead === true)
+        out.dead = true;
+    if (raw.disabled === true)
+        out.disabled = true;
+    return out;
+};
+const parseAttrStates = (raw) => {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const item of raw) {
+        const parsed = parseAttrState(item);
+        if (parsed)
+            out.push(parsed);
+    }
+    return out.length > 0 ? out : undefined;
+};
+const parseSourceReferences = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        throw new Error("entity_prop_source_refs_invalid");
+    const refs = [];
+    for (const item of raw) {
+        if (!isPlainObject(item))
+            throw new Error("entity_prop_source_ref_invalid");
+        if (typeof item.document_entity_id !== "string" ||
+            typeof item.chunk_entity_id !== "string" ||
+            typeof item.chunk_sha256 !== "string" ||
+            !Number.isInteger(item.source_start) ||
+            !Number.isInteger(item.source_end) ||
+            item.source_start < 0 ||
+            item.source_end < item.source_start)
+            throw new Error("entity_prop_source_ref_invalid");
+        refs.push({
+            document_entity_id: item.document_entity_id,
+            chunk_entity_id: item.chunk_entity_id,
+            chunk_sha256: item.chunk_sha256,
+            source_start: item.source_start,
+            source_end: item.source_end
+        });
+    }
+    return refs.length > 0 ? refs : undefined;
+};
+const buildProp = (value, trigger, states, title, initialAvailable, sourceRefs, viewAccess) => {
+    const sanitized = sanitizeTriggerDef(trigger);
+    const parsedStates = parseAttrStates(states);
+    const out = { value };
+    if (sanitized)
+        out.trigger = sanitized;
+    if (parsedStates)
+        out.states = parsedStates;
+    if (typeof title === "string")
+        out.title = title;
+    if (typeof initialAvailable === "boolean") {
+        out.initial_available = initialAvailable;
+    }
+    const parsedSourceRefs = parseSourceReferences(sourceRefs);
+    if (parsedSourceRefs !== undefined)
+        out.source_refs = parsedSourceRefs;
+    if (viewAccess === "inherit" ||
+        viewAccess === "deny" ||
+        viewAccess === "read" ||
+        viewAccess === "read_write") {
+        out.view_access = viewAccess;
+    }
+    else if (viewAccess !== undefined) {
+        throw new Error("entity_prop_view_access_invalid");
+    }
+    return out;
+};
+const isPropEnvelope = (input) => isSerializedPropEnvelope(input);
+const wrapToEntityProp = (raw) => {
+    if (typeof raw === "string") {
+        const parsed = tryParseObject(raw);
+        if (parsed && isPropEnvelope(parsed)) {
+            return buildProp(parsePropValue(parsed.value), parsed.trigger, parsed.states, parsed.title, parsed.initial_available, parsed.source_refs, parsed.view_access);
+        }
+        return { value: raw };
+    }
+    if (isPlainObject(raw) && isPropEnvelope(raw)) {
+        return buildProp(parsePropValue(raw.value), raw.trigger, raw.states, raw.title, raw.initial_available, raw.source_refs, raw.view_access);
+    }
+    return { value: parsePropValue(raw) };
+};
+export const normalizeEntityProps = (raw) => {
+    if (!isPlainObject(raw))
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        out[k] = wrapToEntityProp(v);
+    }
+    return out;
+};
+const valueToTree = (v, defaultKey) => {
+    if (isPropTree(v))
+        return v;
+    const text = propValueToText(v);
+    return text.length > 0 ? { [defaultKey]: { value: v } } : {};
+};
+export const convertPropShape = (v, target, defaultKey) => {
+    if (propShape(v) === target)
+        return v;
+    if (target === "scalar")
+        return propValueToText(v);
+    return valueToTree(v, defaultKey);
+};
+export const emptyPropValue = (shape) => shape === "tree" ? {} : shape === "array" ? [] : "";
+const serializePropValue = (value) => {
+    if (isPropScalar(value))
+        return value;
+    if (isScenarioAssetReferenceValue(value))
+        return value;
+    if (isPropReference(value))
+        return value;
+    if (isPropRichText(value))
+        return value;
+    if (isPropArray(value))
+        return value.map(serializeProp);
+    const out = {};
+    for (const [subKey, sub] of Object.entries(value)) {
+        out[subKey] = serializeProp(sub);
+    }
+    return out;
+};
+const serializeAttrState = (s) => {
+    const out = {
+        id: s.id,
+        value: serializePropValue(s.value)
+    };
+    if (s.enter_when_trigger_id !== undefined) {
+        out.enter_when_trigger_id = s.enter_when_trigger_id;
+    }
+    if (s.locked_until_trigger_id !== undefined) {
+        out.locked_until_trigger_id = s.locked_until_trigger_id;
+    }
+    if (s.dead === true)
+        out.dead = true;
+    if (s.disabled === true)
+        out.disabled = true;
+    return out;
+};
+const serializeProp = (prop) => {
+    const value = serializePropValue(prop.value);
+    const hasTrigger = prop.trigger !== undefined;
+    const hasStates = prop.states !== undefined && prop.states.length > 0;
+    const hasMetadata = prop.title !== undefined
+        || prop.initial_available !== undefined
+        || prop.view_access !== undefined
+        || (prop.source_refs !== undefined && prop.source_refs.length > 0);
+    if (!hasTrigger && !hasStates && !hasMetadata)
+        return value;
+    const out = { [SERIALIZED_PROP_ENVELOPE_MARKER]: true, value };
+    if (hasTrigger)
+        out.trigger = prop.trigger;
+    if (hasStates)
+        out.states = prop.states.map(serializeAttrState);
+    if (prop.title !== undefined)
+        out.title = prop.title;
+    if (prop.initial_available !== undefined) {
+        out.initial_available = prop.initial_available;
+    }
+    if (prop.source_refs !== undefined && prop.source_refs.length > 0) {
+        out.source_refs = prop.source_refs;
+    }
+    if (prop.view_access !== undefined)
+        out.view_access = prop.view_access;
+    return out;
+};
+export const serializeEntityProps = (props) => {
+    const out = {};
+    for (const [k, p] of Object.entries(props)) {
+        out[k] = serializeProp(p);
+    }
+    return out;
+};
+export const toStringPropsLegacy = (props) => {
+    const out = {};
+    for (const [k, p] of Object.entries(props)) {
+        out[k] = propValueToText(p.value);
+    }
+    return out;
+};
+export const propValue = (props, key) => {
+    const p = props[key];
+    return p ? propValueToText(p.value) : "";
+};
+export const activeAttrState = (prop) => {
+    if (!prop.states || prop.states.length === 0)
+        return undefined;
+    for (let i = prop.states.length - 1; i >= 0; i -= 1) {
+        const s = prop.states[i];
+        if (!s.dead)
+            return s;
+    }
+    return undefined;
+};
+export const isPropDead = (prop) => {
+    if (!prop.states || prop.states.length === 0)
+        return false;
+    return activeAttrState(prop) === undefined;
+};
+export const effectivePropValue = (prop) => {
+    const active = activeAttrState(prop);
+    if (prop.states && prop.states.length > 0)
+        return active ? active.value : undefined;
+    return prop.value;
+};
+export const effectivePropValueText = (prop) => {
+    const v = effectivePropValue(prop);
+    if (v === undefined)
+        return "";
+    return propValueToText(v);
+};
+export const isEntityFullyDead = (props) => {
+    const keys = Object.keys(props);
+    if (keys.length === 0)
+        return false;
+    return keys.every((k) => {
+        const p = props[k];
+        if (!p)
+            return true;
+        return isPropDead(p);
+    });
+};

package/dist/ladybug/graph-edge-geometry.d.ts

@@ -0,0 +1,19 @@
+export interface GraphEdgeGeometryInput {
+    readonly sourceX: number;
+    readonly sourceY: number;
+    readonly targetX: number;
+    readonly targetY: number;
+    readonly sourceRadius?: number;
+    readonly targetRadius?: number;
+    readonly fallbackRadius?: number;
+    readonly parallelIndex?: number;
+    readonly parallelCount?: number;
+}
+export interface GraphEdgeGeometry {
+    readonly path: string;
+    readonly labelX: number;
+    readonly labelY: number;
+    readonly selfLoop: boolean;
+}
+/** 将 ReactFlow 的圆心 Handle 裁到可变半径圆边界，并稳定分离平行边。 */
+export declare function computeGraphEdgeGeometry(input: GraphEdgeGeometryInput): GraphEdgeGeometry;

package/dist/ladybug/graph-edge-geometry.js

@@ -0,0 +1,78 @@
+import { NODE_RADIUS } from "./graph-placement.js";
+const PARALLEL_LANE_GAP = 18;
+const SELF_LOOP_GAP = 16;
+const EPSILON = 0.001;
+const finiteRadius = (value, fallback) => value !== undefined && Number.isFinite(value) && value > 0 ? value : fallback;
+const numberToken = (value) => {
+    const rounded = Math.round(value * 1000) / 1000;
+    return String(Object.is(rounded, -0) ? 0 : rounded);
+};
+const lane = (index, count) => {
+    const safeCount = Number.isInteger(count) && (count ?? 0) > 0 ? count : 1;
+    const safeIndex = Number.isInteger(index) && (index ?? -1) >= 0
+        ? Math.min(index, safeCount - 1)
+        : 0;
+    return safeIndex - (safeCount - 1) / 2;
+};
+/** 将 ReactFlow 的圆心 Handle 裁到可变半径圆边界，并稳定分离平行边。 */
+export function computeGraphEdgeGeometry(input) {
+    const fallback = finiteRadius(input.fallbackRadius, NODE_RADIUS);
+    const sourceRadius = finiteRadius(input.sourceRadius, fallback);
+    const targetRadius = finiteRadius(input.targetRadius, fallback);
+    const dx = input.targetX - input.sourceX;
+    const dy = input.targetY - input.sourceY;
+    const distance = Math.hypot(dx, dy);
+    const laneIndex = lane(input.parallelIndex, input.parallelCount);
+    if (distance < EPSILON) {
+        const radius = Math.max(sourceRadius, targetRadius);
+        const xFactor = Math.SQRT1_2;
+        const yFactor = -Math.SQRT1_2;
+        const sourceX = input.sourceX - radius * xFactor;
+        const sourceY = input.sourceY + radius * yFactor;
+        const targetX = input.targetX + radius * xFactor;
+        const targetY = input.targetY + radius * yFactor;
+        const expansion = radius * 1.8 + SELF_LOOP_GAP * (laneIndex + ((input.parallelCount ?? 1) - 1) / 2);
+        const control1X = input.sourceX - expansion;
+        const control1Y = input.sourceY - expansion;
+        const control2X = input.targetX + expansion;
+        const control2Y = input.targetY - expansion;
+        return {
+            path: `M${numberToken(sourceX)} ${numberToken(sourceY)}C${numberToken(control1X)} ${numberToken(control1Y)} ${numberToken(control2X)} ${numberToken(control2Y)} ${numberToken(targetX)} ${numberToken(targetY)}`,
+            labelX: input.sourceX,
+            labelY: input.sourceY - expansion,
+            selfLoop: true
+        };
+    }
+    const unitX = dx / distance;
+    const unitY = dy / distance;
+    const canonicalSign = dx > 0 || (Math.abs(dx) < EPSILON && dy >= 0) ? 1 : -1;
+    const normalX = -unitY * canonicalSign;
+    const normalY = unitX * canonicalSign;
+    const offset = laneIndex * PARALLEL_LANE_GAP;
+    if (Math.abs(offset) < EPSILON) {
+        const sourceX = input.sourceX + unitX * sourceRadius;
+        const sourceY = input.sourceY + unitY * sourceRadius;
+        const targetX = input.targetX - unitX * targetRadius;
+        const targetY = input.targetY - unitY * targetRadius;
+        return {
+            path: `M${numberToken(sourceX)} ${numberToken(sourceY)}L${numberToken(targetX)} ${numberToken(targetY)}`,
+            labelX: (sourceX + targetX) / 2,
+            labelY: (sourceY + targetY) / 2,
+            selfLoop: false
+        };
+    }
+    const controlX = (input.sourceX + input.targetX) / 2 + normalX * offset * 2;
+    const controlY = (input.sourceY + input.targetY) / 2 + normalY * offset * 2;
+    const sourceControlDistance = Math.hypot(controlX - input.sourceX, controlY - input.sourceY);
+    const targetControlDistance = Math.hypot(controlX - input.targetX, controlY - input.targetY);
+    const sourceX = input.sourceX + (controlX - input.sourceX) / sourceControlDistance * sourceRadius;
+    const sourceY = input.sourceY + (controlY - input.sourceY) / sourceControlDistance * sourceRadius;
+    const targetX = input.targetX + (controlX - input.targetX) / targetControlDistance * targetRadius;
+    const targetY = input.targetY + (controlY - input.targetY) / targetControlDistance * targetRadius;
+    return {
+        path: `M${numberToken(sourceX)} ${numberToken(sourceY)}Q${numberToken(controlX)} ${numberToken(controlY)} ${numberToken(targetX)} ${numberToken(targetY)}`,
+        labelX: (sourceX + 2 * controlX + targetX) / 4,
+        labelY: (sourceY + 2 * controlY + targetY) / 4,
+        selfLoop: false
+    };
+}

package/dist/ladybug/graph-edge-mask.d.ts

@@ -0,0 +1,21 @@
+export declare const GRAPH_EDGE_OCCLUSION_HALO = 6;
+export interface GraphEdgeOccluder {
+    readonly id: string;
+    readonly x: number;
+    readonly y: number;
+    readonly radius: number;
+}
+export interface GraphEdgeOcclusionIndex {
+    readonly cellSize: number;
+    readonly cells: ReadonlyMap<string, readonly GraphEdgeOccluder[]>;
+}
+export interface GraphEdgeLabelBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** CSS 使用 inverse zoom 保持屏幕字号；遮挡检测需将 badge 屏幕尺寸换回 world 单位。 */
+export declare function graphEdgeLabelWorldBounds(label: string, x: number, y: number, zoom: number): GraphEdgeLabelBounds;
+export declare function buildGraphEdgeOcclusionIndex(occluders: readonly GraphEdgeOccluder[], halo?: number): GraphEdgeOcclusionIndex;
+export declare function isGraphEdgeLabelOccluded(index: GraphEdgeOcclusionIndex, bounds: GraphEdgeLabelBounds, halo?: number): boolean;

package/dist/ladybug/graph-edge-mask.js

@@ -0,0 +1,52 @@
+export const GRAPH_EDGE_OCCLUSION_HALO = 6;
+const GRAPH_EDGE_LABEL_MIN_SCREEN_SIZE = 18;
+const GRAPH_EDGE_LABEL_DIGIT_SCREEN_WIDTH = 8;
+const GRAPH_EDGE_LABEL_SCREEN_PADDING = 10;
+/** CSS 使用 inverse zoom 保持屏幕字号；遮挡检测需将 badge 屏幕尺寸换回 world 单位。 */
+export function graphEdgeLabelWorldBounds(label, x, y, zoom) {
+    const safeZoom = Number.isFinite(zoom) && zoom > 0 ? zoom : 1;
+    return {
+        x,
+        y,
+        width: Math.max(GRAPH_EDGE_LABEL_MIN_SCREEN_SIZE, label.length * GRAPH_EDGE_LABEL_DIGIT_SCREEN_WIDTH + GRAPH_EDGE_LABEL_SCREEN_PADDING) / safeZoom,
+        height: GRAPH_EDGE_LABEL_MIN_SCREEN_SIZE / safeZoom
+    };
+}
+const cellKey = (x, y) => `${x}:${y}`;
+export function buildGraphEdgeOcclusionIndex(occluders, halo = GRAPH_EDGE_OCCLUSION_HALO) {
+    const largestRadius = occluders.reduce((largest, occluder) => Math.max(largest, occluder.radius + halo), 1);
+    const cellSize = largestRadius * 2;
+    const cells = new Map();
+    for (const occluder of occluders) {
+        const key = cellKey(Math.floor(occluder.x / cellSize), Math.floor(occluder.y / cellSize));
+        const cell = cells.get(key);
+        if (cell === undefined)
+            cells.set(key, [occluder]);
+        else
+            cell.push(occluder);
+    }
+    return { cellSize, cells };
+}
+export function isGraphEdgeLabelOccluded(index, bounds, halo = GRAPH_EDGE_OCCLUSION_HALO) {
+    const halfWidth = bounds.width / 2;
+    const halfHeight = bounds.height / 2;
+    const cellX = Math.floor(bounds.x / index.cellSize);
+    const cellY = Math.floor(bounds.y / index.cellSize);
+    for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
+        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
+            const cell = index.cells.get(cellKey(cellX + offsetX, cellY + offsetY));
+            if (cell === undefined)
+                continue;
+            for (const occluder of cell) {
+                const nearestX = Math.max(bounds.x - halfWidth, Math.min(occluder.x, bounds.x + halfWidth));
+                const nearestY = Math.max(bounds.y - halfHeight, Math.min(occluder.y, bounds.y + halfHeight));
+                const dx = nearestX - occluder.x;
+                const dy = nearestY - occluder.y;
+                const radius = occluder.radius + halo;
+                if (dx * dx + dy * dy <= radius * radius)
+                    return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/ladybug/graph-groups.d.ts

@@ -0,0 +1,47 @@
+export interface SharedGraphGroup {
+    readonly id: string;
+    readonly label?: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface GraphGroupBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export declare const GRAPH_GROUP_MIN_SIZE = 96;
+export declare const GRAPH_GROUP_LABEL_MAX_LENGTH = 40;
+/** 不持久化第二份颜色 authority；相同 group id 在 npm/editor 中得到相同实色。 */
+export declare const graphGroupColor: (id: string) => string;
+export declare const normalizeGraphGroupLabel: (value: string) => string | null;
+export interface GraphGroupPoint {
+    readonly x: number;
+    readonly y: number;
+}
+export interface GraphGroupTranslation {
+    readonly bounds: GraphGroupBounds;
+    readonly delta: GraphGroupPoint;
+}
+export type GraphGroupResizeSide = "top" | "right" | "bottom" | "left";
+export declare const isGraphGroupBoundsFinite: (bounds: GraphGroupBounds) => boolean;
+export declare const snapGraphGroupCoordinate: (value: number) => number;
+export declare const snapGraphGroupPoint: (point: GraphGroupPoint) => GraphGroupPoint;
+/** 同时吸附两角，避免 position 与 size 使用不同网格 authority。 */
+export declare const snapGraphGroupBounds: (bounds: GraphGroupBounds) => GraphGroupBounds;
+/** 画框可向任意方向进行；返回归一化且已吸附的非负矩形。 */
+export declare const graphGroupBoundsFromPoints: (start: GraphGroupPoint, end: GraphGroupPoint) => GraphGroupBounds;
+export declare const graphGroupsOverlap: (left: GraphGroupBounds, right: GraphGroupBounds) => boolean;
+export declare const isGraphGroupBoundsValid: (candidate: GraphGroupBounds, groups: readonly SharedGraphGroup[], excludeId?: string) => boolean;
+/** 所有矩形必须有效，且任何两个矩形只能分离或边界相贴。 */
+export declare const validateGraphGroups: (groups: readonly SharedGraphGroup[]) => boolean;
+export declare const nodesInsideGraphGroup: (group: GraphGroupBounds, centers: Readonly<Record<string, {
+    readonly x: number;
+    readonly y: number;
+}>>) => string[];
+export declare const clampGraphGroupTranslation: (source: GraphGroupBounds, requestedDelta: GraphGroupPoint, groups: readonly SharedGraphGroup[], excludeId?: string) => GraphGroupTranslation;
+export declare const resizeGraphGroupSide: (source: GraphGroupBounds, side: GraphGroupResizeSide, requestedCoordinate: number, groups: readonly SharedGraphGroup[], excludeId?: string) => GraphGroupBounds;
+/** 使用 clamp 返回的同一 delta 更新成员，成员之间的相对偏移不会改变。 */
+export declare const translateGraphGroupMembers: (centers: Readonly<Record<string, GraphGroupPoint>>, memberIds: readonly string[], delta: GraphGroupPoint) => Readonly<Record<string, GraphGroupPoint>>;