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

package/lib/src/actions/verify-studio.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyStudio = void 0;
+const package_1 = require("../npm/package");
+const log_1 = __importDefault(require("../util/log"));
+const files_1 = require("../util/files");
+const constants_1 = require("../constants");
+const import_linter_1 = require("../dependencies/import-linter");
+const outdent_1 = __importDefault(require("outdent"));
+const chalk_1 = __importDefault(require("chalk"));
+const verify_common_1 = require("./verify/verify-common");
+const validations_1 = require("./verify/validations");
+function verifyStudio({ basePath, flags }) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let errors = [];
+        const packageJson = yield (0, package_1.getPackage)({ basePath, validate: false });
+        const verifyConfig = ((_a = packageJson.sanityPlugin) === null || _a === void 0 ? void 0 : _a.verifyPackage) || {};
+        const validation = (0, verify_common_1.createValidator)(verifyConfig, flags, errors);
+        const tsConfig = yield (0, files_1.readJson5File)({ basePath, filename: 'tsconfig.json' });
+        yield validation('studioConfig', () => __awaiter(this, void 0, void 0, function* () { return (0, validations_1.validateStudioConfig)({ basePath }); }));
+        yield validation('dependencies', () => __awaiter(this, void 0, void 0, function* () { return (0, validations_1.validateSanityDependencies)(packageJson); }));
+        yield validation('eslintImports', () => __awaiter(this, void 0, void 0, function* () { return (0, import_linter_1.validateImports)({ basePath }); }));
+        if (errors.length) {
+            throw new Error((0, outdent_1.default) `
+        Detected validation issues!
+        This Sanity Studio is not completely V3 ready. Fix the issues starting from the top, or disable any checks you deem unnecessary.
+
+        More information is available here:
+        - Migration guide: ${constants_1.urls.migrationGuideStudio}
+        - Reference documentation: ${constants_1.urls.refDocs}
+
+        ${chalk_1.default.grey(`To fail-fast on first detected issue run:\nnpx ${constants_1.cliName} verify-studio --single`)}
+      `.trimStart());
+        }
+        yield (0, verify_common_1.runTscMaybe)(verifyConfig, tsConfig);
+        log_1.default.success((0, outdent_1.default) `
+    No outstanding upgrade issues detected. Studio is V3 ready!
+  `.trim());
+    });
+}
+exports.verifyStudio = verifyStudio;
+//# sourceMappingURL=verify-studio.js.map

package/lib/src/actions/verify-studio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-studio.js","sourceRoot":"","sources":["../../../src/actions/verify-studio.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,4CAAyC;AACzC,sDAA6B;AAC7B,yCAA2C;AAC3C,4CAA0C;AAC1C,iEAA6D;AAC7D,sDAA6B;AAC7B,kDAAyB;AACzB,0DAK+B;AAE/B,sDAAqF;AAErF,SAAsB,YAAY,CAAC,EAAC,QAAQ,EAAE,KAAK,EAAyC;;;QAC1F,IAAI,MAAM,GAAa,EAAE,CAAA;QAEzB,MAAM,WAAW,GAAgB,MAAM,IAAA,oBAAU,EAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAC,CAAC,CAAA;QAC9E,MAAM,YAAY,GAAwB,CAAA,MAAA,WAAW,CAAC,YAAY,0CAAE,aAAa,KAAI,EAAE,CAAA;QAEvF,MAAM,UAAU,GAAG,IAAA,+BAAe,EAAC,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,CAAA;QAE/D,MAAM,QAAQ,GAAG,MAAM,IAAA,qBAAa,EAAW,EAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAC,CAAC,CAAA;QAErF,MAAM,UAAU,CAAC,cAAc,EAAE,GAAS,EAAE,gDAAC,OAAA,IAAA,kCAAoB,EAAC,EAAC,QAAQ,EAAC,CAAC,CAAA,GAAA,CAAC,CAAA;QAC9E,MAAM,UAAU,CAAC,cAAc,EAAE,GAAS,EAAE,gDAAC,OAAA,IAAA,wCAA0B,EAAC,WAAW,CAAC,CAAA,GAAA,CAAC,CAAA;QACrF,MAAM,UAAU,CAAC,eAAe,EAAE,GAAS,EAAE,gDAAC,OAAA,IAAA,+BAAe,EAAC,EAAC,QAAQ,EAAC,CAAC,CAAA,GAAA,CAAC,CAAA;QAE1E,IAAI,MAAM,CAAC,MAAM,EAAE;YACjB,MAAM,IAAI,KAAK,CACb,IAAA,iBAAO,EAAA;;;;;6BAKgB,gBAAI,CAAC,oBAAoB;qCACjB,gBAAI,CAAC,OAAO;;UAEvC,eAAK,CAAC,IAAI,CACV,kDAAkD,mBAAO,yBAAyB,CACnF;OACF,CAAC,SAAS,EAAE,CACd,CAAA;SACF;QAED,MAAM,IAAA,2BAAW,EAAC,YAAY,EAAE,QAAQ,CAAC,CAAA;QAEzC,aAAG,CAAC,OAAO,CACT,IAAA,iBAAO,EAAA;;GAER,CAAC,IAAI,EAAE,CACP,CAAA;;CACF;AAtCD,oCAsCC"}

