@sanity/plugin-kit 1.1.0-ecosystem-preset.1 → 1.1.0-ecosystem-preset.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/plugin-kit",
-  "version": "1.1.0-ecosystem-preset.1",
+  "version": "1.1.0-ecosystem-preset.4",
   "description": "Enhanced Sanity.io plugin development experience",
   "scripts": {
     "clean": "rimraf lib",
@@ -14,7 +14,7 @@
     "lint": "eslint .",
     "compile": "tsc --noEmit",
     "format": "prettier src -w",
-    "prepublishOnly": "npm run test && npm run build"
+    "prepublishOnly": "npm run build"
   },
   "binname": "sanity-plugin",
   "source": "./src/index.ts",
@@ -88,6 +88,7 @@
     "@parcel/transformer-typescript-types": "^2.7.0",
     "@sanity/semantic-release-preset": "^2.0.0",
     "@types/eslint": "^8.4.6",
+    "@types/fs-extra": "^9.0.13",
     "@types/inquirer": "^8.2.3",
     "@types/node": "^17.0.40",
     "@types/nodemon": "^1.19.2",
@@ -98,6 +99,7 @@
     "eslint-config-prettier": "^8.5.0",
     "eslint-config-sanity": "^5.1.0",
     "eslint-plugin-prettier": "^4.2.1",
+    "fs-extra": "^10.1.0",
     "husky": "^7.0.4",
     "json5": "^2.2.1",
     "lint-staged": "^12.5.0",

package/src/actions/init.ts

@@ -1,5 +1,5 @@
 import path from 'path'
-import {splat} from './splat'
+import {inject} from './inject'
 import {ensureDir, writeFile} from '../util/files'
 import {resolveLatestVersions} from '../npm/resolveLatestVersions'
 import sharedFlags from '../sharedFlags'
@@ -7,7 +7,6 @@ import {TypedFlags} from 'meow'
 import {getPackage} from '../npm/package'
 import {defaultSourceJs, defaultSourceTs} from '../configs/default-source'
 import {incompatiblePluginPackage} from '../constants'
