vovk-cli 0.0.1-draft.333 → 0.0.1-draft.335

package/dist/new/index.mjs

@@ -1,6 +1,6 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
+export async function newComponents(components, projectInfo, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]
         let segmentNames = components
@@ -10,7 +10,7 @@ export async function newComponents(components, { dryRun, dir, templates, overwr
             segmentNames = [''];
         }
         for (const segmentName of segmentNames) {
-            await newSegment({ segmentName, isStaticSegment, overwrite, dryRun });
+            await newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun });
         }
     }
     else {
@@ -24,6 +24,7 @@ export async function newComponents(components, { dryRun, dir, templates, overwr
             throw new Error('A module name with an optional segment cannot be empty');
         }
         await newModule({
+            projectInfo,
             what,
             moduleNameWithOptionalSegment,
             dir,

package/dist/new/newModule.d.mts

@@ -1,4 +1,6 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
+    projectInfo: ProjectInfo;
     what: string[];
     moduleNameWithOptionalSegment: string;
     dryRun?: boolean;

package/dist/new/newModule.mjs

@@ -3,7 +3,6 @@ import fs from 'node:fs/promises';
 import { getTsconfig } from 'get-tsconfig';
 import render from './render.mjs';
 import addClassToSegmentCode from './addClassToSegmentCode.mjs';
-import getProjectInfo from '../getProjectInfo/index.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
@@ -20,8 +19,8 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
-    const { config, log, cwd, apiDirAbsolutePath } = await getProjectInfo();
+export default async function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
+    const { config, log, cwd, apiDirAbsolutePath } = projectInfo;
     const segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
     const isNodeNextResolution = ['node16', 'nodenext'].includes((await getTsconfig(cwd)?.config?.compilerOptions?.moduleResolution?.toLowerCase()) ?? '');
     let templates = config.moduleTemplates;

package/dist/new/newSegment.d.mts

@@ -1,4 +1,6 @@
-export default function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }: {
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }: {
+    projectInfo: ProjectInfo;
     segmentName: string;
     isStaticSegment?: boolean;
     overwrite?: boolean;

package/dist/new/newSegment.mjs

@@ -1,13 +1,12 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
 import chalk from 'chalk';
-export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
-    const { apiDirAbsolutePath, log, config } = await getProjectInfo();
+export default async function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }) {
+    const { apiDirAbsolutePath, log, config } = projectInfo;
     if (!apiDirAbsolutePath) {
         throw new Error('No API directory found. Please ensure you are in a Nest.js project.');
     }

package/dist/types.d.mts

@@ -12,6 +12,7 @@ export interface DevOptions {
     nextDev?: boolean;
     exit?: boolean;
     devHttps?: boolean;
+    logLevel?: LogLevelNames;
 }
 export interface GenerateOptions {
     prettify?: boolean;
@@ -35,22 +36,24 @@ export interface GenerateOptions {
     segmentedOnly?: boolean;
     segmentedIncludeSegments?: string[];
     segmentedExcludeSegments?: string[];
+    logLevel?: LogLevelNames;
 }
 export interface BundleOptions extends Partial<Pick<VovkStrictConfig['bundle'], 'prebundleOutDir' | 'keepPrebundleDir' | 'includeSegments' | 'excludeSegments'>> {
     config?: string;
     schema?: string;
     outDir?: string;
     origin?: string;
+    tsconfig?: string;
     openapiSpec?: string[];
     openapiGetModuleName?: string[];
     openapiGetMethodName?: string[];
     openapiRootUrl?: string[];
     openapiMixinName?: string[];
+    logLevel?: LogLevelNames;
 }
 export interface InitOptions {
     prefix?: string;
     yes?: boolean;
-    logLevel: LogLevelNames;
     useNpm?: boolean;
     useYarn?: boolean;
     usePnpm?: boolean;
@@ -58,10 +61,11 @@ export interface InitOptions {
     skipInstall?: boolean;
     updateTsConfig?: boolean;
     updateScripts?: 'implicit' | 'explicit';
-    validationLibrary?: string | null;
+    validationLibrary?: 'zod' | 'yup' | 'class-validator' | 'valibot' | 'arktype' | null;
     dryRun?: boolean;
     lang?: string[];
     channel?: 'latest' | 'beta' | 'draft';
+    logLevel?: LogLevelNames;
 }
 export interface NewOptions {
     dryRun?: boolean;
@@ -71,6 +75,7 @@ export interface NewOptions {
     noSegmentUpdate?: boolean;
     empty?: boolean;
     static?: boolean;
+    logLevel?: LogLevelNames;
 }
 export type VovkEnv = {
     PORT?: string;
@@ -78,9 +83,9 @@ export type VovkEnv = {
     VOVK_ORIGIN?: string;
     VOVK_ROOT_ENTRY?: string;
     VOVK_API_ENTRY_POINT?: string;
-    VOVK_LOG_LEVEL?: LogLevelNames;
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
     __VOVK_SCHEMA_OUT_FLAG__?: string;
     __VOVK_DEV_HTTPS_FLAG__?: 'true' | 'false';
     __VOVK_EXIT__?: 'true' | 'false';
+    __VOVK_LOG_LEVEL__?: LogLevelNames;
 };

package/dist/utils/generateFnName.d.mts

@@ -0,0 +1,23 @@
+import { HttpMethod } from 'vovk';
+export interface VerbMapEntry {
+    noParams?: string;
+    withParams?: string;
+    default?: string;
+}
+export declare const VERB_MAP: Record<HttpMethod, VerbMapEntry>;
+export declare function capitalize(str: string): string;
+interface GenerateFnNameOptions {
+    /** Segments to strip out (e.g. ['api','v1']) */
+    ignoreSegments?: string[];
+}
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export declare function generateFnName(method: HttpMethod, rawPath: string, opts?: GenerateFnNameOptions): string;
+export {};

package/dist/utils/generateFnName.mjs

@@ -0,0 +1,76 @@
+export const VERB_MAP = {
+    GET: { noParams: 'list', withParams: 'get' },
+    POST: { default: 'create' },
+    PUT: { default: 'update' },
+    PATCH: { default: 'patch' },
+    DELETE: { default: 'delete' },
+    HEAD: { default: 'head' },
+    OPTIONS: { default: 'options' },
+};
+export function capitalize(str) {
+    if (str.length === 0)
+        return '';
+    return str[0].toUpperCase() + str.slice(1);
+}
+const DEFAULT_OPTIONS = {
+    ignoreSegments: ['api'],
+};
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export function generateFnName(method, rawPath, opts = {}) {
+    const { ignoreSegments } = {
+        ...DEFAULT_OPTIONS,
+        ...opts,
+    };
+    // 1. Clean & split path
+    const parts = rawPath
+        .replace(/^\/|\/$/g, '') // strip leading/trailing slash
+        .split('/')
+        .filter((seg) => !ignoreSegments?.includes(seg.toLowerCase()))
+        .filter(Boolean);
+    // 2. Separate resource tokens from path-params
+    const resources = [];
+    const params = [];
+    parts.forEach((seg) => {
+        const match = seg.match(/^{?([^}]+)}?$/);
+        if (match) {
+            params.push(match[1]);
+        }
+        else {
+            resources.push(seg);
+        }
+    });
+    // 3. Pick base verb from VERB_MAP
+    let baseVerb;
+    if (method === 'GET') {
+        baseVerb = params.length ? VERB_MAP.GET.withParams : VERB_MAP.GET.noParams;
+    }
+    else {
+        baseVerb = VERB_MAP[method].default;
+    }
+    // 4. Build the “resource” part
+    const resourcePart = resources.map(capitalize).join('');
+    // 5. Build the “ByParam” suffix
+    const byParams = params.length ? 'By' + params.map(capitalize).join('') : '';
+    // 6. Combine and ensure camelCase
+    const rawName = `${baseVerb}${resourcePart}${byParams}`;
+    return rawName[0].toLowerCase() + rawName.slice(1);
+}
+/*
+// --- Example usage ---
+console.log(generateFnName('GET', '/users')); // listUsers
+console.log(generateFnName('GET', '/users/{id}')); // getUsersById
+console.log(generateFnName('POST', '/users')); // createUsers
+console.log(generateFnName('PATCH', '/users/{userId}/profile')); // patchUsersProfileByUserId
+console.log(generateFnName('DELETE', '/v1/api/orders/{orderId}')); // deleteOrdersByOrderId
+
+// You can also enable singularization:
+console.log(generateFnName('GET', '/users/{userId}/orders', { singularizeResources: true })); // getUserOrderByUserId
+*/

package/dist/utils/normalizeOpenAPIMixin.d.mts

@@ -0,0 +1,14 @@
+import { HttpMethod, VovkOperationObject, VovkStrictConfig, type VovkConfig } from 'vovk';
+import { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export type GetOpenAPINameFn = (config: {
+    operationObject: VovkOperationObject;
+    method: HttpMethod;
+    path: string;
+    openAPIObject: OpenAPIObject;
+}) => string;
+export declare function normalizeOpenAPIMixin({ mixinModule, log, cwd, }: {
+    mixinModule: NonNullable<NonNullable<NonNullable<NonNullable<VovkConfig['projectConfig']>['segments']>[string]>['openAPIMixin']>;
+    log: ProjectInfo['log'];
+    cwd?: string;
+}): Promise<NonNullable<NonNullable<NonNullable<VovkStrictConfig['projectConfig']>['segments']>[string]>['openAPIMixin']>;

package/dist/utils/normalizeOpenAPIMixin.mjs

@@ -0,0 +1,114 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as YAML from 'yaml';
+import chalkHighlightThing from './chalkHighlightThing.mjs';
+import camelCase from 'lodash/camelCase.js';
+import { generateFnName } from './generateFnName.mjs';
+const getNamesNestJS = (operationObject) => {
+    const operationId = operationObject.operationId;
+    if (!operationId) {
+        throw new Error('Operation ID is required for NestJS module name generation');
+    }
+    const controllerHandlerMatch = operationId?.match(/^([A-Z][a-zA-Z0-9]*)_([a-zA-Z0-9_]+)/);
+    if (!controllerHandlerMatch) {
+        throw new Error(`Invalid operationId format for NestJS: ${operationId}`);
+    }
+    const [controllerName, handlerName] = controllerHandlerMatch.slice(1, 3);
+    return [controllerName.replace(/Controller$/, 'RPC'), handlerName];
+};
+const normalizeGetModuleName = (getModuleName) => {
+    if (getModuleName === 'nestjs-operation-id') {
+        getModuleName = ({ operationObject }) => getNamesNestJS(operationObject)[0];
+    }
+    else if (typeof getModuleName === 'string') {
+        const moduleName = getModuleName;
+        getModuleName = () => moduleName;
+    }
+    else if (typeof getModuleName !== 'function') {
+        throw new Error('getModuleName must be a function or one of the predefined strings');
+    }
+    return getModuleName;
+};
+const normalizeGetMethodName = (getMethodName) => {
+    if (getMethodName === 'nestjs-operation-id') {
+        getMethodName = ({ operationObject }) => getNamesNestJS(operationObject)[1];
+    }
+    else if (getMethodName === 'camel-case-operation-id') {
+        getMethodName = ({ operationObject }) => {
+            const operationId = operationObject.operationId;
+            if (!operationId) {
+                throw new Error('Operation ID is required for camel-case method name generation');
+            }
+            return camelCase(operationId);
+        };
+    }
+    else if (getMethodName === 'auto') {
+        getMethodName = ({ operationObject, method, path }) => {
+            const operationId = operationObject.operationId;
+            const isCamelCase = operationId && /^[a-z][a-zA-Z0-9]*$/.test(operationId);
+            const isSnakeCase = operationId && /^[a-z][a-z0-9_]+$/.test(operationId);
+            return isCamelCase ? operationId : isSnakeCase ? camelCase(operationId) : generateFnName(method, path);
+        };
+    }
+    else if (typeof getMethodName !== 'function') {
+        throw new Error('getMethodName must be a function or one of the predefined strings');
+    }
+    return getMethodName;
+};
+async function getOpenApiSpecLocal(openApiSpecFilePath, cwd) {
+    const openApiSpecAbsolutePath = path.resolve(cwd, openApiSpecFilePath);
+    const fileName = path.basename(openApiSpecAbsolutePath);
+    if (!fileName.endsWith('.json') && !fileName.endsWith('.yaml') && !fileName.endsWith('.yml')) {
+        throw new Error(`Invalid OpenAPI spec file format: ${fileName}. Please provide a JSON or YAML file.`);
+    }
+    const openApiSpecContent = await fs.readFile(openApiSpecAbsolutePath, 'utf8');
+    return (fileName.endsWith('.json') ? JSON.parse(openApiSpecContent) : YAML.parse(openApiSpecContent));
+}
+async function getOpenApiSpecRemote({ cwd, url, fallback, log, }) {
+    const resp = await fetch(url);
+    const text = await resp.text();
+    if (!resp.ok) {
+        if (fallback) {
+            log.warn(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}. Falling back to ${chalkHighlightThing(fallback)}`);
+            return getOpenApiSpecLocal(fallback, cwd);
+        }
+        throw new Error(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}`);
+    }
+    if (fallback) {
+        const fallbackAbsolutePath = path.resolve(cwd, fallback);
+        const existingFallback = await fs.readFile(fallbackAbsolutePath, 'utf8').catch(() => null);
+        if (existingFallback !== text) {
+            await fs.mkdir(path.dirname(fallbackAbsolutePath), { recursive: true });
+            await fs.writeFile(fallbackAbsolutePath, text);
+            log.info(`Saved OpenAPI spec to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+        else {
+            log.debug(`OpenAPI spec at ${chalkHighlightThing(url)} is unchanged. Skipping write to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+    }
+    return (text.trim().startsWith('{') || text.trim().startsWith('[') ? JSON.parse(text) : YAML.parse(text));
+}
+export async function normalizeOpenAPIMixin({ 
+// mixinName,
+mixinModule, log, cwd = process.cwd(), }) {
+    const { source, getModuleName, getMethodName } = mixinModule;
+    let openAPIObject;
+    if ('url' in source) {
+        openAPIObject = await getOpenApiSpecRemote({ url: source.url, fallback: source.fallback, log, cwd });
+    }
+    else if ('file' in source) {
+        openAPIObject = await getOpenApiSpecLocal(source.file, cwd);
+    }
+    else if ('object' in source) {
+        openAPIObject = source.object;
+    }
+    else {
+        throw new Error('Invalid source type for OpenAPI configuration');
+    }
+    return {
+        ...mixinModule,
+        source: { object: openAPIObject },
+        getModuleName: normalizeGetModuleName(getModuleName),
+        getMethodName: normalizeGetMethodName(getMethodName),
+    };
+}

package/module-templates/arktype/controller.ts.ejs

@@ -0,0 +1,68 @@
+<% const vars = { 
+  ModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ModuleName + '.ts' %>
+sourceName: <%= vars.ModuleName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { prefix, get, put, post, del, openapi } from 'vovk';
+import { type } from 'arktype';
+import withArk from '@/lib/withArk<%= t.nodeNextResolutionExt.ts %>';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.nodeNextResolutionExt.ts %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ModuleName %> {
+    @openapi({
+      summary: 'Get <%= t.TheThings %>',
+    })
+    @get()
+    static get<%= t.TheThings %> = withArk({
+        query: type({ search: type('string') }), 
+        handle(req) {
+            const search = req.nextUrl.searchParams.get('search');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
+            <% } else { %>
+            return { results: [], search };
+            <% } %>
+        }
+    });
+
+    @openapi({
+        summary: 'Update <%= t.TheThing %>',
+    })
+    @put('{id}')
+    static update<%= t.TheThing %> = withArk({
+        body: type({
+          foo: type('"bar" | "baz"'),
+        }),
+        query: type({ q: type('string') }),
+        params: type({ id: type('string') }),
+        async handle(req, params) {
+            const { id } = params;
+            const body = await req.json();
+            const q = req.nextUrl.searchParams.get('q');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
+            <% } else { %>
+            return { id, body, q };
+            <% } %>
+        }
+    });
+
+    @post()
+    static create<%= t.TheThing %> = () => {
+        // ...
+    };
+
+    @del(':id')
+    static delete<%= t.TheThing %> = () => {
+        // ...
+    };
+}

package/module-templates/valibot/controller.ts.ejs

@@ -0,0 +1,68 @@
+<% const vars = { 
+  ModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ModuleName + '.ts' %>
+sourceName: <%= vars.ModuleName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { prefix, get, put, post, del, openapi } from 'vovk';
+import * as v from 'valibot';
+import withValibot from '@/lib/withValibot<%= t.nodeNextResolutionExt.ts %>';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.nodeNextResolutionExt.ts %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ModuleName %> {
+    @openapi({
+      summary: 'Get <%= t.TheThings %>',
+    })
+    @get()
+    static get<%= t.TheThings %> = withValibot({
+        query: v.object({ search: v.string() }), 
+        handle(req) {
+            const search = req.nextUrl.searchParams.get('search');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
+            <% } else { %>
+            return { results: [], search };
+            <% } %>
+        }
+    });
+
+    @openapi({
+        summary: 'Update <%= t.TheThing %>',
+    })
+    @put('{id}')
+    static update<%= t.TheThing %> = withValibot({
+        body: v.object({
+          foo: v.union([v.literal('bar'), v.literal('baz')]),
+        }),
+        query: v.object({ q: v.string() }),
+        params: v.object({ id: v.string() }),
+        async handle(req, params) {
+            const { id } = params;
+            const body = await req.json();
+            const q = req.nextUrl.searchParams.get('q');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
+            <% } else { %>
+            return { id, body, q };
+            <% } %>
+        }
+    });
+
+    @post()
+    static create<%= t.TheThing %> = () => {
+        // ...
+    };
+
+    @del(':id')
+    static delete<%= t.TheThing %> = () => {
+        // ...
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.333",
+  "version": "0.0.1-draft.335",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,7 +35,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.374"
+    "vovk": "^3.0.0-draft.397"
   },
   "optionalDependencies": {
     "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.31"

package/dist/generate/mergePackages.d.mts

@@ -1,7 +0,0 @@
-import type { PackageJson } from 'type-fest';
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function mergePackages({ rootPackageJson, packages, }: {
-    rootPackageJson: PackageJson;
-    packages: (PackageJson | undefined)[];
-    log: ProjectInfo['log'];
-}): Promise<PackageJson>;

package/dist/generate/mergePackages.mjs

@@ -1,55 +0,0 @@
-import pick from 'lodash/pick.js';
-function mergeTwoPackageJsons(base, additional) {
-    const merged = { ...base, ...additional };
-    // TODO: Add deep merge for all properties
-    if (base.scripts || additional.scripts) {
-        merged.scripts = { ...base.scripts, ...additional.scripts };
-    }
-    if (base.dependencies || additional.dependencies) {
-        merged.dependencies = { ...base.dependencies, ...additional.dependencies };
-    }
-    if (base.devDependencies || additional.devDependencies) {
-        merged.devDependencies = { ...base.devDependencies, ...additional.devDependencies };
-    }
-    if (base.peerDependencies || additional.peerDependencies) {
-        merged.peerDependencies = { ...base.peerDependencies, ...additional.peerDependencies };
-    }
-    return merged;
-}
-export default async function mergePackages({ rootPackageJson, packages, }) {
-    const defaultPackageJson = {
-        main: './index.cjs',
-        module: './index.mjs',
-        types: './index.d.mts',
-        exports: {
-            '.': {
-                import: './index.mjs',
-                require: './index.cjs',
-            },
-            './schema': {
-                import: './schema.cjs',
-                require: './schema.cjs',
-                types: './schema.d.cts',
-            },
-        },
-    };
-    const pickedPackageJson = pick(rootPackageJson, [
-        'name',
-        'version',
-        'description',
-        'author',
-        'contributors',
-        'license',
-        'repository',
-        'homepage',
-        'bugs',
-        'keywords',
-    ]);
-    let result = { ...pickedPackageJson, ...defaultPackageJson };
-    for (const pkg of packages) {
-        if (pkg) {
-            result = mergeTwoPackageJsons(result, pkg);
-        }
-    }
-    return result;
-}

package/dist/utils/normalizeOpenAPIMixins.d.mts

@@ -1,7 +0,0 @@
-import { VovkStrictConfig, type VovkConfig } from 'vovk';
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export declare function normalizeOpenAPIMixins({ mixinModules, log, cwd, }: {
-    mixinModules: NonNullable<VovkConfig['openApiMixins']>;
-    log: ProjectInfo['log'];
-    cwd?: string;
-}): Promise<VovkStrictConfig['openApiMixins']>;