@servlyadmin/runtime-core 0.1.0 → 0.1.2

package/dist/chunk-CIUQK4GA.js

@@ -0,0 +1,182 @@
+// src/registry.ts
+function createRegistry() {
+  const components = /* @__PURE__ */ new Map();
+  return {
+    get(id, version) {
+      if (version) {
+        const key = `${id}@${version}`;
+        if (components.has(key)) {
+          return components.get(key);
+        }
+      }
+      for (const [key, component] of components) {
+        if (key.startsWith(`${id}@`)) {
+          return component;
+        }
+      }
+      return components.get(id);
+    },
+    has(id, version) {
+      if (version) {
+        return components.has(`${id}@${version}`);
+      }
+      for (const key of components.keys()) {
+        if (key.startsWith(`${id}@`) || key === id) {
+          return true;
+        }
+      }
+      return false;
+    },
+    set(id, version, component) {
+      components.set(`${id}@${version}`, component);
+    }
+  };
+}
+function buildRegistryFromBundle(data) {
+  const registry = createRegistry();
+  registry.set(data.id, data.version, {
+    layout: data.layout,
+    propsInterface: data.propsInterface
+  });
+  if (data.bundle) {
+    for (const [key, component] of Object.entries(data.bundle)) {
+      const [id, version] = key.split("@");
+      if (id && version) {
+        registry.set(id, version, component);
+      }
+    }
+  }
+  return registry;
+}
+function extractDependencies(elements) {
+  const dependencies = [];
+  for (const element of elements) {
+    const config = element.configuration;
+    if (!config) continue;
+    if (config.componentViewRef) {
+      dependencies.push({
+        id: config.componentViewRef,
+        version: config.componentViewVersion,
+        type: "viewRef",
+        elementId: element.i
+      });
+    }
+    if (config.blueprint) {
+      dependencies.push({
+        id: config.blueprint,
+        version: config.blueprintVersion,
+        type: "blueprint",
+        elementId: element.i
+      });
+    }
+  }
+  return dependencies;
+}
+function extractDependenciesFromCode(code) {
+  const dependencies = [];
+  const pattern = /renderDynamicList\s*\(\s*\{[^}]*blueprint\s*:\s*["']([^"']+)["']/g;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    dependencies.push({
+      id: match[1],
+      type: "blueprint"
+    });
+  }
+  return dependencies;
+}
+async function collectAllDependencies(rootId, rootVersion, fetchComponent, maxDepth = 10) {
+  const manifest = {};
+  const visited = /* @__PURE__ */ new Set();
+  async function collect(id, version, via, depth) {
+    if (depth > maxDepth) {
+      console.warn(`Max dependency depth (${maxDepth}) reached for ${id}`);
+      return;
+    }
+    const key = `${id}@${version || "latest"}`;
+    if (visited.has(key)) {
+      return;
+    }
+    visited.add(key);
+    try {
+      const component = await fetchComponent(id, version);
+      if (!component) {
+        console.warn(`Dependency not found: ${id}@${version || "latest"}`);
+        return;
+      }
+      manifest[id] = {
+        version: version || "latest",
+        resolved: component.version,
+        type: via ? "viewRef" : "viewRef",
+        // Will be set by caller
+        via
+      };
+      const nestedDeps = extractDependencies(component.layout);
+      for (const dep of nestedDeps) {
+        await collect(dep.id, dep.version, id, depth + 1);
+      }
+    } catch (error) {
+      console.error(`Failed to fetch dependency ${id}:`, error);
+    }
+  }
+  const rootComponent = await fetchComponent(rootId, rootVersion);
+  if (rootComponent) {
+    const rootDeps = extractDependencies(rootComponent.layout);
+    for (const dep of rootDeps) {
+      manifest[dep.id] = {
+        version: dep.version || "latest",
+        resolved: "",
+        // Will be filled when fetched
+        type: dep.type
+      };
+      await collect(dep.id, dep.version, void 0, 1);
+    }
+  }
+  return manifest;
+}
+function detectCircularDependencies(manifest) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(manifest)) {
+    if (entry.via) {
+      const deps = graph.get(entry.via) || [];
+      deps.push(id);
+      graph.set(entry.via, deps);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(node) {
+    if (stack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      return [...path.slice(cycleStart), node];
+    }
+    if (visited.has(node)) {
+      return null;
+    }
+    visited.add(node);
+    stack.add(node);
+    path.push(node);
+    const neighbors = graph.get(node) || [];
+    for (const neighbor of neighbors) {
+      const cycle = dfs(neighbor);
+      if (cycle) return cycle;
+    }
+    stack.delete(node);
+    path.pop();
+    return null;
+  }
+  for (const node of graph.keys()) {
+    const cycle = dfs(node);
+    if (cycle) return cycle;
+  }
+  return null;
+}
+
+export {
+  createRegistry,
+  buildRegistryFromBundle,
+  extractDependencies,
+  extractDependenciesFromCode,
+  collectAllDependencies,
+  detectCircularDependencies
+};