package/lib/src/actions/verify.js

@@ -0,0 +1,330 @@
+"use strict";
+/*
+import path from 'path'
+//@ts-expect-error missing types
+import spdxLicenseIds from 'spdx-license-ids'
+import semver from 'semver'
+
+import log from '../util/log'
+import {fileExists, readJsonFile} from '../util/files'
+import {readManifest, getReferencesPartPaths} from '../sanity/manifest'
+import {getPackage, getReferencedPaths} from '../npm/package'
+import {getPublishableFiles} from '../npm/publish'
+import {findDependencies} from '../dependencies/find'
+import {uselessFiles} from '../configs/uselessFiles'
+
+export async function verify({basePath, flags}) {
+  const pkg = await getPackage({basePath, flags})
+  const manifest = await readManifest({
+    basePath,
+    pluginName: pkg.name,
+    flags,
+    verifyCompiledParts: true,
+    verifySourceParts: true,
+  })
+
+  // Get all files intended to be published from npm
+  const publishableFiles = await getPublishableFiles(basePath)
+
+  // Errors
+  await verifyPublishableFiles({basePath, pkg, manifest, publishableFiles})
+  await verifyLicenseKey(pkg)
+  await verifyPluginConfig(basePath)
+  await verifyImports({pkg, manifest, basePath})
+
+  // Warnings
+  const hasWarnings = await warnOnUselessFiles(publishableFiles)
+
+  // Huzzah
+  log.success(
+    hasWarnings
+      ? 'Plugin has warnings, but looks good to publish!'
+      : 'Plugin looks good to publish!'
+  )
+}
+
+async function verifyPublishableFiles({pkg, manifest, basePath, publishableFiles}) {
+  // Validate that these files exists, not just that they are publishable
+  if (!(await fileExists(path.resolve(basePath, 'README.md')))) {
+    throw new Error(
+      `This plugin does not contain a README.md, which is required for Sanity plugins.`
+    )
+  }
+
+  const [hasLicense, hasLicenseMd] = await Promise.all([
+    fileExists(path.resolve(basePath, 'LICENSE')),
+    fileExists(path.resolve(basePath, 'LICENSE.md')),
+  ])
+
+  if (!hasLicense && !hasLicenseMd) {
+    throw new Error(
+      `This plugin does not contain a LICENSE-file, which is required for Sanity plugins.`
+    )
+  }
+
+  // Always, uhm... "kindly suggest", to include these files
+  const files = ['README.md']
+    // Get files from parts as well as the ones references in package.json
+    .concat(getReferencesPartPaths(manifest, basePath), getReferencedPaths(pkg, basePath))
+    // Make all paths relative to base path
+    .map((file) =>
+      path.relative(basePath, path.isAbsolute(file) ? file : path.resolve(basePath, file))
+    )
+    // Remove duplicates
+    .filter((file, index, arr) => arr.indexOf(file, index + 1) === -1)
+
+  // Verify that all explicitly referenced files are publishable
+  const unpublishable = files.filter((file) => !publishableFiles.includes(file))
+
+  // Warn with "default error" for unknowns
+  const unknowns = unpublishable.filter((item) => item !== 'README.md').map((file) => `"${file}"`)
+
+  if (unknowns.length > 0) {
+    const paths = unknowns.join(', ')
+    throw new Error(
+      `This plugin references files that are ignored from being published: ${paths}. Check .gitignore, .npmignore and/or the "files" property of package.json. See https://docs.npmjs.com/using-npm/developers.html#keeping-files-out-of-your-package for more information.`
+    )
+  }
+}
+
+function verifyLicenseKey(pkg) {
+  if (!pkg.license) {
+    throw new Error(
+      `package.json is missing "license" key: see https://docs.npmjs.com/files/package.json#license and make sure it matches your "LICENSE" file. See https://choosealicense.com/ for help on choosing a license.`
+    )
+  }
+
+  if (pkg.license !== 'UNLICENSED' && !spdxLicenseIds.includes(pkg.license)) {
+    throw new Error(
+      `package.json has an invalid "license" key: it should be either an SPDX license ID (https://spdx.org/licenses/) or "UNLICENSE". See https://docs.npmjs.com/files/package.json#license and refer to https://choosealicense.com/ for help on choosing a license.`
+    )
+  }
+}
+
+async function verifyPluginConfig(basePath) {
+  const configPath = path.join(basePath, 'config.dist.json')
+  if (!(await fileExists(configPath))) {
+    return
+  }
+
+  let config
+  try {
+    config = await readJsonFile(configPath)
+  } catch (err: any) {
+    throw new Error(`Error reading plugin config (${configPath}): ${err.message}`)
+  }
+
+  if (typeof config !== 'object' || Array.isArray(config) || !config) {
+    throw new Error(
+      `Error reading plugin config (${configPath}): must be an object, got:\n${JSON.stringify(
+        config,
+        null,
+        2
+      )}`
+    )
+  }
+}
+
+function warnOnUselessFiles(files) {
+  const warnFor = files
+    .filter(
+      (file) =>
+        uselessFiles.includes(file) ||
+        uselessFiles.some((useless) => file.startsWith(`${useless}/`))
+    )
+    .map((file) => `"${file}"`)
+    .join(', ')
+
+  if (warnFor.length === 0) {
+    return false
+  }
+
+  log.warn(
+    `This plugin is set to publish the following files, which are generally not needed in a published npm module: ${warnFor}.`
+  )
+  log.warn(
+    `Consider adding these files to an .npmignore or the package.json "files" property. See https://docs.npmjs.com/using-npm/developers.html#keeping-files-out-of-your-package for more information.`
+  )
+
+  return true
+}
+
+async function verifyImports({pkg, manifest, basePath}) {
+  // "Entry" as in... code may start here.
+  const entries = ([] as string[])
+    .concat(
+      getReferencedPaths(pkg, basePath), // From npm
+      getReferencesPartPaths(manifest, basePath) // From parts
+    )
+    // Remove duplicates
+    .filter((file, index, arr) => arr.indexOf(file, index + 1) === -1)
+    // Remove non-javascript/non-css entries
+    .filter((file) => ['.js', '.css'].includes(path.extname(file)))
+
+  const dependencies = findDependencies(entries)
+  const modules = dependencies.filter((dep) => !/^(all|part|config|sanity):/.test(dep))
+
+  await verifyNoUndeclaredDependencies(modules, pkg)
+  await verifyReactDependencies(modules, pkg)
+  await verifyUiDependencies(modules, pkg)
+  await verifyConfigParts(dependencies, pkg, basePath)
+  await verifyNoUnusedDependencies(modules, pkg)
+  await verifyNoUndeclaredParts(dependencies, pkg, manifest)
+}
+
+function verifyNoUndeclaredParts(dependencies, pkg, manifest) {
+  const parts = dependencies
+    .filter((dep) => dep.startsWith('all:') || dep.startsWith('part:'))
+    .map((part) => part.replace(/^all:/, ''))
+    .map((part) => part.replace(/\?$/, ''))
+    .filter((part) => part.startsWith(`part:${pkg.name.replace(/^sanity-plugin-/, '')}`))
+
+  const declaredParts = (manifest.parts || []).reduce(
+    (partNames, part) => [...partNames, ...[part.name, part.implements].filter(Boolean)],
+    []
+  )
+  const undeclaredParts = parts.filter((partName) => !declaredParts.includes(partName))
+
+  if (undeclaredParts.length > 0) {
+    const aPart = undeclaredParts.length > 1 ? 'parts' : 'a part'
+    const is = undeclaredParts.length > 1 ? 'are' : 'is'
+    const partList = undeclaredParts.map((part) => `"${part}"`).join(', ')
+    throw new Error(
+      `Invalid plugin: Source is using ${aPart} that ${is} not declared in "sanity.json":\n\n${partList}.`
+    )
+  }
+}
+
+function verifyNoUnusedDependencies(modules, pkg) {
+  const potentiallyUnused = Object.keys(pkg.dependencies || {}).filter(
+    (dep) => !modules.includes(dep)
+  )
+
+  if (potentiallyUnused.length > 0) {
+    const unusedNames = potentiallyUnused.map((dep) => `"${dep}"`).join(', ')
+    log.warn(`Found modules listed as dependencies which seem to be unused by code: ${unusedNames}`)
+  }
+}
+
+function verifyReactDependencies(modules, pkg) {
+  if (modules.includes('react') && 'react' in (pkg.dependencies || {})) {
+    throw new Error(
+      `Invalid plugin: "react" declared as a dependency - it should be declared as a peerDependency (package.json)`
+    )
+  }
+
+  if (modules.includes('react-dom') && 'react-dom' in (pkg.dependencies || {})) {
+    throw new Error(
+      `Invalid plugin: "react-dom" declared as a dependency - it should be declared as a peerDependency (package.json)`
+    )
+  }
+
+  if (modules.includes('prop-types') && 'prop-types' in (pkg.peerDependencies || {})) {
+    throw new Error(
+      `Invalid plugin: "prop-types" declares as peerDependency - it should be declared as a dependency (package.json)`
+    )
+  }
+}
+
+function verifyUiDependencies(modules, pkg) {
+  const peerDependencies = pkg.peerDependencies || {}
+  const dependencies = pkg.dependencies || {}
+
+  if (modules.includes('@sanity/ui') && '@sanity/ui' in peerDependencies) {
+    throw new Error(
+      `Invalid plugin: "@sanity/ui" declared as a peer dependency - it should be declared as a dependency (package.json)`
+    )
+  }
+
+  if (
+    modules.includes('@sanity/ui') &&
+    dependencies['@sanity/ui'] &&
+    semver.lt(semver.minVersion(dependencies['@sanity/ui']), '0.33.1')
+  ) {
+    throw new Error(
+      `Invalid plugin: "@sanity/ui" dependency must use version higher than or equal to 0.33.1 (package.json)`
+    )
+  }
+
+  if (modules.includes('@sanity/icons') && '@sanity/icons' in peerDependencies) {
+    throw new Error(
+      `Invalid plugin: "@sanity/icons" declared as a peer dependency - it should be declared as a dependency (package.json)`
+    )
+  }
+}
+
+async function verifyConfigParts(dependencies, pkg, basePath) {
+  const configName = `config:${pkg.name.replace(/^sanity-plugin-/, '')}`
+  if (
+    dependencies.includes(configName) &&
+    !(await fileExists(path.join(basePath, 'config.dist.json')))
+  ) {
+    throw new Error(
+      `Plugin imports plugin config (${configName}) but does not contain a "config.dist.json" file.`
+    )
+  }
+
+  const nonPluginConfigs = dependencies.filter(
+    (dep) => dep.startsWith('config:') && dep !== configName
+  )
+
+  if (nonPluginConfigs.length > 0) {
+    const configs = nonPluginConfigs.length > 1 ? 'configs' : 'config'
+    const nonPluginConfigNames = nonPluginConfigs.join(', ')
+    log.warn(
+      `Found references to external ${configs}: ${nonPluginConfigNames} - this is generally considered unsafe`
+    )
+  }
+}
+
+function verifyNoUndeclaredDependencies(modules, pkg) {
+  const undeclared = getUndeclaredDependencies(modules, pkg)
+  if (undeclared.length > 0) {
+    throw new Error(getUndeclaredDependenciesError(undeclared))
+  }
+}
+
+function getUndeclaredDependencies(modules, pkg) {
+  const deps = ([] as string[]).concat(
+    Object.keys(pkg.dependencies || {}),
+    Object.keys(pkg.peerDependencies || {})
+  )
+
+  const devDeps = Object.keys(pkg.devDependencies || {})
+
+  return modules
+    .filter((modDep) => !deps.includes(modDep))
+    .map((modDep) => ({
+      dependency: modDep,
+      isDevDep: devDeps.includes(modDep),
+    }))
+}
+
+function getUndeclaredDependenciesError(undeclared) {
+  const baseError = `Invalid plugin`
+  const moduleNames = undeclared.map((mod) => mod.dependency)
+
+  let declaredWhere = `should be declared in package.json under "dependencies" or "peerDependencies".`
+  if (moduleNames.length === 1 && moduleNames[0] === 'react') {
+    declaredWhere = `should be declared in package.json under "peerDependencies"`
+  } else if (moduleNames.includes('react')) {
+    declaredWhere = `should either be declared in package.json under "dependencies" or "peerDependencies" (react should be in "peerDependencies").`
+  }
+
+  const devDeps = undeclared.filter((dep) => dep.isDevDep).map((dep) => `  - ${dep.dependency}\n`)
+  if (devDeps.length > 0) {
+    const modules = devDeps.length > 1 ? 'modules' : 'module'
+    const depList = devDeps.join('')
+    const target = devDeps.length > 1 ? 'They' : 'It'
+    const are = devDeps.length > 1 ? 'are' : 'is'
+    return `${baseError}: Source uses ${modules} that ${are} declared in "devDependencies":\n\n${depList}\n${target} ${declaredWhere}`
+  }
+
+  const modules = undeclared.length > 1 ? 'modules' : 'module'
+  const depList = undeclared.map((dep) => `  - ${dep.dependency}\n`).join('')
+  const target = undeclared.length > 1 ? 'They' : 'It'
+  const are = undeclared.length > 1 ? 'are' : 'is'
+  return `${baseError}: Source uses ${modules} that ${are} not declared as dependencies:\n\n${depList}\n${target} ${declaredWhere}`
+}
+*/
+//# sourceMappingURL=verify.js.map

