vovk-cli 0.0.1-draft.98 → 0.0.1

package/dist/utils/compileTs.mjs

@@ -0,0 +1,261 @@
+import upperFirst from 'lodash/upperFirst.js';
+import camelCase from 'lodash/camelCase.js';
+export function compileTs(options) {
+    const context = {
+        refs: options.refs || new Map(),
+        compiledRefs: new Map(),
+        refsInProgress: new Set(),
+    };
+    // Collect all definitions from the schema
+    collectDefinitions(options.schema, context.refs);
+    // Ensure the main type name is valid
+    const mainTypeName = sanitizeTypeName(options.name);
+    const mainType = compileSchema(options.schema, mainTypeName, context);
+    // Compile all referenced types, unless dontCreateRefTypes is set
+    const compiledRefs = options.dontCreateRefTypes
+        ? ''
+        : Array.from(context.compiledRefs.entries())
+            .map(([, typeDecl]) => typeDecl)
+            .join('\n\n');
+    return compiledRefs
+        ? `${compiledRefs}\n\n${options.schema.description ? `/** ${escapeJSDocComment(options.schema.description)} */\n` : ''}export type ${mainTypeName} = ${mainType};`
+        : `${options.schema.description ? `/** ${escapeJSDocComment(options.schema.description)} */\n` : ''}export type ${mainTypeName} = ${mainType};`;
+}
+function collectDefinitions(schema, refs) {
+    // Collect from $defs
+    if (schema.$defs) {
+        Object.entries(schema.$defs).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/$defs/${key}`, def);
+            }
+        });
+    }
+    // Collect from definitions (older spec)
+    if (schema.definitions) {
+        Object.entries(schema.definitions).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/definitions/${key}`, def);
+            }
+        });
+    }
+    // Collect from components/schemas (OpenAPI spec)
+    if (schema?.components?.schemas) {
+        Object.entries(schema?.components?.schemas ?? {}).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/components/schemas/${key}`, def);
+            }
+        });
+    }
+    // Recursively collect from nested schemas
+    const schemasToProcess = [];
+    if (schema.properties) {
+        schemasToProcess.push(...Object.values(schema.properties).filter(isSchema));
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schemasToProcess.push(...schema.items.filter(isSchema));
+        }
+        else if (isSchema(schema.items)) {
+            schemasToProcess.push(schema.items);
+        }
+    }
+    if (schema.additionalProperties && isSchema(schema.additionalProperties)) {
+        schemasToProcess.push(schema.additionalProperties);
+    }
+    if (schema.allOf)
+        schemasToProcess.push(...schema.allOf.filter(isSchema));
+    if (schema.anyOf)
+        schemasToProcess.push(...schema.anyOf.filter(isSchema));
+    if (schema.oneOf)
+        schemasToProcess.push(...schema.oneOf.filter(isSchema));
+    schemasToProcess.forEach((s) => collectDefinitions(s, refs));
+}
+function isSchema(value) {
+    return typeof value === 'object' && !Array.isArray(value);
+}
+function compileSchema(schema, name, context) {
+    if (typeof schema === 'boolean') {
+        return schema ? 'any' : 'never';
+    }
+    // Handle x-tsType extension
+    if ('x-tsType' in schema && typeof schema['x-tsType'] === 'string') {
+        return schema['x-tsType'];
+    }
+    // Handle $ref
+    if (schema.$ref) {
+        return handleRef(schema.$ref, context);
+    }
+    // Handle combinators
+    if (schema.allOf) {
+        return handleAllOf(schema.allOf, name, context);
+    }
+    if (schema.anyOf) {
+        return handleAnyOf(schema.anyOf, name, context);
+    }
+    if (schema.oneOf) {
+        return handleOneOf(schema.oneOf, name, context);
+    }
+    // Handle type-specific compilation
+    if (schema.enum) {
+        return handleEnum(schema.enum);
+    }
+    if (schema.const !== undefined) {
+        return handleConst(schema.const);
+    }
+    if (!schema.type) {
+        // No type specified, could be object
+        if (schema.properties || schema.additionalProperties) {
+            return handleObject(schema, name, context);
+        }
+        return 'any';
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.map((t) => compileSchemaWithType({ ...schema, type: t }, name, context)).join(' | ');
+    }
+    return compileSchemaWithType(schema, name, context);
+}
+function compileSchemaWithType(schema, name, context) {
+    switch (schema.type) {
+        case 'null':
+            return 'null';
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'integer':
+            return 'number';
+        case 'array':
+            return handleArray(schema, name, context);
+        case 'object':
+            return handleObject(schema, name, context);
+        default:
+            return 'any';
+    }
+}
+function handleRef(ref, context) {
+    const typeName = refToTypeName(ref);
+    // Check if we're already compiling this ref (circular reference)
+    if (context.refsInProgress.has(ref)) {
+        return typeName;
+    }
+    // Check if already compiled
+    if (context.compiledRefs.has(ref)) {
+        return typeName;
+    }
+    // Find the referenced schema
+    const referencedSchema = context.refs.get(ref);
+    if (!referencedSchema) {
+        return 'any'; // Reference not found
+    }
+    // Mark as in progress
+    context.refsInProgress.add(ref);
+    // Compile the referenced schema
+    const compiledType = compileSchema(referencedSchema, typeName, context);
+    const description = referencedSchema.description
+        ? `/** ${escapeJSDocComment(referencedSchema.description)} */\n`
+        : '';
+    context.compiledRefs.set(ref, `${description}export type ${typeName} = ${compiledType};`);
+    // Mark as completed
+    context.refsInProgress.delete(ref);
+    return typeName;
+}
+function handleAllOf(schemas, name, context) {
+    const types = schemas.map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-all-of-${i}`), context));
+    // For allOf, we need to intersect types
+    // If they're all objects, we can merge them properly
+    const objectTypes = types.filter((t) => t.startsWith('{') && t.endsWith('}'));
+    if (objectTypes.length === types.length) {
+        // Merge object types
+        const merged = objectTypes.map((t) => t.slice(1, -1).trim()).filter((t) => t.length > 0);
+        return merged.length > 0 ? `{ ${merged.join('; ')} }` : '{}';
+    }
+    return types.join(' & ');
+}
+function handleAnyOf(schemas, name, context) {
+    const types = schemas.map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-any-of-${i}`), context));
+    return types.join(' | ');
+}
+function handleOneOf(schemas, name, context) {
+    // For TypeScript, oneOf behaves like anyOf
+    const types = schemas.map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-one-of-${i}`), context));
+    return types.join(' | ');
+}
+function handleEnum(enumValues) {
+    return enumValues.map((v) => JSON.stringify(v)).join(' | ');
+}
+function handleConst(value) {
+    return JSON.stringify(value);
+}
+function handleArray(schema, name, context) {
+    if (!schema.items) {
+        return 'any[]';
+    }
+    if (Array.isArray(schema.items)) {
+        // Tuple (ignoring min/max as requested)
+        const types = schema.items.map((item, i) => compileSchema(item, `${name}Item${i}`, context));
+        return `[${types.join(', ')}]`;
+    }
+    const itemType = compileSchema(schema.items, `${name}Item`, context);
+    return `${wrapUnionType(itemType)}[]`;
+}
+function handleObject(schema, name, context) {
+    const props = [];
+    // Handle known properties
+    if (schema.properties) {
+        const required = new Set(schema.required || []);
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            if (!isSchema(propSchema))
+                continue;
+            const isRequired = required.has(propName);
+            // Ensure the generated type name for nested properties is valid
+            const nestedTypeName = sanitizeTypeName(`${name}-${propName}`);
+            const propType = compileSchema(propSchema, nestedTypeName, context);
+            const safePropName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName) ? propName : `"${propName}"`;
+            // Add JSDoc comment if description is present
+            const comment = propSchema.description ? `\n/** ${escapeJSDocComment(propSchema.description)} */\n` : '';
+            props.push(`${comment}${safePropName}${isRequired ? '' : '?'}: ${propType}`);
+        }
+    }
+    // Handle additional properties
+    if (schema.additionalProperties === true) {
+        props.push('[key: string]: any');
+    }
+    else if (schema.additionalProperties && isSchema(schema.additionalProperties)) {
+        const additionalTypeName = sanitizeTypeName(`${name}-additional`);
+        const additionalType = compileSchema(schema.additionalProperties, additionalTypeName, context);
+        props.push(`[key: string]: ${additionalType}`);
+    }
+    // Handle pattern properties
+    if (schema.patternProperties) {
+        // For simplicity, treat pattern properties as string index signature
+        const patternTypes = Object.values(schema.patternProperties)
+            .filter(isSchema)
+            .map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-pattern-${i}`), context));
+        if (patternTypes.length > 0) {
+            props.push(`[key: string]: ${patternTypes.join(' | ')}`);
+        }
+    }
+    return props.length > 0 ? `{ ${props.join('; ')} }` : '{}';
+}
+function refToTypeName(ref) {
+    // Extract the last part of the reference as the type name
+    const parts = ref.split('/');
+    const name = parts[parts.length - 1];
+    // Convert kebab-case to PascalCase
+    return upperFirst(camelCase(name));
+}
+function wrapUnionType(type) {
+    // Wrap union types in parentheses for array types
+    return type.includes('|') ? `(${type})` : type;
+}
+function sanitizeTypeName(name) {
+    return upperFirst(camelCase(name));
+}
+// Utility function to escape JSDoc comment terminators in descriptions
+function escapeJSDocComment(description) {
+    if (!description)
+        return '';
+    return description.replace(/\*\//g, '*\\/');
+}

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1 @@
-import { KnownAny } from '../types.mjs';
-export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;
+export declare function debounceWithArgs<Callback extends (...args: any[]) => any>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;

package/dist/utils/debounceWithArgs.mjs

@@ -1,4 +1,5 @@
-export default function debounceWithArgs(callback, wait) {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function debounceWithArgs(callback, wait) {
     // Stores timeouts keyed by the stringified arguments
     const timeouts = new Map();
     return (...args) => {

package/dist/utils/formatLoggedSegmentName.d.mts

@@ -1,4 +1,6 @@
-export default function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst }?: {
+export declare function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst, isStatic, segmentType, }?: {
     withChalk?: boolean;
     upperFirst?: boolean;
+    isStatic?: boolean;
+    segmentType?: 'segment' | 'mixin';
 }): string;

package/dist/utils/formatLoggedSegmentName.mjs

@@ -1,7 +1,8 @@
 import upperFirstLodash from 'lodash/upperFirst.js';
-import chalkHighlightThing from './chalkHighlightThing.mjs';
-export default function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false } = {}) {
-    let text = segmentName ? `segment "${segmentName}"` : 'the root segment';
+import { chalkHighlightThing } from './chalkHighlightThing.mjs';
+export function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false, isStatic = false, segmentType = 'segment', // TODO: Apply to all formatLoggedSegmentName invocations
+ } = {}) {
+    let text = segmentName ? `${isStatic ? 'static ' : ''}${segmentType} "${segmentName}"` : 'the root segment';
     text = upperFirst ? upperFirstLodash(text) : text;
     return withChalk ? chalkHighlightThing(text) : text;
 }

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/getAvailablePort.d.mts

@@ -6,5 +6,4 @@
  * @param {(failedPort: number, tryingPort: number) => void} onWarning - The callback function for warnings.
  * @returns {Promise<string>}
  */
-declare function getAvailablePort(startPort: number, maxAttempts: number, attempt: number, onWarning: (failedPort: number, tryingPort: number) => void): Promise<string>;
-export default getAvailablePort;
+export declare function getAvailablePort(startPort: number, maxAttempts: number, attempt: number, onWarning: (failedPort: number, tryingPort: number) => void): Promise<string>;

package/dist/utils/getAvailablePort.mjs

@@ -24,7 +24,7 @@ function checkPort(port, callback) {
  * @param {(failedPort: number, tryingPort: number) => void} onWarning - The callback function for warnings.
  * @returns {Promise<string>}
  */
-function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
+export function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
     return new Promise((resolve, reject) => {
         checkPort(startPort, (isAvailable) => {
             if (isAvailable) {
@@ -40,4 +40,3 @@ function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
         });
     });
 }
-export default getAvailablePort;

package/dist/utils/getFileSystemEntryType.d.mts

@@ -2,4 +2,4 @@ export declare enum FileSystemEntryType {
     FILE = "FILE",
     DIRECTORY = "DIRECTORY"
 }
-export default function getFileSystemEntryType(filePath: string): Promise<FileSystemEntryType | null>;
+export declare function getFileSystemEntryType(filePath: string): Promise<FileSystemEntryType | null>;

package/dist/utils/getFileSystemEntryType.mjs

@@ -4,7 +4,7 @@ export var FileSystemEntryType;
     FileSystemEntryType["FILE"] = "FILE";
     FileSystemEntryType["DIRECTORY"] = "DIRECTORY";
 })(FileSystemEntryType || (FileSystemEntryType = {}));
-export default async function getFileSystemEntryType(filePath) {
+export async function getFileSystemEntryType(filePath) {
     try {
         const stats = await fs.stat(filePath);
         if (stats.isFile()) {

package/dist/utils/getLogger.d.mts

@@ -1,5 +1,5 @@
 import loglevel, { type LogLevelNames } from 'loglevel';
-export default function getLogger(level: LogLevelNames): {
+export declare function getLogger(level: LogLevelNames): {
     info: (msg: string) => void;
     warn: (msg: string) => void;
     error: (msg: string) => void;

package/dist/utils/getLogger.mjs

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import loglevel from 'loglevel';
-export default function getLogger(level) {
+export function getLogger(level) {
     const log = {
         info: (msg) => loglevel.info(chalk.white(`🐺 ${msg}`)),
         warn: (msg) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),

package/dist/utils/getNPMPackageMetadata.d.mts

@@ -13,5 +13,5 @@ interface NpmPackageMetadata {
         };
     };
 }
-export default function getNPMPackageMetadata(packageName: string): Promise<NpmPackageMetadata>;
+export declare function getNPMPackageMetadata(packageName: string): Promise<NpmPackageMetadata>;
 export {};

package/dist/utils/getNPMPackageMetadata.mjs

@@ -1,4 +1,4 @@
-export default async function getNPMPackageMetadata(packageName) {
+export async function getNPMPackageMetadata(packageName) {
     // Fetch package metadata from the npm registry
     const metadataResponse = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`);
     if (!metadataResponse.ok) {

package/dist/utils/getPackageJson.d.mts

@@ -0,0 +1,3 @@
+import { PackageJson } from 'type-fest';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare function getPackageJson(cwd: string, log: ProjectInfo['log']): Promise<PackageJson>;

package/dist/utils/getPackageJson.mjs

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { chalkHighlightThing } from './chalkHighlightThing.mjs';
+let cachedPromise;
+export function getPackageJson(cwd, log) {
+    const pkgPath = path.join(cwd, 'package.json');
+    // If we have a cached promise, return it
+    if (cachedPromise) {
+        return cachedPromise;
+    }
+    const promise = fs
+        .readFile(pkgPath, 'utf8')
+        .then((content) => JSON.parse(content))
+        .catch(() => {
+        cachedPromise = undefined;
+        log.warn(`Unable to load package.json at ${chalkHighlightThing(pkgPath)}. Using an empty fallback.`);
+        return {
+            name: 'unknown',
+        };
+    });
+    cachedPromise = promise;
+    return promise;
+}

package/dist/utils/getPublicModuleNameFromPath.d.mts

@@ -0,0 +1,4 @@
+export declare function getPublicModuleNameFromPath(modulePath: string): {
+    moduleName: string | null;
+    restPath: string;
+};

package/dist/utils/getPublicModuleNameFromPath.mjs

@@ -0,0 +1,9 @@
+export function getPublicModuleNameFromPath(modulePath) {
+    if (modulePath && !modulePath.startsWith('.') && !modulePath.startsWith('/')) {
+        const pathParts = modulePath.split('/');
+        const moduleName = pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0];
+        const restPath = pathParts.slice(pathParts[0].startsWith('@') ? 2 : 1).join('/');
+        return { moduleName, restPath };
+    }
+    return { moduleName: null, restPath: modulePath };
+}

