@samchon/ts-patch 3.2.2 → 3.4.0

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

@@ -0,0 +1,254 @@
+namespace tsp {
+  const crypto = require('crypto');
+
+  /* ********************************************************* */
+  // region: Types
+  /* ********************************************************* */
+
+  /** @internal */
+  interface CreateTransformersFromPatternOptions {
+    factory: PluginFactory;
+    config: PluginConfig;
+    registerConfig: RegisterConfig;
+    program: tsShim.Program;
+    ls?: tsShim.LanguageService;
+  }
+
+  export namespace PluginCreator {
+    export interface Options {
+      resolveBaseDir: string;
+    }
+  }
+
+  // endregion
+
+  /* ********************************************************* */
+  // region: Helpers
+  /* ********************************************************* */
+
+  function createTransformersFromPattern(opt: CreateTransformersFromPatternOptions): TransformerBasePlugin {
+    const { factory, config, program, ls, registerConfig } = opt;
+    const { transform, after, afterDeclarations, name, type, transformProgram, ...cleanConfig } = config;
+
+    if (!transform) throw new TsPatchError('Not a valid config entry: "transform" key not found');
+
+    // @formatter:off
+    const transformerKind =
+      after ? 'after' :
+      afterDeclarations ? 'afterDeclarations' :
+      'before';
+    // @formatter:on
+
+    let pluginFactoryResult: TransformerPlugin;
+    switch (config.type) {
+      case 'ls':
+        if (!ls) throw new TsPatchError(`Plugin ${transform} needs a LanguageService`);
+        pluginFactoryResult = (factory as LSPattern)(ls, cleanConfig);
+        break;
+
+      case 'config':
+        pluginFactoryResult = (factory as ConfigPattern)(cleanConfig);
+        break;
+
+      case 'compilerOptions':
+        pluginFactoryResult = (factory as CompilerOptionsPattern)(program.getCompilerOptions(), cleanConfig);
+        break;
+
+      case 'checker':
+        pluginFactoryResult = (factory as TypeCheckerPattern)(program.getTypeChecker(), cleanConfig);
+        break;
+
+      case undefined:
+      case 'program':
+        const { addDiagnostic, removeDiagnostic, diagnostics } = diagnosticExtrasFactory(program);
+
+        pluginFactoryResult = (factory as ProgramPattern)(program, cleanConfig, {
+          ts: tsp.getTsInstance(),
+          addDiagnostic,
+          removeDiagnostic,
+          diagnostics,
+          library: tsp.currentLibrary
+        });
+        break;
+
+      case 'raw':
+        pluginFactoryResult = (ctx: tsShim.TransformationContext) => (factory as RawPattern)(ctx, program, cleanConfig);
+        break;
+
+      default:
+        throw new TsPatchError(`Invalid plugin type found in tsconfig.json: '${config.type}'`);
+    }
+
+    /* Extract factories */
+    let transformerFactories: TsTransformerFactory[];
+    // noinspection FallThroughInSwitchStatementJS
+    switch (typeof pluginFactoryResult) {
+      // Single transformer factory
+      case 'function':
+        transformerFactories = [ pluginFactoryResult ];
+        break;
+      // TransformerBasePlugin
+      case 'object':
+        const factoryOrFactories = pluginFactoryResult[transformerKind];
+
+        // Single transformer factory
+        if (typeof factoryOrFactories === 'function') {
+          transformerFactories = [ pluginFactoryResult[transformerKind] ];
+          break;
+        }
+        // Array of transformer factories
+        else if (Array.isArray(factoryOrFactories)) {
+          transformerFactories = [ ...factoryOrFactories ];
+          break;
+        }
+        // Deliberate fall-through
+      default:
+        throw new TsPatchError(`Invalid plugin result: expected a function or an object with a '${transformerKind}' property`);
+    }
+
+    /* Wrap factories */
+    const wrappedFactories: TsTransformerFactory[] = [];
+    for (const transformerFactory of transformerFactories) {
+      if (!transformerFactory || typeof transformerFactory !== 'function')
+        throw new TsPatchError(
+          `Invalid plugin entry point! Expected a transformer factory function or an object with a '${transformerKind}' property`
+        );
+
+      /* Wrap w/ register */
+      const wrapper = wrapTransformerFactory(transformerFactory, registerConfig, true);
+      wrappedFactories.push(wrapper);
+    }
+
+    const res: TransformerBasePlugin = {
+      [transformerKind]: wrappedFactories
+    };
+
+    return res;
+  }
+
+  function wrapTransformerFactory(
+    transformerFn: TsTransformerFactory,
+    requireConfig: RegisterConfig,
+    wrapInnerFunction: boolean
+  ): TsTransformerFactory {
+    const wrapper: TsTransformerFactory = function tspWrappedFactory(...args: any[]) {
+      let res: any;
+      try {
+        registerPlugin(requireConfig);
+        if (!wrapInnerFunction) {
+          res = (transformerFn as Function)(...args);
+        } else {
+          const resFn = (transformerFn as Function)(...args);
+          if (typeof resFn !== 'function') throw new TsPatchError('Invalid plugin: expected a function');
+          res = wrapTransformerFactory(resFn, requireConfig, false);
+        }
+      }
+      finally {
+        unregisterPlugin();
+      }
+
+      return res;
+    }
+
+    return wrapper;
+  }
+
+  // endregion
+
+  /* ********************************************************* *
+   * PluginCreator (Class)
+   * ********************************************************* */
+
+  export class PluginCreator {
+    public readonly plugins: TspPlugin[] = [];
+    public readonly options: PluginCreator.Options;
+    public readonly needsTscJsDocParsing: boolean;
+
+    private readonly configs: PluginConfig[];
+
+    constructor(configs: PluginConfig[], options: PluginCreator.Options) {
+      this.configs = configs;
+      this.options = options;
+
+      const { resolveBaseDir } = options;
+
+      /* Create plugins */
+      this.plugins = configs
+        .filter(config => config.transform !== undefined)
+        .map(config => new TspPlugin(config, { resolveBaseDir }));
+
+      /* Check if we need to parse all JSDoc comments */
+      this.needsTscJsDocParsing = this.plugins.some(plugin => plugin.packageConfig?.tscOptions?.parseAllJsDoc === true);
+    }
+
+    private mergeTransformers(into: TransformerList, source: tsShim.CustomTransformers | TransformerBasePlugin) {
+      const slice = <T>(input: T | T[]) => (Array.isArray(input) ? input.slice() : [ input ]);
+
+      if (source.before) into.before.push(...slice(source.before));
+      if (source.after) into.after.push(...slice(source.after));
+      if (source.afterDeclarations) into.afterDeclarations.push(...slice(source.afterDeclarations));
+
+      return this;
+    }
+
+    public createSourceTransformers(
+      params: { program: tsShim.Program } | { ls: tsShim.LanguageService },
+      customTransformers?: tsShim.CustomTransformers
+    ): TransformerList {
+      const transformers: TransformerList = { before: [], after: [], afterDeclarations: [] };
+
+      const [ ls, program ] = ('ls' in params) ? [ params.ls, params.ls.getProgram()! ] : [ void 0, params.program ];
+
+      for (const plugin of this.plugins) {
+        if (plugin.kind !== 'SourceTransformer') continue;
+
+        const { config } = plugin;
+
+        const createFactoryResult = plugin.createFactory();
+        if (!createFactoryResult) continue;
+
+        const { factory, registerConfig } = createFactoryResult;
+
+        this.mergeTransformers(
+          transformers,
+          createTransformersFromPattern({
+            factory: factory as PluginFactory,
+            registerConfig,
+            config,
+            program,
+            ls
+          })
+        );
+      }
+
+      // Chain custom transformers at the end
+      if (customTransformers) this.mergeTransformers(transformers, customTransformers);
+
+      return transformers;
+    }
+
+    public createProgramTransformers(): Map<string, [ ProgramTransformer, PluginConfig ]> {
+      const res = new Map<string, [ ProgramTransformer, PluginConfig ]>();
+      for (const plugin of this.plugins) {
+        if (plugin.kind !== 'ProgramTransformer') continue;
+
+        const { config } = plugin;
+
+        const createFactoryResult = plugin.createFactory();
+        if (createFactoryResult === undefined) continue;
+
+        const { registerConfig, factory: unwrappedFactory } = createFactoryResult;
+        const factory = wrapTransformerFactory(unwrappedFactory as ProgramTransformer, registerConfig, false);
+
+        const transformerKey = crypto
+          .createHash('md5')
+          .update(JSON.stringify({ factory, config }))
+          .digest('hex');
+
+        res.set(transformerKey, [ factory, config ]);
+      }
+
+      return res;
+    }
+  }
+}

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

