@zoneflow/core 0.0.1

package/dist/clone.d.ts

@@ -0,0 +1,14 @@
+import type { UniverseModel, ZoneId } from "./types";
+export type CloneZoneSubtreeOptions = {
+    nextParentZoneId?: ZoneId | null;
+    rename?: (originalName: string) => string;
+};
+export type CloneZoneSubtreeResult = {
+    model: UniverseModel;
+    clonedRootZoneId: ZoneId;
+    zoneIdMap: Record<ZoneId, ZoneId>;
+};
+export declare function cloneZoneSubtree(model: UniverseModel, sourceRootZoneId: ZoneId, options?: CloneZoneSubtreeOptions): CloneZoneSubtreeResult;
+export type DuplicateZoneSubtreeOptions = CloneZoneSubtreeOptions;
+export type DuplicateZoneSubtreeResult = CloneZoneSubtreeResult;
+export declare function duplicateZoneSubtree(model: UniverseModel, sourceRootZoneId: ZoneId, options?: DuplicateZoneSubtreeOptions): DuplicateZoneSubtreeResult;

package/dist/clone.js

@@ -0,0 +1,54 @@
+import { getZone } from "./lookup";
+import { remapSubtreeIds } from "./remap";
+export function cloneZoneSubtree(model, sourceRootZoneId, options = {}) {
+    const sourceRootZone = getZone(model, sourceRootZoneId);
+    if (!sourceRootZone) {
+        return {
+            model,
+            clonedRootZoneId: sourceRootZoneId,
+            zoneIdMap: {},
+        };
+    }
+    const { nextParentZoneId = sourceRootZone.parentZoneId, rename = (name) => `${name} Copy`, } = options;
+    const remapped = remapSubtreeIds(model, sourceRootZoneId);
+    const clonedRootZoneId = remapped.rootZoneIds[0];
+    const nextZonesById = {
+        ...model.zonesById,
+        ...remapped.zonesById,
+    };
+    // 복제 루트의 parent 재설정 + 이름 변경
+    nextZonesById[clonedRootZoneId] = {
+        ...nextZonesById[clonedRootZoneId],
+        parentZoneId: nextParentZoneId,
+        name: rename(sourceRootZone.name),
+    };
+    let nextRootZoneIds = [...model.rootZoneIds];
+    // 루트에 붙이는 경우
+    if (nextParentZoneId === null) {
+        nextRootZoneIds.push(clonedRootZoneId);
+    }
+    else {
+        const parent = nextZonesById[nextParentZoneId];
+        if (parent) {
+            nextZonesById[nextParentZoneId] = {
+                ...parent,
+                childZoneIds: [...parent.childZoneIds, clonedRootZoneId],
+            };
+        }
+    }
+    return {
+        model: {
+            ...model,
+            rootZoneIds: nextRootZoneIds,
+            zonesById: nextZonesById,
+        },
+        clonedRootZoneId,
+        zoneIdMap: remapped.zoneIdMap,
+    };
+}
+export function duplicateZoneSubtree(model, sourceRootZoneId, options = {}) {
+    return cloneZoneSubtree(model, sourceRootZoneId, {
+        rename: options.rename ?? ((name) => `${name} Copy`),
+        nextParentZoneId: options.nextParentZoneId,
+    });
+}

package/dist/hierarchy.d.ts

@@ -0,0 +1,5 @@
+import type { UniverseModel, ZoneId } from "./types";
+export declare function isRootZone(model: UniverseModel, zoneId: ZoneId): boolean;
+export declare function getAncestorZoneIds(model: UniverseModel, zoneId: ZoneId): ZoneId[];
+export declare function getZoneDepth(model: UniverseModel, zoneId: ZoneId): number;
+export declare function isDescendantZone(model: UniverseModel, parentZoneId: ZoneId, childZoneId: ZoneId): boolean;

package/dist/hierarchy.js

