@contentful/experience-design-system-cli 2.26.1-dev-build-a852362.0 → 2.26.1-dev-build-f03f014.0

package/dist/src/analyze/cycle-detection.js

@@ -1,234 +0,0 @@
-function buildGraph(components) {
-    const nodes = [];
-    const seen = new Set();
-    for (const c of components) {
-        if (seen.has(c.name))
-            continue;
-        seen.add(c.name);
-        nodes.push(c.name);
-    }
-    const adjacency = new Map();
-    for (const node of nodes)
-        adjacency.set(node, []);
-    for (const comp of components) {
-        const outgoing = adjacency.get(comp.name);
-        if (!outgoing)
-            continue;
-        for (const slot of comp.slots) {
-            const allowed = slot.allowedComponents ?? [];
-            for (const target of allowed) {
-                if (!seen.has(target))
-                    continue;
-                outgoing.push({ target, slotName: slot.name });
-            }
-        }
-    }
-    return { nodes, adjacency };
-}
-function stronglyConnectedComponents(nodes, adjacency) {
-    const index = new Map();
-    const lowlink = new Map();
-    const onStack = new Set();
-    const stack = [];
-    const sccs = [];
-    let counter = 0;
-    const nodeSet = new Set(nodes);
-    function strongconnect(v) {
-        index.set(v, counter);
-        lowlink.set(v, counter);
-        counter += 1;
-        stack.push(v);
-        onStack.add(v);
-        const neighbours = adjacency.get(v) ?? [];
-        for (const { target } of neighbours) {
-            if (!nodeSet.has(target))
-                continue;
-            if (!index.has(target)) {
-                strongconnect(target);
-                lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(target)));
-            }
-            else if (onStack.has(target)) {
-                lowlink.set(v, Math.min(lowlink.get(v), index.get(target)));
-            }
-        }
-        if (lowlink.get(v) === index.get(v)) {
-            const scc = [];
-            let w;
-            do {
-                w = stack.pop();
-                onStack.delete(w);
-                scc.push(w);
-            } while (w !== v);
-            sccs.push(scc);
-        }
-    }
-    for (const node of nodes) {
-        if (!index.has(node))
-            strongconnect(node);
-    }
-    return sccs;
-}
-function makeCycle(path, edges) {
-    return { path: [...path, path[0]], edges: [...edges] };
-}
-export function findSlotCycles(components) {
-    if (components.length === 0)
-        return [];
-    const { nodes, adjacency } = buildGraph(components);
-    if (nodes.length === 0)
-        return [];
-    const cycles = [];
-    for (const node of nodes) {
-        const outgoing = adjacency.get(node) ?? [];
-        for (const edge of outgoing) {
-            if (edge.target === node) {
-                cycles.push({
-                    path: [node, node],
-                    edges: [{ fromComponent: node, slotName: edge.slotName, toComponent: node }],
-                });
-            }
-        }
-    }
-    const nodeOrder = [...nodes].sort();
-    let remaining = [...nodeOrder];
-    while (remaining.length > 0) {
-        const subgraphNodes = remaining;
-        const sccs = stronglyConnectedComponents(subgraphNodes, adjacency).filter((scc) => {
-            if (scc.length > 1)
-                return true;
-            return false;
-        });
-        if (sccs.length === 0)
-            break;
-        let startNode = null;
-        let startScc = null;
-        for (const scc of sccs) {
-            const min = [...scc].sort()[0];
-            if (startNode === null || min < startNode) {
-                startNode = min;
-                startScc = scc;
-            }
-        }
-        if (startNode === null || startScc === null)
-            break;
-        const sccSet = new Set(startScc);
-        const blocked = new Set();
-        const blockedMap = new Map();
-        const pathStack = [];
-        const edgeStack = [];
-        function unblock(u) {
-            blocked.delete(u);
-            const dependents = blockedMap.get(u);
-            if (!dependents)
-                return;
-            for (const w of dependents) {
-                if (blocked.has(w))
-                    unblock(w);
-            }
-            dependents.clear();
-        }
-        function circuit(v, root) {
-            let foundCycle = false;
-            pathStack.push(v);
-            blocked.add(v);
-            const outgoing = adjacency.get(v) ?? [];
-            for (const { target: w, slotName } of outgoing) {
-                if (!sccSet.has(w))
-                    continue;
-                edgeStack.push({ fromComponent: v, slotName, toComponent: w });
-                if (w === root) {
-                    cycles.push(makeCycle(pathStack, edgeStack));
-                    foundCycle = true;
-                }
-                else if (!blocked.has(w)) {
-                    if (circuit(w, root))
-                        foundCycle = true;
-                }
-                edgeStack.pop();
-            }
-            if (foundCycle) {
-                unblock(v);
-            }
-            else {
-                for (const { target: w } of outgoing) {
-                    if (!sccSet.has(w))
-                        continue;
-                    let deps = blockedMap.get(w);
-                    if (!deps) {
-                        deps = new Set();
-                        blockedMap.set(w, deps);
-                    }
-                    deps.add(v);
-                }
-            }
-            pathStack.pop();
-            return foundCycle;
-        }
-        circuit(startNode, startNode);
-        remaining = remaining.filter((n) => n !== startNode);
-    }
-    return cycles;
-}
-export function suggestCycleBreakEdge(cycle, allCycles) {
-    if (cycle.edges.length === 0) {
-        throw new Error('suggestCycleBreakEdge: cycle has no edges');
-    }
-    const indegree = new Map();
-    for (const c of allCycles) {
-        for (const edge of c.edges) {
-            indegree.set(edge.toComponent, (indegree.get(edge.toComponent) ?? 0) + 1);
-        }
-    }
-    let best = cycle.edges[0];
-    let bestScore = indegree.get(best.toComponent) ?? 0;
-    for (const edge of cycle.edges) {
-        const score = indegree.get(edge.toComponent) ?? 0;
-        if (score > bestScore) {
-            best = edge;
-            bestScore = score;
-        }
-    }
-    return best;
-}
-export function formatCyclePath(cycle, maxHops = 8) {
-    const arrow = ' → ';
-    const parts = [];
-    for (let i = 0; i < cycle.edges.length; i += 1) {
-        parts.push(cycle.path[i]);
-        parts.push(cycle.edges[i].slotName);
-    }
-    parts.push(cycle.path[cycle.path.length - 1]);
-    if (cycle.edges.length <= maxHops) {
-        return parts.join(arrow);
-    }
-    const keepHops = Math.max(1, maxHops - 1);
-    const keepTokens = keepHops * 2;
-    const head = parts.slice(0, keepTokens).join(arrow);
-    const tail = parts[parts.length - 1];
-    return `${head}${arrow}…${arrow}${tail}`;
-}
-export function formatCyclePathSegments(cycle, maxHops = 8) {
-    const raw = [];
-    for (let i = 0; i < cycle.edges.length; i += 1) {
-        raw.push({ kind: 'component', text: cycle.path[i] });
-        raw.push({ kind: 'slot', text: `[${cycle.edges[i].slotName}]` });
-    }
-    raw.push({ kind: 'component', text: cycle.path[cycle.path.length - 1] });
-    const withArrows = (segs) => {
-        const out = [];
-        for (let i = 0; i < segs.length; i += 1) {
-            if (i > 0)
-                out.push({ kind: 'arrow', text: ' → ' });
-            out.push(segs[i]);
-        }
-        return out;
-    };
-    if (cycle.edges.length <= maxHops) {
-        return withArrows(raw);
-    }
-    const keepHops = Math.max(1, maxHops - 1);
-    const keepTokens = keepHops * 2;
-    const head = raw.slice(0, keepTokens);
-    const tail = raw[raw.length - 1];
-    return withArrows([...head, { kind: 'component', text: '…' }, tail]);
-}

