@sanity/plugin-kit 3.1.11 → 3.1.13-canary.0

package/dist/_chunks-cjs/init.js

@@ -0,0 +1,894 @@
+"use strict";
+var path = require("path"), licenses = require("@rexxars/choosealicense-list"), gitRemoteOriginUrl = require("git-remote-origin-url"), cli = require("./cli.js"), xdgBasedir = require("xdg-basedir"), gitUserInfo = require("git-user-info"), emailValidator = require("email-validator"), _package$1 = require("./package.js"), getIt = require("get-it"), middleware = require("get-it/middleware"), _package = require("./package2.js"), outdent = require("outdent"), chalk = require("chalk");
+function _interopDefaultCompat(e) {
+  return e && typeof e == "object" && "default" in e ? e : { default: e };
+}
+var path__default = /* @__PURE__ */ _interopDefaultCompat(path), licenses__default = /* @__PURE__ */ _interopDefaultCompat(licenses), gitRemoteOriginUrl__default = /* @__PURE__ */ _interopDefaultCompat(gitRemoteOriginUrl), xdgBasedir__default = /* @__PURE__ */ _interopDefaultCompat(xdgBasedir), outdent__default = /* @__PURE__ */ _interopDefaultCompat(outdent), chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk);
+const request = getIt.getIt([
+  middleware.promise({ onlyBody: !0 }),
+  middleware.jsonRequest(),
+  middleware.jsonResponse(),
+  middleware.httpErrors(),
+  middleware.headers({ "User-Agent": `${_package.pkg.name}@${_package.pkg.version}` })
+]);
+async function getUserInfo({ requireUserConfirmation, flags }, pkg) {
+  const userInfo = getPackageUserInfo({ author: flags.author ?? pkg?.author }) || await getSanityUserInfo() || await getGitUserInfo();
+  return requireUserConfirmation ? promptForInfo(userInfo) : userInfo;
+}
+function getPackageUserInfo(pkg) {
+  let author = pkg?.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 _package$1.prompt("Author name", {
+    filter: filterString,
+    default: defValue && defValue.name,
+    validate: requiredString
+  }), email = await _package$1.prompt("Author email", {
+    filter: filterString,
+    default: defValue && defValue.email,
+    validate: validOrEmptyEmail
+  });
+  return { name, email };
+}
+async function getSanityUserInfo() {
+  try {
+    const token = (await _package$1.readJsonFile(
+      path__default.default.join(xdgBasedir__default.default.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() {
+  const user = await gitUserInfo.getGitUserInfo();
+  return user ? { name: user.name, email: user.email } : void 0;
+}
+function filterString(val) {
+  return (val || "").trim();
+}
+function requiredString(value) {
+  return value.length > 1 ? !0 : "Required";
+}
+function validOrEmptyEmail(value) {
+  return value ? emailValidator.validate(value) ? !0 : "Must either be a valid email or empty" : !0;
+}
+function generateReadme(data) {
+  const { user, pluginName, license, description } = data;
+  return outdent__default.default`
+    # ${pluginName}
+
+    ${v3BannerNotice()}
+
+    ${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 v3BannerNotice() {
+  return "> This is a **Sanity Studio v3** plugin.";
+}
+function installationSnippet(packageName) {
+  return outdent__default.default`
+    ## Installation
+
+    \`\`\`sh
+    npm install ${packageName}
+    \`\`\`
+    `;
+}
+function developTestSnippet() {
+  return outdent__default.default`
+    ## 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__default.default.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$3
+}, info = (write, msg, ...args) => write && cli.log.info(msg, ...args);
+async function applyPreset$3(options) {
+  await writeAssets(semverWorkflowFiles(), options), await addPrepareScript(options), await addDevDependencies$2(options), await updateReadme(options);
+}
+async function addPrepareScript(options) {
+  const pkg = await _package$1.getPackage(options), didWrite = await _package$1.addPackageJsonScripts(pkg, options, (scripts) => (scripts.prepare = _package$1.addScript("husky install", scripts.prepare), scripts));
+  info(didWrite, "Added prepare script to package.json");
+}
+async function addDevDependencies$2(options) {
+  const pkg = await _package$1.getPackage(options), devDeps = _package$1.sortKeys({
+    ...pkg.devDependencies,
+    ...await semverWorkflowDependencies()
+  }), newPkg = { ...pkg };
+  newPkg.devDependencies = devDeps, await _package$1.writePackageJsonDirect(newPkg, options), cli.log.info("Updated devDependencies."), cli.log.info(
+    chalk__default.default.green(
+      outdent__default.default`
+        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__default.default.join(basePath, "README.md"), readme = await _package$1.readFile(readmePath, "utf8").catch(_package$1.errorToUndefined) ?? "", { v3Banner, install, usage, developTest, license, releaseSnippet } = await readmeSnippets(options), prependSections = missingSections(readme, [v3Banner, install, usage]), appendSections = missingSections(readme, [license, developTest, releaseSnippet]);
+  if (prependSections.length || appendSections.length) {
+    const updatedReadme = [...prependSections, readme, ...appendSections].filter(Boolean).join(`
+
+`);
+    await _package$1.writeFile(readmePath, updatedReadme, { encoding: "utf8" }), cli.log.info("Updated README. Please review the changes.");
+  }
+}
+async function readmeSnippets(options) {
+  const pkg = await _package$1.getPackage(options), user = await getUserInfo(options, pkg), bestEffortUrl = readmeBaseurl(pkg), install = installationSnippet(pkg.name ?? "unknown"), usage = outdent__default.default`
+    ## Usage
+  `, license = getLicenseText(typeof pkg.license == "string" ? pkg.license : void 0, user), releaseSnippet = outdent__default.default`
+    ### 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 {
+    v3Banner: v3BannerNotice(),
+    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 _package$1.resolveLatestVersions([
+    "@commitlint/cli",
+    "@commitlint/config-conventional",
+    "@sanity/semantic-release-preset",
+    "husky",
+    "lint-staged"
+  ]);
+}
+function readmeBaseurl(pkg) {
+  return (pkg.repository?.url ?? pkg.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 renovatePreset = {
+  name: "renovatebot",
+  description: "Files to enable renovatebot.",
+  apply: applyPreset$2
+};
+async function applyPreset$2(options) {
+  await writeAssets(
+    [
+      {
+        type: "copy",
+        from: ["renovatebot", "renovate.json"],
+        to: "renovate.json"
+      }
+    ],
+    options
+  );
+}
+const ui = {
+  name: "ui",
+  description: "`@sanity/ui` and dependencies",
+  apply: applyPreset$1
+};
+async function applyPreset$1(options) {
+  await addDependencies(options), await addDevDependencies$1(options), cli.log.info(chalk__default.default.green("ui preset injected"));
+}
+async function addDependencies(options) {
+  const pkg = await _package$1.getPackage(options), newDeps = _package$1.sortKeys(
+    _package$1.forceDependencyVersions(
+      {
+        ...pkg.dependencies,
+        ...await resolveDependencyList()
+      },
+      _package$1.forcedPackageVersions
+    )
+  ), newPkg = { ...pkg };
+  newPkg.dependencies = newDeps, await _package$1.writePackageJsonDirect(newPkg, options), cli.log.info("Updated dependencies.");
+}
+async function addDevDependencies$1(options) {
+  const pkg = await _package$1.getPackage(options), newDeps = _package$1.sortKeys(
+    _package$1.forceDependencyVersions(
+      {
+        ...pkg.devDependencies,
+        ...await resolveDevDependencyList()
+      },
+      _package$1.forcedDevPackageVersions
+    )
+  ), newPkg = { ...pkg };
+  newPkg.devDependencies = newDeps, await _package$1.writePackageJsonDirect(newPkg, options), cli.log.info("Updated devDependencies.");
+}
+async function resolveDependencyList() {
+  return _package$1.resolveLatestVersions(["@sanity/icons", "@sanity/ui"]);
+}
+async function resolveDevDependencyList() {
+  return _package$1.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), cli.log.info(
+    chalk__default.default.green(
+      outdent__default.default`
+        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__default.default.join(basePath, ".gitignore");
+  let gitignore = await _package$1.readFile(gitignorePath, "utf8").catch(_package$1.errorToUndefined) ?? "";
+  const value = ".workshop";
+  gitignore.includes(value) || (gitignore += `
+
+${value}`, await _package$1.writeFile(gitignorePath, gitignore, { encoding: "utf8" }));
+}
+async function addDevDependencies(options) {
+  const pkg = await _package$1.getPackage(options), devDeps = _package$1.sortKeys({
+    ...pkg.devDependencies,
+    ...await devDependencies()
+  }), newPkg = { ...pkg };
+  newPkg.devDependencies = devDeps, await _package$1.writePackageJsonDirect(newPkg, options), cli.log.info("Updated devDependencies.");
+}
+async function devDependencies() {
+  return _package$1.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;
+}
+function tsconfigTemplate(options) {
+  const { flags } = options;
+  return {
+    type: "template",
+    force: flags.force,
+    to: "tsconfig.json",
+    value: outdent.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.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.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
+        }
+      }
+    `
+  };
+}
+function pkgConfigTemplate(options) {
+  const { flags, outDir } = options;
+  return {
+    type: "template",
+    force: flags.force,
+    to: flags.typescript ? "package.config.ts" : "package.config.js",
+    value: outdent.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-forgotten-export': 'off',
+            'ae-incompatible-release-tags': 'off',
+            'ae-internal-missing-underscore': 'off',
+            'ae-missing-release-tag': 'off',
+          },
+        },
+      })
+    `
+  };
+}
+function gitignoreTemplate() {
+  return {
+    type: "template",
+    to: ".gitignore",
+    value: outdent.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 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",
+    flags.typescript ? "package.config.ts" : "package.config.js",
+    flags.typescript ? "*.js" : ""
+  ].filter(Boolean);
+  return patterns.sort(), {
+    type: "template",
+    force: flags.force,
+    to: ".eslintignore",
+    value: patterns.join(`
+`)
+  };
+}
+function prettierignoreTemplate(options) {
+  const { outDir } = options;
+  return {
+    type: "template",
+    to: ".prettierignore",
+    value: [outDir, "pnpm-lock.yaml", "yarn.lock", "package-lock.json"].join(`
+`)
+  };
+}
+const bannedFields = ["login", "description", "projecturl", "email"], preferredLicenses = ["MIT", "ISC", "BSD-3-Clause"], otherLicenses = Object.keys(licenses__default.default.list).filter((id) => {
+  const license = licenses__default.default.list[id];
+  return !preferredLicenses.includes(id) && !bannedFields.some((field) => license.body.includes(`[${field}]`));
+});
+async function inject(options) {
+  options.flags.presetOnly ? cli.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 && cli.log.info(msg, ...args), pkg = await _package$1.getPackage(options).catch(_package$1.errorToUndefined);
+  cli.log.debug("Plugin has package.json: %s", pkg ? "yes" : "no");
+  const user = await getUserInfo(options, pkg);
+  cli.log.debug("User information: %o", user);
+  const pkgName = flags.name ?? pkg?.name, pluginName = requireUserConfirmation || !pkgName ? await _package$1.promptForPackageName(options, pkgName) : pkgName;
+  cli.log.debug("Plugin name: %s", pluginName);
+  const license = await getLicense(flags, { user, pluginName, pkg, requireUserConfirmation }), licenseChanged = (pkg && pkg.license) !== (license && license.id);
+  cli.log.debug("License: %s", license ? license.id : "<none>");
+  const description = await getProjectDescription(basePath, pkg, requireUserConfirmation);
+  cli.log.debug("Description: %s", description || "<none>");
+  const repoUrl = flags.repo ?? (await gitRemoteOriginUrl__default.default(basePath).catch(_package$1.errorToUndefined) || pkg?.repository?.url), gitOrigin = requireUserConfirmation ? await _package$1.promptForRepoOrigin(options, repoUrl) : repoUrl;
+  cli.log.debug("Remote origin: %s", gitOrigin || "<none>");
+  const data = { user, pluginName, license, description, pkg, gitOrigin };
+  let didWrite;
+  const newPkg = await _package$1.writePackageJson(data, options);
+  info2(newPkg !== pkg, "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 _package$1.addBuildScripts(newPkg, options), info2(didWrite, "Added build scripts to package.json"), didWrite = await addCompileDirToGitIgnore(data, options), info2(didWrite, "Added compilation output directory to .gitignore");
+}
+async function writeReadme(data, options) {
+  const { basePath } = options, readmePath = path__default.default.join(basePath, "README.md"), readme = await _package$1.readFile(readmePath, "utf8").catch(_package$1.errorToUndefined);
+  return readme && !isDefaultGitHubReadme(readme) ? !1 : (await _package$1.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 _package$1.fileExists(path__default.default.join(basePath, "LICENSE.md")), licensePath = path__default.default.join(basePath, hasLicenseMdFile ? "LICENSE.md" : "LICENSE");
+  return await _package$1.writeFileWithOverwritePrompt(licensePath, license.text, {
+    encoding: "utf8",
+    default: licenseChanged,
+    force: flags.force
+  }), !0;
+}
+async function getLicense(flags, {
+  user,
+  pluginName,
+  pkg,
+  requireUserConfirmation
+}) {
+  const license = await getLicenseIdentifier(flags, pkg, 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, pkg, requireUserConfirmation = !1) {
+  if (flags.license === !1)
+    return null;
+  if (typeof flags.license == "string") {
+    const license = licenses__default.default.find(`${flags.license}`);
+    if (!license)
+      throw new Error(`License "${flags.license}" not found`);
+    return license;
+  }
+  if (pkg && pkg.license && !requireUserConfirmation) {
+    const license = licenses__default.default.find(`${pkg.license}`);
+    if (license)
+      return license;
+    cli.log.warn(`package.json contains license "${pkg.license}", which is not recognized`);
+  }
+  const licenseId = await _package$1.prompt("Which license do you want to use?", {
+    default: pkg && pkg.license && licenses__default.default.find(pkg.license) ? pkg.license : preferredLicenses[0],
+    choices: [
+      _package$1.prompt.separator(),
+      ...preferredLicenses.map((value) => ({ value, name: licenses__default.default.list[value].title })),
+      _package$1.prompt.separator(),
+      ...otherLicenses.map((value) => ({ value, name: licenses__default.default.list[value].title }))
+    ]
+  });
+  return licenses__default.default.find(licenseId);
+}
+async function getProjectDescription(basePath, pkg, requireUserConfirmation = !1) {
+  let description = await resolveProjectDescription(basePath, pkg);
+  return requireUserConfirmation && (description = await _package$1.prompt("Plugin description", { default: description || "" })), description ?? "";
+}
+async function resolveProjectDescription(basePath, pkg) {
+  if (pkg && typeof pkg.description == "string" && pkg.description.length > 5)
+    return pkg.description;
+  try {
+    const readmePath = path__default.default.join(basePath, "README.md"), readme = await _package$1.readFile(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 _package$1.errorToUndefined(err);
+  }
+}
+async function writeAssets(injectables, { basePath, flags }) {
+  const assetsDir = await findAssetsDir(), from = (...segments) => path__default.default.join(assetsDir, "inject", ...segments), to = (...segments) => path__default.default.join(basePath, ...segments), writes = [];
+  for (const injectable of injectables) {
+    if (injectable.type === "copy") {
+      const fromPath = asArray(injectable.from), toPath = asArray(injectable.to);
+      await _package$1.copyFileWithOverwritePrompt(from(...fromPath), to(...toPath), flags) && writes.push(path__default.default.join(...toPath));
+      continue;
+    }
+    if (injectable.type === "template") {
+      const toPath = asArray(injectable.to);
+      await _package$1.writeFileWithOverwritePrompt(to(...toPath), `${injectable.value.trim()}
+`, {
+        default: "n",
+        force: injectable.force || flags.force
+      }), writes.push(path__default.default.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 = __dirname, assetsDir = "";
+  for (; !assetsDir && maxBackpaddle; ) {
+    currDir = path__default.default.join(currDir, "..");
+    const assets = path__default.default.join(currDir, "assets");
+    await _package$1.fileExists(assets) ? assetsDir = assets : maxBackpaddle--;
+  }
+  if (!assetsDir)
+    throw new Error("Could not find assets directory!");
+  return assetsDir;
+}
+async function addCompileDirToGitIgnore(data, options) {
+  const gitIgnorePath = path__default.default.join(options.basePath, ".gitignore"), gitignore = await _package$1.readFile(gitIgnorePath, "utf8").catch(_package$1.errorToUndefined);
+  if (!gitignore)
+    return !1;
+  const output = data.pkg?.main ?? data.pkg?.module;
+  if (!output)
+    return !1;
+  const ignore = output.replace(/^[./]+/, "").split("/")[0];
+  if (!ignore)
+    return !1;
+  const lines = gitignore.trim().split(`
+`);
+  return lines.includes(ignore) ? !1 : (lines.push("", "# Compiled plugin", ignore), await _package$1.writeFile(gitIgnorePath, lines.join(`
+`) + `
+`, { encoding: "utf8" }), !0);
+}
+function defaultSourceJs(pkg) {
+  return outdent__default.default`
+  import {definePlugin} from 'sanity'
+
+  /**
+   * Usage in sanity.config.js (or .ts)
+   *
+   * \`\`\`js
+   * import {defineConfig} from 'sanity'
+   * import {myPlugin} from '${pkg.name}'
+   *
+   * export default defineConfig({
+   *   // ...
+   *   plugins: [myPlugin({})],
+   * })
+   * \`\`\`
+   */
+  export const myPlugin = definePlugin((config = {}) => {
+    // eslint-disable-next-line no-console
+    console.log(\`hello from ${pkg.name}\`)
+    return {
+      name: '${pkg.name}',
+    }
+  })
+`.trimStart() + `
+`;
+}
+function defaultSourceTs(pkg) {
+  return outdent__default.default`
+  import {definePlugin} from 'sanity'
+
+  interface MyPluginConfig {
+    /* nothing here yet */
+  }
+
+  /**
+   * Usage in \`sanity.config.ts\` (or .js)
+   *
+   * \`\`\`ts
+   * import {defineConfig} from 'sanity'
+   * import {myPlugin} from '${pkg.name}'
+   *
+   * export default defineConfig({
+   *   // ...
+   *   plugins: [myPlugin()],
+   * })
+   * \`\`\`
+   */
+  export const myPlugin = definePlugin<MyPluginConfig | void>((config = {}) => {
+    // eslint-disable-next-line no-console
+    console.log('hello from ${pkg.name}')
+    return {
+      name: '${pkg.name}',
+    }
+  })
+`.trimStart() + `
+`;
+}
+const initFlags = {
+  ...cli.sharedFlags,
+  scripts: {
+    type: "boolean",
+    default: !0
+  },
+  eslint: {
+    type: "boolean",
+    default: !0
+  },
+  typescript: {
+    type: "boolean",
+    default: !0
+  },
+  prettier: {
+    type: "boolean",
+    default: !0
+  },
+  license: {
+    type: "string"
+  },
+  editorconfig: {
+    type: "boolean",
+    default: !0
+  },
+  gitignore: {
+    type: "boolean",
+    default: !0
+  },
+  force: {
+    type: "boolean",
+    default: !1
+  },
+  install: {
+    type: "boolean",
+    default: !0
+  },
+  name: {
+    type: "string"
+  },
+  author: {
+    type: "string"
+  },
+  repo: {
+    type: "string"
+  },
+  presetOnly: {
+    type: "boolean",
+    default: !1
+  },
+  preset: {
+    type: "string",
+    isMultiple: !0
+  }
+};
+async function init(options) {
+  let dependencies = {}, devDependencies2 = {}, peerDependencies = {};
+  await inject({
+    ...options,
+    outDir: cli.defaultOutDir,
+    requireUserConfirmation: !options.flags.force,
+    dependencies,
+    devDependencies: devDependencies2,
+    peerDependencies,
+    validate: !1
+  });
+  const packageJson = await _package$1.getPackage({ basePath: options.basePath, validate: !1 }), typescript = options.flags.typescript, source = typescript ? defaultSourceTs(packageJson) : defaultSourceJs(packageJson), filename = typescript ? "index.ts" : "index.js", srcDir = path__default.default.resolve(options.basePath, "src");
+  await _package$1.ensureDir(srcDir), await _package$1.writeFile(path__default.default.join(srcDir, filename), source, { encoding: "utf8" });
+}
+exports.init = init;
+exports.initFlags = initFlags;
+exports.inject = inject;
+exports.presetHelpList = presetHelpList;
+//# sourceMappingURL=init.js.map