unbag/dist/esm/commands/transform/action/tasks/dts.mjs

一个专门用来开发npm工具的包

import ts from "typescript";
import { defineTransformActionTask, TransformActionTaskOutFileType } from "../index.mjs";
import { mergeConfig } from "./../../../../utils/config.mjs";
import { useRoot } from "./../../../../utils/common.mjs";
import _ from "lodash";
import { RelativePath, usePath } from "./../../../../utils/path.mjs";
import { useTransformTempDir } from "../../utils.mjs";
import { useLog } from "./../../../../utils/log.mjs";
const TransformActionTaskDtsOptionsDefault = {
  supportExtensions: {
    ".ts": true,
    ".tsx": true,
    ".d.ts": true,
    ".js": true,
    ".jsx": true,
    ".cts": true,
    ".d.cts": true,
    ".cjs": true,
    ".mts": true,
    ".d.mts": true,
    ".mjs": true
  },
  configFilePath: "tsconfig.json"
};
const useCompilerOptions = params => {
  const {
    taskOptions,
    finalUserConfig
  } = params;
  const root = useRoot({
    finalUserConfig
  });
  const {
    configFilePath,
    compilerOptions: compilerOptionsOverrides
  } = taskOptions;
  const finalConfigFilePath = root.resolve({
    next: configFilePath
  });
  let compilerOptionsFromFile = void 0;
  const {
    config
  } = ts.readConfigFile(finalConfigFilePath.content, ts.sys.readFile);
  if (config.compilerOptions) {
    const {
      options
    } = ts.convertCompilerOptionsFromJson(config?.compilerOptions, root.content, finalConfigFilePath.content);
    compilerOptionsFromFile = options;
  }
  const finalCompilerOptions = _.merge({}, compilerOptionsFromFile, compilerOptionsOverrides);
  return finalCompilerOptions;
};
const TransformActionTaskDts = options => {
  const finalOptions = mergeConfig(TransformActionTaskDtsOptionsDefault, options);
  const {
    supportExtensions,
    noLogDiagnosticErrors,
    logFilePathRewrite
  } = finalOptions;
  return defineTransformActionTask(async params => {
    const {
      finalUserConfig,
      inputDir,
      filePaths,
      tempDir
    } = params;
    const matchedFiles = filePaths.filter(e => {
      return supportExtensions[e.extname];
    }).map(e => {
      return inputDir.resolve({
        next: e.content
      });
    });
    const transformTempDir = useTransformTempDir({
      finalUserConfig
    });
    const compilerOptions = useCompilerOptions({
      finalUserConfig,
      taskOptions: finalOptions
    });
    const path = usePath();
    const log = useLog({
      finalUserConfig
    });
    const outDir = transformTempDir.resolve({
      next: "./transform-action-task-dts"
    });
    const finalCompilerOptions = {
      ...compilerOptions,
      emitDeclarationOnly: true,
      declaration: true,
      composite: false,
      noEmit: false,
      outDir: outDir.content
    };
    const program = ts.createProgram(matchedFiles.map(e => e.content), finalCompilerOptions);
    const dtsFiles = [];
    const emitResult = program.emit(void 0, (fileName, text) => {
      const filePath = new RelativePath({
        content: path.relative(outDir.content, fileName)
      });
      dtsFiles.push({
        path: filePath,
        content: text
      });
    });
    if (!noLogDiagnosticErrors) {
      const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
      allDiagnostics.forEach(diagnostic => {
        if (diagnostic.file) {
          let {
            line,
            character
          } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
          let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
          const fileName = logFilePathRewrite ? logFilePathRewrite({
            filePath: diagnostic.file.fileName,
            inputDir,
            tempDir,
            finalUserConfig
          }) : diagnostic.file.fileName;
          log.error(`${fileName} (${line + 1},${character + 1}): ${message}`);
        } else {
          log.error(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
        }
      });
    }
    const result = dtsFiles.map(dtsFile => {
      return {
        type: TransformActionTaskOutFileType.Transformed,
        to: dtsFile.path,
        content: dtsFile.content
      };
    });
    return result;
  });
};
export { TransformActionTaskDts, TransformActionTaskDtsOptionsDefault, useCompilerOptions };