@zoneflow/core 0.0.1

package/dist/mutation.d.ts

@@ -0,0 +1,29 @@
+import type { UniverseModel, Zone, ZoneAction, ZoneId, ZoneType, Path, PathId, ZoneRef } from "./types";
+export type CreateZoneInput = {
+    id: ZoneId;
+    name: string;
+    parentZoneId?: ZoneId | null;
+    zoneType?: ZoneType;
+    inputDisabled?: boolean;
+    outputDisabled?: boolean;
+    action?: ZoneAction;
+    meta?: Record<string, unknown>;
+};
+export type CreatePathInput = {
+    id: PathId;
+    key: string;
+    name: string;
+    target?: ZoneRef | null;
+    rule: Path["rule"];
+    meta?: Record<string, unknown>;
+};
+export declare function createZone(model: UniverseModel, input: CreateZoneInput): UniverseModel;
+export declare function updateZone(model: UniverseModel, zoneId: ZoneId, patch: Partial<Omit<Zone, "id">>): UniverseModel;
+export declare function moveZone(model: UniverseModel, zoneId: ZoneId, nextParentZoneId: ZoneId | null): UniverseModel;
+export declare function collectSubtreeZoneIds(model: UniverseModel, zoneId: ZoneId): ZoneId[];
+export declare function removeZone(model: UniverseModel, zoneId: ZoneId): UniverseModel;
+export declare function addPath(model: UniverseModel, zoneId: ZoneId, input: CreatePathInput): UniverseModel;
+export declare function updatePath(model: UniverseModel, zoneId: ZoneId, pathId: PathId, patch: Partial<Path>): UniverseModel;
+export declare function removePath(model: UniverseModel, zoneId: ZoneId, pathId: PathId): UniverseModel;
+export declare function setPathTarget(model: UniverseModel, zoneId: ZoneId, pathId: PathId, target: ZoneRef | null): UniverseModel;
+export declare function reorderPaths(model: UniverseModel, zoneId: ZoneId, nextPathIds: PathId[]): UniverseModel;

package/dist/mutation.js