package/lib/src/actions/verify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.js","sourceRoot":"","sources":["../../../src/actions/verify.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuUE"}

package/lib/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function cliEntry(argv?: string[], autoExit?: boolean): Promise<void>;

package/lib/src/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliEntry = void 0;
+const meow_1 = __importDefault(require("meow"));
+const log_1 = __importDefault(require("./util/log"));
+const cmds_1 = __importDefault(require("./cmds"));
+const sharedFlags_1 = __importDefault(require("./sharedFlags"));
+const constants_1 = require("./constants");
+function cliEntry(argv = process.argv, autoExit = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cli = (0, meow_1.default)(`
+	Usage
+	  $ ${constants_1.cliName} [--help] [--debug] <command> [<args>]
+
+  These are common commands used in various situations:
+
+    init            Create a new Sanity 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
+    version         Show the version of ${constants_1.cliName} currently installed
+
+  Options
+    --silent        Do not print info and warning messages
+    --verbose       Log everything. This option conflicts with --silent
+    --debug         Print stack trace on errors
+    --version       Output the version number
+    --help          Output usage information
+
+  Examples
+    # Init a new plugin in current directory
+    $ ${constants_1.cliName} init
+
+    # Init a new plugin in my-sanity-plugin directory
+    $ ${constants_1.cliName} init my-sanity-plugin
+
+    # Check that a Sanity plugin package in current directory follows V3 conventions
+    $ ${constants_1.cliName} verify-package
+
+    # Check that a Sanity Studio in current directory  follows V3 conventions
+    $ ${constants_1.cliName} verify-studio
+`, {
+            autoHelp: false,
+            flags: sharedFlags_1.default,
+            argv: argv.slice(2),
+        });
+        const commandName = cli.input[0];
+        if (!commandName) {
+            cli.showHelp(); // Exits
+        }
+        if (!(commandName in cmds_1.default)) {
+            console.error(`Unknown command "${commandName}"`);
+            cli.showHelp(); // Exits
+        }
+        if (cli.flags.silent && cli.flags.verbose) {
+            log_1.default.error(`--silent and --verbose are mutually exclusive`);
+            cli.showHelp(); // Exits
+        }
+        // Lazy-load command
+        const cmd = require(cmds_1.default[commandName]).default;
+        try {
+            log_1.default.setVerbosity(cli.flags);
+            yield cmd({ argv: argv.slice(3) });
+        }
+        catch (err) {
+            log_1.default.error(err instanceof TypeError || cli.flags.debug ? err.stack : err.message);
+            // eslint-disable-next-line no-process-exit
+            process.exit(1);
+        }
+    });
+}
+exports.cliEntry = cliEntry;
+//# sourceMappingURL=cli.js.map

