@samchon/ts-patch 3.2.2-dev.20241204-2 → 3.4.0

package/projects/patch/src/ts/create-program.ts

@@ -0,0 +1,156 @@
+namespace tsp {
+  const activeProgramTransformers = new Set<string>();
+  const { dirname } = require('path');
+
+  /* ********************************************************* */
+  // region: Helpers
+  /* ********************************************************* */
+
+  function getProjectDir(compilerOptions: tsShim.CompilerOptions) {
+    return compilerOptions.configFilePath && dirname(compilerOptions.configFilePath);
+  }
+
+  function getProjectConfig(compilerOptions: tsShim.CompilerOptions, rootFileNames: ReadonlyArray<string>) {
+    let configFilePath = compilerOptions.configFilePath;
+    let projectDir = getProjectDir(compilerOptions);
+
+    if (configFilePath === undefined) {
+      const baseDir = (rootFileNames.length > 0) ? dirname(rootFileNames[0]) : projectDir ?? process.cwd();
+      configFilePath = tsShim.findConfigFile(baseDir, tsShim.sys.fileExists);
+
+      if (configFilePath) {
+        const config = readConfig(configFilePath);
+        compilerOptions = { ...config.options, ...compilerOptions };
+        projectDir = getProjectDir(compilerOptions);
+      }
+    }
+
+    return ({ projectDir, compilerOptions });
+  }
+
+  function readConfig(configFileNamePath: string) {
+    const projectDir = dirname(configFileNamePath);
+    const result = tsShim.readConfigFile(configFileNamePath, tsShim.sys.readFile);
+
+    if (result.error) throw new TsPatchError('Error in tsconfig.json: ' + result.error.messageText);
+
+    return tsShim.parseJsonConfigFileContent(result.config, tsShim.sys, projectDir, undefined, configFileNamePath);
+  }
+
+  function preparePluginsFromCompilerOptions(plugins: any): PluginConfig[] {
+    if (!plugins) return [];
+
+    // Old transformers system
+    if ((plugins.length === 1) && plugins[0].customTransformers) {
+      const { before = [], after = [] } = (plugins[0].customTransformers as { before: string[]; after: string[] });
+
+      return [
+        ...before.map((item: string) => ({ transform: item })),
+        ...after.map((item: string) => ({ transform: item, after: true })),
+      ];
+    }
+
+    return plugins;
+  }
+
+  // endregion
+
+  /* ********************************************************* *
+   * Patched createProgram()
+   * ********************************************************* */
+
+  export function createProgram(
+    rootNamesOrOptions: ReadonlyArray<string> | tsShim.CreateProgramOptions,
+    options?: tsShim.CompilerOptions,
+    host?: tsShim.CompilerHost,
+    oldProgram?: tsShim.Program,
+    configFileParsingDiagnostics?: ReadonlyArray<tsShim.Diagnostic>
+  ): tsShim.Program {
+    let rootNames;
+
+    /* Determine options */
+    const createOpts = !Array.isArray(rootNamesOrOptions) ? <tsShim.CreateProgramOptions>rootNamesOrOptions : void 0;
+    if (createOpts) {
+      rootNames = createOpts.rootNames;
+      options = createOpts.options;
+      host = createOpts.host;
+      oldProgram = createOpts.oldProgram;
+      configFileParsingDiagnostics = createOpts.configFileParsingDiagnostics;
+    } else {
+      options = options!;
+      rootNames = rootNamesOrOptions as ReadonlyArray<string>;
+    }
+
+    /* Get Config */
+    const projectConfig = getProjectConfig(options, rootNames);
+    if ([ 'tsc', 'tsserver', 'tsserverlibrary' ].includes(tsp.currentLibrary)) {
+      options = projectConfig.compilerOptions;
+      if (createOpts) createOpts.options = options;
+    }
+
+    /* Prepare Plugins */
+    const plugins = preparePluginsFromCompilerOptions(options.plugins);
+    const pluginCreator = new PluginCreator(plugins, { resolveBaseDir: projectConfig.projectDir ?? process.cwd() });
+
+    /* Handle JSDoc parsing in v5.3+ */
+    if (tsp.currentLibrary === 'tsc' && tsShim.JSDocParsingMode && pluginCreator.needsTscJsDocParsing) {
+      host!.jsDocParsingMode = tsShim.JSDocParsingMode.ParseAll;
+    }
+
+    /* Invoke TS createProgram */
+    let program: tsShim.Program & { originalEmit?: tsShim.Program['emit'] } = createOpts ?
+      tsShim.originalCreateProgram(createOpts) :
+      tsShim.originalCreateProgram(rootNames, options, host, oldProgram, configFileParsingDiagnostics);
+
+    /* Prevent recursion in Program transformers */
+    const programTransformers = pluginCreator.createProgramTransformers();
+
+    /* Transform Program */
+    for (const [ transformerKey, [ programTransformer, config ] ] of programTransformers) {
+      if (activeProgramTransformers.has(transformerKey)) continue;
+      activeProgramTransformers.add(transformerKey);
+
+      const newProgram: any = programTransformer(program, host, config, { ts: tsp.getTsInstance() });
+      if (typeof newProgram?.['emit'] === 'function') program = newProgram;
+
+      activeProgramTransformers.delete(transformerKey);
+    }
+
+    /* Hook emit method */
+    if (!program.originalEmit) {
+      program.originalEmit = program.emit;
+      program.emit = newEmit;
+    }
+
+    function newEmit(
+      targetSourceFile?: tsShim.SourceFile,
+      writeFile?: tsShim.WriteFileCallback,
+      cancellationToken?: tsShim.CancellationToken,
+      emitOnlyDtsFiles?: boolean,
+      customTransformers?: tsShim.CustomTransformers,
+      ...additionalArgs: any
+    ): tsShim.EmitResult {
+      /* Merge in our transformers */
+      const transformers = pluginCreator.createSourceTransformers({ program }, customTransformers);
+
+      /* Invoke TS emit */
+      const result: tsShim.EmitResult = program.originalEmit!(
+        targetSourceFile,
+        writeFile,
+        cancellationToken,
+        emitOnlyDtsFiles,
+        transformers,
+        // @ts-ignore
+        ...additionalArgs
+      );
+
+      /* Merge in transformer diagnostics */
+      for (const diagnostic of tsp.diagnosticMap.get(program) || [])
+        if (!result.diagnostics.includes(diagnostic)) (<tsShim.Diagnostic[]>result.diagnostics).push(diagnostic)
+
+      return result;
+    }
+
+    return program;
+  }
+}

