@sanity/plugin-kit 0.0.1-studio-v3.1

package/src/util/prompt.ts

@@ -0,0 +1,70 @@
+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 {SplatOptions} from '../actions/splat'
+
+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}: SplatOptions, 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: SplatOptions, 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

@@ -0,0 +1,72 @@
+import outdent from 'outdent'
+// @ts-expect-error missing types
+import licenses from '@rexxars/choosealicense-list'
+import {PackageData} from '../actions/splat'
+import {User} from './user'
+
+export function generateReadme(data: PackageData) {
+  const {user, pluginName, license, description} = data
+
+  return outdent`
+    # ${pluginName}
+
+    ## Installation
+
+    \`\`\`
+    npm install --save ${pluginName}
+    \`\`\`
+
+    or
+
+    \`\`\`
+    yarn add ${pluginName}
+    \`\`\`
+
+    ## Usage
+    Add it as a plugin in sanity.config.ts (or .js):
+
+    \`\`\`
+     import {createConfig} from 'sanity'
+     import {myPlugin} from '${pluginName}'
+
+     export const createConfig({
+         /...
+         plugins: [
+             myPlugin({})
+         ]
+     })
+    \`\`\`
+    ${getLicenseText(license?.id, user?.name ? (user as User) : undefined)}
+  `
+}
+
+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} © ${user?.name}\nSee LICENSE`
+  } else if (licenseName) {
+    licenseText = `${licenseText}\n${licenseName}\nSee LICENSE`
+  } else {
+    licenseText = `${licenseText}\nSee 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

@@ -0,0 +1,13 @@
+// @ts-expect-error missing types
+import getIt from 'get-it'
+// @ts-expect-error missing types
+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/user.ts

@@ -0,0 +1,110 @@
+import path from 'path'
+import xdgBasedir from 'xdg-basedir'
+// @ts-expect-error missing types
+import gitUserInfo from 'git-user-info'
+import {validate as isValidEmail} from 'email-validator'
+import {readJsonFile} from './files'
+import {request} from './request'
+import {prompt} from './prompt'
+import {SplatOptions} from '../actions/splat'
+import {PackageJson} from '../actions/verify/types'
+
+export interface User {
+  name: string
+  email?: string
+}
+
+export async function getUserInfo(
+  {requireUserConfirmation, flags}: SplatOptions,
+  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}): User | undefined {
+  if (!pkg || !pkg.author) {
+    return undefined
+  }
+
+  if (!pkg.author.includes('@')) {
+    return {name: pkg.author}
+  }
+
+  const [pre, ...post] = pkg.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
+  }
+}
+
+function getGitUserInfo(): User | undefined {
+  const user = gitUserInfo()
+  return user ? {name: user.name, email: user.email} : 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'
+}