@contentful/experience-design-system-cli 2.14.2 → 2.15.0

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

@@ -0,0 +1,234 @@
+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.d.ts

@@ -0,0 +1,7 @@
+import type { SlotCycle } from './cycle-detection.js';
+import { type SlotGraphInput } from './slot-graph.js';
+export interface CycleView {
+    pushBlocking: SlotCycle[];
+    structural: Set<string>;
+}
+export declare function computeCycleView(components: SlotGraphInput[]): CycleView;

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

@@ -0,0 +1,28 @@
+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.d.ts

@@ -0,0 +1,3 @@
+export declare function fuzzyMatches(query: string, text: string): boolean;
+export declare function fuzzyScore(query: string, text: string): number | null;
+export declare function fuzzyFilter(query: string, candidates: string[]): string[];

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

@@ -0,0 +1,55 @@
+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.d.ts

@@ -0,0 +1,12 @@
+import type { Closure, NodeStatus } from './composite-closure.js';
+export interface IssueLocation {
+    component: string;
+    status: NodeStatus;
+}
+export interface RenderStatus {
+    status: NodeStatus;
+    isOwn: boolean;
+    sourceComponents: string[];
+}
+export declare function computeRenderStatuses(closure: Closure, directIssues: Map<string, NodeStatus>): Map<string, RenderStatus>;
+export declare function pickDrillTarget(ancestor: string, closure: Closure, directIssues: Map<string, NodeStatus>): string | null;

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

@@ -0,0 +1,108 @@
+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/lineage.d.ts

@@ -0,0 +1,29 @@
+import type { ComponentGraphNode } from './composite-closure.js';
+export interface LineageParentEdge {
+    parent: string;
+    slotName: string;
+}
+export interface LineageEdge {
+    from: string;
+    slotName: string;
+    to: string;
+}
+export type LineageChain = LineageEdge[];
+export declare function findDirectParents(target: string, components: ComponentGraphNode[]): LineageParentEdge[];
+export declare function findAllAncestors(target: string, components: ComponentGraphNode[]): Set<string>;
+export declare function findAllAncestorChains(target: string, components: ComponentGraphNode[]): LineageChain[];
+export interface AncestorTreeNode {
+    name: string;
+    incomingSlotName?: string;
+    depth: number;
+    shared: boolean;
+    cycle: boolean;
+    parents: AncestorTreeNode[];
+}
+export declare function buildAncestorTree(target: string, components: ComponentGraphNode[]): AncestorTreeNode;
+export interface AncestorTreeLine {
+    text: string;
+    jumpTarget?: string;
+    depth: number;
+}
+export declare function renderAncestorTree(node: AncestorTreeNode): AncestorTreeLine[];

package/dist/src/analyze/scope-gate-cascade.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentGraphNode } from './composite-closure.js';
+import type { SlotCycle } from './cycle-detection.js';
+export declare function buildCycleUnits(slotCycles: SlotCycle[]): Map<string, Set<string>>;
+export declare function computeCycleAwareAcceptCascade(target: string, components: ComponentGraphNode[], cycleUnits: Map<string, Set<string>>): Set<string>;
+export interface CycleAwareRejectResult {
+    toReject: Set<string>;
+    toDeselect: Set<string>;
+    cyclePartners: string[];
+}
+export declare function computeCycleAwareRejectCascade(target: string, components: ComponentGraphNode[], cycleUnits: Map<string, Set<string>>): CycleAwareRejectResult;
+export declare function collectReachableCycleUnits(seeds: string[], components: ComponentGraphNode[], cycleUnits: Map<string, Set<string>>): Set<string>;

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

@@ -0,0 +1,170 @@
+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.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentGraphNode } from './composite-closure.js';
+export declare function computeDirectNeighborhood(matches: Iterable<string>, graph: ComponentGraphNode[]): Set<string>;
+export declare function findAllAncestors(target: string, graph: ComponentGraphNode[]): Set<string>;