@ktjs/ts-plugin 0.1.6 → 0.1.8

package/README.md

@@ -8,11 +8,11 @@ TypeScript language service plugin for KT.js `k-for` scope variables in TSX.
 - Suppresses TS2304 (`Cannot find name ...`) for aliases declared by `k-for`.
 - Infers alias types from iterable/indexed sources (for example `k-for="item in users"` makes `item` resolve to `users[number]`).
 - Provides hover type info and member completions for inferred aliases.
+- Supports hover type info inside `k-for` expression strings (`item in users`) for alias/source identifiers.
 - Adds `k-for` inline semantic highlighting in string expressions (for example alias/keyword/source in `k-for="item in list"`).
 - Supports Vue-like syntax:
   - `k-for="item in list"`
   - `k-for="(item, i) in list"`
-  - `k-for="(value, key, i) in mapLike"`
 
 ## Install
 

package/dist/index.js

@@ -5,6 +5,7 @@ const constants_1 = require("./constants");
 const config_1 = require("./config");
 const identifiers_1 = require("./identifiers");
 const kfor_highlighting_1 = require("./kfor-highlighting");
+const quickinfo_1 = require("./quickinfo");
 const scope_analysis_1 = require("./scope-analysis");
 const type_resolution_1 = require("./type-resolution");
 function init(modules) {
@@ -70,25 +71,8 @@ function init(modules) {
             if (!analysis) {
                 return quickInfo;
             }
-            const identifier = (0, ast_1.findIdentifierAtPosition)(analysis.sourceFile, position, ts);
-            if (!identifier) {
-                return quickInfo;
-            }
-            const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
-            const binding = bindings.get(identifier.text);
-            if (!binding) {
-                return quickInfo;
-            }
-            const typeText = (0, type_resolution_1.formatTypeList)(binding.types, analysis.checker, identifier, ts);
-            return {
-                kind: ts.ScriptElementKind.localVariableElement,
-                kindModifiers: '',
-                textSpan: {
-                    start: identifier.getStart(analysis.sourceFile),
-                    length: identifier.getWidth(analysis.sourceFile),
-                },
-                displayParts: [{ text: `(k-for) ${binding.name}: ${typeText}`, kind: 'text' }],
-            };
+            const pluginQuickInfo = (0, quickinfo_1.getKForQuickInfoAtPosition)(analysis, position, ts, config);
+            return pluginQuickInfo || quickInfo;
         };
         proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
             const completions = languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);

package/dist/kfor-highlighting.js

@@ -7,7 +7,6 @@ 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+/;
@@ -233,14 +232,11 @@ function buildSemanticSpans(tokens, format, ts) {
     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)
+                classification: token.kind === 'keyword'
+                    ? encodeSemantic2020(TOKEN_TYPE_VARIABLE, TOKEN_MODIFIER_READONLY)
                     : encodeSemantic2020(TOKEN_TYPE_VARIABLE, 0),
             });
         }

package/dist/quickinfo.d.ts

@@ -0,0 +1,3 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { FileAnalysis, ResolvedConfig } from './types';
+export declare function getKForQuickInfoAtPosition(analysis: FileAnalysis, position: number, ts: typeof tsModule, config: ResolvedConfig): tsModule.QuickInfo | undefined;

