@sanity/plugin-kit 4.0.20 → 5.0.0

package/src/util/command-parser.ts

@@ -1,36 +0,0 @@
-import childProcess from 'child_process'
-import npmRunPath from 'npm-run-path'
-import log from './log'
-
-interface Command {
-  command: string
-  args: string[]
-}
-
-export function parseCommand(commandString: string): Command {
-  const normalized = commandString.replace(/ +/g, ' ')
-  const commandAndArg = normalized.split(' ')
-  return {
-    command: commandAndArg[0],
-    args: commandAndArg.length > 1 ? commandAndArg.slice(1) : [],
-  }
-}
-
-export async function runCommand(commandString: string): Promise<{code: number}> {
-  log.info(`Running command: ${commandString}`)
-  const {command, args} = parseCommand(commandString)
-
-  let options: any = {stdio: 'inherit', env: npmRunPath.env()}
-
-  // ref: https://stackoverflow.com/questions/37459717/error-spawn-enoent-on-windows/37487465
-  options = process.platform === 'win32' ? {...options, shell: true} : options
-
-  return new Promise((resolve, reject) => {
-    childProcess
-      .spawn(command, args, options)
-      .on('error', reject)
-      .on('close', (exitCode) => {
-        resolve({code: exitCode ?? 0})
-      })
-  })
-}

package/src/util/errorToUndefined.ts

@@ -1,7 +0,0 @@
-export function errorToUndefined(err: any) {
-  if (err instanceof TypeError) {
-    throw err
-  }
-
-  return undefined
-}

package/src/util/files.ts

