xcode-graph 0.1.0 → 0.2.0

package/dist/{assets/micro-layout.worker-CSeqAKhL.js → micro-layout.worker.js}

@@ -8,6 +8,8 @@
  */
 /**
  * Node role enum - determines positioning strategy within a cluster
+ *
+ * @public
  */
 var NodeRole;
 (function (NodeRole) {
@@ -20,6 +22,8 @@ var NodeRole;
 })(NodeRole || (NodeRole = {}));
 /**
  * Cluster type enum - distinguishes local projects from packages
+ *
+ * @public
  */
 var ClusterType;
 (function (ClusterType) {
@@ -28,6 +32,8 @@ var ClusterType;
 })(ClusterType || (ClusterType = {}));
 /**
  * ELK Hierarchy Handling strategy
+ *
+ * @public
  */
 var ElkHierarchyHandling;
 (function (ElkHierarchyHandling) {
@@ -35,12 +41,20 @@ var ElkHierarchyHandling;
     ElkHierarchyHandling["IncludeChildren"] = "INCLUDE_CHILDREN";
     ElkHierarchyHandling["SeparateChildren"] = "SEPARATE_CHILDREN";
 })(ElkHierarchyHandling || (ElkHierarchyHandling = {}));
-/** All node role values for iteration */
+/**
+ * All node role values for iteration
+ *
+ * @public
+ */
 Object.values(NodeRole);
-/** All cluster type values for iteration */
+/**
+ * All cluster type values for iteration
+ *
+ * @public
+ */
 Object.values(ClusterType);
 