package/lib/src/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":";AACA,YAAY,CAAA;;;;;;;;;;;;;;;AACZ,gDAAuB;AACvB,qDAA4B;AAC5B,kDAA6B;AAC7B,gEAAuC;AACvC,2CAAmC;AAEnC,SAAsB,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;;QACjE,MAAM,GAAG,GAAG,IAAA,cAAI,EACd;;OAEG,mBAAO;;;;;;;;0CAQ4B,mBAAO;;;;;;;;;;;QAWzC,mBAAO;;;QAGP,mBAAO;;;QAGP,mBAAO;;;QAGP,mBAAO;CACd,EACG;YACE,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,qBAAW;YAClB,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SACpB,CACF,CAAA;QAED,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAChC,IAAI,CAAC,WAAW,EAAE;YAChB,GAAG,CAAC,QAAQ,EAAE,CAAA,CAAC,QAAQ;SACxB;QAED,IAAI,CAAC,CAAC,WAAW,IAAI,cAAQ,CAAC,EAAE;YAC9B,OAAO,CAAC,KAAK,CAAC,oBAAoB,WAAW,GAAG,CAAC,CAAA;YACjD,GAAG,CAAC,QAAQ,EAAE,CAAA,CAAC,QAAQ;SACxB;QAED,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE;YACzC,aAAG,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAA;YAC1D,GAAG,CAAC,QAAQ,EAAE,CAAA,CAAC,QAAQ;SACxB;QAED,oBAAoB;QACpB,MAAM,GAAG,GAAG,OAAO,CAAC,cAAQ,CAAC,WAAoC,CAAC,CAAC,CAAC,OAAO,CAAA;QAE3E,IAAI;YACF,aAAG,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;YAC3B,MAAM,GAAG,CAAC,EAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAC,CAAC,CAAA;SACjC;QAAC,OAAO,GAAQ,EAAE;YACjB,aAAG,CAAC,KAAK,CAAC,GAAG,YAAY,SAAS,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;YAEhF,2CAA2C;YAC3C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;SAChB;IACH,CAAC;CAAA;AApED,4BAoEC"}

