@sanity/pkg-utils 2.3.13-canary.0 → 2.3.13-canary.1

package/dist/_chunks/consoleSpy-686c350b.cjs

@@ -0,0 +1,590 @@
+'use strict';
+
+var node = require('esbuild-register/dist/node');
+var path = require('path');
+var pkgUp = require('pkg-up');
+var findConfig = require('find-config');
+var logger = require('./logger-718e11be.cjs');
+var chalk = require('chalk');
+var zod = require('zod');
+var fs = require('fs/promises');
+require('fs');
+require('mkdirp');
+require('prompts');
+var ts = require('typescript');
+var browserslist = require('browserslist');
+function _interopDefaultCompat(e) {
+  return e && typeof e === 'object' && 'default' in e ? e : {
+    default: e
+  };
+}
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var pkgUp__default = /*#__PURE__*/_interopDefaultCompat(pkgUp);
+var findConfig__default = /*#__PURE__*/_interopDefaultCompat(findConfig);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
+var browserslist__default = /*#__PURE__*/_interopDefaultCompat(browserslist);
+const CONFIG_FILE_NAMES = ["package.config.ts", "package.config.js", "package.config.cjs", "package.config.mjs"];
+function findConfigFile(cwd) {
+  const pkgJsonPath = findConfig__default.default("package.json", {
+    cwd
+  });
+  if (!pkgJsonPath) return void 0;
+  const pkgPath = path__default.default.dirname(pkgJsonPath);
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = path__default.default.resolve(pkgPath, fileName);
+    const exists = logger.fileExists(configPath);
+    if (exists) {
+      return configPath;
+    }
+  }
+  return void 0;
+}
+async function loadConfig(options) {
+  const {
+    cwd
+  } = options;
+  const pkgPath = await pkgUp__default.default({
+    cwd
+  });
+  if (!pkgPath) return void 0;
+  const root = path__default.default.dirname(pkgPath);
+  const configFile = await findConfigFile(root);
+  if (!configFile) {
+    return void 0;
+  }
+  if (!configFile.startsWith(cwd)) {
+    return void 0;
+  }
+  const esbuildOptions = {
+    extensions: [".js", ".mjs", ".ts"]
+  };
+  const {
+    unregister
+  } = globalThis.__DEV__ ? {
+    unregister: () => void 0
+  } : node.register(esbuildOptions);
+  const mod = require(configFile);
+  unregister();
+  return (mod == null ? void 0 : mod.default) || mod || void 0;
+}
+function resolveConfigProperty(prop, initialValue) {
+  if (!prop) return initialValue;
+  if (typeof prop === "function") {
+    return prop(initialValue);
+  }
+  return prop;
+}
+const DEFAULT_BROWSERSLIST_QUERY = ["> 0.2% and supports es6-module and supports es6-module-dynamic-import", "not dead", "not IE 11", "maintained node versions"];
+async function loadPkg(options) {
+  const {
+    cwd
+  } = options;
+  const pkgPath = await pkgUp__default.default({
+    cwd
+  });
+  if (!pkgPath) throw new Error("no package.json found");
+  const buf = await fs__default.default.readFile(pkgPath);
+  const raw = JSON.parse(buf.toString());
+  logger.validatePkg(raw);
+  return raw;
+}
+function assertFirst(a, arr) {
+  const aIdx = arr.indexOf(a);
+  if (aIdx === -1) {
+    return true;
+  }
+  return aIdx === 0;
+}
+function assertLast(a, arr) {
+  const aIdx = arr.indexOf(a);
+  if (aIdx === -1) {
+    return true;
+  }
+  return aIdx === arr.length - 1;
+}
+function assertOrder(a, b, arr) {
+  const aIdx = arr.indexOf(a);
+  const bIdx = arr.indexOf(b);
+  if (aIdx === -1 || bIdx === -1) {
+    return true;
+  }
+  return aIdx < bIdx;
+}
+async function loadPkgWithReporting(options) {
+  const {
+    cwd,
+    logger
+  } = options;
+  try {
+    const pkg = await loadPkg({
+      cwd
+    });
+    let shouldError = false;
+    if (pkg.exports) {
+      const _exports = Object.entries(pkg.exports);
+      for (const [expPath, exp] of _exports) {
+        if (typeof exp === "string") {
+          continue;
+        }
+        const keys = Object.keys(exp);
+        if (!assertFirst("types", keys)) {
+          shouldError = true;
+          logger.error("exports[\"".concat(expPath, "\"]: the `types` property should be the first property"));
+        }
+        if (exp.node) {
+          const nodeKeys = Object.keys(exp.node);
+          if (!assertOrder("module", "import", nodeKeys)) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node.module` property should come before the `node.import` property"));
+          }
+          if (!assertOrder("import", "require", nodeKeys)) {
+            logger.warn("exports[\"".concat(expPath, "\"]: the `node.import` property should come before the `node.require` property"));
+          }
+          if (!assertOrder("module", "require", nodeKeys)) {
+            logger.warn("exports[\"".concat(expPath, "\"]: the `node.module` property should come before `node.require` property"));
+          }
+          if (exp.import && exp.node.import && !assertOrder("node", "import", keys)) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node` property should come before the `import` property"));
+          }
+          if (exp.module && exp.node.module && !assertOrder("node", "module", keys)) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node` property should come before the `module` property"));
+          }
+          if (exp.node.import && !exp.node.require && !exp.node.module) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node.module` property should be added so bundlers don't unintentionally try to bundle `node.import`"));
+          }
+          if (exp.node.import && !exp.node.require && exp.node.module && exp.import && exp.node.module !== exp.import) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node.module` property should match `import`"));
+          }
+          if (exp.require && exp.node.require && exp.require === exp.node.require) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node.require` property isn't necessary as it's identical to `require`"));
+          } else if (exp.require && exp.node.require && !assertOrder("node", "require", keys)) {
+            shouldError = true;
+            logger.error("exports[\"".concat(expPath, "\"]: the `node` property should come before the `require` property"));
+          }
+        } else {
+          if (!assertOrder("import", "require", keys)) {
+            logger.warn("exports[\"".concat(expPath, "\"]: the `import` property should come before the `require` property"));
+          }
+          if (!assertOrder("module", "import", keys)) {
+            logger.warn("exports[\"".concat(expPath, "\"]: the `module` property should come before `import` property"));
+          }
+        }
+        if (!assertLast("default", keys)) {
+          shouldError = true;
+          logger.error("exports[\"".concat(expPath, "\"]: the `default` property should be the last property"));
+        }
+      }
+    }
+    if (shouldError) {
+      process.exit(1);
+    }
+    return pkg;
+  } catch (err) {
+    if (err instanceof zod.ZodError) {
+      for (const issue of err.issues) {
+        if (issue.code === "invalid_type") {
+          logger.error(["`".concat(formatPath(issue.path), "` "), "in `./package.json` must be of type ".concat(chalk__default.default.magenta(issue.expected), " "), "(received ".concat(chalk__default.default.magenta(issue.received), ")")].join(""));
+          continue;
+        }
+        logger.error(issue);
+      }
+    } else {
+      logger.error(err);
+    }
+    process.exit(1);
+  }
+}
+function formatPath(segments) {
+  return segments.map((s, idx) => {
+    if (idx === 0) return s;
+    if (typeof s === "number") {
+      return "[".concat(s, "]");
+    }
+    if (s.startsWith(".")) {
+      return "[\"".concat(s, "\"]");
+    }
+    return ".".concat(s);
+  }).join("");
+}
+function validateExports(_exports, options) {
+  const {
+    extMap,
+    pkg
+  } = options;
+  const ext = extMap[pkg.type || "commonjs"];
+  const errors = [];
+  for (const exp of _exports) {
+    if (exp.require && !exp.require.endsWith(ext.commonjs)) {
+      errors.push("package.json with `type: \"".concat(pkg.type, "\"` - `exports[\"").concat(exp._path, "\"].require` must end with \"").concat(ext.commonjs, "\""));
+    }
+    if (exp.import && !exp.import.endsWith(ext.esm)) {
+      errors.push("package.json with `type: \"".concat(pkg.type, "\"` - `exports[\"").concat(exp._path, "\"].import` must end with \"").concat(ext.esm, "\""));
+    }
+  }
+  return errors;
+}
+function parseExports(options) {
+  const {
+    extMap,
+    pkg,
+    strict
+  } = options;
+  const rootExport = {
+    _exported: true,
+    _path: ".",
+    types: pkg.types,
+    source: pkg.source || "",
+    browser: pkg.browser && {
+      source: pkg.source || "",
+      require: pkg.main && pkg.browser[pkg.main],
+      import: pkg.module && pkg.browser[pkg.module]
+    },
+    require: pkg.main,
+    import: pkg.module,
+    default: pkg.module || pkg.main || ""
+  };
+  const extraExports = [];
+  const errors = [];
+  if (pkg.exports) {
+    if (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")) {
+        if (exportPath === "./package.json") {
+          if (exportEntry !== "./package.json") {
+            errors.push('package.json: `exports["./package.json"] must be "./package.json".');
+          }
+        }
+      } else if (logger.isRecord(exportEntry)) {
+        if (exportPath === ".") {
+          if (exportEntry.require && rootExport.require && exportEntry.require !== rootExport.require) {
+            errors.push('package.json: mismatch between "main" and "exports.require". These must be equal.');
+          }
+          if (exportEntry.import && rootExport.import && exportEntry.import !== rootExport.import) {
+            errors.push('package.json: mismatch between "module" and "exports.import" These must be equal.');
+          }
+          if (exportEntry.types && rootExport.types && exportEntry.types !== rootExport.types) {
+            errors.push('package.json: mismatch between "types" and "exports.types". These must be equal.');
+          }
+          if (exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source) {
+            errors.push('package.json: mismatch between "source" and "exports.source". These must be equal.');
+          }
+          Object.assign(rootExport, exportEntry);
+        } else {
+          const extraExport = {
+            _exported: true,
+            _path: exportPath,
+            ...exportEntry
+          };
+          extraExports.push(extraExport);
+        }
+      } else {
+        errors.push("package.json: exports must be an object");
+      }
+    }
+  }
+  const _exports = [rootExport, ...extraExports];
+  errors.push(...validateExports(_exports, {
+    extMap,
+    pkg
+  }));
+  if (errors.length) {
+    throw new Error("\n- " + errors.join("\n- "));
+  }
+  return _exports;
+}
+const DEFAULT_PKG_EXT_MAP = {
+  // pkg.type: "commonjs"
+  commonjs: {
+    commonjs: ".js",
+    esm: ".mjs"
+  },
+  // pkg.type: "module"
+  module: {
+    commonjs: ".cjs",
+    esm: ".js"
+  }
+};
+function getPkgExtMap(options) {
+  const {
+    legacyExports
+  } = options;
+  const ret = {
+    ...DEFAULT_PKG_EXT_MAP
+  };
+  if (legacyExports) {
+    ret["commonjs"] = {
+      commonjs: ".js",
+      esm: ".esm.js"
+    };
+  }
+  return ret;
+}
+async function loadTSConfig(options) {
+  const {
+    cwd,
+    tsconfigPath
+  } = options;
+  const configPath = ts__default.default.findConfigFile(cwd, ts__default.default.sys.fileExists, tsconfigPath);
+  if (!configPath) {
+    throw new Error("could not find a valid '".concat(tsconfigPath, "'"));
+  }
+  const configFile = ts__default.default.readConfigFile(configPath, ts__default.default.sys.readFile);
+  return ts__default.default.parseJsonConfigFileContent(configFile.config, ts__default.default.sys, cwd);
+}
+function pathContains(containerPath, itemPath) {
+  return !path__default.default.relative(containerPath, itemPath).startsWith("..");
+}
+function findCommonDirPath(filePaths) {
+  let ret = void 0;
+  for (const filePath of filePaths) {
+    let dirPath = path__default.default.dirname(filePath);
+    if (!ret) {
+      ret = dirPath;
+      continue;
+    }
+    while (dirPath !== ret) {
+      dirPath = path__default.default.dirname(dirPath);
+      if (dirPath === ret) {
+        break;
+      }
+      if (pathContains(dirPath, ret)) {
+        ret = dirPath;
+        break;
+      }
+      if (dirPath === ".") return void 0;
+    }
+  }
+  return ret;
+}
+function sortAsNumber(a, b) {
+  const aVersion = Number(a);
+  const bVersion = Number(b);
+  return aVersion - bVersion;
+}
+function resolveBrowserslistVersions(query) {
+  const result = browserslist__default.default(query);
+  const entries = result.map(key => {
+    const [name, version] = key.split(" ");
+    return {
+      name,
+      version: version.split("-")[0].split(".")[0]
+    };
+  });
+  const andChr = entries.filter(b => b.name === "and_chr");
+  const andFf = entries.filter(b => b.name === "and_ff");
+  const chrome = entries.filter(b => b.name === "chrome");
+  const edge = entries.filter(b => b.name === "edge");
+  const ff = entries.filter(b => b.name === "firefox");
+  const iosSaf = entries.filter(b => b.name === "ios_saf");
+  const saf = entries.filter(b => b.name === "safari");
+  const opera = entries.filter(b => b.name === "opera");
+  const node = entries.filter(b => b.name === "node");
+  const versions = {
+    chrome: andChr.concat(chrome).map(b => b.version),
+    ff: andFf.concat(ff).map(b => b.version),
+    edge: edge.map(b => b.version),
+    iosSaf: iosSaf.map(b => b.version),
+    saf: saf.map(b => b.version),
+    opera: opera.map(b => b.version),
+    node: node.map(b => b.version)
+  };
+  versions.chrome.sort(sortAsNumber);
+  versions.ff.sort(sortAsNumber);
+  versions.edge.sort(sortAsNumber);
+  versions.iosSaf.sort(sortAsNumber);
+  versions.saf.sort(sortAsNumber);
+  versions.opera.sort(sortAsNumber);
+  versions.node.sort(sortAsNumber);
+  return versions;
+}
+function resolveBrowserTarget(versions) {
+  const target = [];
+  if (versions.chrome.length) {
+    target.push("chrome".concat(versions.chrome[0]));
+  }
+  if (versions.ff.length) {
+    target.push("firefox".concat(versions.ff[0]));
+  }
+  if (versions.edge.length) {
+    target.push("edge".concat(versions.edge[0]));
+  }
+  if (versions.iosSaf.length) {
+    target.push("ios".concat(versions.iosSaf[0]));
+  }
+  if (versions.saf.length) {
+    target.push("safari".concat(versions.saf[0]));
+  }
+  if (versions.opera.length) {
+    target.push("opera".concat(versions.opera[0]));
+  }
+  if (target.length === 0) {
+    return void 0;
+  }
+  return target;
+}
+function resolveNodeTarget(versions) {
+  const target = [];
+  if (versions.node.length) {
+    target.push("node".concat(versions.node[0]));
+  }
+  if (target.length === 0) {
+    return void 0;
+  }
+  return target;
+}
+async function resolveBuildContext(options) {
+  var _ref;
+  const {
+    config,
+    cwd,
+    emitDeclarationOnly = false,
+    extMap,
+    logger,
+    pkg,
+    strict,
+    tsconfig: tsconfigPath
+  } = options;
+  const tsconfig = await loadTSConfig({
+    cwd,
+    tsconfigPath
+  });
+  const targetVersions = resolveBrowserslistVersions(pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY);
+  const nodeTarget = resolveNodeTarget(targetVersions);
+  const webTarget = resolveBrowserTarget(targetVersions);
+  if (!nodeTarget) {
+    throw new Error("no matching `node` target");
+  }
+  if (!webTarget) {
+    throw new Error("no matching `web` target");
+  }
+  const target = {
+    "*": webTarget.concat(nodeTarget),
+    browser: webTarget,
+    node: nodeTarget
+  };
+  const parsedExports = parseExports({
+    extMap,
+    pkg,
+    strict
+  }).reduce((acc, x) => {
+    const {
+      _path: exportPath,
+      ...exportEntry
+    } = x;
+    return {
+      ...acc,
+      [exportPath]: exportEntry
+    };
+  }, {});
+  const exports = resolveConfigProperty(config == null ? void 0 : config.exports, parsedExports);
+  const parsedExternal = [...(pkg.dependencies ? Object.keys(pkg.dependencies) : []), ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : [])];
+  const external = config && Array.isArray(config.external) ? [...parsedExternal, ...config.external] : resolveConfigProperty(config == null ? void 0 : config.external, parsedExternal);
+  const outputPaths = Object.values(exports).flatMap(exportEntry => {
+    var _a, _b, _c, _d;
+    return [exportEntry.import, exportEntry.require, (_a = exportEntry.browser) == null ? void 0 : _a.import, (_b = exportEntry.browser) == null ? void 0 : _b.require, ((_c = exportEntry.node) == null ? void 0 : _c.source) && exportEntry.node.import, ((_d = exportEntry.node) == null ? void 0 : _d.source) && exportEntry.node.require].filter(Boolean);
+  }).map(p => path__default.default.resolve(cwd, p));
+  const commonDistPath = findCommonDirPath(outputPaths);
+  if (commonDistPath === cwd) {
+    throw new Error("all output files must share a common parent directory which is not the root package directory");
+  }
+  if (commonDistPath && !pathContains(cwd, commonDistPath)) {
+    throw new Error("all output files must be located within the package");
+  }
+  const configDistPath = (config == null ? void 0 : config.dist) ? path__default.default.resolve(cwd, config.dist) : void 0;
+  if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !pathContains(configDistPath, commonDistPath)) {
+    logger.log("did you mean to configure `dist: './".concat(path__default.default.relative(cwd, commonDistPath), "'`?"));
+    throw new Error("all output files must be located with the configured `dist` path");
+  }
+  const distPath = configDistPath || commonDistPath;
+  if (!distPath) {
+    throw new Error("could not detect `dist` path");
+  }
+  const ctx = {
+    config,
+    cwd,
+    distPath,
+    emitDeclarationOnly,
+    exports,
+    external,
+    extMap,
+    files: [],
+    logger,
+    pkg,
+    runtime: (_ref = config == null ? void 0 : config.runtime) !== null && _ref !== void 0 ? _ref : "*",
+    strict,
+    target,
+    ts: {
+      config: tsconfig,
+      configPath: tsconfigPath
+    }
+  };
+  return ctx;
+}
+function createConsoleSpy(options) {
+  const {
+    onRestored
+  } = options || {};
+  const original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error
+  };
+  const messages = [];
+  console.log = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return messages.push({
+      type: "log",
+      args
+    });
+  };
+  console.warn = function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return messages.push({
+      type: "warn",
+      args
+    });
+  };
+  console.error = function () {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return messages.push({
+      type: "error",
+      args
+    });
+  };
+  return {
+    messages,
+    restore: () => {
+      console.log = original.log;
+      console.warn = original.warn;
+      console.error = original.error;
+      onRestored == null ? void 0 : onRestored(messages);
+    }
+  };
+}
+exports.DEFAULT_BROWSERSLIST_QUERY = DEFAULT_BROWSERSLIST_QUERY;
+exports.DEFAULT_PKG_EXT_MAP = DEFAULT_PKG_EXT_MAP;
+exports.createConsoleSpy = createConsoleSpy;
+exports.getPkgExtMap = getPkgExtMap;
+exports.loadConfig = loadConfig;
+exports.loadPkg = loadPkg;
+exports.loadPkgWithReporting = loadPkgWithReporting;
+exports.loadTSConfig = loadTSConfig;
+exports.parseExports = parseExports;
+exports.resolveBuildContext = resolveBuildContext;
+exports.resolveConfigProperty = resolveConfigProperty;
+//# sourceMappingURL=consoleSpy-686c350b.cjs.map