package/dist/quickinfo.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKForQuickInfoAtPosition = getKForQuickInfoAtPosition;
+const ast_1 = require("./ast");
+const completion_1 = require("./completion");
+const jsx_attributes_1 = require("./jsx-attributes");
+const identifiers_1 = require("./identifiers");
+const kfor_parser_1 = require("./kfor-parser");
+const scope_analysis_1 = require("./scope-analysis");
+const type_resolution_1 = require("./type-resolution");
+const IDENTIFIER_PATTERN = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+const KEYWORD_DELIMITER_PATTERN = /\s+(in|of)\s+/;
+function getKForQuickInfoAtPosition(analysis, position, ts, config) {
+    const stringQuickInfo = getKForStringQuickInfo(analysis, position, ts, config);
+    if (stringQuickInfo) {
+        return stringQuickInfo;
+    }
+    const identifier = (0, ast_1.findIdentifierAtPosition)(analysis.sourceFile, position, ts);
+    if (!identifier) {
+        return undefined;
+    }
+    const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
+    if (bindings.size === 0) {
+        return undefined;
+    }
+    const aliasBinding = bindings.get(identifier.text);
+    if (aliasBinding) {
+        return createQuickInfo(identifier, `(k-for) ${aliasBinding.name}`, aliasBinding.types, analysis.checker, ts);
+    }
+    const memberTypes = resolveMemberQuickInfoTypes(identifier, bindings, analysis.sourceFile, analysis.checker, ts);
+    if (memberTypes.length > 0) {
+        return createQuickInfo(identifier, `(k-for) ${identifier.text}`, memberTypes, analysis.checker, ts);
+    }
+    return undefined;
+}
+function getKForStringQuickInfo(analysis, position, ts, config) {
+    const context = findKForStringContextAtPosition(analysis.sourceFile, position, ts, config);
+    if (!context) {
+        return undefined;
+    }
+    if (context.token.kind === 'alias') {
+        const bindings = (0, scope_analysis_1.resolveBindingsForForAttribute)(context.opening, context.attr, analysis.checker, config, ts);
+        for (let i = 0; i < bindings.length; i++) {
+            const binding = bindings[i];
+            if (binding.name === context.token.text) {
+                return createQuickInfoForSpan(context.token.start, context.token.length, `(k-for) ${binding.name}`, binding.types, analysis.checker, context.opening, ts);
+            }
+        }
+        return undefined;
+    }
+    if (context.token.kind === 'source') {
+        const expression = getSourceExpressionForToken(context, ts);
+        if (!expression) {
+            return undefined;
+        }
+        const types = (0, type_resolution_1.resolveExpressionTypesFromText)(expression, {
+            checker: analysis.checker,
+            ts,
+            scopeNode: context.opening,
+        });
+        if (types.length === 0) {
+            return undefined;
+        }
+        return createQuickInfoForSpan(context.token.start, context.token.length, `(k-for source) ${context.token.text}`, types, analysis.checker, context.opening, ts);
+    }
+    return undefined;
+}
+function resolveMemberQuickInfoTypes(identifier, bindings, sourceFile, checker, ts) {
+    const parent = identifier.parent;
+    let expressionText;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === identifier) {
+        expressionText = parent.getText(sourceFile);
+    }
+    else if (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier) {
+        expressionText = parent.getText(sourceFile);
+    }
+    if (!expressionText) {
+        return [];
+    }
+    return (0, type_resolution_1.resolveExpressionTypesFromText)(expressionText, {
+        checker,
+        ts,
+        scopeNode: identifier,
+        localBindings: (0, completion_1.createBindingTypeMap)(bindings),
+    });
+}
+function findKForStringContextAtPosition(sourceFile, position, ts, config) {
+    let found;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        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 tokenContext = findTokenInForAttribute(attr, opening, sourceFile, position, ts, config.allowOfKeyword);
+                if (tokenContext) {
+                    found = tokenContext;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function findTokenInForAttribute(attr, opening, sourceFile, position, ts, allowOfKeyword) {
+    const content = getAttributeRawContent(attr, sourceFile, ts);
+    if (!content) {
+        return undefined;
+    }
+    const raw = content.text;
+    const rawStart = content.start;
+    if (position < rawStart || position >= rawStart + raw.length) {
+        return undefined;
+    }
+    const value = raw.trim();
+    if (!value) {
+        return undefined;
+    }
+    const parsed = (0, kfor_parser_1.parseKForExpression)(value, allowOfKeyword);
+    if (!parsed) {
+        return undefined;
+    }
+    const delimiterMatch = KEYWORD_DELIMITER_PATTERN.exec(value);
+    if (!delimiterMatch) {
+        return undefined;
+    }
+    const trimStart = raw.length - raw.trimStart().length;
+    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 aliasStartInRaw = trimStart + leftLeading;
+    if (leftTrimmed.startsWith('(') && leftTrimmed.endsWith(')')) {
+        aliasText = leftTrimmed.slice(1, -1);
+        aliasStartInRaw += 1;
+    }
+    const rightLeading = rightSegment.length - rightSegment.trimStart().length;
+    const sourceText = rightSegment.trim();
+    const sourceStartInRaw = trimStart + delimiterMatch.index + delimiterMatch[0].length + rightLeading;
+    const aliasTokens = collectAliasTokens(aliasText, aliasStartInRaw, parsed.aliases, rawStart);
+    const sourceTokens = collectSourceTokens(sourceText, sourceStartInRaw, rawStart, ts);
+    const keywordToken = {
+        kind: 'keyword',
+        text: keyword,
+        start: rawStart + trimStart + delimiterMatch.index + keywordOffsetInDelimiter,
+        length: keyword.length,
+    };
+    const allTokens = [...aliasTokens, keywordToken, ...sourceTokens];
+    for (let i = 0; i < allTokens.length; i++) {
+        const token = allTokens[i];
+        if (position >= token.start && position < token.start + token.length) {
+            return {
+                opening,
+                attr,
+                sourceText,
+                sourceStart: rawStart + sourceStartInRaw,
+                token,
+            };
+        }
+    }
+    return undefined;
+}
+function collectAliasTokens(aliasText, aliasStartInRaw, aliases, rawStart) {
+    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({
+            kind: 'alias',
+            text: name,
+            start: rawStart + aliasStartInRaw + match.index,
+            length: name.length,
+        });
+    }
+    return result;
+}
+function collectSourceTokens(sourceText, sourceStartInRaw, rawStart, ts) {
+    const tokens = collectSourceTokensWithAst(sourceText, sourceStartInRaw, rawStart, ts);
+    if (tokens.length > 0) {
+        return tokens;
+    }
+    const result = [];
+    let match;
+    IDENTIFIER_PATTERN.lastIndex = 0;
+    while ((match = IDENTIFIER_PATTERN.exec(sourceText))) {
+        const name = match[0];
+        if (!(0, identifiers_1.isValidIdentifier)(name)) {
+            continue;
+        }
+        result.push({
+            kind: 'source',
+            text: name,
+            start: rawStart + sourceStartInRaw + match.index,
+            length: name.length,
+        });
+    }
+    return result;
+}
+function collectSourceTokensWithAst(sourceText, sourceStartInRaw, rawStart, ts) {
+    const snippet = `(${sourceText});`;
+    const tempSourceFile = ts.createSourceFile('__k_for_quickinfo.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 tokens = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && (0, identifiers_1.isValidIdentifier)(node.text)) {
+            const start = node.getStart(tempSourceFile) - 1;
+            const length = node.getWidth(tempSourceFile);
+            if (start >= 0 && start + length <= sourceText.length) {
+                tokens.push({
+                    kind: 'source',
+                    text: node.text,
+                    start: rawStart + sourceStartInRaw + start,
+                    length,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(statement.expression);
+    return uniqueSourceTokens(tokens);
+}
+function uniqueSourceTokens(tokens) {
+    const map = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const key = `${token.start}:${token.length}:${token.text}`;
+        if (!map.has(key)) {
+            map.set(key, token);
+        }
+    }
+    return Array.from(map.values()).sort((left, right) => left.start - right.start);
+}
+function getSourceExpressionForToken(context, ts) {
+    const relativeStart = context.token.start - context.sourceStart;
+    if (relativeStart < 0 || relativeStart >= context.sourceText.length) {
+        return undefined;
+    }
+    const snippet = `(${context.sourceText});`;
+    const tempSourceFile = ts.createSourceFile('__k_for_quickinfo_resolve.ts', snippet, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const lookupPosition = relativeStart + 1;
+    const identifier = (0, ast_1.findIdentifierAtPosition)(tempSourceFile, lookupPosition, ts);
+    if (!identifier) {
+        return context.token.text;
+    }
+    if (ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier) {
+        return identifier.parent.getText(tempSourceFile);
+    }
+    if (ts.isElementAccessExpression(identifier.parent) && identifier.parent.argumentExpression === identifier) {
+        return identifier.parent.getText(tempSourceFile);
+    }
+    return identifier.getText(tempSourceFile);
+}
+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 createQuickInfo(identifier, label, types, checker, ts) {
+    if (types.length === 0) {
+        return undefined;
+    }
+    return createQuickInfoForSpan(identifier.getStart(), identifier.getWidth(), label, types, checker, identifier, ts);
+}
+function createQuickInfoForSpan(start, length, label, types, checker, scopeNode, ts) {
+    return {
+        kind: ts.ScriptElementKind.localVariableElement,
+        kindModifiers: '',
+        textSpan: { start, length },
+        displayParts: [{ text: `${label}: ${(0, type_resolution_1.formatTypeList)(types, checker, scopeNode, ts)}`, kind: 'text' }],
+    };
+}

package/dist/scope-analysis.d.ts

@@ -1,5 +1,6 @@
 import type tsModule from 'typescript/lib/tsserverlibrary';
-import type { FileAnalysis, KForBinding, KForScope, ResolvedConfig } from './types';
+import type { FileAnalysis, JsxOpeningLikeElement, 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>;
+export declare function resolveBindingsForForAttribute(opening: JsxOpeningLikeElement, forAttr: tsModule.JsxAttribute, checker: tsModule.TypeChecker, config: ResolvedConfig, ts: typeof tsModule): KForBinding[];

package/dist/scope-analysis.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFileAnalysis = getFileAnalysis;
 exports.isSuppressed = isSuppressed;
 exports.collectBindingsAtPosition = collectBindingsAtPosition;
+exports.resolveBindingsForForAttribute = resolveBindingsForForAttribute;
 const jsx_attributes_1 = require("./jsx-attributes");
 const kfor_parser_1 = require("./kfor-parser");
 const identifiers_1 = require("./identifiers");
@@ -53,6 +54,9 @@ function collectBindingsAtPosition(position, scopes) {
     }
     return bindings;
 }
+function resolveBindingsForForAttribute(opening, forAttr, checker, config, ts) {
+    return resolveScopeBindings(opening, forAttr, checker, config, ts);
+}
 function collectKForScopes(sourceFile, checker, ts, config) {
     const scopes = [];
     const visit = (node) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ktjs/ts-plugin",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "TypeScript language service plugin for kt.js k-for scope names in TSX.",
   "type": "commonjs",
   "main": "./dist/index.js",