@sanity/pkg-utils 1.3.1 → 1.5.0

package/dist/_index-5765fada.cjs

@@ -0,0 +1,584 @@
+'use strict';
+
+var chalk = require('chalk');
+var rxjs = require('rxjs');
+var path = require('path');
+var util = require('util');
+var rimrafCallback = require('rimraf');
+var ts = require('typescript');
+var fs = require('fs/promises');
+var apiExtractor = require('@microsoft/api-extractor');
+var mkdirp = require('mkdirp');
+var prettier = require('prettier');
+var tsdocConfig = require('@microsoft/tsdoc-config');
+var jsoncParser = require('jsonc-parser');
+var rollup = require('rollup');
+var alias = require('@rollup/plugin-alias');
+var commonjs = require('@rollup/plugin-commonjs');
+var json = require('@rollup/plugin-json');
+var pluginNodeResolve = require('@rollup/plugin-node-resolve');
+var replace = require('@rollup/plugin-replace');
+var esbuild = require('rollup-plugin-esbuild');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var rimrafCallback__default = /*#__PURE__*/_interopDefaultLegacy(rimrafCallback);
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var mkdirp__default = /*#__PURE__*/_interopDefaultLegacy(mkdirp);
+var prettier__default = /*#__PURE__*/_interopDefaultLegacy(prettier);
+var alias__default = /*#__PURE__*/_interopDefaultLegacy(alias);
+var commonjs__default = /*#__PURE__*/_interopDefaultLegacy(commonjs);
+var json__default = /*#__PURE__*/_interopDefaultLegacy(json);
+var replace__default = /*#__PURE__*/_interopDefaultLegacy(replace);
+var esbuild__default = /*#__PURE__*/_interopDefaultLegacy(esbuild);
+
+function _printExtractMessages(ctx, messages) {
+  const { cwd, logger } = ctx;
+  const warnings = messages.filter((msg) => msg.logLevel === "warning");
+  if (warnings.length) {
+    logger.log();
+  }
+  for (const msg of warnings) {
+    const sourceFilePath = msg.sourceFilePath && path__default["default"].relative(cwd, msg.sourceFilePath);
+    if (msg.messageId === "TS6307") {
+      continue;
+    }
+    logger.log(
+      [
+        `${chalk__default["default"].cyan(sourceFilePath || "?")}`,
+        `:${chalk__default["default"].yellow(msg.sourceFileLine)}:${chalk__default["default"].yellow(msg.sourceFileColumn)}`,
+        ` - ${chalk__default["default"].yellow("warning")} ${chalk__default["default"].gray(msg.messageId)}
+`,
+        msg.text,
+        "\n"
+      ].join("")
+    );
+  }
+  const errors = messages.filter((msg) => msg.logLevel === "error");
+  if (!warnings.length && errors.length) {
+    logger.log("");
+  }
+  for (const msg of errors) {
+    const sourceFilePath = msg.sourceFilePath && path__default["default"].relative(cwd, msg.sourceFilePath);
+    logger.log(
+      [
+        `${chalk__default["default"].cyan(sourceFilePath || "?")}`,
+        `:${chalk__default["default"].yellow(msg.sourceFileLine)}:${chalk__default["default"].yellow(msg.sourceFileColumn)}`,
+        ` - ${chalk__default["default"].red("error")} ${chalk__default["default"].gray(msg.messageId)}
+`,
+        msg.text,
+        "\n"
+      ].join("")
+    );
+  }
+  if (errors.length) {
+    process.exit(1);
+  }
+}
+
+const formatHost = {
+  getCurrentDirectory: () => ts__default["default"].sys.getCurrentDirectory(),
+  getNewLine: () => ts__default["default"].sys.newLine,
+  getCanonicalFileName: ts__default["default"].sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+};
+async function _buildTypes(options) {
+  const { cwd, outDir, sourcePath, tsconfig } = options;
+  const compilerOptions = {
+    ...tsconfig.options,
+    declaration: true,
+    declarationDir: outDir,
+    emitDeclarationOnly: true,
+    noEmit: false,
+    outDir
+  };
+  const rootDir = path__default["default"].relative(
+    cwd,
+    compilerOptions.rootDir ? path__default["default"].resolve(cwd, compilerOptions.rootDir) : path__default["default"].dirname(path__default["default"].resolve(cwd, sourcePath))
+  ) || ".";
+  const program = ts__default["default"].createProgram(tsconfig.fileNames, compilerOptions);
+  const sourceFiles = program.getSourceFiles();
+  const sourceFile = sourceFiles.find((f) => f.fileName === path__default["default"].resolve(cwd, sourcePath));
+  if (!sourceFile) {
+    throw new Error(`source file not found: ${sourcePath}`);
+  }
+  const emitResult = program.emit();
+  const allDiagnostics = ts__default["default"].getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  allDiagnostics.forEach((diagnostic) => {
+    if (diagnostic.file && diagnostic.start) {
+      const { line, character } = ts__default["default"].getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = ts__default["default"].flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      console.log(`${diagnostic.file.fileName} ${line + 1}:${character + 1}
+${message}`);
+    } else {
+      console.log(ts__default["default"].flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+  if (emitResult.emitSkipped) {
+    const errors = allDiagnostics.filter((diag) => diag.category === ts__default["default"].DiagnosticCategory.Error);
+    if (errors.length) {
+      console.error(ts__default["default"].formatDiagnostics(errors, formatHost));
+      throw new Error("failed to compile");
+    }
+  }
+  const typesPath = path__default["default"].resolve(outDir, path__default["default"].relative(rootDir, path__default["default"].resolve(cwd, sourcePath))).replace(/\.[jt]sx?$/, ".d.ts");
+  return { path: typesPath };
+}
+
+class _DtsError extends Error {
+  constructor(message, messages) {
+    super(message);
+    this.messages = messages;
+  }
+}
+
+function _createApiExtractorConfig(options) {
+  const { distPath, exportPath, filePath, messages, projectPath, sourcePath, tsconfigPath } = options;
+  return {
+    apiReport: {
+      enabled: false,
+      reportFileName: "<unscopedPackageName>.api.md"
+    },
+    compiler: {
+      tsconfigFilePath: tsconfigPath
+    },
+    docModel: {
+      enabled: false,
+      apiJsonFilePath: path__default["default"].resolve(distPath, `${exportPath}.api.json`)
+    },
+    dtsRollup: {
+      enabled: true,
+      untrimmedFilePath: path__default["default"].resolve(distPath, filePath)
+    },
+    tsdocMetadata: {
+      enabled: false
+    },
+    messages,
+    mainEntryPointFilePath: sourcePath,
+    projectFolder: projectPath
+  };
+}
+
+async function _createTSDocConfig(opts) {
+  const { customTags } = opts;
+  if (customTags.length === 0) {
+    return void 0;
+  }
+  const tsDocBaseBuf = await fs.readFile(
+    require.resolve("@microsoft/api-extractor/extends/tsdoc-base.json")
+  );
+  const tsDocBaseConfig = jsoncParser.parse(tsDocBaseBuf.toString());
+  const tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(
+    customTags.map((t) => ({
+      tagName: `@${t.name}`,
+      syntaxKind: t.syntaxKind,
+      allowMultiple: t.allowMultiple
+    }))
+  );
+  const supportForTags = { ...tsDocBaseConfig.supportForTags };
+  for (const customTag of customTags) {
+    supportForTags[`@${customTag.name}`] = true;
+  }
+  return tsdocConfig.TSDocConfigFile.loadFromObject({
+    ...tsDocBaseConfig,
+    noStandardTags: false,
+    tagDefinitions,
+    supportForTags
+  });
+}
+
+const _LOG_LEVELS = {
+  error: "error",
+  info: "info",
+  off: "none",
+  warn: "warning"
+};
+async function _extractTypes(options) {
+  const { distPath, exportPath, files, filePath, projectPath, rules, sourcePath, tsconfigPath } = options;
+  const tsdocConfigFile = await _createTSDocConfig({
+    customTags: []
+  });
+  function _ruleToLogLevel(key, defaultLevel) {
+    const r = rules == null ? void 0 : rules[key];
+    return r ? _LOG_LEVELS[r] : defaultLevel || "warning";
+  }
+  const messagesConfig = {
+    compilerMessageReporting: {
+      default: {
+        logLevel: "warning"
+      }
+    },
+    extractorMessageReporting: {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: false
+      },
+      "ae-forgotten-export": {
+        logLevel: _ruleToLogLevel("ae-forgotten-export", "error"),
+        addToApiReportFile: false
+      },
+      "ae-incompatible-release-tags": {
+        logLevel: _ruleToLogLevel("ae-incompatible-release-tags", "error"),
+        addToApiReportFile: false
+      },
+      "ae-internal-missing-underscore": {
+        logLevel: _ruleToLogLevel("ae-internal-missing-underscore"),
+        addToApiReportFile: false
+      },
+      "ae-missing-release-tag": {
+        logLevel: _ruleToLogLevel("ae-missing-release-tag", "error"),
+        addToApiReportFile: false
+      },
+      "ae-wrong-input-file-type": {
+        logLevel: "none",
+        addToApiReportFile: false
+      }
+    },
+    tsdocMessageReporting: {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: false
+      }
+    }
+  };
+  const extractorConfig = apiExtractor.ExtractorConfig.prepare({
+    configObject: _createApiExtractorConfig({
+      distPath,
+      exportPath,
+      filePath,
+      messages: messagesConfig,
+      projectPath,
+      sourcePath,
+      tsconfigPath
+    }),
+    configObjectFullPath: void 0,
+    tsdocConfigFile,
+    packageJsonFullPath: path__default["default"].resolve(projectPath, "package.json")
+  });
+  const messages = [];
+  const extractorResult = apiExtractor.Extractor.invoke(extractorConfig, {
+    localBuild: true,
+    showVerboseMessages: true,
+    messageCallback(message) {
+      messages.push(message);
+      message.handled = true;
+    }
+  });
+  const typesPath = path__default["default"].resolve(distPath, filePath);
+  const typesBuf = await fs__default["default"].readFile(typesPath);
+  const prettierConfig = await prettier__default["default"].resolveConfig(typesPath);
+  await mkdirp__default["default"](path__default["default"].dirname(typesPath));
+  await fs__default["default"].writeFile(
+    typesPath,
+    prettier__default["default"].format(typesBuf.toString(), {
+      ...prettierConfig,
+      filepath: typesPath
+    })
+  );
+  files.push({
+    type: "types",
+    path: typesPath
+  });
+  return { extractorResult, messages };
+}
+
+const rimraf = util.promisify(rimrafCallback__default["default"]);
+async function _doExtract(ctx, task) {
+  var _a;
+  const { config, cwd, dist, files, ts } = ctx;
+  if (!ts.config || !ts.configPath)
+    return { type: "dts", messages: [] };
+  const sourcePath = task.sourcePath;
+  const exportPath = task.exportPath === "." ? "./index" : task.exportPath;
+  const distPath = path__default["default"].resolve(cwd, dist);
+  const filePath = path__default["default"].relative(distPath, path__default["default"].resolve(cwd, task.targetPath));
+  const tmpDirPath = path__default["default"].resolve(distPath, "__dts__");
+  const tmpDir = {
+    path: tmpDirPath,
+    removeCallback: () => rimraf(tmpDirPath)
+  };
+  const types = await _buildTypes({
+    cwd,
+    outDir: tmpDir.path,
+    sourcePath,
+    tsconfig: ts.config
+  });
+  const { messages } = await _extractTypes({
+    cwd,
+    exportPath,
+    files,
+    filePath,
+    projectPath: cwd,
+    rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
+    sourcePath: types.path,
+    tsconfigPath: path__default["default"].resolve(cwd, ts.configPath),
+    distPath
+  });
+  await tmpDir.removeCallback();
+  if (messages.some((msg) => msg.logLevel === "error")) {
+    throw new _DtsError("encountered errors when extracting types", messages);
+  }
+  return { type: "dts", messages };
+}
+
+const _dtsTask = {
+  name: (_ctx, task) => [
+    `build type definitions`,
+    `       ${chalk__default["default"].blue(task.importId)}: ${task.sourcePath} -> ${task.targetPath}`
+  ].join("\n"),
+  exec: (ctx, task) => {
+    return new rxjs.Observable((observer) => {
+      _doExtract(ctx, task).then((result) => {
+        observer.next(result);
+        observer.complete();
+      }).catch((err) => {
+        observer.error(err);
+      });
+    });
+  },
+  complete: (ctx, _task, result) => {
+    _printExtractMessages(ctx, result.messages);
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    if (err instanceof _DtsError) {
+      _printExtractMessages(ctx, err.messages);
+    } else if (err instanceof Error) {
+      logger.error(err);
+    }
+  }
+};
+
+const _dtsWatchTask = {
+  name: (_ctx, task) => [
+    `build type definitions`,
+    `       ${chalk__default["default"].blue(task.importId)}: ${task.sourcePath} -> ${task.targetPath}`
+  ].join("\n"),
+  exec: (ctx, task) => {
+    return new rxjs.Observable((observer) => {
+      _doExtract(ctx, task).then((result) => {
+        observer.next(result);
+        observer.complete();
+      }).catch((err) => observer.error(err));
+    });
+  },
+  complete: (ctx, _task, result) => {
+    const { logger } = ctx;
+    _printExtractMessages(ctx, result.messages);
+    logger.warn("watching typescript definitions is currently not supported");
+    logger.log();
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    if (err instanceof _DtsError) {
+      _printExtractMessages(ctx, err.messages);
+    } else if (err instanceof Error) {
+      logger.error(err);
+    }
+  }
+};
+
+function _resolveRollupConfig(ctx, buildTask) {
+  var _a;
+  const { format, runtime, target } = buildTask;
+  const { config, cwd, external, dist: outDir, pkg, ts } = ctx;
+  const outputExt = format === "commonjs" ? ".cjs" : pkg.type === "module" ? ".mjs" : ".js";
+  const pathAliases = Object.fromEntries(
+    Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(([key, val]) => {
+      var _a2;
+      return [key, path__default["default"].resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
+    })
+  );
+  const entries = buildTask.entries.map((entry) => {
+    return {
+      ...entry,
+      name: path__default["default"].relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+    };
+  }, {});
+  return {
+    inputOptions: {
+      context: cwd,
+      external: (id) => {
+        const idParts = id.split("/");
+        const name = idParts[0].startsWith("@") ? `${idParts[0]}/${idParts[1]}` : idParts[0];
+        if (name && external.includes(name)) {
+          return true;
+        }
+        return false;
+      },
+      input: entries.reduce((acc, entry) => {
+        return { ...acc, [entry.name]: entry.source };
+      }, {}),
+      onwarn(warning, rollupWarn) {
+        if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
+          rollupWarn(warning);
+        }
+      },
+      plugins: [
+        replace__default["default"]({
+          preventAssignment: true,
+          values: {
+            ...pkg.name === "@sanity/pkg-utils" ? {} : {
+              "process.env.PKG_FILE_PATH": (arg) => {
+                const sourcePath = "./" + path__default["default"].relative(cwd, arg);
+                const entry = entries.find((e) => e.source === sourcePath);
+                if (!entry) {
+                  throw new Error(`could not find source entry: ${sourcePath}`);
+                }
+                return JSON.stringify(
+                  path__default["default"].relative(cwd, path__default["default"].resolve(outDir, entry.name + outputExt))
+                );
+              },
+              "process.env.PKG_FORMAT": JSON.stringify(format),
+              "process.env.PKG_RUNTIME": JSON.stringify(runtime),
+              "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version)
+            }
+          }
+        }),
+        alias__default["default"]({
+          entries: { ...pathAliases }
+        }),
+        pluginNodeResolve.nodeResolve({
+          browser: runtime === "browser",
+          extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
+          preferBuiltins: true
+        }),
+        commonjs__default["default"]({
+          esmExternals: false,
+          extensions: [".js"]
+        }),
+        json__default["default"](),
+        esbuild__default["default"]({
+          minify: (config == null ? void 0 : config.minify) ?? true,
+          jsx: "transform",
+          jsxFactory: "React.createElement",
+          jsxFragment: "React.Fragment",
+          target,
+          tsconfig: ctx.ts.configPath || "tsconfig.json"
+        })
+      ],
+      treeshake: {
+        propertyReadSideEffects: false
+      }
+    },
+    outputOptions: {
+      chunkFileNames: () => `_[name]-[hash]${outputExt}`,
+      dir: outDir,
+      entryFileNames: () => `[name]${outputExt}`,
+      format,
+      exports: "auto",
+      sourcemap: (config == null ? void 0 : config.sourcemap) ?? true
+    }
+  };
+}
+
+const _rollupTask = {
+  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk__default["default"].blue(path__default["default"].join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join("\n       ")}`,
+  exec: (ctx, task) => {
+    return new rxjs.Observable((observer) => {
+      _execPromise(ctx, task).then((result) => {
+        observer.next(result);
+        observer.complete();
+      }).catch((err) => observer.error(err));
+    });
+  },
+  complete: () => {
+  },
+  error: (_ctx, _task, err) => {
+    if (err instanceof Error) {
+      console.log(err);
+    }
+  }
+};
+async function _execPromise(ctx, task) {
+  const { files, dist: outDir } = ctx;
+  const { inputOptions, outputOptions } = _resolveRollupConfig(ctx, task);
+  const bundle = await rollup.rollup(inputOptions);
+  const { output } = await bundle.generate(outputOptions);
+  for (const chunkOrAsset of output) {
+    if (chunkOrAsset.type === "asset") {
+      files.push({
+        type: "asset",
+        path: path__default["default"].resolve(outDir, chunkOrAsset.fileName)
+      });
+    } else {
+      files.push({
+        type: "chunk",
+        path: path__default["default"].resolve(outDir, chunkOrAsset.fileName)
+      });
+    }
+  }
+  await bundle.write(outputOptions);
+  await bundle.close();
+}
+
+const _rollupWatchTask = {
+  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk__default["default"].blue(path__default["default"].join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join("\n       ")}`,
+  exec: (ctx, task) => {
+    const { inputOptions, outputOptions } = _resolveRollupConfig(ctx, task);
+    return new rxjs.Observable((observer) => {
+      const watchOptions = {
+        ...inputOptions,
+        output: outputOptions
+      };
+      const watcher = rollup.watch(watchOptions);
+      watcher.on("event", (event) => {
+        observer.next(event);
+      });
+      return () => {
+        watcher.close();
+      };
+    });
+  },
+  complete: (ctx, task, event) => {
+    const { logger } = ctx;
+    if (event.code === "BUNDLE_END") {
+      logger.success(
+        `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk__default["default"].blue(path__default["default"].join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join("\n       ")}`
+      );
+      logger.log("");
+      return;
+    }
+    if (event.code === "BUNDLE_START") {
+      return;
+    }
+    if (event.code === "END") {
+      return;
+    }
+    if (event.code === "ERROR") {
+      logger.error(event.code, event);
+      return;
+    }
+    if (event.code === "START") {
+      return;
+    }
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    if (err instanceof Error) {
+      logger.log(err);
+    }
+  }
+};
+
+const _buildTaskHandlers = {
+  "build:dts": _dtsTask,
+  "build:js": _rollupTask
+};
+const _watchTaskHandlers = {
+  "watch:dts": _dtsWatchTask,
+  "watch:js": _rollupWatchTask
+};
+
+exports._buildTaskHandlers = _buildTaskHandlers;
+exports._dtsTask = _dtsTask;
+exports._dtsWatchTask = _dtsWatchTask;
+exports._rollupTask = _rollupTask;
+exports._rollupWatchTask = _rollupWatchTask;
+exports._watchTaskHandlers = _watchTaskHandlers;
+//# sourceMappingURL=_index-5765fada.cjs.map