@@ -0,0 +1,193 @@
+namespace tsp {
+  const path = require('path');
+  const fs = require('fs');
+
+  const requireStack: string[] = [];
+
+  /* ****************************************************** */
+  // region: Types
+  /* ****************************************************** */
+
+  export namespace TspPlugin {
+    export interface CreateOptions {
+      resolveBaseDir: string
+    }
+
+    export type Kind = 'SourceTransformer' | 'ProgramTransformer'
+  }
+
+  // endregion
+
+  /* ****************************************************** */
+  // region: Helpers
+  /* ****************************************************** */
+
+  // Could likely fail if the plugin is in a symlinked directory or the package's main file is in a
+  // directory above the package.json – however, I believe that the walking up method used here is the common
+  // approach, so we'll consider these acceptable edge cases for now.
+  function getPackagePath(entryFilePath: string): string | undefined {
+    let currentDir = path.dirname(entryFilePath);
+
+    const seenPaths = new Set<string>();
+    while (currentDir !== path.parse(currentDir).root) {
+      if (seenPaths.has(currentDir)) return undefined;
+      seenPaths.add(currentDir);
+
+      const potentialPkgPath = path.join(currentDir, 'package.json');
+      if (fs.existsSync(potentialPkgPath)) return potentialPkgPath;
+
+      currentDir = path.resolve(currentDir, '..');
+    }
+
+    return undefined;
+  }
+
+  // endregion
+
+  /* ****************************************************** */
+  // region: TspPlugin
+  /* ****************************************************** */
+
+  export class TspPlugin {
+    public readonly config: PluginConfig;
+    public readonly tsConfigPath: string | undefined;
+    public readonly entryFilePath: string;
+    public readonly importKey: string;
+    public readonly packageConfig: PluginPackageConfig | undefined;
+    public readonly kind: TspPlugin.Kind;
+
+    private readonly _createOptions: TspPlugin.CreateOptions;
+
+    constructor(config: PluginConfig, createOptions: TspPlugin.CreateOptions) {
+      this.config = { ...config };
+      this.validateConfig();
+
+      this._createOptions = createOptions;
+      this.importKey = config.import || 'default';
+      this.kind = config.transformProgram === true ? 'ProgramTransformer' : 'SourceTransformer';
+
+      const { resolveBaseDir } = createOptions;
+      const configTransformValue = config.transform!;
+
+      /* Resolve paths */
+      this.tsConfigPath = config.tsConfig && path.resolve(resolveBaseDir, config.tsConfig);
+      const entryFilePath = require.resolve(configTransformValue, { paths: [ resolveBaseDir ] });
+      this.entryFilePath = entryFilePath;
+
+      /* Get module PluginPackageConfig */
+      let pluginPackageConfig: PluginPackageConfig | undefined;
+
+      const modulePackagePath = getPackagePath(entryFilePath);
+      if (modulePackagePath) {
+        const modulePkgJsonContent = fs.readFileSync(modulePackagePath, 'utf8');
+        const modulePkgJson = JSON.parse(modulePkgJsonContent) as { tsp?: PluginPackageConfig };
+
+        pluginPackageConfig = modulePkgJson.tsp;
+        if (pluginPackageConfig === null || typeof pluginPackageConfig !== 'object') pluginPackageConfig = undefined;
+      }
+
+      this.packageConfig = pluginPackageConfig;
+    }
+
+    private validateConfig() {
+      const { config } = this;
+
+      const configTransformValue = config.transform;
+      if (!configTransformValue) throw new TsPatchError(`Invalid plugin config: missing "transform" value`);
+
+      if (config.resolvePathAliases && !config.tsConfig) {
+        console.warn(`[ts-patch] Warning: resolvePathAliases needs a tsConfig value pointing to a tsconfig.json for transformer" ${configTransformValue}.`);
+      }
+    }
+
+    createFactory() {
+      const { entryFilePath, config, tsConfigPath, importKey } = this;
+      const configTransformValue = config.transform!;
+
+      /* Prevent circular require */
+      if (requireStack.includes(entryFilePath)) return;
+      requireStack.push(entryFilePath);
+
+      /* Check if ESM */
+      let isEsm: boolean | undefined = config.isEsm;
+      if (isEsm == null) {
+        const impliedModuleFormat = tsShim.getImpliedNodeFormatForFile(
+          entryFilePath as tsShim.Path,
+          undefined,
+          tsShim.sys,
+          { moduleResolution: tsShim.ModuleResolutionKind.Node16 }
+        );
+
+        isEsm = impliedModuleFormat === tsShim.ModuleKind.ESNext;
+      }
+
+      const isTs = configTransformValue.match(/\.[mc]?ts$/) != null;
+
+      const registerConfig: RegisterConfig = {
+        isTs,
+        isEsm,
+        tsConfig: tsConfigPath,
+        pluginConfig: config
+      };
+
+      registerPlugin(registerConfig);
+
+      try {
+        /* Load plugin */
+        const commonjsModule = loadEntryFile();
+
+        const factoryModule = (typeof commonjsModule === 'function') ? { default: commonjsModule } : commonjsModule;
+        const factory = factoryModule[importKey];
+
+        if (!factory)
+          throw new TsPatchError(
+            `tsconfig.json > plugins: "${configTransformValue}" does not have an export "${importKey}": ` +
+            require('util').inspect(factoryModule)
+          );
+
+        if (typeof factory !== 'function') {
+          throw new TsPatchError(
+            `tsconfig.json > plugins: "${configTransformValue}" export "${importKey}" is not a plugin: ` +
+            require('util').inspect(factory)
+          );
+        }
+
+        return {
+          factory,
+          registerConfig: registerConfig
+        };
+      }
+      finally {
+        requireStack.pop();
+        unregisterPlugin();
+      }
+
+      function loadEntryFile(): PluginFactory | { [key: string]: PluginFactory } {
+        /* Load plugin */
+        let res: PluginFactory | { [key: string]: PluginFactory }
+        try {
+          res = require(entryFilePath);
+        } catch (e) {
+          if (e.code === 'ERR_REQUIRE_ESM') {
+            if (!registerConfig.isEsm) {
+              unregisterPlugin();
+              registerConfig.isEsm = true;
+              registerPlugin(registerConfig);
+              return loadEntryFile();
+            } else {
+              throw new TsPatchError(
+                `Cannot load ESM transformer "${configTransformValue}" from "${entryFilePath}". Please file a bug report`
+              );
+            }
+          }
+          else throw e;
+        }
+        return res;
+      }
+    }
+  }
+
+  // endregion
+}
+
+// endregion

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

