vovk-cli 0.0.1-draft.99 → 0.0.3

package/dist/init/index.mjs

@@ -1,47 +1,52 @@
-import { confirm, select } from '@inquirer/prompts';
+import { confirm, select, checkbox } from '@inquirer/prompts';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import getConfigPaths from '../getProjectInfo/getConfigAbsolutePaths.mjs';
 import chalk from 'chalk';
-import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
-import installDependencies, { getPackageManager } from './installDependencies.mjs';
-import getLogger from '../utils/getLogger.mjs';
-import createConfig from './createConfig.mjs';
-import updateNPMScripts, { getDevScript } from './updateNPMScripts.mjs';
-import checkTSConfigForExperimentalDecorators from './checkTSConfigForExperimentalDecorators.mjs';
-import updateTypeScriptConfig from './updateTypeScriptConfig.mjs';
-import updateDependenciesWithoutInstalling from './updateDependenciesWithoutInstalling.mjs';
-import logUpdateDependenciesError from './logUpdateDependenciesError.mjs';
-import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import NPMCliPackageJson from '@npmcli/package-json';
+import { getConfigAbsolutePaths } from '../getProjectInfo/getConfig/getConfigAbsolutePaths.mjs';
+import { getFileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import { installDependencies, getPackageManager } from './installDependencies.mjs';
+import { getLogger } from '../utils/getLogger.mjs';
+import { createConfig } from './createConfig.mjs';
+import { updateNPMScripts, getDevScript } from './updateNPMScripts.mjs';
+import { checkTSConfigForExperimentalDecorators } from './checkTSConfigForExperimentalDecorators.mjs';
+import { updateTypeScriptConfig } from './updateTypeScriptConfig.mjs';
+import { updateDependenciesWithoutInstalling } from './updateDependenciesWithoutInstalling.mjs';
+import { logUpdateDependenciesError } from './logUpdateDependenciesError.mjs';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
 export class Init {
     root;
     log;
-    async #init({ configPaths, pkgJson, }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, validateOnClient, reactQuery, dryRun, channel, }) {
+    async #init({ configPaths, pkgJson, }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, bundle, lang, dryRun, channel, }) {
         const { log, root } = this;
-        const dependencies = ['vovk', 'vovk-client'];
-        const devDependencies = ['vovk-cli', 'openapi3-ts'];
+        const dependencies = ['vovk', 'vovk-client', 'vovk-ajv', 'openapi3-ts'];
+        const devDependencies = ['vovk-cli'];
+        if (lang?.includes('py')) {
+            devDependencies.push('vovk-python');
+        }
+        if (lang?.includes('rs')) {
+            devDependencies.push('vovk-rust');
+        }
         // delete older config files
         if (configPaths.length) {
             await Promise.all(configPaths.map((configPath) => fs.rm(configPath)));
             log.debug(`Deleted existing config file${configPaths.length > 1 ? 's' : ''} at ${configPaths.join(', ')}`);
         }
         if (validationLibrary) {
-            dependencies.push(validationLibrary);
             dependencies.push(...({
-                'vovk-zod': ['zod'],
-                'vovk-yup': ['yup'],
-                'vovk-dto': ['class-validator', 'class-transformer', 'vovk-mapped-types', 'reflect-metadata'],
+                zod: ['zod'],
+                valibot: ['valibot', '@valibot/to-json-schema'],
+                arktype: ['arktype'],
             }[validationLibrary] ?? []));
         }
-        if (reactQuery) {
-            dependencies.push('vovk-react-query');
-            dependencies.push('@tanstack/react-query');
+        if (bundle) {
+            const TSDOWN_VERSION = '0.19.0';
+            devDependencies.push(`tsdown@${TSDOWN_VERSION}`);
         }
         if (updateScripts) {
             try {
-                if (!dryRun)
-                    await updateNPMScripts(pkgJson, root, updateScripts);
+                if (!dryRun && pkgJson)
+                    await updateNPMScripts({ pkgJson, root, bundle, updateScriptsMode: updateScripts });
                 log.info('Updated scripts at package.json');
             }
             catch (error) {
@@ -53,16 +58,22 @@ export class Init {
         }
         if (updateTsConfig) {
             try {
+                const compilerOptions = {
+                    experimentalDecorators: true,
+                };
                 if (!dryRun)
-                    await updateTypeScriptConfig(root);
-                log.info('Added "experimentalDecorators" to tsconfig.json');
+                    await updateTypeScriptConfig(root, compilerOptions);
+                log.info(`Added ${Object.keys(compilerOptions)
+                    .map((k) => `"${k}"`)
+                    .join(' and ')} to tsconfig.json`);
             }
             catch (error) {
                 log.error(`Failed to update tsconfig.json: ${error.message}`);
             }
         }
-        if (!dryRun) {
+        if (!dryRun && pkgJson) {
             let depsUpdated = false;
+            const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun, pkgJson });
             try {
                 await updateDependenciesWithoutInstalling({
                     log,
@@ -75,29 +86,30 @@ export class Init {
             }
             catch (e) {
                 const error = e;
-                logUpdateDependenciesError({ log, error, useNpm, useYarn, usePnpm, useBun, dependencies, devDependencies });
+                logUpdateDependenciesError({
+                    log,
+                    error,
+                    packageManager,
+                    dependencies,
+                    devDependencies,
+                    channel,
+                });
             }
             if (depsUpdated) {
-                const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun });
                 if (skipInstall) {
-                    log.info(`Installation skipped. Please, install them manually with ${chalkHighlightThing(packageManager + ' install')}`);
+                    log.info(`Installation skipped. Please, install them manually with ${chalkHighlightThing(`${packageManager} install`)}`);
                 }
                 else {
                     try {
                         await installDependencies({
                             log,
                             cwd: root,
-                            options: {
-                                useNpm,
-                                useYarn,
-                                usePnpm,
-                                useBun,
-                            },
+                            packageManager,
                         });
                         log.info('Dependencies installed successfully');
                     }
                     catch (error) {
-                        log.warn(`Failed to install dependencies: ${error.message}. Please, install them manually with ${chalkHighlightThing(packageManager + ' install')}`);
+                        log.warn(`Failed to install dependencies. ${error.message}. Please, install them manually with ${chalkHighlightThing(`${packageManager} install`)}`);
                     }
                 }
             }
@@ -106,43 +118,46 @@ export class Init {
             const { configAbsolutePath } = await createConfig({
                 root,
                 log,
-                options: { validationLibrary, validateOnClient, reactQuery, channel, dryRun },
+                options: { validationLibrary, channel, bundle, lang, dryRun },
             });
-            log.info('Config created successfully at ' + configAbsolutePath);
+            log.info(`Config created successfully at ${chalkHighlightThing(configAbsolutePath)}`);
+            log.info(`You can now create a root segment with ${chalkHighlightThing('npx vovk new segment')} command`);
         }
         catch (error) {
-            log.error(`Failed to create config: ${error.message}`);
+            log.error(`Failed to create config: ${error.message}. Please, refer to the documentation at https://vovk.dev/config`);
         }
     }
-    async main(prefix, { yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, validateOnClient, reactQuery, dryRun, channel, }) {
+    async main({ prefix, yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, bundle, lang, dryRun, channel, }) {
         const cwd = process.cwd();
-        const root = path.resolve(cwd, prefix);
-        const log = getLogger(logLevel);
-        const pkgJson = await NPMCliPackageJson.load(root);
+        const root = path.resolve(cwd, prefix ?? '.');
+        const log = getLogger(logLevel ?? 'info');
+        const pkgJson = await NPMCliPackageJson.load(root).catch(() => null);
         this.root = root;
         this.log = log;
-        const configPaths = await getConfigPaths({ cwd, relativePath: prefix });
+        const configPaths = await getConfigAbsolutePaths({ cwd, relativePath: prefix });
         if (yes) {
-            return this.#init({ configPaths, pkgJson }, {
-                useNpm: useNpm ?? (!useYarn && !usePnpm && !useBun),
+            return this.#init({ configPaths, pkgJson, cwd }, {
+                prefix: prefix ?? '.',
+                useNpm: useNpm ?? false,
                 useYarn: useYarn ?? false,
                 usePnpm: usePnpm ?? false,
                 useBun: useBun ?? false,
                 skipInstall: skipInstall ?? false,
                 updateTsConfig: updateTsConfig ?? true,
                 updateScripts: updateScripts ?? 'implicit',
-                validationLibrary: validationLibrary?.toLocaleLowerCase() === 'none' ? null : (validationLibrary ?? 'vovk-zod'),
-                validateOnClient: validateOnClient ?? true,
-                reactQuery: reactQuery ?? true,
+                validationLibrary: validationLibrary?.toLocaleLowerCase() === 'none' ? null : (validationLibrary ?? 'zod'),
+                bundle: bundle ?? true,
                 dryRun: dryRun ?? false,
                 channel: channel ?? 'latest',
+                lang: lang ?? [],
             });
         }
         if (!(await getFileSystemEntryType(path.join(root, 'package.json')))) {
-            throw new Error(`package.json not found at ${root}. Run "npx create-next-app" to create a new Next.js project.`);
+            log.warn(`${chalkHighlightThing('package.json')} not found at ${chalkHighlightThing(root)}. Run "npx create-next-app" to create a new Next.js project
+        .`);
         }
-        if (!(await getFileSystemEntryType(path.join(root, 'tsconfig.json')))) {
-            throw new Error(`tsconfig.json not found at ${root}. Run "npx tsc --init" to create a new tsconfig.json file.`);
+        else if (pkgJson && !(await getFileSystemEntryType(path.join(root, 'tsconfig.json')))) {
+            log.warn(`${chalkHighlightThing('tsconfig.json')} not found at ${chalkHighlightThing(root)}. Run "npx tsc --init" to create a new tsconfig.json file.`);
         }
         if (configPaths.length) {
             if (!(await confirm({
@@ -156,62 +171,27 @@ export class Init {
                 : (validationLibrary ??
                     (await select({
                         message: 'Choose validation library',
-                        default: 'vovk-zod',
+                        default: 'zod',
                         choices: [
                             {
-                                name: 'vovk-zod',
-                                value: 'vovk-zod',
+                                name: 'Zod',
+                                value: 'zod',
                                 description: 'Use Zod for data validation',
                             },
                             {
-                                name: 'vovk-yup',
-                                value: 'vovk-yup',
-                                description: 'Use Yup for data validation',
+                                name: 'ArkType',
+                                value: 'arktype',
+                                description: 'Use ArkType for data validation.',
                             },
                             {
-                                name: 'vovk-dto',
-                                value: 'vovk-dto',
-                                description: 'Use class-validator for data validation. Also installs class-transformer, vovk-mapped-types and reflect-metadata',
+                                name: 'Valibot',
+                                value: 'valibot',
+                                description: 'Use Valibot for data validation.',
                             },
                             { name: 'None', value: null, description: 'Install validation library later' },
                         ],
                     })));
-        if (validationLibrary) {
-            validateOnClient =
-                validateOnClient ??
-                    (await confirm({
-                        message: 'Do you want to enable client validation?',
-                    }));
-        }
-        updateScripts =
-            updateScripts ??
-                (await select({
-                    message: 'Do you want to update package.json by adding "generate" and updating "dev" NPM scripts?',
-                    default: 'implicit',
-                    choices: [
-                        {
-                            name: 'Yes, use "concurrently" implicitly',
-                            value: 'implicit',
-                            description: `The "dev" script will use "concurrently" API to run "next dev" and "vovk dev" commands together and automatically find an available port ${chalk.whiteBright.bold(`"${getDevScript(pkgJson, 'implicit')}"`)}`,
-                        },
-                        {
-                            name: 'Yes, use "concurrently" explicitly',
-                            value: 'explicit',
-                            description: `The "dev" script will use pre-defined PORT variable and run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.whiteBright.bold(`"${getDevScript(pkgJson, 'explicit')}"`)}`,
-                        },
-                        {
-                            name: 'No',
-                            value: undefined,
-                            description: 'Add the NPM scripts manually',
-                        },
-                    ],
-                }));
-        reactQuery =
-            reactQuery ??
-                (await confirm({
-                    message: 'Do you want to use @tanstack/react-query for data fetching at React components?',
-                }));
-        if (typeof updateTsConfig === 'undefined') {
+        if (typeof updateTsConfig === 'undefined' && pkgJson) {
             let shouldAsk = false;
             try {
                 shouldAsk = !(await checkTSConfigForExperimentalDecorators(root));
@@ -220,13 +200,48 @@ export class Init {
                 log.error(`Failed to check tsconfig.json for "experimentalDecorators": ${error.message}`);
             }
             if (shouldAsk) {
+                const keys = ['experimentalDecorators'];
                 updateTsConfig = await confirm({
-                    message: 'Do you want to add "experimentalDecorators" option to tsconfig.json?',
+                    message: `Do you want to add ${keys.map((k) => `"${k}"`).join(' and ')} to tsconfig.json? (recommended)`,
                 });
             }
         }
-        await this.#init({ configPaths, pkgJson }, {
-            useNpm: useNpm ?? (!useYarn && !usePnpm && !useBun),
+        bundle ??= await confirm({
+            message: 'Do you want to set up "tsdown" to bundle TypeScript client?',
+            default: true,
+        });
+        updateScripts ??= !pkgJson
+            ? undefined
+            : await select({
+                message: `Do you want to update "dev" and add "prebuild"${bundle ? ' and "bundle"' : ''} NPM scripts at package.json (recommended)?`,
+                default: 'implicit',
+                choices: [
+                    {
+                        name: 'Yes, use "concurrently" implicitly',
+                        value: 'implicit',
+                        description: `The ${chalk.cyanBright.bold(`"dev"`)} script will use concurrently API to run "next dev" and "vovk dev" commands at the same time. It will automatically find an available port, running ${chalk.cyanBright.bold(`"${getDevScript(pkgJson, 'implicit')}"`)}. The ${chalk.cyanBright.bold(`"prebuild"`)} script will be set to ${chalk.cyanBright.bold(`"vovk generate"`)}`,
+                    },
+                    {
+                        name: 'Yes, use "concurrently" explicitly',
+                        value: 'explicit',
+                        description: `The ${chalk.cyanBright.bold(`"dev"`)} script will use pre-defined PORT variable to run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.cyanBright.bold(`"${getDevScript(pkgJson, 'explicit')}"`)}. The ${chalk.cyanBright.bold(`"prebuild"`)} script will be set to ${chalk.cyanBright.bold(`"vovk generate"`)}`,
+                    },
+                    {
+                        name: 'No',
+                        value: undefined,
+                        description: 'Add the NPM scripts manually',
+                    },
+                ],
+            });
+        lang ??= await checkbox({
+            message: 'Do you want to generate RPC client for other languages besides TypeScript (experimental)?',
+            choices: [
+                { name: 'Python', value: 'py' },
+                { name: 'Rust', value: 'rs' },
+            ],
+        });
+        await this.#init({ configPaths, pkgJson, cwd }, {
+            useNpm: useNpm ?? false,
             useYarn: useYarn ?? false,
             usePnpm: usePnpm ?? false,
             useBun: useBun ?? false,
@@ -234,8 +249,8 @@ export class Init {
             updateTsConfig,
             updateScripts,
             validationLibrary,
-            validateOnClient,
-            reactQuery,
+            bundle,
+            lang,
             dryRun,
             channel,
         });

package/dist/init/installDependencies.d.mts

@@ -1,10 +1,12 @@
-import getLogger from '../utils/getLogger.mjs';
+import type NPMCliPackageJson from '@npmcli/package-json';
+import type { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
-type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
-export declare function getPackageManager(options: Pick<InitOptions, 'useNpm' | 'useYarn' | 'usePnpm' | 'useBun'>): PackageManager;
-export default function installDependencies({ log, cwd, options, }: {
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export declare function getPackageManager(options: Pick<InitOptions, 'useNpm' | 'useYarn' | 'usePnpm' | 'useBun'> & {
+    pkgJson: NPMCliPackageJson;
+}): PackageManager;
+export declare function installDependencies({ log, cwd, packageManager, }: {
     log: ReturnType<typeof getLogger>;
     cwd: string;
-    options: Pick<InitOptions, 'useNpm' | 'useYarn' | 'usePnpm' | 'useBun'>;
+    packageManager: PackageManager;
 }): Promise<void>;
-export {};

package/dist/init/installDependencies.mjs

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
 export function getPackageManager(options) {
     if (options.useNpm)
         return 'npm';
@@ -8,13 +9,14 @@ export function getPackageManager(options) {
         return 'pnpm';
     if (options.useBun)
         return 'bun';
-    return 'npm'; // Default to npm if no options are true
+    const packageManager = options.pkgJson.content?.packageManager;
+    return packageManager ? packageManager.split('@')[0] : 'npm'; // Default to npm if no options are true
 }
-export default async function installDependencies({ log, cwd, options, }) {
-    const packageManager = getPackageManager(options);
-    log.info(`Installing dependencies at ${cwd} using ${packageManager}...`);
+export async function installDependencies({ log, cwd, packageManager, }) {
+    log.info(`Installing dependencies at ${chalkHighlightThing(cwd)} using ${chalkHighlightThing(packageManager)}...`);
     await new Promise((resolve, reject) => {
-        const child = spawn(packageManager, ['install'], { cwd, stdio: 'inherit' });
+        const args = ['install'];
+        const child = spawn(packageManager, args, { cwd, stdio: 'inherit' });
         child.on('close', (code) => {
             if (code === 0) {
                 resolve();

package/dist/init/logUpdateDependenciesError.d.mts

@@ -1,11 +1,11 @@
-import type getLogger from '../utils/getLogger.mjs';
-export default function logUpdateDependenciesError({ useNpm, useYarn, usePnpm, useBun, log, dependencies, devDependencies, error, }: {
-    useNpm?: boolean;
-    useYarn?: boolean;
-    usePnpm?: boolean;
-    useBun?: boolean;
+import type { InitOptions } from '../types.mjs';
+import type { getLogger } from '../utils/getLogger.mjs';
+import type { PackageManager } from './installDependencies.mjs';
+export declare function logUpdateDependenciesError({ packageManager, log, dependencies, devDependencies, error, channel, }: {
+    packageManager: PackageManager;
     log: ReturnType<typeof getLogger>;
     dependencies: string[];
     devDependencies: string[];
     error: Error;
+    channel: InitOptions['channel'];
 }): void;

package/dist/init/logUpdateDependenciesError.mjs

@@ -1,8 +1,12 @@
-import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-import { getPackageManager } from './installDependencies.mjs';
-export default function logUpdateDependenciesError({ useNpm, useYarn, usePnpm, useBun, log, dependencies, devDependencies, error, }) {
-    const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun });
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+export function logUpdateDependenciesError({ packageManager, log, dependencies, devDependencies, error, channel, }) {
     const installCommands = [];
+    const addChannel = (packageName) => {
+        const isVovk = packageName.startsWith('vovk');
+        return isVovk ? (!channel || channel !== 'latest' ? `${packageName}@${channel}` : packageName) : packageName;
+    };
+    dependencies = dependencies.map(addChannel);
+    devDependencies = devDependencies.map(addChannel);
     if (dependencies.length > 0) {
         let depInstallCmd = '';
         switch (packageManager) {

package/dist/init/updateDependenciesWithoutInstalling.d.mts

@@ -1,6 +1,6 @@
-import type getLogger from '../utils/getLogger.mjs';
-import { InitOptions } from '../types.mjs';
-export default function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }: {
+import type { getLogger } from '../utils/getLogger.mjs';
+import type { InitOptions } from '../types.mjs';
+export declare function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }: {
     log: ReturnType<typeof getLogger>;
     dir: string;
     dependencyNames: string[];

package/dist/init/updateDependenciesWithoutInstalling.mjs

@@ -1,23 +1,53 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
-async function updateDeps({ packageJson, packageNames, channel, key, }) {
+import { getNPMPackageMetadata } from '../utils/getNPMPackageMetadata.mjs';
+async function updateDeps({ packageJson, packageNames, channel, key, log, }) {
     return Promise.all(packageNames.map(async (packageName) => {
-        const metadata = await getNPMPackageMetadata(packageName);
-        const isVovk = packageName.startsWith('vovk') && packageName !== 'vovk-mapped-types';
-        const latestVersion = metadata['dist-tags'][isVovk ? (channel ?? 'latest') : 'latest'];
-        if (!packageJson[key]) {
-            packageJson[key] = {};
+        let name;
+        let version;
+        if (packageName.startsWith('@')) {
+            // Handle scoped packages (@org/name@version)
+            const lastAtIndex = packageName.lastIndexOf('@');
+            if (lastAtIndex > 0) {
+                name = packageName.substring(0, lastAtIndex);
+                version = packageName.substring(lastAtIndex + 1);
+            }
+            else {
+                name = packageName;
+                version = undefined;
+            }
+        }
+        else {
+            // Handle regular packages (name@version)
+            const parts = packageName.split('@');
+            name = parts[0];
+            version = parts[1];
+        }
+        if (version) {
+            packageJson[key] ??= {};
+            packageJson[key][name] = version;
+            return;
         }
-        packageJson[key][packageName] = `^${latestVersion}`;
+        let metadata;
+        try {
+            metadata = await getNPMPackageMetadata(name);
+        }
+        catch (error) {
+            log.error(`Failed to fetch metadata for package ${name}@${channel ?? 'latest'}: ${error}`);
+            return;
+        }
+        const isVovk = name.startsWith('vovk');
+        const latestVersion = metadata['dist-tags'][isVovk ? (channel ?? 'latest') : 'latest'];
+        packageJson[key] ??= {};
+        packageJson[key][name] = `^${latestVersion}`;
     }));
 }
-export default async function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }) {
+export async function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }) {
     const packageJsonPath = path.join(dir, 'package.json');
     const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-    await updateDeps({ packageJson, packageNames: dependencyNames, channel, key: 'dependencies' });
-    await updateDeps({ packageJson, packageNames: devDependencyNames, channel, key: 'devDependencies' });
+    await updateDeps({ packageJson, packageNames: dependencyNames, channel, log, key: 'dependencies' });
+    await updateDeps({ packageJson, packageNames: devDependencyNames, channel, log, key: 'devDependencies' });
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
     log.info('Added dependencies to package.json:');
     for (const dependency of dependencyNames) {

package/dist/init/updateNPMScripts.d.mts

@@ -1,3 +1,8 @@
-import NPMCliPackageJson from '@npmcli/package-json';
+import type NPMCliPackageJson from '@npmcli/package-json';
 export declare function getDevScript(pkgJson: NPMCliPackageJson, updateScriptsMode: 'implicit' | 'explicit'): string;
-export default function updateNPMScripts(pkgJson: NPMCliPackageJson, root: string, updateScriptsMode: 'implicit' | 'explicit'): Promise<void>;
+export declare function updateNPMScripts({ pkgJson, bundle, updateScriptsMode, }: {
+    pkgJson: NPMCliPackageJson;
+    root: string;
+    bundle?: boolean;
+    updateScriptsMode: 'implicit' | 'explicit';
+}): Promise<void>;

package/dist/init/updateNPMScripts.mjs

@@ -1,16 +1,20 @@
 export function getDevScript(pkgJson, updateScriptsMode) {
-    const nextDev = pkgJson.content.scripts?.dev ?? 'next dev';
-    const nextDevFlags = nextDev.replace('next dev', '').trim();
+    const dev = pkgJson.content.scripts?.dev ?? 'next dev';
+    if (dev.includes('vovk dev')) {
+        return dev; // Already has vovk dev
+    }
+    const nextDevFlags = dev.replace('next dev', '').trim();
     return updateScriptsMode === 'explicit'
-        ? `PORT=3000 concurrently '${nextDev}' 'vovk dev' --kill-others`
+        ? `PORT=3000 concurrently '${dev}' 'vovk dev' --kill-others`
         : `vovk dev --next-dev${nextDevFlags ? ` -- ${nextDevFlags}` : ''}`;
 }
-export default async function updateNPMScripts(pkgJson, root, updateScriptsMode) {
+export async function updateNPMScripts({ pkgJson, bundle, updateScriptsMode, }) {
     pkgJson.update({
         scripts: {
             ...pkgJson.content.scripts,
-            generate: 'vovk generate',
             dev: getDevScript(pkgJson, updateScriptsMode),
+            prebuild: 'vovk generate',
+            ...(bundle ? { bundle: 'vovk bundle' } : {}),
         },
     });
     await pkgJson.save();

package/dist/init/updateTypeScriptConfig.d.mts

@@ -1 +1,4 @@
-export default function updateTypeScriptConfig(root: string): Promise<void>;
+export declare function updateTypeScriptConfig(root: string, compilerOptions: {
+    experimentalDecorators?: true;
+    emitDecoratorMetadata?: true;
+}): Promise<void>;

package/dist/init/updateTypeScriptConfig.mjs

@@ -1,15 +1,19 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import * as jsonc from 'jsonc-parser';
-import prettify from '../utils/prettify.mjs';
-export default async function updateTypeScriptConfig(root) {
+import { prettify } from '../utils/prettify.mjs';
+export async function updateTypeScriptConfig(root, compilerOptions) {
     const tsconfigPath = path.join(root, 'tsconfig.json');
     const tsconfigContent = await fs.readFile(tsconfigPath, 'utf8');
-    // Use jsonc-parser to generate edits and modify the experimentalDecorators property
-    const edits = jsonc.modify(tsconfigContent, ['compilerOptions', 'experimentalDecorators'], true, {
-        formattingOptions: {},
-    });
-    // Apply the edits to the original content
-    const updatedContent = await prettify(jsonc.applyEdits(tsconfigContent, edits), tsconfigPath);
+    let updatedContent = tsconfigContent;
+    // Apply each compiler option
+    for (const [key, value] of Object.entries(compilerOptions)) {
+        const edits = jsonc.modify(updatedContent, ['compilerOptions', key], value, {
+            formattingOptions: {},
+        });
+        updatedContent = jsonc.applyEdits(updatedContent, edits);
+    }
+    // Prettify the final content
+    updatedContent = await prettify(updatedContent, tsconfigPath);
     await fs.writeFile(tsconfigPath, updatedContent, 'utf8');
 }

package/dist/new/addClassToSegmentCode.d.mts

@@ -1,4 +1,4 @@
-export default function addClassToSegmentCode(segmentSourceCode: string, { sourceName, compiledName, importPath, }: {
+export declare function addClassToSegmentCode(segmentSourceCode: string, { sourceName, compiledName, importPath, }: {
     sourceName: string;
     compiledName: string;
     importPath: string;

package/dist/new/addClassToSegmentCode.mjs

@@ -1,5 +1,5 @@
 import { Project, QuoteKind, SyntaxKind } from 'ts-morph';
-export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, importPath, }) {
+export function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, importPath, }) {
     const project = new Project({
         manipulationSettings: {
             quoteKind: QuoteKind.Single,
@@ -7,11 +7,11 @@ export default function addClassToSegmentCode(segmentSourceCode, { sourceName, c
     });
     const sourceFile = project.createSourceFile('route.ts', segmentSourceCode, { overwrite: true });
     // Add the import if it doesn't exist
-    let importDeclaration = sourceFile.getImportDeclaration((imp) => {
+    const importDeclaration = sourceFile.getImportDeclaration((imp) => {
         return imp.getModuleSpecifierValue() === importPath;
     });
     if (!importDeclaration) {
-        importDeclaration = sourceFile.addImportDeclaration({
+        sourceFile.addImportDeclaration({
             defaultImport: sourceName,
             moduleSpecifier: importPath,
         });

package/dist/new/addCommonTerms.d.mts

@@ -1 +1 @@
-export default function addCommonTerms(): void;
+export declare function addCommonTerms(): void;

package/dist/new/addCommonTerms.mjs

@@ -84,7 +84,7 @@ const terms = [
     ['half', 'halves'],
     ['scarf', 'scarves'],
 ];
-export default function addCommonTerms() {
+export function addCommonTerms() {
     terms.forEach(([singular, plural]) => {
         const regex = new RegExp(`${singular}$`, 'i');
         pluralize.addPluralRule(regex, plural);

package/dist/new/index.d.mts

@@ -1,2 +1,3 @@
 import type { NewOptions } from '../types.mjs';
-export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }: NewOptions): Promise<void>;
+import type { ProjectInfo } from '../getProjectInfo/index.mts';
+export declare function newComponents(components: string[], projectInfo: ProjectInfo, { dryRun, outDir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }: NewOptions): Promise<void>;