@sanity/plugin-kit 4.0.20 → 5.0.0

package/src/presets/semver-workflow.ts

@@ -1,186 +0,0 @@
-import {Injectable, InjectOptions, writeAssets} from '../actions/inject'
-import {resolveLatestVersions} from '../npm/resolveLatestVersions'
-import {Preset} from './presets'
-import {
-  addPackageJsonScripts,
-  addScript,
-  getPackage,
-  sortKeys,
-  writePackageJsonDirect,
-} from '../npm/package'
-import log from '../util/log'
-import outdent from 'outdent'
-import chalk from 'chalk'
-import path from 'path'
-import {readFile, writeFile} from '../util/files'
-import {errorToUndefined} from '../util/errorToUndefined'
-import {PackageJson} from '../actions/verify/types'
-import {developTestSnippet, getLicenseText, installationSnippet} from '../util/readme'
-import {getUserInfo} from '../util/user'
-
-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)
-  await updateReadme(options)
-}
-
-async function addPrepareScript(options: InjectOptions) {
-  const pkg = await getPackage(options)
-  const didWrite = await addPackageJsonScripts(pkg, options, (scripts) => {
-    scripts.prepare = addScript(`husky`, 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`
-        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: InjectOptions) {
-  const {basePath} = options
-
-  const readmePath = path.join(basePath, 'README.md')
-  const readme = (await readFile(readmePath, 'utf8').catch(errorToUndefined)) ?? ''
-
-  const {install, usage, developTest, license, releaseSnippet} = await readmeSnippets(options)
-
-  const prependSections = missingSections(readme, [install, usage])
-  const appendSections = missingSections(readme, [license, developTest, releaseSnippet])
-
-  if (prependSections.length || appendSections.length) {
-    const updatedReadme = [...prependSections, readme, ...appendSections]
-      .filter(Boolean)
-      .join('\n\n')
-    await writeFile(readmePath, updatedReadme, {encoding: 'utf8'})
-    log.info('Updated README. Please review the changes.')
-  }
-}
-
-async function readmeSnippets(options: InjectOptions) {
-  const pkg = await getPackage(options)
-  const user = await getUserInfo(options, pkg)
-
-  const bestEffortUrl = readmeBaseurl(pkg)
-
-  const install = installationSnippet(pkg.name ?? 'unknown')
-
-  const usage = outdent`
-    ## Usage
-  `
-
-  const license = getLicenseText(typeof pkg.license === 'string' ? pkg.license : undefined, user)
-
-  const 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,
-  }
-}
-
-/**
- * Returns sections that does not exists "close enough" in readme
- */
-export function missingSections(readme: string, sections: string[]) {
-  return sections.filter((section) => !closeEnough(section, readme))
-}
-
-/**
- * a and b are considered "close enough" if > 50% of a lines exist in b lines
- * @param a
- * @param b
- */
-function closeEnough(a: string, b: string) {
-  const aLines = a.split('\n')
-  const bLines = b.split('\n')
-
-  const matchingLines = aLines.filter((line) => bLines.find((bLine) => bLine === line)).length
-  const isCloseEnough = matchingLines >= aLines.length * 0.5
-  return isCloseEnough
-}
-
-function semverWorkflowFiles(): Injectable[] {
-  const base: Injectable[] = [
-    {
-      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'},
-  ]
-
-  return base.map((fromTo) => {
-    if (fromTo.type === 'copy') {
-      return {
-        ...fromTo,
-        from: ['semver-workflow', ...fromTo.from],
-      }
-    }
-
-    return fromTo
-  })
-}
-
-async function semverWorkflowDependencies(): Promise<Record<string, string>> {
-  return resolveLatestVersions([
-    '@commitlint/cli',
-    '@commitlint/config-conventional',
-    '@sanity/semantic-release-preset',
-    'husky',
-    'lint-staged',
-  ])
-}
-
-export function readmeBaseurl(pkg: PackageJson) {
-  return ((pkg.repository?.url ?? pkg.homepage ?? 'TODO') as string)
-    .replace(/.+:\/\//g, 'https://')
-    .replace(/\.git/g, '')
-    .replace(/git@github.com\//g, 'github.com/')
-    .replace(/git@github.com:/g, 'https://github.com/')
-    .replace(/#.+/g, '')
-}

package/src/presets/ui-workshop.ts

@@ -1,97 +0,0 @@
-import {Preset} from './presets'
-import {Injectable, InjectOptions, writeAssets} from '../actions/inject'
-import {getPackage, sortKeys, writePackageJsonDirect} from '../npm/package'
-import log from '../util/log'
-import chalk from 'chalk'
-import outdent from 'outdent'
-import {resolveLatestVersions} from '../npm/resolveLatestVersions'
-import path from 'path'
-import {readFile, writeFile} from '../util/files'
-import {errorToUndefined} from '../util/errorToUndefined'
-
-export const uiWorkshop: Preset = {
-  name: 'ui-workshop',
-  description: 'Files for testing custom components with @sanity/ui-workshop',
-  apply: applyPreset,
-}
-
-async function applyPreset(options: InjectOptions) {
-  await writeAssets(files(), options)
-  await addDevDependencies(options)
-  await updateGitIgnore(options)
-  log.info(
-    chalk.green(
-      outdent`
-        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(): Injectable[] {
-  const base: Injectable[] = [
-    {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'],
-    },
-  ]
-
-  return base.map((fromTo) => {
-    if (fromTo.type === 'copy') {
-      return {
-        ...fromTo,
-        from: ['ui-workshop', ...fromTo.from],
-      }
-    }
-
-    return fromTo
-  })
-}
-
-async function updateGitIgnore(options: InjectOptions) {
-  const {basePath} = options
-  const gitignorePath = path.join(basePath, '.gitignore')
-  let gitignore = (await readFile(gitignorePath, 'utf8').catch(errorToUndefined)) ?? ''
-  const value = '.workshop'
-  if (gitignore.includes(value)) {
-    return
-  }
-
-  gitignore += `\n\n${value}`
-  await writeFile(gitignorePath, gitignore, {encoding: 'utf8'})
-}
-
-async function addDevDependencies(options: InjectOptions) {
-  const pkg = await getPackage(options)
-  const devDeps = sortKeys({
-    ...pkg.devDependencies,
-    ...(await devDependencies()),
-  })
-  const newPkg = {...pkg}
-  newPkg.devDependencies = devDeps
-  await writePackageJsonDirect(newPkg, options)
-  log.info('Updated devDependencies.')
-}
-
-async function devDependencies(): Promise<Record<string, string>> {
-  return resolveLatestVersions([
-    '@sanity/ui-workshop',
-    '@sanity/icons',
-    '@sanity/ui',
-    'react',
-    'react-dom',
-    'styled-components',
-  ])
-}

package/src/presets/ui.ts

@@ -1,67 +0,0 @@
-import {Preset} from './presets'
-import {InjectOptions} from '../actions/inject'
-import {forceDependencyVersions, getPackage, sortKeys, writePackageJsonDirect} from '../npm/package'
-import log from '../util/log'
-import chalk from 'chalk'
-import {resolveLatestVersions} from '../npm/resolveLatestVersions'
-import {forcedDevPackageVersions, forcedPackageVersions} from '../configs/forced-package-versions'
-
-export const ui: Preset = {
-  name: 'ui',
-  description: '`@sanity/ui` and dependencies',
-  apply: applyPreset,
-}
-
-async function applyPreset(options: InjectOptions) {
-  await addDependencies(options)
-  await addDevDependencies(options)
-
-  log.info(chalk.green('ui preset injected'))
-}
-
-async function addDependencies(options: InjectOptions) {
-  const pkg = await getPackage(options)
-  const newDeps = sortKeys(
-    forceDependencyVersions(
-      {
-        ...pkg.dependencies,
-        ...(await resolveDependencyList()),
-      },
-      forcedPackageVersions,
-    ),
-  )
-  const newPkg = {...pkg}
-  newPkg.dependencies = newDeps
-  await writePackageJsonDirect(newPkg, options)
-  log.info('Updated dependencies.')
-}
-
-async function addDevDependencies(options: InjectOptions) {
-  const pkg = await getPackage(options)
-  const newDeps = sortKeys(
-    forceDependencyVersions(
-      {
-        ...pkg.devDependencies,
-        ...(await resolveDevDependencyList()),
-      },
-      forcedDevPackageVersions,
-    ),
-  )
-  const newPkg = {...pkg}
-  newPkg.devDependencies = newDeps
-  await writePackageJsonDirect(newPkg, options)
-  log.info('Updated devDependencies.')
-}
-
-async function resolveDependencyList(): Promise<Record<string, string>> {
-  return resolveLatestVersions(['@sanity/icons', '@sanity/ui'])
-}
-
-async function resolveDevDependencyList(): Promise<Record<string, string>> {
-  return resolveLatestVersions([
-    // install the peer dependencies of `@sanity/ui` as dev dependencies
-    'react',
-    'react-dom',
-    'styled-components',
-  ])
-}

package/src/sanity/manifest.ts

@@ -1,340 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import util from 'util'
-import pkg from '../../package.json'
-import {buildExtensions} from '../configs/buildExtensions'
-import {hasSourceFile, hasCompiledFile, readJsonFile, fileExists} from '../util/files'
-import {errorToUndefined} from '../util/errorToUndefined'
-
-const stat = util.promisify(fs.stat)
-const readFile = util.promisify(fs.readFile)
-
-const allowedPartProps = ['name', 'implements', 'path', 'description']
-const disallowedPluginProps = ['api', 'project', 'plugins', 'env']
-
-export interface SanityV2Manifest {
-  root?: boolean
-  name: string
-  paths: ManifestPaths
-  parts?: {
-    path: string
-  }[]
-}
-
-export interface ManifestPaths {
-  basePath: string
-  compiled?: string
-  source?: string
-}
-
-export interface ManifestOptions {
-  isPlugin?: boolean
-  validate?: boolean
-  pluginName?: string
-  basePath: string
-  verifySourceParts?: boolean
-  verifyCompiledParts?: boolean
-  paths?: ManifestPaths
-  flags?: Record<string, any>
-}
-
-export async function getPaths(options: ManifestOptions) {
-  const {basePath} = options
-  const manifest = await readManifest(options)
-  if (!manifest.paths) {
-    return null
-  }
-
-  return absolutifyPaths(manifest.paths, basePath)
-}
-
-function absolutifyPaths(paths: ManifestPaths | undefined, basePath: string) {
-  const getPath = (relative?: string) =>
-    relative ? path.resolve(path.join(basePath, relative)) : undefined
-  return paths
-    ? {
-        basePath,
-        compiled: getPath(paths.compiled),
-        source: getPath(paths.source),
-      }
-    : {basePath}
-}
-
-export async function readManifest(options: ManifestOptions) {
-  const {basePath, validate = true} = options
-  const manifestPath = path.normalize(path.join(basePath, 'sanity.json'))
-
-  let content
-  try {
-    content = await readFile(manifestPath, 'utf8')
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      throw new Error(
-        `No sanity.json found. sanity.json is required for plugins to function. Use \`${pkg.binname} init\` for a new plugin, or create an empty \`sanity.json\` with an empty object (\`{}\`) for existing ones.`,
-      )
-    }
-
-    throw new Error(`Failed to read "${manifestPath}": ${err.message}`)
-  }
-
-  let parsed
-  try {
-    parsed = JSON.parse(content)
-  } catch (err: any) {
-    throw new Error(`Error parsing "${manifestPath}": ${err.message}`)
-  }
-
-  if (validate) {
-    await validateManifest(parsed, options)
-  }
-
-  return parsed
-}
-
-export async function validateManifest(manifest: SanityV2Manifest, opts: ManifestOptions) {
-  const options = {isPlugin: true, ...opts}
-
-  if (!isObject(manifest)) {
-    throw new Error(`Invalid sanity.json: Root must be an object`)
-  }
-
-  if (options.isPlugin) {
-    await validatePluginManifest(manifest, options)
-  } else {
-    await validateProjectManifest(manifest)
-  }
-
-  if ('root' in manifest && typeof manifest.root !== 'boolean') {
-    throw new Error(`Invalid sanity.json: "root" property must be a boolean if declared`)
-  }
-
-  await validateParts(manifest, {
-    ...options,
-    paths: absolutifyPaths(manifest.paths, options.basePath),
-  })
-}
-
-function validateProjectManifest(manifest: SanityV2Manifest) {
-  if ('paths' in manifest) {
-    throw new Error(`Invalid sanity.json: "paths" property has no meaning in a project manifest`)
-  }
-}
-
-export async function validatePluginManifest(
-  manifest: SanityV2Manifest,
-  options: {basePath: string},
-) {
-  const disallowed = Object.keys(manifest)
-    .filter((key) => disallowedPluginProps.includes(key))
-    .map((key) => `"${key}"`)
-
-  if (disallowed.length > 0) {
-    const plural = disallowed.length > 1 ? 's' : ''
-    const joined = disallowed.join(', ')
-    throw new Error(
-      `Invalid sanity.json: Key${plural} ${joined} ${
-        plural ? 'are' : 'is'
-      } not allowed in a plugin manifest`,
-    )
-  }
-
-  if (manifest.root) {
-    throw new Error(`Invalid sanity.json: "root" cannot be truthy in a plugin manifest`)
-  }
-
-  await validatePaths(manifest, options)
-}
-
-export async function validatePaths(manifest: SanityV2Manifest, options: {basePath: string}) {
-  if (!('paths' in manifest)) {
-    return
-  }
-
-  if (!isObject(manifest.paths)) {
-    throw new Error(`Invalid sanity.json: "paths" must be an object if declared`)
-  }
-
-  if (typeof manifest.paths.compiled !== 'string') {
-    throw new Error(
-      `Invalid sanity.json: "paths" must have a (string) "compiled" property if declared`,
-    )
-  }
-
-  if (typeof manifest.paths.source !== 'string') {
-    throw new Error(
-      `Invalid sanity.json: "paths" must have a (string) "source" property if declared`,
-    )
-  }
-
-  const sourcePath = path.resolve(options.basePath, manifest.paths.source)
-  let srcStats
-  try {
-    srcStats = await stat(sourcePath)
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      throw new Error(`sanity.json references "source" path which does not exist: "${sourcePath}"`)
-    }
-  }
-
-  if (!srcStats?.isDirectory()) {
-    throw new Error(
-      `sanity.json references "source" path which is not a directory: "${sourcePath}"`,
-    )
-  }
-}
-
-async function validateParts(manifest: SanityV2Manifest, options: ManifestOptions) {
-  if (!('parts' in manifest)) {
-    return
-  }
-
-  if (!Array.isArray(manifest.parts)) {
-    throw new Error(`Invalid sanity.json: "parts" must be an array if declared`)
-  }
-
-  let i = 0
-  for (const part of manifest.parts) {
-    await validatePart(part, i, options)
-    i++
-  }
-}
-
-async function validatePart(part: Record<string, any>, index: number, options: ManifestOptions) {
-  if (!isObject(part)) {
-    throw new Error(`Invalid sanity.json: "parts[${index}]" must be an object`)
-  }
-
-  validateAllowedPartKeys(part, index)
-  validatePartStringValues(part, index)
-  validatePartNames(part, index, options)
-  await validatePartFiles(part, index, options)
-}
-
-async function validatePartFiles(
-  part: {path?: string} | undefined,
-  index: number,
-  options: ManifestOptions,
-) {
-  const {verifyCompiledParts, verifySourceParts, paths} = options
-  if (!part?.path) {
-    return
-  }
-
-  const ext = path.extname(part.path)
-  if (paths?.source && ext && ext !== '.js' && buildExtensions.includes(ext)) {
-    throw new Error(
-      `Invalid sanity.json: Part path has extension which is not applicable after compiling. ${ext} becomes .js after compiling. Specify filename without extension (${path.basename(
-        part.path,
-      )}) (parts[${index}])`,
-    )
-  }
-
-  if (!verifySourceParts && !verifyCompiledParts) {
-    return
-  }
-
-  const [srcExists, outDirExists] = await Promise.all([
-    hasSourceFile(part.path, paths),
-    verifyCompiledParts && hasCompiledFile(part.path, paths),
-  ])
-
-  if (!srcExists) {
-    throw new Error(
-      `Invalid sanity.json: Part path references file that does not exist in source directory (${
-        paths?.source || paths?.basePath
-      }) (parts[${index}])`,
-    )
-  }
-
-  if (verifyCompiledParts && !outDirExists) {
-    throw new Error(
-      `Invalid sanity.json: Part path references file ("${part.path}") that does not exist in compiled directory (${paths?.compiled}) (parts[${index}])`,
-    )
-  }
-}
-
-function validatePartNames(
-  part: {name?: string; implements?: string} | undefined,
-  index: number,
-  options: ManifestOptions,
-) {
-  const pluginName = options.pluginName ? options.pluginName.replace(/^sanity-plugin-/, '') : ''
-  if (!part?.name || !part?.name?.startsWith(`part:${pluginName}/`)) {
-    throw new Error(
-      `Invalid sanity.json: "name" must be prefixed with "part:${pluginName}/" - got "${part?.name}" (parts[${index}])`,
-    )
-  }
-
-  if (!part?.implements?.startsWith('part:')) {
-    throw new Error(
-      `Invalid sanity.json: "implements" must be prefixed with "part:" - got "${part?.implements}" (parts[${index}])`,
-    )
-  }
-}
-
-function validateAllowedPartKeys(part: Record<string, any>, index: number) {
-  const disallowed = Object.keys(part)
-    .filter((key) => !allowedPartProps.includes(key))
-    .map((key) => `"${key}"`)
-
-  if (disallowed.length > 0) {
-    const plural = disallowed.length > 1 ? 's' : ''
-    const joined = disallowed.join(', ')
-    throw new Error(
-      `Invalid sanity.json: Key${plural} ${joined} ${
-        plural ? 'are' : 'is'
-      } not allowed in a part declaration (parts[${index}])`,
-    )
-  }
-}
-
-function validatePartStringValues(part: Record<string, any>, index: number) {
-  const nonStrings = Object.keys(part)
-    .filter((key) => typeof part[key] !== 'string')
-    .map((key) => `"${key}"`)
-
-  if (nonStrings.length > 0) {
-    const plural = nonStrings.length > 1 ? 's' : ''
-    const joined = nonStrings.join(', ')
-    throw new Error(
-      `Invalid sanity.json: Key${plural} ${joined} should be of type string (parts[${index}])`,
-    )
-  }
-}
-
-function isObject(obj: any) {
-  return !Array.isArray(obj) && obj !== null && typeof obj === 'object'
-}
-
-export function getReferencesPartPaths(manifest: SanityV2Manifest, basePath: string) {
-  const {paths, parts = []} = manifest
-  const compiledPath = path.resolve(basePath, paths?.compiled || '')
-
-  return parts
-    .filter((part) => part.path)
-    .map((part) => part.path)
-    .map((partPath) => (path.extname(partPath) === '' ? `${partPath}.js` : partPath))
-    .map((partPath) =>
-      path.isAbsolute(partPath)
-        ? partPath // Not sure if this ever happens, but :shrugs:
-        : path.resolve(compiledPath, partPath),
-    )
-}
-
-export async function hasSanityJson(basePath: string) {
-  const file = await readJsonFile<{root?: boolean}>(path.join(basePath, 'sanity.json')).catch(
-    errorToUndefined,
-  )
-  return {exists: Boolean(file), isRoot: Boolean(file && file.root)}
-}
-
-export async function findStudioV3Config(basePath: string) {
-  const jsFile = 'sanity.config.js'
-  const jsExists = await fileExists(path.join(basePath, jsFile))
-  if (jsExists) {
-    return {v3ConfigFile: jsFile}
-  }
-  const tsFile = 'sanity.config.ts'
-  const tsExists = await fileExists(path.join(basePath, tsFile))
-  return {v3ConfigFile: tsExists ? tsFile : undefined}
-}

package/src/sharedFlags.ts

@@ -1,14 +0,0 @@
-export default {
-  debug: {
-    default: false,
-    type: 'boolean',
-  },
-  silent: {
-    type: 'boolean',
-    default: false,
-  },
-  verbose: {
-    type: 'boolean',
-    default: false,
-  },
-} as const