@contentful/experience-design-system-cli 2.12.4-dev-build-ff57340.0 → 2.13.1-dev-build-fa478b3.0

package/dist/src/analyze/pre-classify.d.ts

@@ -1,17 +0,0 @@
-import type { RawPropDefinition, RawComponentDefinition } from '../types.js';
-export interface PreClassification {
-    category: 'content' | 'design' | 'state' | 'exclude';
-    cdfTypeHint?: 'string' | 'enum' | 'richtext' | 'media' | 'boolean';
-}
-/**
- * Deterministic pre-classification rule engine.
- * Applies rules in priority order and returns on the first match.
- */
-export declare function preClassifyProp(prop: RawPropDefinition): PreClassification | undefined;
-/**
- * Applies pre-classification to all props in a component definition.
- * - Leaves existing category values unchanged
- * - Sets category for content/design/state matches
- * - Does NOT set category for 'exclude' results (leaves undefined)
- */
-export declare function preClassifyComponent(component: RawComponentDefinition): RawComponentDefinition;

package/dist/src/analyze/pre-classify.js

@@ -1,211 +0,0 @@
-/**
- * Determines whether a type string represents a simple/primitive type
- * (string, boolean, number, or string literal union) vs a complex type
- * (object, function, array, generic, etc.).
- */
-function isSimpleType(type) {
-    const t = type.trim();
-    if (t === 'string' || t === 'boolean' || t === 'number')
-        return true;
-    // String literal union (e.g., "'a' | 'b'")
-    if (isStringLiteralUnion(t))
-        return true;
-    return false;
-}
-function isStringLiteralUnion(type) {
-    return type.includes('|') && type.includes("'");
-}
-function isBooleanType(type) {
-    return type.trim() === 'boolean';
-}
-function isStringType(type) {
-    return type.trim() === 'string';
-}
-function isNumberType(type) {
-    return type.trim() === 'number';
-}
-function isComplexType(type) {
-    return !isSimpleType(type);
-}
-const DOM_PASS_THROUGH_PROPS = new Set([
-    // Bare HTML / framework styling pass-through
-    'className',
-    'class',
-    'classes',
-    'classNames',
-    'rootClassName',
-    'prefixCls',
-    'style',
-    'styles',
-    // Bare HTML attributes
-    'id',
-    'role',
-    'tabIndex',
-    'tabindex',
-    'name',
-    'htmlFor',
-    'for',
-    'slot',
-    'is',
-    'lang',
-    'dir',
-    'hidden',
-    'draggable',
-    'spellCheck',
-    'spellcheck',
-    'contentEditable',
-    'contenteditable',
-    'inputMode',
-    'inputmode',
-    'autoComplete',
-    'autocomplete',
-    'autoFocus',
-    'autofocus',
-    'translate',
-    'part',
-    'exportparts',
-    'aria',
-    // Framework theming / pass-through escape hatches — dev-facing, never marketer-configurable
-    'dt',
-    'pt',
-    'ptOptions',
-    'unstyled',
-    // Polymorphic component props — change rendered HTML/component, not marketer-visible behavior
-    'as',
-    'element',
-    'component',
-    // QA / vendor test attributes
-    'dataQa',
-    'data-qa',
-    // Vue v-model internals — framework wiring, never marketer-configurable
-    'modelValue',
-    'modelModifiers',
-]);
-function isDomPassThroughProp(name) {
-    if (DOM_PASS_THROUGH_PROPS.has(name))
-        return true;
-    // aria-label, aria-hidden, ariaLabel, ariaHidden — both kebab and camel forms
-    if (/^aria[-A-Z]/.test(name))
-        return true;
-    if (name.startsWith('data-'))
-        return true;
-    return false;
-}
-/**
- * Deterministic pre-classification rule engine.
- * Applies rules in priority order and returns on the first match.
- */
-export function preClassifyProp(prop) {
-    const { name, type } = prop;
-    // Rule 1: Event handlers
-    // name starts with `on` + uppercase, OR type contains `=> void` or `EventHandler`
-    if (/^on[A-Z]/.test(name) || type.includes('=> void') || type.includes('EventHandler')) {
-        return { category: 'exclude' };
-    }
-    // Rule 2: Refs
-    if (name === 'ref' || name === 'innerRef' || type.includes('Ref<') || type.includes('RefObject<')) {
-        return { category: 'exclude' };
-    }
-    // Rule 3: Test IDs
-    if (name === 'testId' || name === 'data-testid' || name === 'dataTestId') {
-        return { category: 'exclude' };
-    }
-    // Rule 4: Key prop
-    if (name === 'key') {
-        return { category: 'exclude' };
-    }
-    // Rule 5: Dispatch/setter
-    if (type.includes('Dispatch<') || type.includes('SetStateAction')) {
-        return { category: 'exclude' };
-    }
-    // Rule 6: DOM / a11y / framework pass-through props
-    // These are escape hatches developers use to wire components into the DOM.
-    // Marketers should never configure them in the ExO editor; exposing them
-    // generates noise that obscures the props that actually carry intent.
-    if (isDomPassThroughProp(name)) {
-        return { category: 'exclude' };
-    }
-    // Rule 7: String literal union
-    if (isStringLiteralUnion(type)) {
-        return { category: 'design', cdfTypeHint: 'enum' };
-    }
-    // Rule 8: Design name patterns (only for simple types)
-    if (!isComplexType(type)) {
-        const designNameStart = /^(variant|size|spacing|gap|color|bg|theme|align|layout|orientation|position)/i;
-        const designNameEnd = /(Color|Size|Variant|Style)$/;
-        if (designNameStart.test(name) || designNameEnd.test(name)) {
-            return { category: 'design', cdfTypeHint: 'string' };
-        }
-    }
-    // Rule 10: Boolean + state names (checked before rule 9 since state names
-    // like "disabled" would otherwise match the visual toggle prefix "disable")
-    if (isBooleanType(type)) {
-        const stateNames = ['disabled', 'loading', 'expanded', 'isOpen', 'selected', 'checked', 'active', 'preview'];
-        if (stateNames.includes(name)) {
-            return { category: 'state', cdfTypeHint: 'boolean' };
-        }
-    }
-    // Rule 9: Boolean + visual toggle name
-    if (isBooleanType(type)) {
-        const visualToggle = /^(hide|show|enable|disable|vertical|horizontal|reverse|bold|italic|imageOn|with)/i;
-        if (visualToggle.test(name)) {
-            return { category: 'design', cdfTypeHint: 'boolean' };
-        }
-    }
-    // Rule 11: State identifiers
-    if (name === 'componentId' || name === 'sectionKey' || name === 'locale' || name === 'variantIndex') {
-        return { category: 'state', cdfTypeHint: 'string' };
-    }
-    // Rule 12: URL patterns (string type only)
-    if (isStringType(type)) {
-        const urlNameStart = /^(href|url|link|src)/i;
-        const urlNameEnd = /(Url|Href|Link|Src)$/;
-        if (urlNameStart.test(name) || urlNameEnd.test(name)) {
-            return { category: 'content', cdfTypeHint: 'string' };
-        }
-    }
-    // Rule 13: Text patterns (string type only)
-    if (isStringType(type)) {
-        const textNameStart = /^(label|title|text|description|caption|heading|subheading|body|alt|name|placeholder|summary)/i;
-        const textNameEnd = /(Text|Label|Title|Name)$/;
-        if (textNameStart.test(name) || textNameEnd.test(name)) {
-            return { category: 'content', cdfTypeHint: 'string' };
-        }
-    }
-    // Rule 14: Remaining strings
-    if (isStringType(type)) {
-        return { category: 'content', cdfTypeHint: 'string' };
-    }
-    // Rule 15: Remaining booleans
-    if (isBooleanType(type)) {
-        return { category: 'design', cdfTypeHint: 'boolean' };
-    }
-    // Rule 16: Remaining numbers
-    if (isNumberType(type)) {
-        return { category: 'design', cdfTypeHint: 'string' };
-    }
-    // Rule 17: Complex/object/function/array types — no hint
-    return undefined;
-}
-/**
- * Applies pre-classification to all props in a component definition.
- * - Leaves existing category values unchanged
- * - Sets category for content/design/state matches
- * - Does NOT set category for 'exclude' results (leaves undefined)
- */
-export function preClassifyComponent(component) {
-    const props = component.props.map((prop) => {
-        // If category is already set, leave unchanged
-        if (prop.category) {
-            return prop;
-        }
-        const result = preClassifyProp(prop);
-        // If no result or excluded, leave unchanged
-        if (!result || result.category === 'exclude') {
-            return prop;
-        }
-        // Set category hint
-        return { ...prop, category: result.category };
-    });
-    return { ...component, props };
-}