package/lib/src/cmds/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    init: string;
+    'link-watch': string;
+    'verify-package': string;
+    'verify-studio': string;
+    version: string;
+};
+export default _default;

package/lib/src/cmds/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    init: require.resolve('./init'),
+    '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'),
+};
+//# sourceMappingURL=index.js.map

package/lib/src/cmds/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cmds/index.ts"],"names":[],"mappings":";;AAAA,kBAAe;IACb,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAC/B,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC;IAC7C,gBAAgB,EAAE,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACrD,eAAe,EAAE,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC;IACnD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;IACrC,mCAAmC;IACnC,oCAAoC;CACrC,CAAA"}

package/lib/src/cmds/init.d.ts

@@ -0,0 +1,4 @@
+declare function run({ argv }: {
+    argv: string[];
+}): Promise<void>;
+export default run;

package/lib/src/cmds/init.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const meow_1 = __importDefault(require("meow"));
+const log_1 = __importDefault(require("../util/log"));
+const init_1 = require("../actions/init");
+const files_1 = require("../util/files");
+const manager_1 = require("../npm/manager");
+const manifest_1 = require("../sanity/manifest");
+const prompt_1 = require("../util/prompt");
+const constants_1 = require("../constants");
+const description = `Initialize a new Sanity plugin`;
+const help = `
+Usage
+  $ ${constants_1.cliName} init [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
+  --no-install            Disables automatically running package manager install
+
+  --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
+
+Examples
+  # Initialize a new plugin in the current directory
+  $ ${constants_1.cliName} init
+
+  # Initialize a plugin in the directory ~/my-plugin
+  $ ${constants_1.cliName} init ~/my-plugin
+
+  # Don't add eslint or prettier
+  $ ${constants_1.cliName} init --no-eslint --no-prettier
+`;
+function run({ argv }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cli = (0, meow_1.default)(help, { flags: init_1.initFlags, argv, description });
+        const basePath = path_1.default.resolve(cli.input[0] || process.cwd());
+        const { exists, isRoot } = yield (0, manifest_1.hasSanityJson)(basePath);
+        if (exists && isRoot) {
+            throw new Error(`sanity.json has a "root" property set to true - are you trying to init into a studio instead of a plugin?`);
+        }
+        const { v3ConfigFile } = yield (0, manifest_1.findStudioV3Config)(basePath);
+        if (v3ConfigFile) {
+            throw new Error(`${v3ConfigFile} exsists - are you trying to init into a studio instead of a plugin?`);
+        }
+        log_1.default.info('Initializing new plugin in "%s"', basePath);
+        if (!cli.flags.force &&
+            !(yield (0, files_1.isEmptyish)(basePath)) &&
+            !(yield (0, prompt_1.prompt)('Directory is not empty, proceed?', { type: 'confirm', default: false }))) {
+            log_1.default.error('Directory is not empty. Cancelled.');
+            return;
+        }
+        yield (0, files_1.ensureDir)(basePath);
+        yield (0, init_1.init)({ basePath, flags: cli.flags });
+        if (cli.flags.install) {
+            if (yield (0, manager_1.installDependencies)(yield (0, manager_1.promptForPackageManager)(), { cwd: basePath })) {
+                log_1.default.info('Done!');
+            }
+            else {
+                log_1.default.error('Failed to install dependencies, try manually running `npm install`');
+            }
+        }
+        else {
+            log_1.default.info('Dependency installation skipped.');
+        }
+    });
+}
+exports.default = run;
+//# sourceMappingURL=init.js.map

