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

package/dist/src/import/tui/scope-gate-columns.d.ts

@@ -0,0 +1,31 @@
+import type { Closure } from '../../analyze/composite-closure.js';
+/** Structural subset of ScopeComponent needed by these helpers. */
+export interface ScopeComponentLike {
+    name: string;
+}
+export type Decision = 'accepted' | 'rejected' | 'undecided';
+export declare const THREE_COLUMN_MIN_WIDTH = 120;
+export declare function computeColumnWidths(totalWidth: number): {
+    layout: 'single' | 'three-column';
+    main: number;
+    added: number;
+    groups: number;
+};
+export interface AddedComponentEntry {
+    name: string;
+    isCycle: boolean;
+}
+export interface AddedGroupEntry {
+    name: string;
+    depCount: number;
+    isCycle: boolean;
+}
+export declare function buildAddedComponentsList(components: ScopeComponentLike[], stateByKey: Map<string, Decision>, cycleParticipants?: Set<string>): AddedComponentEntry[];
+export declare function buildAddedGroupsList(closures: Map<string, Closure>, stateByKey: Map<string, Decision>, cycleParticipants?: Set<string>, cycleUnits?: Map<string, Set<string>>): AddedGroupEntry[];
+export declare function computeCounters(components: ScopeComponentLike[], closures: Map<string, Closure>, stateByKey: Map<string, Decision>): {
+    accepted: number;
+    rejected: number;
+    undecided: number;
+    groups: number;
+    total: number;
+};

package/dist/src/import/tui/scope-gate-columns.js

@@ -0,0 +1,94 @@
+import { computeSidebarWidth } from './sidebar-width.js';
+export const THREE_COLUMN_MIN_WIDTH = 120;
+export function computeColumnWidths(totalWidth) {
+    if (totalWidth < THREE_COLUMN_MIN_WIDTH) {
+        return { layout: 'single', main: computeSidebarWidth(totalWidth), added: 0, groups: 0 };
+    }
+    const main = computeSidebarWidth(totalWidth);
+    const remaining = Math.max(0, totalWidth - main - 4);
+    const added = Math.floor(remaining * 0.45);
+    const groups = Math.max(0, remaining - added - 2);
+    return { layout: 'three-column', main, added, groups };
+}
+export function buildAddedComponentsList(components, stateByKey, cycleParticipants = new Set()) {
+    const cycleTier = [];
+    const restTier = [];
+    // Selection state is keyed by name, so components sharing a name (real
+    // collisions across files) collapse to one accepted entry — dedupe by name
+    // to avoid duplicate rows and non-unique React keys downstream.
+    const seen = new Set();
+    for (const c of components) {
+        if (stateByKey.get(c.name) !== 'accepted')
+            continue;
+        if (seen.has(c.name))
+            continue;
+        seen.add(c.name);
+        if (cycleParticipants.has(c.name))
+            cycleTier.push({ name: c.name, isCycle: true });
+        else
+            restTier.push({ name: c.name, isCycle: false });
+    }
+    cycleTier.sort((a, b) => a.name.localeCompare(b.name));
+    restTier.sort((a, b) => a.name.localeCompare(b.name));
+    return [...cycleTier, ...restTier];
+}
+export function buildAddedGroupsList(closures, stateByKey, cycleParticipants = new Set(), cycleUnits = new Map()) {
+    const cycleTier = [];
+    const restTier = [];
+    const seenNames = new Set();
+    for (const [root, closure] of closures.entries()) {
+        if (closure.nodes.length <= 1)
+            continue;
+        if (stateByKey.get(root) !== 'accepted')
+            continue;
+        const entry = {
+            name: root,
+            depCount: closure.nodes.length - 1,
+            isCycle: cycleParticipants.has(root),
+        };
+        if (entry.isCycle)
+            cycleTier.push(entry);
+        else
+            restTier.push(entry);
+        seenNames.add(root);
+    }
+    const seenUnits = new Set();
+    for (const unit of cycleUnits.values()) {
+        if (seenUnits.has(unit))
+            continue;
+        seenUnits.add(unit);
+        for (const member of unit) {
+            if (stateByKey.get(member) !== 'accepted')
+                continue;
+            if (seenNames.has(member))
+                continue;
+            seenNames.add(member);
+            cycleTier.push({ name: member, depCount: unit.size - 1, isCycle: true });
+        }
+    }
+    cycleTier.sort((a, b) => a.name.localeCompare(b.name));
+    restTier.sort((a, b) => a.name.localeCompare(b.name));
+    return [...cycleTier, ...restTier];
+}
+export function computeCounters(components, closures, stateByKey) {
+    let accepted = 0;
+    let rejected = 0;
+    let undecided = 0;
+    for (const c of components) {
+        const s = stateByKey.get(c.name) ?? 'undecided';
+        if (s === 'accepted')
+            accepted++;
+        else if (s === 'rejected')
+            rejected++;
+        else
+            undecided++;
+    }
+    let groups = 0;
+    for (const [root, closure] of closures.entries()) {
+        if (closure.nodes.length <= 1)
+            continue;
+        if (stateByKey.get(root) === 'accepted')
+            groups++;
+    }
+    return { accepted, rejected, undecided, groups, total: components.length };
+}

