@ktjs/ts-plugin 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1 +1,7 @@
-export { }
+import type tsModule from 'typescript/lib/tsserverlibrary';
+declare function init(modules: {
+    typescript: typeof tsModule;
+}): {
+    create: (info: tsModule.server.PluginCreateInfo) => tsModule.LanguageService;
+};
+export = init;

package/dist/index.js

@@ -0,0 +1,190 @@
+"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]+)$/;
+function init(modules) {
+    const ts = modules.typescript;
+    function create(info) {
+        const languageService = info.languageService;
+        const config = resolveConfig(info.config);
+        const proxy = Object.create(null);
+        for (const key of Object.keys(languageService)) {
+            const member = languageService[key];
+            proxy[key] = (...args) => member.apply(languageService, args);
+        }
+        proxy.getSemanticDiagnostics = (fileName) => {
+            const diagnostics = languageService.getSemanticDiagnostics(fileName);
+            if (!isJsxLikeFile(fileName)) {
+                return diagnostics;
+            }
+            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                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 true;
+                }
+                const name = sourceFile.text.slice(diag.start, diag.start + diag.length).trim();
+                if (!isValidIdentifier(name)) {
+                    return true;
+                }
+                return !isSuppressed(diag.start, name, 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 });
+                }
+            }
+        }
+        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);
+    }
+    return result;
+}
+module.exports = init;

package/package.json

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

package/dist/index.mjs

@@ -1 +0,0 @@
-