@ktjs/ts-plugin 0.1.4 → 0.1.6

package/dist/jsx-attributes.d.ts

@@ -0,0 +1,6 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { JsxOpeningLikeElement } from './types';
+export declare function getScopeName(opening: JsxOpeningLikeElement, attrName: string, fallback: string, ts: typeof tsModule): string;
+export declare function getJsxAttribute(opening: tsModule.JsxOpeningElement | tsModule.JsxSelfClosingElement, attrName: string, ts: typeof tsModule): tsModule.JsxAttribute | undefined;
+export declare function getAttributeText(attr: tsModule.JsxAttribute | undefined, ts: typeof tsModule, allowIdentifier?: boolean): string | undefined;
+export declare function getAttributeExpression(attr: tsModule.JsxAttribute | undefined, ts: typeof tsModule): tsModule.Expression | undefined;

package/dist/jsx-attributes.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScopeName = getScopeName;
+exports.getJsxAttribute = getJsxAttribute;
+exports.getAttributeText = getAttributeText;
+exports.getAttributeExpression = getAttributeExpression;
+const identifiers_1 = require("./identifiers");
+function getScopeName(opening, attrName, fallback, ts) {
+    const attr = getJsxAttribute(opening, attrName, ts);
+    const raw = getAttributeText(attr, ts, true);
+    if (raw && (0, identifiers_1.isValidIdentifier)(raw)) {
+        return raw;
+    }
+    return fallback;
+}
+function getJsxAttribute(opening, attrName, ts) {
+    const attrs = opening.attributes.properties;
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ts.isJsxAttribute(attr)) {
+            continue;
+        }
+        if (getAttributeName(attr.name) === attrName) {
+            return attr;
+        }
+    }
+    return undefined;
+}
+function getAttributeText(attr, ts, allowIdentifier = false) {
+    if (!attr || !attr.initializer) {
+        return undefined;
+    }
+    if (ts.isStringLiteral(attr.initializer)) {
+        return attr.initializer.text;
+    }
+    if (!ts.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+        return undefined;
+    }
+    const expr = attr.initializer.expression;
+    if (ts.isStringLiteralLike(expr)) {
+        return expr.text;
+    }
+    if (allowIdentifier && ts.isIdentifier(expr)) {
+        return expr.text;
+    }
+    return undefined;
+}
+function getAttributeExpression(attr, ts) {
+    if (!attr?.initializer || !ts.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+        return undefined;
+    }
+    return attr.initializer.expression;
+}
+function getAttributeName(name) {
+    if ('text' in name) {
+        return String(name.text);
+    }
+    return name.getText();
+}

package/dist/kfor-highlighting.d.ts

@@ -0,0 +1,4 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { ResolvedConfig } from './types';
+export declare function addKForSemanticClassifications(base: tsModule.Classifications, sourceFile: tsModule.SourceFile, span: tsModule.TextSpan, format: tsModule.SemanticClassificationFormat | undefined, ts: typeof tsModule, config: ResolvedConfig): tsModule.Classifications;
+export declare function addKForSyntacticClassifications(base: tsModule.Classifications, sourceFile: tsModule.SourceFile, span: tsModule.TextSpan, ts: typeof tsModule, config: ResolvedConfig): tsModule.Classifications;