package/dist/src/import/tui/scope-gate-host.d.ts

@@ -1,10 +1,12 @@
 import React from 'react';
 import type { ScopeComponent } from './steps/ScopeGateStep.js';
+import type { CompositionMode } from '../../lib/composition-mode.js';
 export type { ScopeComponent };
 export type AutoFilterStatus = 'idle' | 'running' | 'complete' | 'cancelled' | 'failed';
 export type ScopeGateHostProps = {
     components: ReadonlyArray<ScopeComponent>;
     autoAccept: boolean;
+    compositionMode?: CompositionMode;
     onConfirm: (decisions: {
         accepted: string[];
         rejected: string[];
@@ -18,4 +20,4 @@ export type ScopeGateHostProps = {
     aiFilterError?: string | null;
     onCancelAutoFilter?: () => void;
 };
-export declare function ScopeGateHost({ components, autoAccept, onConfirm, onQuit, aiFilterStatus, aiFilterProgress, aiFilterError, onCancelAutoFilter, }: ScopeGateHostProps): React.ReactElement;
+export declare function ScopeGateHost({ components, autoAccept, compositionMode, onConfirm, onQuit, aiFilterStatus, aiFilterProgress, aiFilterError, onCancelAutoFilter, }: ScopeGateHostProps): React.ReactElement;

package/dist/src/import/tui/scope-gate-host.js

@@ -1,20 +1,28 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { PALETTE } from '../../analyze/select/tui/theme.js';
 import React from 'react';
 import { ScopeGateStep } from './steps/ScopeGateStep.js';
-export function ScopeGateHost({ components, autoAccept, onConfirm, onQuit, aiFilterStatus = 'idle', aiFilterProgress = null, aiFilterError = null, onCancelAutoFilter, }) {
+import { AtomicScopeGateStep } from './steps/AtomicScopeGateStep.js';
+export function ScopeGateHost({ components, autoAccept, compositionMode = 'atomic', onConfirm, onQuit, aiFilterStatus = 'idle', aiFilterProgress = null, aiFilterError = null, onCancelAutoFilter, }) {
     if (components.length === 0) {
-        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: "red", children: "Error: no components found for this session \u2014 please re-run analyze extract." }) }));
+        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: PALETTE.error, children: "Error: no components found for this session \u2014 please re-run analyze extract." }) }));
     }
     if (autoAccept) {
         return _jsx(ScopeGateAutoAccept, { components: components, onConfirm: onConfirm });
     }
+    // Atomic mode (spec T9): render the pre-composite flat step. It never imports
+    // the graph/closures/cycles/cascade primitives, so this host fork is the
+    // single point where "atomic bypasses the graph" is guaranteed on the
+    // interactive path.
+    if (compositionMode === 'atomic') {
+        return (_jsx(AtomicScopeGateStep, { components: [...components], onConfirm: onConfirm, onQuit: onQuit, aiFilterStatus: aiFilterStatus, aiFilterProgress: aiFilterProgress, aiFilterError: aiFilterError, onCancelAutoFilter: onCancelAutoFilter }));
+    }
     return (_jsx(ScopeGateStep, { components: [...components], onConfirm: onConfirm, onQuit: onQuit, aiFilterStatus: aiFilterStatus, aiFilterProgress: aiFilterProgress, aiFilterError: aiFilterError, onCancelAutoFilter: onCancelAutoFilter }));
 }
 function ScopeGateAutoAccept({ components, onConfirm, }) {
     React.useEffect(() => {
         onConfirm({ accepted: components.map((c) => c.name), rejected: [] });
-        // fire once on mount; deps intentionally empty so a re-render with new components doesn't double-confirm
     }, []);
     return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsxs(Text, { dimColor: true, children: ["Auto-accepting ", components.length, " components..."] }) }));
 }

package/dist/src/import/tui/sidebar-width.d.ts