@@ -1,260 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import util from 'util'
-import pAny from 'p-any'
-import crypto from 'crypto'
-import {buildExtensions} from '../configs/buildExtensions'
-import {prompt} from './prompt'
-import {InitFlags} from '../actions/init'
-import log from './log'
-import json5 from 'json5'
-import {ManifestPaths} from '../sanity/manifest'
-
-export const stat = util.promisify(fs.stat)
-export const mkdir = util.promisify(fs.mkdir)
-export const readdir = util.promisify(fs.readdir)
-export const copyFile = util.promisify(fs.copyFile)
-export const readFile = util.promisify(fs.readFile)
-export const writeFile = util.promisify(fs.writeFile)
-
-export function hasSourceEquivalent(compiledFile: string, paths: ManifestPaths) {
-  if (!paths.source) {
-    return fileExists(
-      path.isAbsolute(compiledFile) ? compiledFile : path.resolve(paths.basePath, compiledFile),
-    )
-  }
-
-  // /plugin/dist/MyComponent.js => /plugin/src
-  const baseDir = path.dirname(compiledFile.replace(paths.compiled as string, paths.source))
-
-  // /plugin/dist/MyComponent.js => MyComponent
-  const baseName = path.basename(compiledFile, path.extname(compiledFile))
-
-  // MyComponent => /plugin/src/MyComponent
-  const pathStub = path.join(baseDir, baseName)
-
-  /*
-   * /plugin/src/MyComponent => [
-   *   /plugin/src/MyComponent.jsx,
-   *   /plugin/src/MyComponent.mjs,
-   *   ...
-   * ]
-   */
-  return buildCandidateExists(pathStub)
-}
-
-// Generally used for parts resolving
-export async function hasSourceFile(filePath: string, paths?: ManifestPaths) {
-  if (!paths?.source) {
-    return fileExists(
-      path.isAbsolute(filePath) ? filePath : path.resolve(paths?.basePath ?? '', filePath),
-    )
-  }
-
-  // filePath: components/SomeInput
-  // paths: {source: '/plugin/src'}
-  // MyComponent => /plugin/src/MyComponent
-  const pathStub = path.isAbsolute(filePath) ? filePath : path.resolve(paths.source, filePath)
-
-  if (await fileExists(pathStub)) {
-    return true
-  }
-
-  return buildCandidateExists(pathStub)
-}
-
-// Generally used for parts resolving
-export function hasCompiledFile(filePath: string, paths?: ManifestPaths) {
-  if (!paths?.compiled) {
-    return fileExists(
-      path.isAbsolute(filePath) ? filePath : path.resolve(paths?.basePath ?? '', filePath),
-    )
-  }
-
-  // filePath: components/SomeInput
-  // paths: {compiled: '/plugin/dist'}
-
-  // components/SomeInput => /plugin/dist/components/SomeInput
-  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(paths.compiled, filePath)
-
-  // /plugin/dist/components/SomeInput     => /plugin/dist/components/SomeInput.js
-  // /plugin/dist/components/SomeInput.js  => /plugin/dist/components/SomeInput.js
-  // /plugin/dist/components/SomeInput.css => /plugin/dist/components/SomeInput.css
-  const fileExt = path.extname(absPath)
-  const withExt = fileExt === '' ? `${absPath}.js` : absPath
-
-  return fileExists(withExt)
-}
-
-export function buildCandidateExists(pathStub: string) {
-  const candidates = buildExtensions.map((extCandidate) => `${pathStub}${extCandidate}`)
-
-  return pAny(candidates.map((candidate) => stat(candidate)))
-    .then(() => true)
-    .catch(() => false)
-}
-
-export function fileExists(filePath: string) {
-  return stat(filePath)
-    .then(() => true)
-    .catch(() => false)
-}
-
-export async function readJsonFile<T>(filePath: string) {
-  const content = await readFile(filePath, 'utf8')
-  return JSON.parse(content) as T
-}
-
-export function writeJsonFile(filePath: string, content: Record<string, unknown>) {
-  const data = JSON.stringify(content, null, 2) + '\n'
-  return writeFile(filePath, data, {encoding: 'utf8'})
-}
-
-export async function writeFileWithOverwritePrompt(
-  filePath: string,
-  content: string,
-  options: {default?: any; force?: boolean} & fs.ObjectEncodingOptions,
-) {
-  const {default: defaultVal, force = false, ...writeOptions} = options
-  const withinCwd = filePath.startsWith(process.cwd())
-  const printablePath = withinCwd ? path.relative(process.cwd(), filePath) : filePath
-
-  if (await fileEqualsData(filePath, content)) {
-    return false
-  }
-
-  if (
-    !force &&
-    (await fileExists(filePath)) &&
-    !(await prompt(`File "${printablePath}" already exists. Overwrite?`, {
-      type: 'confirm',
-      default: defaultVal,
-    }))
-  ) {
-    return false
-  }
-
-  await writeFile(filePath, content, writeOptions)
-  return true
-}
-
-export async function copyFileWithOverwritePrompt(from: string, to: string, flags: InitFlags) {
-  const withinCwd = to.startsWith(process.cwd())
-  const printablePath = withinCwd ? path.relative(process.cwd(), to) : to
-
-  if (await filesAreEqual(from, to)) {
-    return false
-  }
-
-  await ensureDirectoryExists(to)
-
-  if (
-    !flags.force &&
-    (await fileExists(to)) &&
-    !(await prompt(`File "${printablePath}" already exists. Overwrite?`, {
-      type: 'confirm',
-      default: false,
-    }))
-  ) {
-    return false
-  }
-
-  await copyFile(from, to)
-  return true
-}
-
-async function ensureDirectoryExists(filePath: string) {
-  const dirname = path.dirname(filePath)
-  if (await fileExists(dirname)) {
-    return true
-  }
-  await ensureDirectoryExists(dirname)
-  await mkdir(dirname)
-}
-
-export async function fileEqualsData(filePath: string, content: string) {
-  const contentHash = crypto.createHash('sha1').update(content).digest('hex')
-  const remoteHash = await getFileHash(filePath)
-  return contentHash === remoteHash
-}
-
-export async function filesAreEqual(file1: string, file2: string) {
-  const [hash1, hash2] = await Promise.all([getFileHash(file1, false), getFileHash(file2)])
-  return hash1 === hash2
-}
-
-export function getFileHash(filePath: string, allowMissing = true) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash('sha1')
-    const stream = fs.createReadStream(filePath)
-    stream.on('error', (err) => {
-      if ((err as unknown as {code?: string}).code === 'ENOENT' && allowMissing) {
-        resolve(null)
-      } else {
-        reject(err)
-      }
-    })
-
-    stream.on('end', () => resolve(hash.digest('hex')))
-    stream.on('data', (chunk) => hash.update(chunk))
-  })
-}
-
-export async function ensureDir(dirPath: string) {
-  try {
-    await mkdir(dirPath)
-  } catch (err) {
-    if ((err as unknown as {code?: string}).code !== 'EEXIST') {
-      throw err
-    }
-  }
-}
-
-export async function isEmptyish(dirPath: string) {
-  const ignoredFiles = ['.git', '.gitignore', 'license', 'readme.md']
-  const allFiles = await readdir(dirPath).catch(() => [])
-  const files = allFiles.filter((file) => !ignoredFiles.includes(file.toLowerCase()))
-  return files.length === 0
-}
-
-export async function readFileContent({
-  filename,
-  basePath,
-}: {
-  filename: string
-  basePath: string
-}): Promise<string | undefined> {
-  const filepath = path.normalize(path.join(basePath, filename))
-  try {
-    return await readFile(filepath, 'utf8')
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      log.debug(`No ${filename} file found.`)
-      return undefined
-    }
-    throw new Error(`Failed to read "${filepath}": ${err.message}`)
-  }
-}
-
-export async function readJson5File<T>({
-  filename,
-  basePath,
-}: {
-  filename: string
-  basePath: string
-}): Promise<T | undefined> {
-  const content = await readFileContent({filename, basePath})
-  if (!content) {
-    return undefined
-  }
-
-  return parseJson5<T>(content, filename)
-}
-
-export function parseJson5<T>(content: string, errorKey: string): T {
-  try {
-    return json5.parse<T>(content)
-  } catch (err: any) {
-    throw new Error(`Error parsing "${errorKey}": ${err.message}`)
-  }
-}