@@ -0,0 +1,141 @@
+/// <reference types="node"/>
+
+namespace tsp {
+  const path = require('path');
+
+  let configStack: RegisterConfig[] = [];
+
+  /* ********************************************************* */
+  // region: Types
+  /* ********************************************************* */
+
+  /** @internal */
+  export interface RegisterConfig {
+    tsNodeInstance?: import('ts-node').Service
+    tsConfigPathsCleanup?: () => void
+    esmInterceptCleanup?: () => void
+    isTs: boolean
+    pluginConfig: PluginConfig
+    isEsm: boolean
+    tsConfig: string | undefined
+    compilerOptions?: tsShim.CompilerOptions
+  }
+
+  // endregion
+
+  /* ********************************************************* */
+  // region: Helpers
+  /* ********************************************************* */
+
+  function getTsNode() {
+    try {
+      return require('ts-node') as typeof import('ts-node');
+    } catch (e) {
+      if (e.code === 'MODULE_NOT_FOUND')
+        throw new TsPatchError(
+          `Cannot use a typescript-based transformer without ts-node installed. `+
+          `Add ts-node as a (dev)-dependency or install globally.`
+        );
+      else throw e;
+    }
+  }
+
+  function getTsConfigPaths() {
+    try {
+      return require('tsconfig-paths') as typeof import('tsconfig-paths');
+    } catch (e) {
+      if (e.code === 'MODULE_NOT_FOUND')
+        throw new TsPatchError(
+          `resolvePathAliases requires the library: tsconfig-paths. `+
+          `Add tsconfig-paths as a (dev)-dependency or install globally.`
+        );
+      else throw e;
+    }
+  }
+
+  function getCompilerOptions(tsConfig: string) {
+    const configFile = tsShim.readConfigFile(tsConfig, tsShim.sys.readFile);
+    const parsedConfig = configFile && tsShim.parseJsonConfigFileContent(
+      configFile.config,
+      tsShim.sys,
+      path.dirname(tsConfig)
+    );
+
+    return parsedConfig.options;
+  }
+
+  // endregion
+
+  /* ********************************************************* */
+  // region: Utils
+  /* ********************************************************* */
+
+  export function unregisterPlugin() {
+    const activeRegisterConfig = configStack.pop()!;
+
+    if (activeRegisterConfig.tsConfigPathsCleanup) {
+      activeRegisterConfig.tsConfigPathsCleanup();
+      delete activeRegisterConfig.tsConfigPathsCleanup;
+    }
+
+    if (activeRegisterConfig.tsNodeInstance) {
+      activeRegisterConfig.tsNodeInstance.enabled(false);
+    }
+
+    if (activeRegisterConfig.esmInterceptCleanup) {
+      activeRegisterConfig.esmInterceptCleanup();
+      delete activeRegisterConfig.esmInterceptCleanup;
+    }
+  }
+
+  export function registerPlugin(registerConfig: RegisterConfig) {
+    if (!registerConfig) throw new TsPatchError('requireConfig is required');
+    configStack.push(registerConfig);
+
+    const { isTs, isEsm, tsConfig, pluginConfig } = registerConfig;
+
+    /* Register ESM */
+    if (isEsm) {
+      registerConfig.esmInterceptCleanup = registerEsmIntercept(registerConfig);
+    }
+
+    /* Register tsNode */
+    if (isTs) {
+      const tsNode = getTsNode();
+
+      let tsNodeInstance: import('ts-node').Service;
+      if (registerConfig.tsNodeInstance) {
+        tsNodeInstance = registerConfig.tsNodeInstance;
+        tsNode.register(tsNodeInstance);
+      } else {
+        const tsMajor = parseInt(tsShim.versionMajorMinor);
+        tsNodeInstance = tsNode.register({
+          transpileOnly: true,
+          ...(tsConfig ? { project: tsConfig } : { skipProject: true }),
+          compilerOptions: {
+            target: isEsm ? 'ESNext' : 'ES2018',
+            jsx: 'react',
+            esModuleInterop: true,
+            module: isEsm ? 'ESNext' : 'commonjs',
+            ...(tsMajor >= 6 ? { ignoreDeprecations: '6.0' } : {}),
+          }
+        });
+      }
+
+      tsNodeInstance.enabled(true);
+      registerConfig.tsNodeInstance = tsNodeInstance;
+    }
+
+    /* Register tsconfig-paths */
+    if (tsConfig && pluginConfig.resolvePathAliases) {
+      registerConfig.compilerOptions ??= getCompilerOptions(tsConfig);
+
+      const { paths, baseUrl } = registerConfig.compilerOptions;
+      if (paths && baseUrl) {
+        registerConfig.tsConfigPathsCleanup = getTsConfigPaths().register({ baseUrl, paths });
+      }
+    }
+  }
+
+  // endregion
+}

