@sanity/plugin-kit 4.0.20 → 5.0.0

package/src/configs/pkg-config.ts

@@ -1,30 +0,0 @@
-import {outdent} from 'outdent'
-import {InjectTemplate} from '../actions/inject'
-import {InitFlags} from '../actions/init'
-
-export function pkgConfigTemplate(options: {outDir: string; flags: InitFlags}): InjectTemplate {
-  const {flags, outDir} = options
-
-  return {
-    type: 'template',
-    force: flags.force,
-    to: flags.typescript ? 'package.config.ts' : 'package.config.js',
-    value: outdent`
-      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',
-          },
-        },
-      })
-    `,
-  }
-}

package/src/configs/prettier.ts

@@ -1,11 +0,0 @@
-import {InjectTemplate} from '../actions/inject'
-
-export function prettierignoreTemplate(options: {outDir: string}): InjectTemplate {
-  const {outDir} = options
-
-  return {
-    type: 'template',
-    to: '.prettierignore',
-    value: [outDir, 'pnpm-lock.yaml', 'yarn.lock', 'package-lock.json'].join('\n'),
-  }
-}

package/src/configs/tsconfig.ts

@@ -1,78 +0,0 @@
-import {outdent} from 'outdent'
-import {InjectTemplate} from '../actions/inject'
-import {InitFlags} from '../actions/init'
-
-export function tsconfigTemplate(options: {flags: InitFlags}): InjectTemplate {
-  const {flags} = options
-
-  return {
-    type: 'template',
-    force: flags.force,
-    to: 'tsconfig.json',
-    value: outdent`
-      {
-        "extends": "./tsconfig.settings",
-        "include": ["./src", "./package.config.ts"]
-      }
-    `,
-  }
-}
-
-export function tsconfigTemplateDist(options: {outDir: string; flags: InitFlags}): InjectTemplate {
-  const {flags, outDir} = options
-
-  return {
-    type: 'template',
-    force: flags.force,
-    to: `tsconfig.${outDir}.json`,
-    value: outdent`
-      {
-        "extends": "./tsconfig.settings",
-        "include": ["./src"],
-        "exclude": [
-          "./src/**/__fixtures__",
-          "./src/**/__mocks__",
-          "./src/**/*.test.ts",
-          "./src/**/*.test.tsx"
-        ]
-      }
-    `,
-  }
-}
-
-export function tsconfigTemplateSettings(options: {
-  outDir: string
-  flags: InitFlags
-}): InjectTemplate {
-  const {flags, outDir} = options
-
-  return {
-    type: 'template',
-    force: flags.force,
-    to: `tsconfig.settings.json`,
-    value: outdent`
-      {
-        "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
-        }
-      }
-    `,
-  }
-}

package/src/configs/uselessFiles.ts

@@ -1,29 +0,0 @@
-export const uselessFiles = [
-  '.babel.config.js',
-  '.babelrc',
-  '.drone.yml',
-  '.editorconfig',
-  '.eslintignore',
-  '.eslintrc-ts.js',
-  '.eslintrc-ts',
-  '.eslintrc',
-  '.gitignore',
-  '.github',
-  '.nyc_output',
-  '.prettierrc',
-  '.stylelintignore',
-  '.stylelintrc.json',
-  '.stylelintrc',
-  '.travis.yaml',
-  '.travis.yml',
-  'babel.config.js',
-  'coverage',
-  'gulpfile.js',
-  'lcov-report',
-  'lerna.json',
-  'now.json',
-  'vercel.json',
-  'netlify.toml',
-  'postcss.config.js',
-  'tsconfig.json',
-]

package/src/constants.ts