package/src/util/log.ts

@@ -1,44 +0,0 @@
-// Note: This is _specifically_ meant for CLI usage,
-// I realize that "singletons" are bad.
-
-import chalk from 'chalk'
-
-let beQuiet = false
-let beVerbose = false
-
-function setVerbosity({verbose, silent}: {verbose: boolean; silent: boolean}) {
-  if (silent) {
-    beVerbose = false
-    beQuiet = true
-  } else if (verbose) {
-    beVerbose = true
-    beQuiet = false
-  }
-}
-
-export default {
-  setVerbosity: setVerbosity,
-
-  // Bypasses any checks, prints regardless (only use for things like `cli --version`)
-  msg: (msg: any, ...args: any[]) => !beQuiet && console.log(msg, ...args),
-
-  // Debug only printed on --verbose
-  debug: (msg: any, ...args: any[]) =>
-    !beQuiet && beVerbose && console.debug(`${chalk.bgBlack.white('[debug]')} ${msg}`, ...args),
-
-  // Success messages only printed if not --silent
-  success: (msg: any, ...args: any[]) =>
-    !beQuiet && console.info(`${chalk.bgBlack.greenBright('[success]')} ${msg}`, ...args),
-
-  // Info only printed if not --silent ("standard" level)
-  info: (msg: any, ...args: any[]) =>
-    !beQuiet && console.info(`${chalk.bgBlack.cyanBright('[info]')} ${msg}`, ...args),
-
-  // Warning only printed if not --silent
-  warn: (msg: any, ...args: any[]) =>
-    !beQuiet && console.warn(`${chalk.bgBlack.yellowBright('[warn]')} ${msg}`, ...args),
-
-  // Errors are always printed
-  error: (msg: any, ...args: any[]) =>
-    console.error(`${chalk.bgBlack.redBright('[error]')} ${msg}`, ...args),
-}

package/src/util/prompt.ts

