@ktjs/ts-plugin 0.1.4 → 0.1.5

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-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[];

package/dist/type-resolution.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExpressionTypesFromText = resolveExpressionTypesFromText;
+exports.formatTypeList = formatTypeList;
+exports.uniqueTypes = uniqueTypes;
+function resolveExpressionTypesFromText(raw, context) {
+    const value = raw.trim();
+    if (!value) {
+        return [];
+    }
+    const sourceFile = context.ts.createSourceFile('__k_for_expression.ts', `(${value});`, context.ts.ScriptTarget.Latest, true, context.ts.ScriptKind.TS);
+    if (sourceFile.statements.length === 0) {
+        return [];
+    }
+    const statement = sourceFile.statements[0];
+    if (!context.ts.isExpressionStatement(statement)) {
+        return [];
+    }
+    const types = resolveExpressionTypes(statement.expression, context);
+    return uniqueTypes(types, context.checker, context.scopeNode, context.ts);
+}
+function formatTypeList(types, checker, scopeNode, ts) {
+    if (types.length === 0) {
+        return 'any';
+    }
+    const texts = new Set();
+    for (let i = 0; i < types.length; i++) {
+        texts.add(checker.typeToString(types[i], scopeNode, ts.TypeFormatFlags.NoTruncation));
+    }
+    return Array.from(texts).join(' | ');
+}
+function uniqueTypes(types, checker, scopeNode, ts) {
+    const seen = new Set();
+    const result = [];
+    for (let i = 0; i < types.length; i++) {
+        const type = types[i];
+        const text = checker.typeToString(type, scopeNode, ts.TypeFormatFlags.NoTruncation);
+        if (seen.has(text)) {
+            continue;
+        }
+        seen.add(text);
+        result.push(type);
+    }
+    return result;
+}
+function resolveExpressionTypes(expr, context) {
+    const ts = context.ts;
+    const target = unwrapExpression(expr, ts);
+    if (ts.isIdentifier(target)) {
+        return resolveIdentifierTypes(target.text, context);
+    }
+    if (ts.isPropertyAccessExpression(target)) {
+        const objectTypes = resolveExpressionTypes(target.expression, context);
+        return resolvePropertyTypes(objectTypes, target.name.text, context, false);
+    }
+    if (ts.isElementAccessExpression(target)) {
+        const objectTypes = resolveExpressionTypes(target.expression, context);
+        const argument = target.argumentExpression;
+        if (!argument) {
+            return [];
+        }
+        if (ts.isStringLiteralLike(argument)) {
+            return resolvePropertyTypes(objectTypes, argument.text, context, true);
+        }
+        if (ts.isNumericLiteral(argument)) {
+            return resolveNumericElementTypes(objectTypes, Number(argument.text), context);
+        }
+        return resolveIndexedTypes(objectTypes, context);
+    }
+    if (ts.isCallExpression(target)) {
+        const calleeTypes = resolveExpressionTypes(target.expression, context);
+        const result = [];
+        for (let i = 0; i < calleeTypes.length; i++) {
+            const signatures = context.checker.getSignaturesOfType(calleeTypes[i], ts.SignatureKind.Call);
+            for (let j = 0; j < signatures.length; j++) {
+                result.push(context.checker.getReturnTypeOfSignature(signatures[j]));
+            }
+        }
+        return uniqueTypes(result, context.checker, context.scopeNode, ts);
+    }
+    if (ts.isConditionalExpression(target)) {
+        const whenTrue = resolveExpressionTypes(target.whenTrue, context);
+        const whenFalse = resolveExpressionTypes(target.whenFalse, context);
+        return uniqueTypes([...whenTrue, ...whenFalse], context.checker, context.scopeNode, ts);
+    }
+    if (ts.isBinaryExpression(target) &&
+        (target.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+            target.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+            target.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)) {
+        const left = resolveExpressionTypes(target.left, context);
+        const right = resolveExpressionTypes(target.right, context);
+        return uniqueTypes([...left, ...right], context.checker, context.scopeNode, ts);
+    }
+    return [];
+}
+function unwrapExpression(expr, ts) {
+    let current = expr;
+    while (true) {
+        if (ts.isParenthesizedExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isSatisfiesExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isNonNullExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        return current;
+    }
+}
+function resolveIdentifierTypes(name, context) {
+    const localTypes = context.localBindings?.get(name);
+    if (localTypes && localTypes.length > 0) {
+        return [...localTypes];
+    }
+    const symbol = resolveSymbolInScope(name, context);
+    if (!symbol) {
+        return [];
+    }
+    return [context.checker.getTypeOfSymbolAtLocation(symbol, context.scopeNode)];
+}
+function resolveSymbolInScope(name, context) {
+    const symbols = context.checker.getSymbolsInScope(context.scopeNode, context.ts.SymbolFlags.Value | context.ts.SymbolFlags.Alias);
+    for (let i = 0; i < symbols.length; i++) {
+        const symbol = symbols[i];
+        if (symbol.getName() !== name) {
+            continue;
+        }
+        if (symbol.flags & context.ts.SymbolFlags.Alias) {
+            const aliased = context.checker.getAliasedSymbol(symbol);
+            if (aliased.flags & context.ts.SymbolFlags.Value) {
+                return aliased;
+            }
+            continue;
+        }
+        if (symbol.flags & context.ts.SymbolFlags.Value) {
+            return symbol;
+        }
+    }
+    return undefined;
+}
+function resolvePropertyTypes(objectTypes, propertyName, context, allowStringIndexFallback) {
+    const result = [];
+    for (let i = 0; i < objectTypes.length; i++) {
+        const targetType = context.checker.getApparentType(objectTypes[i]);
+        const property = context.checker.getPropertyOfType(targetType, propertyName);
+        if (property) {
+            result.push(context.checker.getTypeOfSymbolAtLocation(property, context.scopeNode));
+            continue;
+        }
+        if (allowStringIndexFallback) {
+            const stringIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.String);
+            if (stringIndexType) {
+                result.push(stringIndexType);
+            }
+        }
+    }
+    return uniqueTypes(result, context.checker, context.scopeNode, context.ts);
+}
+function resolveNumericElementTypes(objectTypes, index, context) {
+    const result = [];
+    const indexName = String(index);
+    for (let i = 0; i < objectTypes.length; i++) {
+        const targetType = context.checker.getApparentType(objectTypes[i]);
+        const property = context.checker.getPropertyOfType(targetType, indexName);
+        if (property) {
+            result.push(context.checker.getTypeOfSymbolAtLocation(property, context.scopeNode));
+        }
+        const numericIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.Number);
+        if (numericIndexType) {
+            result.push(numericIndexType);
+        }
+    }
+    return uniqueTypes(result, context.checker, context.scopeNode, context.ts);
+}
+function resolveIndexedTypes(objectTypes, context) {
+    const result = [];
+    for (let i = 0; i < objectTypes.length; i++) {
+        const targetType = context.checker.getApparentType(objectTypes[i]);
+        const stringIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.String);
+        if (stringIndexType) {
+            result.push(stringIndexType);
+        }
+        const numericIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.Number);
+        if (numericIndexType) {
+            result.push(numericIndexType);
+        }
+    }
+    return uniqueTypes(result, context.checker, context.scopeNode, context.ts);
+}

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+export interface KForPluginConfig {
+    forAttr?: string;
+    itemAttr?: string;
+    indexAttr?: string;
+    itemName?: string;
+    indexName?: string;
+    allowOfKeyword?: boolean;
+}
+export interface ResolvedConfig {
+    forAttr: string;
+    itemAttr: string;
+    indexAttr: string;
+    itemName: string;
+    indexName: string;
+    allowOfKeyword: boolean;
+}
+export interface KForBinding {
+    name: string;
+    types: tsModule.Type[];
+}
+export interface KForScope {
+    start: number;
+    end: number;
+    bindings: KForBinding[];
+}
+export interface ParsedKForExpression {
+    aliases: string[];
+    source: string;
+}
+export interface TypeResolutionContext {
+    checker: tsModule.TypeChecker;
+    ts: typeof tsModule;
+    scopeNode: tsModule.Node;
+    localBindings?: ReadonlyMap<string, readonly tsModule.Type[]>;
+}
+export interface MemberCompletionContext {
+    receiver: string;
+    prefix: string;
+}
+export interface FileAnalysis {
+    sourceFile: tsModule.SourceFile;
+    checker: tsModule.TypeChecker;
+    scopes: KForScope[];
+}
+export type JsxOpeningLikeElement = tsModule.JsxOpeningElement | tsModule.JsxSelfClosingElement;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ktjs/ts-plugin",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "TypeScript language service plugin for kt.js k-for scope names in TSX.",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -39,4 +39,4 @@
   "scripts": {
     "build": "tsc -p tsconfig.json"
   }
-}
+}