-import {ecosystemDevDependencies} from '../ecosystem/ecosystem-preset'
 
 export const initFlags = {
   ...sharedFlags,
@@ -34,10 +33,6 @@ export const initFlags = {
     type: 'boolean',
     default: true,
   },
-  ecosystemPreset: {
-    type: 'boolean',
-    default: false,
-  },
   gitignore: {
     type: 'boolean',
     default: true,
@@ -59,6 +54,14 @@ export const initFlags = {
   repo: {
     type: 'string',
   },
+  presetOnly: {
+    type: 'boolean',
+    default: false,
+  },
+  preset: {
+    type: 'string',
+    isMultiple: true,
+  },
 } as const
 
 export type InitFlags = TypedFlags<typeof initFlags>
@@ -82,7 +85,6 @@ export async function init(options: InitOptions) {
   devDependencies = {
     ...devDependencies,
     ...defaultDevDependencies,
-    ...(options.flags.ecosystemPreset ? await ecosystemDevDependencies() : []),
     ...(await resolveLatestVersions(['rimraf'])),
   }
   peerDependencies = {
@@ -90,7 +92,7 @@ export async function init(options: InitOptions) {
     ...defaultPeerDependencies,
   }
 
-  await splat({
+  await inject({
     ...options,
     requireUserConfirmation: !options.flags.force,
     dependencies,

package/src/actions/{splat.ts → inject.ts}

@@ -18,7 +18,8 @@ import {
 } from '../util/files'
 import {InitFlags} from './init'
 import {PackageJson} from './verify/types'
-import {ecosystemPresetFiles} from '../ecosystem/ecosystem-preset'
+import outdent from 'outdent'
+import {injectPresets} from '../presets/presets'
 
 const bannedFields = ['login', 'description', 'projecturl', 'email']
 const preferredLicenses = ['MIT', 'ISC', 'BSD-3-Clause']
@@ -32,7 +33,7 @@ const otherLicenses = Object.keys(licenses.list).filter((id) => {
 
 export type FromTo = {from: string | string[]; to: string | string[]}
 
-export interface SplatOptions {
+export interface InjectOptions {
   basePath: string
   requireUserConfirmation?: boolean
   flags: InitFlags
@@ -51,7 +52,16 @@ export interface PackageData {
   gitOrigin?: string
 }
 
-export async function splat(options: SplatOptions) {
+export async function inject(options: InjectOptions) {
+  if (options.flags.presetOnly) {
+    log.info('Only apply presets, skipping default inject.')
+  } else {
+    await injectBase(options)
+  }
+  await injectPresets(options)
+}
+
+async function injectBase(options: InjectOptions) {
   const {basePath, flags, requireUserConfirmation} = options
   const info = (write: boolean, msg: string, ...args: string[]) => write && log.info(msg, ...args)
   // Gather data
@@ -103,6 +113,8 @@ export async function splat(options: SplatOptions) {
 
   didWrite = await writeEslintrc(options)
   info(didWrite, 'Wrote .eslintrc.js')
+  didWrite = await writeEslintIgnore(options)
+  info(didWrite, 'Wrote .eslintignore')
 
   didWrite = await addBuildScripts(newPkg, options)
   info(didWrite, 'Added build scripts to package.json')
@@ -111,7 +123,7 @@ export async function splat(options: SplatOptions) {
   info(didWrite, 'Added compilation output directory to .gitignore')
 }
 
-async function writeReadme(data: PackageData, options: SplatOptions) {
+async function writeReadme(data: PackageData, options: InjectOptions) {
   const {basePath} = options
 
   const readmePath = path.join(basePath, 'README.md')
@@ -128,7 +140,7 @@ async function writeReadme(data: PackageData, options: SplatOptions) {
   return true
 }
 
-async function writeEslintrc(options: SplatOptions) {
+async function writeEslintrc(options: InjectOptions) {
   if (!options.flags.eslint) {
     return false
   }
@@ -159,9 +171,32 @@ async function writeEslintrc(options: SplatOptions) {
   return true
 }
 
+async function writeEslintIgnore(options: InjectOptions) {
+  if (!options.flags.eslint) {
+    return false
+  }
+  const {basePath} = options
+
+  const eslintignore = path.join(basePath, '.eslintignore')
+
+  const content = outdent`
+    .eslintrc.js
+    commitlint.config.js
+    lib
+    lint-staged.config.js
+    ${options.flags.typescript ? '*.js' : ''}
+  `.trim()
+
+  await writeFileWithOverwritePrompt(eslintignore, content, {
+    encoding: 'utf8',
+    force: options.flags.force,
+  })
+  return true
+}
+
 async function writeLicense(
   {license}: PackageData,
-  options: SplatOptions,
+  options: InjectOptions,
   licenseChanged: boolean
 ) {
   const {basePath, flags} = options
@@ -287,24 +322,12 @@ async function resolveProjectDescription(basePath: string, pkg: PackageJson | un
   }
 }
 
-async function writeStaticAssets({basePath, flags}: SplatOptions) {
+export async function writeAssets(files: FromTo[], {basePath, flags}: InjectOptions) {
   const assetsDir = await findAssetsDir()
 
-  const from = (...segments: string[]) => path.join(assetsDir, 'splat', ...segments)
+  const from = (...segments: string[]) => path.join(assetsDir, 'inject', ...segments)
   const to = (...segments: string[]) => path.join(basePath, ...segments)
 
-  const files: FromTo[] = [
-    {from: 'editorconfig', to: '.editorconfig'},
-    {from: 'npmignore', to: '.npmignore'},
-    {from: 'sanity.json', to: 'sanity.json'},
-    {from: 'v2-incompatible.js.template', to: 'v2-incompatible.js'},
-    flags.gitignore && {from: 'gitignore', to: '.gitignore'},
-    flags.typescript && {from: 'template-tsconfig.json', to: 'tsconfig.json'},
-    flags.prettier && {from: 'prettierrc.js', to: '.prettierrc.js'},
-
-    ...(flags.ecosystemPreset ? ecosystemPresetFiles() : []),
-  ].filter((f: false | FromTo): f is FromTo => !!f)
-
   const writes: string[] = []
   for (const file of files) {
     const fromPath = asArray(file.from)
@@ -317,6 +340,24 @@ async function writeStaticAssets({basePath, flags}: SplatOptions) {
   return writes
 }
 
+async function writeStaticAssets(options: InjectOptions) {
+  const {flags} = options
+
+  const files: FromTo[] = [
+    {from: 'editorconfig', to: '.editorconfig'},
+    {from: 'npmignore', to: '.npmignore'},
+    {from: 'sanity.json', to: 'sanity.json'},
+    {from: 'v2-incompatible.js.template', to: 'v2-incompatible.js'},
+    flags.gitignore && {from: 'gitignore', to: '.gitignore'},
+    flags.typescript && {from: 'template-tsconfig.json', to: 'tsconfig.json'},
+    flags.prettier && {from: 'prettierrc.js', to: '.prettierrc.js'},
+  ]
+    .map((f) => (f ? (f as FromTo) : undefined))
+    .filter((f): f is FromTo => !!f)
+
+  return writeAssets(files, options)
+}
+
 function asArray(input: string | string[]): string[] {
   return typeof input === 'string' ? [input] : input
 }
@@ -345,7 +386,7 @@ async function findAssetsDir(): Promise<string> {
   return assetsDir
 }
 
-async function addCompileDirToGitIgnore(data: PackageData, options: SplatOptions) {
+async function addCompileDirToGitIgnore(data: PackageData, options: InjectOptions) {
   const gitIgnorePath = path.join(options.basePath, '.gitignore')
   const gitignore = await readFile(gitIgnorePath, 'utf8').catch(errorToUndefined)
   if (!gitignore) {

package/src/cli.ts

@@ -15,6 +15,7 @@ export async function cliEntry(argv = process.argv, autoExit = true) {
   These are common commands used in various situations:
 
     init            Create a new Sanity plugin
+    inject          Inject config into an existing Sanity v3 plugin
     verify-package  Check that a Sanity plugin package follows V3 conventions. Prints upgrade steps.
     verify-studio   Check that a Sanity Studio follows V3 conventions. Prints upgrade steps.
     link-watch      Recompiles plugin automatically on changes and runs yalc push --publish

package/src/cmds/index.ts

@@ -1,9 +1,8 @@
 export default {
   init: require.resolve('./init'),
+  inject: require.resolve('./inject'),
   'link-watch': require.resolve('./link-watch'),
   'verify-package': require.resolve('./verify-package'),
   'verify-studio': require.resolve('./verify-studio'),
   version: require.resolve('./version'),
-  // wont make it for initial release
-  //splat: require.resolve('./splat'),
 }

package/src/cmds/init.ts

@@ -7,6 +7,7 @@ import {installDependencies, promptForPackageManager} from '../npm/manager'
 import {findStudioV3Config, hasSanityJson} from '../sanity/manifest'
 import {prompt} from '../util/prompt'
 import {cliName} from '../constants'
+import {presetHelpList} from '../presets/presets'
 
 const description = `Initialize a new Sanity plugin`
 
@@ -24,14 +25,16 @@ Options
   --no-scripts            Disables scripts from being added to package.json
   --no-install            Disables automatically running package manager install
 
-  --ecosystem-preset      [beta]: Adds opinionated files and dependencies for conventional-commits, githubworkflow, reonvatebot and semantic-release
-
   --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 promt when overwriting files
 
+  --preset [preset-name]  [beta] - 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

package/src/cmds/inject.ts

@@ -0,0 +1,67 @@
+import path from 'path'
+import meow from 'meow'
+import log from '../util/log'
+import {inject} from '../actions/inject'
+import {findStudioV3Config} from '../sanity/manifest'
+import {initFlags} from '../actions/init'
+import {cliName} from '../constants'
+import {presetHelpList} from '../presets/presets'
+
+const description = `Inject configuration into a Sanity plugin`
+
+const help = `
+Usage
+  $ ${cliName} inject [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
+
+  --license [spdx]        Use the license with the given SPDX identifier
+  --force                 No promt when overwriting files
+
+  --preset [preset-name]  [beta] - Adds config and files from a named preset. --preset can be supplied multiple times.
+                          The following presets are available:
+${presetHelpList(30)}
+  --preset-only           Skips the default inject steps. Use this to apply a preset to an otherwise complete plugin.
+
+Examples
+  # Inject configuration into the plugin in the current directory
+  $ ${cliName} inject
+
+  # Inject configuration into the plugin in ~/my-plugin
+  $ ${cliName} inject ~/my-plugin
+
+  # Don't inject eslint or prettier
+  $ ${cliName} inject --no-eslint --no-prettier
+
+  # Inject plugin configuration and semver-workflow into the plugin in the current directory
+  $ @sanity/plugin-kit inject --preset semver-workflow
+
+  # Only inject semver-workflow and renovatebot config from presets
+  $ ${cliName} inject --preset-only --preset semver-workflow --preset renovatebot
+
+`
+
+async function run({argv}: {argv: string[]}) {
+  const cli = meow(help, {flags: initFlags, argv, description})
+  const basePath = path.resolve(cli.input[0] || process.cwd())
+
+  const {v3ConfigFile} = await findStudioV3Config(basePath)
+  if (v3ConfigFile) {
+    throw new Error(
+      `${v3ConfigFile} exists - are you trying to INJECT into a studio instead of a plugin?`
+    )
+  }
+  log.info('Inject config into plugin in "%s"', basePath)
+
+  await inject({basePath, flags: cli.flags, validate: false})
+  log.info('Done!')
+}
+
+export default run

package/src/npm/package.ts

@@ -10,7 +10,7 @@ import {resolveLatestVersions} from './resolveLatestVersions'
 import {hasSourceEquivalent, writeJsonFile} from '../util/files'
 import log from '../util/log'
 import {cliName} from '../constants'
-import {PackageData, SplatOptions} from '../actions/splat'
+import {InjectOptions, PackageData} from '../actions/inject'
 import {expectedScripts} from '../actions/verify/validations'
 import {PackageJson} from '../actions/verify/types'
 
@@ -181,23 +181,10 @@ function validateLockFiles(options: {basePath: string}) {
   }
 }
 
-export function getReferencedPaths(
-  packageJson: Record<string, string>,
-  basePath: string
-): string[] {
-  return pathKeys
-    .filter((key) => key in packageJson)
-    .map((key) =>
-      path.isAbsolute(packageJson[key])
-        ? packageJson[key]
-        : path.resolve(basePath, packageJson[key])
-    )
-}
-
-export async function writePackageJson(data: PackageData, options: SplatOptions) {
+export async function writePackageJson(data: PackageData, options: InjectOptions) {
   const {user, pluginName, license, description, pkg: prevPkg, gitOrigin} = data
   const {peerDependencies: addPeers, dependencies: addDeps, devDependencies: addDevDeps} = options
-  const {basePath, flags} = options
+  const {flags} = options
   const prev = prevPkg || {}
 
   const usePrettier = flags.prettier !== false
@@ -288,7 +275,7 @@ export async function writePackageJson(data: PackageData, options: SplatOptions)
   const differs = JSON.stringify(prev) !== JSON.stringify(manifest)
   log.debug('Does manifest differ? %s', differs ? 'yes' : 'no')
   if (differs) {
-    await writeJsonFile(path.join(basePath, 'package.json'), manifest)
+    await writePackageJsonDirect(manifest, options)
   }
 
   return differs ? manifest : prev
@@ -321,14 +308,7 @@ function repoFromOrigin(gitOrigin?: string) {
   }
 }
 
-function withSanityKeywords(keywords: string[] = []) {
-  const newKeywords = new Set(keywords)
-  newKeywords.add('sanity')
-  newKeywords.add('sanity-plugin')
-  return Array.from(newKeywords)
-}
-
-function addScript(cmd: string, existing: string) {
+export function addScript(cmd: string, existing: string) {
   if (existing && existing.includes(cmd)) {
     return existing
   }
@@ -336,30 +316,44 @@ function addScript(cmd: string, existing: string) {
   return existing ? `${existing} && ${cmd}` : cmd
 }
 
-export async function addBuildScripts(manifest: PackageJson, {basePath, flags}: SplatOptions) {
-  if (!flags.scripts) {
-    return false
-  }
+export async function addPackageJsonScripts(
+  manifest: PackageJson,
+  options: InjectOptions,
+  updateScripts: (currentScripts: Record<string, string>) => Record<string, string>
+) {
   const originalScripts = manifest.scripts || {}
-  const scripts = {...originalScripts}
-  scripts.clean = addScript(`rimraf lib`, scripts.clean)
-  scripts.lint = addScript(`eslint .`, scripts.lint)
-  scripts.prebuild = addScript('npm run clean && ' + expectedScripts.prebuild, scripts.prebuild)
-  scripts.build = addScript(expectedScripts.build, scripts.build)
-  scripts.watch = addScript(expectedScripts.watch, scripts.watch)
-  scripts['link-watch'] = addScript(expectedScripts['link-watch'], scripts['link-watch'])
-  scripts.prepublishOnly = addScript(expectedScripts.prepublishOnly, scripts.prepublishOnly)
+  const scripts = updateScripts({...originalScripts})
 
   const differs = Object.keys(scripts).some((key) => scripts[key] !== originalScripts[key])
 
   if (differs) {
-    await writeJsonFile(path.join(basePath, 'package.json'), {...manifest, scripts})
+    await writePackageJsonDirect({...manifest, scripts}, options)
   }
 
   return differs
 }
 
-function sortKeys<T extends Record<string, unknown>>(unordered: T): T {
+export async function writePackageJsonDirect(manifest: PackageJson, {basePath}: InjectOptions) {
+  await writeJsonFile(path.join(basePath, 'package.json'), manifest)
+}
+
+export async function addBuildScripts(manifest: PackageJson, options: InjectOptions) {
+  if (!options.flags.scripts) {
+    return false
+  }
+  return addPackageJsonScripts(manifest, options, (scripts) => {
+    scripts.clean = addScript(`rimraf lib`, scripts.clean)
+    scripts.lint = addScript(`eslint .`, scripts.lint)
+    scripts.prebuild = addScript('npm run clean && ' + expectedScripts.prebuild, scripts.prebuild)
+    scripts.build = addScript(expectedScripts.build, scripts.build)
+    scripts.watch = addScript(expectedScripts.watch, scripts.watch)
+    scripts['link-watch'] = addScript(expectedScripts['link-watch'], scripts['link-watch'])
+    scripts.prepublishOnly = addScript(expectedScripts.prepublishOnly, scripts.prepublishOnly)
+    return scripts
+  })
+}
+
+export function sortKeys<T extends Record<string, unknown>>(unordered: T): T {
   return Object.keys(unordered)
     .sort()
     .reduce((obj, key) => {

package/src/presets/presets.ts

@@ -0,0 +1,52 @@
+import {InjectOptions} from '../actions/inject'
+import {semverWorkflowPreset} from './semver-workflow'
+import {renovatePreset} from './renovatebot'
+
+export interface Preset {
+  name: string
+  description: string
+  apply: (options: InjectOptions) => Promise<void>
+}
+
+const presets: Preset[] = [semverWorkflowPreset, renovatePreset]
+const presetNames = presets.map((p) => p.name)
+
+export function presetHelpList(padStart: number) {
+  return presets
+    .map((p) => `${''.padStart(padStart)}${p.name.padEnd(20)}${p.description}`)
+    .join('\n')
+}
+
+export async function injectPresets(options: InjectOptions) {
+  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: string[] | undefined): Preset[] {
+  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 is Preset => !!p)
+}
+
+function onlyUnique(value: string, index: number, arr: string[]) {
+  return arr.indexOf(value) === index
+}

package/src/presets/renovatebot.ts

@@ -0,0 +1,12 @@
+import {Preset} from './presets'
+import {InjectOptions, writeAssets} from '../actions/inject'
+
+export const renovatePreset: Preset = {
+  name: 'renovatebot',
+  description: 'Files to enable renovatebot.',
+  apply: applyPreset,
+}
+
+async function applyPreset(options: InjectOptions) {
+  await writeAssets([{from: ['renovatebot', 'renovate.json'], to: 'renovate.json'}], options)
+}

package/src/presets/semver-workflow.ts

@@ -0,0 +1,84 @@
+import {FromTo, InjectOptions, writeAssets} from '../actions/inject'
+import {resolveLatestVersions} from '../npm/resolveLatestVersions'
+import {Preset} from './presets'
+import {
+  addBuildScripts,
+  addPackageJsonScripts,
+  addScript,
+  getPackage,
+  sortKeys,
+  writePackageJsonDirect,
+} from '../npm/package'
+import log from '../util/log'
+import outdent from 'outdent'
+import chalk from 'chalk'
+
+export const semverWorkflowPreset: Preset = {
+  name: 'semver-workflow',
+  description:
+    'Files and dependencies for conventional-commits, github workflow and semantic-release.',
+  apply: applyPreset,
+}
+
+const info = (write: boolean, msg: string, ...args: string[]) => write && log.info(msg, ...args)
+
+async function applyPreset(options: InjectOptions) {
+  await writeAssets(semverWorkflowFiles(), options)
+  await addPrepareScript(options)
+  await addDevDependencies(options)
+}
+
+async function addPrepareScript(options: InjectOptions) {
+  const pkg = await getPackage(options)
+  const didWrite = await addPackageJsonScripts(pkg, options, (scripts) => {
+    scripts.prepare = addScript(`husky install`, scripts.prepare)
+    return scripts
+  })
+  info(didWrite, 'Added prepare script to package.json')
+}
+
+async function addDevDependencies(options: InjectOptions) {
+  const pkg = await getPackage(options)
+  const devDeps = sortKeys({
+    ...pkg.devDependencies,
+    ...(await semverWorkflowDependencies()),
+  })
+  const newPkg = {...pkg}
+  newPkg.devDependencies = devDeps
+  await writePackageJsonDirect(newPkg, options)
+  log.info('Updated devDependencies.')
+
+  log.info(
+    chalk.green(
+      outdent`
+        You must configure branch-config in the following files manually:
+          - .release.json
+          - .github/workflows/main.yml
+  `.trim()
+    )
+  )
+}
+
+function semverWorkflowFiles(): FromTo[] {
+  return [
+    {from: ['.github', 'workflows', 'main.yml'], to: ['.github', 'workflows', 'main.yml']},
+    {from: ['.husky', 'commit-msg'], to: ['.husky', 'commit-msg']},
+    {from: ['.husky', 'pre-commit'], to: ['.husky', 'pre-commit']},
+    {from: ['.releaserc.json'], to: '.releaserc.json'},
+    {from: ['commitlint.template.js'], to: 'commitlint.config.js'},
+    {from: ['lint-staged.template.js'], to: 'lint-staged.config.js'},
+  ].map((fromTo) => ({
+    ...fromTo,
+    from: ['semver-workflow', ...fromTo.from],
+  }))
+}
+
+async function semverWorkflowDependencies(): Promise<Record<string, string>> {
+  return resolveLatestVersions([
+    '@commitlint/cli',
+    '@commitlint/config-conventional',
+    '@sanity/semantic-release-preset',
+    'husky',
+    'lint-staged',
+  ])
+}

package/src/util/prompt.ts

@@ -5,7 +5,7 @@ import inquirer from 'inquirer'
 import validNpmName from 'validate-npm-package-name'
 // @ts-expect-error missing types
 import githubUrlToObject from 'github-url-to-object'
-import {SplatOptions} from '../actions/splat'
+import {InjectOptions} from '../actions/inject'
 
 export async function prompt(
   message: string,
@@ -24,7 +24,7 @@ export async function prompt(
 
 prompt.separator = () => new inquirer.Separator()
 
-export function promptForPackageName({basePath}: SplatOptions, defaultVal?: string) {
+export function promptForPackageName({basePath}: InjectOptions, defaultVal?: string) {
   return prompt('Plugin name (sanity-plugin-...)', {
     default: defaultVal || path.basename(basePath),
     filter: (name) => {
@@ -46,7 +46,7 @@ export function promptForPackageName({basePath}: SplatOptions, defaultVal?: stri
   })
 }
 
-export function promptForRepoOrigin(options: SplatOptions, defaultVal?: string) {
+export function promptForRepoOrigin(options: InjectOptions, defaultVal?: string) {
   return prompt('Git repository URL', {
     default: defaultVal,
     filter: (raw) => {

package/src/util/readme.ts

@@ -1,7 +1,7 @@
 import outdent from 'outdent'
 // @ts-expect-error missing types
 import licenses from '@rexxars/choosealicense-list'
-import {PackageData} from '../actions/splat'
+import {PackageData} from '../actions/inject'
 import {User} from './user'
 
 export function generateReadme(data: PackageData) {