@@ -1,70 +0,0 @@
-import {URL} from 'url'
-import path from 'path'
-import inquirer from 'inquirer'
-// @ts-expect-error missing types
-import validNpmName from 'validate-npm-package-name'
-// @ts-expect-error missing types
-import githubUrlToObject from 'github-url-to-object'
-import {InjectOptions} from '../actions/inject'
-
-export async function prompt(
-  message: string,
-  options: {
-    choices?: any
-    type?: string
-    default?: any
-    filter?: (val: any) => any
-    validate?: (val: any) => boolean | string
-  },
-) {
-  const type = options.choices ? 'list' : options.type
-  const result = await inquirer.prompt([{...options, type, message, name: 'single'}])
-  return result && result.single
-}
-
-prompt.separator = () => new inquirer.Separator()
-
-export function promptForPackageName({basePath}: InjectOptions, defaultVal?: string) {
-  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: {errors?: string[]} = validNpmName(name)
-      if (valid.errors) {
-        return valid.errors[0]
-      }
-
-      if (name[0] !== '@' && name.endsWith('plugin')) {
-        return `Name shouldn't include "plugin" multiple times (${name})`
-      }
-
-      return true
-    },
-  })
-}
-
-export function promptForRepoOrigin(options: InjectOptions, defaultVal?: string) {
-  return prompt('Git repository URL', {
-    default: defaultVal,
-    filter: (raw) => {
-      const url = (raw || '').trim()
-      const gh: {user: string; repo: string} | undefined = githubUrlToObject(url)
-      return gh ? `git+ssh://git@github.com/${gh.user}/${gh.repo}.git` : url
-    },
-    validate: (url) => {
-      if (!url) {
-        return true
-      }
-
-      try {
-        const parsed = new URL(url)
-        return parsed ? true : 'Invalid URL'
-      } catch (err) {
-        return 'Invalid URL'
-      }
-    },
-  })
-}

package/src/util/readme.ts

