@ktjs/ts-plugin 0.1.4 → 0.1.6

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.6",
   "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"
   }
-}
+}