accel2spa 0.0.0-stage → 0.1.0

package/dist/occ/reference.js

@@ -0,0 +1,104 @@
+/** Reference of what the OCC API exposes, used to detect data and endpoint gaps. */
+import { readFileSync } from 'node:fs';
+const readJson = (rel) => JSON.parse(readFileSync(new URL(rel, import.meta.url), 'utf8'));
+export function loadOccFields(overridePath) {
+    const bundled = readJson('./fields.json');
+    const endpoints = readJson('./endpoints.json').endpoints;
+    const fields = { rootVars: { ...bundled.rootVars }, types: structuredClone(bundled.types), endpoints: [...endpoints] };
+    if (!overridePath)
+        return { fields, source: 'bundled' };
+    const override = JSON.parse(readFileSync(overridePath, 'utf8'));
+    Object.assign(fields.rootVars, override.rootVars ?? {});
+    for (const [name, def] of Object.entries(override.types ?? {})) {
+        fields.types[name] = { ...(fields.types[name] ?? {}), ...def };
+    }
+    if (override.endpoints)
+        fields.endpoints.unshift(...override.endpoints);
+    return { fields, source: `bundled + ${overridePath}` };
+}
+const PRIMITIVES = new Set(['string', 'number', 'boolean', 'date', 'object', 'any']);
+export class OccReference {
+    fields;
+    constructor(fields) {
+        this.fields = fields;
+    }
+    lookup(typeName, field) {
+        const seen = new Set();
+        let t = typeName;
+        while (t && !seen.has(t)) {
+            seen.add(t);
+            const def = this.fields.types[t];
+            if (!def)
+                return undefined;
+            if (field in def && field !== '$extends')
+                return def[field];
+            t = def.$extends;
+        }
+        return undefined;
+    }
+    hasType(name) {
+        return name in this.fields.types;
+    }
+    /** Type of an EL root variable, following `forEach`/`set` aliases and tag attribute types. */
+    rootType(root, aliases, overrides, depth = 0) {
+        if (overrides[root])
+            return overrides[root];
+        const a = aliases[root];
+        if (a) {
+            if (a.ignore)
+                return undefined;
+            if (a.declaredType) {
+                const stripped = a.declaredType.replace(/Data$/, '');
+                if (this.hasType(stripped))
+                    return stripped;
+                if (this.hasType(a.declaredType))
+                    return a.declaredType;
+            }
+            if (a.from && depth < 6) {
+                const r = this.checkPath(a.from, aliases, overrides, depth + 1);
+                if (r.status === 'exposed' && r.resultType)
+                    return a.element ? r.resultType.replace(/\[\]$/, '') : r.resultType;
+                return undefined;
+            }
+        }
+        return this.fields.rootVars[root];
+    }
+    checkPath(path, aliases, overrides, depth = 0) {
+        const [root, ...segs] = path.split('.');
+        const rootType = this.rootType(root, aliases, overrides, depth);
+        if (!rootType)
+            return { status: 'unchecked' };
+        let current = rootType;
+        for (const seg of segs) {
+            const base = current.replace(/\[\]$/, '');
+            if (PRIMITIVES.has(base))
+                return { status: 'exposed', occType: rootType, resultType: base };
+            if (current.endsWith('[]') && ['size', 'length', 'empty'].includes(seg)) {
+                return { status: 'exposed', occType: rootType, resultType: 'number' };
+            }
+            if (!this.hasType(base))
+                return { status: 'unchecked', occType: rootType };
+            const next = this.lookup(base, seg);
+            if (next === undefined)
+                return { status: 'missing', occType: rootType, missingField: seg };
+            current = next;
+        }
+        return { status: 'exposed', occType: rootType, resultType: current };
+    }
+    /** Which OCC endpoint replaces this storefront URL, if known. */
+    matchEndpoint(url, method) {
+        for (const e of this.fields.endpoints) {
+            if (e.method && method !== 'ANY' && e.method.toUpperCase() !== method.toUpperCase())
+                continue;
+            const re = new RegExp('^' +
+                e.accelerator
+                    .split('/')
+                    .map((seg) => (seg === '**' ? '.*' : seg === '{param}' || /^\{.+\}$/.test(seg) ? '[^/]+' : seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')))
+                    .join('/') +
+                '/?$');
+            if (re.test(url))
+                return e.occ;
+        }
+        return undefined;
+    }
+}

package/dist/renderers/spec.d.ts

@@ -0,0 +1,4 @@
+import type { Model, UnitModel } from '../model.js';
+type Ctx = Pick<Model, 'languages' | 'referenceLanguage' | 'storefront'>;
+export declare function renderSpec(unit: UnitModel, ctx: Ctx): string;
+export {};

package/dist/renderers/spec.js

@@ -0,0 +1,264 @@
+/** Renders one Markdown spec (YAML frontmatter + 9 sections) per page/component. */
+import { stringify } from 'yaml';
+const ref = (r) => `\`${r.file}:${r.line}\``;
+const cell = (s) => (s ?? '').replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+const code = (s) => '`' + s.replace(/`/g, "'") + '`';
+const refList = (refs, max = 2) => refs.slice(0, max).map(ref).join(', ') + (refs.length > max ? ` (+${refs.length - max} more)` : '');
+const uniq = (a) => [...new Set(a)];
+function pascal(url) {
+    const words = url
+        .split(/[/{}\-_.]+/)
+        .filter((w) => w && w !== 'param')
+        .map((w) => w[0].toUpperCase() + w.slice(1));
+    return words.join('') || 'Endpoint';
+}
+/** Guess a TS type + mock value from a field name (purely heuristic). */
+function guessField(name) {
+    if (/^(is|has|can|show|enable)|enabled$|active$|requested$/i.test(name))
+        return { ts: 'boolean', mock: 'false' };
+    if (/(count|total|points|qty|quantity|amount|balance|price|value|number|days|left|width|height|size)$/i.test(name))
+        return { ts: 'number', mock: '0' };
+    if (/(date|time|expires|expiry|at|window)$/i.test(name))
+        return { ts: 'string', mock: "'2030-01-01T00:00:00Z'" };
+    if (/(list|items|entries|links)$/i.test(name))
+        return { ts: 'unknown[]', mock: '[]' };
+    return { ts: 'string', mock: "''" };
+}
+function renderTree(node, depth = 0) {
+    const loc = node.line ? ` (included at ${ref({ file: node.file, line: node.line })})` : '';
+    const rep = node.repeated ? ' (already listed above)' : '';
+    const out = [`${'  '.repeat(depth)}- ${code(node.name)} -> ${code(node.file)}${depth ? loc.replace(/ \(included at .*\)/, '') : ''}${rep}`];
+    for (const c of node.children)
+        out.push(...renderTree(c, depth + 1));
+    return out;
+}
+function describeCondition(c) {
+    if (c.kind === 'otherwise')
+        return 'in every other case (c:otherwise)';
+    return `when ${code(c.test ?? '?')}`;
+}
+function endpointInterfaces(e) {
+    const base = pascal(e.url);
+    const lines = [];
+    if (e.requestFields.length) {
+        lines.push(`export interface ${base}Request {`);
+        for (const f of e.requestFields)
+            lines.push(`  ${f}: ${guessField(f).ts};`);
+        lines.push('}', '');
+    }
+    lines.push(`export interface ${base}Response {`);
+    if (e.responseFields.length)
+        for (const f of e.responseFields)
+            lines.push(`  ${f}: ${guessField(f).ts};`);
+    else
+        lines.push('  // TODO: no response fields detected in the source; inspect the real payload.');
+    lines.push('}', '');
+    const reqParam = e.requestFields.length ? `request: ${base}Request` : '';
+    lines.push(`export abstract class ${base}Adapter {`, `  abstract call(${reqParam}): Observable<${base}Response>; // ${e.method} ${e.url}`, '}', '', `export class Mock${base}Adapter extends ${base}Adapter {`, `  call(${reqParam}): Observable<${base}Response> {`, `    return of({ ${e.responseFields.map((f) => `${f}: ${guessField(f).mock}`).join(', ')} });`, '  }', '}');
+    return lines.join('\n');
+}
+export function renderSpec(unit, ctx) {
+    const missingData = unit.data.filter((d) => d.status === 'missing');
+    const missingEndpoints = unit.endpoints.filter((e) => e.status === 'missing');
+    const langs = ctx.languages.map((l) => l.lang);
+    const hasCoverage = langs.length > 0;
+    const refLang = ctx.referenceLanguage;
+    const frontmatter = stringify({
+        id: unit.id,
+        kind: unit.kind,
+        source: unit.files,
+        route: unit.route,
+        complexity: unit.complexity.level,
+        dependsOn: unit.dependsOn,
+        gaps: unit.gaps.map((g) => g.id)
+    }).trimEnd();
+    const L = [];
+    L.push('---', frontmatter, '---', '', `# Migration spec: ${unit.id}`, '');
+    // 1. Context
+    L.push('## 1. Context', '');
+    if (unit.kind === 'page') {
+        L.push(`Accelerator page ${code(unit.file)} from the \`${ctx.storefront}\` storefront. It composes ${unit.tagIncludes.length} tag include(s) across ${unit.files.length} source file(s). Target: a Spartacus page at ${code(unit.route)}${unit.routeSource === 'derived' ? ' (route derived from the file name; confirm it)' : ''}.`);
+    }
+    else {
+        L.push(`CMS component ${unit.cmsType ? code(unit.cmsType) : ''} rendered by ${code(unit.file)} from the \`${ctx.storefront}\` storefront. Target: a Spartacus CMS component mapped through \`cmsComponents\` config.`);
+    }
+    L.push('');
+    L.push(`Detected: ${unit.conditionals.length} conditional(s), ${unit.i18n.length} i18n key(s), ${missingData.length} OCC data gap(s), ${missingEndpoints.length} endpoint gap(s), ${unit.hardcoded.length} hardcoded string(s).`, `Complexity: **${unit.complexity.level}** (score ${unit.complexity.score}; heuristic: 2 per conditional and data gap, 3 per missing endpoint, 1 per tag file, 0.5 per missing translation or hardcoded string).`);
+    if (unit.cmsSlots.length)
+        L.push('', `CMS slots rendered: ${unit.cmsSlots.map((s) => `${code(s.position)} (${ref(s)})`).join(', ')}.`);
+    L.push('');
+    // 2. Pointers
+    L.push('## 2. Pointers, not copies', '', 'Read these in the original source; this spec intentionally does not inline it.', '');
+    for (const f of unit.files)
+        L.push(`- ${code(f)}`);
+    if (unit.tagIncludes.length) {
+        L.push('', 'Tag includes:');
+        for (const t of unit.tagIncludes)
+            L.push(`- ${code(t.name)} at ${ref(t)}${t.tagFile ? ` -> ${code(t.tagFile)}` : ' (tag file not found)'}`);
+    }
+    if (ctx.languages.length) {
+        L.push('', 'Message bundles:');
+        for (const l of ctx.languages)
+            L.push(`- ${code(l.file)} (${l.lang}, ${l.keyCount} keys)`);
+    }
+    L.push('');
+    // 3. Structure & conditional rules
+    L.push('## 3. Structure and conditional rules', '', 'Component tree:', '', ...renderTree(unit.tree), '');
+    if (unit.conditionals.length) {
+        L.push('| # | Where | Controls | Rule |', '|---|-------|----------|------|');
+        unit.conditionals.forEach((c, i) => {
+            const group = c.chooseGroup ? ` (branch of choose ${c.chooseGroup})` : '';
+            L.push(`| ${i + 1} | ${ref(c)}-${c.endLine} | ${c.layout} ${cell(c.label)}${cell(group)} | ${cell(describeCondition(c))} |`);
+        });
+    }
+    else {
+        L.push('No conditional logic detected.');
+    }
+    L.push('');
+    // 4. i18n
+    L.push('## 4. i18n', '');
+    if (unit.i18n.length) {
+        L.push(`| Key | ${refLang ? `Text (${refLang})` : 'Text'} | Missing in | Used at |`, '|-----|------|------------|---------|');
+        for (const u of unit.i18n) {
+            const text = (refLang && u.texts[refLang]) || u.defaultText || Object.values(u.texts)[0] || '(not defined)';
+            L.push(`| ${code(u.key)} | ${cell(text)} | ${u.missingIn.length ? u.missingIn.join(', ') : '-'} | ${u.refs.map(ref).join(', ')} |`);
+        }
+        L.push('');
+        if (hasCoverage) {
+            L.push('Coverage:', '');
+            for (const c of unit.i18nCoverage)
+                L.push(`- ${c.lang}: ${c.present}/${c.total} keys`);
+            L.push('');
+        }
+    }
+    else {
+        L.push('No i18n keys used.', '');
+    }
+    if (unit.dynamicI18n.length) {
+        L.push('Dynamic keys (cannot be checked statically):', '');
+        for (const d of unit.dynamicI18n)
+            L.push(`- ${code(d.expression)} at ${ref(d)}`);
+        L.push('');
+    }
+    if (unit.hardcoded.length) {
+        L.push('Hardcoded strings (must become translation keys):', '');
+        for (const h of unit.hardcoded)
+            L.push(`- ${ref(h)}: "${cell(h.text)}"${h.attribute ? ` (attribute ${h.attribute})` : ''}`);
+        L.push('');
+    }
+    // 5. Data & endpoints
+    L.push('## 5. Data and endpoints', '');
+    L.push(`OCC reference: ${code('src/occ/fields.json')} (an approximation; verify against your OCC API docs).`, '');
+    const checked = unit.data.filter((d) => d.status !== 'unchecked');
+    if (checked.length) {
+        L.push('| Expression | OCC type | OCC exposes it? | Used at |', '|------------|----------|-----------------|---------|');
+        for (const d of checked) {
+            const status = d.status === 'missing' ? `**NO** (gap: \`${d.missingField}\`)` : 'yes';
+            L.push(`| ${code(d.path)} | ${d.occType ?? '-'} | ${status} | ${refList(d.refs)} |`);
+        }
+    }
+    else {
+        L.push('No model data with a known OCC type was detected.');
+    }
+    L.push('');
+    const unchecked = unit.data.filter((d) => d.status === 'unchecked');
+    if (unchecked.length)
+        L.push(`Not verified (unknown root variable): ${unchecked.map((d) => code(d.path)).join(', ')}`, '');
+    if (unit.endpoints.length) {
+        L.push('| Call | Status | Used at |', '|------|--------|---------|');
+        for (const e of unit.endpoints) {
+            const status = e.status === 'missing' ? '**no OCC equivalent**' : e.status === 'mapped' ? `OCC: ${code(e.occEquivalent ?? '')}` : 'external';
+            L.push(`| ${code(`${e.method} ${e.url}`)} (${e.kind}) | ${status} | ${e.refs.map(ref).join(', ')} |`);
+        }
+    }
+    else {
+        L.push('No AJAX/fetch/form endpoints detected.');
+    }
+    L.push('');
+    // 6. Acceptance criteria
+    L.push('## 6. Verifiable acceptance criteria', '');
+    for (const c of unit.conditionals) {
+        if (c.kind === 'otherwise') {
+            L.push(`- [ ] The ${c.layout} at ${ref(c)} is rendered only when none of the other branches of its choose block matches.`);
+        }
+        else {
+            L.push(`- [ ] The ${c.layout} ${c.label} (${ref(c)}) is rendered only ${describeCondition(c)}, and is absent from the DOM otherwise.`);
+        }
+    }
+    for (const lang of langs) {
+        const missing = unit.i18n.filter((u) => u.missingIn.includes(lang));
+        if (missing.length)
+            L.push(`- [ ] Add the ${missing.length} missing key(s) to ${lang}: ${missing.map((m) => code(m.key)).join(', ')}.`);
+    }
+    if (hasCoverage)
+        L.push(`- [ ] All ${unit.i18n.length} keys of this ${unit.kind} exist in every language (${langs.join(', ')}); a build check fails otherwise.`);
+    L.push(`- [ ] No literal user-facing strings in the Spartacus template${unit.hardcoded.length ? ` (${unit.hardcoded.length} in the source today)` : ''}.`);
+    for (const d of missingData)
+        L.push(`- [ ] ${code(d.path)} renders from an agreed OCC field or a documented extension, never empty because the backend omits it.`);
+    for (const e of missingEndpoints)
+        L.push(`- [ ] ${code(`${e.method} ${e.url}`)} is consumed through a typed adapter; switching from mock to real is a provider change only.`);
+    for (const e of unit.endpoints.filter((x) => x.status === 'mapped'))
+        L.push(`- [ ] ${code(`${e.method} ${e.url}`)} is replaced by ${code(e.occEquivalent ?? '')}.`);
+    L.push('');
+    // 7. Visual parity
+    L.push('## 7. Visual parity', '');
+    if (unit.kind === 'page') {
+        L.push(`- Current URL: ${unit.currentUrl ? code(unit.currentUrl) : 'unknown (confirm in the running Accelerator storefront)'}`);
+        L.push(`- Spartacus route: ${code(unit.route)}`);
+    }
+    else {
+        L.push('- Compare the component inside the same CMS slot on the current and the new storefront.');
+    }
+    L.push('- States to compare side by side:');
+    L.push('  - [ ] Empty (no data / condition false)', '  - [ ] Loading / skeleton', '  - [ ] Error (failed request)', '  - [ ] Filled (every conditional branch above, at least once)', '');
+    // 8. Blockers
+    L.push('## 8. Blockers', '');
+    if (!missingData.length && !missingEndpoints.length) {
+        L.push('No backend dependency detected.', '');
+    }
+    if (missingData.length) {
+        L.push('### OCC data gaps (backend work)', '');
+        const byType = new Map();
+        for (const d of missingData) {
+            const t = d.occType ?? 'Unknown';
+            byType.set(t, [...(byType.get(t) ?? []), d]);
+        }
+        for (const [type, list] of byType) {
+            const fields = uniq(list.map((d) => d.path.split('.').slice(1).join('.')));
+            L.push(`${type}: expose ${fields.map(code).join(', ')} in OCC (DTO + field mapping), or agree on an extension payload.`, '');
+            for (const d of list)
+                if (d.note)
+                    L.push(`- ${code(d.path)}: ${d.note}`);
+            L.push('', 'Suggested typed shape + mock while the backend is pending (field types are guesses):', '', '```ts');
+            L.push(`export interface ${type}Extension {`);
+            for (const f of uniq(list.map((d) => d.path.split('.')[1])))
+                L.push(`  ${f}?: ${guessField(f).ts};`);
+            L.push('}', '```', '');
+        }
+    }
+    if (missingEndpoints.length) {
+        L.push('### Missing endpoints', '');
+        for (const e of missingEndpoints) {
+            L.push(`${code(`${e.method} ${e.url}`)} (${e.refs.map(ref).join(', ')}): no OCC equivalent known. Suggested typed interface and mock adapter (shape inferred from the calling code; verify against the real response):`, '', '```ts', "import { Observable, of } from 'rxjs';", '', endpointInterfaces(e), '```', '');
+        }
+    }
+    // 9. Tasks
+    L.push('## 9. Tasks', '');
+    L.push(`- [ ] Create the Spartacus ${unit.kind === 'page' ? `page at ${code(unit.route)}` : 'CMS component and register it in the config'}.`);
+    L.push(`- [ ] Port the structure from section 3 (${unit.tagIncludes.length} tag include(s) become Angular components or template fragments).`);
+    if (unit.conditionals.length)
+        L.push(`- [ ] Implement the ${unit.conditionals.length} conditional rule(s) from section 3 and cover each with a test.`);
+    L.push(`- [ ] Move the ${unit.i18n.length} translation key(s) to the Spartacus i18n resources in every language${unit.hardcoded.length ? `; replace the ${unit.hardcoded.length} hardcoded string(s)` : ''}.`);
+    for (const d of missingData)
+        L.push(`- [ ] Backend: expose ${code(d.path)} through OCC (or agree a fallback).`);
+    for (const e of missingEndpoints)
+        L.push(`- [ ] Backend: provide ${code(`${e.method} ${e.url}`)}; frontend: typed interface + mock adapter first.`);
+    L.push('- [ ] Visual parity review for the states in section 7.');
+    if (unit.warnings.length) {
+        L.push('', '## Analyzer warnings', '');
+        for (const w of unit.warnings)
+            L.push(`- ${w}`);
+    }
+    L.push('');
+    return L.join('\n');
+}

package/dist/routes.d.ts

@@ -0,0 +1,6 @@
+/** Known mapping from Accelerator page ids to current URL and the suggested Spartacus route. */
+export declare function suggestRoute(pageId: string): {
+    currentUrl?: string;
+    route: string;
+    routeSource: 'known' | 'derived';
+};

package/dist/routes.js

@@ -0,0 +1,19 @@
+/** Known mapping from Accelerator page ids to current URL and the suggested Spartacus route. */
+// Order matters: first match wins.
+const RULES = [
+    { match: /order-detail/, current: '/my-account/order/{orderCode}', route: '/my-account/order/:orderCode' },
+    { match: /order-history|^orders?$|account-orders/, current: '/my-account/orders', route: '/my-account/orders' },
+    { match: /^cart$|cart-page/, current: '/cart', route: '/cart' },
+    { match: /checkout/, current: '/checkout', route: '/checkout' },
+    { match: /product-detail/, current: '/{productName}/p/{productCode}', route: '/product/:productCode' },
+    { match: /^search/, current: '/search?text={query}', route: '/search/:query' },
+    { match: /^(home|homepage)$/, current: '/', route: '/' },
+    { match: /^login/, current: '/login', route: '/login' }
+];
+export function suggestRoute(pageId) {
+    for (const r of RULES) {
+        if (r.match.test(pageId))
+            return { currentUrl: r.current, route: r.route, routeSource: 'known' };
+    }
+    return { route: '/' + pageId, routeSource: 'derived' };
+}

package/dist/scanners/cms.d.ts

@@ -0,0 +1,29 @@
+import type { CmsComponentType } from '../model.js';
+export interface ImpexRecordSet {
+    mode: string;
+    type: string;
+    columns: string[];
+    rows: Array<{
+        values: string[];
+        line: number;
+    }>;
+    file: string;
+    line: number;
+}
+/** Parse ImpEx headers and rows. Macros, comments and malformed lines are skipped. */
+export declare function parseImpex(text: string, file: string): ImpexRecordSet[];
+export interface ItemTypeDef {
+    code: string;
+    extends?: string;
+    attributes: Array<{
+        name: string;
+        type?: string;
+        line: number;
+    }>;
+    file: string;
+    line: number;
+}
+/** Parse `<itemtype>` definitions from a `*-items.xml` file. */
+export declare function parseItemsXml(text: string, file: string): ItemTypeDef[];
+/** Merge ImpEx and items.xml information into CMS component types. */
+export declare function buildCmsTypes(sets: ImpexRecordSet[], items: ItemTypeDef[]): CmsComponentType[];

package/dist/scanners/cms.js

@@ -0,0 +1,110 @@
+/** CMS scanners: ImpEx files and `*-items.xml` type definitions (regex based). */
+import { LineMap } from '../util.js';
+const STANDARD_COLUMNS = new Set([
+    'uid', 'name', 'catalogversion', 'visible', 'restrictions', 'actions', 'onlyonerestrictionmustapply',
+    '&componentref', 'cmscomponents', 'slotid', 'position', 'page', 'contentslot', 'template'
+]);
+function columnName(raw) {
+    return raw.replace(/\[[^\]]*\]/g, '').replace(/\([^)]*\)/g, '').trim();
+}
+/** Parse ImpEx headers and rows. Macros, comments and malformed lines are skipped. */
+export function parseImpex(text, file) {
+    const sets = [];
+    let current;
+    const lines = text.replace(/^/, '').split(/\r?\n/);
+    lines.forEach((raw, idx) => {
+        const line = raw.trim();
+        if (!line || line.startsWith('#') || line.startsWith('$')) {
+            if (!line)
+                current = undefined;
+            return;
+        }
+        const header = /^(INSERT_UPDATE|INSERT|UPDATE|REMOVE)\s+([A-Za-z_][\w]*)\s*(;.*)?$/.exec(line);
+        if (header) {
+            const cols = (header[3] ?? '').split(';').slice(1).map((c) => c.trim());
+            current = { mode: header[1], type: header[2], columns: cols, rows: [], file, line: idx + 1 };
+            sets.push(current);
+            return;
+        }
+        if (current && line.startsWith(';')) {
+            current.rows.push({ values: line.split(';').slice(1).map((v) => v.trim()), line: idx + 1 });
+        }
+    });
+    return sets;
+}
+/** Parse `<itemtype>` definitions from a `*-items.xml` file. */
+export function parseItemsXml(text, file) {
+    const out = [];
+    const lines = new LineMap(text);
+    const clean = text.replace(/<!--[\s\S]*?-->/g, (m) => m.replace(/[^\n]/g, ' '));
+    const typeRe = /<itemtype\b([^>]*)>([\s\S]*?)<\/itemtype>/g;
+    let m;
+    while ((m = typeRe.exec(clean))) {
+        const attrs = (s, name) => new RegExp(`\\b${name}\\s*=\\s*"([^"]*)"`).exec(s)?.[1];
+        const code = attrs(m[1], 'code');
+        if (!code)
+            continue;
+        const bodyOffset = m.index + m[0].indexOf('>') + 1;
+        const attributes = [];
+        const attrRe = /<attribute\b([^>]*)>/g;
+        let am;
+        while ((am = attrRe.exec(m[2]))) {
+            const qualifier = attrs(am[1], 'qualifier');
+            if (qualifier)
+                attributes.push({ name: qualifier, type: attrs(am[1], 'type'), line: lines.lineAt(bodyOffset + am.index) });
+        }
+        out.push({ code, extends: attrs(m[1], 'extends'), attributes, file, line: lines.lineAt(m.index) });
+    }
+    return out;
+}
+const isComponentName = (n) => /Component$/.test(n);
+/** Merge ImpEx and items.xml information into CMS component types. */
+export function buildCmsTypes(sets, items) {
+    const byCode = new Map();
+    const get = (code) => {
+        let t = byCode.get(code);
+        if (!t) {
+            t = { code, attributes: [], instances: [] };
+            byCode.set(code, t);
+        }
+        return t;
+    };
+    const itemByCode = new Map(items.map((i) => [i.code, i]));
+    const isComponentItem = (code, depth = 0) => {
+        if (isComponentName(code))
+            return true;
+        const it = itemByCode.get(code);
+        return !!it?.extends && depth < 10 && isComponentItem(it.extends, depth + 1);
+    };
+    for (const it of items) {
+        if (!isComponentItem(it.code))
+            continue;
+        const t = get(it.code);
+        t.extends = it.extends;
+        for (const a of it.attributes) {
+            t.attributes.push({ name: a.name, type: a.type, file: it.file, line: a.line, source: 'items.xml' });
+        }
+    }
+    for (const set of sets) {
+        if (!isComponentName(set.type))
+            continue;
+        const t = get(set.type);
+        const cols = set.columns.map(columnName);
+        cols.forEach((c, i) => {
+            if (!c || c.startsWith('$') || STANDARD_COLUMNS.has(c.toLowerCase()))
+                return;
+            if (!t.attributes.some((a) => a.name === c)) {
+                t.attributes.push({ name: c, file: set.file, line: set.line, source: 'impex' });
+            }
+            void i;
+        });
+        const uidIdx = cols.findIndex((c) => c.toLowerCase() === 'uid');
+        const nameIdx = cols.findIndex((c) => c.toLowerCase() === 'name');
+        for (const row of set.rows) {
+            const uid = uidIdx >= 0 ? row.values[uidIdx] : undefined;
+            if (uid)
+                t.instances.push({ uid, name: nameIdx >= 0 ? row.values[nameIdx] : undefined, file: set.file, line: row.line });
+        }
+    }
+    return [...byCode.values()].sort((a, b) => a.code.localeCompare(b.code));
+}

package/dist/scanners/js.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lightweight detection of HTTP calls in JavaScript (also used for inline <script> blocks in JSPs).
+ * Regex based: no JS parser.
+ */
+export interface RawEndpoint {
+    kind: 'ajax' | 'fetch' | 'xhr' | 'c:url' | 'form';
+    method: string;
+    url: string;
+    line: number;
+    requestFields: string[];
+    responseFields: string[];
+}
+/** Normalize a URL-ish string: strips context path, query/hash; dynamic parts become `{param}`. */
+export declare function normalizeUrlText(raw: string): string | undefined;
+export declare function isStaticUrl(url: string): boolean;
+/** Evaluate a concatenation like `ctx + '/a/' + id` into `/a/{param}`. */
+export declare function evalUrlExpr(expr: string): string | undefined;
+/**
+ * Scan JavaScript source for $.ajax / $.get / $.post / fetch / axios / XHR calls.
+ * `lineAt` maps an index in `code` to a line number in the original file.
+ */
+export declare function scanJsEndpoints(code: string, lineAt: (index: number) => number): RawEndpoint[];