@@ -0,0 +1,18 @@
+export function isRootZone(model, zoneId) {
+    return model.rootZoneIds.includes(zoneId);
+}
+export function getAncestorZoneIds(model, zoneId) {
+    const result = [];
+    let current = model.zonesById[zoneId];
+    while (current?.parentZoneId) {
+        result.push(current.parentZoneId);
+        current = model.zonesById[current.parentZoneId];
+    }
+    return result;
+}
+export function getZoneDepth(model, zoneId) {
+    return getAncestorZoneIds(model, zoneId).length;
+}
+export function isDescendantZone(model, parentZoneId, childZoneId) {
+    return getAncestorZoneIds(model, childZoneId).includes(parentZoneId);
+}

package/dist/ids.d.ts

@@ -0,0 +1,3 @@
+import type { ZoneId, PathId } from "./types";
+export declare function createZoneId(): ZoneId;
+export declare function createPathId(): PathId;

package/dist/ids.js

@@ -0,0 +1,7 @@
+import { v7 as uuidv7 } from "uuid";
+export function createZoneId() {
+    return `zone_${uuidv7()}`;
+}
+export function createPathId() {
+    return `path_${uuidv7()}`;
+}

package/dist/import.d.ts

@@ -0,0 +1,13 @@
+import type { UniverseModel, ZoneId } from "./types";
+export type ExternalTargetPolicy = "preserve" | "drop" | "mark-unresolved";
+export type ImportZoneSubtreeOptions = {
+    nextParentZoneId?: ZoneId | null;
+    rename?: (originalName: string) => string;
+    externalTargetPolicy?: ExternalTargetPolicy;
+};
+export type ImportZoneSubtreeResult = {
+    model: UniverseModel;
+    importedRootZoneId: ZoneId;
+    zoneIdMap: Record<ZoneId, ZoneId>;
+};
+export declare function importZoneSubtree(targetModel: UniverseModel, sourceModel: UniverseModel, sourceRootZoneId: ZoneId, options?: ImportZoneSubtreeOptions): ImportZoneSubtreeResult;

package/dist/import.js