package/dist/src/analyze/cycle-view.js

@@ -1,28 +0,0 @@
-import { findSlotCycles } from './cycle-detection.js';
-import { buildComponentGraph } from './slot-graph.js';
-export function computeCycleView(components) {
-    const filtered = components.filter((c) => c.status !== 'rejected');
-    const filteredGraph = buildComponentGraph(filtered);
-    const unfilteredGraph = buildComponentGraph(components);
-    let pushBlocking = [];
-    const structural = new Set();
-    try {
-        pushBlocking = findSlotCycles(filteredGraph);
-        for (const cyc of pushBlocking)
-            for (const p of cyc.path)
-                structural.add(p);
-    }
-    catch {
-        // Malformed slot data — intentional swallow.
-    }
-    try {
-        const unfilteredCycles = findSlotCycles(unfilteredGraph);
-        for (const cyc of unfilteredCycles)
-            for (const p of cyc.path)
-                structural.add(p);
-    }
-    catch {
-        // Malformed slot data — intentional swallow.
-    }
-    return { pushBlocking, structural };
-}

package/dist/src/analyze/fuzzy-search.js

@@ -1,55 +0,0 @@
-function match(query, text) {
-    if (query.length === 0)
-        return { score: 0 };
-    if (text.length === 0)
-        return null;
-    const queryLower = query.toLowerCase();
-    const textLower = text.toLowerCase();
-    let score = 0;
-    let qi = 0;
-    let lastMatchIndex = -2;
-    for (let ti = 0; ti < text.length && qi < query.length; ti++) {
-        if (textLower[ti] === queryLower[qi]) {
-            score += 10;
-            if (text[ti] === query[qi]) {
-                score += 5;
-            }
-            if (ti === 0 && qi === 0) {
-                score += 15;
-            }
-            if (ti === lastMatchIndex + 1) {
-                score += 5;
-            }
-            lastMatchIndex = ti;
-            qi++;
-        }
-    }
-    if (qi < query.length)
-        return null;
-    score -= text.length * 0.1;
-    return { score };
-}
-export function fuzzyMatches(query, text) {
-    return match(query, text) !== null;
-}
-export function fuzzyScore(query, text) {
-    const result = match(query, text);
-    return result === null ? null : result.score;
-}
-export function fuzzyFilter(query, candidates) {
-    if (query.length === 0)
-        return [...candidates];
-    const scored = candidates
-        .map((candidate, index) => ({
-        candidate,
-        index,
-        score: fuzzyScore(query, candidate),
-    }))
-        .filter((entry) => entry.score !== null);
-    scored.sort((a, b) => {
-        if (b.score !== a.score)
-            return b.score - a.score;
-        return a.index - b.index;
-    });
-    return scored.map((entry) => entry.candidate);
-}

