@rslsp1/fa-app-tools 2.0.78 → 2.0.82

package/dist/chunk-FUY2OCVC.mjs

@@ -0,0 +1,157 @@
+// src/lib/szenen/versionDag.ts
+var VersionDagError = class extends Error {
+};
+function buildVersionDag(versions) {
+  if (versions.length === 0) {
+    throw new VersionDagError("Versions-DAG ohne Versionen ist nicht aufbaubar.");
+  }
+  const elementId = versions[0].element_id;
+  const nodes = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const version of versions) {
+    if (!version.version_id) {
+      throw new VersionDagError("Version ohne version_id.");
+    }
+    if (version.element_id !== elementId) {
+      throw new VersionDagError(
+        `Version ${version.version_id} gehoert zu Element ${version.element_id}, erwartet ${elementId}. Ein DAG umfasst genau ein Element.`
+      );
+    }
+    if (nodes.has(version.version_id)) {
+      throw new VersionDagError(`Version ${version.version_id} kommt doppelt vor.`);
+    }
+    nodes.set(version.version_id, version);
+    if (!children.has(version.version_id)) children.set(version.version_id, []);
+  }
+  for (const version of versions) {
+    const seenParents = /* @__PURE__ */ new Set();
+    for (const link of version.parents) {
+      if (link.parent_version_id === version.version_id) {
+        throw new VersionDagError(`Version ${version.version_id} ist ihr eigener Parent.`);
+      }
+      if (!nodes.has(link.parent_version_id)) {
+        throw new VersionDagError(
+          `Version ${version.version_id} verweist auf unbekannten Parent ${link.parent_version_id}. Der Graph waere unvollstaendig.`
+        );
+      }
+      if (seenParents.has(link.parent_version_id)) {
+        throw new VersionDagError(
+          `Version ${version.version_id} nennt Parent ${link.parent_version_id} doppelt.`
+        );
+      }
+      seenParents.add(link.parent_version_id);
+      children.get(link.parent_version_id).push(version.version_id);
+    }
+  }
+  assertAcyclic(nodes);
+  const versionIds = versions.map((v) => v.version_id);
+  const closure = (start, step) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...step(start)];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (seen.has(current)) continue;
+      seen.add(current);
+      stack.push(...step(current));
+    }
+    return seen;
+  };
+  const parentIdsOf = (id) => (nodes.get(id)?.parents ?? []).map((p) => p.parent_version_id);
+  const childIdsOf = (id) => children.get(id) ?? [];
+  return {
+    elementId,
+    versionIds,
+    get: (versionId) => nodes.get(versionId),
+    parentsOf: (versionId) => nodes.get(versionId)?.parents ?? [],
+    childrenOf: (versionId) => childIdsOf(versionId),
+    heads: () => versionIds.filter((id) => childIdsOf(id).length === 0),
+    roots: () => versionIds.filter((id) => parentIdsOf(id).length === 0),
+    hasFork() {
+      return this.heads().length > 1;
+    },
+    ancestorsOf: (versionId) => closure(versionId, parentIdsOf),
+    descendantsOf: (versionId) => closure(versionId, childIdsOf),
+    isAncestorOf(candidate, versionId) {
+      return this.ancestorsOf(versionId).has(candidate);
+    }
+  };
+}
+function assertAcyclic(nodes) {
+  const OPEN = 1;
+  const DONE = 2;
+  const state = /* @__PURE__ */ new Map();
+  for (const start of nodes.keys()) {
+    if (state.get(start) === DONE) continue;
+    const stack = [
+      { id: start, next: 0, path: [start] }
+    ];
+    state.set(start, OPEN);
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const parents = nodes.get(frame.id).parents;
+      if (frame.next >= parents.length) {
+        state.set(frame.id, DONE);
+        stack.pop();
+        continue;
+      }
+      const parentId = parents[frame.next++].parent_version_id;
+      const parentState = state.get(parentId);
+      if (parentState === OPEN) {
+        throw new VersionDagError(
+          `Zyklus im Versions-DAG: ${[...frame.path, parentId].join(" -> ")}`
+        );
+      }
+      if (parentState !== DONE) {
+        state.set(parentId, OPEN);
+        stack.push({ id: parentId, next: 0, path: [...frame.path, parentId] });
+      }
+    }
+  }
+}
+function resolvePreferredHead(options) {
+  const { dag, workingContextId, inheritanceChain = [], owningContextId, selections = [] } = options;
+  const heads = dag.heads();
+  const ignoredSelections = [];
+  const byContext = /* @__PURE__ */ new Map();
+  for (const selection of selections) {
+    if (!dag.get(selection.version_id)) {
+      ignoredSelections.push(selection);
+      continue;
+    }
+    if (!byContext.has(selection.context_id)) byContext.set(selection.context_id, selection);
+  }
+  const candidates = [
+    { contextId: workingContextId, source: "context" },
+    ...inheritanceChain.map((contextId) => ({ contextId, source: "inherited" })),
+    ...owningContextId ? [{ contextId: owningContextId, source: "owning" }] : []
+  ];
+  for (const candidate of candidates) {
+    const selection = byContext.get(candidate.contextId);
+    if (!selection) continue;
+    return {
+      resolution: {
+        kind: "selected",
+        versionId: selection.version_id,
+        source: candidate.source,
+        contextId: candidate.contextId,
+        heads,
+        stale: !heads.includes(selection.version_id)
+      },
+      ignoredSelections
+    };
+  }
+  if (heads.length === 1) {
+    return { resolution: { kind: "single", versionId: heads[0], heads }, ignoredSelections };
+  }
+  return { resolution: { kind: "fork", heads }, ignoredSelections };
+}
+function preferredVersionId(resolution) {
+  return resolution.kind === "fork" ? null : resolution.versionId;
+}
+
+export {
+  VersionDagError,
+  buildVersionDag,
+  resolvePreferredHead,
+  preferredVersionId
+};