@sanity/plugin-kit 6.0.3 → 6.0.4

package/dist/_chunks-es/package.js

@@ -1,1066 +0,0 @@
-import fs from "fs";
-import path from "path";
-import util from "util";
-import githubUrlToObject from "github-url-to-object";
-import validateNpmPackageName from "validate-npm-package-name";
-import { createRequire } from "node:module";
-import chalk from "chalk";
-import outdent from "outdent";
-import { log, urls, minPkgUtilsMajor, requiredNodeEngine, incompatiblePluginPackage, cliName } from "./index.js";
-import crypto from "crypto";
-import json5 from "json5";
-import pAny from "p-any";
-import { URL } from "url";
-import inquirer from "inquirer";
-import { pkg } from "./package2.js";
-import { getLatestVersion } from "get-latest-version";
-import pProps from "p-props";
-const mergedPackages = [
-  "@sanity/base",
-  "@sanity/core",
-  "@sanity/types",
-  "@sanity/data-aspects",
-  "@sanity/default-layout",
-  "@sanity/default-login",
-  "@sanity/desk-tool",
-  "@sanity/field",
-  "@sanity/form-builder",
-  "@sanity/initial-value-templates",
-  "@sanity/language-filter",
-  "@sanity/production-preview",
-  "@sanity/react-hooks",
-  "@sanity/resolver",
-  "@sanity/state-router",
-  "@sanity/structure",
-  "@sanity/studio-hints"
-].sort(), deprecatedDevDeps = [
-  "tsdx",
-  "sanipack",
-  "parcel",
-  "@parcel/packager-ts",
-  "@parcel/transformer-typescript-types"
-], buildExtensions = [".js", ".jsx", ".es6", ".es", ".mjs", ".ts", ".tsx"];
-async function prompt(message, options) {
-  const type = options.choices ? "list" : options.type, result = await inquirer.prompt([{ ...options, type, message, name: "single" }]);
-  return result && result.single;
-}
-prompt.separator = () => new inquirer.Separator();
-function promptForPackageName({ basePath }, defaultVal) {
-  return prompt("Plugin name (sanity-plugin-...)", {
-    default: defaultVal || path.basename(basePath),
-    filter: (name) => {
-      const prefixless = name.trim().replace(/^sanity-plugin-/, "");
-      return name[0] === "@" ? name : `sanity-plugin-${prefixless}`;
-    },
-    validate: (name) => {
-      const valid = validateNpmPackageName(name);
-      return valid.errors ? valid.errors[0] : name[0] !== "@" && name.endsWith("plugin") ? `Name shouldn't include "plugin" multiple times (${name})` : !0;
-    }
-  });
-}
-function promptForRepoOrigin(_options, defaultVal) {
-  return prompt("Git repository URL", {
-    default: defaultVal,
-    filter: (raw) => {
-      const url = (raw || "").trim(), gh = githubUrlToObject(url);
-      return gh ? `git+ssh://git@github.com/${gh.user}/${gh.repo}.git` : url;
-    },
-    validate: (url) => {
-      if (!url)
-        return !0;
-      try {
-        return new URL(url) ? !0 : "Invalid URL";
-      } catch {
-        return "Invalid URL";
-      }
-    }
-  });
-}
-const stat$1 = util.promisify(fs.stat), mkdir = util.promisify(fs.mkdir), readdir = util.promisify(fs.readdir), copyFile = util.promisify(fs.copyFile), readFile$2 = util.promisify(fs.readFile), writeFile = util.promisify(fs.writeFile);
-function hasSourceEquivalent(compiledFile, paths) {
-  if (!paths.source)
-    return fileExists(
-      path.isAbsolute(compiledFile) ? compiledFile : path.resolve(paths.basePath, compiledFile)
-    );
-  const baseDir = path.dirname(compiledFile.replace(paths.compiled, paths.source)), baseName = path.basename(compiledFile, path.extname(compiledFile)), pathStub = path.join(baseDir, baseName);
-  return buildCandidateExists(pathStub);
-}
-async function hasSourceFile(filePath, paths) {
-  if (!paths?.source)
-    return fileExists(
-      path.isAbsolute(filePath) ? filePath : path.resolve(paths?.basePath ?? "", filePath)
-    );
-  const pathStub = path.isAbsolute(filePath) ? filePath : path.resolve(paths.source, filePath);
-  return await fileExists(pathStub) ? !0 : buildCandidateExists(pathStub);
-}
-function hasCompiledFile(filePath, paths) {
-  if (!paths?.compiled)
-    return fileExists(
-      path.isAbsolute(filePath) ? filePath : path.resolve(paths?.basePath ?? "", filePath)
-    );
-  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(paths.compiled, filePath), withExt = path.extname(absPath) === "" ? `${absPath}.js` : absPath;
-  return fileExists(withExt);
-}
-function buildCandidateExists(pathStub) {
-  const candidates = buildExtensions.map((extCandidate) => `${pathStub}${extCandidate}`);
-  return pAny(candidates.map((candidate) => stat$1(candidate))).then(() => !0).catch(() => !1);
-}
-function fileExists(filePath) {
-  return stat$1(filePath).then(() => !0).catch(() => !1);
-}
-async function readJsonFile(filePath) {
-  const content = await readFile$2(filePath, "utf8");
-  return JSON.parse(content);
-}
-function writeJsonFile(filePath, content) {
-  const data = JSON.stringify(content, null, 2) + `
-`;
-  return writeFile(filePath, data, { encoding: "utf8" });
-}
-async function writeFileWithOverwritePrompt(filePath, content, options) {
-  const { default: defaultVal, force = !1, ...writeOptions } = options, printablePath = filePath.startsWith(process.cwd()) ? path.relative(process.cwd(), filePath) : filePath;
-  return await fileEqualsData(filePath, content) || !force && await fileExists(filePath) && !await prompt(`File "${printablePath}" already exists. Overwrite?`, {
-    type: "confirm",
-    default: defaultVal
-  }) ? !1 : (await writeFile(filePath, content, writeOptions), !0);
-}
-async function copyFileWithOverwritePrompt(from, to, flags) {
-  const printablePath = to.startsWith(process.cwd()) ? path.relative(process.cwd(), to) : to;
-  return await filesAreEqual(from, to) || (await ensureDirectoryExists(to), !flags.force && await fileExists(to) && !await prompt(`File "${printablePath}" already exists. Overwrite?`, {
-    type: "confirm",
-    default: !1
-  })) ? !1 : (await copyFile(from, to), !0);
-}
-async function ensureDirectoryExists(filePath) {
-  const dirname = path.dirname(filePath);
-  await fileExists(dirname) || (await ensureDirectoryExists(dirname), await mkdir(dirname));
-}
-async function fileEqualsData(filePath, content) {
-  const contentHash = crypto.createHash("sha1").update(content).digest("hex"), remoteHash = await getFileHash(filePath);
-  return contentHash === remoteHash;
-}
-async function filesAreEqual(file1, file2) {
-  const [hash1, hash2] = await Promise.all([getFileHash(file1, !1), getFileHash(file2)]);
-  return hash1 === hash2;
-}
-function getFileHash(filePath, allowMissing = !0) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash("sha1"), stream = fs.createReadStream(filePath);
-    stream.on("error", (err) => {
-      err.code === "ENOENT" && allowMissing ? resolve(null) : reject(err);
-    }), stream.on("end", () => resolve(hash.digest("hex"))), stream.on("data", (chunk) => hash.update(chunk));
-  });
-}
-async function ensureDir(dirPath) {
-  try {
-    await mkdir(dirPath);
-  } catch (err) {
-    if (err.code !== "EEXIST")
-      throw err;
-  }
-}
-async function isEmptyish(dirPath) {
-  const ignoredFiles = [".git", ".gitignore", "license", "readme.md"];
-  return (await readdir(dirPath).catch(() => [])).filter((file) => !ignoredFiles.includes(file.toLowerCase())).length === 0;
-}
-async function readFileContent({
-  filename,
-  basePath
-}) {
-  const filepath = path.normalize(path.join(basePath, filename));
-  try {
-    return await readFile$2(filepath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      log.debug(`No ${filename} file found.`);
-      return;
-    }
-    throw new Error(`Failed to read "${filepath}": ${err.message}`);
-  }
-}
-async function readJson5File({
-  filename,
-  basePath
-}) {
-  const content = await readFileContent({ filename, basePath });
-  if (content)
-    return parseJson5(content, filename);
-}
-function parseJson5(content, errorKey) {
-  try {
-    return json5.parse(content);
-  } catch (err) {
-    throw new Error(`Error parsing "${errorKey}": ${err.message}`);
-  }
-}
-const expectedScripts = {
-  build: "plugin-kit verify-package --silent && pkg-utils build --strict --check --clean",
-  watch: "pkg-utils watch --strict",
-  "link-watch": "plugin-kit link-watch",
-  prepublishOnly: "npm run build"
-};
-function filesWithSuffixes(fileBases, suffixes) {
-  return fileBases.flatMap((file) => suffixes.map((suffix) => `${file}.${suffix}`));
-}
-function validateNodeEngine(packageJson) {
-  return packageJson.engines?.node !== requiredNodeEngine ? [
-    outdent`
-        Expected package.json to contain engines.node: "${requiredNodeEngine}" to match @sanity/pkg-utils,
-        but it was: ${packageJson.engines?.node}
-
-        Please add the following to package.json:
-
-        "engines": {
-          "node": "${requiredNodeEngine}"
-        }`.trimStart()
-  ] : [];
-}
-function validateScripts(packageJson) {
-  const errors = [], divergentScripts = Object.entries(expectedScripts).filter(([key, expectedCommand]) => {
-    const command = packageJson.scripts?.[key];
-    return !command || !command.includes(expectedCommand);
-  });
-  return divergentScripts.length && errors.push(
-    outdent`
-      The following script commands did not contain expected defaults: ${divergentScripts.map(([key]) => key).join(", ")}
-
-      This checks for that the commands-strings includes these terms.
-
-      Please add the following to your package.json "scripts":
-
-      ${divergentScripts.map(([key, value]) => `"${key}": "${value}"`).join(`,
-`)}
-  `.trimStart()
-  ), errors;
-}
-async function validateTsConfig(ts, options) {
-  const { basePath, outDir, tsconfig } = options, errors = [], wrongEntries = Object.entries({
-    target: "esnext",
-    jsx: "preserve",
-    module: "preserve",
-    rootDir: ".",
-    outDir,
-    noEmit: !0
-  }).filter(([key, value]) => {
-    let option = ts.options[key];
-    return key === "rootDir" && typeof option == "string" && (option = path.relative(basePath, option) || "."), key === "outDir" && typeof option == "string" && (option = path.relative(basePath, option) || "."), key === "target" && option === 99 && (option = "esnext"), key === "module" && option === 200 && (option = "preserve"), key === "jsx" && option === 1 && (option = "preserve"), typeof value == "string" && typeof option == "string" ? value.toLowerCase() !== option?.toLowerCase() : value !== option;
-  });
-  if (wrongEntries.length) {
-    const expectedOutput = wrongEntries.map(([key, value]) => `"${key}": ${typeof value == "string" ? `"${value}"` : value},`).join(`
-`);
-    errors.push(
-      outdent`
-        Recommended ${tsconfig} compilerOptions missing:
-
-        The following fields had unexpected values: [${wrongEntries.map(([key]) => key).join(", ")}]
-        Expected to find these values:
-        ${expectedOutput}
-
-        Please update your ${tsconfig} accordingly.
-      `.trimStart()
-    );
-  }
-  return errors;
-}
-function validatePackageType({ type }) {
-  return type === "module" ? [] : [
-    outdent`
-      package.json must set "type": "module" — plugins built with @sanity/plugin-kit are ESM-only.
-      Found: ${type ? `"type": "${type}"` : 'no "type" field (defaults to "commonjs")'}
-
-      Please add the following to package.json:
-
-      "type": "module"
-  `.trimStart()
-  ];
-}
-function findRequireConditions(node, pathSegments) {
-  if (Array.isArray(node))
-    return node.flatMap(
-      (entry, index) => findRequireConditions(entry, [...pathSegments, String(index)])
-    );
-  if (!node || typeof node != "object")
-    return [];
-  const found = [];
-  for (const [key, value] of Object.entries(node))
-    key === "require" && found.push(formatExportsPath(pathSegments)), found.push(...findRequireConditions(value, [...pathSegments, key]));
-  return found;
-}
-function formatExportsPath(segments) {
-  return `exports${segments.map((segment) => `[${JSON.stringify(segment)}]`).join("")}`;
-}
-function validateEsmOnly(packageJson) {
-  const offenders = [];
-  typeof packageJson.main < "u" && offenders.push(`- the top-level "main" field (${JSON.stringify(packageJson.main)})`), typeof packageJson.module < "u" && offenders.push(`- the top-level "module" field (${JSON.stringify(packageJson.module)})`);
-  const requireConditions = [...new Set(findRequireConditions(packageJson.exports, []))];
-  for (const conditionPath of requireConditions)
-    offenders.push(`- a "require" export condition at ${conditionPath}`);
-  return offenders.length ? [
-    outdent`
-      package.json ships CommonJS (CJS) output, but Sanity plugins target Sanity Studio v5+, which is pure ESM.
-
-      Remove the following so the package stays ESM-only:
-      ${offenders.join(`
-`)}
-
-      Supporting CJS is not worth it:
-      - It can have unintended side-effects.
-      - The Node.js versions plugin-kit supports (${requiredNodeEngine}) fully support require(esm), so a
-        consumer that still uses require() loads the ESM build directly — which is far more predictable.
-      - Publishing a single format guarantees two copies of the plugin's code (ESM + CJS) can't both end up
-        in the module tree, bloating bundles and slowing down builds.
-
-      Rely on "exports" together with "type": "module", and drop "main", "module" and any "require" conditions.
-  `.trimStart()
-  ] : [];
-}
-function validatePkgUtilsDependency({ devDependencies }) {
-  return devDependencies?.["@sanity/pkg-utils"] ? [] : [
-    outdent`
-        package.json does not list @sanity/pkg-utils as a devDependency.
-        @sanity/pkg-utils replaced parcel as the recommended build tool in @sanity/plugin-kit 2.0.0
-
-        Please add it by running 'npm install --save-dev @sanity/pkg-utils'.
-    `.trimStart()
-  ];
-}
-function validatePkgUtilsVersion({ basePath }) {
-  const require2 = createRequire(path.join(basePath, "package.json"));
-  let installedVersion;
-  try {
-    installedVersion = require2("@sanity/pkg-utils/package.json").version;
-  } catch {
-    return [
-      outdent`
-        @sanity/pkg-utils is not installed.
-        plugin-kit loads package.config.ts through @sanity/pkg-utils (a peer dependency).
-
-        Please install it by running 'npm install --save-dev @sanity/pkg-utils'.
-    `.trimStart()
-    ];
-  }
-  const major = Number.parseInt(installedVersion?.split(".")[0] ?? "", 10);
-  return !Number.isFinite(major) || major < minPkgUtilsMajor ? [
-    outdent`
-        @sanity/pkg-utils ${installedVersion} is too old.
-        plugin-kit requires @sanity/pkg-utils >=${minPkgUtilsMajor} to load package.config.ts.
-
-        Please upgrade it by running 'npm install --save-dev @sanity/pkg-utils@latest'.
-    `.trimStart()
-  ] : [];
-}
-function validateSanityDependencies(packageJson) {
-  const { dependencies, devDependencies, peerDependencies } = packageJson, allDependencies = { ...dependencies, ...devDependencies, ...peerDependencies }, illegalDeps = Object.keys(allDependencies).filter((dep) => mergedPackages.includes(dep)), unique = [...new Set(illegalDeps).values()];
-  return unique.length ? [
-    outdent`
-        package.json depends on "@sanity/*" packages that have moved into "sanity" package.
-
-        The following dependencies should be replaced with "sanity":
-        - ${unique.join(`
-- `)}
-
-        Refer to the reference docs to find replacement imports:
-        ${urls.refDocs}
-    `.trimStart()
-  ] : [];
-}
-function validateDeprecatedDependencies(packageJson) {
-  const { dependencies, devDependencies, peerDependencies } = packageJson, allDependencies = { ...dependencies, ...devDependencies, ...peerDependencies }, illegalDeps = Object.keys(allDependencies).filter((dep) => deprecatedDevDeps.includes(dep)), unique = [...new Set(illegalDeps).values()];
-  return unique.length ? [
-    outdent`
-        package.json contains deprecated dependencies that should be removed:
-        - ${unique.join(`
-- `)}
-    `.trimStart()
-  ] : [];
-}
-async function validateBabelConfig({ basePath }) {
-  const filenames = [".babelrc", ...filesWithSuffixes([".babelrc", "babel.config"], ["json", "js", "cjs", "mjs"])], babelFiles = [];
-  for (const filename of filenames) {
-    const filepath = path.normalize(path.join(basePath, filename));
-    await fileExists(filepath) && babelFiles.push(filename);
-  }
-  return babelFiles.length ? [
-    outdent`
-        Found babel-config file: [${babelFiles.join(
-      ", "
-    )}]. When using default @sanity/plugin-kit build command,
-        this is probably not needed.
-
-        Delete the file, or disable this check.
-      `.trimStart()
-  ] : [];
-}
-async function validateStudioConfig({ basePath }) {
-  const suffixes = ["ts", "js", "tsx", "jsx"], filenames = filesWithSuffixes(["sanity.config", "sanity.cli"], suffixes), files = {};
-  for (const filename of filenames) {
-    const filepath = path.normalize(path.join(basePath, filename));
-    files[filename] = await fileExists(filepath);
-  }
-  const sanityJson = await readJson5File({ basePath, filename: "sanity.json" }), hasConfigFile = (fileBase) => filesWithSuffixes([fileBase], suffixes).some((filename) => files[filename]), hasCliConfig = hasConfigFile("sanity.cli"), hasStudioConfig = hasConfigFile("sanity.config"), errors = [];
-  if (sanityJson) {
-    const info = [
-      outdent`
-        Found sanity.json. This file is not used by Sanity Studio V3.
-
-        Please consult the Studio V3 migration guide:
-         ${urls.migrationGuideStudio}
-        It will detail how to convert sanity.json to sanity.config.ts (or .js) and sanity.cli.ts (or .js) equivalents.
-      `.trimStart(),
-      sanityJson.plugins?.length && outdent`
-        For V3 versions and alternatives to V2 plugins, please refer to the Sanity Exchange:
-        ${urls.sanityExchange}
-      `.trimStart()
-    ].filter((s) => !!s);
-    errors.push(info.join(`
-
-`));
-  }
-  return hasCliConfig || errors.push(
-    outdent`
-        sanity.cli.(${suffixes.join(
-      " | "
-    )}) missing. Please create a file named sanity.cli.ts with the following content:
-
-        ${chalk.green(
-      outdent`
-        import {createCliConfig} from 'sanity/cli'
-
-        export default createCliConfig({
-          api: {
-            projectId: '${sanityJson?.api?.projectId ?? "project-id"}',
-            dataset: '${sanityJson?.api?.dataset ?? "dataset"}',
-          }
-        })`
-    )}
-
-        Make sure to replace the projectId and dataset fields with your own.
-
-        For more, see ${urls.migrationGuideStudio}
-    `.trimStart()
-  ), hasStudioConfig || errors.push(
-    outdent`
-        sanity.config.(${suffixes.join(
-      " | "
-    )}) missing. At a minimum sanity.config.ts should contain:
-
-        ${chalk.green(
-      outdent`
-            import { defineConfig } from "sanity"
-            import { deskTool } from "sanity/desk"
-
-            export default defineConfig({
-              name: "default",
-
-              projectId: '${sanityJson?.api?.projectId ?? "project-id"}',
-              dataset: '${sanityJson?.api?.dataset ?? "dataset"}',
-
-              plugins: [
-                deskTool(),
-              ],
-
-              schema: {
-                types: [
-                  /* put your v2 schema-types here */
-                ],
-              },
-            })`
-    ).trimStart()}
-
-        Make sure to replace the projectId and dataset fields with your own.
-
-        For more, see ${urls.migrationGuideStudio}
-    `.trimStart()
-  ), errors.length ? [errors.join(`
-
----
-
-`)] : [];
-}
-async function validateIncompatiblePlugin({
-  basePath,
-  packageJson
-}) {
-  const { dependencies, devDependencies, peerDependencies } = packageJson, inDependencies = !!(dependencies?.[incompatiblePluginPackage] || devDependencies?.[incompatiblePluginPackage] || peerDependencies?.[incompatiblePluginPackage]), hasShimFile = await fileExists(path.normalize(path.join(basePath, "v2-incompatible.js"))), sanityJsonReferencesShim = !!(await readJson5File({ basePath, filename: "sanity.json" }))?.parts?.some(
-    (part) => part?.path?.includes("v2-incompatible")
-  );
-  if (!inDependencies && !hasShimFile && !sanityJsonReferencesShim)
-    return [];
-  const found = [
-    inDependencies ? `- "${incompatiblePluginPackage}" listed in package.json` : null,
-    hasShimFile ? "- the v2-incompatible.js file" : null,
-    sanityJsonReferencesShim ? "- a sanity.json referencing v2-incompatible.js" : null
-  ].filter((e) => !!e);
-  return [
-    outdent`
-      ${incompatiblePluginPackage} is no longer used and should be removed.
-
-      It only rendered an error dialog in the long end-of-life Sanity Studio v2 when a v3 plugin was
-      installed there. That compatibility shim is now obsolete, so plugin-kit no longer adds it.
-
-      Found:
-      ${found.join(`
-`)}
-
-      To fix this:
-      - Remove "${incompatiblePluginPackage}" from package.json (dependencies/devDependencies/peerDependencies)
-      - Delete the v2-incompatible.js file
-      - Delete sanity.json (if it only contains the v2-incompatible "part")
-      - Remove "sanity.json" and "v2-incompatible.js" from the package.json "files" array
-
-      For more, see ${urls.incompatiblePlugin}
-    `.trimStart()
-  ];
-}
-function validatePackageName$1(packageJson) {
-  const valid = validateNpmPackageName(packageJson.name ?? "");
-  return valid.validForNewPackages ? !packageJson.name?.startsWith("@") && !packageJson.name?.startsWith("sanity-plugin-") ? [
-    'Invalid package.json: "name" should be prefixed with "sanity-plugin-" (or scoped - @your-company/plugin-name)'
-  ] : [] : [`Invalid package.json: "name" is invalid: ${(valid.errors ?? valid.warnings ?? []).join(", ")}`];
-}
-function validateBannedFiles(packageJson) {
-  const { files } = packageJson;
-  return Array.isArray(files) ? files.some((entry) => typeof entry != "string" ? !1 : entry.trim().replace(/^\.?\/+/, "").replace(/\/+$/, "") === "src") ? [
-    outdent`
-      package.json "files" must not include "src".
-
-      Plugins built with @sanity/plugin-kit publish the compiled output in "dist" (and any v2-compatibility files).
-      Shipping the "src" directory bloats the published package and can cause bundlers that resolve the
-      "source" export condition to import raw, uncompiled TypeScript.
-
-      Please remove "src" from the "files" array in package.json.
-    `.trimStart()
-  ] : [] : [];
-}
-async function validateSrcIndexFile(basePath) {
-  const paths = ["index.js", "index.ts"].map((p) => path.join("src", p)), allowedIndexFiles = paths.map((file) => path.join(basePath, file));
-  let hasIndex = !1;
-  for (const indexFile of allowedIndexFiles)
-    hasIndex = hasIndex || await fileExists(indexFile);
-  return hasIndex ? [] : [
-    outdent`
-      Expected one of [${paths.join(", ")}] to exist.
-
-      @sanity/pkg-utils expects a non-jsx file to be the source entry-point for the plugin.
-      If you currently have JSX in your index file, extract it into a separate file and import it.
-      `
-  ];
-}
-async function disallowDuplicateConfig({
-  basePath,
-  pkgJson,
-  configKey,
-  files
-}) {
-  const found = [];
-  for (const file of files) {
-    const filePath = path.join(basePath, file);
-    await fileExists(filePath) && found.push(file);
-  }
-  return found.length > 1 ? [
-    outdent`
-      Found multiple config files that serve the same purpose: [${found.join(", ")}].
-
-      There should be at most one of these files. Delete the rest.
-      `
-  ] : found.length && pkgJson[configKey] ? [
-    outdent`
-      package.json contains ${configKey}, but there also exists a config file that serves the same purpose.
-      Config file: ${found.join("")}]
-
-      Either delete the file or remove ${configKey} entry from package.json.
-      `
-  ] : [];
-}
-async function disallowDuplicateEslintConfig(basePath, pkgJson) {
-  return disallowDuplicateConfig({
-    basePath,
-    pkgJson,
-    configKey: "eslint",
-    files: [
-      ".eslintrc",
-      ".eslintrc.js",
-      ".eslintrc.cjs",
-      ".eslintrc.yaml",
-      ".eslintrc.yml",
-      ".eslintrc.json"
-    ]
-  });
-}
-async function disallowDuplicatePrettierConfig(basePath, pkgJson) {
-  return disallowDuplicateConfig({
-    basePath,
-    pkgJson,
-    configKey: "prettier",
-    files: [
-      ".prettierrc",
-      ".prettierrc.json5",
-      ".prettierrc.json",
-      ".prettierrc.yaml",
-      ".prettierrc.yml",
-      ".prettierrc.js",
-      ".prettierrc.cjs",
-      ".prettier.config,js",
-      ".prettier.config.cjs",
-      ".prettierrc.toml"
-    ]
-  });
-}
-const forcedPackageVersions = {}, forcedDevPackageVersions = {}, forcedPeerPackageVersions = {
-  react: "^18",
-  "react-dom": "^18",
-  "@types/react": "^18",
-  "@types/react-dom": "^18",
-  sanity: "^5 || ^6.0.0-0",
-  "styled-components": "^5.2"
-};
-function errorToUndefined(err) {
-  if (err instanceof TypeError)
-    throw err;
-}
-const stat = util.promisify(fs.stat), readFile$1 = util.promisify(fs.readFile), allowedPartProps = ["name", "implements", "path", "description"], disallowedPluginProps = ["api", "project", "plugins", "env"];
-async function getPaths(options) {
-  const { basePath } = options, manifest = await readManifest(options);
-  return manifest.paths ? absolutifyPaths(manifest.paths, basePath) : null;
-}
-function absolutifyPaths(paths, basePath) {
-  const getPath = (relative) => relative ? path.resolve(path.join(basePath, relative)) : void 0;
-  return paths ? {
-    basePath,
-    compiled: getPath(paths.compiled),
-    source: getPath(paths.source)
-  } : { basePath };
-}
-async function readManifest(options) {
-  const { basePath, validate = !0 } = options, manifestPath = path.normalize(path.join(basePath, "sanity.json"));
-  let content;
-  try {
-    content = await readFile$1(manifestPath, "utf8");
-  } catch (err) {
-    throw err.code === "ENOENT" ? new Error(
-      `No sanity.json found. sanity.json is required for plugins to function. Use \`${pkg.binname} init\` for a new plugin, or create an empty \`sanity.json\` with an empty object (\`{}\`) for existing ones.`
-    ) : new Error(`Failed to read "${manifestPath}": ${err.message}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Error parsing "${manifestPath}": ${err.message}`);
-  }
-  return validate && await validateManifest(parsed, options), parsed;
-}
-async function validateManifest(manifest, opts) {
-  const options = { isPlugin: !0, ...opts };
-  if (!isObject$1(manifest))
-    throw new Error("Invalid sanity.json: Root must be an object");
-  if (options.isPlugin ? await validatePluginManifest(manifest, options) : validateProjectManifest(manifest), "root" in manifest && typeof manifest.root != "boolean")
-    throw new Error('Invalid sanity.json: "root" property must be a boolean if declared');
-  await validateParts(manifest, {
-    ...options,
-    paths: absolutifyPaths(manifest.paths, options.basePath)
-  });
-}
-function validateProjectManifest(manifest) {
-  if ("paths" in manifest)
-    throw new Error('Invalid sanity.json: "paths" property has no meaning in a project manifest');
-}
-async function validatePluginManifest(manifest, options) {
-  const disallowed = Object.keys(manifest).filter((key) => disallowedPluginProps.includes(key)).map((key) => `"${key}"`);
-  if (disallowed.length > 0) {
-    const plural = disallowed.length > 1 ? "s" : "", joined = disallowed.join(", ");
-    throw new Error(
-      `Invalid sanity.json: Key${plural} ${joined} ${plural ? "are" : "is"} not allowed in a plugin manifest`
-    );
-  }
-  if (manifest.root)
-    throw new Error('Invalid sanity.json: "root" cannot be truthy in a plugin manifest');
-  await validatePaths$1(manifest, options);
-}
-async function validatePaths$1(manifest, options) {
-  if (!("paths" in manifest))
-    return;
-  if (!isObject$1(manifest.paths))
-    throw new Error('Invalid sanity.json: "paths" must be an object if declared');
-  if (typeof manifest.paths.compiled != "string")
-    throw new Error(
-      'Invalid sanity.json: "paths" must have a (string) "compiled" property if declared'
-    );
-  if (typeof manifest.paths.source != "string")
-    throw new Error(
-      'Invalid sanity.json: "paths" must have a (string) "source" property if declared'
-    );
-  const sourcePath = path.resolve(options.basePath, manifest.paths.source);
-  let srcStats;
-  try {
-    srcStats = await stat(sourcePath);
-  } catch (err) {
-    if (err.code === "ENOENT")
-      throw new Error(`sanity.json references "source" path which does not exist: "${sourcePath}"`);
-  }
-  if (!srcStats?.isDirectory())
-    throw new Error(
-      `sanity.json references "source" path which is not a directory: "${sourcePath}"`
-    );
-}
-async function validateParts(manifest, options) {
-  if (!("parts" in manifest))
-    return;
-  if (!Array.isArray(manifest.parts))
-    throw new Error('Invalid sanity.json: "parts" must be an array if declared');
-  let i = 0;
-  for (const part of manifest.parts)
-    await validatePart(part, i, options), i++;
-}
-async function validatePart(part, index, options) {
-  if (!isObject$1(part))
-    throw new Error(`Invalid sanity.json: "parts[${index}]" must be an object`);
-  validateAllowedPartKeys(part, index), validatePartStringValues(part, index), validatePartNames(part, index, options), await validatePartFiles(part, index, options);
-}
-async function validatePartFiles(part, index, options) {
-  const { verifyCompiledParts, verifySourceParts, paths } = options;
-  if (!part?.path)
-    return;
-  const ext = path.extname(part.path);
-  if (paths?.source && ext && ext !== ".js" && buildExtensions.includes(ext))
-    throw new Error(
-      `Invalid sanity.json: Part path has extension which is not applicable after compiling. ${ext} becomes .js after compiling. Specify filename without extension (${path.basename(
-        part.path
-      )}) (parts[${index}])`
-    );
-  if (!verifySourceParts && !verifyCompiledParts)
-    return;
-  const [srcExists, outDirExists] = await Promise.all([
-    hasSourceFile(part.path, paths),
-    verifyCompiledParts && hasCompiledFile(part.path, paths)
-  ]);
-  if (!srcExists)
-    throw new Error(
-      `Invalid sanity.json: Part path references file that does not exist in source directory (${paths?.source || paths?.basePath}) (parts[${index}])`
-    );
-  if (verifyCompiledParts && !outDirExists)
-    throw new Error(
-      `Invalid sanity.json: Part path references file ("${part.path}") that does not exist in compiled directory (${paths?.compiled}) (parts[${index}])`
-    );
-}
-function validatePartNames(part, index, options) {
-  const pluginName = options.pluginName ? options.pluginName.replace(/^sanity-plugin-/, "") : "";
-  if (!part?.name || !part?.name?.startsWith(`part:${pluginName}/`))
-    throw new Error(
-      `Invalid sanity.json: "name" must be prefixed with "part:${pluginName}/" - got "${part?.name}" (parts[${index}])`
-    );
-  if (!part?.implements?.startsWith("part:"))
-    throw new Error(
-      `Invalid sanity.json: "implements" must be prefixed with "part:" - got "${part?.implements}" (parts[${index}])`
-    );
-}
-function validateAllowedPartKeys(part, index) {
-  const disallowed = Object.keys(part).filter((key) => !allowedPartProps.includes(key)).map((key) => `"${key}"`);
-  if (disallowed.length > 0) {
-    const plural = disallowed.length > 1 ? "s" : "", joined = disallowed.join(", ");
-    throw new Error(
-      `Invalid sanity.json: Key${plural} ${joined} ${plural ? "are" : "is"} not allowed in a part declaration (parts[${index}])`
-    );
-  }
-}
-function validatePartStringValues(part, index) {
-  const nonStrings = Object.keys(part).filter((key) => typeof part[key] != "string").map((key) => `"${key}"`);
-  if (nonStrings.length > 0) {
-    const plural = nonStrings.length > 1 ? "s" : "", joined = nonStrings.join(", ");
-    throw new Error(
-      `Invalid sanity.json: Key${plural} ${joined} should be of type string (parts[${index}])`
-    );
-  }
-}
-function isObject$1(obj) {
-  return !Array.isArray(obj) && obj !== null && typeof obj == "object";
-}
-async function hasSanityJson(basePath) {
-  const file = await readJsonFile(path.join(basePath, "sanity.json")).catch(
-    errorToUndefined
-  );
-  return { exists: !!file, isRoot: !!(file && file.root) };
-}
-async function findStudioV3Config(basePath) {
-  const jsFile = "sanity.config.js";
-  if (await fileExists(path.join(basePath, jsFile)))
-    return { v3ConfigFile: jsFile };
-  const tsFile = "sanity.config.ts";
-  return { v3ConfigFile: await fileExists(path.join(basePath, tsFile)) ? tsFile : void 0 };
-}
-const lockedDependencies = {
-  "styled-components": "^6.1",
-  eslint: "^8.57.0"
-};
-function resolveLatestVersions(packages) {
-  const versions = {};
-  for (const pkgName of packages)
-    versions[pkgName] = pkgName in lockedDependencies ? lockedDependencies[pkgName] : "latest";
-  return pProps(
-    versions,
-    async (range, pkgName) => {
-      const version = await getLatestVersion(pkgName, { range });
-      if (!version)
-        throw new Error(`Found no version for ${pkgName}`);
-      return rangeify(version);
-    },
-    { concurrency: 8 }
-  );
-}
-function rangeify(version) {
-  return `^${version}`;
-}
-const defaultDependencies = [], defaultDevDependencies = [
-  "sanity",
-  // peer dependencies of `sanity`
-  "react",
-  "react-dom",
-  "styled-components"
-], defaultPeerDependencies = ["react", "sanity"], readFile = util.promisify(fs.readFile), pathKeys = ["main", "module", "browser", "types"];
-async function getPackage(opts) {
-  const options = { flags: {}, ...opts };
-  validateOptions(options);
-  const { basePath, validate = !0 } = options, manifestPath = path.normalize(path.join(basePath, "package.json"));
-  let content;
-  try {
-    content = await readFile(manifestPath, "utf8");
-  } catch (err) {
-    throw err.code === "ENOENT" ? new Error(
-      `No package.json found. package.json is required to publish to npm. Use \`${cliName} init\` for a new plugin, or \`npm init\` for an existing one`
-    ) : new Error(`Failed to read "${manifestPath}": ${err.message}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Error parsing "${manifestPath}": ${err.message}`);
-  }
-  if (!isObject(parsed))
-    throw new Error("Invalid package.json: Root must be an object");
-  return validate && await validatePackage(parsed, options), parsed;
-}
-async function validatePackage(manifest, opts) {
-  validateOptions(opts);
-  const options = { isPlugin: !0, ...opts };
-  options.isPlugin && await validatePluginPackage(manifest, options), validateLockFiles(options);
-}
-function validateOptions(opts) {
-  const options = opts || {};
-  if (!isObject(options))
-    throw new Error("Options must be an object");
-  if (typeof options.basePath != "string")
-    throw new Error('"options.basePath" must be a string (path to plugin base path)');
-}
-async function validatePluginPackage(manifest, options) {
-  validatePackageName(manifest), await validatePaths(manifest, options);
-}
-function validatePackageName(manifest) {
-  if (typeof manifest.name != "string")
-    throw new Error('Invalid package.json: "name" must be a string');
-  const valid = validateNpmPackageName(manifest.name);
-  if (!valid.validForNewPackages)
-    throw new Error(`Invalid package.json: "name" is invalid: ${(valid.errors ?? []).join(", ")}`);
-  if (manifest.name[0] !== "@" && !manifest.name.startsWith("sanity-plugin-"))
-    throw new Error(
-      'Invalid package.json: "name" should be prefixed with "sanity-plugin-" (or scoped - @your-company/plugin-name)'
-    );
-}
-async function validatePaths(manifest, options) {
-  const paths = await getPaths({
-    ...options,
-    pluginName: manifest.name ?? "unknown",
-    verifySourceParts: !1,
-    verifyCompiledParts: !1
-  }), abs = (file) => path.isAbsolute(file) ? file : path.resolve(path.join(options.basePath, file)), exists = (file) => fs.existsSync(abs(file)), willExist = (file) => paths && hasSourceEquivalent(abs(file), paths), withinSourceDir = (file) => paths?.source && abs(file).startsWith(paths.source), withinTargetDir = (file) => paths?.compiled && abs(file).startsWith(paths.compiled);
-  for (const key of pathKeys) {
-    if (!(key in manifest))
-      continue;
-    const manifestValue = manifest[key];
-    if (typeof manifestValue != "string")
-      throw new Error(`Invalid package.json: "${key}" must be a string if defined`);
-    if (!options?.flags?.allowSourceTarget && paths && withinSourceDir(manifestValue))
-      throw new Error(
-        `Invalid package.json: "${key}" points to file within source (uncompiled) directory. Use --allow-source-target if you really want to do this.`
-      );
-    if (exists(manifestValue) && paths && withinTargetDir(manifestValue) && !await willExist(manifestValue))
-      throw new Error(
-        `Invalid package.json: "${key}" points to file that will not exist after compiling`
-      );
-    if (!exists(manifestValue) && !await willExist(manifestValue)) {
-      if (!paths)
-        throw new Error(`Invalid package.json: "${key}" points to file that does not exist`);
-      const inOutDir = paths.compiled && !abs(manifestValue).startsWith(paths.compiled);
-      throw new Error(
-        inOutDir ? `Invalid package.json: "${key}" points to file that does not exist, and "paths" is not configured to compile to this location` : `Invalid package.json: "${key}" points to file that does not exist, and no equivalent is found in source directory`
-      );
-    }
-  }
-}
-function isObject(obj) {
-  return !Array.isArray(obj) && obj !== null && typeof obj == "object";
-}
-function validateLockFiles(options) {
-  const npm = fs.existsSync(path.join(options.basePath, "package-lock.json")), yarn = fs.existsSync(path.join(options.basePath, "yarn.lock"));
-  if (npm && yarn)
-    throw new Error("Invalid plugin: contains both package-lock.json and yarn.lock");
-}
-async function writePackageJson(data, options) {
-  const { user, pluginName, license, description, pkg: prevPkg, gitOrigin } = data, {
-    outDir,
-    peerDependencies: addPeers,
-    dependencies: addDeps,
-    devDependencies: addDevDeps
-  } = options, { flags } = options, prev = prevPkg || {}, usePrettier = flags.prettier !== !1, useEslint = flags.eslint !== !1, useTypescript = flags.eslint !== !1, newDevDependencies = [cliName, "@sanity/pkg-utils"];
-  useTypescript && (log.debug("Using TypeScript. Adding to dev dependencies."), newDevDependencies.push("@types/react", "typescript")), usePrettier && (log.debug("Using prettier. Adding to dev dependencies."), newDevDependencies.push("prettier", "prettier-plugin-packagejson")), useEslint && (log.debug("Using eslint. Adding to dev dependencies."), newDevDependencies.push(
-    "eslint",
-    "eslint-config-sanity",
-    "eslint-plugin-react",
-    "eslint-plugin-react-hooks"
-  ), usePrettier && newDevDependencies.push("eslint-config-prettier", "eslint-plugin-prettier"), useTypescript && newDevDependencies.push("@typescript-eslint/eslint-plugin", "@typescript-eslint/parser")), log.debug("Resolving latest versions for %s", newDevDependencies.join(", "));
-  const dependencies = forceDependencyVersions(
-    {
-      ...prev.dependencies || {},
-      ...addDeps || {},
-      ...await resolveLatestVersions(defaultDependencies)
-    },
-    forcedPackageVersions
-  ), devDependencies = forceDependencyVersions(
-    {
-      ...addDevDeps || {},
-      ...prev.devDependencies || {},
-      ...await resolveLatestVersions([...newDevDependencies, ...defaultDevDependencies])
-    },
-    forcedDevPackageVersions
-  ), peerDependencies = forceDependencyVersions(
-    {
-      ...prev.peerDependencies || {},
-      ...addPeers || {},
-      ...await resolveLatestVersions(defaultPeerDependencies)
-    },
-    forcedPeerPackageVersions
-  ), source = flags.typescript ? "./src/index.ts" : "./src/index.js", files = [outDir];
-  files.sort();
-  const forcedOrder = {
-    name: pluginName,
-    version: prev.version ?? "1.0.0",
-    description: description || "",
-    keywords: prev.keywords ?? ["sanity", "sanity-plugin"],
-    ...urlsFromOrigin(gitOrigin),
-    ...repoFromOrigin(gitOrigin),
-    license: license ? license.id : "UNLICENSED",
-    author: user?.email ? `${user.name} <${user.email}>` : user?.name,
-    sideEffects: !1,
-    type: "module",
-    exports: {
-      ".": {
-        source,
-        default: `./${outDir}/index.js`
-      },
-      "./package.json": "./package.json"
-    },
-    ...flags.typescript ? { types: `./${outDir}/index.d.ts` } : {},
-    files,
-    scripts: { ...prev.scripts },
-    dependencies: sortKeys(dependencies),
-    devDependencies: sortKeys(devDependencies),
-    peerDependencies: sortKeys(peerDependencies),
-    engines: {
-      node: requiredNodeEngine
-    }
-  }, manifest = {
-    ...forcedOrder,
-    // Use already configured values by default (if not otherwise specified)
-    ...prev || {},
-    // We're de-declaring properties because of key order in package.json
-    ...forcedOrder
-  }, differs = JSON.stringify(prev) !== JSON.stringify(manifest);
-  return log.debug("Does manifest differ? %s", differs ? "yes" : "no"), differs && await writePackageJsonDirect(manifest, options), differs ? manifest : prev;
-}
-function urlsFromOrigin(gitOrigin) {
-  if (!gitOrigin)
-    return {};
-  const details = githubUrlToObject(gitOrigin);
-  return details ? {
-    homepage: `https://github.com/${details.user}/${details.repo}#readme`,
-    bugs: {
-      url: `https://github.com/${details.user}/${details.repo}/issues`
-    }
-  } : {};
-}
-function repoFromOrigin(gitOrigin) {
-  return gitOrigin ? {
-    repository: {
-      type: "git",
-      url: gitOrigin
-    }
-  } : {};
-}
-function addScript(cmd, existing) {
-  return existing && existing.includes(cmd) ? existing : cmd;
-}
-async function addPackageJsonScripts(manifest, options, updateScripts) {
-  const originalScripts = manifest.scripts || {}, scripts = updateScripts({ ...originalScripts }), differs = Object.keys(scripts).some((key) => scripts[key] !== originalScripts[key]);
-  return differs && await writePackageJsonDirect({ ...manifest, scripts }, options), differs;
-}
-async function writePackageJsonDirect(manifest, { basePath }) {
-  await writeJsonFile(path.join(basePath, "package.json"), manifest);
-}
-async function addBuildScripts(manifest, options) {
-  return options.flags.scripts ? addPackageJsonScripts(manifest, options, (scripts) => (scripts.build = addScript(expectedScripts.build, scripts.build), scripts.format = addScript("prettier --write --cache --ignore-unknown .", scripts.format), scripts["link-watch"] = addScript(expectedScripts["link-watch"], scripts["link-watch"]), scripts.lint = addScript("eslint .", scripts.lint), scripts.prepublishOnly = addScript(expectedScripts.prepublishOnly, scripts.prepublishOnly), scripts.watch = addScript(expectedScripts.watch, scripts.watch), scripts)) : !1;
-}
-function sortKeys(unordered) {
-  return Object.keys(unordered).sort().reduce((obj, key) => (obj[key] = unordered[key], obj), {});
-}
-function forceDependencyVersions(deps, versions = forcedPackageVersions) {
-  const entries = Object.entries(deps).map((entry) => {
-    const [pkg2] = entry, forceVersion = versions[pkg2];
-    return forceVersion ? [pkg2, forceVersion] : entry;
-  });
-  return Object.fromEntries(entries);
-}
-export {
-  addBuildScripts,
-  addPackageJsonScripts,
-  addScript,
-  copyFileWithOverwritePrompt,
-  disallowDuplicateEslintConfig,
-  disallowDuplicatePrettierConfig,
-  ensureDir,
-  errorToUndefined,
-  fileExists,
-  findStudioV3Config,
-  forceDependencyVersions,
-  forcedDevPackageVersions,
-  forcedPackageVersions,
-  getPackage,
-  hasSanityJson,
-  isEmptyish,
-  mergedPackages,
-  mkdir,
-  prompt,
-  promptForPackageName,
-  promptForRepoOrigin,
-  readFile$2 as readFile,
-  readJsonFile,
-  resolveLatestVersions,
-  sortKeys,
-  validateBabelConfig,
-  validateBannedFiles,
-  validateDeprecatedDependencies,
-  validateEsmOnly,
-  validateIncompatiblePlugin,
-  validateNodeEngine,
-  validatePackageName$1 as validatePackageName,
-  validatePackageType,
-  validatePkgUtilsDependency,
-  validatePkgUtilsVersion,
-  validateSanityDependencies,
-  validateScripts,
-  validateSrcIndexFile,
-  validateStudioConfig,
-  validateTsConfig,
-  writeFile,
-  writeFileWithOverwritePrompt,
-  writePackageJson,
-  writePackageJsonDirect
-};
-//# sourceMappingURL=package.js.map