package/dist/src/apply/error-parser.d.ts

@@ -1,43 +0,0 @@
-/**
- * INTEG-4401 Fix C — parse EDSI failure bodies into a structured shape the
- * TUI can render without dumping timestamps + trace ids at operators.
- *
- * EDSI failure bodies come in three broad shapes today:
- *
- *   1. Plain JSON error:
- *      `{"code":"TopoSortCycleError","message":"...","cycle":["CycleA","CycleB"]}`
- *
- *   2. Wrapper JSON with `details`:
- *      `{"sys":{"type":"Error"},"message":"...","details":{"code":"...","cycle":[...]}}`
- *
- *   3. Lambda log-line spill (the response body is the CloudWatch log
- *      formatting the worker's uncaught exception):
- *      `2026-07-07T22:26:26.479Z\t<request-id>\tERROR\t[dd.trace_id=... dd.span_id=...] <message> {\n  operationId: '...',\n  code: 'TopoSortCycleError',\n  cycle: [ 'CycleA', 'CycleB' ]\n}`
- *
- * We parse each shape best-effort and fall back to a cleaned raw message so
- * the ErrorStep never has to show the operator a timestamp + trace id.
- */
-export interface ParsedEdsiError {
-    /** Server-side error code, if we could extract one. */
-    code: string | null;
-    /** Human-readable message, stripped of log/trace decoration. */
-    message: string;
-    /** Cycle participants, when `code === 'TopoSortCycleError'`. */
-    cycle: string[] | null;
-    /** True when the message survived cleaning as-is (no parseable structure). */
-    raw: boolean;
-}
-/**
- * Strip the Lambda/CloudWatch log-line decoration from the head of a body so
- * the operator-facing message reads as an error sentence, not a log entry.
- */
-export declare function stripLambdaLogPrefix(body: string): string;
-export declare function parseEdsiError(rawInput: string | undefined | null): ParsedEdsiError;
-/**
- * Render a parsed error into a short multi-line block for the ErrorStep.
- * Callers can pass `verbose: true` to include the raw body underneath.
- */
-export declare function formatParsedEdsiError(parsed: ParsedEdsiError, opts?: {
-    verbose?: boolean;
-    raw?: string;
-}): string;

