@sanity/pkg-utils 7.2.9-canary.0 → 7.2.10-canary.0

package/dist/index.js

@@ -12,7 +12,7 @@ import browserslist from "browserslist";
 import config$1 from "@sanity/browserslist-config";
 import ts from "typescript";
 import { errorMap } from "zod-validation-error";
-import { Observable, switchMap } from "rxjs";
+import { Observable, from, switchMap } from "rxjs";
 import { ExtractorConfig, Extractor } from "@microsoft/api-extractor";
 import { mkdirp } from "mkdirp";
 import * as prettier from "prettier";
@@ -21,16 +21,18 @@ import { TSDocConfigFile } from "@microsoft/tsdoc-config";
 import { parse } from "jsonc-parser";
 import { parse as parse$1, print } from "recast";
 import typeScriptParser from "recast/parsers/typescript.js";
-import { rollup, watch as watch$1 } from "rollup";
+import { rolldown } from "rolldown";
 import { optimizeLodashImports } from "@optimize-lodash/rollup-plugin";
 import alias from "@rollup/plugin-alias";
-import { babel, getBabelOutputPlugin } from "@rollup/plugin-babel";
+import { getBabelOutputPlugin, babel } from "@rollup/plugin-babel";
 import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
-import replace from "@rollup/plugin-replace";
 import terser from "@rollup/plugin-terser";
+import { dts } from "rolldown-plugin-dts";
 import esbuild from "rollup-plugin-esbuild";
+import { rollup, watch as watch$1 } from "rollup";
+import replace from "@rollup/plugin-replace";
 import esbuild$1 from "esbuild";
 import treeify from "treeify";
 import prettyBytes from "pretty-bytes";
@@ -555,7 +557,8 @@ async function resolveBuildContext(options) {
     ts: {
       config: tsconfig,
       configPath: tsconfigPath
-    }
+    },
+    dts: config2?.dts === "rolldown" ? "rolldown" : "api-extractor"
   };
 }
 function transformPackageName(packageName) {
@@ -573,95 +576,102 @@ function resolveBuildTasks(ctx) {
   ), dtsTask2 = {
     type: "build:dts",
     entries: []
-  }, rollupTasks = {};
+  }, rolldownDtsTask2 = {}, rollupTasks = {};
   function addRollupTaskEntry(format2, runtime, entry) {
     const buildId = `${format2}:${runtime}`;
-    rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+    ctx.dts === "rolldown" && (rolldownDtsTask2[buildId] ? rolldownDtsTask2[buildId].entries.push(entry) : rolldownDtsTask2[buildId] = {
+      type: "rolldown:dts",
+      buildId,
+      entries: [entry],
+      runtime,
+      format: format2,
+      target: target[runtime]
+    }), ctx.emitDeclarationOnly || (rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
       type: "build:js",
       buildId,
       entries: [entry],
       runtime,
       format: format2,
       target: target[runtime]
-    };
-  }
-  for (const exp of exports) {
-    const importId = path.join(pkg.name, exp._path);
-    exp.source?.endsWith(".ts") && dtsTask2.entries.push({
-      importId,
-      exportPath: exp._path,
-      sourcePath: exp.source,
-      targetPaths: getTargetPaths(pkg.type, exp)
-    }), exp.browser?.source?.endsWith(".ts") && dtsTask2.entries.push({
-      importId,
-      exportPath: exp._path,
-      sourcePath: exp.browser.source,
-      targetPaths: getTargetPaths(pkg.type, exp.browser)
-    }), exp.node?.source?.endsWith(".ts") && dtsTask2.entries.push({
-      importId,
-      exportPath: exp._path,
-      sourcePath: exp.node.source,
-      targetPaths: getTargetPaths(pkg.type, exp.node)
     });
   }
-  for (const bundle of bundles)
-    if (bundle.source?.endsWith(".ts")) {
-      const exportPath = (bundle.import || bundle.require).replace(/\.[mc]?js$/, ""), importId = path.join(pkg.name, exportPath);
-      dtsTask2.entries.push({
-        importId,
-        exportPath,
-        sourcePath: bundle.source,
-        targetPaths: getTargetPaths(pkg.type, bundle)
-      });
-    }
-  if (dtsTask2.entries.length && tasks.push(dtsTask2), !ctx.emitDeclarationOnly) {
-    for (const exp of exports) {
-      const output = exp.require;
-      output && addRollupTaskEntry("commonjs", ctx.runtime, {
-        path: exp._path,
-        source: exp.source,
-        output
-      });
-    }
-    for (const exp of exports) {
-      const output = exp.import;
-      output && addRollupTaskEntry("esm", ctx.runtime, {
-        path: exp._path,
-        source: exp.source,
-        output
-      });
-    }
-    for (const exp of exports) {
-      const output = exp.browser?.require;
-      output && addRollupTaskEntry("commonjs", "browser", {
-        path: exp._path,
-        source: exp.browser?.source || exp.source,
-        output
-      });
-    }
+  if (ctx.dts === "api-extractor") {
     for (const exp of exports) {
-      const output = exp.browser?.import;
-      output && addRollupTaskEntry("esm", "browser", {
-        path: exp._path,
-        source: exp.browser?.source || exp.source,
-        output
-      });
-    }
-    for (const bundle of bundles) {
-      const idx = bundles.indexOf(bundle);
-      bundle.require && addRollupTaskEntry("commonjs", bundle.runtime || ctx.runtime, {
-        path: `__$$bundle_cjs_${idx}$$__`,
-        source: bundle.source,
-        output: bundle.require
-      }), bundle.import && addRollupTaskEntry("esm", bundle.runtime || ctx.runtime, {
-        path: `__$$bundle_esm_${idx}$$__`,
-        source: bundle.source,
-        output: bundle.import
+      const importId = path.join(pkg.name, exp._path);
+      exp.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPaths: getTargetPaths(pkg.type, exp)
+      }), exp.browser?.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.browser.source,
+        targetPaths: getTargetPaths(pkg.type, exp.browser)
+      }), exp.node?.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.node.source,
+        targetPaths: getTargetPaths(pkg.type, exp.node)
       });
     }
-    tasks.push(...Object.values(rollupTasks));
+    for (const bundle of bundles)
+      if (bundle.source?.endsWith(".ts")) {
+        const exportPath = (bundle.import || bundle.require).replace(/\.[mc]?js$/, ""), importId = path.join(pkg.name, exportPath);
+        dtsTask2.entries.push({
+          importId,
+          exportPath,
+          sourcePath: bundle.source,
+          targetPaths: getTargetPaths(pkg.type, bundle)
+        });
+      }
+    dtsTask2.entries.length && tasks.push(dtsTask2);
+  }
+  for (const exp of exports) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
   }
-  return tasks;
+  for (const exp of exports) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    const output = exp.browser?.import;
+    output && addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const bundle of bundles) {
+    const idx = bundles.indexOf(bundle);
+    bundle.require && addRollupTaskEntry("commonjs", bundle.runtime || ctx.runtime, {
+      path: `__$$bundle_cjs_${idx}$$__`,
+      source: bundle.source,
+      output: bundle.require
+    }), bundle.import && addRollupTaskEntry("esm", bundle.runtime || ctx.runtime, {
+      path: `__$$bundle_esm_${idx}$$__`,
+      source: bundle.source,
+      output: bundle.import
+    });
+  }
+  return tasks.push(...Object.values(rolldownDtsTask2)), tasks.push(...Object.values(rollupTasks)), tasks;
 }
 function createSpinner(msg) {
   const startTime = Date.now();
@@ -753,7 +763,8 @@ function createApiExtractorConfig(options) {
     projectFolder,
     mainEntryPointFilePath,
     tsconfig,
-    tsconfigPath
+    tsconfigPath,
+    dtsRollupEnabled
   } = options;
   return {
     apiReport: {
@@ -776,7 +787,7 @@ function createApiExtractorConfig(options) {
       apiJsonFilePath: path.resolve(distPath, `${exportPath}.api.json`)
     },
     dtsRollup: {
-      enabled: !0,
+      enabled: dtsRollupEnabled,
       untrimmedFilePath: path.resolve(distPath, filePath)
       // betaTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-beta.d.ts')),
       // publicTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-public.d.ts')),
@@ -832,7 +843,7 @@ const LOG_LEVELS = {
   warn: "warning"
 };
 function getExtractMessagesConfig(options) {
-  const { rules } = options;
+  const { rules, disabled = !1 } = options;
   function ruleToLogLevel(key, defaultLevel) {
     const r = rules?.[key];
     return r ? LOG_LEVELS[r] : defaultLevel || "warning";
@@ -840,10 +851,15 @@ function getExtractMessagesConfig(options) {
   return {
     compilerMessageReporting: {
       default: {
-        logLevel: "warning"
+        logLevel: disabled ? "none" : "warning"
       }
     },
-    extractorMessageReporting: {
+    extractorMessageReporting: disabled ? {
+      default: {
+        logLevel: "none",
+        addToApiReportFile: !1
+      }
+    } : {
       default: {
         logLevel: "warning",
         addToApiReportFile: !1
@@ -873,13 +889,21 @@ function getExtractMessagesConfig(options) {
         addToApiReportFile: !1
       }
     },
-    tsdocMessageReporting: {
+    tsdocMessageReporting: disabled ? {
+      default: {
+        logLevel: "none",
+        addToApiReportFile: !1
+      }
+    } : {
       default: {
         logLevel: "warning",
         addToApiReportFile: !1
       },
       "tsdoc-link-tag-unescaped-text": {
-        logLevel: ruleToLogLevel("tsdoc-link-tag-unescaped-text", "warning"),
+        logLevel: ruleToLogLevel(
+          "tsdoc-link-tag-unescaped-text",
+          "warning"
+        ),
         addToApiReportFile: !1
       },
       "tsdoc-undefined-tag": {
@@ -906,7 +930,8 @@ async function extractTypes(options) {
     sourceTypesPath,
     tmpPath,
     tsconfig,
-    tsconfigPath
+    tsconfigPath,
+    extractorDisabled
   } = options, tsdocConfigFile = await createTSDocConfig({
     customTags: customTags || []
   }), filePath = filePaths[0].replace(/\.d\.[mc]ts$/, ".d.ts"), shouldCleanUpDts = !filePaths.includes(filePath), extractorConfig = ExtractorConfig.prepare({
@@ -915,11 +940,12 @@ async function extractTypes(options) {
       distPath,
       exportPath,
       filePath,
-      messages: getExtractMessagesConfig({ rules }),
+      messages: getExtractMessagesConfig({ rules, disabled: extractorDisabled }),
       projectFolder: projectPath,
       mainEntryPointFilePath: sourceTypesPath,
       tsconfig,
-      tsconfigPath
+      tsconfigPath,
+      dtsRollupEnabled: !0
     }),
     configObjectFullPath: void 0,
     tsdocConfigFile,
@@ -979,7 +1005,8 @@ async function doExtract(ctx, task) {
       sourceTypesPath,
       tsconfig: ts2.config,
       tmpPath,
-      tsconfigPath: path.resolve(cwd, ts2.configPath || "tsconfig.json")
+      tsconfigPath: path.resolve(cwd, ts2.configPath || "tsconfig.json"),
+      extractorDisabled: config2?.extract?.enabled === !1
     });
     messages.push(...result.messages);
     const errors = result.messages.filter((msg) => msg.logLevel === "error");
@@ -990,8 +1017,8 @@ async function doExtract(ctx, task) {
   return await rimraf$1(tmpPath), { type: "dts", messages, results };
 }
 const dtsTask = {
-  name: (_ctx, task) => [
-    "Build type definitions...",
+  name: (ctx, task) => [
+    `Build type definitions with ${chalk.bold(ctx.dts)}...`,
     "  entries:",
     ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
       `    - ${chalk.cyan(entry.importId)}: `,
@@ -1089,7 +1116,8 @@ const dtsTask = {
               sourceTypesPath,
               tsconfig: tsContext.config,
               tmpPath,
-              tsconfigPath: path.resolve(cwd, tsContext.configPath || "tsconfig.json")
+              tsconfigPath: path.resolve(cwd, tsContext.configPath || "tsconfig.json"),
+              extractorDisabled: config2?.extract?.enabled === !1
             });
             messages.push(...result.messages), results.push({ sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
           } catch (err) {
@@ -1137,6 +1165,174 @@ function createConsoleSpy(options) {
     }
   };
 }
+function resolveRolldownConfig(ctx, buildTask) {
+  const { format: format2, runtime, target } = buildTask, { config: config2, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = pkgExtMap[pkg.type || "commonjs"][format2], minify = config2?.minify ?? !1, outDir = path.relative(cwd, distPath), pathAliases = Object.fromEntries(
+    Object.entries(ts2.config?.options.paths || {}).map(([key, val]) => [key, path.resolve(cwd, ts2.config?.options.baseUrl || ".", val[0])])
+  ), entries = buildTask.entries.map((entry) => ({
+    ...entry,
+    name: path.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+  }), {}), exportIds = _exports && Object.keys(_exports).map((exportPath) => path.join(pkg.name, exportPath)), sourcePaths = _exports && Object.values(_exports).map((e) => path.resolve(cwd, e.source)), replacements = Object.fromEntries(
+    Object.entries(config2?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
+  ), { optimizeLodash: enableOptimizeLodash = hasDependency$1(pkg, "lodash") } = config2?.rollup || {};
+  [
+    alias({
+      entries: { ...pathAliases }
+    }),
+    nodeResolve({
+      browser: runtime === "browser",
+      extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
+      preferBuiltins: !0
+    }),
+    commonjs(),
+    json(),
+    esbuild({
+      target,
+      tsconfig: ctx.ts.configPath || "tsconfig.json",
+      treeShaking: !0,
+      minifySyntax: config2?.minify !== !1,
+      supported: {
+        "template-literal": !0
+      }
+    }),
+    Array.isArray(config2?.babel?.plugins) && getBabelOutputPlugin({
+      babelrc: !1,
+      plugins: config2.babel.plugins
+    }),
+    enableOptimizeLodash && optimizeLodashImports({
+      useLodashEs: format2 === "esm" && hasDependency$1(pkg, "lodash-es") ? !0 : void 0,
+      ...typeof config2?.rollup?.optimizeLodash == "boolean" ? {} : config2?.rollup?.optimizeLodash
+    }),
+    minify && terser({
+      compress: { directives: !1, passes: 10 },
+      ecma: 2020,
+      output: {
+        comments: (_node, comment) => {
+          const text = comment.value;
+          return comment.type === "comment2" ? /@preserve|@license|@cc_on/i.test(text) : !1;
+        },
+        preserve_annotations: !0
+      }
+    })
+  ].filter(Boolean);
+  const hashChunkFileNames = config2?.rollup?.hashChunkFileNames ?? !1, chunkFileNames = `${hashChunkFileNames ? "_chunks" : "_chunks-[format]"}/${hashChunkFileNames ? "[name]-[hash]" : "[name]"}${outputExt}`, entryFileNames = `[name]${outputExt}`, inputOptions = {
+    cwd,
+    jsx: {
+      mode: config2?.jsx === "automatic" ? "automatic" : config2?.jsx === "preserve" ? "preserve" : config2?.jsx === "transform" ? "classic" : "automatic",
+      factory: config2?.jsxFactory,
+      fragment: config2?.jsxFragment,
+      importSource: config2?.jsxImportSource
+    },
+    define: pkg.name === "@sanity/pkg-utils" ? { ...replacements } : {
+      "process.env.PKG_FORMAT": JSON.stringify(format2),
+      "process.env.PKG_RUNTIME": JSON.stringify(runtime),
+      "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version),
+      ...replacements
+    },
+    external: (id, importer) => {
+      if (exportIds?.includes(id))
+        return !0;
+      if (importer && (id.startsWith(".") || id.startsWith("/"))) {
+        const idPath = path.resolve(path.dirname(importer), id);
+        if (sourcePaths?.includes(idPath))
+          return logger.warn(
+            `detected self-referencing import \u2013 treating as external: ${path.relative(
+              cwd,
+              idPath
+            )}`
+          ), !0;
+      }
+      const idParts = id.split("/"), name = idParts[0].startsWith("@") ? `${idParts[0]}/${idParts[1]}` : idParts[0];
+      return !!(name && external.includes(name));
+    },
+    input: entries.reduce(
+      (acc, entry) => Object.assign(acc, { [entry.name]: entry.source }),
+      {}
+    ),
+    plugins: [dts({ emitDtsOnly: !0, tsconfig: ctx.ts.configPath || "tsconfig.json" })],
+    treeshake: !0
+  }, outputOptions = {
+    chunkFileNames,
+    dir: outDir,
+    entryFileNames,
+    esModule: !0,
+    format: buildTask.type === "rolldown:dts" ? "es" : format2,
+    sourcemap: buildTask.type === "rolldown:dts" ? !1 : config2?.sourcemap ?? !0,
+    hoistTransitiveImports: !1
+  };
+  return { inputOptions, outputOptions };
+}
+function hasDependency$1(pkg, packageName) {
+  return pkg.dependencies ? packageName in pkg.dependencies : pkg.peerDependencies ? packageName in pkg.peerDependencies : !1;
+}
+const rolldownDtsTask = {
+  name: (ctx, task) => {
+    const bundleEntries = task.entries.filter((e) => e.path.includes("__$$bundle_")), entries = task.entries.filter((e) => !e.path.includes("__$$bundle_")), targetLines = task.target.length ? ["  target:", ...task.target.map((t) => `    - ${chalk.yellow(t)}`)] : [], bundlesLines = bundleEntries.length ? [
+      "  bundles:",
+      ...bundleEntries.map(
+        (e) => [
+          "    - ",
+          `${chalk.yellow(e.source)} ${chalk.gray("\u2192")} ${chalk.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [], entriesLines = entries.length ? [
+      "  entries:",
+      ...entries.map(
+        (e) => [
+          "    - ",
+          `${chalk.cyan(path.join(ctx.pkg.name, e.path))}: `,
+          `${chalk.yellow(e.source)} ${chalk.gray("\u2192")} ${chalk.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [];
+    return [
+      `Build type definitions with ${chalk.bold("rolldown")}...`,
+      `  format: ${chalk.yellow(task.format)}`,
+      ...targetLines,
+      ...bundlesLines,
+      ...entriesLines
+    ].join(`
+`);
+  },
+  exec: (ctx, task) => from(execPromise$1(ctx, task)),
+  complete: () => {
+  },
+  error: (_ctx, _task, err) => {
+    console.error(err);
+  }
+};
+async function execPromise$1(ctx, task) {
+  const { distPath, files, logger } = ctx, outDir = path.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
+    onRestored: (messages) => {
+      for (const msg of messages) {
+        const text = String(msg.args[0]);
+        msg.code !== "CIRCULAR_DEPENDENCY" && (text.startsWith("Dynamic import can only") || text.startsWith("Sourcemap is likely to be incorrect") || (msg.type === "log" && logger.info(...msg.args), msg.type === "warn" && logger.warn(...msg.args), msg.type === "error" && logger.error(...msg.args)));
+      }
+    }
+  });
+  try {
+    const { inputOptions, outputOptions } = resolveRolldownConfig(ctx, task), bundle = await rolldown({
+      ...inputOptions,
+      onwarn(warning) {
+        consoleSpy.messages.push({
+          type: "warn",
+          code: warning.code,
+          args: [warning.message]
+        });
+      }
+    }), { output } = await bundle.generate(outputOptions);
+    for (const chunkOrAsset of output)
+      chunkOrAsset.type === "asset" ? files.push({
+        type: "asset",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      }) : files.push({
+        type: "chunk",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      });
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
+  } catch (err) {
+    throw consoleSpy.restore(), err;
+  }
+}
 function resolveRollupConfig(ctx, buildTask) {
   const { format: format2, runtime, target } = buildTask, { config: config2, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = pkgExtMap[pkg.type || "commonjs"][format2], minify = config2?.minify ?? !1, outDir = path.relative(cwd, distPath), pathAliases = Object.fromEntries(
     Object.entries(ts2.config?.options.paths || {}).map(([key, val]) => [key, path.resolve(cwd, ts2.config?.options.baseUrl || ".", val[0])])
@@ -1398,7 +1594,8 @@ const rollupWatchTask = {
   }
 }, buildTaskHandlers = {
   "build:dts": dtsTask,
-  "build:js": rollupTask
+  "build:js": rollupTask,
+  "rolldown:dts": rolldownDtsTask
 }, watchTaskHandlers = {
   "watch:dts": dtsWatchTask,
   "watch:js": rollupWatchTask