@@ -0,0 +1 @@
+export declare function computeSidebarWidth(terminalWidth: number): number;

package/dist/src/import/tui/sidebar-width.js

@@ -0,0 +1,3 @@
+export function computeSidebarWidth(terminalWidth) {
+    return Math.min(60, Math.max(36, Math.floor(terminalWidth * 0.45)));
+}

package/dist/src/import/tui/step-filters.d.ts

@@ -0,0 +1,19 @@
+export type FilterCategory = 'broken' | 'cycles' | 'deleted';
+export interface FilterDataSources {
+    /** Component keys that participate in a slot cycle. */
+    cycles?: Iterable<string>;
+    /** Component keys the step considers "broken" (issue/warning/AI-flagged). */
+    broken?: Iterable<string>;
+    /** Component keys marked for deletion (GenerateReview only). */
+    deleted?: Iterable<string>;
+}
+export declare function computeFilterKeys(input: {
+    filters: Iterable<FilterCategory>;
+    data: FilterDataSources;
+}): Set<string> | undefined;
+export declare function intersectFilterKeys(a: Set<string> | undefined, b: Set<string> | undefined): Set<string> | undefined;
+export declare function buildFlatDimPredicate(input: {
+    viewMode: 'grouped' | 'flat';
+    searchQuery: string;
+    filterVisibleKeys: Set<string> | undefined;
+}): ((componentKey: string) => boolean) | undefined;

package/dist/src/import/tui/step-filters.js

@@ -0,0 +1,42 @@
+import { fuzzyMatches } from '../../analyze/fuzzy-search.js';
+export function computeFilterKeys(input) {
+    const active = new Set(input.filters);
+    if (active.size === 0)
+        return undefined;
+    const out = new Set();
+    if (active.has('cycles'))
+        for (const k of input.data.cycles ?? [])
+            out.add(k);
+    if (active.has('broken'))
+        for (const k of input.data.broken ?? [])
+            out.add(k);
+    if (active.has('deleted'))
+        for (const k of input.data.deleted ?? [])
+            out.add(k);
+    return out;
+}
+export function intersectFilterKeys(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    const out = new Set();
+    for (const k of a)
+        if (b.has(k))
+            out.add(k);
+    return out;
+}
+export function buildFlatDimPredicate(input) {
+    const hasSearch = input.searchQuery.length > 0;
+    const isFlat = input.viewMode === 'flat';
+    const keys = isFlat ? input.filterVisibleKeys : undefined;
+    if (!hasSearch && keys === undefined)
+        return undefined;
+    return (name) => {
+        if (hasSearch && !fuzzyMatches(input.searchQuery, name))
+            return true;
+        if (keys !== undefined && !keys.has(name))
+            return true;
+        return false;
+    };
+}

package/dist/src/import/tui/steps/AtomicGenerateReviewStep.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+type GenerateReviewStepProps = {
+    extractSessionId: string;
+    onFinalize: (accepted: number, rejected: number, unresolved: number) => void;
+    onQuit: () => void;
+    /**
+     * Feature 2 (live preview after every save). When `true` (default), the
+     * wizard re-runs `previewImport` after each successful FieldEditor Ctrl+S
+     * (debounced 500ms) and refreshes the sidebar's previewAnnotation badges.
+     * Operator opts out via `experiences import --no-live-preview`.
+     */
+    livePreview?: boolean;
+    spaceId?: string;
+    environmentId?: string;
+    cmaToken?: string;
+    host?: string;
+    tokensPath?: string;
+    /**
+     * INTEG-4411 refined: initial value for the inline `finalizeError` banner.
+     * The wizard sets this when it routes back to `final-review` after the
+     * preview API returned an empty diff (pure no-op push). Cleared on the
+     * next `a` / `A` keystroke.
+     */
+    initialFinalizeError?: string | null;
+};
+/**
+ * Sort components for the final-review sidebar so the underlying data array
+ * matches the visual order. Empty components (zero classified $properties)
+ * surface at the top via the warning-tier path in Sidebar.tsx; we mirror that
+ * here so `selectedIdx` indexes into the same order the user sees. Without
+ * this, j/k navigation lands on different rows than the visually-selected
+ * one (INTEG-4259).
+ *
+ * Within each tier (empty / non-empty) we tie-break alphabetically by `key`.
+ */
+export declare function sortComponentsForSidebar<T extends {
+    key: string;
+    entry: CDFComponentEntry;
+}>(components: T[]): T[];
+export declare function AtomicGenerateReviewStep({ extractSessionId, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }: GenerateReviewStepProps): React.ReactElement;
+export {};