package/dist/src/analyze/issue-inheritance.js

@@ -1,108 +0,0 @@
-const STATUS_RANK = { ok: 0, warning: 1, error: 2 };
-const RANK_STATUS = ['ok', 'warning', 'error'];
-function worstOf(statuses) {
-    let worst = 0;
-    for (const s of statuses) {
-        const r = STATUS_RANK[s];
-        if (r > worst)
-            worst = r;
-    }
-    return RANK_STATUS[worst];
-}
-export function computeRenderStatuses(closure, directIssues) {
-    const out = new Map();
-    if (closure.nodes.length === 0)
-        return out;
-    const nodesByName = new Map();
-    for (const node of closure.nodes) {
-        nodesByName.set(node.name, { name: node.name, path: node.path });
-    }
-    // Descendant relationship: A is an ancestor of B iff A appears in B.path
-    // (which is the shortest path from root to B) at a position before B. Note
-    // this uses the ONE canonical shortest path. For pure-inheritance semantics
-    // — a node has an inherited issue iff any node reachable from it in the
-    // closure has an issue — we need transitive descendants. In this closure
-    // model, every node's `path` field gives its shortest-path ancestor chain,
-    // and every ancestor along that chain is transitively a "container" of that
-    // node. That is sufficient here because the closure is rooted and a node is
-    // reachable from the root iff it appears in the closure.
-    const own = new Map();
-    for (const node of closure.nodes) {
-        const s = directIssues.get(node.name);
-        if (s && s !== 'ok')
-            own.set(node.name, s);
-    }
-    const inheritedSources = new Map();
-    for (const node of closure.nodes) {
-        const ownStatus = own.get(node.name);
-        if (!ownStatus)
-            continue;
-        for (let i = 0; i < node.path.length - 1; i++) {
-            const ancestor = node.path[i];
-            if (!inheritedSources.has(ancestor))
-                inheritedSources.set(ancestor, new Map());
-            inheritedSources.get(ancestor).set(node.name, ownStatus);
-        }
-    }
-    for (const [name, status] of own.entries()) {
-        out.set(name, {
-            status,
-            isOwn: true,
-            sourceComponents: [name],
-        });
-    }
-    for (const [ancestor, sources] of inheritedSources.entries()) {
-        if (out.has(ancestor))
-            continue;
-        const sourceNames = [...sources.keys()].sort();
-        const status = worstOf([...sources.values()]);
-        out.set(ancestor, {
-            status,
-            isOwn: false,
-            sourceComponents: sourceNames,
-        });
-    }
-    return out;
-}
-export function pickDrillTarget(ancestor, closure, directIssues) {
-    const ancestorDirect = directIssues.get(ancestor);
-    if (ancestorDirect && ancestorDirect !== 'ok')
-        return null;
-    const nodesByName = new Map();
-    for (const node of closure.nodes)
-        nodesByName.set(node.name, node);
-    const ancestorNode = nodesByName.get(ancestor);
-    if (!ancestorNode)
-        return null;
-    const candidates = [];
-    const ancestorDepth = ancestorNode.path.length - 1;
-    for (const node of closure.nodes) {
-        if (node.name === ancestor)
-            continue;
-        const idx = node.path.indexOf(ancestor);
-        if (idx === -1)
-            continue;
-        const status = directIssues.get(node.name);
-        if (!status || status === 'ok')
-            continue;
-        // depthFromAncestor is number of edges between ancestor and node along
-        // the shortest path from root. Since `path` is the shortest path from
-        // root, path.length-1 == node.depth and idx == ancestor.depth along that
-        // path, so distance = (node.path.length - 1) - idx.
-        const depthFromAncestor = node.path.length - 1 - idx;
-        void ancestorDepth;
-        candidates.push({ name: node.name, status, depthFromAncestor });
-    }
-    if (candidates.length === 0)
-        return null;
-    candidates.sort((a, b) => {
-        const rDiff = STATUS_RANK[b.status] - STATUS_RANK[a.status];
-        if (rDiff !== 0)
-            return rDiff;
-        if (a.depthFromAncestor !== b.depthFromAncestor) {
-            return a.depthFromAncestor - b.depthFromAncestor;
-        }
-        return a.name.localeCompare(b.name);
-    });
-    return candidates[0].name;
-}

