koppajs-language-core 0.1.0

package/dist/language/templateComponents.js

@@ -0,0 +1,1248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectImportedKpaComponents = collectImportedKpaComponents;
+exports.collectCanonicalTemplateTags = collectCanonicalTemplateTags;
+exports.collectCanonicalTemplateComponentUsages = collectCanonicalTemplateComponentUsages;
+exports.collectKnownTemplateComponents = collectKnownTemplateComponents;
+exports.collectWorkspaceTemplateComponentUsagesForResolvedFile = collectWorkspaceTemplateComponentUsagesForResolvedFile;
+exports.getCanonicalTemplateTagAtOffset = getCanonicalTemplateTagAtOffset;
+exports.resolveCanonicalTemplateComponentAtOffset = resolveCanonicalTemplateComponentAtOffset;
+exports.findImportedKpaComponentForSymbol = findImportedKpaComponentForSymbol;
+exports.getImportedKpaComponentLocalSymbols = getImportedKpaComponentLocalSymbols;
+exports.collectCanonicalTemplateTagsForComponent = collectCanonicalTemplateTagsForComponent;
+exports.normalizeComponentRenameTarget = normalizeComponentRenameTarget;
+exports.getImportedKpaComponentApi = getImportedKpaComponentApi;
+exports.getResolvedTemplateComponentApi = getResolvedTemplateComponentApi;
+exports.collectCanonicalTemplateComponentDiagnostics = collectCanonicalTemplateComponentDiagnostics;
+exports.resolveTemplateComponentAtOffset = resolveTemplateComponentAtOffset;
+exports.toKebabCase = toKebabCase;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const kpaBlocks_1 = require("../data/kpaBlocks");
+const diagnosticCodes_1 = require("./diagnosticCodes");
+const localSymbolReferences_1 = require("./localSymbolReferences");
+const parser_1 = require("./parser");
+const projectConfig_1 = require("./projectConfig");
+const sourcePositions_1 = require("./sourcePositions");
+const componentContract_1 = require("./componentContract");
+const symbols_1 = require("./symbols");
+const workspaceRegistrations_1 = require("./workspaceRegistrations");
+const componentApiCache = new Map();
+const allowedPassthroughComponentAttributes = new Set([
+    'else',
+    'else-if',
+    'aria-label',
+    'class',
+    'id',
+    'if',
+    'key',
+    'loop',
+    'ref',
+    'slot',
+    'style',
+]);
+function collectImportedKpaComponents(document, sourcePath) {
+    return document.blocks.flatMap((block) => isScriptBlock(block) ? collectComponentsFromScriptBlock(document, block, sourcePath) : []);
+}
+function collectCanonicalTemplateTags(document) {
+    return document.blocks.flatMap((block) => block.name === kpaBlocks_1.canonicalTemplateBlock
+        ? collectTemplateTagMatchesFromBlock(document, block).map((match) => createTemplateTag(document, block, match))
+        : []);
+}
+function collectCanonicalTemplateComponentUsages(document, sourcePath) {
+    const componentsByTagName = new Map();
+    for (const component of collectImportedKpaComponents(document, sourcePath)) {
+        for (const tagName of component.tagNames) {
+            componentsByTagName.set(tagName, component);
+        }
+    }
+    return document.blocks.flatMap((block) => {
+        if (block.name !== kpaBlocks_1.canonicalTemplateBlock) {
+            return [];
+        }
+        return collectTemplateTagMatchesFromBlock(document, block).flatMap((match) => {
+            if (match.isClosing) {
+                return [];
+            }
+            const component = componentsByTagName.get(match.name);
+            if (!component) {
+                return [];
+            }
+            return [
+                {
+                    attributes: match.attributes.map((attribute) => createTemplateAttribute(document, block, attribute)),
+                    component,
+                    insertOffset: block.contentRange.start.offset + match.insertionIndex,
+                    tag: createTemplateTag(document, block, match),
+                },
+            ];
+        });
+    });
+}
+function collectKnownTemplateComponents(document, sourcePath) {
+    const components = [];
+    const seenTagNames = new Set();
+    for (const component of collectImportedKpaComponents(document, sourcePath)) {
+        components.push({
+            importedComponent: component,
+            importPath: component.importPath,
+            kind: 'imported',
+            name: component.name,
+            resolvedFilePath: component.resolvedFilePath,
+            tagNames: component.tagNames,
+        });
+        for (const tagName of component.tagNames) {
+            seenTagNames.add(tagName);
+        }
+    }
+    for (const registration of (0, workspaceRegistrations_1.collectWorkspaceComponentRegistrations)(sourcePath)) {
+        if (seenTagNames.has(registration.tagName)) {
+            continue;
+        }
+        seenTagNames.add(registration.tagName);
+        components.push({
+            kind: 'workspace-registration',
+            name: registration.componentName,
+            registration,
+            resolvedFilePath: registration.resolvedFilePath,
+            tagNames: [registration.tagName],
+        });
+    }
+    return components;
+}
+function collectCanonicalTemplateComponentCallSites(document, sourcePath) {
+    const componentsByTagName = createKnownTemplateComponentsByTagName(document, sourcePath);
+    return document.blocks.flatMap((block) => {
+        if (block.name !== kpaBlocks_1.canonicalTemplateBlock) {
+            return [];
+        }
+        const matches = collectTemplateTagMatchesFromBlock(document, block);
+        const callSites = [];
+        const openTagStack = [];
+        for (const match of matches) {
+            const component = componentsByTagName.get(match.name);
+            if (!component) {
+                continue;
+            }
+            if (match.isClosing) {
+                const matchingOpenIndex = findMatchingOpenComponentIndex(openTagStack, component, match.name);
+                if (matchingOpenIndex === -1) {
+                    continue;
+                }
+                const openTag = openTagStack.splice(matchingOpenIndex, 1)[0];
+                const openingUsage = createCanonicalTemplateComponentCallSite(document, block, openTag.match, component, match);
+                callSites.push(openingUsage);
+                continue;
+            }
+            if (match.isSelfClosing) {
+                callSites.push(createCanonicalTemplateComponentCallSite(document, block, match, component));
+                continue;
+            }
+            openTagStack.push({
+                component,
+                match,
+            });
+        }
+        for (const openTag of openTagStack) {
+            callSites.push(createCanonicalTemplateComponentCallSite(document, block, openTag.match, openTag.component));
+        }
+        return callSites;
+    });
+}
+function collectWorkspaceTemplateComponentUsagesForResolvedFile(document, sourcePath, resolvedFilePath) {
+    return collectImportedKpaComponents(document, sourcePath)
+        .filter((component) => component.resolvedFilePath === resolvedFilePath)
+        .map((component) => ({
+        component,
+        symbolRanges: deduplicateRanges((0, localSymbolReferences_1.collectLocalReferenceRangesForSymbols)(document, getImportedKpaComponentLocalSymbols(document, sourcePath, component))),
+        tags: collectCanonicalTemplateTagsForComponent(document, component),
+    }));
+}
+function getCanonicalTemplateTagAtOffset(document, offset) {
+    return collectCanonicalTemplateTags(document).find((tag) => offset >= tag.range.start.offset && offset <= tag.range.end.offset);
+}
+function resolveCanonicalTemplateComponentAtOffset(document, sourcePath, offset) {
+    const tag = getCanonicalTemplateTagAtOffset(document, offset);
+    if (!tag) {
+        return undefined;
+    }
+    const component = collectImportedKpaComponents(document, sourcePath).find((candidate) => candidate.tagNames.includes(tag.name));
+    if (!component) {
+        return undefined;
+    }
+    return {
+        component,
+        tag,
+    };
+}
+function findImportedKpaComponentForSymbol(document, sourcePath, symbol) {
+    return collectImportedKpaComponents(document, sourcePath).find((component) => component.name === symbol.name &&
+        component.importRange.start.offset === symbol.range.start.offset &&
+        component.importRange.end.offset === symbol.range.end.offset);
+}
+function getImportedKpaComponentLocalSymbols(document, sourcePath, component) {
+    return (0, symbols_1.collectLocalScriptSymbols)(document).all.filter((symbol) => symbol.kind === 'import' &&
+        findImportedKpaComponentForSymbol(document, sourcePath, symbol)?.name === component.name);
+}
+function collectCanonicalTemplateTagsForComponent(document, component) {
+    return collectCanonicalTemplateTags(document).filter((tag) => component.tagNames.includes(tag.name));
+}
+function normalizeComponentRenameTarget(requestedName) {
+    const trimmedName = requestedName.trim();
+    const symbolName = trimmedName.includes('-') ? toPascalCase(trimmedName) : trimmedName;
+    if (!/^[A-Za-z_$][\w$]*$/.test(symbolName)) {
+        throw new Error(`Komponentenname [${requestedName}] ist ungueltig. Erwartet wird ein gueltiger Bezeichner oder Kebab-Case.`);
+    }
+    return {
+        kebabTagName: toKebabCase(symbolName),
+        symbolName,
+    };
+}
+function getImportedKpaComponentApi(component) {
+    return readComponentApiFromFile(component.resolvedFilePath);
+}
+function getResolvedTemplateComponentApi(component) {
+    if (component.kind === 'imported' && component.importedComponent) {
+        return getImportedKpaComponentApi(component.importedComponent);
+    }
+    return readComponentApiFromFile(component.resolvedFilePath);
+}
+function collectCanonicalTemplateComponentDiagnostics(document, sourcePath) {
+    const importedComponents = collectImportedKpaComponents(document, sourcePath);
+    const knownComponentTags = new Set(collectKnownTemplateComponents(document, sourcePath).flatMap((component) => component.tagNames));
+    const diagnostics = [];
+    for (const component of importedComponents) {
+        if (!component.importPath.endsWith('.kpa') || component.resolvedFilePath) {
+            continue;
+        }
+        diagnostics.push({
+            code: diagnosticCodes_1.kpaDiagnosticCodes.unresolvedComponentImport,
+            message: `Komponenten-Import [${component.name}] verweist auf [${component.importPath}], konnte aber nicht im Workspace aufgeloest werden.`,
+            range: toDiagnosticRange(component.importRange),
+        });
+    }
+    for (const tag of collectCanonicalTemplateTags(document)) {
+        if (tag.isClosing || !looksLikeComponentTagName(tag.name) || knownComponentTags.has(tag.name)) {
+            continue;
+        }
+        diagnostics.push({
+            code: diagnosticCodes_1.kpaDiagnosticCodes.unresolvedComponentTag,
+            data: {
+                componentName: tag.name.includes('-') ? toPascalCase(tag.name) : tag.name,
+                tagName: tag.name,
+            },
+            message: `Komponente [${tag.name}] wurde im [template]-Block verwendet, aber nicht als .kpa-Import gefunden.`,
+            range: toDiagnosticRange(tag.range),
+        });
+    }
+    for (const callSite of collectCanonicalTemplateComponentCallSites(document, sourcePath)) {
+        const componentApi = getResolvedTemplateComponentApi(callSite.component);
+        if (!componentApi) {
+            continue;
+        }
+        const providedProps = new Set();
+        const propsByAlias = new Map();
+        for (const prop of componentApi.props) {
+            for (const alias of createComponentPropAliases(prop.name)) {
+                propsByAlias.set(alias, prop);
+            }
+        }
+        const hasSpreadAttribute = callSite.attributes.some((attribute) => attribute.kind === 'spread');
+        for (const attribute of callSite.attributes) {
+            if (attribute.kind === 'spread' || isEventBindingAttribute(attribute.name)) {
+                continue;
+            }
+            const prop = propsByAlias.get(getComponentPropLookupName(attribute.name));
+            if (!prop) {
+                if (shouldWarnUnknownComponentAttribute(attribute.name)) {
+                    diagnostics.push({
+                        code: diagnosticCodes_1.kpaDiagnosticCodes.unknownComponentProp,
+                        message: `Attribut [${attribute.name}] ist kein bekanntes Prop von Komponente [${callSite.component.name}].`,
+                        range: toDiagnosticRange(attribute.range),
+                    });
+                }
+                continue;
+            }
+            providedProps.add(prop.name);
+            const isExpressionAssignable = prop.typeText &&
+                attribute.kind === 'expression' &&
+                isExpressionAttributeAssignableToPropType(document, sourcePath, attribute, prop.typeText);
+            const inferredValueType = isExpressionAssignable === undefined ? inferAttributeType(attribute) : undefined;
+            if (prop.typeText &&
+                ((isExpressionAssignable === false && attribute.kind === 'expression') ||
+                    (inferredValueType && !isCompatiblePropType(prop.typeText, inferredValueType)))) {
+                diagnostics.push({
+                    code: diagnosticCodes_1.kpaDiagnosticCodes.invalidComponentPropType,
+                    message: `Prop [${prop.name}] an Komponente [${callSite.component.name}] erwartet [${prop.typeText}], erhalten wurde [${attribute.kind === 'expression'
+                        ? attribute.valueText?.trim() || 'Ausdruck'
+                        : (inferredValueType ?? 'unbekannt')}].`,
+                    range: toDiagnosticRange(attribute.range),
+                });
+            }
+        }
+        if (componentApi.emits.length > 0) {
+            const knownEmitNames = new Set(componentApi.emits.map((entry) => entry.name));
+            for (const attribute of callSite.eventAttributes) {
+                const emitName = getEventNameFromAttribute(attribute.name);
+                if (!emitName || knownEmitNames.has(emitName)) {
+                    continue;
+                }
+                diagnostics.push({
+                    code: diagnosticCodes_1.kpaDiagnosticCodes.unknownComponentEmit,
+                    message: `Event-Handler [${attribute.name}] verweist auf unbekanntes Emit [${emitName}] von Komponente [${callSite.component.name}].`,
+                    range: toDiagnosticRange(attribute.range),
+                });
+            }
+        }
+        if (componentApi.slots.length > 0) {
+            const providedSlots = new Set(callSite.slotUsages.map((slotUsage) => slotUsage.name));
+            const knownSlotNames = new Set(componentApi.slots.map((entry) => entry.name));
+            if (callSite.hasDefaultSlotContent) {
+                providedSlots.add('default');
+            }
+            for (const slotUsage of callSite.slotUsages) {
+                if (knownSlotNames.has(slotUsage.name)) {
+                    continue;
+                }
+                diagnostics.push({
+                    code: diagnosticCodes_1.kpaDiagnosticCodes.unknownComponentSlot,
+                    message: `Slot [${slotUsage.name}] ist kein bekannter Slot von Komponente [${callSite.component.name}].`,
+                    range: toDiagnosticRange(slotUsage.range),
+                });
+            }
+            for (const requiredSlot of componentApi.slots.filter((slot) => !slot.optional)) {
+                if (providedSlots.has(requiredSlot.name)) {
+                    continue;
+                }
+                diagnostics.push({
+                    code: diagnosticCodes_1.kpaDiagnosticCodes.missingComponentSlot,
+                    message: `Required Slot [${requiredSlot.name}] fehlt an Komponente [${callSite.component.name}].`,
+                    range: toDiagnosticRange(callSite.tag.range),
+                });
+            }
+        }
+        if (hasSpreadAttribute) {
+            continue;
+        }
+        for (const requiredProp of componentApi.props.filter((prop) => !prop.optional)) {
+            if (providedProps.has(requiredProp.name)) {
+                continue;
+            }
+            diagnostics.push({
+                code: diagnosticCodes_1.kpaDiagnosticCodes.missingComponentProp,
+                data: {
+                    componentName: callSite.component.name,
+                    insertOffset: callSite.insertOffset,
+                    propName: requiredProp.name,
+                    propTypeText: requiredProp.typeText,
+                },
+                message: `Required Prop [${requiredProp.name}] fehlt an Komponente [${callSite.component.name}].`,
+                range: toDiagnosticRange(callSite.tag.range),
+            });
+        }
+    }
+    return diagnostics;
+}
+function resolveTemplateComponentAtOffset(document, sourcePath, offset) {
+    const tag = getCanonicalTemplateTagAtOffset(document, offset);
+    if (!tag) {
+        return undefined;
+    }
+    const component = findKnownTemplateComponentByTagName(document, sourcePath, tag.name);
+    if (!component) {
+        return undefined;
+    }
+    return {
+        component,
+        tag,
+    };
+}
+function collectComponentsFromScriptBlock(document, block, sourcePath) {
+    const content = document.text.slice(block.contentRange.start.offset, block.contentRange.end.offset);
+    const sourceFile = typescript_1.default.createSourceFile(createEmbeddedFileName(block.kind), content, typescript_1.default.ScriptTarget.Latest, true, block.kind === 'script-ts' ? typescript_1.default.ScriptKind.TS : typescript_1.default.ScriptKind.JS);
+    return sourceFile.statements.flatMap((statement) => {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteral(statement.moduleSpecifier)) {
+            return [];
+        }
+        const importClause = statement.importClause;
+        if (!importClause || importClause.isTypeOnly) {
+            return [];
+        }
+        const importPath = statement.moduleSpecifier.text;
+        const resolvedFilePath = resolveComponentImportPath(importPath, sourcePath);
+        const isExplicitKpaImport = importPath.endsWith('.kpa');
+        const isResolvedKpaImport = resolvedFilePath?.endsWith('.kpa') === true;
+        if (!isExplicitKpaImport && !isResolvedKpaImport) {
+            return [];
+        }
+        const importedBindings = [];
+        if (importClause.name) {
+            importedBindings.push(importClause.name);
+        }
+        if (importClause.namedBindings && typescript_1.default.isNamedImports(importClause.namedBindings)) {
+            for (const element of importClause.namedBindings.elements) {
+                if (!element.isTypeOnly) {
+                    importedBindings.push(element.name);
+                }
+            }
+        }
+        return importedBindings.map((binding) => ({
+            importPath,
+            importRange: createDocumentRange(document, block, binding.getStart(sourceFile), binding.end),
+            name: binding.text,
+            resolvedFilePath,
+            tagNames: createComponentTagNames(binding.text),
+        }));
+    });
+}
+function collectTemplateTagMatchesFromBlock(document, block) {
+    const content = document.text.slice(block.contentRange.start.offset, block.contentRange.end.offset);
+    const tags = [];
+    for (let index = 0; index < content.length; index++) {
+        if (startsMustacheExpression(content, index)) {
+            const expressionEnd = findMustacheExpressionEnd(content, index + 2);
+            if (expressionEnd === undefined) {
+                break;
+            }
+            index = Math.max(index, expressionEnd + 1);
+            continue;
+        }
+        if (content[index] !== '<') {
+            continue;
+        }
+        const tagMatch = readTagAt(content, index);
+        if (!tagMatch) {
+            continue;
+        }
+        tags.push(tagMatch);
+        index = Math.max(index, tagMatch.tagEnd - 1);
+    }
+    return tags;
+}
+function readTagAt(content, index) {
+    let cursor = index + 1;
+    let isClosing = false;
+    if (content[cursor] === '/') {
+        isClosing = true;
+        cursor++;
+    }
+    while (isWhitespace(content[cursor])) {
+        cursor++;
+    }
+    const nameStart = cursor;
+    if (!isTagNameStart(content[cursor])) {
+        return undefined;
+    }
+    cursor++;
+    while (isTagNameCharacter(content[cursor])) {
+        cursor++;
+    }
+    const nameEnd = cursor;
+    const attributes = [];
+    while (cursor < content.length) {
+        while (isWhitespace(content[cursor])) {
+            cursor++;
+        }
+        if (content[cursor] === '>') {
+            return {
+                attributes,
+                insertionIndex: trimTagInsertionIndex(content, nameEnd, cursor),
+                isClosing,
+                isSelfClosing: false,
+                name: content.slice(nameStart, nameEnd),
+                nameEnd,
+                nameStart,
+                tagEnd: cursor + 1,
+            };
+        }
+        if (content[cursor] === '/' && content[cursor + 1] === '>') {
+            return {
+                attributes,
+                insertionIndex: trimTagInsertionIndex(content, nameEnd, cursor),
+                isClosing,
+                isSelfClosing: true,
+                name: content.slice(nameStart, nameEnd),
+                nameEnd,
+                nameStart,
+                tagEnd: cursor + 2,
+            };
+        }
+        const parsedAttribute = readAttributeAt(content, cursor);
+        if (!parsedAttribute) {
+            cursor++;
+            continue;
+        }
+        attributes.push(parsedAttribute.attribute);
+        cursor = parsedAttribute.nextIndex;
+    }
+    return {
+        attributes,
+        insertionIndex: trimTagInsertionIndex(content, nameEnd, cursor),
+        isClosing,
+        isSelfClosing: false,
+        name: content.slice(nameStart, nameEnd),
+        nameEnd,
+        nameStart,
+        tagEnd: cursor,
+    };
+}
+function readAttributeAt(content, index) {
+    if (content[index] === '{') {
+        const bracedValue = readBracedValue(content, index);
+        if (!bracedValue) {
+            return undefined;
+        }
+        const normalizedValueText = bracedValue.valueText.trim();
+        if (!normalizedValueText.startsWith('...')) {
+            return {
+                attribute: {
+                    kind: 'expression',
+                    name: normalizedValueText,
+                    nameEnd: bracedValue.end,
+                    nameStart: index,
+                    valueEnd: bracedValue.end - 1,
+                    valueStart: index + 1,
+                    valueText: bracedValue.valueText,
+                },
+                nextIndex: bracedValue.end,
+            };
+        }
+        return {
+            attribute: {
+                kind: 'spread',
+                name: normalizedValueText,
+                nameEnd: bracedValue.end,
+                nameStart: index,
+                valueEnd: bracedValue.end - 1,
+                valueStart: index + 1,
+                valueText: bracedValue.valueText,
+            },
+            nextIndex: bracedValue.end,
+        };
+    }
+    if (!isAttributeNameStart(content[index])) {
+        return undefined;
+    }
+    let cursor = index + 1;
+    while (isAttributeNameCharacter(content[cursor])) {
+        cursor++;
+    }
+    const nameStart = index;
+    const nameEnd = cursor;
+    const name = content.slice(nameStart, nameEnd);
+    const isDynamicBinding = isDynamicBindingAttribute(name);
+    while (isWhitespace(content[cursor])) {
+        cursor++;
+    }
+    if (content[cursor] !== '=') {
+        return {
+            attribute: {
+                kind: 'boolean',
+                name,
+                nameEnd,
+                nameStart,
+            },
+            nextIndex: cursor,
+        };
+    }
+    cursor++;
+    while (isWhitespace(content[cursor])) {
+        cursor++;
+    }
+    if (content[cursor] === "'" || content[cursor] === '"') {
+        const quote = content[cursor];
+        const valueStart = cursor + 1;
+        cursor++;
+        while (cursor < content.length && content[cursor] !== quote) {
+            cursor++;
+        }
+        const valueEnd = cursor;
+        return {
+            attribute: {
+                kind: isDynamicBinding ? 'expression' : 'string',
+                name,
+                nameEnd,
+                nameStart,
+                valueEnd,
+                valueStart,
+                valueText: content.slice(valueStart, valueEnd),
+            },
+            nextIndex: cursor < content.length ? cursor + 1 : cursor,
+        };
+    }
+    if (content[cursor] === '{') {
+        const bracedValue = readBracedValue(content, cursor);
+        if (!bracedValue) {
+            return undefined;
+        }
+        return {
+            attribute: {
+                kind: 'expression',
+                name,
+                nameEnd,
+                nameStart,
+                valueEnd: bracedValue.end - 1,
+                valueStart: cursor + 1,
+                valueText: bracedValue.valueText,
+            },
+            nextIndex: bracedValue.end,
+        };
+    }
+    const valueStart = cursor;
+    while (cursor < content.length &&
+        !isWhitespace(content[cursor]) &&
+        content[cursor] !== '>' &&
+        !(content[cursor] === '/' && content[cursor + 1] === '>')) {
+        cursor++;
+    }
+    return {
+        attribute: {
+            kind: isDynamicBinding ? 'expression' : 'unquoted',
+            name,
+            nameEnd,
+            nameStart,
+            valueEnd: cursor,
+            valueStart,
+            valueText: content.slice(valueStart, cursor),
+        },
+        nextIndex: cursor,
+    };
+}
+function readBracedValue(content, startIndex) {
+    let cursor = startIndex + 1;
+    let depth = 1;
+    let quote;
+    let escaped = false;
+    while (cursor < content.length) {
+        const character = content[cursor];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                cursor++;
+                continue;
+            }
+            if (character === '\\') {
+                escaped = true;
+                cursor++;
+                continue;
+            }
+            if (character === quote) {
+                quote = undefined;
+            }
+            cursor++;
+            continue;
+        }
+        if (character === "'" || character === '"' || character === '`') {
+            quote = character;
+            cursor++;
+            continue;
+        }
+        if (character === '{') {
+            depth++;
+            cursor++;
+            continue;
+        }
+        if (character === '}') {
+            depth--;
+            if (depth === 0) {
+                return {
+                    end: cursor + 1,
+                    valueText: content.slice(startIndex + 1, cursor),
+                };
+            }
+        }
+        cursor++;
+    }
+    return undefined;
+}
+function startsMustacheExpression(content, index) {
+    return content[index] === '{' && content[index + 1] === '{';
+}
+function findMustacheExpressionEnd(content, startIndex) {
+    let cursor = startIndex;
+    let nestedBraceDepth = 0;
+    let quote;
+    let escaped = false;
+    while (cursor < content.length) {
+        const character = content[cursor];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                cursor++;
+                continue;
+            }
+            if (character === '\\') {
+                escaped = true;
+                cursor++;
+                continue;
+            }
+            if (character === quote) {
+                quote = undefined;
+            }
+            cursor++;
+            continue;
+        }
+        if (character === "'" || character === '"' || character === '`') {
+            quote = character;
+            cursor++;
+            continue;
+        }
+        if (character === '{') {
+            nestedBraceDepth++;
+            cursor++;
+            continue;
+        }
+        if (character === '}') {
+            if (nestedBraceDepth > 0) {
+                nestedBraceDepth--;
+                cursor++;
+                continue;
+            }
+            if (content[cursor + 1] === '}') {
+                return cursor;
+            }
+        }
+        cursor++;
+    }
+    return undefined;
+}
+function trimTagInsertionIndex(content, minimumIndex, closingIndex) {
+    let insertionIndex = closingIndex;
+    while (insertionIndex > minimumIndex && isWhitespace(content[insertionIndex - 1])) {
+        insertionIndex--;
+    }
+    return insertionIndex;
+}
+function createTemplateTag(document, block, match) {
+    return {
+        block,
+        isClosing: match.isClosing,
+        name: match.name,
+        range: (0, sourcePositions_1.createLocatedRange)(document.lineStarts, block.contentRange.start.offset + match.nameStart, block.contentRange.start.offset + match.nameEnd),
+    };
+}
+function createTemplateAttribute(document, block, attribute) {
+    return {
+        kind: attribute.kind,
+        name: attribute.name,
+        range: (0, sourcePositions_1.createLocatedRange)(document.lineStarts, block.contentRange.start.offset + attribute.nameStart, block.contentRange.start.offset + attribute.nameEnd),
+        valueRange: attribute.valueStart !== undefined && attribute.valueEnd !== undefined
+            ? (0, sourcePositions_1.createLocatedRange)(document.lineStarts, block.contentRange.start.offset + attribute.valueStart, block.contentRange.start.offset + attribute.valueEnd)
+            : undefined,
+        valueText: attribute.valueText,
+    };
+}
+function createCanonicalTemplateComponentCallSite(document, block, openingMatch, component, closingMatch) {
+    const openingTag = createTemplateTag(document, block, openingMatch);
+    const bodyStartOffset = block.contentRange.start.offset + openingMatch.tagEnd;
+    const bodyEndOffset = closingMatch
+        ? block.contentRange.start.offset + closingMatch.nameStart - 1
+        : bodyStartOffset;
+    const slotUsages = closingMatch && bodyEndOffset >= bodyStartOffset
+        ? collectSlotUsagesFromContent(document, block, bodyStartOffset, bodyEndOffset)
+        : [];
+    const eventAttributes = openingMatch.attributes
+        .map((attribute) => createTemplateAttribute(document, block, attribute))
+        .filter((attribute) => isEventBindingAttribute(attribute.name));
+    return {
+        attributes: openingMatch.attributes.map((attribute) => createTemplateAttribute(document, block, attribute)),
+        component,
+        eventAttributes,
+        hasDefaultSlotContent: closingMatch !== undefined &&
+            hasDefaultSlotBodyContent(document, bodyStartOffset, bodyEndOffset),
+        insertOffset: block.contentRange.start.offset + openingMatch.insertionIndex,
+        slotUsages,
+        tag: openingTag,
+    };
+}
+function findMatchingOpenComponentIndex(openTagStack, component, closingTagName) {
+    for (let index = openTagStack.length - 1; index >= 0; index--) {
+        const candidate = openTagStack[index];
+        if (candidate.component.name === component.name &&
+            candidate.component.tagNames.includes(closingTagName)) {
+            return index;
+        }
+    }
+    return -1;
+}
+function createKnownTemplateComponentsByTagName(document, sourcePath) {
+    const componentsByTagName = new Map();
+    for (const component of collectKnownTemplateComponents(document, sourcePath)) {
+        for (const tagName of component.tagNames) {
+            if (!componentsByTagName.has(tagName)) {
+                componentsByTagName.set(tagName, component);
+            }
+        }
+    }
+    return componentsByTagName;
+}
+function findKnownTemplateComponentByTagName(document, sourcePath, tagName) {
+    return createKnownTemplateComponentsByTagName(document, sourcePath).get(tagName);
+}
+function collectSlotUsagesFromContent(document, block, bodyStartOffset, bodyEndOffset) {
+    const relativeStart = bodyStartOffset - block.contentRange.start.offset;
+    const content = document.text.slice(bodyStartOffset, bodyEndOffset);
+    const slotUsages = [];
+    const slotPattern = /\bslot\s*=\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z_$][\w$-]*))/g;
+    let match;
+    while ((match = slotPattern.exec(content)) !== null) {
+        const slotName = match[1] ?? match[2] ?? match[3];
+        if (!slotName) {
+            continue;
+        }
+        const slotNamePrefix = match[0].slice(0, match[0].indexOf(slotName));
+        const slotNameStart = relativeStart + match.index + slotNamePrefix.length;
+        const slotNameEnd = slotNameStart + slotName.length;
+        slotUsages.push({
+            name: slotName,
+            range: (0, sourcePositions_1.createLocatedRange)(document.lineStarts, block.contentRange.start.offset + slotNameStart, block.contentRange.start.offset + slotNameEnd),
+        });
+    }
+    return slotUsages;
+}
+function hasDefaultSlotBodyContent(document, bodyStartOffset, bodyEndOffset) {
+    if (bodyEndOffset <= bodyStartOffset) {
+        return false;
+    }
+    const bodyContent = document.text.slice(bodyStartOffset, bodyEndOffset);
+    if (!/\S/.test(bodyContent)) {
+        return false;
+    }
+    const strippedNamedSlotContent = bodyContent.replace(/<([A-Za-z][A-Za-z0-9:_-]*)([^>]*)\bslot\s*=\s*(?:"[^"]+"|'[^']+'|[A-Za-z_$][\w$-]*)([^>]*)>[\s\S]*?<\/\1\s*>/g, '');
+    return /\S/.test(strippedNamedSlotContent);
+}
+function isEventBindingAttribute(attributeName) {
+    return (attributeName.startsWith('@') ||
+        attributeName.startsWith('on:') ||
+        /^on[A-Z]/.test(attributeName));
+}
+function getEventNameFromAttribute(attributeName) {
+    if (attributeName.startsWith('@')) {
+        return attributeName.slice(1);
+    }
+    if (attributeName.startsWith('on:')) {
+        return attributeName.slice(3);
+    }
+    if (/^on[A-Z]/.test(attributeName)) {
+        return attributeName[2].toLowerCase() + attributeName.slice(3);
+    }
+    return undefined;
+}
+function createComponentTagNames(name) {
+    const tagNames = [name];
+    const kebabAlias = toKebabCase(name);
+    if (kebabAlias !== name && kebabAlias.includes('-')) {
+        tagNames.push(kebabAlias);
+    }
+    return tagNames;
+}
+function createComponentPropAliases(name) {
+    const aliases = [name];
+    const kebabAlias = toKebabCase(name);
+    if (kebabAlias !== name) {
+        aliases.push(kebabAlias);
+    }
+    return aliases;
+}
+function extractComponentApiFromDocument(document) {
+    const props = new Map();
+    const emits = new Map();
+    const slots = new Map();
+    for (const block of document.blocks) {
+        if (block.name === kpaBlocks_1.canonicalTemplateBlock) {
+            for (const slotEntry of collectSlotEntriesFromTemplateBlock(document, block)) {
+                if (!slots.has(slotEntry.name)) {
+                    slots.set(slotEntry.name, slotEntry);
+                }
+            }
+            continue;
+        }
+        if (!isScriptBlock(block)) {
+            continue;
+        }
+        const content = document.text.slice(block.contentRange.start.offset, block.contentRange.end.offset);
+        const sourceFile = typescript_1.default.createSourceFile(createEmbeddedFileName(block.kind), content, typescript_1.default.ScriptTarget.Latest, true, block.kind === 'script-ts' ? typescript_1.default.ScriptKind.TS : typescript_1.default.ScriptKind.JS);
+        for (const statement of sourceFile.statements) {
+            if (typescript_1.default.isInterfaceDeclaration(statement) && isPropsInterfaceName(statement.name.text)) {
+                for (const entry of collectInterfaceEntries(statement, sourceFile)) {
+                    props.set(entry.name, entry);
+                }
+                continue;
+            }
+            if (typescript_1.default.isInterfaceDeclaration(statement) && isSlotsInterfaceName(statement.name.text)) {
+                for (const entry of collectInterfaceEntries(statement, sourceFile)) {
+                    slots.set(entry.name, entry);
+                }
+                continue;
+            }
+            if (typescript_1.default.isTypeAliasDeclaration(statement) && isEmitsTypeName(statement.name.text)) {
+                for (const entry of collectTypeLiteralEntries(statement.type, sourceFile)) {
+                    emits.set(entry.name, entry);
+                }
+            }
+        }
+        for (const runtimeProp of (0, componentContract_1.collectRuntimeComponentProps)(sourceFile)) {
+            props.set(runtimeProp.name, {
+                name: runtimeProp.name,
+                optional: runtimeProp.optional,
+                typeText: runtimeProp.typeText,
+            });
+        }
+    }
+    return {
+        emits: [...emits.values()],
+        props: [...props.values()],
+        slots: [...slots.values()],
+    };
+}
+function collectSlotEntriesFromTemplateBlock(document, block) {
+    const content = document.text.slice(block.contentRange.start.offset, block.contentRange.end.offset);
+    const entries = [];
+    const seenNames = new Set();
+    const slotPattern = /<slot\b([^>]*)>/g;
+    let match;
+    while ((match = slotPattern.exec(content)) !== null) {
+        const attributeText = match[1] ?? '';
+        const slotNameMatch = /\bname\s*=\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z_$][\w$-]*))/.exec(attributeText);
+        const slotName = slotNameMatch?.[1] ?? slotNameMatch?.[2] ?? slotNameMatch?.[3] ?? 'default';
+        if (seenNames.has(slotName)) {
+            continue;
+        }
+        seenNames.add(slotName);
+        entries.push({
+            name: slotName,
+            optional: true,
+        });
+    }
+    return entries;
+}
+function collectInterfaceEntries(declaration, sourceFile) {
+    const entries = [];
+    for (const member of declaration.members) {
+        if ((typescript_1.default.isPropertySignature(member) || typescript_1.default.isMethodSignature(member)) &&
+            getComponentMemberName(member.name)) {
+            const name = getComponentMemberName(member.name);
+            if (!name) {
+                continue;
+            }
+            entries.push({
+                name,
+                optional: Boolean(member.questionToken),
+                typeText: member.type ? member.type.getText(sourceFile).trim() : undefined,
+            });
+        }
+    }
+    return entries;
+}
+function collectTypeLiteralEntries(node, sourceFile) {
+    if (!typescript_1.default.isTypeLiteralNode(node)) {
+        return [];
+    }
+    const entries = [];
+    for (const member of node.members) {
+        if ((typescript_1.default.isPropertySignature(member) || typescript_1.default.isMethodSignature(member)) &&
+            getComponentMemberName(member.name)) {
+            const name = getComponentMemberName(member.name);
+            if (!name) {
+                continue;
+            }
+            entries.push({
+                name,
+                optional: Boolean(member.questionToken),
+                typeText: member.type ? member.type.getText(sourceFile).trim() : undefined,
+            });
+        }
+    }
+    return entries;
+}
+function getComponentMemberName(name) {
+    if (!name) {
+        return undefined;
+    }
+    if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function isPropsInterfaceName(name) {
+    return name === 'Props' || name.endsWith('Props');
+}
+function isSlotsInterfaceName(name) {
+    return name === 'Slots' || name.endsWith('Slots');
+}
+function isEmitsTypeName(name) {
+    return name === 'Emits' || name.endsWith('Emits');
+}
+function isExpressionAttributeAssignableToPropType(document, sourcePath, attribute, propTypeText) {
+    const valueText = attribute.valueText?.trim();
+    if (!valueText) {
+        return undefined;
+    }
+    const virtualFileName = createComponentTypecheckVirtualFileName(sourcePath);
+    const compilerOptions = loadTypecheckCompilerOptions(virtualFileName);
+    const virtualSourceText = createComponentTypecheckSource(document, valueText, propTypeText);
+    const languageServiceHost = {
+        getCompilationSettings: () => compilerOptions,
+        getCurrentDirectory: () => path_1.default.dirname(virtualFileName),
+        getDefaultLibFileName: (options) => typescript_1.default.getDefaultLibFilePath(options),
+        getScriptFileNames: () => [virtualFileName],
+        getScriptVersion: () => '0',
+        getScriptSnapshot: (fileName) => {
+            if (fileName === virtualFileName) {
+                return typescript_1.default.ScriptSnapshot.fromString(virtualSourceText);
+            }
+            const sourceText = typescript_1.default.sys.readFile(fileName);
+            return sourceText !== undefined ? typescript_1.default.ScriptSnapshot.fromString(sourceText) : undefined;
+        },
+        fileExists: (fileName) => fileName === virtualFileName || typescript_1.default.sys.fileExists(fileName),
+        readFile: (fileName) => fileName === virtualFileName ? virtualSourceText : typescript_1.default.sys.readFile(fileName),
+        readDirectory: typescript_1.default.sys.readDirectory,
+        directoryExists: (directoryName) => directoryName === path_1.default.dirname(virtualFileName) || typescript_1.default.sys.directoryExists(directoryName),
+        getDirectories: typescript_1.default.sys.getDirectories,
+        useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
+        getNewLine: () => typescript_1.default.sys.newLine,
+    };
+    const languageService = typescript_1.default.createLanguageService(languageServiceHost);
+    const diagnostics = languageService.getSemanticDiagnostics(virtualFileName);
+    if (diagnostics.some((diagnostic) => diagnostic.code === 2304 || diagnostic.code === 2552 || diagnostic.code === 2693)) {
+        return undefined;
+    }
+    return diagnostics.length === 0;
+}
+function createComponentTypecheckVirtualFileName(sourcePath) {
+    if (sourcePath) {
+        return `${sourcePath}.component-check.ts`;
+    }
+    return path_1.default.join(process.cwd(), '__kpa_virtual__', 'untitled.kpa.component-check.ts');
+}
+function createComponentTypecheckSource(document, valueText, propTypeText) {
+    const parts = [];
+    const scriptBlock = document.blocks.find(isScriptBlock);
+    if (scriptBlock) {
+        const content = document.text.slice(scriptBlock.contentRange.start.offset, scriptBlock.contentRange.end.offset);
+        parts.push(content);
+        parts.push('\n');
+        for (const symbol of (0, symbols_1.collectTemplateContextSymbols)(document)) {
+            appendComponentTypecheckBindingDeclaration(parts, symbol);
+        }
+    }
+    parts.push(`type __KpaTarget = ${propTypeText};\n`);
+    parts.push(`const __kpa_value__ = (${valueText});\n`);
+    parts.push('const __kpa_assign__: __KpaTarget = __kpa_value__;\n');
+    return parts.join('');
+}
+function appendComponentTypecheckBindingDeclaration(parts, symbol) {
+    parts.push(`const ${symbol.name} = `);
+    if (symbol.valueText) {
+        parts.push(`${symbol.valueText};\n`);
+        return;
+    }
+    parts.push(`undefined as unknown as ${getComponentTypecheckPropValueType(symbol)};\n`);
+}
+function getComponentTypecheckPropValueType(symbol) {
+    const baseType = symbol.typeText?.trim() || 'unknown';
+    return symbol.optional ? `${baseType} | undefined` : baseType;
+}
+function loadTypecheckCompilerOptions(virtualFileName) {
+    const configFile = typescript_1.default.findConfigFile(path_1.default.dirname(virtualFileName), typescript_1.default.sys.fileExists);
+    if (configFile) {
+        const configFileResult = typescript_1.default.readConfigFile(configFile, typescript_1.default.sys.readFile);
+        if (!configFileResult.error) {
+            const parsedConfig = typescript_1.default.parseJsonConfigFileContent(configFileResult.config, typescript_1.default.sys, path_1.default.dirname(configFile));
+            return {
+                ...parsedConfig.options,
+                allowJs: true,
+                checkJs: true,
+            };
+        }
+    }
+    return {
+        allowJs: true,
+        checkJs: true,
+        module: typescript_1.default.ModuleKind.Node16,
+        moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
+        strict: true,
+        target: typescript_1.default.ScriptTarget.ES2022,
+    };
+}
+function inferAttributeType(attribute) {
+    switch (attribute.kind) {
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+        case 'unquoted':
+            return 'string';
+        case 'expression': {
+            const valueText = attribute.valueText?.trim();
+            if (!valueText) {
+                return undefined;
+            }
+            if (/^(true|false)$/.test(valueText)) {
+                return 'boolean';
+            }
+            if (/^-?\d+(?:\.\d+)?$/.test(valueText)) {
+                return 'number';
+            }
+            if (/^(["'`]).*\1$/s.test(valueText)) {
+                return 'string';
+            }
+            if (valueText === 'null') {
+                return 'null';
+            }
+            if (/^\[.*\]$/s.test(valueText)) {
+                return 'array';
+            }
+            if (/^\{.*\}$/s.test(valueText)) {
+                return 'object';
+            }
+            return undefined;
+        }
+        case 'spread':
+            return undefined;
+    }
+}
+function isCompatiblePropType(typeText, inferredType) {
+    const normalizedTypeText = typeText.replace(/\s+/g, '');
+    if (normalizedTypeText.includes('any') ||
+        normalizedTypeText.includes('unknown') ||
+        normalizedTypeText.includes('never')) {
+        return true;
+    }
+    switch (inferredType) {
+        case 'string':
+            return (normalizedTypeText.includes('string') ||
+                /'[^']*'|"[^"]*"/.test(typeText) ||
+                normalizedTypeText.includes('String'));
+        case 'number':
+            return normalizedTypeText.includes('number');
+        case 'boolean':
+            return (normalizedTypeText.includes('boolean') ||
+                normalizedTypeText.includes('true') ||
+                normalizedTypeText.includes('false'));
+        case 'null':
+            return normalizedTypeText.includes('null');
+        case 'array':
+            return normalizedTypeText.includes('[]') || normalizedTypeText.includes('Array<');
+        case 'object':
+            return (normalizedTypeText.includes('{') ||
+                normalizedTypeText.includes('object') ||
+                normalizedTypeText.includes('Record<'));
+    }
+}
+function shouldWarnUnknownComponentAttribute(name) {
+    const normalizedName = getComponentPropLookupName(name);
+    if (allowedPassthroughComponentAttributes.has(normalizedName)) {
+        return false;
+    }
+    return !(normalizedName.startsWith('aria-') ||
+        name.startsWith('bind:') ||
+        name.startsWith('class:') ||
+        normalizedName.startsWith('data-') ||
+        name.startsWith('on:') ||
+        name.startsWith('style:') ||
+        name.startsWith('use:'));
+}
+function isDynamicBindingAttribute(name) {
+    return name.startsWith(':') || name.startsWith('bind:');
+}
+function getComponentPropLookupName(name) {
+    if (name.startsWith(':')) {
+        return name.slice(1);
+    }
+    if (name.startsWith('bind:')) {
+        return name.slice(5);
+    }
+    return name;
+}
+function toKebabCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/[_\s]+/g, '-')
+        .toLowerCase();
+}
+function toPascalCase(name) {
+    return name
+        .split(/[-_\s]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}
+function resolveComponentImportPath(importPath, sourcePath) {
+    return (0, projectConfig_1.resolveWorkspaceImportPath)(importPath, sourcePath, ['.kpa']);
+}
+function readComponentApiFromFile(resolvedFilePath) {
+    if (!resolvedFilePath) {
+        return undefined;
+    }
+    try {
+        const fileStats = fs_1.default.statSync(resolvedFilePath);
+        const cachedEntry = componentApiCache.get(resolvedFilePath);
+        if (cachedEntry && cachedEntry.mtimeMs === fileStats.mtimeMs) {
+            return cachedEntry.api;
+        }
+        const text = fs_1.default.readFileSync(resolvedFilePath, 'utf8');
+        const document = (0, parser_1.parseKpaDocument)(text);
+        const api = extractComponentApiFromDocument(document);
+        componentApiCache.set(resolvedFilePath, {
+            api,
+            mtimeMs: fileStats.mtimeMs,
+        });
+        return api;
+    }
+    catch {
+        return undefined;
+    }
+}
+function createDocumentRange(document, block, startOffsetInBlock, endOffsetInBlock) {
+    const startOffset = block.contentRange.start.offset + startOffsetInBlock;
+    const endOffset = block.contentRange.start.offset + endOffsetInBlock;
+    return (0, sourcePositions_1.createLocatedRange)(document.lineStarts, startOffset, endOffset);
+}
+function isScriptBlock(block) {
+    return block.kind === 'script-ts' || block.kind === 'script-js';
+}
+function createEmbeddedFileName(kind) {
+    return kind === 'script-ts' ? 'embedded.kpa.ts' : 'embedded.kpa.js';
+}
+function looksLikeComponentTagName(name) {
+    return /^[A-Z]/.test(name) || /^[a-z][a-z0-9]*-[a-z0-9-]+$/.test(name);
+}
+function isTagNameStart(character) {
+    return character !== undefined && /[A-Za-z]/.test(character);
+}
+function isTagNameCharacter(character) {
+    return character !== undefined && /[A-Za-z0-9:_-]/.test(character);
+}
+function isAttributeNameStart(character) {
+    return character !== undefined && /[A-Za-z_:@]/.test(character);
+}
+function isAttributeNameCharacter(character) {
+    return character !== undefined && /[A-Za-z0-9_:@.-]/.test(character);
+}
+function isWhitespace(character) {
+    return character === ' ' || character === '\t' || character === '\n' || character === '\r';
+}
+function toDiagnosticRange(range) {
+    return {
+        endChar: range.end.character,
+        line: range.start.line,
+        startChar: range.start.character,
+    };
+}
+function deduplicateRanges(ranges) {
+    const seenRanges = new Set();
+    return ranges.filter((range) => {
+        const key = `${range.start.offset}:${range.end.offset}`;
+        if (seenRanges.has(key)) {
+            return false;
+        }
+        seenRanges.add(key);
+        return true;
+    });
+}
+//# sourceMappingURL=templateComponents.js.map