ts-const-value-transformer 0.9.0 → 0.10.0

package/dist/lsp/lspTransformerUtil.mjs

@@ -0,0 +1,536 @@
+import * as ts from 'typescript';
+const HOVER_CACHE_SYMBOL = Symbol('hover-cache');
+const TYPE_CACHE_SYMBOL = Symbol('type-cache');
+const READONLY_CACHE_SYMBOL = Symbol('read-only-cache');
+const DEFINITION_CACHE_SYMBOL = Symbol('definition-cache');
+function positionToLineAndColumn(sourceFile, pos) {
+    const p = sourceFile.getLineAndCharacterOfPosition(pos);
+    return { line: p.line, column: p.character };
+}
+function addToPositionByText(pos, text) {
+    const r = {
+        line: pos.line,
+        column: pos.column,
+    };
+    const textLines = text.split(/\r?\n/g);
+    if (textLines.length > 1) {
+        r.line += textLines.length - 1;
+        r.column = textLines[textLines.length - 1].length;
+    }
+    else {
+        r.column += text.length;
+    }
+    return r;
+}
+function getNodeFromPosition(sourceFile, line, pos) {
+    const lines = sourceFile.getLineStarts();
+    if (line >= lines.length) {
+        line = lines.length - 1;
+    }
+    const nodePos = pos + lines[line];
+    let foundNode;
+    visit(sourceFile, undefined);
+    return foundNode;
+    function visit(node, parent) {
+        node.parent = parent;
+        if (node.pos <= nodePos && node.end >= nodePos) {
+            foundNode = node;
+        }
+        ts.visitEachChild(node, (n) => visit(n, node), undefined);
+        return node;
+    }
+}
+function isParentNode(target, child, stopNode) {
+    if (target === child) {
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    while (child.parent) {
+        if (child.parent === target) {
+            return true;
+        }
+        if (child.parent === stopNode) {
+            break;
+        }
+        child = child.parent;
+    }
+    return false;
+}
+function getNodeLineAndColumn(node, sourceFile, tsInstance) {
+    return positionToLineAndColumn(sourceFile, 
+    // For call expression, use end of position of expression (excluding arguments range)
+    tsInstance.isCallExpression(node) ? node.expression.end : node.end);
+}
+function hoverResultToCode(result) {
+    let code = result[1];
+    if (result[0]) {
+        const ra = /```(`*)(?:ts|tsx|typescript|js|jsx|javascript)\s+([\s\S]*?)\s+```\1/.exec(code);
+        if (ra) {
+            code = ra[2];
+        }
+    }
+    return code.trim();
+}
+function getHoverFromNode(node, sourceFile, tsInstance, client) {
+    if (node[HOVER_CACHE_SYMBOL] != null) {
+        return node[HOVER_CACHE_SYMBOL];
+    }
+    const pos = getNodeLineAndColumn(node, sourceFile, tsInstance);
+    const o = client.hoverForPosition(sourceFile.fileName, pos.line, pos.column);
+    const code = hoverResultToCode(o);
+    node[HOVER_CACHE_SYMBOL] = code;
+    return code;
+}
+function isFunctionLike(hover) {
+    return (hover.startsWith('function') ||
+        hover.startsWith('(local function)') ||
+        hover.startsWith('(method)'));
+}
+function hoverToTypeString(node, hover, tsInstance) {
+    if (hover.startsWith('(enum member)')) {
+        hover = hover.slice(13);
+        const s = tsInstance.createScanner(tsInstance.ScriptTarget.Latest, false);
+        s.setText(hover);
+        for (;;) {
+            const t = s.scan();
+            if (t === tsInstance.SyntaxKind.EqualsToken) {
+                return hover.slice(s.getTokenEnd()).trim();
+            }
+            else if (t === tsInstance.SyntaxKind.EndOfFileToken) {
+                return '';
+            }
+        }
+    }
+    else if (node && tsInstance.isIdentifier(node) && isFunctionLike(hover)) {
+        if (hover.startsWith('function')) {
+            hover = hover.slice(8);
+        }
+        else if (hover.startsWith('(local function)')) {
+            hover = hover.slice(16);
+        }
+        else if (hover.startsWith('(method)')) {
+            hover = hover.slice(8);
+        }
+        return hover.trim();
+    }
+    else {
+        const s = tsInstance.createScanner(tsInstance.ScriptTarget.Latest, false);
+        s.setText(hover);
+        const tokenStack = [];
+        for (;;) {
+            const t = s.scan();
+            if (tokenStack.length > 0) {
+                if (tokenStack[tokenStack.length - 1] === t) {
+                    tokenStack.pop();
+                }
+                else if (t === tsInstance.SyntaxKind.EndOfFileToken) {
+                    // Unexpected
+                    return '';
+                }
+                continue;
+            }
+            if (t === tsInstance.SyntaxKind.ColonToken) {
+                return hover.slice(s.getTokenEnd()).trim();
+            }
+            else if (t === tsInstance.SyntaxKind.EndOfFileToken) {
+                // Including indexed access
+                return '';
+            }
+            else if (t === tsInstance.SyntaxKind.LessThanToken) {
+                tokenStack.push(tsInstance.SyntaxKind.GreaterThanToken);
+            }
+            else if (t === tsInstance.SyntaxKind.OpenBraceToken) {
+                tokenStack.push(tsInstance.SyntaxKind.CloseBraceToken);
+            }
+            else if (t === tsInstance.SyntaxKind.OpenBracketToken) {
+                tokenStack.push(tsInstance.SyntaxKind.CloseBracketToken);
+            }
+            else if (t === tsInstance.SyntaxKind.OpenParenToken) {
+                tokenStack.push(tsInstance.SyntaxKind.CloseParenToken);
+            }
+        }
+    }
+}
+function hoverToFunctionReturnTypeString(node, hover, tsInstance) {
+    const t = hoverToTypeString(node, hover, tsInstance);
+    if (isFunctionLike(hover)) {
+        return t;
+    }
+    if (t[0] !== '(') {
+        return '';
+    }
+    // Search type string after '=>'
+    const s = tsInstance.createScanner(tsInstance.ScriptTarget.Latest, false);
+    s.setText(t);
+    const tokenStack = [];
+    for (;;) {
+        const t = s.scan();
+        if (tokenStack.length > 0) {
+            if (tokenStack[tokenStack.length - 1] === t) {
+                tokenStack.pop();
+            }
+            else if (t === tsInstance.SyntaxKind.EndOfFileToken) {
+                // Unexpected
+                return '';
+            }
+            continue;
+        }
+        if (t === tsInstance.SyntaxKind.EqualsGreaterThanToken) {
+            return hover.slice(s.getTokenEnd()).trim();
+        }
+        else if (t === tsInstance.SyntaxKind.EndOfFileToken) {
+            // Unexpected
+            return '';
+        }
+        else if (t === tsInstance.SyntaxKind.LessThanToken) {
+            tokenStack.push(tsInstance.SyntaxKind.GreaterThanToken);
+        }
+        else if (t === tsInstance.SyntaxKind.OpenBraceToken) {
+            tokenStack.push(tsInstance.SyntaxKind.CloseBraceToken);
+        }
+        else if (t === tsInstance.SyntaxKind.OpenBracketToken) {
+            tokenStack.push(tsInstance.SyntaxKind.CloseBracketToken);
+        }
+        else if (t === tsInstance.SyntaxKind.OpenParenToken) {
+            tokenStack.push(tsInstance.SyntaxKind.CloseParenToken);
+        }
+    }
+}
+function retrieveActualTypeString(fileName, pos, tsIntance, client) {
+    const def = client.getTypeDefitition(fileName, pos.line, pos.column);
+    if (!def) {
+        return ['', ''];
+    }
+    const o = client.hoverForPosition(def.fileName, def.lineEnd, def.posEnd);
+    const code = hoverResultToCode(o);
+    return [code, hoverToTypeString(null, code, tsIntance)];
+}
+function typeStringToLiteralType(typeString, tsInstance) {
+    typeString = typeString.trim();
+    if (typeString === '') {
+        return 0;
+    }
+    if (typeString === 'null') {
+        return tsInstance.TypeFlags.Null;
+    }
+    if (typeString === 'undefined') {
+        return tsInstance.TypeFlags.Undefined;
+    }
+    if (typeString === 'true' || typeString === 'false') {
+        return tsInstance.TypeFlags.BooleanLiteral;
+    }
+    // string literal
+    if (/^(["']).*\1$/.test(typeString)) {
+        return tsInstance.TypeFlags.StringLiteral;
+    }
+    // number / bigint
+    const ra = /^-?[0-9]+(?:\.[0-9]*)?(n?)$/.exec(typeString);
+    if (ra) {
+        return ra[1] === 'n'
+            ? tsInstance.TypeFlags.BigIntLiteral
+            : tsInstance.TypeFlags.NumberLiteral;
+    }
+    return 0;
+}
+function performActualPropertyForElementAccessExpression(node, sourceFile, tsInstance, client, perform) {
+    const a = node.argumentExpression;
+    let replacedRange;
+    if (!tsInstance.isLiteralExpression(a)) {
+        // Temporary replace
+        const rStart = positionToLineAndColumn(sourceFile, a.pos);
+        const rEnd = positionToLineAndColumn(sourceFile, a.end);
+        const t = nodeToTypeString(a, sourceFile, tsInstance, client);
+        const flags = typeStringToLiteralType(t, tsInstance);
+        if (flags !== 0) {
+            client.sendReplaceText(sourceFile.fileName, rStart.line, rStart.column, rEnd.line, rEnd.column, t);
+            replacedRange = {
+                start: rStart,
+                end: addToPositionByText(rStart, t),
+            };
+        }
+    }
+    const targetPos = replacedRange
+        ? replacedRange.end
+        : positionToLineAndColumn(sourceFile, a.end);
+    const r = perform(targetPos);
+    if (replacedRange) {
+        // Restore replacement
+        client.sendReplaceText(sourceFile.fileName, replacedRange.start.line, replacedRange.start.column, replacedRange.end.line, replacedRange.end.column, a.getFullText(sourceFile));
+    }
+    return r;
+}
+function elementAccessExpressionToTypeString(node, sourceFile, tsInstance, client) {
+    if (node[TYPE_CACHE_SYMBOL] != null) {
+        return node[TYPE_CACHE_SYMBOL][0];
+    }
+    const typeString = performActualPropertyForElementAccessExpression(node, sourceFile, tsInstance, client, (pos) => {
+        const result = client.hoverForPosition(sourceFile.fileName, pos.line, pos.column);
+        const hover = hoverResultToCode(result);
+        node[HOVER_CACHE_SYMBOL] = hover;
+        let typeString = hoverToTypeString(node, hover, tsInstance);
+        let isEnum = hover.startsWith('(enum member)');
+        if (typeStringToLiteralType(typeString, tsInstance) === 0) {
+            const t = retrieveActualTypeString(sourceFile.fileName, pos, tsInstance, client);
+            if (t[1] !== '') {
+                isEnum = t[0].startsWith('(enum member)');
+                typeString = t[1];
+            }
+        }
+        node[TYPE_CACHE_SYMBOL] = [
+            typeString,
+            isEnum,
+        ];
+        return typeString;
+    });
+    return typeString;
+}
+function templateExpressionToTypeString(node, sourceFile, tsInstance, client) {
+    if (node[TYPE_CACHE_SYMBOL] != null) {
+        return node[TYPE_CACHE_SYMBOL][0];
+    }
+    // hack to retrieve actual literal type by using arrow function
+    // - before: `foo ${'bar'}`
+    // - after: (()=>(`foo ${'bar'}`) as const)()
+    const text = node.getFullText(sourceFile);
+    const rStart = positionToLineAndColumn(sourceFile, node.pos);
+    const rEnd = positionToLineAndColumn(sourceFile, node.end);
+    const replacedText = `(()=>(${text}) as const)()`;
+    client.sendReplaceText(sourceFile.fileName, rStart.line, rStart.column, rEnd.line, rEnd.column, replacedText);
+    const result = client.hoverForPosition(sourceFile.fileName, rStart.line, rStart.column + 4 // middle of arrow '=>' position
+    );
+    const hover = hoverResultToCode(result);
+    node[HOVER_CACHE_SYMBOL] = hover;
+    const typeString = hoverToTypeString(node, hover, tsInstance);
+    const rNewEnd = addToPositionByText(rStart, replacedText);
+    // Restore replacement
+    client.sendReplaceText(sourceFile.fileName, rStart.line, rStart.column, rNewEnd.line, rNewEnd.column, text);
+    node[TYPE_CACHE_SYMBOL] = [
+        typeString,
+        false,
+    ];
+    return typeString;
+}
+// @internal
+export function nodeToTypeString(node, sourceFile, tsInstance, client) {
+    if (node[TYPE_CACHE_SYMBOL] != null) {
+        return node[TYPE_CACHE_SYMBOL][0];
+    }
+    if (tsInstance.isElementAccessExpression(node)) {
+        return elementAccessExpressionToTypeString(node, sourceFile, tsInstance, client);
+    }
+    let typeString;
+    let isEnum = false;
+    if (tsInstance.isAsExpression(node)) {
+        typeString = node.type.getText(sourceFile);
+        if (typeString === 'const') {
+            nodeToTypeString(node.expression, sourceFile, tsInstance, client);
+            // use cached value instead of return value
+            [typeString, isEnum] = node.expression[TYPE_CACHE_SYMBOL];
+        }
+    }
+    else if (tsInstance.isStringLiteral(node)) {
+        typeString = JSON.stringify(node.text);
+    }
+    else if (tsInstance.isNumericLiteral(node) ||
+        tsInstance.isBigIntLiteral(node)) {
+        typeString = node.text;
+    }
+    else if (tsInstance.isTemplateExpression(node)) {
+        typeString = templateExpressionToTypeString(node, sourceFile, tsInstance, client);
+    }
+    else {
+        const hover = getHoverFromNode(node, sourceFile, tsInstance, client);
+        if (tsInstance.isCallExpression(node)) {
+            typeString = hoverToFunctionReturnTypeString(node, hover, tsInstance);
+        }
+        else {
+            typeString = hoverToTypeString(node, hover, tsInstance);
+        }
+        isEnum = hover.startsWith('(enum member)');
+    }
+    if (typeStringToLiteralType(typeString, tsInstance) === 0) {
+        const pos = getNodeLineAndColumn(node, sourceFile, tsInstance);
+        const t = retrieveActualTypeString(sourceFile.fileName, pos, tsInstance, client);
+        if (t[1] !== '') {
+            isEnum = t[0].startsWith('(enum member)');
+            typeString = t[1];
+        }
+    }
+    node[TYPE_CACHE_SYMBOL] = [typeString, isEnum];
+    return typeString;
+}
+// @internal
+export function nodeToTypeFlags(node, sourceFile, tsInstance, client) {
+    const typeString = nodeToTypeString(node, sourceFile, tsInstance, client);
+    let flags = typeStringToLiteralType(typeString, tsInstance);
+    if (node[TYPE_CACHE_SYMBOL][1]) {
+        flags |= tsInstance.TypeFlags.EnumLiteral;
+    }
+    return flags;
+}
+function determineIfPropertyIsReadonly(node, sourceFile, tsInstance, client, getSourceFile) {
+    if (!getSourceFile) {
+        return false;
+    }
+    let def;
+    if (ts.isElementAccessExpression(node)) {
+        def = performActualPropertyForElementAccessExpression(node, sourceFile, tsInstance, client, (pos) => client.getDefinition(sourceFile.fileName, pos.line, pos.column));
+    }
+    else {
+        const pos = positionToLineAndColumn(sourceFile, node.end);
+        def = client.getDefinition(sourceFile.fileName, pos.line, pos.column);
+    }
+    if (!def) {
+        return false;
+    }
+    const defSource = getSourceFile(def.fileName);
+    const expr = getNodeFromPosition(defSource, def.lineEnd, def.posEnd);
+    if (!expr) {
+        return false;
+    }
+    let parent = expr.parent;
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    while (parent) {
+        // For interface/type literal
+        if (ts.isPropertySignature(parent)) {
+            if (parent.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ReadonlyKeyword)) {
+                return true;
+            }
+            break;
+        }
+        else if (ts.isAsExpression(parent)) {
+            // For definition, 'as const' should be readonly
+            if (parent.type.getText(sourceFile) === 'const') {
+                return true;
+            }
+        }
+        else if (ts.isEnumMember(parent)) {
+            // Enum member is readonly
+            return true;
+        }
+        else if (ts.isVariableDeclaration(parent)) {
+            if (isParentNode(parent.name, expr, parent)) {
+                const p = parent.parent;
+                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                if (p && ts.isVariableDeclarationList(p)) {
+                    return (p.flags & ts.NodeFlags.Const) !== 0;
+                }
+            }
+            // Reached to top level
+            break;
+        }
+        if (parent.parent === parent) {
+            break;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+// @internal
+export function isExpressionReadonly(node, sourceFile, tsInstance, client, getSourceFile) {
+    if (node[READONLY_CACHE_SYMBOL] != null) {
+        return node[READONLY_CACHE_SYMBOL];
+    }
+    if (!ts.isIdentifier(node) &&
+        !ts.isPropertyAccessExpression(node) &&
+        !ts.isElementAccessExpression(node)) {
+        return null;
+    }
+    if (ts.isIdentifier(node)) {
+        if (
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        node.parent &&
+            isUndefinedIdentifier(node, node.parent, sourceFile, tsInstance, client)) {
+            return true;
+        }
+        let hover = getHoverFromNode(node, sourceFile, tsInstance, client);
+        if (hover.startsWith('(alias)')) {
+            hover = hover.slice(7).trim();
+            const lines = hover.split(/\r?\n/g);
+            if (lines.length >= 2 && /^import\b/.test(lines[1].trim())) {
+                return true;
+            }
+        }
+        const isReadonly = /^const\b/.test(hover);
+        node[READONLY_CACHE_SYMBOL] =
+            isReadonly;
+        return isReadonly;
+    }
+    return determineIfPropertyIsReadonly(node, sourceFile, tsInstance, client, getSourceFile);
+    // const typeString = nodeToTypeString(node, sourceFile, tsInstance, client);
+    // if (typeStringToLiteralType(typeString, tsInstance) === 0) {
+    //   return null;
+    // }
+    // const diagBefore = client.receiveDiagnostics(sourceFile.fileName);
+    // // Replace expression with `(expression = typeString)` which should be error if expression is read-only
+    // const text = node.getFullText(sourceFile);
+    // const replacedText = `(${text} = ${typeString})`;
+    // const rStart = positionToLineAndColumn(sourceFile, node.pos);
+    // const rEnd = positionToLineAndColumn(sourceFile, node.end);
+    // client.sendReplaceText(
+    //   sourceFile.fileName,
+    //   rStart.line,
+    //   rStart.column,
+    //   rEnd.line,
+    //   rEnd.column,
+    //   replacedText
+    // );
+    // const diagAfter = client.receiveDiagnostics(sourceFile.fileName);
+    // const isReadonly = diagAfter.length > diagBefore.length;
+    // // Restore text
+    // const rNewEnd = addToPositionByText(rStart, replacedText);
+    // client.sendReplaceText(
+    //   sourceFile.fileName,
+    //   rStart.line,
+    //   rStart.column,
+    //   rNewEnd.line,
+    //   rNewEnd.column,
+    //   text
+    // );
+    // (node as ts.Node as NodeWithReadonlyCache)[READONLY_CACHE_SYMBOL] =
+    //   isReadonly;
+    // return isReadonly;
+}
+// @internal
+export function isExternalReference(node, sourceFile, tsInstance, client, externalNames) {
+    if (node[DEFINITION_CACHE_SYMBOL] === undefined) {
+        const pos = getNodeLineAndColumn(node, sourceFile, tsInstance);
+        const def = client.getDefinition(sourceFile.fileName, pos.line, pos.column);
+        node[DEFINITION_CACHE_SYMBOL] =
+            def != null ? def.fileName : null;
+    }
+    const defFile = node[DEFINITION_CACHE_SYMBOL];
+    if (defFile == null) {
+        return false;
+    }
+    if (externalNames.length === 0) {
+        return /[\\/]node_modules[\\/]/.test(defFile);
+    }
+    else {
+        return externalNames.some((part) => {
+            if (typeof part === 'string') {
+                return defFile.replace(/\\/g, '/').includes(part);
+            }
+            else {
+                return part.test(defFile);
+            }
+        });
+    }
+}
+// @internal
+export function isUndefinedIdentifier(node, parent, sourceFile, tsInstance, client) {
+    if (tsInstance.isPropertyAccessExpression(parent) ||
+        tsInstance.isElementAccessExpression(parent)) {
+        return false;
+    }
+    if (node.getText(sourceFile)?.trim() !== 'undefined') {
+        return false;
+    }
+    const typeFlags = nodeToTypeFlags(node, sourceFile, tsInstance, client);
+    return (typeFlags & tsInstance.TypeFlags.Undefined) !== 0;
+}
+// @internal
+export function isEnumAccess(node, sourceFile, tsInstance, client) {
+    const hover = getHoverFromNode(node, sourceFile, tsInstance, client);
+    return hover.startsWith('(enum member)');
+}

package/dist/lspTransformer.d.mts

@@ -0,0 +1,9 @@
+import type * as sourceMap from 'source-map';
+import type * as ts from 'typescript';
+import type TsLspClient from './lsp/TsLspClient.mjs';
+import { type TransformOptions } from './transform.mjs';
+export declare function printSource(sourceFile: ts.SourceFile, tsInstance?: typeof ts): string;
+export declare function printSourceWithMap(sourceFile: ts.SourceFile, originalSourceName: string, startOfSourceMap?: sourceMap.RawSourceMap, tsInstance?: typeof ts): [string, sourceMap.RawSourceMap];
+export declare function transformSource(sourceFile: ts.SourceFile, lspClient: TsLspClient, getSourceFile: (fileName: string) => ts.SourceFile, options?: TransformOptions): ts.SourceFile;
+export declare function transformAndPrintSource(sourceFile: ts.SourceFile, lspClient: TsLspClient, getSourceFile: (fileName: string) => ts.SourceFile, options?: TransformOptions): string;
+export declare function transformAndPrintSourceWithMap(sourceFile: ts.SourceFile, lspClient: TsLspClient, getSourceFile: (fileName: string) => ts.SourceFile, originalSourceName: string, options?: TransformOptions, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];