package/dist/src/analyze/scope-gate-cascade.js

@@ -1,170 +0,0 @@
-import { findDirectParents } from './lineage.js';
-export function buildCycleUnits(slotCycles) {
-    const parent = new Map();
-    const find = (x) => {
-        let cur = x;
-        while (parent.get(cur) !== cur) {
-            cur = parent.get(cur);
-        }
-        let walk = x;
-        while (parent.get(walk) !== cur) {
-            const next = parent.get(walk);
-            parent.set(walk, cur);
-            walk = next;
-        }
-        return cur;
-    };
-    const union = (a, b) => {
-        const ra = find(a);
-        const rb = find(b);
-        if (ra !== rb)
-            parent.set(ra, rb);
-    };
-    for (const cycle of slotCycles) {
-        for (const node of cycle.path) {
-            if (!parent.has(node))
-                parent.set(node, node);
-        }
-        // `path` has the first node duplicated at the end; union with path[0] is
-        // enough to link every node in the cycle.
-        for (let i = 1; i < cycle.path.length; i++) {
-            union(cycle.path[0], cycle.path[i]);
-        }
-    }
-    const groups = new Map();
-    for (const node of parent.keys()) {
-        const root = find(node);
-        let group = groups.get(root);
-        if (!group) {
-            group = new Set();
-            groups.set(root, group);
-        }
-        group.add(node);
-    }
-    const out = new Map();
-    for (const group of groups.values()) {
-        for (const node of group) {
-            out.set(node, group);
-        }
-    }
-    return out;
-}
-function slotTargets(node, byName) {
-    const c = byName.get(node);
-    if (!c)
-        return [];
-    const seen = new Set();
-    const out = [];
-    for (const slot of c.slots) {
-        for (const target of slot.allowedComponents ?? []) {
-            if (!byName.has(target))
-                continue;
-            if (seen.has(target))
-                continue;
-            seen.add(target);
-            out.push(target);
-        }
-    }
-    return out;
-}
-export function computeCycleAwareAcceptCascade(target, components, cycleUnits) {
-    const byName = new Map(components.map((c) => [c.name, c]));
-    const visited = new Set();
-    const queue = [];
-    const enqueue = (name) => {
-        if (visited.has(name))
-            return;
-        visited.add(name);
-        queue.push(name);
-        // Cohesion: touching any cycle member pulls its whole unit along.
-        const unit = cycleUnits.get(name);
-        if (unit) {
-            for (const member of unit) {
-                if (!visited.has(member)) {
-                    visited.add(member);
-                    queue.push(member);
-                }
-            }
-        }
-    };
-    enqueue(target);
-    while (queue.length > 0) {
-        const cur = queue.shift();
-        for (const next of slotTargets(cur, byName)) {
-            enqueue(next);
-        }
-    }
-    return visited;
-}
-export function computeCycleAwareRejectCascade(target, components, cycleUnits) {
-    const toReject = new Set();
-    const targetUnit = cycleUnits.get(target);
-    const initialSeeds = targetUnit ? [...targetUnit] : [target];
-    for (const seed of initialSeeds)
-        toReject.add(seed);
-    // Walk ancestors. Whenever a newly-added node happens to be a cycle
-    // member, splice in its whole cycle unit and keep walking from each unit
-    // member. Terminates because every add is idempotent against `toReject`.
-    const stack = [...toReject];
-    while (stack.length > 0) {
-        const cur = stack.pop();
-        for (const { parent } of findDirectParents(cur, components)) {
-            if (toReject.has(parent))
-                continue;
-            toReject.add(parent);
-            stack.push(parent);
-            const unit = cycleUnits.get(parent);
-            if (unit) {
-                for (const member of unit) {
-                    if (!toReject.has(member)) {
-                        toReject.add(member);
-                        stack.push(member);
-                    }
-                }
-            }
-        }
-    }
-    const acceptCascade = computeCycleAwareAcceptCascade(target, components, cycleUnits);
-    const toDeselect = new Set();
-    for (const n of acceptCascade) {
-        if (toReject.has(n))
-            continue;
-        toDeselect.add(n);
-    }
-    const cyclePartners = [];
-    if (targetUnit) {
-        for (const m of targetUnit) {
-            if (m !== target)
-                cyclePartners.push(m);
-        }
-        cyclePartners.sort();
-    }
-    return { toReject, toDeselect, cyclePartners };
-}
-export function collectReachableCycleUnits(seeds, components, cycleUnits) {
-    const out = new Set();
-    if (cycleUnits.size === 0)
-        return out;
-    const byName = new Map(components.map((c) => [c.name, c]));
-    const visited = new Set();
-    const queue = [...seeds];
-    while (queue.length > 0) {
-        const cur = queue.shift();
-        if (visited.has(cur))
-            continue;
-        visited.add(cur);
-        const unit = cycleUnits.get(cur);
-        if (unit) {
-            for (const member of unit) {
-                out.add(member);
-                if (!visited.has(member))
-                    queue.push(member);
-            }
-        }
-        for (const next of slotTargets(cur, byName)) {
-            if (!visited.has(next))
-                queue.push(next);
-        }
-    }
-    return out;
-}