@@ -0,0 +1,251 @@
+export function createZone(model, input) {
+    const { id, name, parentZoneId = null, zoneType = "container", inputDisabled, outputDisabled, action, meta, } = input;
+    if (model.zonesById[id])
+        return model;
+    const newZone = {
+        id,
+        parentZoneId,
+        name,
+        zoneType,
+        inputDisabled,
+        outputDisabled,
+        childZoneIds: [],
+        pathIds: [],
+        pathsById: {},
+        action,
+        meta,
+    };
+    const nextZonesById = {
+        ...model.zonesById,
+        [id]: newZone,
+    };
+    if (parentZoneId === null) {
+        return {
+            ...model,
+            rootZoneIds: [...model.rootZoneIds, id],
+            zonesById: nextZonesById,
+        };
+    }
+    const parent = model.zonesById[parentZoneId];
+    if (!parent)
+        return model;
+    return {
+        ...model,
+        zonesById: {
+            ...nextZonesById,
+            [parentZoneId]: {
+                ...parent,
+                childZoneIds: [...parent.childZoneIds, id],
+            },
+        },
+    };
+}
+export function updateZone(model, zoneId, patch) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    return {
+        ...model,
+        zonesById: {
+            ...model.zonesById,
+            [zoneId]: {
+                ...zone,
+                ...patch,
+            },
+        },
+    };
+}
+export function moveZone(model, zoneId, nextParentZoneId) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    const prevParentZoneId = zone.parentZoneId;
+    if (prevParentZoneId === nextParentZoneId)
+        return model;
+    let nextModel = model;
+    if (prevParentZoneId !== null) {
+        const prevParent = nextModel.zonesById[prevParentZoneId];
+        if (prevParent) {
+            nextModel = {
+                ...nextModel,
+                zonesById: {
+                    ...nextModel.zonesById,
+                    [prevParentZoneId]: {
+                        ...prevParent,
+                        childZoneIds: prevParent.childZoneIds.filter((id) => id !== zoneId),
+                    },
+                },
+            };
+        }
+    }
+    else {
+        nextModel = {
+            ...nextModel,
+            rootZoneIds: nextModel.rootZoneIds.filter((id) => id !== zoneId),
+        };
+    }
+    if (nextParentZoneId !== null) {
+        const nextParent = nextModel.zonesById[nextParentZoneId];
+        if (!nextParent)
+            return model;
+        nextModel = {
+            ...nextModel,
+            zonesById: {
+                ...nextModel.zonesById,
+                [nextParentZoneId]: {
+                    ...nextParent,
+                    childZoneIds: [...nextParent.childZoneIds, zoneId],
+                },
+            },
+        };
+    }
+    else {
+        nextModel = {
+            ...nextModel,
+            rootZoneIds: [...nextModel.rootZoneIds, zoneId],
+        };
+    }
+    return {
+        ...nextModel,
+        zonesById: {
+            ...nextModel.zonesById,
+            [zoneId]: {
+                ...nextModel.zonesById[zoneId],
+                parentZoneId: nextParentZoneId,
+            },
+        },
+    };
+}
+export function collectSubtreeZoneIds(model, zoneId) {
+    const result = [];
+    const stack = [zoneId];
+    while (stack.length > 0) {
+        const currentId = stack.pop();
+        const current = model.zonesById[currentId];
+        if (!current)
+            continue;
+        result.push(currentId);
+        stack.push(...current.childZoneIds);
+    }
+    return result;
+}
+export function removeZone(model, zoneId) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    const zoneIdsToDelete = collectSubtreeZoneIds(model, zoneId);
+    const nextZonesById = { ...model.zonesById };
+    for (const id of zoneIdsToDelete) {
+        delete nextZonesById[id];
+    }
+    const nextRootZoneIds = model.rootZoneIds.filter((id) => !zoneIdsToDelete.includes(id));
+    if (zone.parentZoneId && nextZonesById[zone.parentZoneId]) {
+        nextZonesById[zone.parentZoneId] = {
+            ...nextZonesById[zone.parentZoneId],
+            childZoneIds: nextZonesById[zone.parentZoneId].childZoneIds.filter((id) => id !== zoneId),
+        };
+    }
+    return {
+        ...model,
+        rootZoneIds: nextRootZoneIds,
+        zonesById: nextZonesById,
+    };
+}
+export function addPath(model, zoneId, input) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    if (zone.pathsById[input.id])
+        return model;
+    const newPath = {
+        id: input.id,
+        key: input.key,
+        name: input.name,
+        target: input.target,
+        rule: input.rule ?? null,
+        meta: input.meta,
+    };
+    return {
+        ...model,
+        zonesById: {
+            ...model.zonesById,
+            [zoneId]: {
+                ...zone,
+                pathIds: [...zone.pathIds, input.id],
+                pathsById: {
+                    ...zone.pathsById,
+                    [input.id]: newPath,
+                },
+            },
+        },
+    };
+}
+export function updatePath(model, zoneId, pathId, patch) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    const path = zone.pathsById[pathId];
+    if (!path)
+        return model;
+    return {
+        ...model,
+        zonesById: {
+            ...model.zonesById,
+            [zoneId]: {
+                ...zone,
+                pathsById: {
+                    ...zone.pathsById,
+                    [pathId]: {
+                        ...path,
+                        ...patch,
+                        rule: Object.prototype.hasOwnProperty.call(patch, "rule")
+                            ? (patch.rule ?? null)
+                            : path.rule,
+                    },
+                },
+            },
+        },
+    };
+}
+export function removePath(model, zoneId, pathId) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    if (!zone.pathsById[pathId])
+        return model;
+    const nextPathsById = { ...zone.pathsById };
+    delete nextPathsById[pathId];
+    return {
+        ...model,
+        zonesById: {
+            ...model.zonesById,
+            [zoneId]: {
+                ...zone,
+                pathIds: zone.pathIds.filter((id) => id !== pathId),
+                pathsById: nextPathsById,
+            },
+        },
+    };
+}
+export function setPathTarget(model, zoneId, pathId, target) {
+    return updatePath(model, zoneId, pathId, { target });
+}
+export function reorderPaths(model, zoneId, nextPathIds) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return model;
+    const sameLength = zone.pathIds.length === nextPathIds.length;
+    const allExist = nextPathIds.every((id) => Boolean(zone.pathsById[id]));
+    if (!sameLength || !allExist)
+        return model;
+    return {
+        ...model,
+        zonesById: {
+            ...model.zonesById,
+            [zoneId]: {
+                ...zone,
+                pathIds: [...nextPathIds],
+            },
+        },
+    };
+}

package/dist/path.d.ts

@@ -0,0 +1,4 @@
+import type { UniverseModel, Path, Zone, ZoneId } from "./types";
+export declare function resolvePathTarget(model: UniverseModel, path: Path): Zone | undefined;
+export declare function getOutgoingZones(model: UniverseModel, zoneId: ZoneId): Zone[];
+export declare function getIncomingPaths(model: UniverseModel, zoneId: ZoneId): Path[];

package/dist/path.js

