@plumeria/init 19.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) zss-in-js contributer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# @plumeria/init
+
+Sets Plumeria up in a project that already exists. No install needed — run it
+with `npx`.
+
+```sh
+npx @plumeria/init
+```
+
+It reads the project, asks what it cannot read, shows the plan, and only then
+writes. Nothing is installed or patched before you say so.
+
+```
+✔ detected  next  pnpm  typescript
+
+  ➡︎ install  @plumeria/core @plumeria/next-plugin @plumeria/eslint-plugin oxlint
+  + write    plumeria.d.ts     classStyle
+  ~ patch    next.config.ts    withPlumeria(...)
+  ~ patch    eslint.config.ts  plumeria.configs.recommended
+  ~ patch    package.json      build: plumerialint -- next build
+```
+
+## What it detects
+
+The package manager comes from `packageManager` or the lockfile, both looked for
+upwards from the directory init runs in, so a package inside a workspace is
+installed with the manager the workspace root uses. The bundler comes from the
+dependencies, and from the config files when nothing is installed yet: `next`, `vite`, `astro`, `webpack`, `rspack`, `rollup`,
+`rolldown`, `esbuild`, `farm` and `bun`. Pass `--bundler <name>` to decide it
+yourself.
+
+Next.js gets `@plumeria/next-plugin`; every other bundler gets
+`@plumeria/unplugin` with the factory that matches it.
+
+## What it asks
+
+**Which spelling of a two-named property does this project write?** —
+`marginBlockStart` or `marginTop`. The answer reaches both sides at once: the
+bundler plugin gets `withoutLogicalProperties` or `withoutPhysicalProperties`,
+so the counterpart cannot compile, and ESLint gets
+`@plumeria/no-logical-properties` or `@plumeria/no-physical-properties`, so it
+is reported while you type. Answering "both" sets neither. `--sizes` extends
+the answer to the size axis, where `width` and `inlineSize` are the pair.
+
+**Expand a border shorthand into the three declarations it sets?** — turns on
+`@plumeria/expand-border-shorthands`. A `border` shorthand crosses the axis
+shorthands without either containing the other, so leaving it whole makes the
+outcome depend on order.
+
+**Which JSX prop carries styles?** — `classStyle` by default. A renamed prop is
+written into the plugin as `styleProp` and declared in `plumeria.d.ts`, so the
+two cannot disagree. It has to be an identifier TypeScript can declare, and a
+name React leaves free; `className`, `style`, `key`, `ref` and `children` are
+refused, from the prompt and from `--style-prop` alike.
+
+**Set up `@plumeria/eslint-plugin` and the `plumerialint` build guard?** — adds
+the plugin and `oxlint`, writes or extends the flat config, and prefixes the
+`build` script with `plumerialint --`, so a style error stops the build.
+
+## What it writes
+
+- `plumeria.d.ts` — the styling prop TypeScript reads.
+- the bundler config — the plugin, and the options the answers chose. An
+  existing config is patched: the import lands after the last import, and the
+  plugin joins the `plugins` array. A Next config has its default export
+  wrapped in `withPlumeria`.
+- `eslint.config.ts` — `plumeria.configs.recommended` plus the rules that were
+  asked for. An existing flat config is extended rather than replaced.
+- `package.json` — `plumerialint --` in front of the `build` script, and on
+  Next.js `rimraf .next` before `dev` and before `build`, so a version change is
+  not read as a compile error. A `pre` script is added only for a script the
+  project actually has, and one it already wrote is left alone. Clearing the
+  cache is a Next.js concern rather than a lint one, so `--no-eslint` keeps it.
+
+What counts as already set up is the plugin being *called*, not merely imported.
+A bare `plumeria.version`, and a call inside a comment, a string or a regex
+literal, all read as not set up, because none of them registers anything; an import nothing
+calls is completed rather than skipped, and the binding the file already named is
+the one that gets called. An import spanning several lines is read as one
+statement, so it is never duplicated. A second run writes nothing; a
+half-finished one is finished.
+
+The `plugins` array it extends is the one the config object owns — a `plugins`
+belonging to a nested key, such as `test` for Vitest, is never written into.
+Where the plugin cannot be placed safely — a config whose own object has no
+`plugins` array, a build script rather than a config, a legacy `.eslintrc` —
+nothing is touched and the snippet is printed instead.
+
+## Options
+
+```sh
+npx @plumeria/init --dry-run            # show the plan, write nothing
+npx @plumeria/init --yes                # take every default, ask nothing
+npx @plumeria/init --physical --sizes   # answer the spelling question up front
+npx @plumeria/init --style-prop sx
+npx @plumeria/init --bundler rollup
+npx @plumeria/init --no-eslint          # leave ESLint and the plumerialint guard out
+npx @plumeria/init --no-install         # write the configs, print the command
+npx @plumeria/init --cwd packages/app
+```
+
+Without a TTY it never asks — every unanswered question takes its default,
+which is what makes it usable in CI. Colour comes from `node:util`'s
+`styleText`, which leaves the text alone when the output is not a terminal, so a
+piped or logged run carries no escape codes.
+
+Installed rather than fetched, the command is `plumeria-init`.
+
+Commit before running, so the writes can be reverted with `git checkout`.