package/dist/utils/locateSegments.d.mts

@@ -0,0 +1,12 @@
+import type { VovkStrictConfig } from 'vovk/internal';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export type Segment = {
+    routeFilePath: string;
+    segmentName: string;
+};
+export declare function locateSegments({ dir, rootDir, config, log, }: {
+    dir: string | null;
+    rootDir?: string;
+    config: VovkStrictConfig | null;
+    log: ProjectInfo['log'];
+}): Promise<Segment[]>;

package/dist/{locateSegments.mjs → utils/locateSegments.mjs}

@@ -1,12 +1,20 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-// config: null is used for testing
-export default async function locateSegments({ dir, rootDir, config, }) {
+import { getFileSystemEntryType } from './getFileSystemEntryType.mjs';
+export async function locateSegments({ dir, rootDir, config, log, }) {
     let results = [];
+    if (!dir)
+        return results; // If dir is null, return empty results because this isn't a Next.js app
     rootDir = rootDir ?? dir;
+    let list;
     // Read the contents of the directory
-    const list = await fs.readdir(dir);
+    try {
+        list = (await fs.readdir(dir)).toSorted();
+    }
+    catch {
+        // do nothing
+        return results;
+    }
     // Iterate through each item in the directory
     for (const file of list) {
         const filePath = path.join(dir, file);
@@ -19,12 +27,11 @@ export default async function locateSegments({ dir, rootDir, config, }) {
                 if (await getFileSystemEntryType(routeFilePath)) {
                     // Calculate the basePath relative to the root directory
                     const segmentName = path.relative(rootDir, dir).replace(/\\/g, '/'); // windows fix
-                    const segmentImportPath = path.relative(config?.clientOutDir ?? '.__', routeFilePath);
-                    results.push({ routeFilePath, segmentName, segmentImportPath });
+                    results.push({ routeFilePath, segmentName });
                 }
             }
             // Recursively search inside subdirectories
-            const subDirResults = await locateSegments({ dir: filePath, rootDir, config });
+            const subDirResults = await locateSegments({ dir: filePath, rootDir, config, log });
             results = results.concat(subDirResults);
         }
     }

package/dist/utils/normalizeOpenAPIMixin.d.mts

@@ -0,0 +1,15 @@
+import { HttpMethod, type VovkConfig } from 'vovk';
+import { VovkOperationObject, VovkStrictConfig } from 'vovk/internal';
+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['outputConfig']>['segments']>[string]>['openAPIMixin']>;
+    log: ProjectInfo['log'];
+    cwd?: string;
+}): Promise<NonNullable<NonNullable<NonNullable<NonNullable<VovkStrictConfig['outputConfig']>['segments']>[string]>['openAPIMixin']>>;