@@ -0,0 +1,129 @@
+import { createPathId, createZoneId } from "./ids";
+import { flattenSubtree } from "./traversal";
+export function importZoneSubtree(targetModel, sourceModel, sourceRootZoneId, options = {}) {
+    const { nextParentZoneId = null, rename = (name) => name, externalTargetPolicy = "preserve", } = options;
+    const sourceRootZone = sourceModel.zonesById[sourceRootZoneId];
+    if (!sourceRootZone) {
+        return {
+            model: targetModel,
+            importedRootZoneId: sourceRootZoneId,
+            zoneIdMap: {},
+        };
+    }
+    const sourceZones = flattenSubtree(sourceModel, sourceRootZoneId);
+    const zoneIdMap = {};
+    const pathIdMap = {};
+    // 1) Zone ID 재발급
+    for (const zone of sourceZones) {
+        zoneIdMap[zone.id] = createZoneId();
+    }
+    // 2) Path ID 재발급
+    for (const zone of sourceZones) {
+        for (const pathId of zone.pathIds) {
+            const path = zone.pathsById[pathId];
+            if (!path)
+                continue;
+            pathIdMap[path.id] = createPathId();
+        }
+    }
+    // 3) Zone clone + 내부 참조 재작성
+    const importedZonesById = {};
+    for (const sourceZone of sourceZones) {
+        const nextZoneId = zoneIdMap[sourceZone.id];
+        const nextChildZoneIds = sourceZone.childZoneIds
+            .map((childId) => zoneIdMap[childId])
+            .filter((id) => Boolean(id));
+        const nextPathIds = sourceZone.pathIds
+            .map((pathId) => {
+            const path = sourceZone.pathsById[pathId];
+            if (!path)
+                return undefined;
+            return pathIdMap[path.id];
+        })
+            .filter((id) => Boolean(id));
+        const nextPathsById = {};
+        for (const oldPathId of sourceZone.pathIds) {
+            const oldPath = sourceZone.pathsById[oldPathId];
+            if (!oldPath)
+                continue;
+            const nextPathId = pathIdMap[oldPath.id];
+            let nextTarget = oldPath.target ?? null;
+            let nextMeta = oldPath.meta ? { ...oldPath.meta } : undefined;
+            if (nextTarget) {
+                const isSameSourceUniverse = nextTarget.universeId === sourceModel.universeId;
+                const isInternalTarget = Boolean(zoneIdMap[nextTarget.zoneId]);
+                // source subtree 내부 참조면 새 ID로 교체
+                if (isSameSourceUniverse && isInternalTarget) {
+                    nextTarget = {
+                        universeId: targetModel.universeId,
+                        zoneId: zoneIdMap[nextTarget.zoneId],
+                    };
+                }
+                else {
+                    // 외부 참조 정책 적용
+                    if (externalTargetPolicy === "drop") {
+                        nextTarget = null;
+                    }
+                    else if (externalTargetPolicy === "mark-unresolved") {
+                        nextMeta = {
+                            ...nextMeta,
+                            unresolvedTarget: true,
+                            originalTarget: oldPath.target,
+                        };
+                    }
+                    // preserve는 그대로 둠
+                }
+            }
+            nextPathsById[nextPathId] = {
+                ...oldPath,
+                id: nextPathId,
+                target: nextTarget,
+                meta: nextMeta,
+            };
+        }
+        importedZonesById[nextZoneId] = {
+            ...sourceZone,
+            id: nextZoneId,
+            parentZoneId: sourceZone.parentZoneId
+                ? zoneIdMap[sourceZone.parentZoneId] ?? null
+                : null,
+            childZoneIds: nextChildZoneIds,
+            pathIds: nextPathIds,
+            pathsById: nextPathsById,
+        };
+    }
+    const importedRootZoneId = zoneIdMap[sourceRootZoneId];
+    // 4) 가져온 루트 zone 이름/부모 수정
+    importedZonesById[importedRootZoneId] = {
+        ...importedZonesById[importedRootZoneId],
+        parentZoneId: nextParentZoneId,
+        name: rename(sourceRootZone.name),
+    };
+    // 5) targetModel에 병합
+    const nextZonesById = {
+        ...targetModel.zonesById,
+        ...importedZonesById,
+    };
+    let nextRootZoneIds = [...targetModel.rootZoneIds];
+    if (nextParentZoneId === null) {
+        nextRootZoneIds.push(importedRootZoneId);
+    }
+    else {
+        const parent = nextZonesById[nextParentZoneId];
+        if (parent) {
+            nextZonesById[nextParentZoneId] = {
+                ...parent,
+                childZoneIds: [...parent.childZoneIds, importedRootZoneId],
+            };
+        }
+    }
+    return {
+        model: {
+            ...targetModel,
+            rootZoneIds: nextRootZoneIds,
+            zonesById: nextZonesById,
+        },
+        importedRootZoneId,
+        zoneIdMap,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types";
+export * from "./zoneCapabilities";
+export * from "./lookup";
+export * from "./path";
+export * from "./hierarchy";
+export * from "./traversal";
+export * from "./validation";
+export * from "./mutation";
+export * from "./layout";
+export * from "./ids";
+export * from "./remap";
+export * from "./clone";
+export * from "./import";
+export * from "./wrap";
+export * from "./unwrap";

package/dist/index.js

@@ -0,0 +1,15 @@
+export * from "./types";
+export * from "./zoneCapabilities";
+export * from "./lookup";
+export * from "./path";
+export * from "./hierarchy";
+export * from "./traversal";
+export * from "./validation";
+export * from "./mutation";
+export * from "./layout";
+export * from "./ids";
+export * from "./remap";
+export * from "./clone";
+export * from "./import";
+export * from "./wrap";
+export * from "./unwrap";

package/dist/layout.d.ts

@@ -0,0 +1,39 @@
+import type { Layout, PathId, PathLayout, UniverseId, UniverseLayoutModel, UniverseModel, ZoneId, ZoneLayout } from "./types";
+export type CreateUniverseLayoutModelInput = {
+    universeId: UniverseId;
+    version?: string;
+    zoneLayoutsById?: Record<ZoneId, ZoneLayout>;
+    pathLayoutsById?: Record<PathId, PathLayout>;
+    meta?: Record<string, unknown>;
+};
+export declare function createUniverseLayoutModel(input: CreateUniverseLayoutModelInput): UniverseLayoutModel;
+export declare function createZoneLayout(input: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): ZoneLayout;
+export declare function getZoneLayout(layoutModel: UniverseLayoutModel, zoneId: ZoneId): ZoneLayout | undefined;
+export declare function setZoneLayout(layoutModel: UniverseLayoutModel, zoneId: ZoneId, layout: ZoneLayout | undefined): UniverseLayoutModel;
+export declare function updateZoneLayout(layoutModel: UniverseLayoutModel, zoneId: ZoneId, patch: Partial<ZoneLayout>): UniverseLayoutModel;
+export declare function getPathLayout(layoutModel: UniverseLayoutModel, pathId: PathId): PathLayout | undefined;
+export declare function setPathLayout(layoutModel: UniverseLayoutModel, pathId: PathId, layout: PathLayout | undefined): UniverseLayoutModel;
+export declare function updatePathLayout(layoutModel: UniverseLayoutModel, pathId: PathId, patch: Partial<PathLayout>): UniverseLayoutModel;
+export declare function getPathComponentLayout(layoutModel: UniverseLayoutModel, pathId: PathId, componentId: string): Layout | undefined;
+export declare function setPathComponentLayout(layoutModel: UniverseLayoutModel, pathId: PathId, componentId: string, layout: Layout | undefined): UniverseLayoutModel;
+export declare function updatePathComponentLayout(layoutModel: UniverseLayoutModel, pathId: PathId, componentId: string, patch: Partial<Layout>): UniverseLayoutModel;
+export declare function removeZoneLayouts(layoutModel: UniverseLayoutModel, zoneIds: ZoneId[]): UniverseLayoutModel;
+export declare function removePathLayouts(layoutModel: UniverseLayoutModel, pathIds: PathId[]): UniverseLayoutModel;
+export declare function pruneLayoutModel(model: UniverseModel, layoutModel: UniverseLayoutModel): UniverseLayoutModel;
+export declare function computeAutoLayoutForZoneTree(model: UniverseModel, layoutModel: UniverseLayoutModel, zoneId: ZoneId, options?: {
+    paddingX?: number;
+    paddingY?: number;
+    verticalGap?: number;
+    defaultWidth?: number;
+    defaultHeight?: number;
+}): ZoneLayout | undefined;
+export declare function computeWrapperLayoutFromChildren(model: UniverseModel, layoutModel: UniverseLayoutModel, zoneIds: ZoneId[], options?: {
+    padding?: number;
+    minWidth?: number;
+    minHeight?: number;
+}): ZoneLayout | undefined;

package/dist/layout.js

@@ -0,0 +1,279 @@
+function createDefaultAnchors() {
+    return {
+        inlet: {
+            point: { x: 0, y: 0 },
+        },
+        outlet: {
+            point: { x: 0, y: 0 },
+        },
+    };
+}
+function cloneAnchor(anchor) {
+    return {
+        point: {
+            x: anchor?.point.x ?? 0,
+            y: anchor?.point.y ?? 0,
+        },
+        rect: anchor?.rect ? { ...anchor.rect } : undefined,
+    };
+}
+function cloneAnchors(anchors) {
+    return {
+        inlet: cloneAnchor(anchors?.inlet),
+        outlet: cloneAnchor(anchors?.outlet),
+    };
+}
+function mergeAnchor(current, patch) {
+    return {
+        point: {
+            x: patch?.point?.x ?? current?.point.x ?? 0,
+            y: patch?.point?.y ?? current?.point.y ?? 0,
+        },
+        rect: patch?.rect !== undefined
+            ? patch.rect
+                ? { ...patch.rect }
+                : undefined
+            : current?.rect
+                ? { ...current.rect }
+                : undefined,
+    };
+}
+function mergeAnchors(current, patch) {
+    return {
+        inlet: mergeAnchor(current?.inlet, patch?.inlet),
+        outlet: mergeAnchor(current?.outlet, patch?.outlet),
+    };
+}
+export function createUniverseLayoutModel(input) {
+    return {
+        version: input.version ?? "1.0.0",
+        universeId: input.universeId,
+        zoneLayoutsById: input.zoneLayoutsById ? { ...input.zoneLayoutsById } : {},
+        pathLayoutsById: input.pathLayoutsById ? { ...input.pathLayoutsById } : {},
+        meta: input.meta ? { ...input.meta } : undefined,
+    };
+}
+export function createZoneLayout(input) {
+    const { x, y, width, height } = input;
+    return {
+        x,
+        y,
+        width,
+        height,
+        anchors: {
+            inlet: {
+                point: {
+                    x: 0,
+                    y: height / 2,
+                },
+            },
+            outlet: {
+                point: {
+                    x: width,
+                    y: height / 2,
+                },
+            },
+        },
+    };
+}
+export function getZoneLayout(layoutModel, zoneId) {
+    return layoutModel.zoneLayoutsById[zoneId];
+}
+export function setZoneLayout(layoutModel, zoneId, layout) {
+    const nextZoneLayoutsById = { ...layoutModel.zoneLayoutsById };
+    if (layout) {
+        nextZoneLayoutsById[zoneId] = layout;
+    }
+    else {
+        delete nextZoneLayoutsById[zoneId];
+    }
+    return {
+        ...layoutModel,
+        zoneLayoutsById: nextZoneLayoutsById,
+    };
+}
+export function updateZoneLayout(layoutModel, zoneId, patch) {
+    const currentLayout = layoutModel.zoneLayoutsById[zoneId];
+    return setZoneLayout(layoutModel, zoneId, {
+        x: patch.x ?? currentLayout?.x ?? 0,
+        y: patch.y ?? currentLayout?.y ?? 0,
+        width: patch.width ?? currentLayout?.width,
+        height: patch.height ?? currentLayout?.height,
+        anchors: mergeAnchors(currentLayout?.anchors, patch.anchors),
+    });
+}
+export function getPathLayout(layoutModel, pathId) {
+    return layoutModel.pathLayoutsById[pathId];
+}
+export function setPathLayout(layoutModel, pathId, layout) {
+    const nextPathLayoutsById = { ...layoutModel.pathLayoutsById };
+    if (layout) {
+        nextPathLayoutsById[pathId] = layout;
+    }
+    else {
+        delete nextPathLayoutsById[pathId];
+    }
+    return {
+        ...layoutModel,
+        pathLayoutsById: nextPathLayoutsById,
+    };
+}
+export function updatePathLayout(layoutModel, pathId, patch) {
+    const currentLayout = layoutModel.pathLayoutsById[pathId];
+    return setPathLayout(layoutModel, pathId, {
+        ...currentLayout,
+        ...patch,
+        componentLayoutsById: patch.componentLayoutsById ??
+            currentLayout?.componentLayoutsById,
+    });
+}
+export function getPathComponentLayout(layoutModel, pathId, componentId) {
+    return layoutModel.pathLayoutsById[pathId]?.componentLayoutsById?.[componentId];
+}
+export function setPathComponentLayout(layoutModel, pathId, componentId, layout) {
+    const currentPathLayout = layoutModel.pathLayoutsById[pathId] ?? {};
+    const nextComponentLayoutsById = {
+        ...(currentPathLayout.componentLayoutsById ?? {}),
+    };
+    if (layout) {
+        nextComponentLayoutsById[componentId] = layout;
+    }
+    else {
+        delete nextComponentLayoutsById[componentId];
+    }
+    const hasComponents = Object.keys(nextComponentLayoutsById).length > 0;
+    const nextPathLayout = {
+        ...currentPathLayout,
+        componentLayoutsById: hasComponents
+            ? nextComponentLayoutsById
+            : undefined,
+    };
+    if (!nextPathLayout.routeOffset && !nextPathLayout.componentLayoutsById) {
+        return setPathLayout(layoutModel, pathId, undefined);
+    }
+    return setPathLayout(layoutModel, pathId, nextPathLayout);
+}
+export function updatePathComponentLayout(layoutModel, pathId, componentId, patch) {
+    const currentLayout = layoutModel.pathLayoutsById[pathId]?.componentLayoutsById?.[componentId];
+    return setPathComponentLayout(layoutModel, pathId, componentId, {
+        x: patch.x ?? currentLayout?.x ?? 0,
+        y: patch.y ?? currentLayout?.y ?? 0,
+        width: patch.width ?? currentLayout?.width,
+        height: patch.height ?? currentLayout?.height,
+    });
+}
+export function removeZoneLayouts(layoutModel, zoneIds) {
+    if (zoneIds.length === 0)
+        return layoutModel;
+    const zoneIdSet = new Set(zoneIds);
+    const nextZoneLayoutsById = {};
+    for (const [zoneId, layout] of Object.entries(layoutModel.zoneLayoutsById)) {
+        if (!zoneIdSet.has(zoneId)) {
+            nextZoneLayoutsById[zoneId] = layout;
+        }
+    }
+    return {
+        ...layoutModel,
+        zoneLayoutsById: nextZoneLayoutsById,
+    };
+}
+export function removePathLayouts(layoutModel, pathIds) {
+    if (pathIds.length === 0)
+        return layoutModel;
+    const pathIdSet = new Set(pathIds);
+    const nextPathLayoutsById = {};
+    for (const [pathId, layout] of Object.entries(layoutModel.pathLayoutsById)) {
+        if (!pathIdSet.has(pathId)) {
+            nextPathLayoutsById[pathId] = layout;
+        }
+    }
+    return {
+        ...layoutModel,
+        pathLayoutsById: nextPathLayoutsById,
+    };
+}
+export function pruneLayoutModel(model, layoutModel) {
+    const zoneIds = new Set(Object.keys(model.zonesById));
+    const pathIds = new Set();
+    for (const zone of Object.values(model.zonesById)) {
+        for (const pathId of zone.pathIds) {
+            const path = zone.pathsById[pathId];
+            if (path) {
+                pathIds.add(path.id);
+            }
+        }
+    }
+    const nextZoneLayoutsById = {};
+    for (const [zoneId, layout] of Object.entries(layoutModel.zoneLayoutsById)) {
+        if (zoneIds.has(zoneId)) {
+            nextZoneLayoutsById[zoneId] = layout;
+        }
+    }
+    const nextPathLayoutsById = {};
+    for (const [pathId, layout] of Object.entries(layoutModel.pathLayoutsById)) {
+        if (pathIds.has(pathId)) {
+            nextPathLayoutsById[pathId] = layout;
+        }
+    }
+    return {
+        ...layoutModel,
+        universeId: model.universeId,
+        zoneLayoutsById: nextZoneLayoutsById,
+        pathLayoutsById: nextPathLayoutsById,
+    };
+}
+export function computeAutoLayoutForZoneTree(model, layoutModel, zoneId, options = {}) {
+    const { paddingX = 32, paddingY = 24, verticalGap = 24, defaultWidth = 160, defaultHeight = 100, } = options;
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return undefined;
+    const ownLayout = layoutModel.zoneLayoutsById[zone.id];
+    const childLayouts = zone.childZoneIds
+        .map((childId) => computeAutoLayoutForZoneTree(model, layoutModel, childId, options))
+        .filter((layout) => Boolean(layout));
+    const ownWidth = ownLayout?.width ?? defaultWidth;
+    const ownHeight = ownLayout?.height ?? defaultHeight;
+    if (childLayouts.length === 0) {
+        return {
+            x: ownLayout?.x ?? 0,
+            y: ownLayout?.y ?? 0,
+            width: ownWidth,
+            height: ownHeight,
+            anchors: cloneAnchors(ownLayout?.anchors),
+        };
+    }
+    const minChildX = Math.min(...childLayouts.map((layout) => layout.x));
+    const minChildY = Math.min(...childLayouts.map((layout) => layout.y));
+    const maxChildX = Math.max(...childLayouts.map((layout) => layout.x + (layout.width ?? defaultWidth)));
+    const maxChildY = Math.max(...childLayouts.map((layout) => layout.y + (layout.height ?? defaultHeight)));
+    return {
+        x: ownLayout?.x ?? minChildX - paddingX,
+        y: ownLayout?.y ?? minChildY - (ownHeight + verticalGap / 2),
+        width: Math.max(maxChildX - minChildX + paddingX * 2, ownWidth),
+        height: Math.max(ownHeight + verticalGap + (maxChildY - minChildY) + paddingY * 2, ownHeight),
+        anchors: cloneAnchors(ownLayout?.anchors),
+    };
+}
+export function computeWrapperLayoutFromChildren(model, layoutModel, zoneIds, options = {}) {
+    const { padding = 32, minWidth = 160, minHeight = 120 } = options;
+    const layouts = zoneIds
+        .map((zoneId) => {
+        if (!model.zonesById[zoneId])
+            return undefined;
+        return layoutModel.zoneLayoutsById[zoneId];
+    })
+        .filter((layout) => Boolean(layout));
+    if (layouts.length === 0)
+        return undefined;
+    const minX = Math.min(...layouts.map((layout) => layout.x));
+    const minY = Math.min(...layouts.map((layout) => layout.y));
+    const maxX = Math.max(...layouts.map((layout) => layout.x + (layout.width ?? 0)));
+    const maxY = Math.max(...layouts.map((layout) => layout.y + (layout.height ?? 0)));
+    return {
+        x: minX - padding,
+        y: minY - padding,
+        width: Math.max(maxX - minX + padding * 2, minWidth),
+        height: Math.max(maxY - minY + padding * 2, minHeight),
+        anchors: createDefaultAnchors(),
+    };
+}

package/dist/lookup.d.ts

@@ -0,0 +1,10 @@
+import type { UniverseModel, Zone, ZoneId, Path, PathId } from "./types";
+export declare function getZone(model: UniverseModel, zoneId: ZoneId): Zone | undefined;
+export declare function getRootZones(model: UniverseModel): Zone[];
+export declare function getChildZones(model: UniverseModel, zoneId: ZoneId): Zone[];
+export declare function getParentZone(model: UniverseModel, zoneId: ZoneId): Zone | undefined;
+export declare function getPath(zone: Zone, pathId: PathId): Path | undefined;
+export declare function getPaths(zone: Zone): Path[];
+export declare function getPathByKey(zone: Zone, key: string): Path | undefined;
+export declare function findPathSourceZoneId(model: UniverseModel, pathId: PathId): ZoneId | undefined;
+export declare function findPathSourceZone(model: UniverseModel, pathId: PathId): Zone | undefined;

package/dist/lookup.js

@@ -0,0 +1,44 @@
+export function getZone(model, zoneId) {
+    return model.zonesById[zoneId];
+}
+export function getRootZones(model) {
+    return model.rootZoneIds
+        .map((id) => model.zonesById[id])
+        .filter((zone) => Boolean(zone));
+}
+export function getChildZones(model, zoneId) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return [];
+    return zone.childZoneIds
+        .map((id) => model.zonesById[id])
+        .filter((child) => Boolean(child));
+}
+export function getParentZone(model, zoneId) {
+    const zone = model.zonesById[zoneId];
+    if (!zone?.parentZoneId)
+        return undefined;
+    return model.zonesById[zone.parentZoneId];
+}
+export function getPath(zone, pathId) {
+    return zone.pathsById[pathId];
+}
+export function getPaths(zone) {
+    return zone.pathIds
+        .map((id) => zone.pathsById[id])
+        .filter((path) => Boolean(path));
+}
+export function getPathByKey(zone, key) {
+    return getPaths(zone).find((path) => path.key === key);
+}
+export function findPathSourceZoneId(model, pathId) {
+    for (const zone of Object.values(model.zonesById)) {
+        if (zone.pathsById[pathId])
+            return zone.id;
+    }
+    return undefined;
+}
+export function findPathSourceZone(model, pathId) {
+    const zoneId = findPathSourceZoneId(model, pathId);
+    return zoneId ? model.zonesById[zoneId] : undefined;
+}