@@ -0,0 +1,29 @@
+import { getPaths } from "./lookup";
+export function resolvePathTarget(model, path) {
+    if (!path.target)
+        return undefined;
+    if (path.target.universeId !== model.universeId)
+        return undefined;
+    return model.zonesById[path.target.zoneId];
+}
+export function getOutgoingZones(model, zoneId) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return [];
+    return getPaths(zone)
+        .map((path) => resolvePathTarget(model, path))
+        .filter((target) => Boolean(target));
+}
+export function getIncomingPaths(model, zoneId) {
+    const result = [];
+    for (const zone of Object.values(model.zonesById)) {
+        for (const path of getPaths(zone)) {
+            if (path.target &&
+                path.target.universeId === model.universeId &&
+                path.target.zoneId === zoneId) {
+                result.push(path);
+            }
+        }
+    }
+    return result;
+}

package/dist/remap.d.ts

@@ -0,0 +1,8 @@
+import type { UniverseModel, Zone, ZoneId, PathId } from "./types";
+export type RemapResult = {
+    zonesById: Record<ZoneId, Zone>;
+    rootZoneIds: ZoneId[];
+    zoneIdMap: Record<ZoneId, ZoneId>;
+    pathIdMap: Record<PathId, PathId>;
+};
+export declare function remapSubtreeIds(model: UniverseModel, sourceRootZoneId: ZoneId): RemapResult;

package/dist/remap.js