package/projects/patch/src/ts/shim.ts

@@ -0,0 +1,43 @@
+/** @internal */
+namespace tsp {
+  /**
+   * Compensate for modules which do not wrap functions in a `ts` namespace.
+   */
+  export const tsShim = new Proxy(
+    {},
+    {
+      get(_, key: string) {
+        const target = tsp.getTsInstance();
+        if (target) {
+          return (<any>target)[key];
+        } else {
+          try {
+            return eval(key);
+          } catch (e) {
+            throw new TsPatchError(`Failed to find "${key}" in TypeScript shim`, e);
+          }
+        }
+      },
+    }
+  ) as typeof import('typescript');
+
+  export namespace tsShim {
+    export type CompilerOptions = import('typescript').CompilerOptions;
+    export type CreateProgramOptions = import('typescript').CreateProgramOptions;
+    export type Program = import('typescript').Program;
+    export type CompilerHost = import('typescript').CompilerHost;
+    export type Diagnostic = import('typescript').Diagnostic;
+    export type SourceFile = import('typescript').SourceFile;
+    export type WriteFileCallback = import('typescript').WriteFileCallback;
+    export type CancellationToken = import('typescript').CancellationToken;
+    export type CustomTransformers = import('typescript').CustomTransformers;
+    export type EmitResult = import('typescript').EmitResult;
+    export type LanguageService = import('typescript').LanguageService;
+    export type TransformationContext = import('typescript').TransformationContext;
+    export type Node = import('typescript').Node;
+    export type TransformerFactory<T extends Node> = import('typescript').TransformerFactory<T>;
+    export type Bundle = import('typescript').Bundle;
+    export type Path = import('typescript').Path;
+    export type JSDocParsingMode = import('typescript').JSDocParsingMode;
+  }
+}