package/projects/patch/src/shared.ts

@@ -0,0 +1,59 @@
+namespace tsp {
+  const os = require('os');
+  const path = require('path');
+  const fs = require('fs');
+
+  /* ********************************************************* */
+  // region: Vars
+  /* ********************************************************* */
+
+  export const diagnosticMap: tsp.DiagnosticMap = new WeakMap();
+
+  /** Injected during patch — library name minus extension */
+  export declare const currentLibrary: string;
+
+  export const supportedExtensions = [ '.ts', '.mts', '.cts', '.js', '.mjs', '.cjs' ];
+  export const tsExtensions = [ '.ts', '.mts', '.cts' ];
+
+  // endregion
+
+  /* ********************************************************* */
+  // region: Utils
+  /* ********************************************************* */
+
+  /** @internal */
+  export function diagnosticExtrasFactory(program: tsShim.Program) {
+    const diagnostics = diagnosticMap.get(program) || diagnosticMap.set(program, []).get(program)!;
+
+    const addDiagnostic = (diag: tsShim.Diagnostic): number => diagnostics.push(diag);
+    const removeDiagnostic = (index: number) => { diagnostics.splice(index, 1) };
+
+    return { addDiagnostic, removeDiagnostic, diagnostics };
+  }
+
+  /** @internal */
+  export function getTmpDir(subPath?: string) {
+    const tmpDir = path.resolve(os.tmpdir(), 'tsp', subPath);
+    if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
+    return tmpDir;
+  }
+
+  /** @internal */
+  export function getTsInstance() {
+    return (typeof ts !== 'undefined' ? ts : module.exports) as typeof import('typescript');
+  }
+
+  // endregion
+
+  /* ********************************************************* */
+  // region: Other
+  /* ********************************************************* */
+
+  export class TsPatchError extends Error {
+    constructor(message: string, public diagnostic?: tsShim.Diagnostic) {
+      super(message);
+    }
+  }
+
+  // endregion
+}