@@ -0,0 +1,72 @@
+import { createPathId, createZoneId } from "./ids";
+import { flattenSubtree } from "./traversal";
+export function remapSubtreeIds(model, sourceRootZoneId) {
+    const sourceZones = flattenSubtree(model, 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 nextZonesById = {};
+    for (const zone of sourceZones) {
+        const nextZoneId = zoneIdMap[zone.id];
+        const nextChildZoneIds = zone.childZoneIds
+            .map((childId) => zoneIdMap[childId])
+            .filter((id) => Boolean(id));
+        const nextPathIds = zone.pathIds
+            .map((pathId) => {
+            const path = zone.pathsById[pathId];
+            if (!path)
+                return undefined;
+            return pathIdMap[path.id];
+        })
+            .filter((id) => Boolean(id));
+        const nextPathsById = {};
+        for (const oldPathId of zone.pathIds) {
+            const oldPath = zone.pathsById[oldPathId];
+            if (!oldPath)
+                continue;
+            const nextPathId = pathIdMap[oldPath.id];
+            let nextTarget = oldPath.target ?? null;
+            // 내부 참조면 zoneId 재작성
+            if (nextTarget &&
+                nextTarget.universeId === model.universeId &&
+                zoneIdMap[nextTarget.zoneId]) {
+                nextTarget = {
+                    ...nextTarget,
+                    zoneId: zoneIdMap[nextTarget.zoneId],
+                };
+            }
+            nextPathsById[nextPathId] = {
+                ...oldPath,
+                id: nextPathId,
+                target: nextTarget,
+            };
+        }
+        nextZonesById[nextZoneId] = {
+            ...zone,
+            id: nextZoneId,
+            parentZoneId: zone.parentZoneId ? zoneIdMap[zone.parentZoneId] ?? null : null,
+            childZoneIds: nextChildZoneIds,
+            pathIds: nextPathIds,
+            pathsById: nextPathsById,
+        };
+    }
+    return {
+        zonesById: nextZonesById,
+        rootZoneIds: [zoneIdMap[sourceRootZoneId]],
+        zoneIdMap,
+        pathIdMap,
+    };
+}

package/dist/traversal.d.ts

@@ -0,0 +1,3 @@
+import type { UniverseModel, Zone, ZoneId } from "./types";
+export declare function walkZonesDepthFirst(model: UniverseModel, zoneId: ZoneId, visit: (zone: Zone) => void): void;
+export declare function flattenSubtree(model: UniverseModel, zoneId: ZoneId): Zone[];

package/dist/traversal.js

@@ -0,0 +1,16 @@
+export function walkZonesDepthFirst(model, zoneId, visit) {
+    const zone = model.zonesById[zoneId];
+    if (!zone)
+        return;
+    visit(zone);
+    for (const childId of zone.childZoneIds) {
+        walkZonesDepthFirst(model, childId, visit);
+    }
+}
+export function flattenSubtree(model, zoneId) {
+    const result = [];
+    walkZonesDepthFirst(model, zoneId, (zone) => {
+        result.push(zone);
+    });
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,76 @@
+export type UniverseId = string;
+export type ZoneId = string;
+export type PathId = string;
+export type ZoneType = "container" | "action" | string;
+export type Layout = {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export type AnchorRect = Layout;
+export type AnchorLayout = {
+    point: Point;
+    rect?: AnchorRect;
+};
+export type ZoneLayout = Layout & {
+    anchors: {
+        inlet: AnchorLayout;
+        outlet: AnchorLayout;
+    };
+};
+export type PathLayout = {
+    routeOffset?: Point;
+    componentLayoutsById?: Record<string, Layout>;
+};
+export type ZoneAction = {
+    type: string;
+    payload?: Record<string, unknown>;
+};
+export type PathRule = {
+    type: string;
+    payload?: Record<string, unknown>;
+};
+export type ZoneRef = {
+    universeId: UniverseId;
+    zoneId: ZoneId;
+};
+export type Path = {
+    id: PathId;
+    key: string;
+    name: string;
+    target?: ZoneRef | null;
+    rule: PathRule | null;
+    meta?: Record<string, unknown>;
+};
+export type Zone = {
+    id: ZoneId;
+    parentZoneId: ZoneId | null;
+    name: string;
+    zoneType: ZoneType;
+    inputDisabled?: boolean;
+    outputDisabled?: boolean;
+    childZoneIds: ZoneId[];
+    action?: ZoneAction;
+    pathIds: PathId[];
+    pathsById: Record<PathId, Path>;
+    meta?: Record<string, unknown>;
+};
+export type UniverseModel = {
+    version: string;
+    universeId: UniverseId;
+    rootZoneIds: ZoneId[];
+    zonesById: Record<ZoneId, Zone>;
+    meta?: Record<string, unknown>;
+};
+export type UniverseLayoutModel = {
+    version: string;
+    universeId: UniverseId;
+    zoneLayoutsById: Record<ZoneId, ZoneLayout>;
+    pathLayoutsById: Record<PathId, PathLayout>;
+    meta?: Record<string, unknown>;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/unwrap.d.ts

@@ -0,0 +1,12 @@
+import type { UniverseModel, ZoneId } from "./types";
+export type UnwrapZoneResult = {
+    model: UniverseModel;
+    unwrappedZoneId: ZoneId;
+    movedChildZoneIds: ZoneId[];
+};
+export type CanUnwrapZoneResult = {
+    ok: boolean;
+    reason?: "MISSING_ZONE" | "HAS_NO_CHILDREN" | "MISSING_PARENT" | "ROOT_WITHOUT_CHILDREN";
+};
+export declare function canUnwrapZone(model: UniverseModel, zoneId: ZoneId): CanUnwrapZoneResult;
+export declare function unwrapZone(model: UniverseModel, zoneId: ZoneId): UnwrapZoneResult;

package/dist/unwrap.js

@@ -0,0 +1,81 @@
+import { getParentZone, getZone } from "./lookup";
+export function canUnwrapZone(model, zoneId) {
+    const zone = getZone(model, zoneId);
+    if (!zone) {
+        return { ok: false, reason: "MISSING_ZONE" };
+    }
+    if (zone.childZoneIds.length === 0) {
+        return {
+            ok: false,
+            reason: zone.parentZoneId === null ? "ROOT_WITHOUT_CHILDREN" : "HAS_NO_CHILDREN",
+        };
+    }
+    if (zone.parentZoneId !== null && !getParentZone(model, zoneId)) {
+        return { ok: false, reason: "MISSING_PARENT" };
+    }
+    return { ok: true };
+}
+export function unwrapZone(model, zoneId) {
+    const canUnwrap = canUnwrapZone(model, zoneId);
+    if (!canUnwrap.ok) {
+        return {
+            model,
+            unwrappedZoneId: zoneId,
+            movedChildZoneIds: [],
+        };
+    }
+    const zone = getZone(model, zoneId);
+    const parentZoneId = zone.parentZoneId;
+    const movedChildZoneIds = [...zone.childZoneIds];
+    let nextZonesById = { ...model.zonesById };
+    let nextRootZoneIds = [...model.rootZoneIds];
+    // 1) 자식들의 parent를 wrapper의 parent로 변경
+    for (const childZoneId of movedChildZoneIds) {
+        const child = nextZonesById[childZoneId];
+        if (!child)
+            continue;
+        nextZonesById[childZoneId] = {
+            ...child,
+            parentZoneId,
+        };
+    }
+    // 2) 부모가 있으면 부모 childZoneIds에서 wrapper 제거하고 자식들 삽입
+    if (parentZoneId !== null) {
+        const parent = nextZonesById[parentZoneId];
+        if (parent) {
+            const wrapperIndex = parent.childZoneIds.indexOf(zoneId);
+            const before = wrapperIndex >= 0
+                ? parent.childZoneIds.slice(0, wrapperIndex)
+                : parent.childZoneIds;
+            const after = wrapperIndex >= 0
+                ? parent.childZoneIds.slice(wrapperIndex + 1)
+                : [];
+            nextZonesById[parentZoneId] = {
+                ...parent,
+                childZoneIds: [...before, ...movedChildZoneIds, ...after],
+            };
+        }
+    }
+    else {
+        // 3) 루트 wrapper면 rootZoneIds에서 wrapper 제거하고 자식들 삽입
+        const wrapperIndex = nextRootZoneIds.indexOf(zoneId);
+        const before = wrapperIndex >= 0
+            ? nextRootZoneIds.slice(0, wrapperIndex)
+            : nextRootZoneIds;
+        const after = wrapperIndex >= 0
+            ? nextRootZoneIds.slice(wrapperIndex + 1)
+            : [];
+        nextRootZoneIds = [...before, ...movedChildZoneIds, ...after];
+    }
+    // 4) wrapper 제거
+    delete nextZonesById[zoneId];
+    return {
+        model: {
+            ...model,
+            rootZoneIds: nextRootZoneIds,
+            zonesById: nextZonesById,
+        },
+        unwrappedZoneId: zoneId,
+        movedChildZoneIds,
+    };
+}

package/dist/validation.d.ts

@@ -0,0 +1,2 @@
+import type { UniverseModel } from "./types";
+export declare function validateUniverseModel(model: UniverseModel): string[];

package/dist/validation.js

@@ -0,0 +1,48 @@
+export function validateUniverseModel(model) {
+    const errors = [];
+    for (const rootId of model.rootZoneIds) {
+        if (!model.zonesById[rootId]) {
+            errors.push(`Root zone not found: ${rootId}`);
+        }
+    }
+    for (const zone of Object.values(model.zonesById)) {
+        if (zone.parentZoneId && !model.zonesById[zone.parentZoneId]) {
+            errors.push(`Zone "${zone.id}" has invalid parentZoneId "${zone.parentZoneId}"`);
+        }
+        for (const childId of zone.childZoneIds) {
+            if (!model.zonesById[childId]) {
+                errors.push(`Zone "${zone.id}" has invalid childZoneId "${childId}"`);
+            }
+        }
+        const seenPathIds = new Set();
+        const seenPathKeys = new Set();
+        for (const pathId of zone.pathIds) {
+            const path = zone.pathsById[pathId];
+            if (!path) {
+                errors.push(`Zone "${zone.id}" pathIds includes missing path "${pathId}"`);
+                continue;
+            }
+            if (seenPathIds.has(path.id)) {
+                errors.push(`Zone "${zone.id}" has duplicate path id "${path.id}"`);
+            }
+            seenPathIds.add(path.id);
+            if (seenPathKeys.has(path.key)) {
+                errors.push(`Zone "${zone.id}" has duplicate path key "${path.key}"`);
+            }
+            seenPathKeys.add(path.key);
+            if (path.target) {
+                if (path.target.universeId === model.universeId) {
+                    if (!model.zonesById[path.target.zoneId]) {
+                        errors.push(`Path "${path.id}" in zone "${zone.id}" points to missing zone "${path.target.zoneId}"`);
+                    }
+                }
+            }
+        }
+        for (const path of Object.values(zone.pathsById)) {
+            if (!zone.pathIds.includes(path.id)) {
+                errors.push(`Zone "${zone.id}" has path "${path.id}" in pathsById but not in pathIds`);
+            }
+        }
+    }
+    return errors;
+}

package/dist/wrap.d.ts

@@ -0,0 +1,19 @@
+import type { UniverseModel, ZoneAction, ZoneId, ZoneType } from "./types";
+export type CanWrapZonesResult = {
+    ok: boolean;
+    reason?: "EMPTY_SELECTION" | "DUPLICATE_IDS" | "MISSING_ZONE" | "DIFFERENT_PARENTS";
+};
+export type WrapZonesWithNewParentInput = {
+    zoneIds: ZoneId[];
+    name: string;
+    zoneType?: ZoneType;
+    action?: ZoneAction;
+    meta?: Record<string, unknown>;
+    newZoneId?: ZoneId;
+};
+export type WrapZonesWithNewParentResult = {
+    model: UniverseModel;
+    wrapperZoneId: ZoneId;
+};
+export declare function canWrapZones(model: UniverseModel, zoneIds: ZoneId[]): CanWrapZonesResult;
+export declare function wrapZonesWithNewParent(model: UniverseModel, input: WrapZonesWithNewParentInput): WrapZonesWithNewParentResult;