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

package/lib/src/dependencies/find.js

@@ -0,0 +1,195 @@
+"use strict";
+/*
+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)}`
+}
+*/
+//# sourceMappingURL=find.js.map

package/lib/src/dependencies/find.js.map

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

package/lib/src/dependencies/import-linter.d.ts

@@ -0,0 +1,3 @@
+export declare function validateImports({ basePath }: {
+    basePath: string;
+}): Promise<string[]>;

package/lib/src/dependencies/import-linter.js

@@ -0,0 +1,112 @@
+"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.validateImports = void 0;
+const log_1 = __importDefault(require("../util/log"));
+const merged_packages_1 = require("../configs/merged-packages");
+const constants_1 = require("../constants");
+const eslint_1 = require("eslint");
+const path_1 = __importDefault(require("path"));
+const outdent_1 = __importDefault(require("outdent"));
+const removedImportSuffix = `imports where removed in Sanity v3. Please refer to the migration guide: ${constants_1.urls.migrationGuideStudio}, or new API-reference docs: ${constants_1.urls.refDocs}`;
+function validateImports({ basePath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        log_1.default.debug('Running ESLint with Sanity Studio import hints...');
+        const eslint = new eslint_1.ESLint({
+            cwd: basePath,
+            overrideConfig: {
+                ignorePatterns: ['node_modules'],
+                rules: {
+                    'no-restricted-imports': [
+                        'error',
+                        {
+                            patterns: [
+                                ...merged_packages_1.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: ${constants_1.urls.migrationGuideStudio}`,
+                                },
+                                {
+                                    group: ['part:*'],
+                                    message: `part: ${removedImportSuffix}`,
+                                },
+                                {
+                                    group: ['all:part:*'],
+                                    message: `all:part: ${removedImportSuffix}`,
+                                },
+                                {
+                                    group: ['sanity:*'],
+                                    message: `sanity: ${removedImportSuffix}`,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        });
+        try {
+            const results = yield eslint.lintFiles([path_1.default.join(basePath, '**/*.{js,jsx,ts,tsx}')]);
+            const onlyImportErrors = results
+                .map((r) => {
+                const limitErrors = r.messages.filter((m) => m.ruleId === 'no-restricted-imports');
+                return Object.assign(Object.assign({}, r), { messages: limitErrors, errorCount: limitErrors.length });
+            })
+                .filter((r) => r.errorCount);
+            if (onlyImportErrors.length) {
+                const formatter = yield eslint.loadFormatter('stylish');
+                const resultText = yield formatter.format(onlyImportErrors);
+                const addtionalInfo = (0, outdent_1.default) `
+        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 ${constants_1.urls.linterPackage}
+
+        If the plugin package does not use eslint, disable this check.
+    `;
+                return [resultText + addtionalInfo];
+            }
+        }
+        catch (e) {
+            log_1.default.error('Failed to run eslint check', e);
+            return [
+                (0, outdent_1.default) `
+        Failed to run ESLint. Is ESLint configured?
+        It is recommended to install eslint-config-sanity and add 'sanity/upgrade-v2' to your eslint-extends config.
+
+        Run:
+        npm install --save-dev eslint-config-sanity
+
+        In .eslintrc add:
+        extends: ['sanity/upgrade-v2']
+
+        This way, V2-imports can be identified directly in the IDE, or using eslint CLI.
+        If the package does not use eslint, disable this check.
+    `,
+            ];
+        }
+        return [];
+    });
+}
+exports.validateImports = validateImports;
+//# sourceMappingURL=import-linter.js.map

package/lib/src/dependencies/import-linter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-linter.js","sourceRoot":"","sources":["../../../src/dependencies/import-linter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,sDAA6B;AAC7B,gEAAyD;AACzD,4CAAiC;AACjC,mCAA6B;AAC7B,gDAAuB;AACvB,sDAA6B;AAE7B,MAAM,mBAAmB,GAAG,4EAA4E,gBAAI,CAAC,oBAAoB,gCAAgC,gBAAI,CAAC,OAAO,EAAE,CAAA;AAE/K,SAAsB,eAAe,CAAC,EAAC,QAAQ,EAAqB;;QAClE,aAAG,CAAC,KAAK,CAAC,mDAAmD,CAAC,CAAA;QAC9D,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC;YACxB,GAAG,EAAE,QAAQ;YACb,cAAc,EAAE;gBACd,cAAc,EAAE,CAAC,cAAc,CAAC;gBAChC,KAAK,EAAE;oBACL,uBAAuB,EAAE;wBACvB,OAAO;wBACP;4BACE,QAAQ,EAAE;gCACR,GAAG,gCAAc,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;oCACtC,KAAK,EAAE,CAAC,GAAG,WAAW,GAAG,CAAC;oCAC1B,OAAO,EAAE,yBAAyB,WAAW,GAAG;iCACjD,CAAC,CAAC;gCACH;oCACE,KAAK,EAAE,CAAC,UAAU,CAAC;oCACnB,OAAO,EAAE,4FAA4F,gBAAI,CAAC,oBAAoB,EAAE;iCACjI;gCACD;oCACE,KAAK,EAAE,CAAC,QAAQ,CAAC;oCACjB,OAAO,EAAE,SAAS,mBAAmB,EAAE;iCACxC;gCACD;oCACE,KAAK,EAAE,CAAC,YAAY,CAAC;oCACrB,OAAO,EAAE,aAAa,mBAAmB,EAAE;iCAC5C;gCACD;oCACE,KAAK,EAAE,CAAC,UAAU,CAAC;oCACnB,OAAO,EAAE,WAAW,mBAAmB,EAAE;iCAC1C;6BACF;yBACF;qBACF;iBACF;aACF;SACF,CAAC,CAAA;QAEF,IAAI;YACF,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAA;YAErF,MAAM,gBAAgB,GAAG,OAAO;iBAC7B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACT,MAAM,WAAW,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,uBAAuB,CAAC,CAAA;gBAClF,uCACK,CAAC,KACJ,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,WAAW,CAAC,MAAM,IAC/B;YACH,CAAC,CAAC;iBACD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAA;YAE9B,IAAI,gBAAgB,CAAC,MAAM,EAAE;gBAC3B,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAA;gBACvD,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;gBAE3D,MAAM,aAAa,GAAG,IAAA,iBAAO,EAAA;;;;;;;;;;;wBAWX,gBAAI,CAAC,aAAa;;;KAGrC,CAAA;gBACC,OAAO,CAAC,UAAU,GAAG,aAAa,CAAC,CAAA;aACpC;SACF;QAAC,OAAO,CAAC,EAAE;YACV,aAAG,CAAC,KAAK,CAAC,4BAA4B,EAAE,CAAC,CAAC,CAAA;YAC1C,OAAO;gBACL,IAAA,iBAAO,EAAA;;;;;;;;;;;;KAYR;aACA,CAAA;SACF;QAED,OAAO,EAAE,CAAA;IACX,CAAC;CAAA;AA7FD,0CA6FC"}

package/lib/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/src/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+(0, cli_1.cliEntry)();
+//# sourceMappingURL=index.js.map

package/lib/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AACA,+BAA8B;AAE9B,IAAA,cAAQ,GAAE,CAAA"}

package/lib/src/npm/manager.d.ts

@@ -0,0 +1,7 @@
+export declare function npmIsAvailable(): Promise<boolean>;
+export declare function yarnIsAvailable(): Promise<boolean>;
+export declare function pnpmAvailable(): Promise<boolean>;
+export declare function promptForPackageManager(): Promise<any>;
+export declare function installDependencies(pm: string, { cwd }: {
+    cwd?: string;
+}): Promise<boolean>;

package/lib/src/npm/manager.js

@@ -0,0 +1,62 @@
+"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.installDependencies = exports.promptForPackageManager = exports.pnpmAvailable = exports.yarnIsAvailable = exports.npmIsAvailable = void 0;
+const execa_1 = __importDefault(require("execa"));
+const prompt_1 = require("../util/prompt");
+function npmIsAvailable() {
+    return (0, execa_1.default)('npm', ['-v'])
+        .then(() => true)
+        .catch(() => false);
+}
+exports.npmIsAvailable = npmIsAvailable;
+function yarnIsAvailable() {
+    return (0, execa_1.default)('yarn', ['-v'])
+        .then(() => true)
+        .catch(() => false);
+}
+exports.yarnIsAvailable = yarnIsAvailable;
+function pnpmAvailable() {
+    return (0, execa_1.default)('pnpm', ['-v'])
+        .then(() => true)
+        .catch(() => false);
+}
+exports.pnpmAvailable = pnpmAvailable;
+function promptForPackageManager() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [npm, yarn, pnpm] = yield Promise.all([
+            npmIsAvailable(),
+            yarnIsAvailable(),
+            pnpmAvailable(),
+        ]);
+        const choices = [npm && 'npm', yarn && 'yarn', pnpm && 'pnpm'].filter(Boolean);
+        if (choices.length < 2) {
+            return choices[0] || 'npm';
+        }
+        return (0, prompt_1.prompt)('Which package manager do you prefer?', {
+            choices: choices.map((value) => ({ value, name: value })),
+            default: choices[0],
+        });
+    });
+}
+exports.promptForPackageManager = promptForPackageManager;
+function installDependencies(pm, { cwd }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proc = (0, execa_1.default)(pm, ['install'], { cwd, stdio: 'inherit' });
+        const { exitCode } = yield proc;
+        return exitCode <= 0;
+    });
+}
+exports.installDependencies = installDependencies;
+//# sourceMappingURL=manager.js.map

package/lib/src/npm/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../src/npm/manager.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,kDAAyB;AACzB,2CAAqC;AAErC,SAAgB,cAAc;IAC5B,OAAO,IAAA,eAAK,EAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC;SACxB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;SAChB,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;AACvB,CAAC;AAJD,wCAIC;AAED,SAAgB,eAAe;IAC7B,OAAO,IAAA,eAAK,EAAC,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC;SACzB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;SAChB,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;AACvB,CAAC;AAJD,0CAIC;AAED,SAAgB,aAAa;IAC3B,OAAO,IAAA,eAAK,EAAC,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC;SACzB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;SAChB,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;AACvB,CAAC;AAJD,sCAIC;AAED,SAAsB,uBAAuB;;QAC3C,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC1C,cAAc,EAAE;YAChB,eAAe,EAAE;YACjB,aAAa,EAAE;SAChB,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,KAAK,EAAE,IAAI,IAAI,MAAM,EAAE,IAAI,IAAI,MAAM,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;QAC9E,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAA;SAC3B;QAED,OAAO,IAAA,eAAM,EAAC,sCAAsC,EAAE;YACpD,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAC,CAAC,CAAC;YACvD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;SACpB,CAAC,CAAA;IACJ,CAAC;CAAA;AAhBD,0DAgBC;AAED,SAAsB,mBAAmB,CAAC,EAAU,EAAE,EAAC,GAAG,EAAiB;;QACzE,MAAM,IAAI,GAAG,IAAA,eAAK,EAAC,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,EAAC,GAAG,EAAE,KAAK,EAAE,SAAS,EAAC,CAAC,CAAA;QAC5D,MAAM,EAAC,QAAQ,EAAC,GAAG,MAAM,IAAI,CAAA;QAC7B,OAAO,QAAQ,IAAI,CAAC,CAAA;IACtB,CAAC;CAAA;AAJD,kDAIC"}

package/lib/src/npm/package.d.ts

@@ -0,0 +1,8 @@
+import { ManifestOptions } from '../sanity/manifest';
+import { PackageData, SplatOptions } from '../actions/splat';
+import { PackageJson } from '../actions/verify/types';
+export declare function getPackage(opts: ManifestOptions): Promise<PackageJson>;
+export declare function validatePackage(manifest: PackageJson, opts: ManifestOptions): Promise<void>;
+export declare function getReferencedPaths(packageJson: Record<string, string>, basePath: string): string[];
+export declare function writePackageJson(data: PackageData, options: SplatOptions): Promise<PackageJson>;
+export declare function addBuildScripts(manifest: PackageJson, { basePath, flags }: SplatOptions): Promise<boolean>;