package/projects/patch/src/types/plugin-types.ts

@@ -0,0 +1,51 @@
+// @ts-nocheck
+/** AUTO-GENERATED - DO NOT EDIT */
+
+/** @build-types */
+declare namespace tsp {
+    export interface PluginConfig {
+        [x: string]: any;
+        name?: string;
+        transform?: string;
+        resolvePathAliases?: boolean;
+        tsConfig?: string;
+        import?: string;
+        isEsm?: boolean;
+        type?: 'ls' | 'program' | 'config' | 'checker' | 'raw' | 'compilerOptions';
+        after?: boolean;
+        afterDeclarations?: boolean;
+        transformProgram?: boolean;
+    }
+    export type TransformerList = Required<ts.CustomTransformers>;
+    export type TransformerPlugin = TransformerBasePlugin | TsTransformerFactory;
+    export type TsTransformerFactory = ts.TransformerFactory<ts.SourceFile>;
+    export type PluginFactory = LSPattern | ProgramPattern | ConfigPattern | CompilerOptionsPattern | TypeCheckerPattern | RawPattern;
+    export interface TransformerBasePlugin {
+        before?: ts.TransformerFactory<ts.SourceFile> | ts.TransformerFactory<ts.SourceFile>[];
+        after?: ts.TransformerFactory<ts.SourceFile> | ts.TransformerFactory<ts.SourceFile>[];
+        afterDeclarations?: ts.TransformerFactory<ts.SourceFile | ts.Bundle> | ts.TransformerFactory<ts.SourceFile | ts.Bundle>[];
+    }
+    export type DiagnosticMap = WeakMap<ts.Program, ts.Diagnostic[]>;
+    export type TransformerExtras = {
+        ts: typeof ts;
+        library: string;
+        addDiagnostic: (diag: ts.Diagnostic) => number;
+        removeDiagnostic: (index: number) => void;
+        diagnostics: readonly ts.Diagnostic[];
+    };
+    export type ProgramTransformerExtras = {
+        ts: typeof ts;
+    };
+    export type ProgramTransformer = (program: ts.Program, host: ts.CompilerHost | undefined, config: PluginConfig, extras: ProgramTransformerExtras) => ts.Program;
+    export type LSPattern = (ls: ts.LanguageService, config: {}) => TransformerPlugin;
+    export type CompilerOptionsPattern = (compilerOpts: ts.CompilerOptions, config: {}) => TransformerPlugin;
+    export type ConfigPattern = (config: {}) => TransformerPlugin;
+    export type TypeCheckerPattern = (checker: ts.TypeChecker, config: {}) => TransformerPlugin;
+    export type ProgramPattern = (program: ts.Program, config: {}, extras: TransformerExtras) => TransformerPlugin;
+    export type RawPattern = (context: ts.TransformationContext, program: ts.Program, config: {}) => ts.Transformer<ts.SourceFile>;
+    export interface PluginPackageConfig {
+        tscOptions?: {
+            parseAllJsDoc?: boolean;
+        };
+    }
+}

package/projects/patch/src/types/typescript.ts

@@ -0,0 +1,11 @@
+/* ****************************************************************************************************************** *
+ * Added Properties
+ * ****************************************************************************************************************** */
+
+/** @build-types */
+declare namespace ts {
+  /** @internal */
+  const createProgram: typeof import('typescript').createProgram;
+
+  export const originalCreateProgram: typeof ts.createProgram;
+}