package/bin/init.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+const { main } = require('../dist/cli.js');
+
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    console.error(`✖ ${(error && error.message) || error}`);
+    process.exitCode = 1;
+  },
+);

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+import type { Bundler } from './detect';
+import type { Answers } from './setup';
+interface Options {
+    cwd: string;
+    bundler: Bundler | undefined;
+    preset: Partial<Answers>;
+    yes: boolean;
+    dryRun: boolean;
+}
+export declare function parseArgs(argv: string[]): Options | null;
+export declare function main(argv: string[]): Promise<number>;
+export {};

package/dist/cli.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.main = main;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const detect_1 = require("./detect");
+const prompt_1 = require("./prompt");
+const setup_1 = require("./setup");
+const style_1 = require("./style");
+const { version } = require('../package.json');
+const USAGE = `@plumeria/init — set up Plumeria in this project
+
+Usage
+  npx @plumeria/init
+
+It reads the project, asks what it cannot detect, then installs the packages
+and writes the configs. Nothing is written before the plan is shown.
+
+Options
+  -y, --yes            accept every default, ask nothing
+  -d, --dry-run        show the plan without writing
+      --bundler <name> ${detect_1.BUNDLERS.join(', ')}
+      --style-prop <p> the JSX prop that carries styles (default classStyle)
+      --logical        this project writes logical properties
+      --physical       this project writes physical properties
+      --sizes          extend the spelling policy to the size axis
+      --no-eslint      leave ESLint and the plumerialint guard out
+      --no-install     write the configs, print the install command
+      --cwd <dir>      run against another directory
+  -h, --help           show this message
+  -v, --version        show the version
+
+The spelling answer reaches both sides: the bundler plugin rejects the
+counterpart at compile time, and ESLint reports it while you type.`;
+class UsageError extends Error {
+}
+function parseArgs(argv) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        console.log(USAGE);
+        return null;
+    }
+    if (argv.includes('-v') || argv.includes('--version')) {
+        console.log(version);
+        return null;
+    }
+    const options = {
+        cwd: process.cwd(),
+        bundler: undefined,
+        preset: {},
+        yes: false,
+        dryRun: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '-y':
+            case '--yes':
+                options.yes = true;
+                break;
+            case '-d':
+            case '--dry-run':
+                options.dryRun = true;
+                break;
+            case '--logical':
+                options.preset.spelling = 'logical';
+                break;
+            case '--physical':
+                options.preset.spelling = 'physical';
+                break;
+            case '--both':
+                options.preset.spelling = 'both';
+                break;
+            case '--sizes':
+                options.preset.sizes = true;
+                break;
+            case '--no-eslint':
+                options.preset.eslint = false;
+                break;
+            case '--no-install':
+                options.preset.install = false;
+                break;
+            case '--bundler':
+                options.bundler = read(argv, ++i, '--bundler');
+                break;
+            case '--style-prop':
+                options.preset.styleProp = styleProp(read(argv, ++i, '--style-prop'));
+                break;
+            case '--cwd':
+                options.cwd = node_path_1.default.resolve(read(argv, ++i, '--cwd'));
+                break;
+            default:
+                throw new UsageError(`unknown option "${arg}"`);
+        }
+    }
+    if (options.bundler && !detect_1.BUNDLERS.includes(options.bundler)) {
+        throw new UsageError(`unknown bundler "${options.bundler}". Available: ${detect_1.BUNDLERS.join(', ')}`);
+    }
+    if (options.preset.sizes && options.preset.spelling === undefined) {
+        throw new UsageError('--sizes needs --logical or --physical');
+    }
+    return options;
+}
+function styleProp(value) {
+    try {
+        return (0, setup_1.assertStyleProp)(value);
+    }
+    catch (error) {
+        throw new UsageError(error.message);
+    }
+}
+function read(argv, index, flag) {
+    const value = argv[index];
+    if (!value || value.startsWith('-'))
+        throw new UsageError(`${flag} needs a value`);
+    return value;
+}
+const MARKS = {
+    install: '➡︎',
+    write: '+',
+    patch: '~',
+    manual: '!',
+    skip: '·',
+};
+const PAINT = {
+    install: style_1.style.install,
+    write: style_1.style.write,
+    patch: style_1.style.patch,
+    manual: style_1.style.manual,
+    skip: style_1.style.skip,
+};
+function show(actions) {
+    const label = Math.max(...actions.map((action) => action.label.length));
+    const named = actions.filter((action) => action.kind !== 'install');
+    const file = Math.max(0, ...named.map((action) => action.file.length));
+    const pad = (text, width) => ' '.repeat(Math.max(0, width - text.length));
+    for (const action of actions) {
+        const head = PAINT[action.kind](`${MARKS[action.kind]} ${action.label}`) +
+            pad(action.label, label);
+        const target = action.kind === 'install'
+            ? ''
+            : `  ${style_1.style.strong(action.file)}${pad(action.file, file)}`;
+        console.log(`  ${head}${target}  ${action.note}`);
+    }
+}
+function apply(root, action) {
+    if (action.kind !== 'write' && action.kind !== 'patch')
+        return;
+    const file = node_path_1.default.join(root, action.file);
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    node_fs_1.default.writeFileSync(file, action.contents);
+}
+function install(root, action) {
+    if (action.kind !== 'install')
+        return 0;
+    const [command, ...args] = action.command.split(' ');
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd: root,
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+    });
+    return result.status ?? 1;
+}
+async function main(argv) {
+    let options;
+    try {
+        options = parseArgs(argv);
+    }
+    catch (error) {
+        if (!(error instanceof UsageError))
+            throw error;
+        console.error(`${style_1.style.failure('✖')} ${error.message}\n`);
+        console.error(USAGE);
+        return 1;
+    }
+    if (!options)
+        return 0;
+    const detected = (0, detect_1.detect)(options.cwd, options.bundler);
+    const found = [
+        detected.bundler,
+        detected.packageManager,
+        detected.typescript ? 'typescript' : 'javascript',
+    ]
+        .map((name) => style_1.style.strong(name))
+        .join('  ');
+    console.log(`\n${style_1.style.ok('✔')} detected  ${found}`);
+    const interactive = !options.yes && process.stdin.isTTY === true;
+    let asker;
+    let answers;
+    try {
+        if (interactive) {
+            asker = (0, prompt_1.terminal)();
+            answers = await (0, prompt_1.ask)(asker, options.preset);
+        }
+        else {
+            answers = { ...setup_1.DEFAULT_ANSWERS, ...options.preset };
+        }
+        const actions = (0, setup_1.plan)(detected, answers);
+        console.log('');
+        show(actions);
+        if (options.dryRun) {
+            console.log(`\n${style_1.style.faint('Run without --dry-run to apply.')}`);
+            return 0;
+        }
+        if (interactive && asker) {
+            const go = (await asker.question('\nApply? (Y/n) ')).trim().toLowerCase();
+            if (go !== '' && go !== 'y' && go !== 'yes') {
+                console.log(style_1.style.faint('Nothing was written.'));
+                return 0;
+            }
+        }
+        for (const action of actions)
+            apply(detected.root, action);
+        const wanted = actions.find((action) => action.kind === 'install');
+        if (wanted && answers.install) {
+            console.log('');
+            const status = install(detected.root, wanted);
+            if (status !== 0) {
+                console.error(`\n${style_1.style.failure('✖')} ${wanted.command} failed. Run it yourself and try again.`);
+                return status;
+            }
+        }
+        else if (wanted) {
+            console.log(`\n${style_1.style.install('➡︎')} run: ${wanted.command}`);
+        }
+        console.log(`\n${style_1.style.ok('✔')} Plumeria is set up.`);
+        const manual = actions.filter((action) => action.kind === 'manual');
+        if (manual.length === 0)
+            return 0;
+        console.log(`\n${style_1.style.manual('Left to you — these could not be written safely:')}\n`);
+        for (const action of manual) {
+            if (action.kind !== 'manual')
+                continue;
+            console.log(`  ${style_1.style.strong(action.file)}  ${action.note}`);
+            for (const line of action.snippet.split('\n'))
+                console.log(style_1.style.faint(`    ${line}`));
+            console.log('');
+        }
+        return 1;
+    }
+    finally {
+        asker?.close();
+    }
+}

