@santi020k/lumen 3.0.0 → 4.0.0

package/dist/integration-diagnostics.js

@@ -2,6 +2,8 @@ import { createHash } from 'node:crypto';
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { extname, join, relative, resolve, sep } from 'node:path';
 import { lumenComponentBehavior, lumenComponentNames, lumenGlobalBehaviors, lumenStylingContracts } from '@santi020k/lumen-core';
+import { createSourceFile, forEachChild, isForOfStatement, isImportDeclaration, isNamedImports, isStringLiteral, ScriptKind, ScriptTarget, SyntaxKind } from 'typescript';
+import { findMarkupTagEnd, getMarkupStart } from './v2-migration.js';
 const sourceExtensions = new Set(['.astro', '.css', '.js', '.jsx', '.mjs', '.ts', '.tsx']);
 const ignoredDirectories = new Set([
     '.astro',
@@ -330,6 +332,199 @@ const getGlobalRuntimeBehaviors = (sources) => lumenGlobalBehaviors
     return behavior.authoredBy.split(',').some(eventName => item.source.includes(eventName.trim()));
 }))
     .map(behavior => behavior.name);
+const isRuntimeImport = (statement) => (isImportDeclaration(statement) && isStringLiteral(statement.moduleSpecifier) &&
+    statement.moduleSpecifier.text === '@santi020k/lumen-astro/runtime');
+const getDefaultRuntimeName = (binding) => !binding.isTypeOnly && (binding.propertyName?.text ?? binding.name.text) === 'default' ? [binding.name.text] : [];
+const getImportRuntimeNames = (statement) => {
+    const clause = statement.importClause;
+    if (!clause || clause.phaseModifier === SyntaxKind.TypeKeyword)
+        return [];
+    const names = clause.name ? [clause.name.text] : [];
+    const bindings = clause.namedBindings;
+    if (!bindings || !isNamedImports(bindings))
+        return names;
+    return [...names, ...bindings.elements.flatMap(getDefaultRuntimeName)];
+};
+const getRuntimeBindingNames = ({ file, source }) => {
+    if (!source.includes('@santi020k/lumen-astro/runtime'))
+        return new Set(['UIPrimitives']);
+    try {
+        const parsed = createSourceFile(file, source, ScriptTarget.Latest, false, ScriptKind.TS);
+        const imports = parsed.statements.filter(isRuntimeImport);
+        // Preserve canonical-name detection for legacy imports and wrapper components.
+        return imports.length > 0 ? new Set(imports.flatMap(getImportRuntimeNames)) : new Set(['UIPrimitives']);
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+        return new Set();
+    }
+};
+const runtimeTagDelimiter = /[\s/>]/u;
+const getMarkupNameEnd = (source, start) => {
+    let end = start + 1;
+    while (end < source.length && source[end] !== '<' && !runtimeTagDelimiter.test(source[end] ?? ''))
+        end += 1;
+    return end;
+};
+const skipRuntimeQuotedText = (source, start) => {
+    let end = start + 1;
+    while (end < source.length) {
+        if (source[end] === '\\')
+            end += 2;
+        else if (source[end] === source[start])
+            return end + 1;
+        else
+            end += 1;
+    }
+    return source.length;
+};
+const runtimeRegexPrefixes = new Set(['{', '(', '[', '=', ':', ',', ';', '!', '?', '&', '|', '+', '*', '%', '~', '^', '<', '>', '-']);
+const runtimeRegexKeywords = new Set(['return', 'throw', 'case', 'yield', 'typeof', 'void', 'delete', 'instanceof', 'in', 'new', 'await', 'else', 'do']);
+const getForOfRegexStarts = (source) => {
+    const starts = new Set();
+    try {
+        const parsed = createSourceFile('runtime.tsx', source, ScriptTarget.Latest, true, ScriptKind.TSX);
+        const pending = [parsed];
+        while (pending.length > 0) {
+            const node = pending.pop();
+            if (!node)
+                continue;
+            if (isForOfStatement(node))
+                starts.add(node.expression.getStart(parsed));
+            forEachChild(node, child => {
+                pending.push(child);
+            });
+        }
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+    }
+    return starts;
+};
+const runtimeCodePointStart = (source, index) => {
+    const current = source.charCodeAt(index);
+    const previous = source.charCodeAt(index - 1);
+    return current >= 0xdc00 && current <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff ? index - 1 : index;
+};
+const previousRuntimeCharacter = (source, start, pattern) => {
+    let previous = start;
+    while (previous >= 0) {
+        const pointStart = runtimeCodePointStart(source, previous);
+        if (!pattern.test(source.slice(pointStart, previous + 1)))
+            break;
+        previous = pointStart - 1;
+    }
+    return previous;
+};
+const isRuntimeRegexStart = (source, start, forOfStarts) => {
+    if (forOfStarts.has(start))
+        return true;
+    const previous = previousRuntimeCharacter(source, start - 1, /\s/u);
+    if (previous < 0 || runtimeRegexPrefixes.has(source[previous] ?? ''))
+        return true;
+    const wordEnd = previous + 1;
+    const wordStart = previousRuntimeCharacter(source, previous, /[$\u200c\u200d\p{ID_Continue}]/u) + 1;
+    const keyword = source.slice(wordStart, wordEnd);
+    if (!runtimeRegexKeywords.has(keyword))
+        return false;
+    return source[previousRuntimeCharacter(source, wordStart - 1, /\s/u)] !== '.';
+};
+const skipRuntimeRegex = (source, start) => {
+    let cursor = start + 1;
+    let inClass = false;
+    while (cursor < source.length) {
+        const character = source[cursor];
+        if (character === '\\')
+            cursor += 2;
+        else {
+            if (character === '[')
+                inClass = true;
+            else if (character === ']')
+                inClass = false;
+            else if (character === '/' && !inClass)
+                return cursor + 1;
+            cursor += 1;
+        }
+    }
+    return source.length;
+};
+const skipRuntimeExpressionTrivia = (source, start, depth, forOfStarts) => {
+    if (depth === 0)
+        return start;
+    if (/['"`]/u.test(source[start] ?? ''))
+        return skipRuntimeQuotedText(source, start);
+    if (source.startsWith('/*', start)) {
+        const end = source.indexOf('*/', start + 2);
+        return end < 0 ? source.length : end + 2;
+    }
+    if (source.startsWith('//', start)) {
+        const end = source.indexOf('\n', start + 2);
+        return end < 0 ? source.length : end + 1;
+    }
+    if (source[start] === '/' && isRuntimeRegexStart(source, start, forOfStarts))
+        return skipRuntimeRegex(source, start);
+    return start;
+};
+const skipRuntimeRawText = (lowerSource, name, start) => {
+    if (name !== 'script' && name !== 'style')
+        return start;
+    let closing = lowerSource.indexOf(`</${name}`, start);
+    while (closing >= 0 && !runtimeTagDelimiter.test(lowerSource[closing + name.length + 2] ?? '')) {
+        closing = lowerSource.indexOf(`</${name}`, closing + name.length + 2);
+    }
+    return closing < 0 ? lowerSource.length : closing;
+};
+const getRuntimeExpressionDepth = (character, depth) => {
+    if (character === '{')
+        return depth + 1;
+    return character === '}' ? Math.max(0, depth - 1) : depth;
+};
+const skipRuntimeMarkupTrivia = (source, start) => {
+    if (source.startsWith('<!--', start)) {
+        const end = source.indexOf('-->', start + 4);
+        return end < 0 ? source.length : end + 3;
+    }
+    return /[A-Za-z_$/]/u.test(source[start + 1] ?? '') ? start : start + 1;
+};
+const countRuntimeMounts = (entry) => {
+    const names = getRuntimeBindingNames(entry);
+    let count = 0;
+    let depth = 0;
+    let start = getMarkupStart(entry.source, entry.file);
+    const forOfStarts = new Set([...getForOfRegexStarts(entry.source.slice(start))].map(position => position + start));
+    const lowerSource = entry.source.replace(/[A-Z]/gu, character => character.toLowerCase());
+    while (start < entry.source.length) {
+        const skipped = skipRuntimeExpressionTrivia(entry.source, start, depth, forOfStarts);
+        if (skipped !== start) {
+            start = skipped;
+            continue;
+        }
+        const character = entry.source[start];
+        depth = getRuntimeExpressionDepth(character, depth);
+        if (character !== '<') {
+            start += 1;
+            continue;
+        }
+        const markupStart = skipRuntimeMarkupTrivia(entry.source, start);
+        if (markupStart !== start) {
+            start = markupStart;
+            continue;
+        }
+        const end = getMarkupNameEnd(entry.source, start);
+        const name = entry.source.slice(start + 1, end);
+        const tagEnd = findMarkupTagEnd(entry.source, end, true);
+        if (tagEnd < 0) {
+            start += 1;
+            continue;
+        }
+        if (names.has(name) && runtimeTagDelimiter.test(entry.source[end] ?? ''))
+            count += 1;
+        start = skipRuntimeRawText(lowerSource, name, tagEnd + 1);
+    }
+    return count;
+};
 const collectRuntimeFindings = (repositoryRoot, boundary) => {
     const runtimeImports = getRuntimeImports(boundary.sources);
     const runtimeComponents = [
@@ -338,15 +533,16 @@ const collectRuntimeFindings = (repositoryRoot, boundary) => {
             ...getGlobalRuntimeBehaviors(boundary.sources)
         ])
     ];
-    const mountSources = boundary.sources.filter(item => /<UIPrimitives(?:\s|\/|>)/u.test(item.source));
+    const mountSources = boundary.sources
+        .map(item => ({ ...item, mountCount: countRuntimeMounts(item) }))
+        .filter(item => item.mountCount > 0);
     const findings = [];
     if (runtimeComponents.length > 0 && mountSources.length === 0) {
         const firstRuntimeImport = runtimeImports[0];
         findings.push(finding(firstRuntimeImport ? relative(repositoryRoot, firstRuntimeImport.file) : relative(repositoryRoot, boundary.root), 'astro-runtime-missing', `Interactive Astro usage requires UIPrimitives: ${runtimeComponents.join(', ')}.`, 'Mount <UIPrimitives /> once in the application root, or use a documented controlled prop when application code owns the behavior.'));
     }
     for (const mount of mountSources) {
-        const mountCount = [...mount.source.matchAll(/<UIPrimitives(?:\s|\/|>)/g)].length;
-        if (mountCount > 1) {
+        if (mount.mountCount > 1) {
             findings.push(finding(relative(repositoryRoot, mount.file), 'astro-runtime-duplicate', 'UIPrimitives is mounted more than once in this file.', 'Keep one mount in the application root layout.'));
         }
     }

package/dist/registry-component-name.d.ts

@@ -0,0 +1,2 @@
+export declare const isSafeRegistryComponentName: (name: unknown) => name is string;
+//# sourceMappingURL=registry-component-name.d.ts.map

package/dist/registry-component-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-component-name.d.ts","sourceRoot":"","sources":["../src/registry-component-name.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,2BAA2B,GAAI,MAAM,OAAO,KAAG,IAAI,IAAI,MAEnE,CAAA"}

package/dist/registry-component-name.js

@@ -0,0 +1,53 @@
+const reservedNames = new Set([
+    'arguments',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+// Names are interpolated into identifiers and custom-element tag names in the
+// generated wrappers. Use their shared ASCII subset, without module keywords.
+export const isSafeRegistryComponentName = (name) => (typeof name === 'string' && /^[A-Za-z_][A-Za-z0-9_]*(?![\s\S])/u.test(name) && !reservedNames.has(name));