package/dist/kfor-highlighting.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addKForSemanticClassifications = addKForSemanticClassifications;
+exports.addKForSyntacticClassifications = addKForSyntacticClassifications;
+const jsx_attributes_1 = require("./jsx-attributes");
+const kfor_parser_1 = require("./kfor-parser");
+const identifiers_1 = require("./identifiers");
+const TOKEN_TYPE_VARIABLE = 7;
+const TOKEN_MODIFIER_READONLY = 1 << 3;
+const TOKEN_MODIFIER_LOCAL = 1 << 5;
+const TOKEN_ENCODING_TYPE_OFFSET = 8;
+const IDENTIFIER_PATTERN = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+const KEYWORD_DELIMITER_PATTERN = /\s+(in|of)\s+/;
+function addKForSemanticClassifications(base, sourceFile, span, format, ts, config) {
+    const tokens = collectHighlightTokens(sourceFile, ts, config, span);
+    if (tokens.length === 0) {
+        return base;
+    }
+    const semanticSpans = buildSemanticSpans(tokens, format, ts);
+    if (semanticSpans.length === 0) {
+        return base;
+    }
+    return mergeClassifications(base, semanticSpans, false);
+}
+function addKForSyntacticClassifications(base, sourceFile, span, ts, config) {
+    const tokens = collectHighlightTokens(sourceFile, ts, config, span);
+    if (tokens.length === 0) {
+        return base;
+    }
+    const keywordSpans = buildSyntacticKeywordSpans(tokens, ts);
+    if (keywordSpans.length === 0) {
+        return base;
+    }
+    return mergeClassifications(base, keywordSpans, true);
+}
+function collectHighlightTokens(sourceFile, ts, config, span) {
+    const tokens = [];
+    const spanStart = span.start;
+    const spanEnd = span.start + span.length;
+    const visit = (node) => {
+        let opening;
+        if (ts.isJsxElement(node)) {
+            opening = node.openingElement;
+        }
+        else if (ts.isJsxSelfClosingElement(node)) {
+            opening = node;
+        }
+        if (opening) {
+            const attr = (0, jsx_attributes_1.getJsxAttribute)(opening, config.forAttr, ts);
+            if (attr) {
+                const parsed = parseKForAttributeTokens(attr, sourceFile, ts, config.allowOfKeyword);
+                for (let i = 0; i < parsed.length; i++) {
+                    const token = parsed[i];
+                    const tokenStart = token.start;
+                    const tokenEnd = token.start + token.length;
+                    if (tokenEnd <= spanStart || tokenStart >= spanEnd) {
+                        continue;
+                    }
+                    const clippedStart = Math.max(tokenStart, spanStart);
+                    const clippedEnd = Math.min(tokenEnd, spanEnd);
+                    if (clippedEnd > clippedStart) {
+                        tokens.push({
+                            start: clippedStart,
+                            length: clippedEnd - clippedStart,
+                            kind: token.kind,
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return uniqueTokens(tokens);
+}
+function parseKForAttributeTokens(attr, sourceFile, ts, allowOfKeyword) {
+    const content = getAttributeRawContent(attr, sourceFile, ts);
+    if (!content) {
+        return [];
+    }
+    const raw = content.text;
+    const rawOffset = content.start;
+    const value = raw.trim();
+    if (!value) {
+        return [];
+    }
+    const parsed = (0, kfor_parser_1.parseKForExpression)(value, allowOfKeyword);
+    if (!parsed) {
+        return [];
+    }
+    const trimStart = raw.length - raw.trimStart().length;
+    const delimiterMatch = KEYWORD_DELIMITER_PATTERN.exec(value);
+    if (!delimiterMatch) {
+        return [];
+    }
+    const keyword = delimiterMatch[1];
+    const keywordOffsetInDelimiter = delimiterMatch[0].indexOf(keyword);
+    const leftSegment = value.slice(0, delimiterMatch.index);
+    const rightSegment = value.slice(delimiterMatch.index + delimiterMatch[0].length);
+    const leftLeading = leftSegment.length - leftSegment.trimStart().length;
+    const leftTrimmed = leftSegment.trim();
+    let aliasText = leftTrimmed;
+    let aliasTextStartInRaw = trimStart + leftLeading;
+    if (leftTrimmed.startsWith('(') && leftTrimmed.endsWith(')')) {
+        aliasText = leftTrimmed.slice(1, -1);
+        aliasTextStartInRaw += 1;
+    }
+    const rightLeading = rightSegment.length - rightSegment.trimStart().length;
+    const sourceText = rightSegment.trim();
+    const sourceTextStartInRaw = trimStart + delimiterMatch.index + delimiterMatch[0].length + rightLeading;
+    const keywordStartInRaw = trimStart + delimiterMatch.index + keywordOffsetInDelimiter;
+    const tokens = [];
+    const aliasTokens = collectAliasTokens(aliasText, aliasTextStartInRaw, parsed.aliases);
+    for (let i = 0; i < aliasTokens.length; i++) {
+        tokens.push({
+            start: rawOffset + aliasTokens[i].start,
+            length: aliasTokens[i].length,
+            kind: 'alias',
+        });
+    }
+    tokens.push({
+        start: rawOffset + keywordStartInRaw,
+        length: keyword.length,
+        kind: 'keyword',
+    });
+    const sourceTokens = collectSourceTokens(sourceText, sourceTextStartInRaw, ts);
+    for (let i = 0; i < sourceTokens.length; i++) {
+        tokens.push({
+            start: rawOffset + sourceTokens[i].start,
+            length: sourceTokens[i].length,
+            kind: 'source',
+        });
+    }
+    return tokens;
+}
+function collectAliasTokens(aliasText, baseStart, aliases) {
+    const result = [];
+    const allowed = new Set(aliases);
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(aliasText))) {
+        const name = match[0];
+        if (!allowed.has(name) || !(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        result.push({
+            start: baseStart + match.index,
+            length: name.length,
+            kind: 'alias',
+        });
+    }
+    return result;
+}
+function collectSourceTokens(sourceText, baseStart, ts) {
+    const tokens = collectSourceTokensWithAst(sourceText, baseStart, ts);
+    if (tokens.length > 0) {
+        return tokens;
+    }
+    const fallback = [];
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(sourceText))) {
+        const name = match[0];
+        if (!(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        fallback.push({
+            start: baseStart + match.index,
+            length: name.length,
+            kind: 'source',
+        });
+    }
+    return fallback;
+}
+function collectSourceTokensWithAst(sourceText, baseStart, ts) {
+    const snippet = `(${sourceText});`;
+    const tempSourceFile = ts.createSourceFile('__k_for_highlight.ts', snippet, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    if (tempSourceFile.statements.length === 0) {
+        return [];
+    }
+    const statement = tempSourceFile.statements[0];
+    if (!ts.isExpressionStatement(statement)) {
+        return [];
+    }
+    const result = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && (0, identifiers_1.isValidIdentifier)(node.text)) {
+            const start = node.getStart(tempSourceFile) - 1;
+            const end = start + node.getWidth(tempSourceFile);
+            if (start >= 0 && end <= sourceText.length) {
+                result.push({
+                    start: baseStart + start,
+                    length: end - start,
+                    kind: 'source',
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(statement.expression);
+    return result;
+}
+function getAttributeRawContent(attr, sourceFile, ts) {
+    const initializer = attr.initializer;
+    if (!initializer) {
+        return undefined;
+    }
+    if (ts.isStringLiteral(initializer)) {
+        const quotedText = initializer.getText(sourceFile);
+        if (quotedText.length < 2) {
+            return undefined;
+        }
+        return {
+            start: initializer.getStart(sourceFile) + 1,
+            text: quotedText.slice(1, -1),
+        };
+    }
+    const expression = (0, jsx_attributes_1.getAttributeExpression)(attr, ts);
+    if (!expression || !ts.isStringLiteralLike(expression)) {
+        return undefined;
+    }
+    const quotedText = expression.getText(sourceFile);
+    if (quotedText.length < 2) {
+        return undefined;
+    }
+    return {
+        start: expression.getStart(sourceFile) + 1,
+        text: quotedText.slice(1, -1),
+    };
+}
+function buildSemanticSpans(tokens, format, ts) {
+    const spans = [];
+    if (format === ts.SemanticClassificationFormat.TwentyTwenty) {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.kind === 'keyword') {
+                continue;
+            }
+            spans.push({
+                start: token.start,
+                length: token.length,
+                classification: token.kind === 'alias'
+                    ? encodeSemantic2020(TOKEN_TYPE_VARIABLE, TOKEN_MODIFIER_READONLY | TOKEN_MODIFIER_LOCAL)
+                    : encodeSemantic2020(TOKEN_TYPE_VARIABLE, 0),
+            });
+        }
+        return spans;
+    }
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        spans.push({
+            start: token.start,
+            length: token.length,
+            classification: token.kind === 'keyword' ? ts.ClassificationType.keyword : ts.ClassificationType.identifier,
+        });
+    }
+    return spans;
+}
+function buildSyntacticKeywordSpans(tokens, ts) {
+    const spans = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.kind !== 'keyword') {
+            continue;
+        }
+        spans.push({
+            start: token.start,
+            length: token.length,
+            classification: ts.ClassificationType.keyword,
+        });
+    }
+    return spans;
+}
+function encodeSemantic2020(typeIndex, modifiers) {
+    return ((typeIndex + 1) << TOKEN_ENCODING_TYPE_OFFSET) + modifiers;
+}
+function mergeClassifications(base, overlays, replaceOverlaps) {
+    if (overlays.length === 0) {
+        return base;
+    }
+    const baseSpans = decodeSpans(base.spans);
+    const extraSpans = normalizeSpans(overlays);
+    if (extraSpans.length === 0) {
+        return base;
+    }
+    const merged = replaceOverlaps
+        ? [...removeOverlayOverlaps(baseSpans, extraSpans), ...extraSpans]
+        : [...baseSpans, ...extraSpans];
+    const normalized = normalizeSpans(merged);
+    return {
+        spans: encodeSpans(normalized),
+        endOfLineState: base.endOfLineState,
+    };
+}
+function removeOverlayOverlaps(baseSpans, overlays) {
+    const result = [];
+    for (let i = 0; i < baseSpans.length; i++) {
+        let segments = [baseSpans[i]];
+        for (let j = 0; j < overlays.length; j++) {
+            const overlay = overlays[j];
+            const nextSegments = [];
+            for (let k = 0; k < segments.length; k++) {
+                const segment = segments[k];
+                const segmentStart = segment.start;
+                const segmentEnd = segment.start + segment.length;
+                const overlayStart = overlay.start;
+                const overlayEnd = overlay.start + overlay.length;
+                if (overlayEnd <= segmentStart || overlayStart >= segmentEnd) {
+                    nextSegments.push(segment);
+                    continue;
+                }
+                if (segmentStart < overlayStart) {
+                    nextSegments.push({
+                        start: segmentStart,
+                        length: overlayStart - segmentStart,
+                        classification: segment.classification,
+                    });
+                }
+                if (overlayEnd < segmentEnd) {
+                    nextSegments.push({
+                        start: overlayEnd,
+                        length: segmentEnd - overlayEnd,
+                        classification: segment.classification,
+                    });
+                }
+            }
+            segments = nextSegments;
+            if (segments.length === 0) {
+                break;
+            }
+        }
+        for (let j = 0; j < segments.length; j++) {
+            result.push(segments[j]);
+        }
+    }
+    return result;
+}
+function decodeSpans(spans) {
+    const decoded = [];
+    for (let i = 0; i + 2 < spans.length; i += 3) {
+        const start = spans[i];
+        const length = spans[i + 1];
+        const classification = spans[i + 2];
+        if (length <= 0) {
+            continue;
+        }
+        decoded.push({ start, length, classification });
+    }
+    return decoded;
+}
+function encodeSpans(spans) {
+    const encoded = [];
+    for (let i = 0; i < spans.length; i++) {
+        const span = spans[i];
+        encoded.push(span.start, span.length, span.classification);
+    }
+    return encoded;
+}
+function normalizeSpans(spans) {
+    if (spans.length === 0) {
+        return [];
+    }
+    const sorted = spans
+        .filter((span) => span.length > 0)
+        .slice()
+        .sort((left, right) => {
+        if (left.start !== right.start) {
+            return left.start - right.start;
+        }
+        if (left.length !== right.length) {
+            return left.length - right.length;
+        }
+        return left.classification - right.classification;
+    });
+    const normalized = [];
+    for (let i = 0; i < sorted.length; i++) {
+        const span = sorted[i];
+        const previous = normalized[normalized.length - 1];
+        if (previous &&
+            previous.start === span.start &&
+            previous.length === span.length &&
+            previous.classification === span.classification) {
+            continue;
+        }
+        normalized.push(span);
+    }
+    return normalized;
+}
+function uniqueTokens(tokens) {
+    if (tokens.length === 0) {
+        return [];
+    }
+    const map = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const key = `${token.start}:${token.length}:${token.kind}`;
+        if (!map.has(key)) {
+            map.set(key, token);
+        }
+    }
+    return Array.from(map.values()).sort((left, right) => {
+        if (left.start !== right.start) {
+            return left.start - right.start;
+        }
+        return left.length - right.length;
+    });
+}

package/dist/kfor-parser.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedKForExpression } from './types';
+export declare function parseKForExpression(raw: string, allowOfKeyword: boolean): ParsedKForExpression | null;

package/dist/kfor-parser.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKForExpression = parseKForExpression;
+const constants_1 = require("./constants");
+const identifiers_1 = require("./identifiers");
+function parseKForExpression(raw, allowOfKeyword) {
+    const value = raw.trim();
+    if (!value) {
+        return null;
+    }
+    const tupleMatch = constants_1.KFOR_TUPLE_PATTERN.exec(value);
+    if (tupleMatch) {
+        const keyword = tupleMatch[4];
+        const source = tupleMatch[5]?.trim();
+        if ((!allowOfKeyword && keyword === 'of') || !source) {
+            return null;
+        }
+        return {
+            aliases: (0, identifiers_1.uniqueIdentifiers)([tupleMatch[1], tupleMatch[2], tupleMatch[3]].filter(Boolean)),
+            source,
+        };
+    }
+    const singleMatch = constants_1.KFOR_SINGLE_PATTERN.exec(value);
+    if (singleMatch) {
+        const keyword = singleMatch[2];
+        const source = singleMatch[3]?.trim();
+        if ((!allowOfKeyword && keyword === 'of') || !source) {
+            return null;
+        }
+        return {
+            aliases: (0, identifiers_1.uniqueIdentifiers)([singleMatch[1]]),
+            source,
+        };
+    }
+    return null;
+}

package/dist/scope-analysis.d.ts

@@ -0,0 +1,5 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { FileAnalysis, KForBinding, KForScope, ResolvedConfig } from './types';
+export declare function getFileAnalysis(fileName: string, languageService: tsModule.LanguageService, ts: typeof tsModule, config: ResolvedConfig): FileAnalysis | undefined;
+export declare function isSuppressed(position: number, diagnosticName: string, scopes: KForScope[]): boolean;
+export declare function collectBindingsAtPosition(position: number, scopes: KForScope[]): Map<string, KForBinding>;

package/dist/scope-analysis.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileAnalysis = getFileAnalysis;
+exports.isSuppressed = isSuppressed;
+exports.collectBindingsAtPosition = collectBindingsAtPosition;
+const jsx_attributes_1 = require("./jsx-attributes");
+const kfor_parser_1 = require("./kfor-parser");
+const identifiers_1 = require("./identifiers");
+const type_resolution_1 = require("./type-resolution");
+function getFileAnalysis(fileName, languageService, ts, config) {
+    const program = languageService.getProgram();
+    if (!program) {
+        return undefined;
+    }
+    const sourceFile = program.getSourceFile(fileName);
+    if (!sourceFile) {
+        return undefined;
+    }
+    const checker = program.getTypeChecker();
+    const scopes = collectKForScopes(sourceFile, checker, ts, config);
+    if (scopes.length === 0) {
+        return undefined;
+    }
+    return { sourceFile, checker, scopes };
+}
+function isSuppressed(position, diagnosticName, scopes) {
+    for (let i = scopes.length - 1; i >= 0; i--) {
+        const scope = scopes[i];
+        if (position < scope.start || position >= scope.end) {
+            continue;
+        }
+        for (let j = 0; j < scope.bindings.length; j++) {
+            if (scope.bindings[j].name === diagnosticName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function collectBindingsAtPosition(position, scopes) {
+    const bindings = new Map();
+    for (let i = scopes.length - 1; i >= 0; i--) {
+        const scope = scopes[i];
+        if (position < scope.start || position >= scope.end) {
+            continue;
+        }
+        for (let j = 0; j < scope.bindings.length; j++) {
+            const binding = scope.bindings[j];
+            if (!bindings.has(binding.name)) {
+                bindings.set(binding.name, binding);
+            }
+        }
+    }
+    return bindings;
+}
+function collectKForScopes(sourceFile, checker, ts, config) {
+    const scopes = [];
+    const visit = (node) => {
+        if (ts.isJsxElement(node)) {
+            const forAttr = (0, jsx_attributes_1.getJsxAttribute)(node.openingElement, config.forAttr, ts);
+            if (forAttr) {
+                const bindings = resolveScopeBindings(node.openingElement, forAttr, checker, config, ts);
+                const start = node.openingElement.end;
+                const end = node.closingElement.getStart(sourceFile);
+                if (start < end && bindings.length > 0) {
+                    scopes.push({ start, end, bindings });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return scopes;
+}
+function resolveScopeBindings(opening, forAttr, checker, config, ts) {
+    const forExpression = (0, jsx_attributes_1.getAttributeText)(forAttr, ts);
+    if (forExpression !== undefined) {
+        const parsed = (0, kfor_parser_1.parseKForExpression)(forExpression, config.allowOfKeyword);
+        if (parsed) {
+            const sourceTypes = (0, type_resolution_1.resolveExpressionTypesFromText)(parsed.source, {
+                checker,
+                ts,
+                scopeNode: opening,
+            });
+            return createBindings(parsed.aliases, sourceTypes, checker, opening, ts);
+        }
+    }
+    const itemName = (0, jsx_attributes_1.getScopeName)(opening, config.itemAttr, config.itemName, ts);
+    const indexName = (0, jsx_attributes_1.getScopeName)(opening, config.indexAttr, config.indexName, ts);
+    const aliases = (0, identifiers_1.uniqueIdentifiers)([itemName, indexName]);
+    const sourceTypes = getLegacyForSourceTypes(forAttr, checker, ts);
+    return createBindings(aliases, sourceTypes, checker, opening, ts);
+}
+function createBindings(names, sourceTypes, checker, scopeNode, ts) {
+    if (names.length === 0) {
+        return [];
+    }
+    const inferred = inferBindingTypes(sourceTypes, names.length, checker, scopeNode, ts);
+    const bindings = [];
+    for (let i = 0; i < names.length; i++) {
+        bindings.push({
+            name: names[i],
+            types: inferred[i] || [],
+        });
+    }
+    return bindings;
+}
+function inferBindingTypes(sourceTypes, bindingCount, checker, scopeNode, ts) {
+    const slots = Array.from({ length: bindingCount }, () => []);
+    const candidates = expandUnionTypes(sourceTypes, ts);
+    for (let i = 0; i < candidates.length; i++) {
+        const sourceType = checker.getApparentType(candidates[i]);
+        const elementType = checker.getIndexTypeOfType(sourceType, ts.IndexKind.Number);
+        const stringValueType = elementType ? undefined : checker.getIndexTypeOfType(sourceType, ts.IndexKind.String);
+        const valueTypes = elementType ? [elementType] : stringValueType ? [stringValueType] : [];
+        if (valueTypes.length === 0) {
+            continue;
+        }
+        slots[0].push(...valueTypes);
+        if (bindingCount > 1) {
+            slots[1].push(elementType ? checker.getNumberType() : checker.getStringType());
+        }
+        if (bindingCount > 2) {
+            slots[2].push(checker.getNumberType());
+        }
+    }
+    for (let i = 0; i < slots.length; i++) {
+        slots[i] = (0, type_resolution_1.uniqueTypes)(slots[i], checker, scopeNode, ts);
+    }
+    return slots;
+}
+function expandUnionTypes(types, ts) {
+    const result = [];
+    for (let i = 0; i < types.length; i++) {
+        const type = types[i];
+        if (type.flags & ts.TypeFlags.Union) {
+            const union = type;
+            result.push(...union.types);
+            continue;
+        }
+        result.push(type);
+    }
+    return result;
+}
+function getLegacyForSourceTypes(forAttr, checker, ts) {
+    const expression = (0, jsx_attributes_1.getAttributeExpression)(forAttr, ts);
+    if (!expression || ts.isStringLiteralLike(expression)) {
+        return [];
+    }
+    return [checker.getTypeAtLocation(expression)];
+}

package/dist/type-resolution.d.ts

@@ -0,0 +1,5 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { TypeResolutionContext } from './types';
+export declare function resolveExpressionTypesFromText(raw: string, context: TypeResolutionContext): tsModule.Type[];
+export declare function formatTypeList(types: tsModule.Type[], checker: tsModule.TypeChecker, scopeNode: tsModule.Node, ts: typeof tsModule): string;
+export declare function uniqueTypes(types: tsModule.Type[], checker: tsModule.TypeChecker, scopeNode: tsModule.Node, ts: typeof tsModule): tsModule.Type[];