@@ -1,15 +0,0 @@
-export const cliName = '@sanity/plugin-kit'
-
-export const urls = {
-  refDocs: 'https://beta.sanity.io/docs/reference',
-  migrationGuideStudio: 'https://beta.sanity.io/docs/platform/v2-to-v3',
-  migrationGuidePlugin: 'https://beta.sanity.io/docs/platform/v2-to-v3/plugins',
-  pluginReadme: 'https://github.com/sanity-io/plugin-kit',
-  incompatiblePlugin: 'https://github.com/sanity-io/incompatible-plugin',
-  sanityExchange: 'https://www.sanity.io/exchange',
-  linterPackage: 'https://github.com/sanity-io/eslint-config-no-v2-imports',
-}
-
-export const incompatiblePluginPackage = '@sanity/incompatible-plugin'
-
-export const defaultOutDir = 'dist'

package/src/dependencies/find.ts

@@ -1,193 +0,0 @@
-/*
-import fs from 'fs'
-import path from 'path'
-import postcss from 'postcss'
-import {discoverPathSync} from 'discover-path'
-import traverse from '@babel/traverse'
-import {parseSync} from '@babel/core'
-
-export default {findDependencies}
-
-const partReg = /^(all:part|part|config|sanity):/
-const importReg = /^(?:"([^"]+)"|'([^']+)')$/
-const composesReg = /^(.+?)\s+from\s+(?:"([^"]+)"|'([^']+)'|(global))$/
-
-function findDependenciesFromFiles(files, seen = new Set<string>()): string[] {
-  const dependencies = new Set<string>()
-  files.forEach((file) => findDependencies(file, seen).forEach((dep) => dependencies.add(dep)))
-  return Array.from(dependencies)
-}
-
-function findDependenciesInCss(css, entryPath, processDependency) {
-  let ast
-  try {
-    ast = postcss.parse(css)
-  } catch (err: any) {
-    throw new Error(`Error parsing file (${entryPath}): ${err.message}`)
-  }
-
-  ast.walkDecls(/^composes/, (decl) => {
-    const matches = decl.value.match(composesReg)
-    if (!matches) {
-      return
-    }
-
-    const [, , doubleQuotePath, singleQuotePath] = matches
-    const importPath = doubleQuotePath || singleQuotePath
-    if (importPath) {
-      processDependency(importPath)
-    }
-  })
-
-  ast.walkAtRules('import', (rule) => {
-    const matches = rule.params.match(importReg)
-    if (!matches) {
-      return
-    }
-
-    const [, doubleQuotePath, singleQuotePath] = matches
-    const importPath = doubleQuotePath || singleQuotePath
-    if (importPath) {
-      processDependency(importPath)
-    }
-  })
-}
-
-interface Traverse {
-  node: {callee: {name: string}; source: {value: string}; arguments: {value: string}[]}
-}
-
-function findDependenciesInJs(
-  js: string,
-  entryPath: string,
-  processDependency: (val: string) => void
-) {
-  let ast
-  try {
-    ast = parseSync(js, {babelrc: false})
-  } catch (err: any) {
-    throw new Error(`Error parsing file (${entryPath}): ${err.message}`)
-  }
-
-  traverse(ast, {
-    ImportDeclaration({node}: Traverse) {
-      processDependency(node.source.value)
-    },
-
-    CallExpression({node}: Traverse) {
-      if (node.callee.name === 'require') {
-        processDependency(node.arguments[0].value)
-      }
-    },
-  })
-}
-
-export function findDependencies(entryPath: string, seen = new Set<string>()): string[] {
-  if (Array.isArray(entryPath)) {
-    return findDependenciesFromFiles(entryPath, seen)
-  }
-
-  seen.add(entryPath)
-
-  let content
-  try {
-    content = fs.readFileSync(entryPath, 'utf8')
-  } catch (err: any) {
-    throw new Error(`Error reading file (${entryPath}): ${err.message}`)
-  }
-
-  const dir = path.dirname(entryPath)
-  const dependencies = new Set<string>()
-
-  if (entryPath.endsWith('.css')) {
-    findDependenciesInCss(content, entryPath, processDependency)
-  } else {
-    findDependenciesInJs(content, entryPath, processDependency)
-  }
-
-  function processDependency(requirePath: string) {
-    if (typeof requirePath !== 'string') {
-      return
-    }
-
-    // Don't allow absolute requires
-    if (path.isAbsolute(requirePath)) {
-      throw new Error(
-        `Absolute paths cannot be used in require/import statements: ${entryPath} references path "${requirePath}"`
-      )
-    }
-
-    const isRelative = requirePath.startsWith('.')
-    const depPath = isRelative && resolveDependency(dir, requirePath, entryPath)
-
-    if (
-      depPath &&
-      ['.js', '.css', '.esm', '.mjs', '.jsx'].includes(path.extname(depPath)) &&
-      !seen.has(depPath)
-    ) {
-      // For relative javascript/css requires, recurse to find all depdendencies
-      findDependencies(depPath, seen).forEach((dep) => dependencies.add(dep))
-      return
-    }
-
-    if (isRelative) {
-      // Not JS? Skip it
-      return
-    }
-
-    // For parts, we want the entire path, as we might want to validate them
-    if (partReg.test(requirePath)) {
-      dependencies.add(requirePath)
-      return
-    }
-
-    // For modules, resolve the base module name, then add them
-    // eg: `codemirror/mode/javascript` => `codemirror`
-    // eg: `@sanity/base/foo/bar.js`    => `@sanity/base`
-    const dep = requirePath.startsWith('@')
-      ? requirePath.replace(/^(@[^/]+\/[^/]+)(\/.*|$)/, '$1')
-      : requirePath.replace(/^([^/]+)(\/.*|$)/, '$1')
-
-    dependencies.add(dep)
-  }
-
-  return Array.from(dependencies)
-}
-
-function resolveDependency(fromDir: string, toPath: string, entryPath: string) {
-  const [querylessPath] = toPath.split('?', 1)
-
-  let depPath
-  try {
-    depPath = require.resolve(path.resolve(fromDir, querylessPath))
-  } catch (err) {
-    throw new Error(`Unable to resolve "${querylessPath}" from ${entryPath}`)
-  }
-
-  let actualPath
-  try {
-    actualPath = discoverPathSync(depPath)
-  } catch (err: any) {
-    const paths = (err.suggestions || []).map((suggested: string) =>
-      getDidYouMeanPath(querylessPath, suggested)
-    )
-    const didYouMean = paths ? `Did you mean:\n${paths.join('\n- ')}` : ''
-    throw new Error(`Unable to resolve "${querylessPath}" from ${entryPath}. ${didYouMean}`)
-  }
-
-  if (actualPath !== depPath) {
-    const didYouMean = getDidYouMeanPath(querylessPath, actualPath)
-    throw new Error(
-      `Unable to resolve "${querylessPath} from ${entryPath}. Did you mean "${didYouMean}"?`
-    )
-  }
-
-  return actualPath
-}
-
-function getDidYouMeanPath(wanted: string, suggested: string) {
-  const end = wanted.replace(/[./]+/, '')
-  const start = wanted.slice(0, 0 - end.length)
-  return `${start}${suggested.slice(0 - end.length)}`
-}
-*/