@@ -1,88 +0,0 @@
-import outdent from 'outdent'
-// @ts-expect-error missing types
-import licenses from '@rexxars/choosealicense-list'
-import {PackageData} from '../actions/inject'
-import {User} from './user'
-
-export function generateReadme(data: PackageData) {
-  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 as User) : undefined)}
-    ${developTestSnippet()}
-  ` + '\n'
-  )
-}
-
-export function installationSnippet(packageName: string) {
-  return outdent`
-    ## Installation
-
-    \`\`\`sh
-    npm install ${packageName}
-    \`\`\`
-    `
-}
-
-export 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.
-  `
-}
-
-export function getLicenseText(licenseId?: string, user?: User) {
-  if (!licenseId) {
-    return ''
-  }
-
-  let licenseName: string | undefined = licenses.find(licenseId).title
-  licenseName = licenseName?.replace(/\s+license$/i, '')
-
-  let licenseText = '## License\n'
-  if (licenseName && user?.name) {
-    licenseText = `${licenseText}\n[${licenseName}](LICENSE) © ${user?.name}\n`
-  } else if (licenseName) {
-    licenseText = `${licenseText}\n[${licenseName}](LICENSE)\n`
-  } else {
-    licenseText = `${licenseText}\nSee [LICENSE](LICENSE)`
-  }
-
-  return licenseText
-}
-
-export function isDefaultGitHubReadme(readme: string) {
-  if (!readme) {
-    return false
-  }
-
-  const lines = readme.split('\n', 20).filter(Boolean)
-
-  // title + _optional_ description
-  return lines.length <= 2 && lines[0].startsWith('#')
-}

package/src/util/request.ts

@@ -1,11 +0,0 @@
-import {getIt} from 'get-it'
-import {jsonRequest, jsonResponse, httpErrors, headers, promise} from 'get-it/middleware'
-import pkg from '../../package.json'
-
-export const request = getIt([
-  promise({onlyBody: true}),
-  jsonRequest(),
-  jsonResponse(),
-  httpErrors(),
-  headers({'User-Agent': `${pkg.name}@${pkg.version}`}),
-])

package/src/util/ts.ts

@@ -1,19 +0,0 @@
-import * as ts from 'typescript'
-import path from 'path'
-import {fileExists} from './files'
-
-export async function readTSConfig(options: {basePath: string; filename: string}) {
-  const {basePath, filename} = options
-  const filePath = path.resolve(basePath, filename)
-  const exists = await fileExists(filePath)
-
-  if (!exists) return undefined
-
-  return ts.readConfigFile(filePath, ts.sys.readFile).config
-    ? ts.parseJsonConfigFileContent(
-        ts.readConfigFile(filePath, ts.sys.readFile).config,
-        ts.sys,
-        basePath,
-      )
-    : undefined
-}

package/src/util/user.ts

@@ -1,129 +0,0 @@
-import path from 'path'
-import {execSync} from 'child_process'
-import xdgBasedir from 'xdg-basedir'
-import {validate as isValidEmail} from 'email-validator'
-import {readJsonFile} from './files'
-import {request} from './request'
-import {prompt} from './prompt'
-import {InjectOptions} from '../actions/inject'
-import {PackageJson} from '../actions/verify/types'
-
-export interface User {
-  name: string
-  email?: string
-}
-
-export async function getUserInfo(
-  {requireUserConfirmation, flags}: InjectOptions,
-  pkg?: PackageJson,
-): Promise<User | undefined> {
-  const userInfo =
-    getPackageUserInfo({author: flags.author ?? pkg?.author}) ||
-    (await getSanityUserInfo()) ||
-    ((await getGitUserInfo()) as User | undefined)
-  if (requireUserConfirmation) {
-    return promptForInfo(userInfo)
-  }
-
-  return userInfo
-}
-
-export function getPackageUserInfo(pkg?: {
-  author?:
-    | string
-    | {
-        name: string
-        email?: string
-      }
-}): User | undefined {
-  let author = pkg?.author
-  if (!author) {
-    return undefined
-  }
-
-  if (author && typeof author !== 'string') {
-    return author
-  } else if (!author.includes('@')) {
-    return {name: author}
-  }
-
-  const [pre, ...post] = author.replace(/[<>[\]]/g, '').split(/@/)
-  const nameParts = pre.split(/\s+/)
-  const email = [nameParts[nameParts.length - 1], ...post].join('@')
-  const name = nameParts.slice(0, -1).join(' ')
-  return {name, email}
-}
-
-async function promptForInfo(defValue?: User) {
-  const name = await prompt('Author name', {
-    filter: filterString,
-    default: defValue && defValue.name,
-    validate: requiredString,
-  })
-
-  const email = await prompt('Author email', {
-    filter: filterString,
-    default: defValue && defValue.email,
-    validate: validOrEmptyEmail,
-  })
-
-  return {name, email}
-}
-
-async function getSanityUserInfo(): Promise<User | undefined> {
-  try {
-    const data = await readJsonFile<{authToken?: string}>(
-      path.join(xdgBasedir.config ?? '', 'sanity', 'config.json'),
-    )
-    const token = data?.authToken
-
-    if (!token) {
-      return undefined
-    }
-
-    const user = await request({
-      url: 'https://api.sanity.io/v1/users/me',
-      headers: {Authorization: `Bearer ${token}`},
-    })
-
-    if (!user) {
-      return undefined
-    }
-
-    const {name, email} = user
-    return {name, email}
-  } catch (err) {
-    return undefined
-  }
-}
-
-async function getGitUserInfo(): Promise<User | undefined> {
-  try {
-    const name = execSync('git config user.name', {encoding: 'utf8'}).trim()
-    const email = execSync('git config user.email', {encoding: 'utf8'}).trim()
-
-    if (!name) {
-      return undefined
-    }
-
-    return {name, email: email || undefined}
-  } catch (err) {
-    return undefined
-  }
-}
-
-function filterString(val: string) {
-  return (val || '').trim()
-}
-
-function requiredString(value: string) {
-  return value.length > 1 ? true : 'Required'
-}
-
-function validOrEmptyEmail(value: string): true | string {
-  if (!value) {
-    return true
-  }
-
-  return isValidEmail(value) ? true : 'Must either be a valid email or empty'
-}