@sanity/plugin-kit 4.0.19 → 5.0.0

package/dist/_chunks-es/package.js

@@ -0,0 +1,1759 @@
+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 { URL, fileURLToPath } from "url";
+import licenses from "@rexxars/choosealicense-list";
+import gitRemoteOriginUrl from "git-remote-origin-url";
+import { log, urls, minPkgUtilsMajor, requiredNodeEngine, incompatiblePluginPackage, cliName } from "./index.js";
+import { createRequire } from "node:module";
+import chalk from "chalk";
+import outdent$1, { outdent } from "outdent";
+import crypto from "crypto";
+import json5 from "json5";
+import pAny from "p-any";
+import { pkg } from "./package2.js";
+import inquirer from "inquirer";
+import getLatestVersion from "get-latest-version";
+import pProps from "p-props";
+import { getIt } from "get-it";
+import { promise, jsonRequest, jsonResponse, httpErrors, headers } from "get-it/middleware";
+import { execSync } from "child_process";
+import { validate } from "email-validator";
+import xdgBasedir from "xdg-basedir";
+function eslintrcTemplate(options) {
+  const { flags } = options, eslintConfig = {
+    root: !0,
+    env: {
+      node: !0,
+      browser: !0
+    },
+    extends: [
+      "sanity",
+      flags.typescript && "sanity/typescript",
+      "sanity/react",
+      "plugin:react-hooks/recommended",
+      flags.prettier && "plugin:prettier/recommended",
+      "plugin:react/jsx-runtime"
+    ].filter(Boolean)
+  };
+  return {
+    type: "template",
+    force: flags.force,
+    to: ".eslintrc",
+    value: JSON.stringify(eslintConfig, null, 2)
+  };
+}
+function eslintignoreTemplate(options) {
+  const { flags, outDir } = options, patterns = [
+    ".eslintrc.js",
+    "commitlint.config.js",
+    outDir,
+    "lint-staged.config.js",
+    "package.config.ts",
+    flags.typescript ? "*.js" : ""
+  ].filter(Boolean);
+  return patterns.sort(), {
+    type: "template",
+    force: flags.force,
+    to: ".eslintignore",
+    value: patterns.join(`
+`)
+  };
+}
+function gitignoreTemplate() {
+  return {
+    type: "template",
+    to: ".gitignore",
+    value: outdent`
+      # Logs
+      logs
+      *.log
+      npm-debug.log*
+
+      # Runtime data
+      pids
+      *.pid
+      *.seed
+
+      # Directory for instrumented libs generated by jscoverage/JSCover
+      lib-cov
+
+      # Coverage directory used by tools like istanbul
+      coverage
+
+      # nyc test coverage
+      .nyc_output
+
+      # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+      .grunt
+
+      # node-waf configuration
+      .lock-wscript
+
+      # Compiled binary addons (http://nodejs.org/api/addons.html)
+      build/Release
+
+      # Dependency directories
+      node_modules
+      jspm_packages
+
+      # Optional npm cache directory
+      .npm
+
+      # Optional REPL history
+      .node_repl_history
+
+      # macOS finder cache file
+      .DS_Store
+
+      # VS Code settings
+      .vscode
+
+      # IntelliJ
+      .idea
+      *.iml
+
+      # Cache
+      .cache
+
+      # Yalc
+      .yalc
+      yalc.lock
+
+      # npm package zips
+      *.tgz
+    `
+  };
+}
+function pkgConfigTemplate(options) {
+  const { flags, outDir } = options;
+  return {
+    type: "template",
+    force: flags.force,
+    // Always a `.ts` config: plugins are ESM (`"type": "module"`), so `@sanity/pkg-utils`
+    // loads it without needing a `.mts`/`.mjs` extension to force ESM interpretation.
+    to: "package.config.ts",
+    value: outdent`
+      import {defineConfig} from '@sanity/pkg-utils'
+
+      export default defineConfig({
+        dist: '${outDir}',
+        tsconfig: 'tsconfig.${outDir}.json',
+
+        // Remove this block to enable strict export validation
+        extract: {
+          rules: {
+            'ae-incompatible-release-tags': 'off',
+            'ae-internal-missing-underscore': 'off',
+            'ae-missing-release-tag': 'off',
+          },
+        },
+      })
+    `
+  };
+}
+function prettierignoreTemplate(options) {
+  const { outDir } = options;
+  return {
+    type: "template",
+    to: ".prettierignore",
+    value: [outDir, "pnpm-lock.yaml", "yarn.lock", "package-lock.json"].join(`
+`)
+  };
+}
+function tsconfigTemplate(options) {
+  const { flags } = options;
+  return {
+    type: "template",
+    force: flags.force,
+    to: "tsconfig.json",
+    value: outdent`
+      {
+        "extends": "./tsconfig.settings",
+        "include": ["./src", "./package.config.ts"]
+      }
+    `
+  };
+}
+function tsconfigTemplateDist(options) {
+  const { flags, outDir } = options;
+  return {
+    type: "template",
+    force: flags.force,
+    to: `tsconfig.${outDir}.json`,
+    value: outdent`
+      {
+        "extends": "./tsconfig.settings",
+        "include": ["./src"],
+        "exclude": [
+          "./src/**/__fixtures__",
+          "./src/**/__mocks__",
+          "./src/**/*.test.ts",
+          "./src/**/*.test.tsx"
+        ]
+      }
+    `
+  };
+}
+function tsconfigTemplateSettings(options) {
+  const { flags, outDir } = options;
+  return {
+    type: "template",
+    force: flags.force,
+    to: "tsconfig.settings.json",
+    value: outdent`
+      {
+        "compilerOptions": {
+          "rootDir": ".",
+          "outDir": "./${outDir}",
+
+          "target": "esnext",
+          "jsx": "preserve",
+          "module": "preserve",
+          "moduleResolution": "bundler",
+          "esModuleInterop": true,
+          "resolveJsonModule": true,
+          "moduleDetection": "force",
+          "strict": true,
+          "allowSyntheticDefaultImports": true,
+          "skipLibCheck": true,
+          "forceConsistentCasingInFileNames": true,
+          "isolatedModules": true,
+
+          // Don't emit by default, pkg-utils will ignore this when generating .d.ts files
+          "noEmit": true
+        }
+      }
+    `
+  };
+}
+const renovatePreset = {
+  name: "renovatebot",
+  description: "Files to enable renovatebot.",
+  apply: applyPreset$3
+};
+async function applyPreset$3(options) {
+  await writeAssets(
+    [
+      {
+        type: "copy",
+        from: ["renovatebot", "renovate.json"],
+        to: "renovate.json"
+      }
+    ],
+    options
+  );
+}
+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}`;
+}
+function errorToUndefined(err) {
+  if (err instanceof TypeError)
+    throw err;
+}
+const buildExtensions = [".js", ".jsx", ".es6", ".es", ".mjs", ".ts", ".tsx"], stat$1 = util.promisify(fs.stat), readFile$2 = 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: validate2 = !0 } = options, manifestPath = path.normalize(path.join(basePath, "sanity.json"));
+  let content;
+  try {
+    content = await readFile$2(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 validate2 && 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$1(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 };
+}
+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 = util.promisify(fs.stat), mkdir = util.promisify(fs.mkdir), readdir = util.promisify(fs.readdir), copyFile = util.promisify(fs.copyFile), readFile$1 = 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(candidate))).then(() => !0).catch(() => !1);
+}
+function fileExists(filePath) {
+  return stat(filePath).then(() => !0).catch(() => !1);
+}
+async function readJsonFile(filePath) {
+  const content = await readFile$1(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$1(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 request = getIt([
+  promise({ onlyBody: !0 }),
+  jsonRequest(),
+  jsonResponse(),
+  httpErrors(),
+  headers({ "User-Agent": `${pkg.name}@${pkg.version}` })
+]);
+async function getUserInfo({ requireUserConfirmation, flags }, pkg2) {
+  const userInfo = getPackageUserInfo({ author: flags.author ?? pkg2?.author }) || await getSanityUserInfo() || await getGitUserInfo();
+  return requireUserConfirmation ? promptForInfo(userInfo) : userInfo;
+}
+function getPackageUserInfo(pkg2) {
+  let author = pkg2?.author;
+  if (!author)
+    return;
+  if (author && typeof author != "string")
+    return author;
+  if (!author.includes("@"))
+    return { name: author };
+  const [pre, ...post] = author.replace(/[<>[\]]/g, "").split(/@/), nameParts = pre.split(/\s+/), email = [nameParts[nameParts.length - 1], ...post].join("@");
+  return { name: nameParts.slice(0, -1).join(" "), email };
+}
+async function promptForInfo(defValue) {
+  const name = await prompt("Author name", {
+    filter: filterString,
+    default: defValue && defValue.name,
+    validate: requiredString
+  }), email = await prompt("Author email", {
+    filter: filterString,
+    default: defValue && defValue.email,
+    validate: validOrEmptyEmail
+  });
+  return { name, email };
+}
+async function getSanityUserInfo() {
+  try {
+    const token = (await readJsonFile(
+      path.join(xdgBasedir.config ?? "", "sanity", "config.json")
+    ))?.authToken;
+    if (!token)
+      return;
+    const user = await request({
+      url: "https://api.sanity.io/v1/users/me",
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!user)
+      return;
+    const { name, email } = user;
+    return { name, email };
+  } catch {
+    return;
+  }
+}
+async function getGitUserInfo() {
+  try {
+    const name = execSync("git config user.name", { encoding: "utf8" }).trim(), email = execSync("git config user.email", { encoding: "utf8" }).trim();
+    return name ? { name, email: email || void 0 } : void 0;
+  } catch {
+    return;
+  }
+}
+function filterString(val) {
+  return (val || "").trim();
+}
+function requiredString(value) {
+  return value.length > 1 ? !0 : "Required";
+}
+function validOrEmptyEmail(value) {
+  return value ? validate(value) ? !0 : "Must either be a valid email or empty" : !0;
+}
+function generateReadme(data) {
+  const { user, pluginName, license } = data;
+  return outdent$1`
+    # ${pluginName}
+
+
+    ${installationSnippet(pluginName ?? "unknown")}
+
+    ## Usage
+
+    Add it as a plugin in \`sanity.config.ts\` (or .js):
+
+    \`\`\`ts
+    import {defineConfig} from 'sanity'
+    import {myPlugin} from '${pluginName}'
+
+    export default defineConfig({
+      //...
+      plugins: [myPlugin({})],
+    })
+    \`\`\`
+
+    ${getLicenseText(license?.id, user?.name ? user : void 0)}
+    ${developTestSnippet()}
+  ` + `
+`;
+}
+function installationSnippet(packageName) {
+  return outdent$1`
+    ## Installation
+
+    \`\`\`sh
+    npm install ${packageName}
+    \`\`\`
+    `;
+}
+function developTestSnippet() {
+  return outdent$1`
+    ## Develop & test
+
+    This plugin uses [@sanity/plugin-kit](https://github.com/sanity-io/plugin-kit)
+    with default configuration for build & watch scripts.
+
+    See [Testing a plugin in Sanity Studio](https://github.com/sanity-io/plugin-kit#testing-a-plugin-in-sanity-studio)
+    on how to run this plugin with hotreload in the studio.
+  `;
+}
+function getLicenseText(licenseId, user) {
+  if (!licenseId)
+    return "";
+  let licenseName = licenses.find(licenseId).title;
+  licenseName = licenseName?.replace(/\s+license$/i, "");
+  let licenseText = `## License
+`;
+  return licenseName && user?.name ? licenseText = `${licenseText}
+[${licenseName}](LICENSE) \xA9 ${user?.name}
+` : licenseName ? licenseText = `${licenseText}
+[${licenseName}](LICENSE)
+` : licenseText = `${licenseText}
+See [LICENSE](LICENSE)`, licenseText;
+}
+function isDefaultGitHubReadme(readme) {
+  if (!readme)
+    return !1;
+  const lines = readme.split(`
+`, 20).filter(Boolean);
+  return lines.length <= 2 && lines[0].startsWith("#");
+}
+const semverWorkflowPreset = {
+  name: "semver-workflow",
+  description: "Files and dependencies for conventional-commits, github workflow and semantic-release.",
+  apply: applyPreset$2
+}, info = (write, msg, ...args) => write && log.info(msg, ...args);
+async function applyPreset$2(options) {
+  await writeAssets(semverWorkflowFiles(), options), await addPrepareScript(options), await addDevDependencies$2(options), await updateReadme(options);
+}
+async function addPrepareScript(options) {
+  const pkg2 = await getPackage(options), didWrite = await addPackageJsonScripts(pkg2, options, (scripts) => (scripts.prepare = addScript("husky", scripts.prepare), scripts));
+  info(didWrite, "Added prepare script to package.json");
+}
+async function addDevDependencies$2(options) {
+  const pkg2 = await getPackage(options), devDeps = sortKeys({
+    ...pkg2.devDependencies,
+    ...await semverWorkflowDependencies()
+  }), newPkg = { ...pkg2 };
+  newPkg.devDependencies = devDeps, await writePackageJsonDirect(newPkg, options), log.info("Updated devDependencies."), log.info(
+    chalk.green(
+      outdent$1`
+        semantic-release preset injected.
+
+        Please confer
+        https://github.com/sanity-io/plugin-kit/blob/main/docs/semver-workflow.md#manual-steps-after-inject
+        to finalize configuration for this preset.
+  `.trim()
+    )
+  );
+}
+async function updateReadme(options) {
+  const { basePath } = options, readmePath = path.join(basePath, "README.md"), readme = await readFile$1(readmePath, "utf8").catch(errorToUndefined) ?? "", { install, usage, developTest, license, releaseSnippet } = await readmeSnippets(options), prependSections = missingSections(readme, [install, usage]), appendSections = missingSections(readme, [license, developTest, releaseSnippet]);
+  if (prependSections.length || appendSections.length) {
+    const updatedReadme = [...prependSections, readme, ...appendSections].filter(Boolean).join(`
+
+`);
+    await writeFile(readmePath, updatedReadme, { encoding: "utf8" }), log.info("Updated README. Please review the changes.");
+  }
+}
+async function readmeSnippets(options) {
+  const pkg2 = await getPackage(options), user = await getUserInfo(options, pkg2), bestEffortUrl = readmeBaseurl(pkg2), install = installationSnippet(pkg2.name ?? "unknown"), usage = outdent$1`
+    ## Usage
+  `, license = getLicenseText(typeof pkg2.license == "string" ? pkg2.license : void 0, user), releaseSnippet = outdent$1`
+    ### Release new version
+
+    Run ["CI & Release" workflow](${bestEffortUrl}/actions/workflows/main.yml).
+    Make sure to select the main branch and check "Release new version".
+
+    Semantic release will only release on configured branches, so it is safe to run release on any branch.
+  `;
+  return {
+    install,
+    usage,
+    license,
+    developTest: developTestSnippet(),
+    releaseSnippet
+  };
+}
+function missingSections(readme, sections) {
+  return sections.filter((section) => !closeEnough(section, readme));
+}
+function closeEnough(a, b) {
+  const aLines = a.split(`
+`), bLines = b.split(`
+`);
+  return aLines.filter((line) => bLines.find((bLine) => bLine === line)).length >= aLines.length * 0.5;
+}
+function semverWorkflowFiles() {
+  return [
+    {
+      type: "copy",
+      from: [".github", "workflows", "main.yml"],
+      to: [".github", "workflows", "main.yml"]
+    },
+    { type: "copy", from: [".husky", "commit-msg"], to: [".husky", "commit-msg"] },
+    { type: "copy", from: [".husky", "pre-commit"], to: [".husky", "pre-commit"] },
+    { type: "copy", from: [".releaserc.json"], to: ".releaserc.json" },
+    { type: "copy", from: ["commitlint.template.js"], to: "commitlint.config.js" },
+    { type: "copy", from: ["lint-staged.template.js"], to: "lint-staged.config.js" }
+  ].map((fromTo) => fromTo.type === "copy" ? {
+    ...fromTo,
+    from: ["semver-workflow", ...fromTo.from]
+  } : fromTo);
+}
+async function semverWorkflowDependencies() {
+  return resolveLatestVersions([
+    "@commitlint/cli",
+    "@commitlint/config-conventional",
+    "@sanity/semantic-release-preset",
+    "husky",
+    "lint-staged"
+  ]);
+}
+function readmeBaseurl(pkg2) {
+  return (pkg2.repository?.url ?? pkg2.homepage ?? "TODO").replace(/.+:\/\//g, "https://").replace(/\.git/g, "").replace(/git@github.com\//g, "github.com/").replace(/git@github.com:/g, "https://github.com/").replace(/#.+/g, "");
+}
+const forcedPackageVersions = {}, forcedDevPackageVersions = {}, forcedPeerPackageVersions = {
+  react: "^18",
+  "react-dom": "^18",
+  "@types/react": "^18",
+  "@types/react-dom": "^18",
+  sanity: "^3",
+  "styled-components": "^5.2"
+}, ui = {
+  name: "ui",
+  description: "`@sanity/ui` and dependencies",
+  apply: applyPreset$1
+};
+async function applyPreset$1(options) {
+  await addDependencies(options), await addDevDependencies$1(options), log.info(chalk.green("ui preset injected"));
+}
+async function addDependencies(options) {
+  const pkg2 = await getPackage(options), newDeps = sortKeys(
+    forceDependencyVersions(
+      {
+        ...pkg2.dependencies,
+        ...await resolveDependencyList()
+      },
+      forcedPackageVersions
+    )
+  ), newPkg = { ...pkg2 };
+  newPkg.dependencies = newDeps, await writePackageJsonDirect(newPkg, options), log.info("Updated dependencies.");
+}
+async function addDevDependencies$1(options) {
+  const pkg2 = await getPackage(options), newDeps = sortKeys(
+    forceDependencyVersions(
+      {
+        ...pkg2.devDependencies,
+        ...await resolveDevDependencyList()
+      },
+      forcedDevPackageVersions
+    )
+  ), newPkg = { ...pkg2 };
+  newPkg.devDependencies = newDeps, await writePackageJsonDirect(newPkg, options), log.info("Updated devDependencies.");
+}
+async function resolveDependencyList() {
+  return resolveLatestVersions(["@sanity/icons", "@sanity/ui"]);
+}
+async function resolveDevDependencyList() {
+  return resolveLatestVersions([
+    // install the peer dependencies of `@sanity/ui` as dev dependencies
+    "react",
+    "react-dom",
+    "styled-components"
+  ]);
+}
+const uiWorkshop = {
+  name: "ui-workshop",
+  description: "Files for testing custom components with @sanity/ui-workshop",
+  apply: applyPreset
+};
+async function applyPreset(options) {
+  await writeAssets(files(), options), await addDevDependencies(options), await updateGitIgnore(options), log.info(
+    chalk.green(
+      outdent$1`
+        ui-workshop preset injected.
+
+        Please confer
+        https://github.com/sanity-io/plugin-kit/blob/main/docs/ui-workshop.md#manual-steps-after-inject
+        to finalize configuration for this preset.
+  `.trim()
+    )
+  );
+}
+function files() {
+  return [
+    { type: "copy", from: ["workshop.config.ts"], to: ["workshop.config.ts"] },
+    { type: "copy", from: ["src", "CustomField.tsx"], to: ["src", "CustomField.tsx"] },
+    {
+      type: "copy",
+      from: ["src", "__workshop__", "index.tsx"],
+      to: ["src", "__workshop__", "index.tsx"]
+    },
+    {
+      type: "copy",
+      from: ["src", "__workshop__", "props.tsx"],
+      to: ["src", "__workshop__", "props.tsx"]
+    }
+  ].map((fromTo) => fromTo.type === "copy" ? {
+    ...fromTo,
+    from: ["ui-workshop", ...fromTo.from]
+  } : fromTo);
+}
+async function updateGitIgnore(options) {
+  const { basePath } = options, gitignorePath = path.join(basePath, ".gitignore");
+  let gitignore = await readFile$1(gitignorePath, "utf8").catch(errorToUndefined) ?? "";
+  const value = ".workshop";
+  gitignore.includes(value) || (gitignore += `
+
+${value}`, await writeFile(gitignorePath, gitignore, { encoding: "utf8" }));
+}
+async function addDevDependencies(options) {
+  const pkg2 = await getPackage(options), devDeps = sortKeys({
+    ...pkg2.devDependencies,
+    ...await devDependencies()
+  }), newPkg = { ...pkg2 };
+  newPkg.devDependencies = devDeps, await writePackageJsonDirect(newPkg, options), log.info("Updated devDependencies.");
+}
+async function devDependencies() {
+  return resolveLatestVersions([
+    "@sanity/ui-workshop",
+    "@sanity/icons",
+    "@sanity/ui",
+    "react",
+    "react-dom",
+    "styled-components"
+  ]);
+}
+const presets = [semverWorkflowPreset, renovatePreset, ui, uiWorkshop], presetNames = presets.map((p) => p?.name);
+function presetHelpList(padStart) {
+  return presets.map((p) => `${"".padStart(padStart)}${p.name.padEnd(20)}${p.description}`).join(`
+`);
+}
+async function injectPresets(options) {
+  if (options.flags.presetOnly && !options.flags.preset?.length)
+    throw new Error("--preset-only, but no --preset [preset-name] was provided.");
+  const applyPresets = presetsFromInput(options.flags.preset);
+  for (const preset of applyPresets)
+    await preset.apply(options);
+}
+function presetsFromInput(inputPresets) {
+  if (!inputPresets)
+    return [];
+  const unknownPresets = inputPresets.filter((p) => !presetNames.includes(p));
+  if (unknownPresets.length)
+    throw new Error(
+      `Unknown --preset(s): [${unknownPresets.join(", ")}]. Must be one of: [${presetNames.join(
+        ", "
+      )}]`
+    );
+  return inputPresets.filter(onlyUnique).map((presetName) => presets.find((p) => p.name === presetName)).filter((p) => !!p);
+}
+function onlyUnique(value, index, arr) {
+  return arr.indexOf(value) === index;
+}
+const bannedFields = ["login", "description", "projecturl", "email"], preferredLicenses = ["MIT", "ISC", "BSD-3-Clause"], otherLicenses = Object.keys(licenses.list).filter((id) => {
+  const license = licenses.list[id];
+  return !preferredLicenses.includes(id) && !bannedFields.some((field) => license.body.includes(`[${field}]`));
+});
+async function inject(options) {
+  options.flags.presetOnly ? log.info("Only apply presets, skipping default inject.") : await injectBase(options), await injectPresets(options);
+}
+async function injectBase(options) {
+  const { basePath, flags, requireUserConfirmation } = options, info2 = (write, msg, ...args) => write && log.info(msg, ...args), pkg2 = await getPackage(options).catch(errorToUndefined);
+  log.debug("Plugin has package.json: %s", pkg2 ? "yes" : "no");
+  const user = await getUserInfo(options, pkg2);
+  log.debug("User information: %o", user);
+  const pkgName = flags.name ?? pkg2?.name, pluginName = requireUserConfirmation || !pkgName ? await promptForPackageName(options, pkgName) : pkgName;
+  log.debug("Plugin name: %s", pluginName);
+  const license = await getLicense(flags, { user, pluginName, pkg: pkg2, requireUserConfirmation }), licenseChanged = (pkg2 && pkg2.license) !== (license && license.id);
+  log.debug("License: %s", license ? license.id : "<none>");
+  const description = await getProjectDescription(basePath, pkg2, requireUserConfirmation);
+  log.debug("Description: %s", description || "<none>");
+  const repoUrl = flags.repo ?? (await gitRemoteOriginUrl(basePath).catch(errorToUndefined) || pkg2?.repository?.url), gitOrigin = requireUserConfirmation ? await promptForRepoOrigin(options, repoUrl) : repoUrl;
+  log.debug("Remote origin: %s", gitOrigin || "<none>");
+  const data = { user, pluginName, license, description, pkg: pkg2, gitOrigin };
+  let didWrite;
+  const newPkg = await writePackageJson(data, options);
+  info2(newPkg !== pkg2, "Wrote package.json"), data.pkg = newPkg, didWrite = await writeLicense(data, options, licenseChanged), info2(didWrite, "Wrote license file (LICENSE)"), didWrite = await writeReadme(data, options), info2(didWrite, "Wrote readme file (README.md)"), didWrite = await writeStaticAssets(options), info2(didWrite.length > 0, "Wrote static asset files: %s", didWrite.join(", ")), didWrite = await addBuildScripts(newPkg, options), info2(didWrite, "Added build scripts to package.json"), didWrite = await addCompileDirToGitIgnore(options), info2(didWrite, "Added compilation output directory to .gitignore");
+}
+async function writeReadme(data, options) {
+  const { basePath } = options, readmePath = path.join(basePath, "README.md"), readme = await readFile$1(readmePath, "utf8").catch(errorToUndefined);
+  return readme && !isDefaultGitHubReadme(readme) ? !1 : (await writeFileWithOverwritePrompt(readmePath, generateReadme(data), {
+    encoding: "utf8",
+    force: options.flags.force
+  }), !0);
+}
+async function writeLicense({ license }, options, licenseChanged) {
+  const { basePath, flags } = options;
+  if (flags.license === !1 || !license)
+    return !1;
+  const hasLicenseMdFile = await fileExists(path.join(basePath, "LICENSE.md")), licensePath = path.join(basePath, hasLicenseMdFile ? "LICENSE.md" : "LICENSE");
+  return await writeFileWithOverwritePrompt(licensePath, license.text, {
+    encoding: "utf8",
+    default: licenseChanged,
+    force: flags.force
+  }), !0;
+}
+async function getLicense(flags, {
+  user,
+  pluginName,
+  pkg: pkg2,
+  requireUserConfirmation
+}) {
+  const license = await getLicenseIdentifier(flags, pkg2, requireUserConfirmation);
+  if (!license)
+    return;
+  const text = license.body.replace(/\[fullname\]/g, user?.name).replace(/\[project\]/g, pluginName).replace(/\[year\]/g, (/* @__PURE__ */ new Date()).getFullYear());
+  return { id: license.id, text };
+}
+async function getLicenseIdentifier(flags, pkg2, requireUserConfirmation = !1) {
+  if (flags.license === !1)
+    return null;
+  if (typeof flags.license == "string") {
+    const license = licenses.find(`${flags.license}`);
+    if (!license)
+      throw new Error(`License "${flags.license}" not found`);
+    return license;
+  }
+  if (pkg2 && pkg2.license && !requireUserConfirmation) {
+    const license = licenses.find(`${pkg2.license}`);
+    if (license)
+      return license;
+    log.warn(`package.json contains license "${pkg2.license}", which is not recognized`);
+  }
+  const licenseId = await prompt("Which license do you want to use?", {
+    default: pkg2 && pkg2.license && licenses.find(pkg2.license) ? pkg2.license : preferredLicenses[0],
+    choices: [
+      prompt.separator(),
+      ...preferredLicenses.map((value) => ({ value, name: licenses.list[value].title })),
+      prompt.separator(),
+      ...otherLicenses.map((value) => ({ value, name: licenses.list[value].title }))
+    ]
+  });
+  return licenses.find(licenseId);
+}
+async function getProjectDescription(basePath, pkg2, requireUserConfirmation = !1) {
+  let description = await resolveProjectDescription(basePath, pkg2);
+  return requireUserConfirmation && (description = await prompt("Plugin description", { default: description || "" })), description ?? "";
+}
+async function resolveProjectDescription(basePath, pkg2) {
+  if (pkg2 && typeof pkg2.description == "string" && pkg2.description.length > 5)
+    return pkg2.description;
+  try {
+    const readmePath = path.join(basePath, "README.md"), readme = await readFile$1(readmePath, "utf8"), [title, description] = readme.split(`
+`).filter(Boolean);
+    if (!title || !description || !title.match(/^#\s+\w+/))
+      return null;
+    const unlinked = description.replace(/\[(.*?)\]\(.*?\)/g, "$1");
+    return /^[^#]/.test(unlinked) ? unlinked : null;
+  } catch (err) {
+    return errorToUndefined(err);
+  }
+}
+async function writeAssets(injectables, { basePath, flags }) {
+  const assetsDir = await findAssetsDir(), from = (...segments) => path.join(assetsDir, "inject", ...segments), to = (...segments) => path.join(basePath, ...segments), writes = [];
+  for (const injectable of injectables) {
+    if (injectable.type === "copy") {
+      const fromPath = asArray(injectable.from), toPath = asArray(injectable.to);
+      await copyFileWithOverwritePrompt(from(...fromPath), to(...toPath), flags) && writes.push(path.join(...toPath));
+      continue;
+    }
+    if (injectable.type === "template") {
+      const toPath = asArray(injectable.to);
+      await writeFileWithOverwritePrompt(to(...toPath), `${injectable.value.trim()}
+`, {
+        default: "n",
+        force: injectable.force || flags.force
+      }), writes.push(path.join(...toPath));
+      continue;
+    }
+    throw new Error(`Unknown operation type "${injectable.type}"`);
+  }
+  return writes;
+}
+async function writeStaticAssets(options) {
+  const { outDir, flags } = options, files2 = [
+    flags.eslint && eslintrcTemplate({ flags: options.flags }),
+    flags.eslint && eslintignoreTemplate({ outDir, flags: options.flags }),
+    { type: "copy", from: "editorconfig", to: ".editorconfig" },
+    { type: "copy", from: "sanity.json", to: "sanity.json" },
+    { type: "copy", from: "v2-incompatible.js.template", to: "v2-incompatible.js" },
+    pkgConfigTemplate({ outDir, flags: options.flags }),
+    flags.gitignore && gitignoreTemplate(),
+    flags.typescript && tsconfigTemplate({ flags: options.flags }),
+    flags.typescript && tsconfigTemplateDist({ outDir, flags: options.flags }),
+    flags.typescript && tsconfigTemplateSettings({ outDir, flags: options.flags }),
+    flags.prettier && prettierignoreTemplate({ outDir }),
+    flags.prettier && { type: "copy", from: "prettierrc.json", to: ".prettierrc" }
+  ].map((f) => f || void 0).filter((f) => !!f);
+  return writeAssets(files2, options);
+}
+function asArray(input) {
+  return typeof input == "string" ? [input] : input;
+}
+async function findAssetsDir() {
+  let maxBackpaddle = 3, currDir = path.dirname(fileURLToPath(import.meta.url)), assetsDir = "";
+  for (; !assetsDir && maxBackpaddle; ) {
+    currDir = path.join(currDir, "..");
+    const assets = path.join(currDir, "assets");
+    await fileExists(assets) ? assetsDir = assets : maxBackpaddle--;
+  }
+  if (!assetsDir)
+    throw new Error("Could not find assets directory!");
+  return assetsDir;
+}
+async function addCompileDirToGitIgnore(options) {
+  const gitIgnorePath = path.join(options.basePath, ".gitignore"), gitignore = await readFile$1(gitIgnorePath, "utf8").catch(errorToUndefined);
+  if (!gitignore)
+    return !1;
+  const ignore = options.outDir.replace(/^[./]+/, "").split("/")[0];
+  if (!ignore)
+    return !1;
+  const lines = gitignore.trim().split(`
+`);
+  return lines.includes(ignore) ? !1 : (lines.push("", "# Compiled plugin", ignore), await writeFile(gitIgnorePath, lines.join(`
+`) + `
+`, { encoding: "utf8" }), !0);
+}
+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"
+], 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$1`
+        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$1`
+      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$1`
+        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$1`
+      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 validatePkgUtilsDependency({ devDependencies: devDependencies2 }) {
+  return devDependencies2?.["@sanity/pkg-utils"] ? [] : [
+    outdent$1`
+        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$1`
+        @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$1`
+        @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: devDependencies2, peerDependencies } = packageJson, allDependencies = { ...dependencies, ...devDependencies2, ...peerDependencies }, illegalDeps = Object.keys(allDependencies).filter((dep) => mergedPackages.includes(dep)), unique = [...new Set(illegalDeps).values()];
+  return unique.length ? [
+    outdent$1`
+        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: devDependencies2, peerDependencies } = packageJson, allDependencies = { ...dependencies, ...devDependencies2, ...peerDependencies }, illegalDeps = Object.keys(allDependencies).filter((dep) => deprecatedDevDeps.includes(dep)), unique = [...new Set(illegalDeps).values()];
+  return unique.length ? [
+    outdent$1`
+        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$1`
+        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), files2 = {};
+  for (const filename of filenames) {
+    const filepath = path.normalize(path.join(basePath, filename));
+    files2[filename] = await fileExists(filepath);
+  }
+  const sanityJson = await readJson5File({ basePath, filename: "sanity.json" }), hasConfigFile = (fileBase) => filesWithSuffixes([fileBase], suffixes).some((filename) => files2[filename]), hasCliConfig = hasConfigFile("sanity.cli"), hasStudioConfig = hasConfigFile("sanity.config"), errors = [];
+  if (sanityJson) {
+    const info2 = [
+      outdent$1`
+        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$1`
+        For V3 versions and alternatives to V2 plugins, please refer to the Sanity Exchange:
+        ${urls.sanityExchange}
+      `.trimStart()
+    ].filter((s) => !!s);
+    errors.push(info2.join(`
+
+`));
+  }
+  return hasCliConfig || errors.push(
+    outdent$1`
+        sanity.cli.(${suffixes.join(
+      " | "
+    )}) missing. Please create a file named sanity.cli.ts with the following content:
+
+        ${chalk.green(
+      outdent$1`
+        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$1`
+        sanity.config.(${suffixes.join(
+      " | "
+    )}) missing. At a minimum sanity.config.ts should contain:
+
+        ${chalk.green(
+      outdent$1`
+            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 validatePluginSanityJson({
+  basePath,
+  packageJson
+}) {
+  const sanityJson = await readJson5File({ basePath, filename: "sanity.json" }), expectedDefaults = {
+    parts: [
+      {
+        implements: "part:@sanity/base/sanity-root",
+        path: "./v2-incompatible.js"
+      }
+    ]
+  }, hasSinglePart = sanityJson && Object.keys(sanityJson).length === 1 && sanityJson?.parts && sanityJson.parts.length === 1, firstPart = hasSinglePart ? sanityJson?.parts?.[0] : void 0, correctImplements = firstPart?.implements === expectedDefaults.parts[0].implements, pathExists = firstPart?.path && await fileExists(path.normalize(path.join(basePath, firstPart.path))), hasDependency = !!packageJson.dependencies?.[incompatiblePluginPackage];
+  if (!(sanityJson && hasSinglePart && correctImplements && pathExists && hasDependency)) {
+    const errors = [
+      sanityJson ? null : "sanity.json does not exist",
+      hasSinglePart ? null : 'sanity.json should have exactly one entry in "parts", but did not.',
+      correctImplements ? null : `The part should implement ${expectedDefaults.parts[0].implements}, but did not.`,
+      firstPart?.path && !pathExists ? `The file in "path", ${firstPart?.path}, does not exist.` : null,
+      hasDependency ? null : outdent$1`
+      package.json should have ${incompatiblePluginPackage} as a dependency, but did not.
+        Install it with: npm install --save ${incompatiblePluginPackage}
+      `.trimStart()
+    ].filter((e) => !!e);
+    return [
+      outdent$1`
+        Invalid sanity.json. It is used for compatibility checking in V2 studios:
+
+        - ${errors.join(`
+- `)}
+
+        sanity.json will only be used when incorrectly installing a v3 plugin in a v2 Studio.
+
+        This check ensures that sanity.json conforms with the usage section of
+        ${urls.incompatiblePlugin}
+    `.trimStart()
+    ];
+  }
+  return [];
+}
+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.join(", ")}`];
+}
+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$1`
+      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: files2
+}) {
+  const found = [];
+  for (const file of files2) {
+    const filePath = path.join(basePath, file);
+    await fileExists(filePath) && found.push(file);
+  }
+  return found.length > 1 ? [
+    outdent$1`
+      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$1`
+      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 defaultDependencies = [incompatiblePluginPackage], 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: validate2 = !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 validate2 && 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
+  ), devDependencies2 = 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", files2 = [outDir, "sanity.json", "src", "v2-incompatible.js"];
+  files2.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: files2,
+    scripts: { ...prev.scripts },
+    dependencies: sortKeys(dependencies),
+    devDependencies: sortKeys(devDependencies2),
+    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) {
+  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 {
+  disallowDuplicateEslintConfig,
+  disallowDuplicatePrettierConfig,
+  ensureDir,
+  fileExists,
+  findStudioV3Config,
+  getPackage,
+  hasSanityJson,
+  inject,
+  isEmptyish,
+  mergedPackages,
+  mkdir,
+  presetHelpList,
+  prompt,
+  validateBabelConfig,
+  validateDeprecatedDependencies,
+  validateNodeEngine,
+  validatePackageName$1 as validatePackageName,
+  validatePackageType,
+  validatePkgUtilsDependency,
+  validatePkgUtilsVersion,
+  validatePluginSanityJson,
+  validateSanityDependencies,
+  validateScripts,
+  validateSrcIndexFile,
+  validateStudioConfig,
+  validateTsConfig,
+  writeFile
+};
+//# sourceMappingURL=package.js.map