package/src/dependencies/import-linter.ts

@@ -1,95 +0,0 @@
-import log from '../util/log'
-import {mergedPackages} from '../configs/banned-packages'
-import {urls} from '../constants'
-import {ESLint} from 'eslint'
-import path from 'path'
-import outdent from 'outdent'
-
-const removedImportSuffix = `imports where removed in Sanity v3. Please refer to the migration guide: ${urls.migrationGuideStudio}, or new API-reference docs: ${urls.refDocs}`
-
-export async function validateImports({basePath}: {basePath: string}): Promise<string[]> {
-  log.debug('Running ESLint with Sanity Studio import hints...')
-  const eslint = new ESLint({
-    cwd: basePath,
-    overrideConfig: {
-      ignorePatterns: ['node_modules'],
-      rules: {
-        'no-restricted-imports': [
-          'error',
-          {
-            patterns: [
-              ...mergedPackages.map((packageName) => ({
-                group: [`${packageName}*`],
-                message: `Use sanity instead of ${packageName}.`,
-              })),
-              {
-                group: ['config:*'],
-                message: `config: imports are no longer supported. Please see the new plugin API for alternatives: ${urls.migrationGuideStudio}`,
-              },
-              {
-                group: ['part:*'],
-                message: `part: ${removedImportSuffix}`,
-              },
-              {
-                group: ['all:part:*'],
-                message: `all:part: ${removedImportSuffix}`,
-              },
-              {
-                group: ['sanity:*'],
-                message: `sanity: ${removedImportSuffix}`,
-              },
-            ],
-          },
-        ],
-      },
-    },
-  })
-
-  try {
-    const results = await eslint.lintFiles([path.join(basePath, '**/*.{js,jsx,ts,tsx}')])
-
-    const onlyImportErrors = results
-      .map((r) => {
-        const limitErrors = r.messages.filter((m) => m.ruleId === 'no-restricted-imports')
-        return {
-          ...r,
-          messages: limitErrors,
-          errorCount: limitErrors.length,
-        }
-      })
-      .filter((r) => r.errorCount)
-
-    if (onlyImportErrors.length) {
-      const formatter = await eslint.loadFormatter('stylish')
-      const resultText = await formatter.format(onlyImportErrors)
-
-      const addtionalInfo = outdent`
-        ESLint detected Studio V2 imports that are no longer available.
-        It is recommended configure @sanity/eslint-config-no-v2-imports for ESLint.
-
-        Run:
-        npm install --save-dev @sanity/eslint-config-no-v2-imports
-
-        In .eslintrc add:
-        "extends": ["@sanity/no-v2-imports"]
-
-        This way, V2-imports can be identified directly in the IDE, or using eslint CLI.
-        For more, see ${urls.linterPackage}
-
-        If the plugin package does not use eslint, disable this check.
-    `
-      return [resultText + addtionalInfo]
-    }
-  } catch (e) {
-    log.error('Failed to run eslint check', e)
-    return [
-      outdent`
-        Failed to run ESLint. Is ESLint configured?
-
-        If the package does not use eslint, disable this check.
-    `,
-    ]
-  }
-
-  return []
-}