package/dist/src/analyze/search-neighborhood.js

@@ -1,56 +0,0 @@
-export function computeDirectNeighborhood(matches, graph) {
-    const matchSet = new Set(matches);
-    const out = new Set(matchSet);
-    if (matchSet.size === 0)
-        return out;
-    for (const node of graph) {
-        const targets = [];
-        for (const slot of node.slots) {
-            for (const t of slot.allowedComponents ?? [])
-                targets.push(t);
-        }
-        if (matchSet.has(node.name)) {
-            for (const t of targets)
-                out.add(t);
-        }
-        for (const t of targets) {
-            if (matchSet.has(t)) {
-                out.add(node.name);
-                break;
-            }
-        }
-    }
-    return out;
-}
-export function findAllAncestors(target, graph) {
-    const out = new Set([target]);
-    const parentsOf = new Map();
-    for (const node of graph) {
-        for (const slot of node.slots) {
-            for (const child of slot.allowedComponents ?? []) {
-                const list = parentsOf.get(child);
-                if (list) {
-                    if (!list.includes(node.name))
-                        list.push(node.name);
-                }
-                else {
-                    parentsOf.set(child, [node.name]);
-                }
-            }
-        }
-    }
-    const queue = [target];
-    while (queue.length > 0) {
-        const cur = queue.shift();
-        const parents = parentsOf.get(cur);
-        if (!parents)
-            continue;
-        for (const p of parents) {
-            if (out.has(p))
-                continue;
-            out.add(p);
-            queue.push(p);
-        }
-    }
-    return out;
-}