vovk-cli 0.0.1-draft.33 → 0.0.1-draft.330

package/dist/new/newModule.mjs

@@ -1,13 +1,15 @@
 import path from 'node:path';
 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 locateSegments from '../locateSegments.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import prettify from '../utils/prettify.mjs';
+import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
+import { locateSegments } from '../locateSegments.mjs';
 function splitByLast(str, delimiter = '/') {
     const index = str.lastIndexOf(delimiter);
     if (index === -1) {
@@ -18,19 +20,19 @@ 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, }) {
-    const { config, log, apiDir, cwd } = await getProjectInfo();
-    let templates = config.templates;
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
+    const { config, log, cwd, apiDirAbsolutePath } = await getProjectInfo();
+    const segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
+    const isNodeNextResolution = ['node16', 'nodenext'].includes((await getTsconfig(cwd)?.config?.compilerOptions?.moduleResolution?.toLowerCase()) ?? '');
+    let templates = config.moduleTemplates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
-    // replace c by controller, s by service, w by worker, everything else keeps the same
+    // replace c by controller, s by service, everything else keeps the same
     what = what.map((s) => {
         switch (s) {
             case 'c':
                 return 'controller';
             case 's':
                 return 'service';
-            case 'w':
-                return 'worker';
             default:
                 return s;
         }
@@ -49,16 +51,13 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments(apiDir);
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
         throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);
     }
     for (const type of what) {
         const templatePath = templates[type];
-        const templateAbsolutePath = templatePath.startsWith('/') || templatePath.startsWith('.')
-            ? path.resolve(cwd, templatePath)
-            : path.resolve(cwd, './node_modules', templatePath);
+        const templateAbsolutePath = resolveAbsoluteModulePath(templatePath, cwd);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
         const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
             cwd,
@@ -66,6 +65,9 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             withService: what.includes('service'),
             segmentName,
             moduleName,
+            empty,
+            templateFileName: templateAbsolutePath,
+            isNodeNextResolution,
         });
         const dir = dirFlag || renderedDir;
         if (!dir) {
@@ -84,24 +86,24 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             else {
                 await fs.mkdir(absoluteModuleDir, { recursive: true });
                 await fs.writeFile(absoluteModulePath, prettiedCode);
-                log.info(`Created ${chalkHighlightThing(fileName)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
+                log.info(`Created${empty ? ' empty' : ''} ${chalkHighlightThing(absoluteModulePath)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
-        if (type === 'controller' || type === 'worker') {
+        if (type === 'controller') {
             if (!sourceName) {
                 throw new Error(`The template for "${type}" does not provide a sourceName`);
             }
             if (!compiledName) {
-                throw new Error('The template for "${type}" does not provide a compiledName');
+                throw new Error(`The template for "${type}" does not provide a compiledName`);
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(path.dirname(routeFilePath), absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            let importPath = path.relative(path.dirname(routeFilePath) + '/', absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            importPath += isNodeNextResolution ? '.ts' : '';
             if (!noSegmentUpdate) {
                 const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
                     sourceName,
                     compiledName,
-                    type,
                     importPath,
                 }), routeFilePath);
                 if (!dryRun) {

package/dist/new/newSegment.d.mts

@@ -1,5 +1,6 @@
-export default function newSegment({ segmentName, overwrite, dryRun, }: {
+export default function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }: {
     segmentName: string;
+    isStaticSegment?: boolean;
     overwrite?: boolean;
     dryRun?: boolean;
 }): Promise<void>;

package/dist/new/newSegment.mjs

@@ -5,23 +5,30 @@ import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
-export default async function newSegment({ segmentName, overwrite, dryRun, }) {
-    const { apiDir, cwd, log } = await getProjectInfo();
-    const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
+import chalk from 'chalk';
+export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
+    const { apiDirAbsolutePath, log, config } = await getProjectInfo();
+    if (!apiDirAbsolutePath) {
+        throw new Error('No API directory found. Please ensure you are in a Nest.js project.');
+    }
+    const absoluteSegmentRoutePath = path.join(apiDirAbsolutePath, segmentName, '[[...vovk]]/route.ts');
     if (!overwrite && (await getFileSystemEntryType(absoluteSegmentRoutePath))) {
         throw new Error(`Unable to create new segment. ${formatLoggedSegmentName(segmentName, { upperFirst: true })} already exists.`);
     }
-    const code = await prettify(`import { initVovk } from 'vovk';
+    const code = await prettify(`import { initSegment${isStaticSegment ? ', generateStaticAPI' : ''} } from 'vovk';
 
 const controllers = {};
-const workers = {};
 
 export type Controllers = typeof controllers;
-export type Workers = typeof workers;
-
-export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
+${isStaticSegment
+        ? `
+export function generateStaticParams() {
+  return generateStaticAPI(controllers);
+}
+`
+        : ''}
+export const { GET${isStaticSegment ? '' : ', POST, PATCH, PUT, HEAD, OPTIONS, DELETE'} } = initSegment({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
-  workers,
   controllers,
 });
 `, absoluteSegmentRoutePath);
@@ -29,5 +36,7 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
     }
-    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`vovk new controller ${[segmentName, 'someName'].filter(Boolean).join('/')}`)} to create a new controller`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true, isStatic: isStaticSegment })} created at ${absoluteSegmentRoutePath}.`);
+    const dir = chalk.cyanBright([segmentName, 'thing'].filter(Boolean).join('/'));
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at ${path.join(config.modulesDir, dir)} folder for this segment`);
 }

package/dist/new/render.d.mts

@@ -1,8 +1,12 @@
-import type { VovkConfig, VovkModuleRenderResult } from '../types.mjs';
-export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, }: {
+import type { VovkStrictConfig } from 'vovk';
+import type { VovkModuleRenderResult } from '../types.mjs';
+export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, }: {
     cwd: string;
-    config: VovkConfig;
+    config: VovkStrictConfig;
     withService: boolean;
     segmentName: string;
     moduleName: string;
+    empty?: boolean;
+    templateFileName: string;
+    isNodeNextResolution: boolean;
 }): Promise<VovkModuleRenderResult>;

package/dist/new/render.mjs

@@ -4,25 +4,46 @@ import _ from 'lodash';
 import pluralize from 'pluralize';
 import addCommonTerms from './addCommonTerms.mjs';
 addCommonTerms();
-export default async function render(codeTemplate, { config, withService, segmentName, moduleName, }) {
+export default async function render(codeTemplate, { config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, }) {
     const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
         .filter(Boolean)
         .join('/');
-    const templateVars = {
-        // input
+    const theThing = _.camelCase(moduleName);
+    const TheThing = _.upperFirst(theThing);
+    const the_thing = _.snakeCase(moduleName);
+    const THE_THING = _.toUpper(the_thing);
+    const the__thing = _.kebabCase(moduleName);
+    const t = {
+        // module name variations
+        moduleName,
+        theThing,
+        theThings: pluralize(theThing),
+        TheThing,
+        TheThings: pluralize(TheThing),
+        the_thing,
+        the_things: pluralize(the_thing),
+        THE_THING,
+        THE_THINGS: pluralize(THE_THING),
+        'the-thing': the__thing,
+        'the-things': pluralize(the__thing),
+        // data
         config,
         withService,
         segmentName,
-        moduleName,
-        // utils
-        getModuleDirName,
+        nodeNextResolutionExt: {
+            ts: isNodeNextResolution ? '.ts' : '',
+            js: isNodeNextResolution ? '.js' : '',
+            cjs: isNodeNextResolution ? '.cjs' : '',
+            mjs: isNodeNextResolution ? '.mjs' : '',
+        },
+        defaultDir: getModuleDirName(segmentName, theThing),
         // libraries
         _, // lodash
         pluralize,
     };
-    const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
+    const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
     const { dir, fileName, sourceName, compiledName } = parsed.data;
-    const code = parsed.content;
+    const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;
     return {
         dir,
         fileName,

package/dist/types.d.mts

@@ -1,42 +1,5 @@
 import type { LogLevelNames } from 'loglevel';
-export type KnownAny = any;
-export type VovkDevEnv = {
-    PORT?: string;
-    VOVK_CLIENT_OUT_DIR?: string;
-    VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER?: string;
-    VOVK_VALIDATE_ON_CLIENT?: string;
-    VOVK_MODULES_DIR?: string;
-    VOVK_VALIDATION_LIBRARY?: string;
-    VOVK_ORIGIN?: string;
-    VOVK_ROOT_ENTRY?: string;
-    VOVK_API_ENTRY_POINT?: string;
-    VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
-    VOVK_LOG_LEVEL?: LogLevelNames;
-    VOVK_PRETTIFY_CLIENT?: string;
-    VOVK_DEV_HTTPS?: string;
-    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
-};
-export type VovkConfig = {
-    clientOutDir?: string;
-    schemaOutDir?: string;
-    fetcher?: string;
-    validateOnClient?: string | null;
-    modulesDir?: string;
-    validationLibrary?: string | null;
-    rootEntry?: string;
-    origin?: string;
-    rootSegmentModulesDirName?: string;
-    logLevel?: LogLevelNames;
-    prettifyClient?: boolean;
-    devHttps?: boolean;
-    templates?: {
-        service?: string;
-        controller?: string;
-        worker?: string;
-        [key: string]: string | undefined;
-    };
-};
+import type { VovkStrictConfig } from 'vovk';
 export type VovkModuleRenderResult = {
     fileName: string;
     dir: string;
@@ -45,10 +8,44 @@ export type VovkModuleRenderResult = {
     code: string;
 };
 export interface DevOptions {
+    schemaOut?: string;
     nextDev?: boolean;
+    exit?: boolean;
+    devHttps?: boolean;
 }
 export interface GenerateOptions {
-    clientOut?: string;
+    prettify?: boolean;
+    configPath?: string;
+    schemaPath?: string;
+    origin?: string;
+    openapiSpec?: string[];
+    openapiGetModuleName?: string[];
+    openapiGetMethodName?: string[];
+    openapiRootUrl?: string[];
+    openapiMixinName?: string[];
+    openapiFallback?: string[];
+    watch?: boolean | string;
+    composedFrom?: string[];
+    composedOut?: string;
+    composedOnly?: boolean;
+    composedIncludeSegments?: string[];
+    composedExcludeSegments?: string[];
+    segmentedFrom?: string[];
+    segmentedOut?: string;
+    segmentedOnly?: boolean;
+    segmentedIncludeSegments?: string[];
+    segmentedExcludeSegments?: string[];
+}
+export interface BundleOptions extends Partial<Pick<VovkStrictConfig['bundle'], 'prebundleOutDir' | 'keepPrebundleDir' | 'includeSegments' | 'excludeSegments'>> {
+    config?: string;
+    schema?: string;
+    outDir?: string;
+    origin?: string;
+    openapiSpec?: string[];
+    openapiGetModuleName?: string[];
+    openapiGetMethodName?: string[];
+    openapiRootUrl?: string[];
+    openapiMixinName?: string[];
 }
 export interface InitOptions {
     yes?: boolean;
@@ -61,8 +58,8 @@ export interface InitOptions {
     updateTsConfig?: boolean;
     updateScripts?: 'implicit' | 'explicit';
     validationLibrary?: string | null;
-    validateOnClient?: boolean;
     dryRun?: boolean;
+    lang?: string[];
     channel?: 'latest' | 'beta' | 'draft';
 }
 export interface NewOptions {
@@ -71,4 +68,18 @@ export interface NewOptions {
     dir?: string;
     overwrite?: boolean;
     noSegmentUpdate?: boolean;
+    empty?: boolean;
+    static?: boolean;
 }
+export type VovkEnv = {
+    PORT?: string;
+    VOVK_SCHEMA_OUT_DIR?: string;
+    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';
+};

package/dist/utils/compileJSONSchemaToTypeScriptType.d.mts

@@ -0,0 +1,5 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { JSONSchema7 } from 'json-schema';
+export declare function compileJSONSchemaToTypeScriptType(schema: JSONSchema7, typeName: string, components?: NonNullable<OpenAPIObject['components']>, options?: {
+    dontCreateRefTypes?: boolean;
+}): string;

package/dist/utils/compileJSONSchemaToTypeScriptType.mjs

@@ -0,0 +1,9 @@
+import { compileTs } from './compileTs.mjs';
+export function compileJSONSchemaToTypeScriptType(schema, typeName, components = {}, options = {}) {
+    if (!schema)
+        return '';
+    if ('tsType' in schema && typeof schema.tsType === 'string')
+        return `export type ${typeName} = ${schema.tsType};\n`;
+    const tsType = compileTs({ schema: { ...schema, components }, name: typeName, ...options });
+    return tsType;
+}

package/dist/utils/compileTs.d.mts

@@ -0,0 +1,12 @@
+import { JSONSchema7 } from 'json-schema';
+import { OpenAPIObject } from 'openapi3-ts/oas31';
+interface CompileOptions {
+    name: string;
+    schema: JSONSchema7 & {
+        components?: OpenAPIObject['components'];
+    };
+    refs?: Map<string, JSONSchema7>;
+    dontCreateRefTypes?: boolean;
+}
+export declare function compileTs(options: CompileOptions): string;
+export {};

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,2 @@
-import { KnownAny } from '../types.mjs';
-export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;
+import type { KnownAny } from 'vovk';
+export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;