package/projects/patch/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "include": [
+    "src"
+  ],
+
+  "compilerOptions": {
+    "outFile": "../../dist/resources/module-patch.js",
+    "rootDir": "./src",
+    "declaration": true,
+    "types": [ "@types/node" ],
+
+    "strict": true,
+    "noUnusedLocals": false,
+    "noImplicitReturns": true,
+    "allowSyntheticDefaultImports": true,
+    "stripInternal": true,
+
+    "target": "ES2020",
+    "downlevelIteration": true,
+    "useUnknownInCatchVariables": false,
+    "ignoreDeprecations": "6.0",
+    "newLine": "LF",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+
+    "plugins": [
+      {
+        "transform": "./plugin.ts",
+        "transformProgram": true,
+        "import": "transformProgram"
+      }
+    ]
+  }
+}

package/scripts/postbuild.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+const shell = require('shelljs');
+const path = require('path');
+const fs = require('fs');
+const glob = require('glob');
+
+
+/* ********************************************************************************************************************
+ * Constants
+ * ********************************************************************************************************************/
+
+const BASE_DIR = path.resolve('.');
+const SRC_DIR = path.resolve('./src');
+const DIST_DIR = path.resolve('./dist');
+const DIST_RESOURCE_DIR = path.join(DIST_DIR, 'resources');
+const COMPILER_DIR = path.resolve('./projects/core/src/compiler');
+
+
+/* ********************************************************************************************************************
+ * Post-Build Steps
+ * ********************************************************************************************************************/
+
+/* Uncomment this if you need to temporarily build without patched ts */
+// shell.mv(path.join(DIST_DIR, 'src', '*'), DIST_DIR);
+// shell.mv(path.join(DIST_DIR, 'shared', '*'), DIST_DIR);
+// shell.rm('-rf', path.join(DIST_DIR, 'src'));
+// shell.rm('-rf', path.join(DIST_DIR, 'shared'));
+
+/* Build package.json */
+const pkgJSON = JSON.parse(fs.readFileSync(path.join(BASE_DIR, 'package.json'), 'utf8'));
+
+delete pkgJSON.scripts;
+delete pkgJSON.private;
+delete pkgJSON.workspaces;
+delete pkgJSON.devDependencies;
+
+// Write & remove ./dist
+fs.writeFileSync(
+  path.join(DIST_DIR, 'package.json'),
+  JSON.stringify(pkgJSON, null, 2).replace(/(?<=['"].*?)dist\//g, '')
+);
+
+/* Copy Live files */
+shell.cp('-r', COMPILER_DIR, DIST_DIR);
+
+/* Copy Readme & Changelog */
+shell.cp(path.resolve('./README.md'), DIST_DIR);
+shell.cp(path.resolve('./CHANGELOG.md'), DIST_DIR);
+shell.cp(path.resolve('./LICENSE.md'), DIST_DIR);
+
+/* Add shebang line to bin files */
+const binFiles = glob
+  .sync(path.join(DIST_DIR, 'bin', '*.js'))
+  .map((filePath) => [
+      filePath,
+      `#!/usr/bin/env node\n\n` + fs.readFileSync(filePath, 'utf8')
+  ]);
+
+for (const [ filePath, fileContent] of binFiles) {
+  const fileName = path.basename(filePath);
+  fs.writeFileSync(path.join(DIST_DIR, 'bin', fileName), fileContent, 'utf8');
+}
+
+/* Ensure EOL = LF in resources */
+const resFiles = glob.sync(path.join(DIST_RESOURCE_DIR, '*').replace(/\\/g, '/'));
+shell.sed('-i', /\r+$/, '', resFiles);

package/test/.yarnrc

@@ -0,0 +1 @@
+--no-lockfile true

package/test/assets/projects/main/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "test-project",
+  "private": true,
+  "dependencies": {}
+}

package/test/assets/projects/main/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "include" : [ "src" ],
+  "compilerOptions": {
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "strict": true,
+
+    "lib": [ "ESNext" ],
+    "target": "ESNext",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+
+    "newLine": "LF",
+    "allowSyntheticDefaultImports": true
+  }
+}

package/test/assets/projects/package-config/plugin/package.json

@@ -0,0 +1,8 @@
+{
+  "main" : "plugin.js",
+  "tsp": {
+    "tscOptions": {
+      "parseAllJsDoc": true
+    }
+  }
+}

package/test/assets/projects/package-config/plugin/plugin.js

@@ -0,0 +1,9 @@
+const transformer1Factory = require('./transformers/transformer1');
+const transformer2Factory = require('./transformers/transformer2');
+
+module.exports = function(...args) {
+  return {
+    before: [transformer1Factory(...args), transformer2Factory(...args)],
+    after: () => { throw new Error('after should be unreachable') }
+  }
+}

package/test/assets/projects/package-config/plugin/transformers/transformer1.js

@@ -0,0 +1,28 @@
+/**
+ * Change the value of a variable declaration to the value of all jsDoc comments
+ */
+function transformer1Factory(program, config, { ts }) {
+  return context => {
+    const { factory } = context;
+
+    function visitor(node) {
+      if (ts.isVariableDeclaration(node) && node.initializer) {
+        const jsDocs = ts.getJSDocTags(node);
+        if (jsDocs.length > 0) {
+          const jsDocComment = jsDocs.map(doc => doc.comment).filter(comment => comment).join(' ');
+          return factory.createVariableDeclaration(
+            node.name,
+            undefined,
+            undefined,
+            factory.createStringLiteral(jsDocComment)
+          );
+        }
+      }
+      return ts.visitEachChild(node, visitor, context);
+    }
+
+    return sourceFile => ts.visitNode(sourceFile, visitor);
+  };
+}
+
+module.exports = transformer1Factory;

package/test/assets/projects/package-config/plugin/transformers/transformer2.js

@@ -0,0 +1,22 @@
+/**
+ * Transform let to const
+ */
+function transformer2Factory(program, config, { ts }) {
+  return context => {
+    const { factory } = context;
+
+    function visitor(node) {
+      if (ts.isVariableStatement(node) && node.declarationList.flags & ts.NodeFlags.Let) {
+        return factory.createVariableStatement(
+          undefined,
+          factory.createVariableDeclarationList(node.declarationList.declarations, ts.NodeFlags.Const)
+        );
+      }
+      return ts.visitEachChild(node, visitor, context);
+    }
+
+    return sourceFile => ts.visitNode(sourceFile, visitor);
+  }
+}
+
+module.exports = transformer2Factory;

package/test/assets/projects/package-config/run-transform.js

@@ -0,0 +1,72 @@
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { getLiveModule } = require('ts-patch');
+const { runInThisContext } = require("vm");
+
+
+/* ****************************************************************************************************************** *
+ * Helpers
+ * ****************************************************************************************************************** */
+
+function runTsc(disableTspClause) {
+  const pluginDir = path.resolve(__dirname, 'plugin');
+  const pluginPackageJsonPath = path.join(pluginDir, 'package.json');
+
+  process.env.TSP_SKIP_CACHE = true;
+  const { js, tsModule } = getLiveModule('tsc.js');
+
+  let currentWriteFile = undefined;
+  const fs = {
+    ...require('fs'),
+    mkdirSync: function (dirPath) {
+      return;
+    },
+    writeFileSync: function (filePath, data, options) {
+      throw new Error('Should not be used');
+    },
+    openSync: function (filePath, flags, mode) {
+      currentWriteFile = filePath;
+      return 1;
+    },
+    writeSync: function (fd, data, options) {
+      // process.stdout.write(currentWriteFile + '\n');
+
+      // Check if the file is src/index.ts and output to stdout
+      if (path.basename(currentWriteFile) === 'index.js') {
+        process.stdout.write(data);
+      }
+    },
+    closeSync: function (fd) {
+      currentWriteFile = undefined;
+    },
+    readFileSync: function (filePath, options) {
+      if (disableTspClause && path.normalize(filePath) === pluginPackageJsonPath) {
+        return JSON.stringify({ });
+      }
+      return require('fs').readFileSync(filePath, options);
+    }
+  }
+
+  const myRequire = function (modulePath) {
+    if (modulePath === 'fs') return fs;
+    return require(modulePath);
+  }
+  Object.assign(myRequire, require);
+
+  const script = runInThisContext(`
+    (function (exports, require, module, __filename, __dirname) {
+      process.argv = ['node', 'tsc.js', '--noEmit', 'false'];
+      ${js}
+    });
+  `);
+
+  script.call(exports, exports, myRequire, module, tsModule.modulePath, path.dirname(tsModule.modulePath));
+}
+
+
+/* ****************************************************************************************************************** *
+ * Entry
+ * ****************************************************************************************************************** */
+
+const disableTspClause = process.argv[2] === '--disable';
+runTsc(disableTspClause);

package/test/assets/projects/package-config/src/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @tag1 ExampleTag1
+ * @tag2 ExampleTag2
+ */
+let myVar = 123;
+let anotherVar = "test";

package/test/assets/projects/package-config/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "include": [ "src" ],
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "module": "commonjs",
+    "target": "esnext",
+    "noEmit": true,
+    "plugins" : [
+      { "transform": "./plugin" }
+    ]
+  }
+}