-function center(x, y) {
+function forceCenter(x, y) {
   var nodes, strength = 1;
 
   if (x == null) x = 0;
@@ -1144,6 +1158,12 @@ function forceY(y) {
   return force;
 }
 
+/** Node count above which extra congestion padding is applied */
+const CONGESTION_THRESHOLD = 15;
+/** Per-node padding multiplier for clusters exceeding CONGESTION_THRESHOLD */
+const CONGESTION_FACTOR = 2.0;
+/** Base padding added to every cluster radius (pixels) */
+const BASE_MICRO_PADDING = 50;
 /**
  * Role order for dynamic band calculation (center to outside)
  */
@@ -1156,7 +1176,13 @@ const ROLE_ORDER = [
     NodeRole.Tool,
 ];
 /**
- * Compute micro-layout for a single cluster using "Solar System" physics
+ * Compute micro-layout for a single cluster using "Solar System" physics.
+ * Nodes are placed in concentric bands based on their role, with anchors at the center.
+ * Uses D3 force simulation with orbit, collision, center gravity, and charge forces.
+ *
+ * @param cluster - The cluster to compute interior layout for
+ * @param config - Layout configuration with force parameters
+ * @returns Micro layout result with cluster dimensions and relative node positions
  */
 function computeClusterInterior(cluster, config) {
     const nodes = cluster.nodes;
@@ -1199,8 +1225,8 @@ function computeClusterInterior(cluster, config) {
     const nodeSpace = config.nodeRadius * 2 + config.clusterNodeSpacing;
     const baseR = n ** 0.6 * nodeSpace * spacingFactor;
     // Add extra padding for large clusters
-    const congestionPadding = Math.max(0, n - 15) * 2.0;
-    const padding = 50 + congestionPadding;
+    const congestionPadding = Math.max(0, n - CONGESTION_THRESHOLD) * CONGESTION_FACTOR;
+    const padding = BASE_MICRO_PADDING + congestionPadding;
     const radius = Math.max(config.minClusterSize / 2, baseR + padding);
     const size = radius * 2;
     // 3. Initialize Simulation Nodes
@@ -1247,7 +1273,7 @@ function computeClusterInterior(cluster, config) {
         }
     })
         // C. Center Gravity (keep things coherent but loose)
-        .force('center', center(0, 0).strength(0.02))
+        .force('center', forceCenter(0, 0).strength(0.02))
         // D. Many Body (stronger repulsion to use available space)
         .force('charge', forceManyBody().strength(config.nodeCharge));
     // 5. Run Simulation
@@ -1283,8 +1309,12 @@ function computeClusterInterior(cluster, config) {
 
 /**
  * Apply a gentle force-directed "massage" to nodes within a cluster.
- * This runs after the main "Solar System" layout to improve spacing
- * and resolve any local congestions while preserving the overall structure.
+ * Runs after the main "Solar System" layout to improve spacing and resolve
+ * local congestions while preserving the overall band structure.
+ *
+ * @param micro - Micro layout result from `computeClusterInterior`
+ * @param config - Layout configuration with collision and charge parameters
+ * @returns Updated micro layout with refined node positions and possibly expanded dimensions
  */
 function applyNodeMassage(micro, config) {
     const nodes = Array.from(micro.relativePositions.values()).map((pos) => ({
@@ -1319,11 +1349,14 @@ function applyNodeMassage(micro, config) {
     let minX = Infinity, maxX = -Infinity;
     let minY = Infinity, maxY = -Infinity;
     for (const node of nodes) {
-        newPositions.set(node.id, {
-            ...micro.relativePositions.get(node.id),
-            x: node.x,
-            y: node.y,
-        });
+        const existingPos = micro.relativePositions.get(node.id);
+        if (existingPos) {
+            newPositions.set(node.id, {
+                ...existingPos,
+                x: node.x,
+                y: node.y,
+            });
+        }
         if (node.x < minX)
             minX = node.x;
         if (node.x > maxX)
@@ -1348,355 +1381,6 @@ function applyNodeMassage(micro, config) {
     };
 }
 
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-const proxyMarker = Symbol("Comlink.proxy");
-const createEndpoint = Symbol("Comlink.endpoint");
-const releaseProxy = Symbol("Comlink.releaseProxy");
-const finalizer = Symbol("Comlink.finalizer");
-const throwMarker = Symbol("Comlink.thrown");
-const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
-/**
- * Internal transfer handle to handle objects marked to proxy.
- */
-const proxyTransferHandler = {
-    canHandle: (val) => isObject(val) && val[proxyMarker],
-    serialize(obj) {
-        const { port1, port2 } = new MessageChannel();
-        expose(obj, port1);
-        return [port2, [port2]];
-    },
-    deserialize(port) {
-        port.start();
-        return wrap(port);
-    },
-};
-/**
- * Internal transfer handler to handle thrown exceptions.
- */
-const throwTransferHandler = {
-    canHandle: (value) => isObject(value) && throwMarker in value,
-    serialize({ value }) {
-        let serialized;
-        if (value instanceof Error) {
-            serialized = {
-                isError: true,
-                value: {
-                    message: value.message,
-                    name: value.name,
-                    stack: value.stack,
-                },
-            };
-        }
-        else {
-            serialized = { isError: false, value };
-        }
-        return [serialized, []];
-    },
-    deserialize(serialized) {
-        if (serialized.isError) {
-            throw Object.assign(new Error(serialized.value.message), serialized.value);
-        }
-        throw serialized.value;
-    },
-};
-/**
- * Allows customizing the serialization of certain values.
- */
-const transferHandlers = new Map([
-    ["proxy", proxyTransferHandler],
-    ["throw", throwTransferHandler],
-]);
-function isAllowedOrigin(allowedOrigins, origin) {
-    for (const allowedOrigin of allowedOrigins) {
-        if (origin === allowedOrigin || allowedOrigin === "*") {
-            return true;
-        }
-        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
-            return true;
-        }
-    }
-    return false;
-}
-function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
-    ep.addEventListener("message", function callback(ev) {
-        if (!ev || !ev.data) {
-            return;
-        }
-        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
-            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
-            return;
-        }
-        const { id, type, path } = Object.assign({ path: [] }, ev.data);
-        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-        let returnValue;
-        try {
-            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
-            const rawValue = path.reduce((obj, prop) => obj[prop], obj);
-            switch (type) {
-                case "GET" /* MessageType.GET */:
-                    {
-                        returnValue = rawValue;
-                    }
-                    break;
-                case "SET" /* MessageType.SET */:
-                    {
-                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
-                        returnValue = true;
-                    }
-                    break;
-                case "APPLY" /* MessageType.APPLY */:
-                    {
-                        returnValue = rawValue.apply(parent, argumentList);
-                    }
-                    break;
-                case "CONSTRUCT" /* MessageType.CONSTRUCT */:
-                    {
-                        const value = new rawValue(...argumentList);
-                        returnValue = proxy(value);
-                    }
-                    break;
-                case "ENDPOINT" /* MessageType.ENDPOINT */:
-                    {
-                        const { port1, port2 } = new MessageChannel();
-                        expose(obj, port2);
-                        returnValue = transfer(port1, [port1]);
-                    }
-                    break;
-                case "RELEASE" /* MessageType.RELEASE */:
-                    {
-                        returnValue = undefined;
-                    }
-                    break;
-                default:
-                    return;
-            }
-        }
-        catch (value) {
-            returnValue = { value, [throwMarker]: 0 };
-        }
-        Promise.resolve(returnValue)
-            .catch((value) => {
-            return { value, [throwMarker]: 0 };
-        })
-            .then((returnValue) => {
-            const [wireValue, transferables] = toWireValue(returnValue);
-            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-            if (type === "RELEASE" /* MessageType.RELEASE */) {
-                // detach and deactive after sending release response above.
-                ep.removeEventListener("message", callback);
-                closeEndPoint(ep);
-                if (finalizer in obj && typeof obj[finalizer] === "function") {
-                    obj[finalizer]();
-                }
-            }
-        })
-            .catch((error) => {
-            // Send Serialization Error To Caller
-            const [wireValue, transferables] = toWireValue({
-                value: new TypeError("Unserializable return value"),
-                [throwMarker]: 0,
-            });
-            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-        });
-    });
-    if (ep.start) {
-        ep.start();
-    }
-}
-function isMessagePort(endpoint) {
-    return endpoint.constructor.name === "MessagePort";
-}
-function closeEndPoint(endpoint) {
-    if (isMessagePort(endpoint))
-        endpoint.close();
-}
-function wrap(ep, target) {
-    const pendingListeners = new Map();
-    ep.addEventListener("message", function handleMessage(ev) {
-        const { data } = ev;
-        if (!data || !data.id) {
-            return;
-        }
-        const resolver = pendingListeners.get(data.id);
-        if (!resolver) {
-            return;
-        }
-        try {
-            resolver(data);
-        }
-        finally {
-            pendingListeners.delete(data.id);
-        }
-    });
-    return createProxy(ep, pendingListeners, [], target);
-}
-function throwIfProxyReleased(isReleased) {
-    if (isReleased) {
-        throw new Error("Proxy has been released and is not useable");
-    }
-}
-function releaseEndpoint(ep) {
-    return requestResponseMessage(ep, new Map(), {
-        type: "RELEASE" /* MessageType.RELEASE */,
-    }).then(() => {
-        closeEndPoint(ep);
-    });
-}
-const proxyCounter = new WeakMap();
-const proxyFinalizers = "FinalizationRegistry" in globalThis &&
-    new FinalizationRegistry((ep) => {
-        const newCount = (proxyCounter.get(ep) || 0) - 1;
-        proxyCounter.set(ep, newCount);
-        if (newCount === 0) {
-            releaseEndpoint(ep);
-        }
-    });
-function registerProxy(proxy, ep) {
-    const newCount = (proxyCounter.get(ep) || 0) + 1;
-    proxyCounter.set(ep, newCount);
-    if (proxyFinalizers) {
-        proxyFinalizers.register(proxy, ep, proxy);
-    }
-}
-function unregisterProxy(proxy) {
-    if (proxyFinalizers) {
-        proxyFinalizers.unregister(proxy);
-    }
-}
-function createProxy(ep, pendingListeners, path = [], target = function () { }) {
-    let isProxyReleased = false;
-    const proxy = new Proxy(target, {
-        get(_target, prop) {
-            throwIfProxyReleased(isProxyReleased);
-            if (prop === releaseProxy) {
-                return () => {
-                    unregisterProxy(proxy);
-                    releaseEndpoint(ep);
-                    pendingListeners.clear();
-                    isProxyReleased = true;
-                };
-            }
-            if (prop === "then") {
-                if (path.length === 0) {
-                    return { then: () => proxy };
-                }
-                const r = requestResponseMessage(ep, pendingListeners, {
-                    type: "GET" /* MessageType.GET */,
-                    path: path.map((p) => p.toString()),
-                }).then(fromWireValue);
-                return r.then.bind(r);
-            }
-            return createProxy(ep, pendingListeners, [...path, prop]);
-        },
-        set(_target, prop, rawValue) {
-            throwIfProxyReleased(isProxyReleased);
-            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
-            // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
-            const [value, transferables] = toWireValue(rawValue);
-            return requestResponseMessage(ep, pendingListeners, {
-                type: "SET" /* MessageType.SET */,
-                path: [...path, prop].map((p) => p.toString()),
-                value,
-            }, transferables).then(fromWireValue);
-        },
-        apply(_target, _thisArg, rawArgumentList) {
-            throwIfProxyReleased(isProxyReleased);
-            const last = path[path.length - 1];
-            if (last === createEndpoint) {
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "ENDPOINT" /* MessageType.ENDPOINT */,
-                }).then(fromWireValue);
-            }
-            // We just pretend that `bind()` didn’t happen.
-            if (last === "bind") {
-                return createProxy(ep, pendingListeners, path.slice(0, -1));
-            }
-            const [argumentList, transferables] = processArguments(rawArgumentList);
-            return requestResponseMessage(ep, pendingListeners, {
-                type: "APPLY" /* MessageType.APPLY */,
-                path: path.map((p) => p.toString()),
-                argumentList,
-            }, transferables).then(fromWireValue);
-        },
-        construct(_target, rawArgumentList) {
-            throwIfProxyReleased(isProxyReleased);
-            const [argumentList, transferables] = processArguments(rawArgumentList);
-            return requestResponseMessage(ep, pendingListeners, {
-                type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
-                path: path.map((p) => p.toString()),
-                argumentList,
-            }, transferables).then(fromWireValue);
-        },
-    });
-    registerProxy(proxy, ep);
-    return proxy;
-}
-function myFlat(arr) {
-    return Array.prototype.concat.apply([], arr);
-}
-function processArguments(argumentList) {
-    const processed = argumentList.map(toWireValue);
-    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
-}
-const transferCache = new WeakMap();
-function transfer(obj, transfers) {
-    transferCache.set(obj, transfers);
-    return obj;
-}
-function proxy(obj) {
-    return Object.assign(obj, { [proxyMarker]: true });
-}
-function toWireValue(value) {
-    for (const [name, handler] of transferHandlers) {
-        if (handler.canHandle(value)) {
-            const [serializedValue, transferables] = handler.serialize(value);
-            return [
-                {
-                    type: "HANDLER" /* WireValueType.HANDLER */,
-                    name,
-                    value: serializedValue,
-                },
-                transferables,
-            ];
-        }
-    }
-    return [
-        {
-            type: "RAW" /* WireValueType.RAW */,
-            value,
-        },
-        transferCache.get(value) || [],
-    ];
-}
-function fromWireValue(value) {
-    switch (value.type) {
-        case "HANDLER" /* WireValueType.HANDLER */:
-            return transferHandlers.get(value.name).deserialize(value.value);
-        case "RAW" /* WireValueType.RAW */:
-            return value.value;
-    }
-}
-function requestResponseMessage(ep, pendingListeners, msg, transfers) {
-    return new Promise((resolve) => {
-        const id = generateUUID();
-        pendingListeners.set(id, resolve);
-        if (ep.start) {
-            ep.start();
-        }
-        ep.postMessage(Object.assign({ id }, msg), transfers);
-    });
-}
-function generateUUID() {
-    return new Array(4)
-        .fill(0)
-        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-        .join("-");
-}
-
 /**
  * Micro-Layout Web Worker
  *
@@ -1704,6 +1388,11 @@ function generateUUID() {
  * off the main thread. Used by parallel-micro.ts to parallelize
  * micro-layout computation across multiple workers.
  */
+/**
+ * Converts a serialized cluster (with arrays) back to the internal Cluster type (with Maps).
+ * @param sc - Serialized cluster received from the main thread
+ * @returns Deserialized Cluster instance
+ */
 function deserializeCluster(sc) {
     return {
         ...sc,
@@ -1723,4 +1412,9 @@ const workerApi = {
         };
     },
 };
-expose(workerApi);
+/* v8 ignore start */
+self.onmessage = (e) => {
+    const result = workerApi.computeMicro(e.data.cluster, e.data.config);
+    self.postMessage(result);
+};
+/* v8 ignore stop */