package/dist/detect.d.ts

@@ -0,0 +1,28 @@
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export type Bundler = 'next' | 'vite' | 'astro' | 'webpack' | 'rspack' | 'rollup' | 'rolldown' | 'esbuild' | 'farm' | 'bun';
+export interface Manifest {
+    type?: string;
+    packageManager?: string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+export interface Detected {
+    root: string;
+    manifest: Manifest;
+    packageManager: PackageManager;
+    bundler: Bundler;
+    bundlerConfig: string | undefined;
+    eslintConfig: string | undefined;
+    declaration: string | undefined;
+    typescript: boolean;
+    esm: boolean;
+}
+export declare const BUNDLERS: readonly Bundler[];
+export declare const readManifest: (root: string) => Manifest;
+export declare const installed: (manifest: Manifest) => Record<string, string>;
+export declare const detectPackageManager: (root: string, manifest: Manifest) => PackageManager;
+export declare const detectBundler: (root: string, manifest: Manifest) => Bundler | undefined;
+export declare const detect: (root: string, override?: Bundler) => Detected;
+export declare const defaultConfigName: (bundler: Bundler, typescript: boolean) => string;
+export declare const configNames: (bundler: Bundler) => readonly string[];

package/dist/detect.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configNames = exports.defaultConfigName = exports.detect = exports.detectBundler = exports.detectPackageManager = exports.installed = exports.readManifest = exports.BUNDLERS = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.BUNDLERS = [
+    'next',
+    'vite',
+    'astro',
+    'webpack',
+    'rspack',
+    'rollup',
+    'rolldown',
+    'esbuild',
+    'farm',
+    'bun',
+];
+const LOCKFILES = [
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['yarn.lock', 'yarn'],
+    ['package-lock.json', 'npm'],
+];
+const CONFIG_NAMES = {
+    next: [
+        'next.config.ts',
+        'next.config.mts',
+        'next.config.mjs',
+        'next.config.js',
+        'next.config.cjs',
+    ],
+    vite: [
+        'vite.config.ts',
+        'vite.config.mts',
+        'vite.config.mjs',
+        'vite.config.js',
+    ],
+    astro: [
+        'astro.config.ts',
+        'astro.config.mts',
+        'astro.config.mjs',
+        'astro.config.js',
+    ],
+    webpack: [
+        'webpack.config.ts',
+        'webpack.config.mjs',
+        'webpack.config.js',
+        'webpack.config.cjs',
+    ],
+    rspack: [
+        'rspack.config.ts',
+        'rspack.config.mjs',
+        'rspack.config.js',
+        'rspack.config.cjs',
+    ],
+    rollup: ['rollup.config.ts', 'rollup.config.mjs', 'rollup.config.js'],
+    rolldown: ['rolldown.config.ts', 'rolldown.config.mjs', 'rolldown.config.js'],
+    esbuild: ['build.ts', 'build.mjs', 'build.js', 'esbuild.config.js'],
+    farm: ['farm.config.ts', 'farm.config.mjs', 'farm.config.js'],
+    bun: ['build.ts', 'build.mjs', 'build.js'],
+};
+const ESLINT_NAMES = [
+    'eslint.config.ts',
+    'eslint.config.mts',
+    'eslint.config.mjs',
+    'eslint.config.js',
+    'eslint.config.cjs',
+    '.eslintrc.json',
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc',
+];
+const DECLARATION_NAMES = [
+    'plumeria.d.ts',
+    'src/plumeria.d.ts',
+    'app/plumeria.d.ts',
+    'types/plumeria.d.ts',
+];
+const readManifest = (root) => {
+    const file = node_path_1.default.join(root, 'package.json');
+    if (!node_fs_1.default.existsSync(file)) {
+        throw new Error(`no package.json in ${root}. Run this from the project root.`);
+    }
+    return JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+};
+exports.readManifest = readManifest;
+const installed = (manifest) => ({
+    ...manifest.dependencies,
+    ...manifest.devDependencies,
+});
+exports.installed = installed;
+const named = (value) => value === 'pnpm' || value === 'yarn' || value === 'bun' || value === 'npm'
+    ? value
+    : undefined;
+const declaredIn = (dir) => {
+    const file = node_path_1.default.join(dir, 'package.json');
+    if (!node_fs_1.default.existsSync(file))
+        return undefined;
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+        return named(parsed.packageManager?.split('@')[0]);
+    }
+    catch {
+        return undefined;
+    }
+};
+const detectPackageManager = (root, manifest) => {
+    const own = named(manifest.packageManager?.split('@')[0]);
+    if (own)
+        return own;
+    for (let dir = root;;) {
+        for (const [lockfile, manager] of LOCKFILES) {
+            if (node_fs_1.default.existsSync(node_path_1.default.join(dir, lockfile)))
+                return manager;
+        }
+        if (dir !== root) {
+            const declared = declaredIn(dir);
+            if (declared)
+                return declared;
+        }
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return 'npm';
+};
+exports.detectPackageManager = detectPackageManager;
+const firstExisting = (root, names) => names.find((name) => node_fs_1.default.existsSync(node_path_1.default.join(root, name)));
+const detectBundler = (root, manifest) => {
+    const deps = (0, exports.installed)(manifest);
+    const has = (name) => name in deps;
+    if (has('next'))
+        return 'next';
+    if (has('astro'))
+        return 'astro';
+    if (has('@rspack/core') || has('@rspack/cli'))
+        return 'rspack';
+    if (has('@farmfe/core'))
+        return 'farm';
+    if (has('vite') || has('@react-router/dev'))
+        return 'vite';
+    if (has('rolldown'))
+        return 'rolldown';
+    if (has('rollup'))
+        return 'rollup';
+    if (has('webpack'))
+        return 'webpack';
+    if (has('esbuild'))
+        return 'esbuild';
+    for (const bundler of exports.BUNDLERS) {
+        if (bundler === 'bun')
+            continue;
+        if (firstExisting(root, CONFIG_NAMES[bundler]))
+            return bundler;
+    }
+    if (node_fs_1.default.existsSync(node_path_1.default.join(root, 'bun.lock')) ||
+        node_fs_1.default.existsSync(node_path_1.default.join(root, 'bun.lockb'))) {
+        return 'bun';
+    }
+    return undefined;
+};
+exports.detectBundler = detectBundler;
+const detect = (root, override) => {
+    const manifest = (0, exports.readManifest)(root);
+    const bundler = override ?? (0, exports.detectBundler)(root, manifest);
+    if (!bundler) {
+        throw new Error(`no bundler found. Pass --bundler <${exports.BUNDLERS.join('|')}>.`);
+    }
+    const declaration = firstExisting(root, DECLARATION_NAMES);
+    const typescript = node_fs_1.default.existsSync(node_path_1.default.join(root, 'tsconfig.json')) ||
+        'typescript' in (0, exports.installed)(manifest);
+    return {
+        root,
+        manifest,
+        packageManager: (0, exports.detectPackageManager)(root, manifest),
+        bundler,
+        bundlerConfig: firstExisting(root, CONFIG_NAMES[bundler]),
+        eslintConfig: firstExisting(root, ESLINT_NAMES),
+        declaration,
+        typescript,
+        esm: manifest.type === 'module',
+    };
+};
+exports.detect = detect;
+const defaultConfigName = (bundler, typescript) => {
+    const names = CONFIG_NAMES[bundler];
+    const ending = (suffix) => names.find((name) => name.endsWith(suffix));
+    if (typescript)
+        return ending('.ts') ?? names[0];
+    return ending('.mjs') ?? ending('.js') ?? names[0];
+};
+exports.defaultConfigName = defaultConfigName;
+const configNames = (bundler) => CONFIG_NAMES[bundler];
+exports.configNames = configNames;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { detect, detectBundler, detectPackageManager } from './detect';
+export type { Bundler, Detected, PackageManager } from './detect';
+export { plan } from './setup';
+export type { Action, Answers, Spelling } from './setup';
+export { main } from './cli';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.plan = exports.detectPackageManager = exports.detectBundler = exports.detect = void 0;
+var detect_1 = require("./detect");
+Object.defineProperty(exports, "detect", { enumerable: true, get: function () { return detect_1.detect; } });
+Object.defineProperty(exports, "detectBundler", { enumerable: true, get: function () { return detect_1.detectBundler; } });
+Object.defineProperty(exports, "detectPackageManager", { enumerable: true, get: function () { return detect_1.detectPackageManager; } });
+var setup_1 = require("./setup");
+Object.defineProperty(exports, "plan", { enumerable: true, get: function () { return setup_1.plan; } });
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "main", { enumerable: true, get: function () { return cli_1.main; } });

package/dist/prompt.d.ts

@@ -0,0 +1,7 @@
+import type { Answers } from './setup';
+export interface Asker {
+    question: (prompt: string) => Promise<string>;
+    close: () => void;
+}
+export declare const terminal: () => Asker;
+export declare const ask: (asker: Asker, preset: Partial<Answers>) => Promise<Answers>;