package/test/assets/projects/path-mapping/base.ts

@@ -0,0 +1 @@
+export const b = 2;

package/test/assets/projects/path-mapping/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "path-mapping-test",
+  "main": "src/index.ts",
+  "dependencies": {
+    "ts-node" : "^10.9.1",
+    "tsconfig-paths" : "^4.2.0"
+  }
+}

package/test/assets/projects/path-mapping/src/a/a.ts

@@ -0,0 +1 @@
+export const aVar = "a";

package/test/assets/projects/path-mapping/src/b.ts

@@ -0,0 +1 @@
+export const bVar = "b";

package/test/assets/projects/path-mapping/src/index.ts

@@ -0,0 +1,29 @@
+// @ts-nocheck
+
+import * as ts from 'typescript';
+import '@a/a';
+import '@b';
+
+const tryRequire = (path: string) => {
+  try {
+    require(path);
+  } catch (e) {
+    if (e.code === 'MODULE_NOT_FOUND') {
+      return false;
+    } else {
+      throw e;
+    }
+  }
+
+  return true;
+}
+
+export default function(program: ts.Program, pluginOptions: any) {
+  return (ctx: ts.TransformationContext) => {
+    process.stdout.write(`sub-path:${tryRequire('@a/a')}\n`);
+    process.stdout.write(`path:${tryRequire('@b')}\n`);
+    process.stdout.write(`non-mapped:${tryRequire('@c')}\n`);
+
+    return (_: any) => _;
+  };
+}

package/test/assets/projects/path-mapping/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "include": [ "base.ts" ],
+  "compilerOptions": {
+    "outDir" : "dist",
+    "moduleResolution" : "node",
+    "ignoreDeprecations": "6.0",
+    "module": "commonjs",
+    "target": "ES2020",
+    "noEmit": false,
+    "plugins" : [
+      {
+        "transform": "./src/index.ts",
+        "tsConfig": "./tsconfig.plugin.json",
+        "resolvePathAliases": "always",
+      }
+    ]
+  }
+}

package/test/assets/projects/path-mapping/tsconfig.plugin.json

@@ -0,0 +1,15 @@
+{
+  "include": [ "src" ],
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "module": "commonjs",
+    "target": "ES2020",
+    "noEmit": true,
+    "baseUrl" : "src",
+    "paths": {
+      "@a/*": [ "./a/*" ],
+      "@b": [ "./b" ],
+    }
+  }
+}

package/test/assets/projects/transform/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "minimal-ts-patch",
+  "main": "src/index.ts",
+  "dependencies": {
+    "esm": "^3.2.25",
+    "ts-node" : "^10.9.1",
+    "semver" : "^7.6.3"
+  }
+}