package/lib/src/cmds/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../src/cmds/init.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,gDAAuB;AACvB,gDAAuB;AACvB,sDAA6B;AAC7B,0CAA+C;AAC/C,yCAAmD;AACnD,4CAA2E;AAC3E,iDAAoE;AACpE,2CAAqC;AACrC,4CAAoC;AAEpC,MAAM,WAAW,GAAG,gCAAgC,CAAA;AAEpD,MAAM,IAAI,GAAG;;MAEP,mBAAO;;;;;;;;;;;;;;;;;;;;MAoBP,mBAAO;;;MAGP,mBAAO;;;MAGP,mBAAO;CACZ,CAAA;AAED,SAAe,GAAG,CAAC,EAAC,IAAI,EAAmB;;QACzC,MAAM,GAAG,GAAG,IAAA,cAAI,EAAC,IAAI,EAAE,EAAC,KAAK,EAAE,gBAAS,EAAE,IAAI,EAAE,WAAW,EAAC,CAAC,CAAA;QAC7D,MAAM,QAAQ,GAAG,cAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;QAE5D,MAAM,EAAC,MAAM,EAAE,MAAM,EAAC,GAAG,MAAM,IAAA,wBAAa,EAAC,QAAQ,CAAC,CAAA;QACtD,IAAI,MAAM,IAAI,MAAM,EAAE;YACpB,MAAM,IAAI,KAAK,CACb,2GAA2G,CAC5G,CAAA;SACF;QAED,MAAM,EAAC,YAAY,EAAC,GAAG,MAAM,IAAA,6BAAkB,EAAC,QAAQ,CAAC,CAAA;QACzD,IAAI,YAAY,EAAE;YAChB,MAAM,IAAI,KAAK,CACb,GAAG,YAAY,sEAAsE,CACtF,CAAA;SACF;QAED,aAAG,CAAC,IAAI,CAAC,iCAAiC,EAAE,QAAQ,CAAC,CAAA;QACrD,IACE,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK;YAChB,CAAC,CAAC,MAAM,IAAA,kBAAU,EAAC,QAAQ,CAAC,CAAC;YAC7B,CAAC,CAAC,MAAM,IAAA,eAAM,EAAC,kCAAkC,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC,EACtF;YACA,aAAG,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAA;YAC/C,OAAM;SACP;QAED,MAAM,IAAA,iBAAS,EAAC,QAAQ,CAAC,CAAA;QACzB,MAAM,IAAA,WAAI,EAAC,EAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAC,CAAC,CAAA;QACxC,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE;YACrB,IAAI,MAAM,IAAA,6BAAmB,EAAC,MAAM,IAAA,iCAAuB,GAAE,EAAE,EAAC,GAAG,EAAE,QAAQ,EAAC,CAAC,EAAE;gBAC/E,aAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;aAClB;iBAAM;gBACL,aAAG,CAAC,KAAK,CAAC,oEAAoE,CAAC,CAAA;aAChF;SACF;aAAM;YACL,aAAG,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAA;SAC7C;IACH,CAAC;CAAA;AAED,kBAAe,GAAG,CAAA"}

package/lib/src/cmds/link-watch.d.ts

@@ -0,0 +1,4 @@
+declare function run({ argv }: {
+    argv: string[];
+}): Promise<void>;
+export default run;