package/dist/src/apply/error-parser.js

@@ -1,163 +0,0 @@
-/**
- * INTEG-4401 Fix C — parse EDSI failure bodies into a structured shape the
- * TUI can render without dumping timestamps + trace ids at operators.
- *
- * EDSI failure bodies come in three broad shapes today:
- *
- *   1. Plain JSON error:
- *      `{"code":"TopoSortCycleError","message":"...","cycle":["CycleA","CycleB"]}`
- *
- *   2. Wrapper JSON with `details`:
- *      `{"sys":{"type":"Error"},"message":"...","details":{"code":"...","cycle":[...]}}`
- *
- *   3. Lambda log-line spill (the response body is the CloudWatch log
- *      formatting the worker's uncaught exception):
- *      `2026-07-07T22:26:26.479Z\t<request-id>\tERROR\t[dd.trace_id=... dd.span_id=...] <message> {\n  operationId: '...',\n  code: 'TopoSortCycleError',\n  cycle: [ 'CycleA', 'CycleB' ]\n}`
- *
- * We parse each shape best-effort and fall back to a cleaned raw message so
- * the ErrorStep never has to show the operator a timestamp + trace id.
- */
-const LAMBDA_LOG_PREFIX_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\s+[0-9a-f-]+\s+ERROR\s+(?:\[dd\.[^\]]*\]\s*)?/;
-const DD_TAG_RE = /\[dd\.(?:trace_id|span_id)=[^\]]*\]\s*/g;
-/**
- * Strip the Lambda/CloudWatch log-line decoration from the head of a body so
- * the operator-facing message reads as an error sentence, not a log entry.
- */
-export function stripLambdaLogPrefix(body) {
-    let out = body.replace(LAMBDA_LOG_PREFIX_RE, '');
-    out = out.replace(DD_TAG_RE, '');
-    return out.trim();
-}
-/**
- * Extract a JS-object-literal tail like `{ operationId: '...', code: '...', cycle: [ 'A', 'B' ] }`
- * that Lambda-spilled errors trail with. Returns `null` if no such structure
- * is present or the fields we care about can't be recovered.
- */
-function parseObjectLiteralTail(body) {
-    const braceStart = body.lastIndexOf('{');
-    if (braceStart === -1)
-        return null;
-    const tail = body.slice(braceStart);
-    const codeMatch = tail.match(/code:\s*['"]([^'"]+)['"]/);
-    const cycleMatch = tail.match(/cycle:\s*\[\s*([^\]]*)\s*\]/);
-    if (!codeMatch && !cycleMatch)
-        return null;
-    const code = codeMatch ? codeMatch[1] : null;
-    let cycle = null;
-    if (cycleMatch) {
-        cycle = cycleMatch[1]
-            .split(',')
-            .map((s) => s.trim().replace(/^['"]|['"]$/g, ''))
-            .filter((s) => s.length > 0);
-        if (cycle.length === 0)
-            cycle = null;
-    }
-    return { code, cycle };
-}
-/**
- * Best-effort JSON parse walking one level deep into `details`. Fields we
- * accept anywhere in the top-level or `details` object: `code`, `message`,
- * `cycle`. Returns `null` when the input isn't JSON.
- */
-function parseJsonBody(body) {
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== 'object')
-        return null;
-    const p = parsed;
-    const details = (p.details && typeof p.details === 'object' ? p.details : {});
-    const pick = (k) => (p[k] !== undefined ? p[k] : details[k]);
-    const codeRaw = pick('code');
-    const messageRaw = pick('message');
-    const cycleRaw = pick('cycle');
-    const out = {};
-    if (typeof codeRaw === 'string')
-        out.code = codeRaw;
-    if (typeof messageRaw === 'string')
-        out.message = messageRaw;
-    if (Array.isArray(cycleRaw)) {
-        const strs = cycleRaw.filter((x) => typeof x === 'string');
-        if (strs.length > 0)
-            out.cycle = strs;
-    }
-    return out;
-}
-/**
- * Parse an EDSI error body (the raw response body, or an `ApiError.message`
- * that has the body appended). Always returns a value — the fallback is the
- * cleaned raw message with `code: null`.
- */
-// ApiError.message shape: `${phasePrefix}\n${body}` where phasePrefix looks
-// like `apply failed: 400`, `preview failed: 422`, `poll failed: 500`. We
-// only strip the prefix line when the first line matches this shape —
-// otherwise a raw body that happens to contain a newline (e.g. a Lambda log
-// spill with a multi-line object literal) gets truncated mid-structure.
-const API_ERROR_PREFIX_RE = /^(?:apply|preview|poll) failed: \d+$/;
-export function parseEdsiError(rawInput) {
-    if (!rawInput)
-        return { code: null, message: '', cycle: null, raw: true };
-    const nlIndex = rawInput.indexOf('\n');
-    let body = rawInput;
-    let prefix = '';
-    if (nlIndex !== -1) {
-        const firstLine = rawInput.slice(0, nlIndex);
-        if (API_ERROR_PREFIX_RE.test(firstLine)) {
-            prefix = firstLine;
-            body = rawInput.slice(nlIndex + 1);
-        }
-    }
-    const cleaned = stripLambdaLogPrefix(body);
-    const json = parseJsonBody(cleaned) ?? parseJsonBody(body);
-    if (json && (json.code || json.message || json.cycle)) {
-        return {
-            code: json.code ?? null,
-            message: json.message ?? (cleaned || prefix),
-            cycle: json.cycle ?? null,
-            raw: false,
-        };
-    }
-    const literal = parseObjectLiteralTail(cleaned);
-    if (literal && (literal.code || literal.cycle)) {
-        // Grab the human-readable head — text before the trailing `{`. This is
-        // the sentence part of a Lambda log-line spill (e.g. "Apply operation
-        // <id> rejected: ComponentType slot dependency cycle detected among:
-        // CycleA, CycleB. Break the cycle by...").
-        const braceStart = cleaned.lastIndexOf('{');
-        const head = braceStart === -1 ? cleaned : cleaned.slice(0, braceStart).trim();
-        return {
-            code: literal.code ?? null,
-            message: head || cleaned,
-            cycle: literal.cycle ?? null,
-            raw: false,
-        };
-    }
-    return { code: null, message: cleaned || prefix || rawInput, cycle: null, raw: true };
-}
-/**
- * Render a parsed error into a short multi-line block for the ErrorStep.
- * Callers can pass `verbose: true` to include the raw body underneath.
- */
-export function formatParsedEdsiError(parsed, opts = {}) {
-    const lines = [];
-    if (parsed.code) {
-        lines.push(`[${parsed.code}]`);
-    }
-    if (parsed.message) {
-        lines.push(parsed.message);
-    }
-    if (parsed.cycle && parsed.cycle.length > 0) {
-        lines.push(`Cycle: ${parsed.cycle.join(' → ')} → ${parsed.cycle[0]}`);
-        lines.push('Break the cycle by removing at least one $allowedComponents entry.');
-    }
-    if (opts.verbose && opts.raw) {
-        lines.push('');
-        lines.push('--- raw ---');
-        lines.push(opts.raw);
-    }
-    return lines.filter(Boolean).join('\n');
-}