@ktjs/ts-plugin 0.1.4 → 0.1.5

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);
+}