ts-const-value-transformer 0.9.1 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v0.10.0
+
+- Fix to avoid hosting parameters
+- (Experimental) Add features to use language-server (such as `tsgo`)
+
 ## v0.9.1
 
 - Add `hoistConstTemplateLiteral` option

package/README.md

@@ -317,6 +317,37 @@ interface CreatePortalTransformerOptions extends TransformOptions {
 
 If `Promise` cannot be used for some reason, use `createPortalTransformerSync` instead.
 
+#### createPortalTransformerWithTsLs: (options?: CreatePortalTransformerWithTsLsOptions) => Promise<PortalTransformerWithTsLs>
+
+_Experimental_: Creates 'portal transformer' like [`createPortalTransformer`](#createportaltransformer-options-createportaltransformeroptions--promise), but uses TypeScript language server, including [`tsgo`](https://www.npmjs.com/package/@typescript/native-preview), as type information provider.
+
+- To use with `tsgo`, you must install it like `npm install -D @typescript/native-preview`.
+- Currently, `typescript` package is also necessary for parsing source code into AST.
+- Also, tsconfig file must be named with `tsconfig.json` (it is limitation of language server).
+
+`CreatePortalTransformerOptions` has a following signature. Also, `TransformOptions` fields, including `ignoreFiles`, can be used.
+
+```ts
+export interface CreatePortalTransformerWithTsLsOptions
+  extends TransformOptions {
+  /**
+   * Command to run language server. The first element is used for command name and following elements are used for `argv`.
+   * Default is `['npx', 'tsgo', '--lsp', '--stdio']`.
+   */
+  command?: readonly string[];
+  /** Path to tsconfig.json. If omitted, `tsconfig.json` will be used. **Currently `project` must be path to `tsconfig.json` file name; other than `tsconfig.json` is not supported.** */
+  project?: string;
+  /** Package path to `typescript` or `typescript` namespace object. This is still necessary to retrieve AST. */
+  typescript?: string | typeof tsNamespace;
+  /** The current directory for file search. Also affects to `project` option. */
+  cwd?: string;
+  /** Specifies to cache base (original) source code for check if the input is changed. Default is false. */
+  cacheBaseSource?: boolean;
+  /** Specifies to cache result source code. Default is true (false for webpack loader). If the latter process has cache system, specifies false to reduce memory usage. */
+  cacheResult?: boolean;
+}
+```
+
 ## Notice
 
 Starting from v0.4.0, `unsafeHoistWritableValues` option is introduced. Since TypeScript sometimes narrows non-constant values to literal types such as:

package/dist/TsProxy.d.mts

@@ -0,0 +1,105 @@
+export declare namespace ProxyTypes {
+    interface TextRange {
+        readonly pos: number;
+        readonly end: number;
+    }
+    interface Node {
+        readonly pos: number;
+        readonly end: number;
+        parent?: Node;
+    }
+    interface SourceFile extends Node {
+        readonly text: string;
+    }
+    interface Expression extends Node {
+        _expressionBrand?: any;
+    }
+    interface UnaryExpression extends Expression {
+        _unaryExpressionBrand?: any;
+    }
+    interface UpdateExpression extends UnaryExpression {
+        _updateExpressionBrand?: any;
+    }
+    interface LeftHandSideExpression extends UpdateExpression {
+        _leftHandSideExpressionBrand?: any;
+    }
+    interface MemberExpression extends LeftHandSideExpression {
+        _memberExpressionBrand?: any;
+    }
+    interface PrimaryExpression extends MemberExpression {
+        _primaryExpressionBrand?: any;
+    }
+    interface Identifier extends PrimaryExpression {
+        readonly text: string;
+    }
+    interface PrivateIdentifier extends PrimaryExpression {
+        readonly escapedText: string;
+    }
+    type MemberName = Identifier | PrivateIdentifier;
+    interface ElementAccessExpression extends MemberExpression {
+        readonly argumentExpression: Expression;
+    }
+    interface PropertyAccessExpression extends MemberExpression {
+        readonly expression: LeftHandSideExpression;
+        readonly name: MemberName;
+    }
+    interface Type {
+        readonly flags: number;
+    }
+    interface StringLiteralType extends Type {
+        readonly value: string;
+    }
+    interface NumberLiteralType extends Type {
+        readonly value: number;
+    }
+}
+export interface ApiProxy<TTransformationContext = void> {
+    visitEachChild<T extends ProxyTypes.Node>(node: T, visitor: (node: ProxyTypes.Node) => ProxyTypes.Node | readonly ProxyTypes.Node[] | undefined, context: TTransformationContext | undefined): T;
+    getNodeText(node: ProxyTypes.Node, sourceFile: ProxyTypes.SourceFile): string;
+    getNodeFullText(node: ProxyTypes.Node, sourceFile: ProxyTypes.SourceFile): string;
+    appendMultiLineComment<Node extends ProxyTypes.Node>(node: Node, comment: string): Node;
+    setTextRange<T extends ProxyTypes.TextRange>(range: T, location: ProxyTypes.TextRange | undefined): T;
+    isExpression(node: ProxyTypes.Node): node is ProxyTypes.Expression;
+    isAsExpression(node: ProxyTypes.Node): boolean;
+    isCallLikeExpression(node: ProxyTypes.Node): boolean;
+    isTemplateExpression(node: ProxyTypes.Node): boolean;
+    isPropertyAccessExpression(node: ProxyTypes.Node): node is ProxyTypes.PropertyAccessExpression;
+    isElementAccessExpression(node: ProxyTypes.Node): node is ProxyTypes.ElementAccessExpression;
+    isInterfaceDeclaration(node: ProxyTypes.Node): boolean;
+    isTypeAliasDeclaration(node: ProxyTypes.Node): boolean;
+    isImportDeclaration(node: ProxyTypes.Node): boolean;
+    isTypeOnlyExportDeclaration(node: ProxyTypes.Node): boolean;
+    isIdentifier(node: ProxyTypes.Node): node is ProxyTypes.Identifier;
+    isComputedPropertyName(node: ProxyTypes.Node): boolean;
+    getTypeAtLocation(node: ProxyTypes.Node, sourceFile: ProxyTypes.SourceFile): ProxyTypes.Type | undefined;
+    isEnumLiteral(type: ProxyTypes.Type): boolean;
+    isStringLiteral(type: ProxyTypes.Type): type is ProxyTypes.StringLiteralType;
+    isNumberLiteral(type: ProxyTypes.Type): type is ProxyTypes.NumberLiteralType;
+    isBigIntLiteral(type: ProxyTypes.Type): boolean;
+    isBooleanLiteral(type: ProxyTypes.Type): boolean;
+    isNullType(type: ProxyTypes.Type): boolean;
+    isUndefinedType(type: ProxyTypes.Type): boolean;
+    typeToString(type: ProxyTypes.Type): string;
+    factory?: {
+        createIdentifier(text: string): ProxyTypes.Identifier;
+        createStringLiteral(value: string): ProxyTypes.PrimaryExpression;
+        createNumericLiteral(value: number | string): ProxyTypes.PrimaryExpression;
+        createExpressionWithMinusToken(operand: ProxyTypes.Expression): ProxyTypes.Expression;
+        createBigIntLiteral(value: string): ProxyTypes.PrimaryExpression;
+        createTrue(): ProxyTypes.PrimaryExpression;
+        createFalse(): ProxyTypes.PrimaryExpression;
+        createNull(): ProxyTypes.PrimaryExpression;
+        createParenthesizedExpression(expression: ProxyTypes.Expression): ProxyTypes.Expression;
+        createVoidZero(): ProxyTypes.Expression;
+    };
+    isEnumAccess(node: ProxyTypes.PropertyAccessExpression | ProxyTypes.ElementAccessExpression, sourceFile: ProxyTypes.SourceFile): boolean;
+    isEnumIdentifier(node: ProxyTypes.Identifier, sourceFile: ProxyTypes.SourceFile): boolean;
+    isExternalReference(node: ProxyTypes.Node, externalNames: ReadonlyArray<string | RegExp>, sourceFile: ProxyTypes.SourceFile): boolean;
+    hasPureAnnotation(node: ProxyTypes.Node, sourceFile: ProxyTypes.SourceFile): boolean;
+    /** Return `null` if not a target */
+    isReadonlyExpression(node: ProxyTypes.Node, sourceFile: ProxyTypes.SourceFile): boolean | null;
+    isHoistablePropertyAccess(node: ProxyTypes.PropertyAccessExpression | ProxyTypes.ElementAccessExpression, sourceFile: ProxyTypes.SourceFile): boolean;
+    isUndefinedIdentifier(node: ProxyTypes.Identifier, parent: ProxyTypes.Node, sourceFile: ProxyTypes.SourceFile): boolean;
+    makeStringLiteralSource(value: string): string;
+    getLineStarts(sourceFile: ProxyTypes.SourceFile): readonly number[];
+}

package/dist/TsProxy.mjs

@@ -0,0 +1 @@
+export {};

package/dist/createPortalTransformer.mjs

@@ -1,7 +1,8 @@
 import * as fs from 'fs';
 import { createRequire } from 'module';
 import * as path from 'path';
-import { getIgnoreFilesFunction, transformAndPrintSourceWithMap, } from './transform.mjs';
+import { getIgnoreFilesFunction } from './transform.mjs';
+import { transformAndPrintSourceWithMap } from './tscTransformer.mjs';
 const require = createRequire(import.meta.url);
 function optionsToString(options) {
     return JSON.stringify(options, (key, value) => {

package/dist/createPortalTransformerWithTsLs.d.mts

@@ -0,0 +1,59 @@
+import type { RawSourceMap } from 'source-map';
+import type * as tsNamespace from 'typescript';
+import type { PortalTransformerResult, PortalTransformerResultNonNull } from './createPortalTransformer.mjs';
+import { type TransformOptions } from './transform.mjs';
+export interface CreatePortalTransformerWithTsLsOptions extends TransformOptions {
+    /**
+     * Command to run language server. The first element is used for command name and following elements are used for `argv`.
+     * Default is `['npx', 'tsgo', '--lsp', '--stdio']`.
+     */
+    command?: readonly string[];
+    /** Path to tsconfig.json. If omitted, `tsconfig.json` will be used. **Currently `project` must be path to `tsconfig.json` file name; other than `tsconfig.json` is not supported.** */
+    project?: string;
+    /** Package path to `typescript` or `typescript` namespace object. This is still necessary to retrieve AST. */
+    typescript?: string | typeof tsNamespace;
+    /** The current directory for file search. Also affects to `project` option. */
+    cwd?: string;
+    /** Specifies to cache base (original) source code for check if the input is changed. Default is false. */
+    cacheBaseSource?: boolean;
+    /** Specifies to cache result source code. Default is true (false for webpack loader). If the latter process has cache system, specifies false to reduce memory usage. */
+    cacheResult?: boolean;
+}
+export interface PortalTransformerWithTsLs {
+    /** The `typescript` namespace object */
+    readonly ts: typeof tsNamespace;
+    /** Clears transformed cache. */
+    clearCache(): void;
+    /**
+     * Performs transformation.
+     * @param content Base source code. If null, uses loaded source code in the TS project.
+     * @param fileName Base file name (If not included in the TS project, transformation will not be performed.)
+     * @param sourceMap Base source map if exists
+     * @param options Transform options (addition to `options` passed to `createPortalTransformer`)
+     * @returns Tuple of new source code and source map. Source map may be undefined if source code is unchanged.
+     */
+    transform(content: string, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): PortalTransformerResultNonNull;
+    /**
+     * Performs transformation.
+     * @param content Base source code. If null, uses loaded source code in the TS project.
+     * @param fileName Base file name (If not included in the TS project, transformation will not be performed.)
+     * @param sourceMap Base source map if exists
+     * @param options Transform options (addition to `options` passed to `createPortalTransformer`)
+     * @returns Tuple of new source code and source map. Source map may be undefined if source code is unchanged.
+     */
+    transform(content: string | null, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): PortalTransformerResult;
+    /**
+     * Closes the LSP client.
+     */
+    close(): void;
+}
+/**
+ * Creates the new portal transformer instance for the TS project using language server.
+ * After creation, the transformation process can be performed by calling {@link PortalTransformerWithTsLs.transform}.
+ */
+export default function createPortalTransformerWithTsLs(options?: CreatePortalTransformerWithTsLsOptions): Promise<PortalTransformerWithTsLs>;
+/**
+ * Creates the new portal transformer instance for the TS project (using `require` function).
+ * After creation, the transformation process can be performed by calling {@link PortalTransformerWithTsLs.transform}.
+ */
+export declare function createPortalTransformerSyncWithTsLs(options?: CreatePortalTransformerWithTsLsOptions): PortalTransformerWithTsLs;

package/dist/createPortalTransformerWithTsLs.mjs

@@ -0,0 +1,159 @@
+import * as fs from 'fs';
+import { createRequire } from 'module';
+import * as path from 'path';
+import TsLspClient from './lsp/TsLspClient.mjs';
+import { transformAndPrintSourceWithMap } from './lspTransformer.mjs';
+import { getIgnoreFilesFunction } from './transform.mjs';
+const require = createRequire(import.meta.url);
+function optionsToString(options) {
+    return JSON.stringify(options, (key, value) => {
+        if (typeof value === 'function' || value instanceof RegExp) {
+            return value.toString();
+        }
+        if (key === 'typescript' && typeof value === 'object' && value != null) {
+            return '[object typescript]';
+        }
+        return value;
+    });
+}
+function createPortalTransformerImpl(options, ts) {
+    const project = options.project ?? 'tsconfig.json';
+    if (path.basename(project) !== 'tsconfig.json') {
+        throw new Error(`options.project must be 'tsconfig.json' due to restriction of language-server (actual: "${project}")`);
+    }
+    const commandArray = options.command ?? ['npx', 'tsgo', '--lsp', '--stdio'];
+    if (commandArray.length < 1) {
+        throw new Error(`options.command must have at least one element`);
+    }
+    const ignoreFiles = getIgnoreFilesFunction(options.ignoreFiles);
+    const cwd = options.cwd ?? process.cwd();
+    const cacheBaseSource = options.cacheBaseSource ?? false;
+    const cacheResult = options.cacheResult ?? true;
+    const workspaceFolder = path.dirname(path.resolve(cwd, project));
+    const client = new TsLspClient(commandArray[0], commandArray.slice(1));
+    let isInitialized = false;
+    const cache = new Map();
+    const sourceFileMap = new Map();
+    const getSourceFile = (fileName, content) => {
+        let sourceFile = sourceFileMap.get(fileName);
+        if (!sourceFile) {
+            if (content == null) {
+                content = fs.readFileSync(fileName, 'utf-8');
+            }
+            sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
+            sourceFileMap.set(fileName, sourceFile);
+            client.openDocument(fileName, content);
+        }
+        return sourceFile;
+    };
+    const instance = {
+        ts,
+        clearCache: () => cache.clear(),
+        transform: (content, fileName, sourceMap, individualOptions) => {
+            const individualOptionsJson = optionsToString(individualOptions ?? {});
+            if (cacheResult) {
+                const cachedData = cache.get(fileName);
+                if (cachedData &&
+                    (!cacheBaseSource || cachedData.content === content) &&
+                    cachedData.optJson === individualOptionsJson) {
+                    return cachedData.result;
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const rawSourceMap = typeof sourceMap === 'string'
+                ? JSON.parse(sourceMap)
+                : (sourceMap ?? void 0);
+            if (ignoreFiles(fileName)) {
+                return [content, rawSourceMap];
+            }
+            if (!isInitialized) {
+                client.initialize(workspaceFolder);
+            }
+            let sourceFile = sourceFileMap.get(fileName);
+            if (!sourceFile) {
+                sourceFile = getSourceFile(fileName, content);
+            }
+            // If input content is changed, replace it
+            else if (content != null && sourceFile.text !== content) {
+                sourceFile.update(content, {
+                    span: { start: 0, length: sourceFile.end },
+                    newLength: content.length,
+                });
+                sourceFile.text = content;
+            }
+            if (!isInitialized) {
+                client.waitForFirstDiagnosticsReceived();
+                isInitialized = true;
+            }
+            const result = transformAndPrintSourceWithMap(sourceFile, client, getSourceFile, fileName, { ...options, ...individualOptions, ts }, rawSourceMap);
+            if (sourceFile.text === result[0]) {
+                result[1] = undefined;
+            }
+            if (cacheResult) {
+                // This forces to concatenate strings into flatten one, to reduce object trees for ConsString
+                void (result[0] | 0);
+                const json = result[1];
+                if (json) {
+                    void (json.mappings | 0);
+                }
+                cache.set(fileName, {
+                    content: cacheBaseSource ? content : '',
+                    optJson: individualOptionsJson,
+                    result,
+                });
+            }
+            client.closeDocument(fileName);
+            return result;
+        },
+        close: () => {
+            client.exit();
+        },
+    };
+    return instance;
+}
+/**
+ * Creates the new portal transformer instance for the TS project using language server.
+ * After creation, the transformation process can be performed by calling {@link PortalTransformerWithTsLs.transform}.
+ */
+export default async function createPortalTransformerWithTsLs(options = {}) {
+    let ts;
+    if (options.typescript != null) {
+        if (typeof options.typescript === 'string') {
+            // Use eval to avoid webpack warnings
+            // eslint-disable-next-line no-eval
+            ts = (await eval('import(options.typescript)'));
+        }
+        else {
+            ts = options.typescript;
+        }
+    }
+    else if (options.ts != null) {
+        ts = options.ts;
+    }
+    else {
+        ts = await import('typescript');
+    }
+    return createPortalTransformerImpl(options, ts);
+}
+/**
+ * Creates the new portal transformer instance for the TS project (using `require` function).
+ * After creation, the transformation process can be performed by calling {@link PortalTransformerWithTsLs.transform}.
+ */
+export function createPortalTransformerSyncWithTsLs(options = {}) {
+    let ts;
+    if (options.typescript != null) {
+        if (typeof options.typescript === 'string') {
+            ts = require(options.typescript);
+        }
+        else {
+            ts = options.typescript;
+        }
+    }
+    else if (options.ts != null) {
+        ts = options.ts;
+    }
+    else {
+        ts = require('typescript');
+    }
+    return createPortalTransformerImpl(options, ts);
+}

package/dist/createTransformer.mjs

@@ -1,4 +1,5 @@
-import { getIgnoreFilesFunction, transformSource, } from './transform.mjs';
+import { getIgnoreFilesFunction } from './transform.mjs';
+import { transformSource } from './tscTransformer.mjs';
 export default function createTransformer(program, 
 // for ttypescript and ts-patch
 config, 

package/dist/index.d.mts

@@ -1,5 +1,7 @@
 import createPortalTransformer, { createPortalTransformerSync, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull } from './createPortalTransformer.mjs';
+import createPortalTransformerWithTsLs, { createPortalTransformerSyncWithTsLs, type CreatePortalTransformerWithTsLsOptions, type PortalTransformerWithTsLs } from './createPortalTransformerWithTsLs.mjs';
 import createTransformer from './createTransformer.mjs';
 import version from './version.mjs';
-export { printSource, printSourceWithMap, transformAndPrintSource, transformAndPrintSourceWithMap, transformSource, type TransformOptions, } from './transform.mjs';
-export { createPortalTransformer, createPortalTransformerSync, createTransformer, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull, version, };
+export { printSourceWithProxy, printSourceWithMapWithProxy, transformAndPrintSourceWithProxy, transformAndPrintSourceWithMapWithProxy, transformSourceWithProxy, type TransformOptions, } from './transform.mjs';
+export { printSource, printSourceWithMap, transformAndPrintSource, transformAndPrintSourceWithMap, transformSource, } from './tscTransformer.mjs';
+export { createPortalTransformer, createPortalTransformerSync, createTransformer, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull, createPortalTransformerWithTsLs, createPortalTransformerSyncWithTsLs, type CreatePortalTransformerWithTsLsOptions, type PortalTransformerWithTsLs, version, };

package/dist/index.mjs

@@ -1,5 +1,7 @@
 import createPortalTransformer, { createPortalTransformerSync, } from './createPortalTransformer.mjs';
+import createPortalTransformerWithTsLs, { createPortalTransformerSyncWithTsLs, } from './createPortalTransformerWithTsLs.mjs';
 import createTransformer from './createTransformer.mjs';
 import version from './version.mjs';
-export { printSource, printSourceWithMap, transformAndPrintSource, transformAndPrintSourceWithMap, transformSource, } from './transform.mjs';
-export { createPortalTransformer, createPortalTransformerSync, createTransformer, version, };
+export { printSourceWithProxy, printSourceWithMapWithProxy, transformAndPrintSourceWithProxy, transformAndPrintSourceWithMapWithProxy, transformSourceWithProxy, } from './transform.mjs';
+export { printSource, printSourceWithMap, transformAndPrintSource, transformAndPrintSourceWithMap, transformSource, } from './tscTransformer.mjs';
+export { createPortalTransformer, createPortalTransformerSync, createTransformer, createPortalTransformerWithTsLs, createPortalTransformerSyncWithTsLs, version, };

package/dist/lsp/SyncLspClient.d.mts

@@ -0,0 +1,25 @@
+export default class SyncLspClient {
+    /** process */
+    private readonly _p;
+    private _id;
+    /** received data */
+    private readonly _r;
+    /** server message handlers */
+    private readonly _s;
+    /** notification handlers */
+    private readonly _n;
+    /** last buffer */
+    private _l;
+    /** encoding */
+    private readonly _e;
+    constructor(command: string, argv: string[], encoding?: BufferEncoding);
+    private sendRaw;
+    sendMessage(method: string, params?: object): number | string;
+    notifyMessage(method: string, params?: object): void;
+    private pushReceived;
+    pumpMessage(flushOnly?: boolean): boolean;
+    receiveMessage(id: number | string): object | null | undefined;
+    registerServerMessageHandler(method: string, callback: (method: string, params: object | undefined) => object | null | undefined, once?: boolean): () => void;
+    registerNotificationHandler(method: string, callback: (method: string, params: object | undefined) => void, once?: boolean): () => void;
+    close(): void;
+}