hono-takibi 0.7.4 → 0.7.5

package/dist/cli/hono-takibi/index.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '../../result/index.js';
+export declare function honoTakibi(): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/hono-takibi/index.js

@@ -0,0 +1,37 @@
+import { ok, asyncAndThen } from '../../result/index.js';
+import { getConfig } from '../../config/index.js';
+import { resolveConfig } from '../config/index.js';
+import { takibi } from './takibi.js';
+import { parseCli } from '../args/parse-cli.js';
+import { isHelpRequested, sliceArgv } from '../utils/index.js';
+const HELP_TEXT = `
+Usage:
+  hono-takibi <input.yaml|json> -o <routes.ts> [options]
+
+Options:
+  --export-type               Export generated type aliases
+
+  --export-schema             Export generated schema objects
+
+  --naming-case-type <PascalCase|camelCase>
+                              Casing for generated *type aliases*
+                              (default: PascalCase)
+
+  --naming-case-schema <PascalCase|camelCase>
+                              Casing for generated *schema objects*
+                              (default: PascalCase)
+
+  --template                  Generate an app file and handler stubs
+
+  --test                      Generate empty *.test.ts files for handlers
+
+  --base-path <path>          API prefix (e.g. /api)
+  
+  --help                      Show this help and exit
+`.trimStart();
+export async function honoTakibi() {
+    const args = sliceArgv(process.argv);
+    return isHelpRequested(args)
+        ? ok({ message: HELP_TEXT })
+        : await asyncAndThen(getConfig(), async (config) => asyncAndThen(parseCli(args, config), async (cli) => asyncAndThen(resolveConfig(config, cli), async (finalConfig) => takibi(finalConfig, cli.template, cli.test, cli.basePath))));
+}

package/dist/cli/{takibi.d.ts → hono-takibi/takibi.d.ts}

