@sanity/plugin-kit 6.0.3 → 7.0.0

package/dist/_chunks-es/init2.js

@@ -1,839 +1,99 @@
+import { t as cliName } from "./constants.js";
+import { t as log_default } from "./log.js";
+import { i as presetHelpList, n as initFlags, t as init } from "./init.js";
+import { F as isEmptyish, N as ensureDir, V as prompt, d as hasSanityJson, u as findStudioV3Config } from "./package.js";
+import meow from "meow";
 import path from "path";
-import outdent, { outdent as outdent$1 } from "outdent";
-import { log, sharedFlags, defaultOutDir } from "./index.js";
-import { readJsonFile, prompt, getPackage, addPackageJsonScripts, sortKeys, writePackageJsonDirect, readFile, errorToUndefined, writeFile, resolveLatestVersions, addScript, forceDependencyVersions, forcedPackageVersions, forcedDevPackageVersions, promptForPackageName, promptForRepoOrigin, writePackageJson, addBuildScripts, fileExists, writeFileWithOverwritePrompt, copyFileWithOverwritePrompt, ensureDir } from "./package.js";
-import { fileURLToPath } from "url";
-import licenses from "@rexxars/choosealicense-list";
-import gitRemoteOriginUrl from "git-remote-origin-url";
-import chalk from "chalk";
-import { execSync } from "child_process";
-import { validate } from "email-validator";
-import xdgBasedir from "xdg-basedir";
-import { createRequester } from "get-it";
-import { pkg } from "./package2.js";
-function defaultSourceJs(pkg2) {
-  return outdent`
-  import {definePlugin} from 'sanity'
-
-  /**
-   * Usage in sanity.config.js (or .ts)
-   *
-   * \`\`\`js
-   * import {defineConfig} from 'sanity'
-   * import {myPlugin} from '${pkg2.name}'
-   *
-   * export default defineConfig({
-   *   // ...
-   *   plugins: [myPlugin({})],
-   * })
-   * \`\`\`
-   *
-   * @public
-   */
-  export const myPlugin = definePlugin((config = {}) => {
-    // eslint-disable-next-line no-console
-    console.log(\`hello from ${pkg2.name}\`)
-    return {
-      name: '${pkg2.name}',
-    }
-  })
-`.trimStart() + `
+import execa from "execa";
+function npmIsAvailable() {
+	return execa("npm", ["-v"]).then(() => !0).catch(() => !1);
+}
+function yarnIsAvailable() {
+	return execa("yarn", ["-v"]).then(() => !0).catch(() => !1);
+}
+function pnpmAvailable() {
+	return execa("pnpm", ["-v"]).then(() => !0).catch(() => !1);
+}
+async function promptForPackageManager() {
+	let [npm, yarn, pnpm] = await Promise.all([
+		npmIsAvailable(),
+		yarnIsAvailable(),
+		pnpmAvailable()
+	]), choices = [
+		npm && "npm",
+		yarn && "yarn",
+		pnpm && "pnpm"
+	].filter(Boolean);
+	return choices.length < 2 ? choices[0] || "npm" : prompt("Which package manager do you prefer?", {
+		choices: choices.map((value) => ({
+			value,
+			name: value
+		})),
+		default: choices[0]
+	});
+}
+async function installDependencies(pm, { cwd }) {
+	let { exitCode } = await execa(pm, ["install"], {
+		cwd,
+		stdio: "inherit"
+	});
+	return exitCode <= 0;
+}
+const help = `
+Usage
+  $ ${cliName} init [dir] [<args>]
+
+Options
+  --no-eslint             Disables ESLint config and dependencies from being added
+  --no-prettier           Disables prettier config and dependencies from being added
+  --no-typescript         Disables typescript config and dependencies from being added
+  --no-license            Disables LICENSE + package.json license field from being added
+  --no-editorconfig       Disables .editorconfig from being added
+  --no-gitignore          Disables .gitignore from being added
+  --no-scripts            Disables scripts from being added to package.json
+  --no-install            Disables automatically running package manager install
+
+  --name [package-name]   Use the provided package-name
+  --author [name]         Use the provided author
+  --repo [url]            Use the provided repo url
+  --license [spdx]        Use the license with the given SPDX identifier
+  --force                 No prompt when overwriting files
+
+  --preset [preset-name]  Adds config and files from a named preset. --preset can be supplied multiple times.
+                          The following presets are available:
+${presetHelpList(30)}
+
+Examples
+  # Initialize a new plugin in the current directory
+  $ ${cliName} init
+
+  # Initialize a plugin in the directory ~/my-plugin
+  $ ${cliName} init ~/my-plugin
+
+  # Don't add eslint or prettier
+  $ ${cliName} init --no-eslint --no-prettier
 `;
-}
-function defaultSourceTs(pkg2) {
-  return outdent`
-  import {definePlugin} from 'sanity'
-
-  interface MyPluginConfig {
-    /* nothing here yet */
-  }
-
-  /**
-   * Usage in \`sanity.config.ts\` (or .js)
-   *
-   * \`\`\`ts
-   * import {defineConfig} from 'sanity'
-   * import {myPlugin} from '${pkg2.name}'
-   *
-   * export default defineConfig({
-   *   // ...
-   *   plugins: [myPlugin()],
-   * })
-   * \`\`\`
-   *
-   * @public
-   */
-  export const myPlugin = definePlugin<MyPluginConfig | void>((config = {}) => {
-    // eslint-disable-next-line no-console
-    console.log('hello from ${pkg2.name}')
-    return {
-      name: '${pkg2.name}',
-    }
-  })
-`.trimStart() + `
-`;
-}
-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$1`
-      # 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$1`
-      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$1`
-      {
-        "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$1`
-      {
-        "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$1`
-      {
-        "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$2
-};
-async function applyPreset$2(options) {
-  await writeAssets(
-    [
-      {
-        type: "copy",
-        from: ["renovatebot", "renovate.json"],
-        to: "renovate.json"
-      }
-    ],
-    options
-  );
-}
-function generateReadme(data) {
-  const { user, pluginName, license } = data;
-  return outdent`
-    # ${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`
-    ## Installation
-
-    \`\`\`sh
-    npm install ${packageName}
-    \`\`\`
-    `;
-}
-function developTestSnippet() {
-  return outdent`
-    ## 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 "";
-  const license = licenses.find(licenseId);
-  let licenseName = license ? license.title : void 0;
-  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 requester = createRequester({
-  headers: { "User-Agent": `${pkg.name}@${pkg.version}` },
-  as: "json"
-});
-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 { body: user } = await requester({
-      url: "https://api.sanity.io/v1/users/me",
-      as: "json",
-      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;
-}
-const semverWorkflowPreset = {
-  name: "semver-workflow",
-  description: "Files and dependencies for conventional-commits, github workflow and semantic-release.",
-  apply: applyPreset$1
-}, info = (write, msg, ...args) => write && log.info(msg, ...args);
-async function applyPreset$1(options) {
-  await writeAssets(semverWorkflowFiles(), options), await addPrepareScript(options), await addDevDependencies$1(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$1(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`
-        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(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`
-    ## Usage
-  `, license = getLicenseText(typeof pkg2.license == "string" ? pkg2.license : void 0, user), releaseSnippet = outdent`
-    ### 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 ui = {
-  name: "ui",
-  description: "`@sanity/ui` and dependencies",
-  apply: applyPreset
-};
-async function applyPreset(options) {
-  await addDependencies(options), await addDevDependencies(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(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 presets = [semverWorkflowPreset, renovatePreset, ui], 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(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, String((/* @__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(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, files = [
-    flags.eslint && eslintrcTemplate({ flags: options.flags }),
-    flags.eslint && eslintignoreTemplate({ outDir, flags: options.flags }),
-    { type: "copy", from: "editorconfig", to: ".editorconfig" },
-    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(files, 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(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 initFlags = {
-  ...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 = {}, devDependencies = {}, peerDependencies = {};
-  await inject({
-    ...options,
-    outDir: defaultOutDir,
-    requireUserConfirmation: !options.flags.force,
-    dependencies,
-    devDependencies,
-    peerDependencies,
-    validate: !1
-  });
-  const packageJson = await getPackage({ basePath: options.basePath, validate: !1 }), typescript = options.flags.typescript, source = typescript ? defaultSourceTs(packageJson) : defaultSourceJs(packageJson), filename = typescript ? "index.ts" : "index.js", srcDir = path.resolve(options.basePath, "src");
-  await ensureDir(srcDir), await writeFile(path.join(srcDir, filename), source, { encoding: "utf8" });
-}
-export {
-  init,
-  initFlags,
-  inject,
-  presetHelpList
-};
-//# sourceMappingURL=init2.js.map
+async function run({ argv }) {
+	let cli = meow(help, {
+		flags: initFlags,
+		argv,
+		description: "Initialize a new Sanity plugin"
+	}), basePath = path.resolve(cli.input[0] || process.cwd()), { exists, isRoot } = await hasSanityJson(basePath);
+	if (exists && isRoot) throw Error("sanity.json has a \"root\" property set to true - are you trying to init into a studio instead of a plugin?");
+	let { v3ConfigFile } = await findStudioV3Config(basePath);
+	if (v3ConfigFile) throw Error(`${v3ConfigFile} exists - are you trying to init into a studio instead of a plugin?`);
+	if (log_default.info("Initializing new plugin in \"%s\"", basePath), !cli.flags.force && !await isEmptyish(basePath) && !await prompt("Directory is not empty, proceed?", {
+		type: "confirm",
+		default: !1
+	})) {
+		log_default.error("Directory is not empty. Cancelled.");
+		return;
+	}
+	await ensureDir(basePath), await init({
+		basePath,
+		flags: cli.flags
+	}), cli.flags.install ? await installDependencies(await promptForPackageManager(), { cwd: basePath }) ? log_default.info("Done!") : log_default.error("Failed to install dependencies, try manually running `npm install`") : log_default.info("Dependency installation skipped.");
+}
+export { run as default };
+
+//# sourceMappingURL=init2.js.map