@ktjs/ts-plugin 0.1.3 → 0.1.5

package/README.md

@@ -6,12 +6,12 @@ TypeScript language service plugin for KT.js `k-for` scope variables in TSX.
 
 - Editor-only enhancement (tsserver), no runtime transform.
 - 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 Vue-like syntax:
   - `k-for="item in list"`
   - `k-for="(item, i) in list"`
   - `k-for="(value, key, i) in mapLike"`
-- Keeps legacy fallback mode:
-  - `k-for={list}` with `k-for-item` / `k-for-index` (or configured defaults).
 
 ## Install
 
@@ -19,6 +19,8 @@ TypeScript language service plugin for KT.js `k-for` scope variables in TSX.
 pnpm add -D @ktjs/ts-plugin typescript
 ```
 
+Then open a `.tsx` or `.ts` file in your editor, press `Ctrl+Shift+P` and select "TypeScript: Select TypeScript Version", then choose "Use workspace version" to make sure your editor uses the version of TypeScript where the plugin is installed.
+
 ## Where to install it
 
 Install it in the same project/workspace that owns the `tsconfig.json` where you enable the plugin.

package/dist/ast.d.ts

@@ -0,0 +1,4 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+export declare function findIdentifierAtPosition(sourceFile: tsModule.SourceFile, position: number, ts: typeof tsModule): tsModule.Identifier | undefined;
+export declare function normalizePosition(position: number, sourceFile: tsModule.SourceFile): number;
+export declare function findInnermostNode(node: tsModule.Node, position: number, ts: typeof tsModule): tsModule.Node | undefined;

package/dist/ast.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIdentifierAtPosition = findIdentifierAtPosition;
+exports.normalizePosition = normalizePosition;
+exports.findInnermostNode = findInnermostNode;
+function findIdentifierAtPosition(sourceFile, position, ts) {
+    const exact = findInnermostNode(sourceFile, normalizePosition(position, sourceFile), ts);
+    if (exact && ts.isIdentifier(exact)) {
+        return exact;
+    }
+    if (position > 0) {
+        const previous = findInnermostNode(sourceFile, normalizePosition(position - 1, sourceFile), ts);
+        if (previous && ts.isIdentifier(previous)) {
+            return previous;
+        }
+    }
+    return undefined;
+}
+function normalizePosition(position, sourceFile) {
+    const max = Math.max(sourceFile.text.length - 1, 0);
+    if (position < 0) {
+        return 0;
+    }
+    if (position > max) {
+        return max;
+    }
+    return position;
+}
+function findInnermostNode(node, position, ts) {
+    if (position < node.getFullStart() || position >= node.end) {
+        return undefined;
+    }
+    let match;
+    ts.forEachChild(node, (child) => {
+        const childMatch = findInnermostNode(child, position, ts);
+        if (childMatch) {
+            match = childMatch;
+        }
+    });
+    return match || node;
+}

package/dist/completion.d.ts

@@ -0,0 +1,7 @@
+import type tsModule from 'typescript/lib/tsserverlibrary';
+import type { KForBinding, MemberCompletionContext } from './types';
+export declare function createMemberCompletionEntries(types: tsModule.Type[], prefix: string, checker: tsModule.TypeChecker, scopeNode: tsModule.Node, ts: typeof tsModule): tsModule.CompletionEntry[];
+export declare function createAliasCompletionEntries(bindings: Map<string, KForBinding>, text: string, position: number, ts: typeof tsModule): tsModule.CompletionEntry[];
+export declare function mergeCompletionInfo(completions: tsModule.CompletionInfo | undefined, extraEntries: tsModule.CompletionEntry[], forceMemberCompletion: boolean): tsModule.CompletionInfo;
+export declare function createBindingTypeMap(bindings: Map<string, KForBinding>): Map<string, readonly tsModule.Type[]>;
+export declare function getMemberCompletionContext(text: string, position: number): MemberCompletionContext | undefined;

package/dist/completion.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemberCompletionEntries = createMemberCompletionEntries;
+exports.createAliasCompletionEntries = createAliasCompletionEntries;
+exports.mergeCompletionInfo = mergeCompletionInfo;
+exports.createBindingTypeMap = createBindingTypeMap;
+exports.getMemberCompletionContext = getMemberCompletionContext;
+const constants_1 = require("./constants");
+const identifiers_1 = require("./identifiers");
+const type_resolution_1 = require("./type-resolution");
+function createMemberCompletionEntries(types, prefix, checker, scopeNode, ts) {
+    if (types.length === 0) {
+        return [];
+    }
+    const entries = new Map();
+    const candidates = (0, type_resolution_1.uniqueTypes)(types, checker, scopeNode, ts);
+    for (let i = 0; i < candidates.length; i++) {
+        const properties = checker.getPropertiesOfType(checker.getApparentType(candidates[i]));
+        for (let j = 0; j < properties.length; j++) {
+            const property = properties[j];
+            const name = property.getName();
+            if (!(0, identifiers_1.isValidIdentifier)(name) || name.startsWith('__@')) {
+                continue;
+            }
+            if (prefix && !name.startsWith(prefix)) {
+                continue;
+            }
+            if (entries.has(name)) {
+                continue;
+            }
+            entries.set(name, {
+                name,
+                kind: getCompletionKind(property, ts),
+                kindModifiers: '',
+                sortText: '0',
+            });
+        }
+    }
+    return Array.from(entries.values()).sort((left, right) => left.name.localeCompare(right.name));
+}
+function createAliasCompletionEntries(bindings, text, position, ts) {
+    const prefix = getIdentifierPrefix(text, position);
+    if (prefix.isMemberAccess) {
+        return [];
+    }
+    const entries = [];
+    for (const binding of bindings.values()) {
+        if (prefix.text && !binding.name.startsWith(prefix.text)) {
+            continue;
+        }
+        entries.push({
+            name: binding.name,
+            kind: ts.ScriptElementKind.localVariableElement,
+            kindModifiers: '',
+            sortText: '0',
+        });
+    }
+    return entries;
+}
+function mergeCompletionInfo(completions, extraEntries, forceMemberCompletion) {
+    if (!completions) {
+        return {
+            isGlobalCompletion: !forceMemberCompletion,
+            isMemberCompletion: forceMemberCompletion,
+            isNewIdentifierLocation: !forceMemberCompletion,
+            entries: extraEntries,
+        };
+    }
+    const seen = new Set();
+    for (let i = 0; i < completions.entries.length; i++) {
+        seen.add(completions.entries[i].name);
+    }
+    const merged = completions.entries.slice();
+    for (let i = 0; i < extraEntries.length; i++) {
+        const entry = extraEntries[i];
+        if (seen.has(entry.name)) {
+            continue;
+        }
+        seen.add(entry.name);
+        merged.push(entry);
+    }
+    return {
+        ...completions,
+        isMemberCompletion: completions.isMemberCompletion || forceMemberCompletion,
+        entries: merged,
+    };
+}
+function createBindingTypeMap(bindings) {
+    const map = new Map();
+    for (const binding of bindings.values()) {
+        map.set(binding.name, binding.types);
+    }
+    return map;
+}
+function getMemberCompletionContext(text, position) {
+    const sliceStart = Math.max(0, position - 200);
+    const snippet = text.slice(sliceStart, position);
+    const match = constants_1.MEMBER_COMPLETION_PATTERN.exec(snippet);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        receiver: match[1],
+        prefix: match[2] || '',
+    };
+}
+function getCompletionKind(symbol, ts) {
+    const flags = symbol.flags;
+    if (flags & ts.SymbolFlags.Method) {
+        return ts.ScriptElementKind.memberFunctionElement;
+    }
+    if (flags & ts.SymbolFlags.Function) {
+        return ts.ScriptElementKind.functionElement;
+    }
+    if (flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor | ts.SymbolFlags.Property)) {
+        return ts.ScriptElementKind.memberVariableElement;
+    }
+    return ts.ScriptElementKind.memberVariableElement;
+}
+function getIdentifierPrefix(text, position) {
+    let start = position;
+    while (start > 0 && (0, identifiers_1.isIdentifierPart)(text.charCodeAt(start - 1))) {
+        start--;
+    }
+    const prefix = text.slice(start, position);
+    const isMemberAccess = start > 0 && text.charCodeAt(start - 1) === 46;
+    return { text: prefix, isMemberAccess };
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { KForPluginConfig, ResolvedConfig } from './types';
+export declare function resolveConfig(config?: KForPluginConfig): ResolvedConfig;
+export declare function isJsxLikeFile(fileName: string): boolean;

package/dist/config.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.isJsxLikeFile = isJsxLikeFile;
+const node_path_1 = __importDefault(require("node:path"));
+function resolveConfig(config) {
+    return {
+        forAttr: config?.forAttr || 'k-for',
+        itemAttr: config?.itemAttr || 'k-for-item',
+        indexAttr: config?.indexAttr || 'k-for-index',
+        itemName: config?.itemName || 'item',
+        indexName: config?.indexName || 'index',
+        allowOfKeyword: config?.allowOfKeyword !== false,
+    };
+}
+function isJsxLikeFile(fileName) {
+    const ext = node_path_1.default.extname(fileName).toLowerCase();
+    return ext === '.tsx' || ext === '.jsx';
+}

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const DIAGNOSTIC_CANNOT_FIND_NAME = 2304;
+export declare const IDENTIFIER_RE: RegExp;
+export declare const KFOR_SINGLE_PATTERN: RegExp;
+export declare const KFOR_TUPLE_PATTERN: RegExp;
+export declare const MEMBER_COMPLETION_PATTERN: RegExp;

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMBER_COMPLETION_PATTERN = exports.KFOR_TUPLE_PATTERN = exports.KFOR_SINGLE_PATTERN = exports.IDENTIFIER_RE = exports.DIAGNOSTIC_CANNOT_FIND_NAME = void 0;
+exports.DIAGNOSTIC_CANNOT_FIND_NAME = 2304;
+exports.IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+exports.KFOR_SINGLE_PATTERN = /^([A-Za-z_$][A-Za-z0-9_$]*)\s+(in|of)\s+([\s\S]+)$/;
+exports.KFOR_TUPLE_PATTERN = /^\(\s*([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*))?(?:\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*))?\s*\)\s+(in|of)\s+([\s\S]+)$/;
+exports.MEMBER_COMPLETION_PATTERN = /([A-Za-z_$][A-Za-z0-9_$]*(?:\s*(?:\.\s*[A-Za-z_$][A-Za-z0-9_$]*|\[\s*(?:'[^'\\]*(?:\\.[^'\\]*)*'|"[^"\\]*(?:\\.[^"\\]*)*"|\d+)\s*\]))*)\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)?$/;

package/dist/identifiers.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidIdentifier(name: string): boolean;
+export declare function uniqueIdentifiers(names: string[]): string[];
+export declare function isIdentifierPart(code: number): boolean;

package/dist/identifiers.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidIdentifier = isValidIdentifier;
+exports.uniqueIdentifiers = uniqueIdentifiers;
+exports.isIdentifierPart = isIdentifierPart;
+const constants_1 = require("./constants");
+function isValidIdentifier(name) {
+    return constants_1.IDENTIFIER_RE.test(name);
+}
+function uniqueIdentifiers(names) {
+    const seen = new Set();
+    const result = [];
+    for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        if (!isValidIdentifier(name) || seen.has(name)) {
+            continue;
+        }
+        seen.add(name);
+        result.push(name);
+    }
+    return result;
+}
+function isIdentifierPart(code) {
+    return ((code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        (code >= 48 && code <= 57) ||
+        code === 95 ||
+        code === 36);
+}

package/dist/index.js

@@ -1,17 +1,16 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const node_path_1 = __importDefault(require("node:path"));
-const DIAGNOSTIC_CANNOT_FIND_NAME = 2304;
-const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const KFOR_SINGLE_PATTERN = /^([A-Za-z_$][A-Za-z0-9_$]*)\s+(in|of)\s+([\s\S]+)$/;
-const KFOR_TUPLE_PATTERN = /^\(\s*([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*))?(?:\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*))?\s*\)\s+(in|of)\s+([\s\S]+)$/;
+const ast_1 = require("./ast");
+const completion_1 = require("./completion");
+const constants_1 = require("./constants");
+const config_1 = require("./config");
+const identifiers_1 = require("./identifiers");
+const scope_analysis_1 = require("./scope-analysis");
+const type_resolution_1 = require("./type-resolution");
 function init(modules) {
     const ts = modules.typescript;
     function create(info) {
         const languageService = info.languageService;
-        const config = resolveConfig(info.config);
+        const config = (0, config_1.resolveConfig)(info.config);
         const proxy = Object.create(null);
         for (const key of Object.keys(languageService)) {
             const member = languageService[key];
@@ -19,172 +18,92 @@ function init(modules) {
         }
         proxy.getSemanticDiagnostics = (fileName) => {
             const diagnostics = languageService.getSemanticDiagnostics(fileName);
-            if (!isJsxLikeFile(fileName)) {
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
                 return diagnostics;
             }
-            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
-            if (!sourceFile) {
+            const analysis = (0, scope_analysis_1.getFileAnalysis)(fileName, languageService, ts, config);
+            if (!analysis) {
                 return diagnostics;
             }
-            const scopes = collectKForScopes(sourceFile, ts, config);
-            if (scopes.length === 0) {
-                return diagnostics;
-            }
-            return diagnostics.filter((diag) => {
-                if (diag.code !== DIAGNOSTIC_CANNOT_FIND_NAME || diag.start == null || diag.length == null) {
+            return diagnostics.filter((diagnostic) => {
+                if (diagnostic.code !== constants_1.DIAGNOSTIC_CANNOT_FIND_NAME ||
+                    diagnostic.start == null ||
+                    diagnostic.length == null) {
                     return true;
                 }
-                const name = sourceFile.text.slice(diag.start, diag.start + diag.length).trim();
-                if (!isValidIdentifier(name)) {
+                const name = analysis.sourceFile.text.slice(diagnostic.start, diagnostic.start + diagnostic.length).trim();
+                if (!(0, identifiers_1.isValidIdentifier)(name)) {
                     return true;
                 }
-                return !isSuppressed(diag.start, name, scopes);
+                return !(0, scope_analysis_1.isSuppressed)(diagnostic.start, name, analysis.scopes);
             });
         };
-        return proxy;
-    }
-    return { create };
-}
-function resolveConfig(config) {
-    return {
-        forAttr: config?.forAttr || 'k-for',
-        itemAttr: config?.itemAttr || 'k-for-item',
-        indexAttr: config?.indexAttr || 'k-for-index',
-        itemName: config?.itemName || 'item',
-        indexName: config?.indexName || 'index',
-        allowOfKeyword: config?.allowOfKeyword !== false,
-    };
-}
-function isJsxLikeFile(fileName) {
-    const ext = node_path_1.default.extname(fileName).toLowerCase();
-    return ext === '.tsx' || ext === '.jsx';
-}
-function collectKForScopes(sourceFile, ts, config) {
-    const scopes = [];
-    const visit = (node) => {
-        if (ts.isJsxElement(node)) {
-            const forAttr = getJsxAttribute(node.openingElement, config.forAttr, ts);
-            if (forAttr) {
-                const names = resolveScopeNames(node.openingElement, forAttr, config, ts);
-                const start = node.openingElement.end;
-                const end = node.closingElement.getStart(sourceFile);
-                if (start < end && names.length > 0) {
-                    scopes.push({ start, end, names });
+        proxy.getQuickInfoAtPosition = (fileName, position) => {
+            const quickInfo = languageService.getQuickInfoAtPosition(fileName, position);
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
+                return quickInfo;
+            }
+            const analysis = (0, scope_analysis_1.getFileAnalysis)(fileName, languageService, ts, config);
+            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' }],
+            };
+        };
+        proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+            const completions = languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
+                return completions;
+            }
+            const analysis = (0, scope_analysis_1.getFileAnalysis)(fileName, languageService, ts, config);
+            if (!analysis) {
+                return completions;
+            }
+            const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
+            if (bindings.size === 0) {
+                return completions;
+            }
+            const contextNode = (0, ast_1.findInnermostNode)(analysis.sourceFile, (0, ast_1.normalizePosition)(position, analysis.sourceFile), ts) ||
+                analysis.sourceFile;
+            const localBindings = (0, completion_1.createBindingTypeMap)(bindings);
+            const memberContext = (0, completion_1.getMemberCompletionContext)(analysis.sourceFile.text, position);
+            if (memberContext) {
+                const receiverTypes = (0, type_resolution_1.resolveExpressionTypesFromText)(memberContext.receiver, {
+                    checker: analysis.checker,
+                    ts,
+                    scopeNode: contextNode,
+                    localBindings,
+                });
+                const memberEntries = (0, completion_1.createMemberCompletionEntries)(receiverTypes, memberContext.prefix, analysis.checker, contextNode, ts);
+                if (memberEntries.length > 0) {
+                    return (0, completion_1.mergeCompletionInfo)(completions, memberEntries, true);
                 }
             }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    return scopes;
-}
-function resolveScopeNames(opening, forAttr, config, ts) {
-    const forExpression = getAttributeText(forAttr, ts);
-    if (forExpression !== undefined) {
-        const parsedNames = parseKForAliases(forExpression, config.allowOfKeyword);
-        return parsedNames || [];
-    }
-    const itemName = getScopeName(opening, config.itemAttr, config.itemName, ts);
-    const indexName = getScopeName(opening, config.indexAttr, config.indexName, ts);
-    return uniqueIdentifiers([itemName, indexName]);
-}
-function getScopeName(opening, attrName, fallback, ts) {
-    const attr = getJsxAttribute(opening, attrName, ts);
-    const raw = getAttributeText(attr, ts, true);
-    if (raw && 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 getAttributeName(name) {
-    if ('text' in name) {
-        return String(name.text);
-    }
-    return name.getText();
-}
-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;
-        }
-        if (scope.names.includes(diagnosticName)) {
-            return true;
-        }
-    }
-    return false;
-}
-function parseKForAliases(raw, allowOfKeyword) {
-    const value = raw.trim();
-    if (!value) {
-        return null;
-    }
-    const tupleMatch = KFOR_TUPLE_PATTERN.exec(value);
-    if (tupleMatch) {
-        const keyword = tupleMatch[4];
-        const source = tupleMatch[5]?.trim();
-        if ((!allowOfKeyword && keyword === 'of') || !source) {
-            return null;
-        }
-        return uniqueIdentifiers([tupleMatch[1], tupleMatch[2], tupleMatch[3]].filter(Boolean));
-    }
-    const singleMatch = KFOR_SINGLE_PATTERN.exec(value);
-    if (singleMatch) {
-        const keyword = singleMatch[2];
-        const source = singleMatch[3]?.trim();
-        if ((!allowOfKeyword && keyword === 'of') || !source) {
-            return null;
-        }
-        return uniqueIdentifiers([singleMatch[1]]);
-    }
-    return null;
-}
-function isValidIdentifier(name) {
-    return IDENTIFIER_RE.test(name);
-}
-function uniqueIdentifiers(names) {
-    const seen = new Set();
-    const result = [];
-    for (let i = 0; i < names.length; i++) {
-        const name = names[i];
-        if (!isValidIdentifier(name) || seen.has(name)) {
-            continue;
-        }
-        seen.add(name);
-        result.push(name);
+            const aliasEntries = (0, completion_1.createAliasCompletionEntries)(bindings, analysis.sourceFile.text, position, ts);
+            if (aliasEntries.length > 0) {
+                return (0, completion_1.mergeCompletionInfo)(completions, aliasEntries, false);
+            }
+            return completions;
+        };
+        return proxy;
     }
-    return result;
+    return { create };
 }
 module.exports = init;

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,15 +1,15 @@
 {
   "name": "@ktjs/ts-plugin",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "TypeScript language service plugin for kt.js k-for scope names in TSX.",
   "type": "commonjs",
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.cts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.cts",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.cjs"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [