@sanity/pkg-utils 7.4.0-canary.2 → 7.4.1-canary.0

package/dist/_chunks-es/index.js

@@ -1,181 +1,182 @@
-import chalk from "chalk";
-import { Observable, from } from "rxjs";
-import path from "node:path";
-import * as rimraf from "rimraf";
-import { rimraf as rimraf$1 } from "rimraf";
-import ts from "typescript";
-import fs, { readFile } from "node:fs/promises";
-import { ExtractorConfig, Extractor } from "@microsoft/api-extractor";
-import { mkdirp } from "mkdirp";
-import * as prettier from "prettier";
-import { createRequire } from "node:module";
-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 { createConsoleSpy, resolveConfigProperty, pkgExtMap } from "./consoleSpy.js";
-import { rollup, watch } from "rollup";
-import { optimizeLodashImports } from "@optimize-lodash/rollup-plugin";
-import alias from "@rollup/plugin-alias";
-import { babel, getBabelOutputPlugin } 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 esbuild from "rollup-plugin-esbuild";
-function printExtractMessages(ctx, messages) {
-  const { cwd, logger } = ctx, warnings = messages.filter((msg) => msg.logLevel === "warning");
-  warnings.length && logger.log();
-  for (const msg of warnings) {
-    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
-    msg.messageId !== "TS6307" && logger.log(
-      [
-        `${chalk.cyan(sourceFilePath || "?")}`,
-        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
-        ` - ${chalk.yellow("warning")} ${chalk.gray(msg.messageId)}
-`,
-        msg.text,
-        `
-`
-      ].join("")
-    );
-  }
-  const errors = messages.filter((msg) => msg.logLevel === "error");
-  !warnings.length && errors.length && logger.log("");
-  for (const msg of errors) {
-    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
-    logger.log(
-      [
-        `${chalk.cyan(sourceFilePath || "?")}`,
-        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
-        ` - ${chalk.red("error")} ${chalk.gray(msg.messageId)}
-`,
-        msg.text,
-        `
-`
-      ].join("")
-    );
-  }
-  errors.length && process.exit(1);
+import "./build.js";
+import "./check.js";
+import "./loadPkgWithReporting.js";
+import config from "@sanity/browserslist-config";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import "./init.js";
+import "./logger.js";
+import { z } from "zod";
+import { errorMap } from "zod-validation-error";
+import "./watch.js";
+function defineConfig(configOptions) {
+  return configOptions;
+}
+const DEFAULT_BROWSERSLIST_QUERY = config, fileEnding = /\.[mc]?js$/, dtsEnding = ".d.ts", defaultEnding = ".js", mjsEnding = ".mjs", cjsEnding = ".cjs", mtsEnding = ".d.mts", ctsEnding = ".d.cts";
+function getTargetPaths(_type, expOrBundle) {
+  const type = _type === "module" ? "module" : "commonjs", set = /* @__PURE__ */ new Set();
+  return expOrBundle?.import && set.add(expOrBundle.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)), expOrBundle?.require && set.add(expOrBundle.require.replace(fileEnding, type === "commonjs" ? dtsEnding : ctsEnding)), isPkgExport$1(expOrBundle) && (expOrBundle.browser?.source || (expOrBundle.browser?.import && set.add(
+    expOrBundle.browser.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)
+  ), expOrBundle.browser?.require && set.add(
+    expOrBundle.browser.require.replace(
+      fileEnding,
+      type === "commonjs" ? dtsEnding : ctsEnding
+    )
+  )), expOrBundle.node?.source || (expOrBundle.node?.import && set.add(
+    expOrBundle.node.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)
+  ), expOrBundle.node?.require && set.add(
+    expOrBundle.node.require.replace(fileEnding, type === "commonjs" ? dtsEnding : ctsEnding)
+  ))), Array.from(set);
 }
-function printDiagnostic(options) {
-  const { cwd, logger, diagnostic } = options;
-  if (diagnostic.file && diagnostic.start) {
-    const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), message = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`), file = path.relative(cwd, diagnostic.file.fileName), output = [
-      `${chalk.yellow(file)}:${chalk.blue(line + 1)}:${chalk.blue(character + 1)} - `,
-      `${chalk.gray(`TS${diagnostic.code}:`)} ${message}`
-    ].join("");
-    diagnostic.category === ts.DiagnosticCategory.Error && logger.error(output), diagnostic.category === ts.DiagnosticCategory.Warning && logger.warn(output), diagnostic.category === ts.DiagnosticCategory.Message && logger.log(output), diagnostic.category === ts.DiagnosticCategory.Suggestion && logger.log(output);
-  } else
-    logger.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`));
+function isPkgExport$1(exp) {
+  return exp?.browser || exp?.node || exp?.default;
 }
-async function buildTypes(options) {
-  const { cwd, logger, outDir, tsconfig, strict = !1 } = options, compilerOptions = {
-    ...tsconfig.options,
-    declaration: !0,
-    declarationDir: outDir,
-    emitDeclarationOnly: !0,
-    noEmit: !1,
-    noEmitOnError: strict ? !0 : tsconfig.options.noEmitOnError ?? !0,
-    outDir
-  }, program = ts.createProgram(tsconfig.fileNames, compilerOptions), emitResult = program.emit(), allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-  for (const diagnostic of allDiagnostics)
-    printDiagnostic({ cwd, logger, diagnostic });
-  if (emitResult.emitSkipped && allDiagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error).length)
-    throw new Error("failed to compile TypeScript definitions");
+function isRecord(value) {
+  return !!value && !Array.isArray(value) && typeof value == "object";
 }
-class DtsError extends Error {
-  messages;
-  constructor(message, messages) {
-    super(message), this.messages = messages;
+const pkgExtMap = {
+  // pkg.type: "commonjs"
+  commonjs: {
+    commonjs: defaultEnding,
+    esm: mjsEnding
+  },
+  // pkg.type: "module"
+  module: {
+    commonjs: cjsEnding,
+    esm: defaultEnding
   }
+};
+function validateExports(_exports, options) {
+  const { pkg } = options, type = pkg.type || "commonjs", ext = pkgExtMap[type], errors = [];
+  for (const exp of _exports)
+    exp.require && !exp.require.endsWith(ext.commonjs) && errors.push(
+      `package.json with \`type: "${type}"\` - \`exports["${exp._path}"].require\` must end with "${ext.commonjs}"`
+    ), exp.import && !exp.import.endsWith(ext.esm) && errors.push(
+      `package.json with \`type: "${type}"\` - \`exports["${exp._path}"].import\` must end with "${ext.esm}"`
+    );
+  return errors;
 }
-function createApiExtractorConfig(options) {
-  const {
-    bundledPackages,
-    distPath,
-    exportPath,
-    filePath,
-    messages,
-    projectFolder,
-    mainEntryPointFilePath,
-    tsconfig,
-    tsconfigPath,
-    dtsRollupEnabled
-  } = options;
-  return {
-    apiReport: {
-      enabled: !1,
-      reportFileName: "<unscopedPackageName>.api.md"
-    },
-    bundledPackages,
-    // If `paths` are used for self-referencing imports (e.g. the module is named `sanity`, and the `sanity/structure` export is also importing from `sanity/router`),
-    compiler: tsconfig.options.paths ? {
-      overrideTsconfig: {
-        extends: tsconfigPath,
-        compilerOptions: {
-          // An empty object replaces whatever is in the original tsconfig file
-          paths: {}
-        }
-      }
-    } : { tsconfigFilePath: tsconfigPath },
-    docModel: {
-      enabled: !1,
-      apiJsonFilePath: path.resolve(distPath, `${exportPath}.api.json`)
-    },
-    dtsRollup: {
-      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')),
-    },
-    tsdocMetadata: {
-      enabled: !1
-    },
-    messages,
-    mainEntryPointFilePath,
-    projectFolder
+function parseExports(options) {
+  const { cwd, pkg, strict, strictOptions: strictOptions2, logger } = options, type = pkg.type || "commonjs", errors = [], report = (kind, message) => {
+    kind === "warn" ? logger.warn(message) : errors.push(message);
   };
+  if (!pkg.main && strict && strictOptions2.alwaysPackageJsonMain !== "off" && report(strictOptions2.alwaysPackageJsonMain, "package.json: `main` must be declared"), !Array.isArray(pkg.files) && strict && strictOptions2.alwaysPackageJsonFiles !== "off" && report(
+    strictOptions2.alwaysPackageJsonFiles,
+    "package.json: `files` should be used over `.npmignore`"
+  ), pkg.source) {
+    if (strict && pkg.exports?.["."] && typeof pkg.exports["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source === pkg.source)
+      errors.push(
+        'package.json: the "source" property can be removed, as it is equal to exports["."].source.'
+      );
+    else if (!pkg.exports && pkg.main) {
+      const extMap = pkgExtMap[type], importExport = pkg.main.replace(fileEnding, extMap.esm), requireExport = pkg.main.replace(fileEnding, extMap.commonjs), defaultExport = pkg.main.replace(fileEnding, defaultEnding), maybeBrowserCondition = [];
+      if (pkg.browser) {
+        const browserConditions = [];
+        pkg.module && pkg.browser?.[pkg.module] ? browserConditions.push(
+          `      "import": ${JSON.stringify(pkg.browser[pkg.module].replace(fileEnding, extMap.esm))}`
+        ) : pkg.browser?.[pkg.main] && browserConditions.push(
+          `      "import": ${JSON.stringify(pkg.browser?.[pkg.main].replace(fileEnding, extMap.esm))}`
+        ), pkg.browser?.[pkg.main] && browserConditions.push(
+          `      "require": ${JSON.stringify(pkg.browser[pkg.main].replace(fileEnding, extMap.commonjs))}`
+        ), browserConditions.length && maybeBrowserCondition.push(
+          '    "browser": {',
+          `      "source": ${JSON.stringify(pkg.browser?.[pkg.source] || pkg.source)},`,
+          ...browserConditions,
+          "    }"
+        );
+      }
+      errors.push(
+        ...[
+          "package.json: `exports` are missing, it should be:",
+          '"exports": {',
+          '  ".": {',
+          `    "source": ${JSON.stringify(pkg.source)},`,
+          // If browser conditions are detected then add them to the suggestion
+          ...maybeBrowserCondition.length > 0 ? maybeBrowserCondition : [],
+          type === "commonjs" && `    "import": ${JSON.stringify(importExport)},`,
+          type === "module" && `    "require": ${JSON.stringify(requireExport)},`,
+          `    "default": ${JSON.stringify(defaultExport)}`,
+          "  },",
+          '  "./package.json": "./package.json"',
+          "}"
+        ].filter(Boolean)
+      );
+    }
+  }
+  if (errors.length)
+    throw new Error(`
+- ` + errors.join(`
+- `));
+  if (!pkg.exports)
+    throw new Error(
+      `
+- ` + [
+        "package.json: `exports` are missing, please set a minimal configuration, for example:",
+        '"exports": {',
+        '  ".": {',
+        '    "source": "./src/index.js",',
+        '    "default": "./dist/index.js"',
+        "  },",
+        '  "./package.json": "./package.json"',
+        "}"
+      ].join(`
+- `)
+    );
+  const _exports = [];
+  strict && strictOptions2.noPackageJsonTypings !== "off" && "typings" in pkg && report(strictOptions2.noPackageJsonTypings, "package.json: `typings` should be `types`"), strict && strictOptions2.alwaysPackageJsonTypes !== "off" && !pkg.types && typeof pkg.exports?.["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source?.endsWith(".ts") && report(
+    strictOptions2.alwaysPackageJsonTypes,
+    "package.json: `types` must be declared for the npm listing to show as a TypeScript module."
+  ), strict && !pkg.exports["./package.json"] && errors.push('package.json: `exports["./package.json"] must be declared.');
+  for (const [exportPath, exportEntry] of Object.entries(pkg.exports))
+    if (exportPath.endsWith(".json") || typeof exportEntry == "string" && exportEntry.endsWith(".json"))
+      exportPath === "./package.json" && exportEntry !== "./package.json" && errors.push('package.json: `exports["./package.json"]` must be "./package.json".');
+    else if (exportPath.endsWith(".css"))
+      typeof exportEntry == "string" && !existsSync(resolve(cwd, exportEntry)) ? errors.push(
+        `package.json: \`exports[${JSON.stringify(exportPath)}]\`: file does not exist.`
+      ) : typeof exportEntry != "string" && errors.push(
+        `package.json: \`exports[${JSON.stringify(exportPath)}]\`: export conditions not supported for CSS files.`
+      );
+    else if (!(isRecord(exportEntry) && "svelte" in exportEntry))
+      if (isPkgExport(exportEntry)) {
+        const exp = {
+          _exported: !0,
+          _path: exportPath,
+          ...exportEntry
+        };
+        if (!exp.default) {
+          const fallback = type === "module" ? exp.import : exp.require;
+          fallback && (exp.default = fallback);
+        }
+        !exp.require && type === "commonjs" && exp.default && (exp.require = exp.default), !exp.import && type === "module" && exp.default && (exp.import = exp.default), exportPath === "." && (exportEntry.require && pkg.main && exportEntry.require !== pkg.main && errors.push(
+          'package.json: mismatch between "main" and "exports.require". These must be equal.'
+        ), exportEntry.import && pkg.module && exportEntry.import !== pkg.module && errors.push(
+          'package.json: mismatch between "module" and "exports.import" These must be equal.'
+        )), _exports.push(exp);
+      } else isRecord(exportEntry) || errors.push("package.json: exports must be an object");
+  if (errors.push(...validateExports(_exports, { pkg })), errors.length)
+    throw new Error(`
+- ` + errors.join(`
+- `));
+  return _exports;
 }
-const require2 = createRequire(import.meta.url);
-async function createTSDocConfig(opts) {
-  const { customTags } = opts;
-  if (customTags.length === 0)
-    return;
-  const tsDocBaseBuf = await readFile(
-    require2.resolve("@microsoft/api-extractor/extends/tsdoc-base.json")
-  ), tsDocBaseConfig = parse(tsDocBaseBuf.toString()), tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(
-    customTags.map((t) => ({
-      tagName: `@${t.name}`,
-      syntaxKind: t.syntaxKind,
-      allowMultiple: t.allowMultiple
-    }))
-  ), supportForTags = { ...tsDocBaseConfig.supportForTags };
-  for (const customTag of customTags)
-    supportForTags[`@${customTag.name}`] = !0;
-  return TSDocConfigFile.loadFromObject({
-    ...tsDocBaseConfig,
-    noStandardTags: !1,
-    tagDefinitions,
-    supportForTags
-  });
+function isPkgExport(value) {
+  return isRecord(value) && "source" in value && typeof value.source == "string";
 }
-async function extractModuleBlocksFromTypes({
-  tsOutDir,
-  extractResult
-}) {
-  const program = extractResult.compilerState.program, moduleBlocks = [], sourceFiles = [...program.getSourceFiles()].filter((sourceFile) => sourceFile.fileName.includes(tsOutDir));
-  for (const sourceFile of sourceFiles)
-    sourceFile.text.includes("declare module") && moduleBlocks.push(...extractModuleBlocks(sourceFile.text));
-  return moduleBlocks;
+function defineTemplateOption(option) {
+  return option;
 }
-function extractModuleBlocks(fileContent) {
-  return parse$1(fileContent, {
-    parser: typeScriptParser
-  }).program.body.filter((node) => node.type === "TSModuleDeclaration").map((node) => print(node).code);
+const toggle = z.union([z.literal("error"), z.literal("warn"), z.literal("off")]), strictOptions = z.object({
+  noPackageJsonTypings: toggle.default("error"),
+  noImplicitSideEffects: toggle.default("warn"),
+  noImplicitBrowsersList: toggle.default("warn"),
+  alwaysPackageJsonTypes: toggle.default("error"),
+  alwaysPackageJsonMain: toggle.default("error"),
+  alwaysPackageJsonFiles: toggle.default("error")
+}).strict(), validationSchema = z.object({
+  strictOptions: strictOptions.default({})
+});
+function parseStrictOptions(input) {
+  return validationSchema.parse({ strictOptions: input }, { errorMap }).strictOptions;
 }
 const LOG_LEVELS = {
   error: "error",
@@ -258,592 +259,17 @@ function getExtractMessagesConfig(options) {
     }
   };
 }
-async function extractTypes(options) {
-  const {
-    bundledPackages,
-    customTags,
-    distPath,
-    exportPath,
-    files,
-    filePaths,
-    projectPath,
-    rules,
-    sourceTypesPath,
-    tmpPath,
-    tsconfig,
-    tsconfigPath,
-    extractorDisabled
-  } = options, tsdocConfigFile = await createTSDocConfig({
-    customTags: customTags || []
-  }), filePath = filePaths[0].replace(/\.d\.[mc]ts$/, ".d.ts"), shouldCleanUpDts = !filePaths.includes(filePath), extractorConfig = ExtractorConfig.prepare({
-    configObject: createApiExtractorConfig({
-      bundledPackages,
-      distPath,
-      exportPath,
-      filePath,
-      messages: getExtractMessagesConfig({ rules, disabled: extractorDisabled }),
-      projectFolder: projectPath,
-      mainEntryPointFilePath: sourceTypesPath,
-      tsconfig,
-      tsconfigPath,
-      dtsRollupEnabled: !0
-    }),
-    configObjectFullPath: void 0,
-    tsdocConfigFile,
-    packageJsonFullPath: path.resolve(projectPath, "package.json")
-  }), messages = [], extractorResult = Extractor.invoke(extractorConfig, {
-    // Equivalent to the "--local" command-line parameter
-    localBuild: !0,
-    // Equivalent to the "--verbose" command-line parameter
-    showVerboseMessages: !0,
-    // handle messages
-    messageCallback(message) {
-      messages.push(message), message.handled = !0;
-    }
-  }), typesPath = path.resolve(distPath, filePath), typesBuf = await fs.readFile(typesPath), prettierConfig = await prettier.resolveConfig(typesPath);
-  await mkdirp(path.dirname(typesPath));
-  const moduleBlocks = await extractModuleBlocksFromTypes({
-    extractResult: extractorResult,
-    tsOutDir: tmpPath
-  }), code = [typesBuf.toString(), ...moduleBlocks].join(`
-
-`), prettyCode = await prettier.format(code, {
-    ...prettierConfig,
-    filepath: typesPath
-  });
-  for (const expFilePath of filePaths) {
-    const expTypesPath = path.resolve(distPath, expFilePath);
-    await fs.writeFile(expTypesPath, prettyCode), files.push({
-      type: "types",
-      path: expTypesPath
-    });
-  }
-  return shouldCleanUpDts && await fs.unlink(typesPath), { extractorResult, messages };
-}
-async function doExtract(ctx, task) {
-  const { config, cwd, files, logger, strict, ts: ts2, bundledPackages } = ctx;
-  if (!ts2.config || !ts2.configPath)
-    return { type: "dts", messages: [], results: [] };
-  const { outDir, rootDir = cwd } = ts2.config.options;
-  if (!outDir)
-    throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
-  const tmpPath = path.resolve(outDir, "__tmp__");
-  await buildTypes({ cwd, logger, outDir: tmpPath, strict, tsconfig: ts2.config });
-  const messages = [], results = [];
-  for (const entry of task.entries) {
-    const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath, sourceTypesPath = path.resolve(
-      tmpPath,
-      path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
-    ), targetPaths = entry.targetPaths.map((targetPath) => path.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path.relative(outDir, targetPath)), result = await extractTypes({
-      bundledPackages: bundledPackages || [],
-      customTags: config?.extract?.customTags,
-      distPath: outDir,
-      exportPath,
-      files,
-      filePaths,
-      projectPath: cwd,
-      rules: config?.extract?.rules,
-      sourceTypesPath,
-      tsconfig: ts2.config,
-      tmpPath,
-      tsconfigPath: path.resolve(cwd, ts2.configPath || "tsconfig.json"),
-      extractorDisabled: config?.extract?.enabled === !1
-    });
-    messages.push(...result.messages);
-    const errors = result.messages.filter((msg) => msg.logLevel === "error");
-    if (errors.length > 0)
-      throw await rimraf$1(tmpPath), new DtsError(`encountered ${errors.length} errors when extracting types`, errors);
-    results.push({ sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
-  }
-  return await rimraf$1(tmpPath), { type: "dts", messages, results };
-}
-const dtsTask = {
-  name: (ctx, task) => [
-    `Build type definitions with ${chalk.bold(ctx.dts)}...`,
-    "  entries:",
-    ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
-      `    - ${chalk.cyan(entry.importId)}: `,
-      `${chalk.yellow(entry.sourcePath)} ${chalk.gray("\u2192")} ${chalk.yellow(targetPath)}`
-    ].join("")).join(`
-`))
-  ].join(`
-`),
-  exec: (ctx, task) => new 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;
-    err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
-  }
-}, dtsWatchTask = {
-  name: (_ctx, task) => [
-    "build type definitions",
-    ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
-      `    - ${chalk.cyan(entry.importId)}: `,
-      `${chalk.yellow(entry.sourcePath)} ${chalk.gray("\u2192")} ${chalk.yellow(targetPath)}`
-    ].join("")))
-  ].join(`
-`),
-  exec: (ctx, task) => {
-    const { config, cwd, files, logger, strict, ts: tsContext, bundledPackages } = ctx;
-    return new Observable((observer) => {
-      if (!tsContext.config || !tsContext.configPath) {
-        observer.next({ type: "dts", messages: [], results: [] }), observer.complete();
-        return;
-      }
-      const { outDir, rootDir = cwd } = tsContext.config.options;
-      if (!outDir) {
-        observer.error(new Error("tsconfig.json is missing `compilerOptions.outDir`"));
-        return;
-      }
-      const tmpPath = path.resolve(outDir, "__tmp__");
-      buildTypes({
-        cwd,
-        logger,
-        outDir: tmpPath,
-        tsconfig: tsContext.config,
-        strict
-      }).catch((err) => {
-        observer.error(err);
-      });
-      const host = ts.createWatchCompilerHost(
-        tsContext.configPath,
-        {
-          ...tsContext.config.options,
-          declaration: !0,
-          declarationDir: tmpPath,
-          emitDeclarationOnly: !0,
-          noEmit: !1,
-          noEmitOnError: strict ? !0 : tsContext.config.options.noEmitOnError ?? !0,
-          outDir: tmpPath
-        },
-        ts.sys,
-        ts.createEmitAndSemanticDiagnosticsBuilderProgram,
-        (diagnostic) => {
-          logger.error(ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`));
-        },
-        (diagnostic) => {
-          logger.info(ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`));
-        }
-      ), origPostProgramCreate = host.afterProgramCreate;
-      host.afterProgramCreate = async (program) => {
-        origPostProgramCreate?.(program);
-        const messages = [], results = [];
-        for (const entry of task.entries) {
-          const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath, sourceTypesPath = path.resolve(
-            tmpPath,
-            path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
-          ), targetPaths = entry.targetPaths.map((targetPath) => path.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path.relative(outDir, targetPath));
-          try {
-            const result = await extractTypes({
-              bundledPackages: bundledPackages || [],
-              customTags: config?.extract?.customTags,
-              cwd,
-              distPath: outDir,
-              exportPath,
-              files,
-              filePaths,
-              projectPath: cwd,
-              rules: config?.extract?.rules,
-              sourceTypesPath,
-              tsconfig: tsContext.config,
-              tmpPath,
-              tsconfigPath: path.resolve(cwd, tsContext.configPath || "tsconfig.json"),
-              extractorDisabled: config?.extract?.enabled === !1
-            });
-            messages.push(...result.messages), results.push({ sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
-          } catch (err) {
-            if (err instanceof DtsError)
-              messages.push(...err.messages);
-            else {
-              observer.error(err);
-              return;
-            }
-          }
-        }
-        observer.next({ type: "dts", messages, results });
-      };
-      const watchProgram = ts.createWatchProgram(host);
-      return () => {
-        watchProgram.close(), rimraf.sync(tmpPath);
-      };
-    });
-  },
-  complete: (ctx, task, result) => {
-    const { logger } = ctx;
-    printExtractMessages(ctx, result.messages), logger.success(
-      `build type definitions
-       ${task.entries.map(
-        (entry) => `    - ${chalk.cyan(entry.importId)}: ${chalk.yellow(entry.sourcePath)} ${chalk.gray("\u2192")} ${chalk.yellow(entry.targetPaths.join(", "))}`
-      ).join(`
-       `)}`
-    ), logger.log("");
-  },
-  error: (ctx, _task, err) => {
-    const { logger } = ctx;
-    err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
-  }
-}, 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(replaceFileEnding(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(replaceFileEnding(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 [{ rolldown }, { resolveRolldownConfig }] = await Promise.all([
-    import("rolldown"),
-    import("./resolveRolldownConfig.js")
-  ]), { 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 replaceFileEnding(path2) {
-  switch (!0) {
-    case path2.endsWith(".mjs"):
-      return path2.replace(/\.mjs$/, ".d.mts");
-    case path2.endsWith(".cjs"):
-      return path2.replace(/\.cjs$/, ".d.cts");
-    default:
-      return path2.replace(/\.js$/, ".d.ts");
-  }
-}
-function resolveRollupConfig(ctx, buildTask) {
-  const { format, runtime, target } = buildTask, { config, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = pkgExtMap[pkg.type || "commonjs"][format], minify = config?.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(config?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
-  ), { optimizeLodash: enableOptimizeLodash = hasDependency(pkg, "lodash") } = config?.rollup || {}, defaultPlugins = [
-    replace({
-      preventAssignment: !0,
-      values: pkg.name === "@sanity/pkg-utils" ? { ...replacements } : {
-        "process.env.PKG_FILE_PATH": (arg) => {
-          const sourcePath = `./${path.relative(cwd, arg)}`, entry = entries.find((e) => e.source === sourcePath);
-          return entry ? JSON.stringify(
-            path.relative(cwd, path.resolve(outDir, entry.name + outputExt))
-          ) : (console.error(`could not find source entry: ${sourcePath}`), "null");
-        },
-        "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),
-        ...replacements
-      }
-    }),
-    alias({
-      entries: { ...pathAliases }
-    }),
-    nodeResolve({
-      browser: runtime === "browser",
-      extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
-      preferBuiltins: !0
-    }),
-    commonjs(),
-    json(),
-    (config?.babel?.reactCompiler || config?.babel?.styledComponents) && babel({
-      babelrc: !1,
-      presets: ["@babel/preset-typescript"],
-      babelHelpers: "bundled",
-      extensions: [".ts", ".tsx", ".js", ".jsx"],
-      plugins: [
-        // The styled-components plugin needs to run before the react-compiler plugin, in case the css prop is used
-        config?.babel?.styledComponents && [
-          "babel-plugin-styled-components",
-          {
-            // Unnecessary, as the way we use styled-components in Sanity is usually by wrapping `@sanity/ui` primitives, not declaring new ones like "const Button = styled.button``"
-            fileName: !1,
-            // Native template literals take less space than this transpilation
-            transpileTemplateLiterals: !1,
-            // Massively helps dead code elimination and tree-shaking
-            pure: !0,
-            // disabled, as pkg-utils tends to be used for npm publishing, while other tooling, like `sanity dev`, `next dev`, etc are used for testing
-            cssProp: !1,
-            ...typeof config.babel.styledComponents == "object" ? config.babel.styledComponents : {}
-          }
-        ],
-        config?.babel?.reactCompiler && [
-          "babel-plugin-react-compiler",
-          config?.reactCompilerOptions || {}
-        ]
-      ].filter(Boolean)
-    }),
-    esbuild({
-      jsx: config?.jsx ?? "automatic",
-      jsxFactory: config?.jsxFactory ?? "createElement",
-      jsxFragment: config?.jsxFragment ?? "Fragment",
-      jsxImportSource: config?.jsxImportSource ?? "react",
-      target,
-      tsconfig: ctx.ts.configPath || "tsconfig.json",
-      treeShaking: !0,
-      minifySyntax: config?.minify !== !1,
-      supported: {
-        "template-literal": !0
-      }
-    }),
-    Array.isArray(config?.babel?.plugins) && getBabelOutputPlugin({
-      babelrc: !1,
-      plugins: config.babel.plugins
-    }),
-    enableOptimizeLodash && optimizeLodashImports({
-      useLodashEs: format === "esm" && hasDependency(pkg, "lodash-es") ? !0 : void 0,
-      ...typeof config?.rollup?.optimizeLodash == "boolean" ? {} : config?.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), userPlugins = config?.rollup?.plugins, plugins = Array.isArray(userPlugins) ? defaultPlugins.concat(userPlugins) : resolveConfigProperty(config?.rollup?.plugins, defaultPlugins), hashChunkFileNames = config?.rollup?.hashChunkFileNames ?? !1, chunkFileNames = `${hashChunkFileNames ? "_chunks" : "_chunks-[format]"}/${hashChunkFileNames ? "[name]-[hash]" : "[name]"}${outputExt}`, entryFileNames = `[name]${outputExt}`;
-  return {
-    inputOptions: {
-      context: cwd,
-      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 }),
-        {}
-      ),
-      watch: {
-        chokidar: {
-          usePolling: !0
-        }
-      },
-      plugins,
-      treeshake: {
-        preset: "recommended",
-        propertyReadSideEffects: !1,
-        moduleSideEffects: "no-external",
-        ...config?.rollup?.treeshake
-      },
-      experimentalLogSideEffects: config?.rollup?.experimentalLogSideEffects
-    },
-    outputOptions: {
-      chunkFileNames,
-      compact: minify,
-      dir: outDir,
-      entryFileNames,
-      esModule: !0,
-      format,
-      interop: "compat",
-      sourcemap: config?.sourcemap ?? !0,
-      hoistTransitiveImports: !1,
-      minifyInternalExports: minify,
-      ...config?.rollup?.output
-    }
-  };
-}
-function hasDependency(pkg, packageName) {
-  return pkg.dependencies ? packageName in pkg.dependencies : pkg.peerDependencies ? packageName in pkg.peerDependencies : !1;
-}
-const rollupTask = {
-  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 javascript files...",
-      `  format: ${chalk.yellow(task.format)}`,
-      ...targetLines,
-      ...bundlesLines,
-      ...entriesLines
-    ].join(`
-`);
-  },
-  exec: (ctx, task) => new Observable((observer) => {
-    execPromise(ctx, task).then((result) => {
-      observer.next(result), observer.complete();
-    }).catch((err) => observer.error(err));
-  }),
-  complete: () => {
-  },
-  error: (_ctx, _task, err) => {
-    console.error(err);
-  }
-};
-async function execPromise(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 } = resolveRollupConfig(ctx, task), bundle = await rollup({
-      ...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;
-  }
-}
-const rollupWatchTask = {
-  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
-       ${task.entries.map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join(`
-       `)}`,
-  exec: (ctx, task) => {
-    const { inputOptions, outputOptions } = resolveRollupConfig(ctx, task);
-    return new Observable((observer) => {
-      const watchOptions = {
-        ...inputOptions,
-        output: outputOptions
-      }, watcher = watch(watchOptions);
-      return watcher.on("event", (event) => {
-        observer.next(event);
-      }), () => {
-        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.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join(`
-       `)}`
-      ), logger.log("");
-      return;
-    }
-    if (event.code !== "BUNDLE_START" && event.code !== "END" && event.code === "ERROR") {
-      logger.error(event.code, event);
-      return;
-    }
-  },
-  error: (ctx, _task, err) => {
-    const { logger } = ctx;
-    err instanceof Error && logger.log(err);
-  }
-}, buildTaskHandlers = {
-  "build:dts": dtsTask,
-  "build:js": rollupTask,
-  "rolldown:dts": rolldownDtsTask
-}, watchTaskHandlers = {
-  "watch:dts": dtsWatchTask,
-  "watch:js": rollupWatchTask
-};
 export {
-  buildTaskHandlers,
+  DEFAULT_BROWSERSLIST_QUERY,
+  defineConfig,
+  defineTemplateOption,
   getExtractMessagesConfig,
-  watchTaskHandlers
+  getTargetPaths,
+  isRecord,
+  parseExports,
+  parseStrictOptions,
+  pkgExtMap,
+  strictOptions,
+  toggle
 };
 //# sourceMappingURL=index.js.map