package/src/index.ts

@@ -1 +0,0 @@
-export {}

package/src/npm/manager.ts

@@ -1,44 +0,0 @@
-import execa from 'execa'
-import {prompt} from '../util/prompt'
-
-export function npmIsAvailable() {
-  return execa('npm', ['-v'])
-    .then(() => true)
-    .catch(() => false)
-}
-
-export function yarnIsAvailable() {
-  return execa('yarn', ['-v'])
-    .then(() => true)
-    .catch(() => false)
-}
-
-export function pnpmAvailable() {
-  return execa('pnpm', ['-v'])
-    .then(() => true)
-    .catch(() => false)
-}
-
-export async function promptForPackageManager() {
-  const [npm, yarn, pnpm] = await Promise.all([
-    npmIsAvailable(),
-    yarnIsAvailable(),
-    pnpmAvailable(),
-  ])
-
-  const choices = [npm && 'npm', yarn && 'yarn', pnpm && 'pnpm'].filter(Boolean)
-  if (choices.length < 2) {
-    return choices[0] || 'npm'
-  }
-
-  return prompt('Which package manager do you prefer?', {
-    choices: choices.map((value) => ({value, name: value})),
-    default: choices[0],
-  })
-}
-
-export async function installDependencies(pm: string, {cwd}: {cwd?: string}) {
-  const proc = execa(pm, ['install'], {cwd, stdio: 'inherit'})
-  const {exitCode} = await proc
-  return exitCode <= 0
-}