@_linked/cli 1.44.0 → 1.45.0

package/lib/esm/cli-methods.js

@@ -33,10 +33,38 @@ import ora from 'ora';
 import stagedGitFiles from 'staged-git-files';
 import { packagePublishesCjs } from './package-manifest.js';
 import { asNamespace, defaultOntologyNamespace } from './utils/ontologyNamespace.js';
+import { decidePackageKind, ontologySlugFor, packageNameFor, scaffoldKinds, PACKAGE_TEMPLATE_DIRS, SHARED_TEMPLATE_FILES, } from './utils/packageKind.js';
+import { resolvePackageBaseUri, withBaseUri } from './utils/packageBaseUri.js';
 let dirname__ = typeof __dirname !== 'undefined'
     ? __dirname
     : //@ts-ignore
         dirname(import.meta.url).replace('file:/', '');
+/**
+ * A folder under this package's `defaults/`. The built module sits in `lib/esm/`
+ * and the source in `src/`, so the templates are two or one level up.
+ */
+function defaultsDir(...parts) {
+    var _a;
+    const candidates = [
+        path.join(dirname__, '..', '..', 'defaults'),
+        path.join(dirname__, '..', 'defaults'),
+    ];
+    const root = (_a = candidates.find((dir) => fs.existsSync(dir))) !== null && _a !== void 0 ? _a : candidates[0];
+    return path.join(root, ...parts);
+}
+/**
+ * The commands that write a file importing `../package.js` need a `src/package.ts`
+ * to import. A new app root has none (it is a linkedApp, not a linkedPackage), so
+ * there the import would be broken: refuse instead. Only the file decides: a
+ * linkedApp that keeps its shapes at its root with its own `src/package.ts`, as
+ * create-now does, is served as before.
+ */
+function assertInsidePackage(sourceFolder, command) {
+    if (fs.existsSync(path.join(sourceFolder, 'package.ts')))
+        return;
+    throw new CreatePackageError(`${command}: no src/package.ts here, so there is no package to add to. An app root is ` +
+        `not a package; run this inside a package (packages/<name>).`);
+}
 /**
  * Dynamically import the app's backend storage configuration. Tries the
  * canonical `linked.backend.storage.{ts,js}` at app root first, then the
@@ -376,8 +404,12 @@ function setEnvVar(envText, key, value) {
  *  - `.env.example` (committed defaults for this app) + `.env` (local): APP_NAME
  *    drives the display name; APP_PREFIX names data files.
  *  - `package.json`: `name` (hyphenated id) + `displayName` (human name).
- *  - `src/package.ts`: the runtime `linkedPackage` id — shape URIs derive from it.
  *  - pm2 process names + the VS Code launch name (cosmetic, but should match).
+ *
+ * Nothing under `src/` is touched: the app is a linkedApp, not a linked package,
+ * so its root registers no package and has no package id to stamp. Its shapes
+ * live in its packages (`packages/<name>-assets`), each with its own
+ * `src/package.ts`.
  */
 /**
  * Scaffolded apps are npm apps, so the new app must not also look like a yarn
@@ -396,7 +428,7 @@ export function stripYarnProjectFiles(targetFolder) {
         fs.removeSync(path.join(targetFolder, yarnLeftover));
     }
 }
-function applyAppIdentity(targetFolder, ids) {
+export function applyAppIdentity(targetFolder, ids) {
     const { appName, appPrefix, hyphenName } = ids;
     // 1. .env.example (+ seed .env from it so the first `npm start` is correct).
     const envExample = path.join(targetFolder, '.env.example');
@@ -417,13 +449,7 @@ function applyAppIdentity(targetFolder, ids) {
         pkg.displayName = appName;
         fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
     }
-    // 3. src/package.ts — the runtime linkedPackage id.
-    const packageTs = path.join(targetFolder, 'src', 'package.ts');
-    if (fs.existsSync(packageTs)) {
-        const src = fs.readFileSync(packageTs, 'utf8');
-        fs.writeFileSync(packageTs, src.replace(/linkedPackage\(\s*['"][^'"]*['"]\s*\)/, `linkedPackage('${hyphenName}')`));
-    }
-    // 4. pm2 process names + VS Code launch name (template hardcodes 'app').
+    // 3. pm2 process names + VS Code launch name (template hardcodes 'app').
     const renames = [
         ['pm2.config.js', /name:\s*'app'/, `name: '${hyphenName}'`],
         ['pm2-staging.config.js', /name:\s*'app-staging'/, `name: '${hyphenName}-staging'`],
@@ -1043,6 +1069,7 @@ export const createOntology = (prefix_1, uriBase_1, ...args_1) => __awaiter(void
         return;
     }
     let sourceFolder = getSourceFolder(basePath);
+    assertInsidePackage(sourceFolder, 'create-ontology');
     let targetFolder = ensureFolderExists(sourceFolder, 'ontologies');
     if (!uriBase) {
         uriBase = defaultOntologyNamespace(prefix);
@@ -1053,16 +1080,16 @@ export const createOntology = (prefix_1, uriBase_1, ...args_1) => __awaiter(void
     log("Creating files for ontology '" + prefix + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.ts');
     let targetRegisterFile = path.join(targetFolder, hyphenName + '.register.ts');
-    fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
+    fs.copySync(defaultsDir('package-ontology', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
     // The registration sibling. It has to be a separate module: registration needs the
     // ontology module's whole export namespace, and a module cannot import itself once a
     // bundler is involved -- Rollup elides the self-reference and the app dies at boot.
-    fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.register.ts'), targetRegisterFile);
+    fs.copySync(defaultsDir('package-ontology', 'src', 'ontologies', 'example-ontology.register.ts'), targetRegisterFile);
     //copy data files
     let targetDataFile = path.join(targetFolder, '..', 'data', hyphenName + '.json');
     let targetDataFile2 = path.join(targetFolder, '..', 'data', hyphenName + '.json.d.ts');
-    fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json'), targetDataFile);
-    fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
+    fs.copySync(defaultsDir('package-ontology', 'src', 'data', 'example-ontology.json'), targetDataFile);
+    fs.copySync(defaultsDir('package-ontology', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
     yield replaceVariablesInFiles(targetFile, targetRegisterFile, targetDataFile, targetDataFile2);
     log(`Prepared a new ontology data files in ${chalk.magenta(targetDataFile.replace(basePath, ''))}`, `And an ontology accessor file in ${chalk.magenta(targetFile.replace(basePath, ''))}`);
     //if this is not a lincd app (but a lincd package instead)
@@ -1261,12 +1288,13 @@ export const getScriptDir = () => {
 };
 export const createShape = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     let sourceFolder = getSourceFolder(basePath);
+    assertInsidePackage(sourceFolder, 'create-shape');
     let targetFolder = ensureFolderExists(sourceFolder, 'shapes');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
     //copy default shape file
     // log("Creating files for shape '" + name + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.ts');
-    fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'shape.ts'), targetFile);
+    fs.copySync(defaultsDir('shape.ts'), targetFile);
     //replace variables in some of the copied files
     yield replaceVariablesInFiles(targetFile);
     log(`Created a new shape class template in ${chalk.magenta(targetFile.replace(basePath, ''))}`);
@@ -1279,14 +1307,15 @@ export const createShape = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...
     log(`Registered the shape in ${chalk.magenta(barrelPath.replace(basePath, ''))}`);
 });
 export const createSetComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
+    assertInsidePackage(path.join(basePath, 'src'), 'create-set-component');
     let targetFolder = ensureFolderExists(basePath, 'src', 'components');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
     //copy default shape file
     log("Creating files for set component '" + name + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.tsx');
-    fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'set-component.tsx'), targetFile);
+    fs.copySync(defaultsDir('set-component.tsx'), targetFile);
     let targetFile2 = path.join(targetFolder, hyphenName + '.scss');
-    fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'component.scss'), targetFile2);
+    fs.copySync(defaultsDir('component.scss'), targetFile2);
     //replace variables in some of the copied files
     yield replaceVariablesInFiles(targetFile, targetFile2);
     let indexPath = addLineToIndex(`import './components/${hyphenName}.js';`, 'components');
@@ -1294,14 +1323,15 @@ export const createSetComponent = (name_1, ...args_1) => __awaiter(void 0, [name
 });
 export const createComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     let sourceFolder = getSourceFolder(basePath);
+    assertInsidePackage(sourceFolder, 'create-component');
     let targetFolder = ensureFolderExists(sourceFolder, 'components');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
     //copy default shape file
     log("Creating files for component '" + name + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.tsx');
-    fs.copySync(path.join(getScriptDir(), '..', 'defaults', 'component.tsx'), targetFile);
+    fs.copySync(defaultsDir('component.tsx'), targetFile);
     let targetFile2 = path.join(targetFolder, hyphenName + '.scss');
-    fs.copySync(path.join(getScriptDir(), '..', 'defaults', 'component.scss'), targetFile2);
+    fs.copySync(defaultsDir('component.scss'), targetFile2);
     //replace variables in some of the copied files
     yield replaceVariablesInFiles(targetFile, targetFile2);
     log(`Created a new component template in ${chalk.magenta(targetFile.replace(basePath, ''))}`, `Created component stylesheet template in ${chalk.magenta(targetFile2.replace(basePath, ''))}`);
@@ -1839,95 +1869,216 @@ export const createPackage = (name_1, uriBase_1, ...args_1) => __awaiter(void 0,
         console.warn('Please provide a name as the first argument');
         return;
     }
-    const appRoot = findLinkedAppRoot(basePath);
-    const decided = decideCreatePackageTarget({
-        appRoot,
-        options,
-        isTTY: !!(process.stdin.isTTY && process.stdout.isTTY),
+    const isTTY = !!(process.stdin.isTTY && process.stdout.isTTY);
+    // What, then where. Both are settled before anything is written, so a
+    // refusal leaves nothing behind and `both` asks each question once.
+    const kindDecided = decidePackageKind({
+        kind: options.kind,
+        remote: options.remote,
+        isTTY,
     });
+    if (kindDecided.kind === 'refuse')
+        throw new CreatePackageError(kindDecided.message);
+    const packageKind = kindDecided.kind === 'ask' ? yield askPackageKind(name) : kindDecided.packageKind;
+    const appRoot = findLinkedAppRoot(basePath);
+    const decided = decideCreatePackageTarget({ appRoot, options, isTTY });
     if (decided.kind === 'refuse')
         throw new CreatePackageError(decided.message);
+    // The root its IRIs are minted under: a malformed one is refused here, before
+    // anything is written or asked.
+    let root;
+    try {
+        root = resolvePackageBaseUri({ flag: options.baseUri, appRoot });
+    }
+    catch (e) {
+        throw new CreatePackageError(e.message);
+    }
     const decision = decided.kind === 'ask' ? yield askPackageLocation(name) : decided;
-    //let's remove scope for variable names
-    const cleanPackageName = bareName(name);
-    let targetFolder;
-    if (decision.kind === 'outside') {
-        //if ran with npx, basePath will be the root directory of the repository, even if we're executing from a sub folder (the root directory is where node_modules lives and package.json with workspaces)
-        //so we manually find a packages folder, if it exists we go into that.
-        if (fs.existsSync(path.join(basePath, 'packages'))) {
-            basePath = path.join(basePath, 'packages');
+    const packages = scaffoldKinds(packageKind).map((kind) => ({
+        kind,
+        name: packageNameFor(name, kind),
+    }));
+    // Nothing is written until every target is free.
+    const targets = yield Promise.all(packages.map((_a) => __awaiter(void 0, [_a], void 0, function* ({ name: packageName }) {
+        const targetFolder = yield packageTargetFolder(packageName, basePath, appRoot, decision);
+        if (fs.existsSync(targetFolder)) {
+            throw new CreatePackageError(`${targetFolder} already exists. Refusing to write a new package over it.`);
+        }
+        return targetFolder;
+    })));
+    // linked.cm is the normal root for an open-source package, so its absence is
+    // information, not a warning.
+    log(root
+        ? `Base URI ${root.baseUri} (from ${root.source}): shapes mint ${root.baseUri}shape/<package>/<Name>`
+        : `Shapes and terms in ${packages.map((p) => p.name).join(' and ')} mint under https://linked.cm/. ` +
+            `They resolve once the package is published (npx linked publish, coming soon).`);
+    for (const [i, { kind, name: packageName }] of packages.entries()) {
+        const targetFolder = targets[i];
+        yield scaffoldPackage(packageName, kind, targetFolder, uriBase, root === null || root === void 0 ? void 0 : root.baseUri);
+        if (kind === 'assets' && packageKind === 'both') {
+            // The pair is one unit: the asset package's shapes use the ontology
+            // created with it. `ontology` comes first in `scaffoldKinds`, so its
+            // package.json is already written.
+            const ontIndex = packages.findIndex((p) => p.kind === 'ontology');
+            dependOnOntologyPackage(targetFolder, packages[ontIndex].name, targets[ontIndex], decision.kind === 'resolved' && decision.location === 'packages');
+        }
+        const skipped = () => log(`Prepared a new linked package in ${chalk.magenta(targetFolder)} (install skipped)`);
+        if (decision.kind === 'outside') {
+            if (options.skipInstall)
+                skipped();
+            else
+                yield installStandalonePackage(targetFolder);
+        }
+        else if (decision.location === 'packages') {
+            // The app's package.json is wired either way: that is files, not install.
+            yield installWorkspacePackage(packageName, targetFolder, appRoot, options.skipInstall);
+        }
+        else if (options.skipInstall) {
+            skipped();
         }
-        //for lincd.org currently packages are stored in the modules folder
-        else if (fs.existsSync(path.join(basePath, 'modules'))) {
-            basePath = path.join(basePath, 'modules');
+        else {
+            yield installOwnRepoPackage(packageName, targetFolder, appRoot, decision);
         }
-        targetFolder = path.join(basePath, cleanPackageName);
     }
-    else if (decision.location === 'packages') {
-        targetFolder = path.join(appRoot, 'packages', cleanPackageName);
+});
+/**
+ * Declare the ontology package as a regular dependency of the asset package,
+ * at `^` its version — the same entry Create Now's project scaffold writes.
+ *
+ * Only where npm workspaces link the two (`--location packages`). Anywhere
+ * else the `-ont` package is not published yet, so `npm install` in the asset
+ * package would fail with E404: the entry is left out and one line says how to
+ * add it once the ontology package is published.
+ */
+function dependOnOntologyPackage(assetsFolder, ontName, ontFolder, linkedByWorkspace) {
+    if (!linkedByWorkspace) {
+        log(`The asset package does not depend on ${ontName} yet: once ${ontName} is published, ` +
+            `run npm install ${ontName} in ${assetsFolder}`);
+        return;
     }
-    else {
+    const { version } = fs.readJsonSync(path.join(ontFolder, 'package.json'));
+    const pkgPath = path.join(assetsFolder, 'package.json');
+    const pkg = fs.readJsonSync(pkgPath);
+    pkg.dependencies = Object.assign(Object.assign({}, pkg.dependencies), { [ontName]: `^${version}` });
+    fs.writeJsonSync(pkgPath, pkg, { spaces: 2 });
+}
+/** Where a package goes, given where create-package was told to put it. */
+function packageTargetFolder(name, basePath, appRoot, decision) {
+    return __awaiter(this, void 0, void 0, function* () {
+        //let's remove scope for folder names
+        const cleanPackageName = bareName(name);
+        if (decision.kind === 'outside') {
+            //if ran with npx, basePath will be the root directory of the repository, even if we're executing from a sub folder (the root directory is where node_modules lives and package.json with workspaces)
+            //so we manually find a packages folder, if it exists we go into that.
+            if (fs.existsSync(path.join(basePath, 'packages'))) {
+                basePath = path.join(basePath, 'packages');
+            }
+            //for lincd.org currently packages are stored in the modules folder
+            else if (fs.existsSync(path.join(basePath, 'modules'))) {
+                basePath = path.join(basePath, 'modules');
+            }
+            return path.join(basePath, cleanPackageName);
+        }
+        if (decision.kind === 'resolved' && decision.location === 'packages') {
+            return path.join(appRoot, 'packages', cleanPackageName);
+        }
         // localize's own naming, so `linked localize` and this command can never
         // disagree about where a package lives.
         const { checkoutNameFor, DEFAULT_DIR } = yield import('./localize/index.js');
-        targetFolder = path.join(appRoot, DEFAULT_DIR, checkoutNameFor(name));
-    }
-    if (fs.existsSync(targetFolder)) {
-        throw new CreatePackageError(`${targetFolder} already exists. Refusing to write a new package over it.`);
-    }
-    if (!uriBase) {
-        uriBase = defaultOntologyNamespace(name);
-    }
-    setVariable('uri_base', asNamespace(uriBase));
-    //save the full scoped package name under ${package_name}
-    setVariable('package_name', name);
-    //extra variable for clarity (will be same as 'name')
-    setVariable('output_file_name', name);
-    const { hyphenName } = setNameVariables(cleanPackageName);
-    log("Creating new linked package '" + name + "'");
-    fs.mkdirSync(targetFolder, { recursive: true });
-    fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'package'), targetFolder);
-    renameShippedDotfiles(targetFolder);
-    //replace variables in some of the copied files
-    yield Promise.all([
-        'src/index.ts',
-        'package.json',
-        'src/package.ts',
-        'src/ontologies/example-ontology.ts',
-        'src/ontologies/example-ontology.register.ts',
-        'src/data/example-ontology.json',
-    ]
-        .map((f) => path.join(targetFolder, f))
-        .map((file) => {
-        return replaceVariablesInFile(file);
-    }));
-    //rename these to a file name similar to the pkg name
-    [
-        'src/ontologies/example-ontology.ts',
-        // The register sibling is what index.ts imports; without it here the scaffold keeps a
-        // literal `example-ontology.register.ts` full of unsubstituted `${...}` placeholders and
-        // nothing ever calls linkedOntology().
-        'src/ontologies/example-ontology.register.ts',
-        'src/data/example-ontology.json',
-        'src/data/example-ontology.json.d.ts',
-    ].forEach((f) => {
-        let parts = f.split('/');
-        let newParts = [...parts];
-        let [name, ...extensions] = newParts.pop().split('.');
-        let newName = hyphenName + '.' + extensions.join('.');
-        console.log('rename ', path.join(targetFolder, f), path.join(targetFolder, ...newParts, newName));
-        fs.renameSync(path.join(targetFolder, f), path.join(targetFolder, ...newParts, newName));
+        return path.join(appRoot, DEFAULT_DIR, checkoutNameFor(name));
     });
-    if (decision.kind === 'outside') {
-        yield installStandalonePackage(targetFolder);
-    }
-    else if (decision.location === 'packages') {
-        yield installWorkspacePackage(name, targetFolder, appRoot);
-    }
-    else {
-        yield installOwnRepoPackage(name, targetFolder, appRoot, decision);
-    }
-});
+}
+/**
+ * Write one package of a kind. Every kind gets the shared files of
+ * `defaults/package` (manifest, tsconfigs, dotfiles, `src/package.ts`); an asset
+ * package gets the rest of that folder, an ontology package gets
+ * `defaults/package-ontology` instead, with the example ontology named after
+ * its ontology slug.
+ */
+function scaffoldPackage(name, kind, targetFolder, uriBase, baseUri) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // An ontology package `foo-ont` holds the ontology `foo`: that slug names its
+        // files and its prefix, and its terms mint `{root}ont/foo/{Term}`.
+        const ontologySlug = kind === 'ontology' ? ontologySlugFor(name) : undefined;
+        if (!uriBase) {
+            uriBase = baseUri
+                ? `${baseUri}ont/${ontologySlug !== null && ontologySlug !== void 0 ? ontologySlug : bareName(name)}/`
+                : defaultOntologyNamespace(ontologySlug !== null && ontologySlug !== void 0 ? ontologySlug : name);
+        }
+        setVariable('uri_base', asNamespace(uriBase));
+        //save the full scoped package name under ${package_name}
+        setVariable('package_name', name);
+        //extra variable for clarity (will be same as 'name')
+        setVariable('output_file_name', name);
+        const { hyphenName } = setNameVariables(ontologySlug !== null && ontologySlug !== void 0 ? ontologySlug : bareName(name));
+        log(`Creating new linked ${kind} package '${name}'`);
+        fs.mkdirSync(targetFolder, { recursive: true });
+        const [shared, ...variants] = PACKAGE_TEMPLATE_DIRS[kind];
+        if (variants.length === 0) {
+            fs.copySync(defaultsDir(shared), targetFolder);
+        }
+        else {
+            for (const file of SHARED_TEMPLATE_FILES) {
+                fs.copySync(defaultsDir(shared, file), path.join(targetFolder, file));
+            }
+            for (const variant of variants) {
+                fs.copySync(defaultsDir(variant), targetFolder);
+            }
+        }
+        renameShippedDotfiles(targetFolder);
+        //replace variables in some of the copied files
+        yield Promise.all(['src/index.ts', 'package.json', 'src/package.ts']
+            .concat(kind === 'ontology'
+            ? [
+                'src/ontologies/example-ontology.ts',
+                'src/ontologies/example-ontology.register.ts',
+                'src/data/example-ontology.json',
+            ]
+            : [])
+            .map((f) => path.join(targetFolder, f))
+            .map((file) => replaceVariablesInFile(file)));
+        if (baseUri) {
+            const packageTs = path.join(targetFolder, 'src', 'package.ts');
+            fs.writeFileSync(packageTs, withBaseUri(fs.readFileSync(packageTs, 'utf8'), baseUri));
+        }
+        if (kind !== 'ontology')
+            return;
+        //rename these to a file name similar to the ontology slug
+        [
+            'src/ontologies/example-ontology.ts',
+            // The register sibling is what index.ts imports; without it here the scaffold keeps a
+            // literal `example-ontology.register.ts` full of unsubstituted `${...}` placeholders and
+            // nothing ever calls linkedOntology().
+            'src/ontologies/example-ontology.register.ts',
+            'src/data/example-ontology.json',
+            'src/data/example-ontology.json.d.ts',
+        ].forEach((f) => {
+            let parts = f.split('/');
+            let newParts = [...parts];
+            let [, ...extensions] = newParts.pop().split('.');
+            let newName = hyphenName + '.' + extensions.join('.');
+            fs.renameSync(path.join(targetFolder, f), path.join(targetFolder, ...newParts, newName));
+        });
+    });
+}
+/**
+ * Ask what kind of package to make — only ever on a terminal, and only when
+ * `--kind` did not say.
+ */
+function askPackageKind(name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`\nWhat kind of package is ${chalk.magenta(name)}?\n` +
+            `  1) ontology  one ontology, no shapes or components   (${packageNameFor(name, 'ontology')})\n` +
+            `  2) assets    shapes, components and a backend         (${packageNameFor(name, 'assets')})\n` +
+            `  3) both      the two packages above\n`);
+        const kinds = ['ontology', 'assets', 'both'];
+        let answer = '';
+        while (!['1', '2', '3'].includes(answer)) {
+            answer = yield promptUser('Choose 1, 2 or 3: ');
+        }
+        return kinds[Number(answer) - 1];
+    });
+}
 /**
  * Ask where a new package goes — only ever on a terminal, and only when no
  * flag said so already.
@@ -2004,8 +2155,8 @@ function installStandalonePackage(targetFolder) {
  * workspace member by name, and `build-all` builds what the app depends on —
  * and the install runs at the app root, where the workspace is.
  */