@@ -1,4 +1,4 @@
-import type { Result } from '../result/types.js';
+import type { Result } from '../../result/types.js';
 export declare function takibi(config: {
     schema: {
         name: 'PascalCase' | 'camelCase';

package/dist/cli/{takibi.js → hono-takibi/takibi.js}

@@ -1,12 +1,12 @@
 import path from 'node:path';
-import { ok, asyncAndThen } from '../result/index.js';
-import { fmt } from '../format/index.js';
-import { parseOpenAPI } from '../openapi/parse-openapi.js';
-import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/zod-openapi-hono.js';
-import { app } from './app.js';
-import { mkdir, writeFile } from '../fsp/index.js';
+import { ok, asyncAndThen } from '../../result/index.js';
+import { fmt } from '../../format/index.js';
+import { parseOpenAPI } from '../../openapi/parse-openapi.js';
+import { zodOpenAPIHono } from '../../generator/zod-openapi-hono/openapi/zod-openapi-hono.js';
+import { templateCode } from './template-code.js';
+import { mkdir, writeFile } from '../../fsp/index.js';
 export async function takibi(config, template, test, basePath) {
-    return await asyncAndThen(await parseOpenAPI(config.input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, config)), async (code) => asyncAndThen(await mkdir(path.dirname(config.output)), async () => asyncAndThen(await writeFile(config.output, code), async () => asyncAndThen(await app(openAPI, config.output, template, test, basePath), async () => ok({
+    return await asyncAndThen(await parseOpenAPI(config.input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, config)), async (code) => asyncAndThen(await mkdir(path.dirname(config.output)), async () => asyncAndThen(await writeFile(config.output, code), async () => asyncAndThen(await templateCode(openAPI, config.output, template, test, basePath), async () => ok({
         message: template
             ? 'Generated code and template files written'
             : `Generated code written to ${config.output}`,

package/dist/cli/hono-takibi/template-code.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPI } from '../../openapi/index.js';
+import type { Result } from '../../result/index.js';
+export declare function templateCode(openAPI: OpenAPI, output: `${string}.ts`, template: boolean, test: boolean, basePath?: string): Promise<Result<void, string>>;

package/dist/cli/{app.js → hono-takibi/template-code.js}

@@ -1,11 +1,11 @@
 import path from 'node:path';
-import { ok, err, asyncAndThen } from '../result/index.js';
-import { readdir, writeFile } from '../fsp/index.js';
-import { fmt } from '../format/index.js';
-import { generateApp } from '../generator/zod-openapi-hono/app/index.js';
-import { zodOpenapiHonoHandler } from '../generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
-export async function app(openAPI, output, template, test, basePath) {
-    if (!(template || !output.includes('/')))
+import { ok, asyncAndThen } from '../../result/index.js';
+import { readdir, writeFile } from '../../fsp/index.js';
+import { fmt } from '../../format/index.js';
+import { generateApp } from '../../generator/zod-openapi-hono/app/index.js';
+import { zodOpenapiHonoHandler } from '../../generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
+export async function templateCode(openAPI, output, template, test, basePath) {
+    if (!(template && output.includes('/')))
         return ok(undefined);
     const dir = path.dirname(output);
     return await asyncAndThen(await fmt(generateApp(openAPI, output, basePath)), async (appCode) => asyncAndThen(await readdir(dir), async (files) => {

package/dist/cli/index.d.ts

@@ -1,4 +1 @@
-import type { Result } from '../result/index.js';
-export declare function honoTakibi(): Promise<Result<{
-    message: string;
-}, string>>;
+export { honoTakibi } from './hono-takibi/index.js';

package/dist/cli/index.js

@@ -1,37 +1 @@
-import { ok, asyncAndThen } from '../result/index.js';
-import { getConfig } from '../config/index.js';
-import { resolveConfig } from './config/index.js';
-import { takibi } from './takibi.js';
-import { parseCli } from './args/parse-cli.js';
-import { isHelpRequested, sliceArgv } from './utils/index.js';
-const HELP_TEXT = `
-Usage:
-  hono-takibi <input.yaml|json> -o <routes.ts> [options]
-
-Options:
-  --export-type               Export generated type aliases
-
-  --export-schema             Export generated schema objects
-
-  --naming-case-type <PascalCase|camelCase>
-                              Casing for generated *type aliases*
-                              (default: PascalCase)
-
-  --naming-case-schema <PascalCase|camelCase>
-                              Casing for generated *schema objects*
-                              (default: PascalCase)
-
-  --template                  Generate an app file and handler stubs
-
-  --test                      Generate empty *.test.ts files for handlers
-
-  --base-path <path>          API prefix (e.g. /api)
-  
-  --help                      Show this help and exit
-`.trimStart();
-export async function honoTakibi() {
-    const args = sliceArgv(process.argv);
-    return isHelpRequested(args)
-        ? ok({ message: HELP_TEXT })
-        : await asyncAndThen(getConfig(), async (config) => asyncAndThen(parseCli(args, config), async (cli) => asyncAndThen(resolveConfig(config, cli), async (finalConfig) => takibi(finalConfig, cli.template, cli.test, cli.basePath))));
-}
+export { honoTakibi } from './hono-takibi/index.js';

package/dist/core/helper/get-camel-case-schema-name.js

@@ -1,4 +1,4 @@
-import { decapitalize } from '../text/index.js';
+import { decapitalize } from '../utils/index.js';
 /**
  * Generates a camelCase schema name from a given schema name.
  * @param { string } schemaName - The original schema name.

package/dist/core/helper/get-pascal-case-schema-name.js

@@ -1,4 +1,4 @@
-import { capitalize } from '../text/index.js';
+import { capitalize } from '../utils/index.js';
 /**
  * Generates a PascalCase schema name from a given schema name.
  * @param { string } schemaName - The original schema name.

package/dist/core/helper/get-variable-name.d.ts

@@ -1,8 +1,7 @@
-import type { Config } from '../../config/index.js';
 /**
  * Generates a variable name from a given name and config.
  * @param { string } name - The name of the schema.
- * @param { Config } config - The config of the schema.
+ * @param { 'camelCase' | 'PascalCase' } style - The style of the variable name.
  * @returns { string } The variable name.
  */
-export declare function getVariableName(name: string, config: Config): string;
+export declare function getVariableName(name: string, style?: 'camelCase' | 'PascalCase'): string;

package/dist/core/helper/get-variable-name.js

@@ -1,10 +1,10 @@
-import { capitalize, decapitalize } from '../text/index.js';
+import { capitalize, decapitalize } from '../utils/index.js';
 /**
  * Generates a variable name from a given name and config.
  * @param { string } name - The name of the schema.
- * @param { Config } config - The config of the schema.
+ * @param { 'camelCase' | 'PascalCase' } style - The style of the variable name.
  * @returns { string } The variable name.
  */
-export function getVariableName(name, config) {
-    return config.type.name === 'camelCase' ? decapitalize(name) : capitalize(name);
+export function getVariableName(name, style = 'PascalCase') {
+    return style === 'camelCase' ? decapitalize(name) : capitalize(name);
 }

package/dist/core/helper/get-variable-schema-name.d.ts

@@ -1,8 +1,7 @@
-import type { Config } from '../../config/index.js';
 /**
  * Generates a variable schema name from a given name and config.
  * @param { string } name - The name of the schema.
- * @param { Config } config - The config of the schema.
+ * @param { 'camelCase' | 'PascalCase' } style - The style of the variable name.
  * @returns { string } The variable schema name.
  */
-export declare function getVariableSchemaName(name: string, config: Config): string;
+export declare function getVariableSchemaName(name: string, style?: 'camelCase' | 'PascalCase'): string;

package/dist/core/helper/get-variable-schema-name.js

@@ -2,11 +2,9 @@ import { getCamelCaseSchemaName, getPascalCaseSchemaName } from './index.js';
 /**
  * Generates a variable schema name from a given name and config.
  * @param { string } name - The name of the schema.
- * @param { Config } config - The config of the schema.
+ * @param { 'camelCase' | 'PascalCase' } style - The style of the variable name.
  * @returns { string } The variable schema name.
  */
-export function getVariableSchemaName(name, config) {
-    return config.schema.name === 'camelCase'
-        ? getCamelCaseSchemaName(name)
-        : getPascalCaseSchemaName(name);
+export function getVariableSchemaName(name, style = 'PascalCase') {
+    return style === 'camelCase' ? getCamelCaseSchemaName(name) : getPascalCaseSchemaName(name);
 }

package/dist/core/helper/sanitize-identifier.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeIdentifier(str: string): string;

package/dist/core/helper/sanitize-identifier.js

@@ -0,0 +1,3 @@
+export function sanitizeIdentifier(str) {
+    return str.replace(/[^A-Za-z0-9_$]/g, '_');
+}

package/dist/core/schema/references/get-ref-schema-name.d.ts

@@ -1,10 +1,9 @@
-import type { Config } from '../../../config/index.js';
 import type { Schema } from '../../../openapi/index.js';
 /**
  * Retrieves the referenced schema name from a schema object.
  * @param { Schema } schema - The schema object
- * @param { Config } config - The configuration object
+ * @param { 'camelCase' | 'PascalCase' } style - The naming style for the schema name, either 'camelCase' or 'PascalCase'
  * @returns { string } The referenced schema name
  * @throws { Error } Will throw an error if the $ref property or the reference name is not found
  */
-export declare function getRefSchemaName(schema: Schema, config: Config): string;
+export declare function getRefSchemaName(schema: Schema, style?: 'camelCase' | 'PascalCase'): string;

package/dist/core/schema/references/get-ref-schema-name.js

@@ -3,11 +3,11 @@ import { getRefName } from './get-ref-name.js';
 /**
  * Retrieves the referenced schema name from a schema object.
  * @param { Schema } schema - The schema object
- * @param { Config } config - The configuration object
+ * @param { 'camelCase' | 'PascalCase' } style - The naming style for the schema name, either 'camelCase' or 'PascalCase'
  * @returns { string } The referenced schema name
  * @throws { Error } Will throw an error if the $ref property or the reference name is not found
  */
-export function getRefSchemaName(schema, config) {
+export function getRefSchemaName(schema, style = 'PascalCase') {
     if (!schema.$ref) {
         throw new Error('refName is not found');
     }
@@ -15,5 +15,5 @@ export function getRefSchemaName(schema, config) {
     if (!refName) {
         throw new Error('refName is not found');
     }
-    return getVariableSchemaName(refName, config);
+    return getVariableSchemaName(refName, style);
 }

package/dist/core/{text/escape-str.d.ts → utils/escape-string-literal.d.ts}

@@ -3,4 +3,4 @@
  * @param { string } text - The text to escape
  * @returns { string } The escaped text
  */
-export declare function escapeStr(text: string): string;
+export declare function escapeStringLiteral(text: string): string;

package/dist/core/{text/escape-str.js → utils/escape-string-literal.js}

@@ -3,7 +3,7 @@
  * @param { string } text - The text to escape
  * @returns { string } The escaped text
  */
-export function escapeStr(text) {
+export function escapeStringLiteral(text) {
     return (text
         // Basic text cleaning
         .replace(/\n/g, ' ') // Replace line breaks with spaces

package/dist/core/utils/index.d.ts

@@ -0,0 +1,6 @@
+export { capitalize } from './capitalize.js';
+export { decapitalize } from './decapitalize.js';
+export { escapeStringLiteral } from './escape-string-literal.js';
+export { regexPattern } from './regex-pattern.js';
+export { removeZodPrefix } from './remove-zod-prefix.js';
+export { sanitizeIdentifier } from './sanitizeIdentifier.js';

package/dist/core/utils/index.js

@@ -0,0 +1,6 @@
+export { capitalize } from './capitalize.js';
+export { decapitalize } from './decapitalize.js';
+export { escapeStringLiteral } from './escape-string-literal.js';
+export { regexPattern } from './regex-pattern.js';
+export { removeZodPrefix } from './remove-zod-prefix.js';
+export { sanitizeIdentifier } from './sanitizeIdentifier.js';

package/dist/core/{text → utils}/regex-pattern.js

@@ -5,6 +5,5 @@
  */
 export function regexPattern(pattern) {
     const escapedPattern = pattern.replace(/(?<!\\)\//g, '\\/');
-    const res = `/${escapedPattern}/`;
-    return res;
+    return `/${escapedPattern}/`;
 }

package/dist/core/utils/sanitizeIdentifier.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Converts an arbitrary string into a safe TypeScript identifier
+ * by replacing invalid characters with underscores (`_`).
+ *
+ * This is useful when generating variable names from external strings
+ * such as schema names, object keys, or user input.
+ *
+ * Only letters, digits, underscores, and dollar signs are allowed.
+ * All other characters are replaced with `_`.
+ *
+ * @param str - The raw string to sanitize.
+ * @returns A sanitized string that can be used as a TypeScript identifier.
+ *
+ * @example
+ * ```ts
+ * sanitizeIdentifier('foo-bar')        // 'foo_bar'
+ * sanitizeIdentifier('123user@name')   // '123user_name'
+ * sanitizeIdentifier('日本語')           // '___'
+ * sanitizeIdentifier('post.title')     // 'post_title'
+ * sanitizeIdentifier('valid_Name')     // 'valid_Name'
+ * ```
+ */
+export declare function sanitizeIdentifier(str: string): string;

package/dist/core/utils/sanitizeIdentifier.js

@@ -0,0 +1,25 @@
+/**
+ * Converts an arbitrary string into a safe TypeScript identifier
+ * by replacing invalid characters with underscores (`_`).
+ *
+ * This is useful when generating variable names from external strings
+ * such as schema names, object keys, or user input.
+ *
+ * Only letters, digits, underscores, and dollar signs are allowed.
+ * All other characters are replaced with `_`.
+ *
+ * @param str - The raw string to sanitize.
+ * @returns A sanitized string that can be used as a TypeScript identifier.
+ *
+ * @example
+ * ```ts
+ * sanitizeIdentifier('foo-bar')        // 'foo_bar'
+ * sanitizeIdentifier('123user@name')   // '123user_name'
+ * sanitizeIdentifier('日本語')           // '___'
+ * sanitizeIdentifier('post.title')     // 'post_title'
+ * sanitizeIdentifier('valid_Name')     // 'valid_Name'
+ * ```
+ */
+export function sanitizeIdentifier(str) {
+    return str.replace(/[^A-Za-z0-9_$]/g, '_');
+}

package/dist/generator/zod/coerce.js

@@ -1,4 +1,4 @@
-import { removeZodPrefix } from '../../core/text/index.js';
+import { removeZodPrefix } from '../../core/utils/index.js';
 /**
  * Generates a zod pipe function to coerce a value to a zod schema.
  * @param { string } z - The zod schema to coerce to.

package/dist/generator/zod/object.js

@@ -1,7 +1,7 @@
 import { record, passthrough } from './index.js';
-import { generateAllOfCode } from '../zod-openapi-hono/openapi/component/allof/generate-allof-code.js';
-import { generateOneOfCode } from '../zod-openapi-hono/openapi/component/oneof/generate-oneof-code.js';
-import { generateAnyOfCode } from '../zod-openapi-hono/openapi/component/anyof/generate-anyof-code.js';
+import { allOf } from '../zod-openapi-hono/openapi/component/allof/index.js';
+import { oneOf } from '../zod-openapi-hono/openapi/component/oneof/index.js';
+import { anyOf } from '../zod-openapi-hono/openapi/component/anyof/any-of.js';
 import { generateZodPropertiesSchema } from './property/generate-zod-properties-schema.js';
 /**
  * Generate Zod object schema
@@ -21,13 +21,13 @@ export function object(schema, config) {
         return record(schema.additionalProperties, config);
     }
     if (schema.allOf) {
-        return generateAllOfCode(schema, config);
+        return allOf(schema, config);
     }
     if (schema.oneOf) {
-        return generateOneOfCode(schema, config);
+        return oneOf(schema, config);
     }
     if (schema.anyOf) {
-        return generateAnyOfCode(schema, config);
+        return anyOf(schema, config);
     }
     if (!schema.properties) {
         return 'z.object({})';

package/dist/generator/zod/reference/generate-array-reference-schema.js

@@ -15,6 +15,6 @@ export function generateArrayReferenceSchema(schema, config) {
     if (!refName) {
         return 'z.array(z.any())';
     }
-    const variableName = getVariableSchemaName(refName, config);
+    const variableName = getVariableSchemaName(refName, config.schema.name);
     return array(variableName);
 }

package/dist/generator/zod/reference/generate-reference-schema.js

@@ -14,5 +14,5 @@ export function generateReferenceSchema(schema, config) {
     if (!refName) {
         return 'z.any()';
     }
-    return getVariableSchemaName(refName, config) || 'z.any()';
+    return getVariableSchemaName(refName, config.schema.name) || 'z.any()';
 }

package/dist/generator/zod/regex.js

@@ -1,4 +1,4 @@
-import { regexPattern } from '../../core/text/index.js';
+import { regexPattern } from '../../core/utils/index.js';
 /**
  * Generate Zod regex validation
  * @param { string } pattern - Regex pattern

package/dist/generator/zod/sub/generate-zod-schema-from-sub-schema.js

@@ -7,5 +7,5 @@ import { zod } from '../index.js';
  * @returns { string } The generated Zod schema as a string.
  */
 export function generateZodSchemaFromSubSchema(subSchema, config) {
-    return subSchema.$ref ? getRefSchemaName(subSchema, config) : zod(config, subSchema);
+    return subSchema.$ref ? getRefSchemaName(subSchema, config.schema.name) : zod(config, subSchema);
 }

package/dist/generator/zod/zod.js

@@ -3,10 +3,10 @@ import { getVariableSchemaName } from '../../core/helper/index.js';
 import { stripMinIfgTExistHelper } from './helper/strip-min-if-gt-exist-helper.js';
 import { stripMaxIfLtExistHelper } from './helper/strip-max-if-lt-exist-helper.js';
 import { stripMinMaxExistHelper } from './helper/strip-min-max-exist-helper.js';
-import { generateOneOfCode } from '../zod-openapi-hono/openapi/component/oneof/generate-oneof-code.js';
-import { generateAnyOfCode } from '../zod-openapi-hono/openapi/component/anyof/generate-anyof-code.js';
-import { generateAllOfCode } from '../zod-openapi-hono/openapi/component/allof/generate-allof-code.js';
-import { generateNotCode } from '../zod-openapi-hono/openapi/component/not/generate-not-code.js';
+import { oneOf } from '../zod-openapi-hono/openapi/component/oneof/index.js';
+import { anyOf } from '../zod-openapi-hono/openapi/component/anyof/index.js';
+import { allOf } from '../zod-openapi-hono/openapi/component/allof/index.js';
+import { not } from '../zod-openapi-hono/openapi/component/not/index.js';
 import { zodToOpenAPI } from '../zod-to-openapi/index.js';
 /**
  * Mapping of OpenAPI/JSON Schema types to Zod schema strings
@@ -153,24 +153,24 @@ export function zod(config, schema) {
     }
     // oneOf
     if (schema.oneOf) {
-        return generateOneOfCode(schema, config);
+        return oneOf(schema, config);
     }
     // anyOf
     if (schema.anyOf) {
-        return generateAnyOfCode(schema, config);
+        return anyOf(schema, config);
     }
     // allOf
     if (schema.allOf) {
-        return generateAllOfCode(schema, config);
+        return allOf(schema, config);
     }
     // not
     if (schema.not) {
-        return generateNotCode(schema);
+        return not(schema);
     }
     if (schema.$ref) {
         const refParts = schema.$ref.split('/');
         const refName = refParts[refParts.length - 1];
-        const schemaName = getVariableSchemaName(refName, config);
+        const schemaName = getVariableSchemaName(refName, config.schema.name);
         return schemaName;
     }
     // fallback

package/dist/generator/zod-openapi-hono/app/docs/index.d.ts

@@ -0,0 +1,8 @@
+import type { OpenAPI } from '../../../../openapi/index.js';
+export declare function docs(openapi: OpenAPI): {
+    openapi: string | undefined;
+    info: OpenAPI['info'];
+    servers: OpenAPI['servers'];
+    externalDocs: OpenAPI['externalDocs'];
+    tags: OpenAPI['tags'];
+};

package/dist/generator/zod-openapi-hono/app/docs/index.js

@@ -0,0 +1,9 @@
+export function docs(openapi) {
+    return {
+        openapi: openapi.openapi,
+        info: openapi.info,
+        servers: openapi.servers,
+        externalDocs: openapi.externalDocs,
+        tags: openapi.tags,
+    };
+}

package/dist/generator/zod-openapi-hono/app/{generators/generate-app-route-handler.d.ts → generator/app-route-handler.d.ts}

@@ -3,4 +3,4 @@
  * @param { string } routeName - Route name
  * @param { string } handlerName - Handler name
  */
-export declare function generateAppRouteHandler(routeName: string, handlerName: string): string;
+export declare function appRouteHandler(routeName: string, handlerName: string): string;

package/dist/generator/zod-openapi-hono/app/{generators/generate-app-route-handler.js → generator/app-route-handler.js}

@@ -3,6 +3,6 @@
  * @param { string } routeName - Route name
  * @param { string } handlerName - Handler name
  */
-export function generateAppRouteHandler(routeName, handlerName) {
+export function appRouteHandler(routeName, handlerName) {
     return `.openapi(${routeName},${handlerName})`;
 }

package/dist/generator/zod-openapi-hono/app/{generators/generate-apply-openapi-routes.d.ts → generator/apply-openapi-routes.d.ts}

@@ -1,11 +1,11 @@
 /**
  * Generates the application route handlers.
  *
- * @function generateApplyOpenapiRoutes
+ * @function applyOpenapiRoutes
  * @param routeMappings - An array of objects containing route name, handler name, and path.
  * @returns A string of application route handlers.
  */
-export declare function generateApplyOpenapiRoutes(routeMappings: {
+export declare function applyOpenapiRoutes(routeMappings: {
     routeName: string;
     handlerName: string;
     path: string;

package/dist/generator/zod-openapi-hono/app/{generators/generate-apply-openapi-routes.js → generator/apply-openapi-routes.js}

@@ -1,15 +1,15 @@
-import { generateAppRouteHandler } from './generate-app-route-handler.js';
+import { appRouteHandler } from './index.js';
 /**
  * Generates the application route handlers.
  *
- * @function generateApplyOpenapiRoutes
+ * @function applyOpenapiRoutes
  * @param routeMappings - An array of objects containing route name, handler name, and path.
  * @returns A string of application route handlers.
  */
-export function generateApplyOpenapiRoutes(routeMappings) {
+export function applyOpenapiRoutes(routeMappings) {
     return routeMappings
         .map(({ routeName, handlerName }) => {
-        return generateAppRouteHandler(routeName, handlerName);
+        return appRouteHandler(routeName, handlerName);
     })
         .join('\n');
 }

package/dist/generator/zod-openapi-hono/app/{generators/generate-import-routes.d.ts → generator/import-routes.d.ts}

@@ -1,10 +1,10 @@
 /**
  * Generates import statements for the routes.
  *
- * @function generateImportRoutes
+ * @function importRoutes
  * @param importsMap - A map of import paths to the names of the routes.
  * @returns An array of import statements.
  */
-export declare function generateImportRoutes(importsMap: {
+export declare function importRoutes(importsMap: {
     [importPath: string]: string[];
 }): string[];

package/dist/generator/zod-openapi-hono/app/{generators/generate-import-routes.js → generator/import-routes.js}

@@ -1,11 +1,11 @@
 /**
  * Generates import statements for the routes.
  *
- * @function generateImportRoutes
+ * @function importRoutes
  * @param importsMap - A map of import paths to the names of the routes.
  * @returns An array of import statements.
  */
-export function generateImportRoutes(importsMap) {
+export function importRoutes(importsMap) {
     const importRoutes = [];
     for (const [importPath, names] of Object.entries(importsMap)) {
         const uniqueNames = Array.from(new Set(names));

package/dist/generator/zod-openapi-hono/app/generator/index.d.ts

@@ -0,0 +1,3 @@
+export { appRouteHandler } from './app-route-handler.js';
+export { applyOpenapiRoutes } from './apply-openapi-routes.js';
+export { importRoutes } from './import-routes.js';

package/dist/generator/zod-openapi-hono/app/generator/index.js

@@ -0,0 +1,3 @@
+export { appRouteHandler } from './app-route-handler.js';
+export { applyOpenapiRoutes } from './apply-openapi-routes.js';
+export { importRoutes } from './import-routes.js';

package/dist/generator/zod-openapi-hono/app/helper/get-route-maps.d.ts

@@ -1,10 +1,10 @@
-import type { OpenAPISpec } from '../../../../openapi/index.js';
+import type { OpenAPI } from '../../../../openapi/index.js';
 /**
  * Get route maps
- * @param { OpenAPISpec } openAPISpec - OpenAPI spec
+ * @param { openAPI } OpenAPI - OpenAPI spec
  * @returns { { routeName: string, handlerName: string, path: string }[] } Route maps
  */
-export declare function getRouteMaps(openAPISpec: OpenAPISpec): {
+export declare function getRouteMaps(openapi: OpenAPI): {
     routeName: string;
     handlerName: string;
     path: string;

package/dist/generator/zod-openapi-hono/app/helper/get-route-maps.js

@@ -2,11 +2,11 @@ import { handlerName } from '../../handler/generator/index.js';
 import { generateRouteName } from '../../openapi/route/generate-route-name.js';
 /**
  * Get route maps
- * @param { OpenAPISpec } openAPISpec - OpenAPI spec
+ * @param { openAPI } OpenAPI - OpenAPI spec
  * @returns { { routeName: string, handlerName: string, path: string }[] } Route maps
  */
-export function getRouteMaps(openAPISpec) {
-    const paths = openAPISpec.paths;
+export function getRouteMaps(openapi) {
+    const paths = openapi.paths;
     const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
         return Object.entries(pathItem).flatMap(([method]) => {
             return {