@zoneflow/core 0.0.1

package/dist/wrap.js

@@ -0,0 +1,103 @@
+import { createZoneId } from "./ids";
+export function canWrapZones(model, zoneIds) {
+    if (zoneIds.length === 0) {
+        return { ok: false, reason: "EMPTY_SELECTION" };
+    }
+    const uniqueZoneIds = new Set(zoneIds);
+    if (uniqueZoneIds.size !== zoneIds.length) {
+        return { ok: false, reason: "DUPLICATE_IDS" };
+    }
+    const zones = zoneIds.map((zoneId) => model.zonesById[zoneId]);
+    if (zones.some((zone) => !zone)) {
+        return { ok: false, reason: "MISSING_ZONE" };
+    }
+    const firstParentZoneId = zones[0].parentZoneId;
+    const sameParent = zones.every((zone) => zone.parentZoneId === firstParentZoneId);
+    if (!sameParent) {
+        return { ok: false, reason: "DIFFERENT_PARENTS" };
+    }
+    return { ok: true };
+}
+export function wrapZonesWithNewParent(model, input) {
+    const { zoneIds, name, zoneType = "container", action, meta, newZoneId = createZoneId(), } = input;
+    const check = canWrapZones(model, zoneIds);
+    if (!check.ok) {
+        return {
+            model,
+            wrapperZoneId: newZoneId,
+        };
+    }
+    const uniqueZoneIds = [...new Set(zoneIds)];
+    const firstZone = model.zonesById[uniqueZoneIds[0]];
+    const parentZoneId = firstZone.parentZoneId;
+    if (model.zonesById[newZoneId]) {
+        return {
+            model,
+            wrapperZoneId: newZoneId,
+        };
+    }
+    const wrapperZone = {
+        id: newZoneId,
+        parentZoneId,
+        name,
+        zoneType,
+        childZoneIds: [...uniqueZoneIds],
+        pathIds: [],
+        pathsById: {},
+        action,
+        meta,
+    };
+    let nextZonesById = {
+        ...model.zonesById,
+        [newZoneId]: wrapperZone,
+    };
+    for (const zoneId of uniqueZoneIds) {
+        const zone = nextZonesById[zoneId];
+        if (!zone)
+            continue;
+        nextZonesById[zoneId] = {
+            ...zone,
+            parentZoneId: newZoneId,
+        };
+    }
+    let nextRootZoneIds = [...model.rootZoneIds];
+    if (parentZoneId !== null) {
+        const parent = nextZonesById[parentZoneId];
+        if (parent) {
+            const selectedSet = new Set(uniqueZoneIds);
+            const originalChildren = parent.childZoneIds;
+            const firstSelectedIndex = originalChildren.findIndex((id) => selectedSet.has(id));
+            const remainingChildren = originalChildren.filter((id) => !selectedSet.has(id));
+            const insertIndex = firstSelectedIndex >= 0 ? firstSelectedIndex : remainingChildren.length;
+            const nextChildZoneIds = [
+                ...remainingChildren.slice(0, insertIndex),
+                newZoneId,
+                ...remainingChildren.slice(insertIndex),
+            ];
+            nextZonesById[parentZoneId] = {
+                ...parent,
+                childZoneIds: nextChildZoneIds,
+            };
+        }
+    }
+    else {
+        const selectedSet = new Set(uniqueZoneIds);
+        const originalRoots = model.rootZoneIds;
+        const firstSelectedIndex = originalRoots.findIndex((id) => selectedSet.has(id));
+        const remainingRoots = originalRoots.filter((id) => !selectedSet.has(id));
+        const insertIndex = firstSelectedIndex >= 0 ? firstSelectedIndex : remainingRoots.length;
+        nextRootZoneIds = [
+            ...remainingRoots.slice(0, insertIndex),
+            newZoneId,
+            ...remainingRoots.slice(insertIndex),
+        ];
+    }
+    return {
+        model: {
+            ...model,
+            rootZoneIds: nextRootZoneIds,
+            zonesById: nextZonesById,
+        },
+        wrapperZoneId: newZoneId,
+    };
+}

package/dist/zoneCapabilities.d.ts

@@ -0,0 +1,4 @@
+import type { Zone } from "./types";
+export declare function canZoneContainChildren(zone: Pick<Zone, "zoneType"> | null | undefined): boolean;
+export declare function isZoneInputEnabled(zone: Pick<Zone, "inputDisabled"> | null | undefined): boolean;
+export declare function isZoneOutputEnabled(zone: Pick<Zone, "outputDisabled"> | null | undefined): boolean;

package/dist/zoneCapabilities.js

@@ -0,0 +1,9 @@
+export function canZoneContainChildren(zone) {
+    return zone?.zoneType === "container";
+}
+export function isZoneInputEnabled(zone) {
+    return !zone?.inputDisabled;
+}
+export function isZoneOutputEnabled(zone) {
+    return !zone?.outputDisabled;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@zoneflow/core",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git@github-groobee:groobee/zoneflow.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "type-check": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "uuid": "^13.0.0"
+  }
+}