-function installWorkspacePackage(name, targetFolder, appRoot) {
-    return __awaiter(this, void 0, void 0, function* () {
+function installWorkspacePackage(name_1, targetFolder_1, appRoot_1) {
+    return __awaiter(this, arguments, void 0, function* (name, targetFolder, appRoot, skipInstall = false) {
         const appPkgPath = path.join(appRoot, 'package.json');
         const appPkg = fs.readJsonSync(appPkgPath);
         const workspaces = ensureWorkspaceGlob(appPkg);
@@ -2016,6 +2167,10 @@ function installWorkspacePackage(name, targetFolder, appRoot) {
         fs.writeJsonSync(appPkgPath, appPkg, { spaces: 2 });
         log(`Added ${name}@^${version} to ${path.relative(process.cwd(), appPkgPath) || 'package.json'}` +
             (workspaces.changed ? ' and packages/* to its workspaces' : ''));
+        if (skipInstall) {
+            log(`Prepared a new linked package in ${chalk.magenta(targetFolder)} (install skipped)`);
+            return;
+        }
         const setup = yield packageSetupFor(appRoot);
         yield installThenBuild(setup, appRoot, targetFolder, `The app's package.json already declares ${name}; run the install again at the app root once it is fixed.`);
         log(`Prepared a new linked package in ${chalk.magenta(targetFolder)}, part of this app's repository`, `Run ${chalk.blueBright(runScriptCommand(setup.packageManager, 'start'))} in it to continuously rebuild on file changes`);