vovk-cli 0.0.1-draft.99 → 0.0.3

package/dist/new/index.mjs

@@ -1,6 +1,6 @@
-import newModule from './newModule.mjs';
-import newSegment from './newSegment.mjs';
-export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }) {
+import { newModule } from './newModule.mjs';
+import { newSegment } from './newSegment.mjs';
+export async function newComponents(components, projectInfo, { dryRun, outDir, 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 default async function newComponents(components, { dryRun, dir, templates
             segmentNames = [''];
         }
         for (const segmentName of segmentNames) {
-            await newSegment({ segmentName, overwrite, dryRun });
+            await newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun });
         }
     }
     else {
@@ -24,9 +24,10 @@ export default async function newComponents(components, { dryRun, dir, templates
             throw new Error('A module name with an optional segment cannot be empty');
         }
         await newModule({
+            projectInfo,
             what,
             moduleNameWithOptionalSegment,
-            dir,
+            outDir,
             templates,
             overwrite,
             noSegmentUpdate,

package/dist/new/newModule.d.mts

@@ -1,10 +1,12 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, outDir: outDirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
+    projectInfo: ProjectInfo;
     what: string[];
     moduleNameWithOptionalSegment: string;
     dryRun?: boolean;
-    dir?: string;
+    outDir?: string;
     templates?: string[];
     noSegmentUpdate?: boolean;
     overwrite?: boolean;
     empty?: boolean;
-}): Promise<void>;
+}): Promise<undefined>;

package/dist/new/newModule.mjs

@@ -1,13 +1,15 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-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 chalk from 'chalk';
+import { getTsconfig } from 'get-tsconfig';
+import { render } from './render.mjs';
+import { addClassToSegmentCode } from './addClassToSegmentCode.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 '../utils/locateSegments.mjs';
 function splitByLast(str, delimiter = '/') {
     const index = str.lastIndexOf(delimiter);
     if (index === -1) {
@@ -18,9 +20,11 @@ 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, apiDir, cwd } = await getProjectInfo();
-    let templates = config.templates;
+export async function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, outDir: outDirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
+    const { config, log, cwd, apiDirAbsolutePath, srcRoot } = 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;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
     // replace c by controller, s by service, everything else keeps the same
     what = what.map((s) => {
@@ -37,8 +41,7 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
         if (templatesFlag.length > what.length) {
             throw new Error('Too many templates provided');
         }
-        templates = templatesFlag.reduce((acc, templatePath, index) => ({
-            ...acc,
+        templates = templatesFlag.reduce((acc, templatePath, index) => Object.assign(acc, {
             [what[index]]: templatePath,
         }), templates);
     }
@@ -47,44 +50,47 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments({ dir: apiDir, config });
     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`);
+        log.error(`Unable to create module: ${formatLoggedSegmentName(segmentName)} not found. Run ${chalkHighlightThing(`npx vovk new segment${segmentName ? ` ${segmentName}` : ''}`)} to create it`);
+        return process.exit(1);
     }
     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);
+        if (!templatePath)
+            continue; // suppresses TypeScript error, but it shouldn't happen
+        const templateAbsolutePath = resolveAbsoluteModulePath(templatePath, cwd);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
-        const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
+        const { outDir: renderedOutDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
             cwd,
+            srcRoot,
             config,
             withService: what.includes('service'),
             segmentName,
             moduleName,
             empty,
             templateFileName: templateAbsolutePath,
+            isNodeNextResolution,
         });
-        const dir = dirFlag || renderedDir;
-        if (!dir) {
-            throw new Error(`The template for "${type}" does not provide a dir`);
+        const outDir = outDirFlag ?? renderedOutDir;
+        if (!outDir) {
+            throw new Error(`The template for "${type}" does not provide a outDir`);
         }
         if (!fileName) {
             throw new Error(`The template for "${type}" does not provide a fileName`);
         }
-        const absoluteModuleDir = path.join(cwd, dir);
+        const absoluteModuleDir = path.join(cwd, outDir);
         const absoluteModulePath = path.join(absoluteModuleDir, fileName);
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
             if (!overwrite && (await getFileSystemEntryType(absoluteModulePath))) {
-                log.warn(`File ${chalkHighlightThing(absoluteModulePath)} already exists, skipping this "${type}"`);
+                log.error(`File ${chalkHighlightThing(absoluteModulePath)} already exists, skipping this "${chalkHighlightThing(type)}". You can use --overwrite flag to overwrite it.`);
+                return process.exit(1);
             }
             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(`${chalk.green('Created')}${empty ? ' empty' : ''} ${chalkHighlightThing(absoluteModulePath)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
         if (type === 'controller') {
@@ -96,7 +102,8 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             }
             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,
@@ -107,7 +114,7 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                     await fs.writeFile(routeFilePath, newSegmentCode);
                 }
             }
-            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
+            log.info(`${chalk.green('Added')} ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
         }
     }
 }

package/dist/new/newSegment.d.mts

@@ -1,5 +1,8 @@
-export default function newSegment({ segmentName, overwrite, dryRun, }: {
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }: {
+    projectInfo: ProjectInfo;
     segmentName: string;
+    isStaticSegment?: boolean;
     overwrite?: boolean;
     dryRun?: boolean;
-}): Promise<void>;
+}): Promise<undefined>;

package/dist/new/newSegment.mjs

@@ -1,26 +1,33 @@
 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 { 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, overwrite, dryRun, }) {
-    const { apiDir, cwd, log } = await getProjectInfo();
-    const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
+export 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 Next.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.`);
+        log.error(`Unable to create new segment. ${formatLoggedSegmentName(segmentName, { upperFirst: true })} already exists. You can use --overwrite flag to overwrite it.`);
+        return process.exit(1);
     }
-    const code = await prettify(`import { initVovk } from 'vovk';
-
-export const runtime = 'edge';
+    const code = await prettify(`import { initSegment${isStaticSegment ? ', controllersToStaticParams' : ''} } from 'vovk';
 
 const controllers = {};
 
 export type Controllers = typeof controllers;
-
-export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
+${isStaticSegment
+        ? `
+export function generateStaticParams() {
+  return controllersToStaticParams(controllers);
+}
+`
+        : ''}
+export const { GET${isStaticSegment ? '' : ', POST, PATCH, PUT, HEAD, OPTIONS, DELETE'} } = initSegment({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
   controllers,
 });
@@ -29,7 +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}.`);
+    log.info(`${chalk.green('Created')} ${formatLoggedSegmentName(segmentName, { isStatic: isStaticSegment })} 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 modules/${dir} folder for this segment`);
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at ./${path.join(config.modulesDir, dir)}/ directory for this segment`);
 }

package/dist/new/render.d.mts

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

package/dist/new/render.mjs

@@ -2,20 +2,14 @@ import ejs from 'ejs';
 import matter from 'gray-matter';
 import _ from 'lodash';
 import pluralize from 'pluralize';
-import addCommonTerms from './addCommonTerms.mjs';
+import { addCommonTerms } from './addCommonTerms.mjs';
+import path from 'node:path';
 addCommonTerms();
-export default async function render(codeTemplate, { config, withService, segmentName, moduleName, empty, templateFileName, }) {
-    const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
+export async function render(codeTemplate, { cwd, config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, srcRoot, }) {
+    const defaultOutDir = [config.modulesDir, segmentName || config.rootSegmentModulesDirName, _.camelCase(moduleName)]
         .filter(Boolean)
         .join('/');
-    /*
-      <% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-  <% var modulePascalNamePlural = pluralize(modulePascalName); %>
-  <% var controllerName = modulePascalName + 'Controller'; %>
-  <% var compiledName = modulePascalName + 'RPC'; %>
-  <% var serviceName = modulePascalName + 'Service'; %>
-  <% var prefix = pluralize(_.kebabCase(moduleName).toLowerCase()); %>
-      */
+    const relativePathToSourceRoot = path.relative(path.resolve(cwd, defaultOutDir), path.join(cwd, srcRoot ?? '.')) || '.';
     const theThing = _.camelCase(moduleName);
     const TheThing = _.upperFirst(theThing);
     const the_thing = _.snakeCase(moduleName);
@@ -38,16 +32,23 @@ export default async function render(codeTemplate, { config, withService, segmen
         config,
         withService,
         segmentName,
-        defaultDir: getModuleDirName(segmentName, theThing),
+        nodeNextResolutionExt: {
+            ts: isNodeNextResolution ? '.ts' : '',
+            js: isNodeNextResolution ? '.js' : '',
+            cjs: isNodeNextResolution ? '.cjs' : '',
+            mjs: isNodeNextResolution ? '.mjs' : '',
+        },
+        defaultOutDir,
+        relativePathToSourceRoot,
         // libraries
         _, // lodash
         pluralize,
     };
     const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
-    const { dir, fileName, sourceName, compiledName } = parsed.data;
+    const { outDir, fileName, sourceName, compiledName } = parsed.data;
     const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;
     return {
-        dir,
+        outDir,
         fileName,
         sourceName,
         compiledName,

package/dist/types.d.mts

@@ -1,75 +1,61 @@
 import type { LogLevelNames } from 'loglevel';
-export type KnownAny = any;
-export type VovkEnv = {
-    PORT?: string;
-    VOVK_CLIENT_OUT_DIR?: string;
-    VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER_PATH?: string;
-    VOVK_VALIDATE_ON_CLIENT_PATH?: string;
-    VOVK_CREATE_RPC_PATH?: string;
-    VOVK_MODULES_DIR?: 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';
-    __VOVK_EXIT__?: 'true' | 'false';
-};
-type GenerateFrom = (string | {
-    templatePath: string;
-    outDir?: string;
-    templateName?: string;
-    fullSchema?: string | boolean;
-})[];
-export type VovkConfig = {
-    clientOutDir?: string;
-    schemaOutDir?: string;
-    fetcherImport?: string | string[];
-    validateOnClientImport?: string | string[] | null;
-    createRPCImport?: string | string[];
-    modulesDir?: string;
-    rootEntry?: string;
-    origin?: string;
-    rootSegmentModulesDirName?: string;
-    logLevel?: LogLevelNames;
-    prettifyClient?: boolean;
-    devHttps?: boolean;
-    generateFrom?: GenerateFrom | ((value: GenerateFrom) => GenerateFrom);
-    templates?: {
-        service?: string;
-        controller?: string;
-        [key: string]: string | undefined;
-    };
-};
-export type VovkStrictConfig = Required<Omit<VovkConfig, 'validateOnClientImport' | 'fetcherImport' | 'createRPCImport' | 'generateFrom'>> & {
-    validateOnClientImport: string[] | null;
-    fetcherImport: string[];
-    createRPCImport: string[];
-    generateFrom: GenerateFrom;
-};
+import type { build } from 'tsdown';
+import type { VovkStrictConfig } from 'vovk/internal';
 export type VovkModuleRenderResult = {
     fileName: string;
-    dir: string;
+    outDir: string;
     sourceName?: string;
     compiledName?: string;
     code: string;
 };
 export interface DevOptions {
+    schemaOut?: string;
     nextDev?: boolean;
     exit?: boolean;
+    devHttps?: boolean;
+    logLevel?: LogLevelNames;
 }
 export interface GenerateOptions {
-    clientOutDir?: string;
-    templates?: string[];
     prettify?: boolean;
-    fullSchema?: string | 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[];
+    logLevel?: LogLevelNames;
+}
+export interface BundleOptions extends Partial<Pick<VovkStrictConfig['bundle'], 'prebundleOutDir' | 'keepPrebundleDir' | 'includeSegments' | 'excludeSegments'>> {
+    bundler?: 'tsdown' | 'ncc';
+    configPath?: string;
+    schemaPath?: string;
+    outDir?: string;
+    origin?: string;
+    openapiSpec?: string[];
+    openapiGetModuleName?: string[];
+    openapiGetMethodName?: string[];
+    openapiRootUrl?: string[];
+    openapiMixinName?: string[];
+    openapiFallback?: string[];
+    logLevel?: LogLevelNames;
 }
 export interface InitOptions {
+    prefix?: string;
     yes?: boolean;
-    logLevel: LogLevelNames;
     useNpm?: boolean;
     useYarn?: boolean;
     usePnpm?: boolean;
@@ -77,18 +63,35 @@ export interface InitOptions {
     skipInstall?: boolean;
     updateTsConfig?: boolean;
     updateScripts?: 'implicit' | 'explicit';
-    validationLibrary?: string | null;
-    reactQuery?: boolean;
-    validateOnClient?: boolean;
+    bundle?: boolean;
+    validationLibrary?: 'zod' | 'valibot' | 'arktype' | null;
     dryRun?: boolean;
+    lang?: string[];
     channel?: 'latest' | 'beta' | 'draft';
+    logLevel?: LogLevelNames;
 }
 export interface NewOptions {
     dryRun?: boolean;
     templates?: string[];
-    dir?: string;
+    outDir?: string;
     overwrite?: boolean;
     noSegmentUpdate?: boolean;
     empty?: boolean;
+    static?: boolean;
+    logLevel?: LogLevelNames;
+}
+export type VovkEnv = {
+    PORT?: string;
+    VOVK_SCHEMA_OUT_DIR?: string;
+    VOVK_ORIGIN?: string;
+    VOVK_ROOT_ENTRY?: string;
+    VOVK_API_ENTRY_POINT?: string;
+    __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;
+};
+declare global {
+    var TSdownBuildOptions: Parameters<typeof build>[0];
 }
-export {};

package/dist/utils/chalkHighlightThing.d.mts

@@ -1 +1 @@
-export default function chalkHighlightThing(str: string): string;
+export declare function chalkHighlightThing(str: string): string;

package/dist/utils/chalkHighlightThing.mjs

@@ -1,4 +1,4 @@
 import chalk from 'chalk';
-export default function chalkHighlightThing(str) {
+export function chalkHighlightThing(str) {
     return chalk.whiteBright.bold(str);
 }

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 type { JSONSchema7 } from 'json-schema';
+import type { 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 {};