hono-takibi 0.4.2 → 0.4.4

package/dist/core/schema/references/resolve-schemas-dependencies.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSchemasDependencies = resolveSchemasDependencies;
-const extract_refs_1 = require("./extract-refs");
+const traverse_schema_dependencies_1 = require("./traverse-schema-dependencies");
 /**
  * Resolves dependencies between schemas and returns them in topological order for safe processing
  *
@@ -49,50 +49,15 @@ const extract_refs_1 = require("./extract-refs");
  * - Uses depth-first search for dependency resolution
  * - Automatically handles circular dependencies by preventing infinite recursion
  */
-// export function resolveSchemasDependencies(schemas: Record<string, Schema>): string[] {
-//   // 1. get schema reference relations as a map
-//   const dependencies = resolveSchemaReferences(schemas)
-//   // 2. initialize ordered list and visited set
-//   const ordered: string[] = []
-//   const visited = new Set<string>()
-//   // 3. resolve schema order
-//   for (const name of Object.keys(schemas)) {
-//     resolveSchemaOrder(name, dependencies, visited, ordered)
-//   }
-//   // 4. return ordered list
-//   return ordered
-// }
 function resolveSchemasDependencies(schemas) {
-    const visited = {};
-    const temp = {};
-    const result = [];
-    const visit = (schemaName) => {
-        if (temp[schemaName]) {
-            throw new Error(`bad schema: ${schemaName}`);
-        }
-        if (!visited[schemaName]) {
-            temp[schemaName] = true;
-            const schema = schemas[schemaName];
-            if (schema) {
-                const refs = (0, extract_refs_1.extractRefs)(schema);
-                for (const ref of refs) {
-                    if (schemas[ref]) {
-                        visit(ref);
-                    }
-                    else {
-                        console.warn(`not found schema: ${ref}`);
-                    }
-                }
-            }
-            visited[schemaName] = true;
-            temp[schemaName] = false;
-            result.push(schemaName);
-        }
-    };
+    const visited = new Set();
+    const recursionStack = new Set();
+    const orderedSchemas = [];
+    // Conduct visits for each schema
     for (const schemaName of Object.keys(schemas)) {
-        if (!visited[schemaName]) {
-            visit(schemaName);
+        if (!visited.has(schemaName)) {
+            (0, traverse_schema_dependencies_1.traverseSchemaDependencies)(schemaName, schemas, visited, recursionStack, orderedSchemas);
         }
     }
-    return result;
+    return orderedSchemas;
 }

package/dist/core/schema/references/traverse-schema-dependencies.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../../../types';
+export declare function traverseSchemaDependencies(schemaName: string, schemas: Record<string, Schema>, visited: Set<string>, recursionStack: Set<string>, orderedSchemas: string[]): void;

package/dist/core/schema/references/traverse-schema-dependencies.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSchemaDependencies = traverseSchemaDependencies;
+const extract_refs_1 = require("./extract-refs");
+function traverseSchemaDependencies(schemaName, schemas, visited, recursionStack, orderedSchemas) {
+    // Circular dependencies occur if they already exist on the recursing stack
+    if (recursionStack.has(schemaName)) {
+        throw new Error(`Circular dependency detected in schema: ${schemaName}`);
+    }
+    // Processed only if not visited
+    if (!visited.has(schemaName)) {
+        recursionStack.add(schemaName);
+        const schema = schemas[schemaName];
+        if (schema) {
+            // Get other schemas referenced by the current schema
+            const references = (0, extract_refs_1.extractRefs)(schema);
+            for (const ref of references) {
+                if (ref in schemas) {
+                    traverseSchemaDependencies(ref, schemas, visited, recursionStack, orderedSchemas);
+                }
+                else {
+                    console.warn(`Schema reference not found: ${ref}`);
+                }
+            }
+        }
+        recursionStack.delete(schemaName);
+        visited.add(schemaName);
+        orderedSchemas.push(schemaName);
+    }
+}

package/dist/core/text/escape-str.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Escapes text for use in TypeScript code
+ *
+ * @param text - The text to escape
+ * @returns The escaped text
+ */
+export declare function escapeStr(text: string): string;

package/dist/core/text/escape-str.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeStr = escapeStr;
+/**
+ * Escapes text for use in TypeScript code
+ *
+ * @param text - The text to escape
+ * @returns The escaped text
+ */
+function escapeStr(text) {
+    return (text
+        // Basic text cleaning
+        .replace(/\n/g, ' ') // Replace line breaks with spaces
+        .replace(/\s+/g, ' ') // Replace consecutive spaces with a single space
+        .replace(/\t/g, ' ') // Replace tabs with spaces
+        // Escaping special characters
+        .replace(/\\/g, '\\\\') // Escaping backslash
+        .replace(/'/g, "\\'") // Escaping single quote
+        // Convert full-width spaces to half-width
+        .replace(/　/g, ' ')
+        // Removing zero-width characters
+        .replace(/\u200B|\u200C|\u200D|\uFEFF/g, '')
+        .trim());
+}

package/dist/core/validator/is-array-with-schema-reference.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '../../types';
+/**
+ * array has $ref
+ *
+ * @param schema - schema
+ * @returns boolean
+ */
+export declare function isArrayWithSchemaReference(schema: Schema): boolean;

package/dist/core/validator/is-array-with-schema-reference.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrayWithSchemaReference = isArrayWithSchemaReference;
+/**
+ * array has $ref
+ *
+ * @param schema - schema
+ * @returns boolean
+ */
+function isArrayWithSchemaReference(schema) {
+    return schema.type === 'array' && Boolean(schema.items?.$ref);
+}

package/dist/core/validator/is-schema-reference.d.ts

@@ -0,0 +1,9 @@
+import type { Schema } from '../../types';
+/**
+ * isSchemaReference
+ * is schema reference
+ *
+ * @param schema
+ * @returns boolean
+ */
+export declare function isSchemaReference(schema: Schema): boolean;

package/dist/core/validator/is-schema-reference.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSchemaReference = isSchemaReference;
+/**
+ * isSchemaReference
+ * is schema reference
+ *
+ * @param schema
+ * @returns boolean
+ */
+function isSchemaReference(schema) {
+    return Boolean(schema.$ref);
+}

package/dist/generators/zod/generate-zod-enum.js

@@ -7,5 +7,17 @@ function generateZodEnum(schema) {
         const openapi_example = (0, generate_zod_to_openapi_1.generateZodToOpenAPI)(schema.example);
         return `z.enum(${JSON.stringify(schema.enum)})${openapi_example}`;
     }
+    // number
+    if (schema.type === 'number' && schema.enum) {
+        return `z.literal(${schema.enum})`;
+    }
+    // bigint
+    if (schema.type === 'bigint' && schema.enum) {
+        return `z.literal(${schema.enum}n)`;
+    }
+    // boolean
+    if (schema.type === 'boolean' && schema.enum) {
+        return `z.literal(${schema.enum})`;
+    }
     return `z.enum(${JSON.stringify(schema.enum)})`;
 }

package/dist/generators/zod/generate-zod-number-schema.d.ts

@@ -5,6 +5,8 @@ type GenerateZodNumberSchemaParams = {
     maxLength?: number;
     minimum?: number;
     maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
     default?: DefaultValue;
     example?: ExampleValue;
     paramName?: string;

package/dist/generators/zod/generate-zod-number-schema.js

@@ -24,12 +24,11 @@ function generateZodNumberSchema(args) {
     // maxLength
     if (args.maxLength)
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maxLength));
-    // 0 falsy value
     // minimum
-    if (typeof args.minimum === 'number')
+    if (args.minimum)
         validations.push((0, generate_zod_min_1.generateZodMin)(args.minimum));
     // maximum
-    if (typeof args.maximum === 'number')
+    if (args.maximum)
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maximum));
     // default
     if (args.default)
@@ -37,5 +36,33 @@ function generateZodNumberSchema(args) {
     // example
     if (args.example)
         validations.push((0, generate_zod_to_openapi_1.generateZodToOpenAPI)(args.example, args.paramName, args.isPath));
+    // 0 falsy value
+    // minimum === 0
+    // positive
+    if (args.minimum === 0 && args.exclusiveMinimum) {
+        validations.push('.positive()');
+    }
+    // nonpositive
+    if (args.minimum === 0 && !args.exclusiveMinimum) {
+        validations.push('.nonpositive()');
+    }
+    // negative
+    if (args.maximum === 0 && args.exclusiveMaximum) {
+        validations.push('.negative()');
+    }
+    // gt
+    if (args.minimum) {
+        if (args.minimum > 0 && args.exclusiveMinimum) {
+            const res = `.gt(${args.minimum})`;
+            validations.push(res);
+        }
+    }
+    // lt
+    if (args.maximum) {
+        if (args.maximum > 0 && args.exclusiveMaximum) {
+            const res = `.lt(${args.maximum})`;
+            validations.push(res);
+        }
+    }
     return validations.join('');
 }

package/dist/generators/zod/generate-zod-object.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodObject = generateZodObject;
 const generate_zod_record_schema_1 = require("./generate-zod-record-schema");
-const generate_allof_code_1 = require("../hono/openapi/component/allof/generate-allof-code");
-const generate_oneof_code_1 = require("../hono/openapi/component/oneof/generate-oneof-code");
-const generate_anyof_code_1 = require("../hono/openapi/component/anyof/generate-anyof-code");
+const generate_allof_code_1 = require("../zod-openapi-hono/openapi/component/allof/generate-allof-code");
+const generate_oneof_code_1 = require("../zod-openapi-hono/openapi/component/oneof/generate-oneof-code");
+const generate_anyof_code_1 = require("../zod-openapi-hono/openapi/component/anyof/generate-anyof-code");
 const generate_zod_properties_schema_1 = require("./generate-zod-properties-schema");
 function generateZodObject(schema, config) {
     if (schema.additionalProperties)

package/dist/generators/zod/generate-zod-property-schema.d.ts

@@ -1,5 +1,3 @@
-import type { Schema } from '../../types';
-import type { Config } from '../../config';
 /**
  * Generates a Zod schema string for a given OpenAPI schema definition
  *
@@ -23,4 +21,13 @@ import type { Config } from '../../config';
  * generatePropertySchema({ type: 'string' })
  * // Returns: 'z.string()'
  */
+import type { Schema } from '../../types';
+import type { Config } from '../../config';
+/**
+ * generatePropertySchema
+ * generate property schema
+ *
+ * @param schema
+ * @param config
+ */
 export declare function generatePropertySchema(schema: Schema, config: Config): string;

package/dist/generators/zod/generate-zod-property-schema.js

@@ -1,11 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatePropertySchema = generatePropertySchema;
-const get_ref_name_1 = require("../../core/schema/references/get-ref-name");
-const generate_zod_array_1 = require("./generate-zod-array");
-const generate_zod_schema_1 = require("./schema/generate-zod-schema");
-const get_variable_schema_name_helper_1 = require("../../core/helper/get-variable-schema-name-helper");
-// import { generateZodOpenAPIExample } from './generate-zod-openapi-example'
 /**
  * Generates a Zod schema string for a given OpenAPI schema definition
  *
@@ -29,23 +22,26 @@ const get_variable_schema_name_helper_1 = require("../../core/helper/get-variabl
  * generatePropertySchema({ type: 'string' })
  * // Returns: 'z.string()'
  */
-function generatePropertySchema(schema, 
-// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
-config) {
-    if (schema.$ref) {
-        const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
-        if (refName) {
-            const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
-            // return getRefName(variableName) || 'z.any()'
-            return variableName || 'z.any()';
-        }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePropertySchema = generatePropertySchema;
+const generate_zod_schema_1 = require("./schema/generate-zod-schema");
+const is_schema_reference_1 = require("../../core/validator/is-schema-reference");
+const is_array_with_schema_reference_1 = require("../../core/validator/is-array-with-schema-reference");
+const generate_reference_schema_1 = require("./reference/generate-reference-schema");
+const generate_array_reference_schema_1 = require("./reference/generate-array-reference-schema");
+/**
+ * generatePropertySchema
+ * generate property schema
+ *
+ * @param schema
+ * @param config
+ */
+function generatePropertySchema(schema, config) {
+    if ((0, is_schema_reference_1.isSchemaReference)(schema)) {
+        return (0, generate_reference_schema_1.generateReferenceSchema)(schema, config);
     }
-    if (schema.type === 'array' && schema.items?.$ref) {
-        const refName = (0, get_ref_name_1.getRefName)(schema.items.$ref);
-        if (refName) {
-            const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
-            return (0, generate_zod_array_1.generateZodArray)(variableName);
-        }
+    if ((0, is_array_with_schema_reference_1.isArrayWithSchemaReference)(schema)) {
+        return (0, generate_array_reference_schema_1.generateArrayReferenceSchema)(schema, config);
     }
     return (0, generate_zod_schema_1.generateZodSchema)(config, schema, undefined, undefined);
 }

package/dist/generators/zod/generate-zod-string-schema.d.ts

@@ -4,6 +4,7 @@ type GenerateZodStringSchemaParams = {
     minLength?: number;
     maxLength?: number;
     format?: FormatString;
+    nullable?: boolean;
     default?: DefaultValue;
     example?: ExampleValue;
     paramName?: string;

package/dist/generators/zod/generate-zod-string-schema.js

@@ -61,6 +61,9 @@ function generateZodStringSchema(args) {
     // default
     if (args.default)
         validations.push((0, generate_zod_default_1.generateZodDefault)(args.default));
+    // nullable
+    if (args.nullable)
+        validations.push('.nullable()');
     // example
     if (args.example)
         validations.push((0, generate_zod_to_openapi_1.generateZodToOpenAPI)(args.example, args.paramName, args.isPath));

package/dist/generators/zod/reference/generate-array-reference-schema.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../../../config';
+import type { Schema } from '../../../types';
+/**
+ * generateArrayReferenceSchema
+ * generate array reference schema
+ *
+ * @param schema
+ * @param config
+ */
+export declare function generateArrayReferenceSchema(schema: Schema, config: Config): string;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArrayReferenceSchema = generateArrayReferenceSchema;
+const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
+const get_ref_name_1 = require("../../../core/schema/references/get-ref-name");
+const generate_zod_array_1 = require("../generate-zod-array");
+/**
+ * generateArrayReferenceSchema
+ * generate array reference schema
+ *
+ * @param schema
+ * @param config
+ */
+function generateArrayReferenceSchema(schema, config) {
+    if (!schema.items?.$ref) {
+        return 'z.array(z.any())';
+    }
+    const refName = (0, get_ref_name_1.getRefName)(schema.items?.$ref);
+    if (!refName) {
+        return 'z.array(z.any())';
+    }
+    const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
+    return (0, generate_zod_array_1.generateZodArray)(variableName);
+}

package/dist/generators/zod/reference/generate-reference-schema.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../../../config';
+import type { Schema } from '../../../types';
+/**
+ * generateReferenceSchema
+ * generate reference schema
+ *
+ * @param schema
+ * @param config
+ */
+export declare function generateReferenceSchema(schema: Schema, config: Config): string;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateReferenceSchema = generateReferenceSchema;
+const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
+const get_ref_name_1 = require("../../../core/schema/references/get-ref-name");
+/**
+ * generateReferenceSchema
+ * generate reference schema
+ *
+ * @param schema
+ * @param config
+ */
+function generateReferenceSchema(schema, config) {
+    if (!schema.$ref) {
+        return 'z.any()';
+    }
+    const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
+    if (!refName) {
+        return 'z.any()';
+    }
+    return (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config) || 'z.any()';
+}

package/dist/generators/zod/schema/generate-zod-schema.js

@@ -6,12 +6,14 @@ const generate_zod_string_schema_1 = require("../generate-zod-string-schema");
 const is_format_string_1 = require("../../../core/validator/is-format-string");
 const generate_zod_number_schema_1 = require("../generate-zod-number-schema");
 const generate_zod_integer_schema_1 = require("../generate-zod-integer-schema");
-const generate_allof_code_1 = require("../../hono/openapi/component/allof/generate-allof-code");
-const generate_anyof_code_1 = require("../../hono/openapi/component/anyof/generate-anyof-code");
-const generate_oneof_code_1 = require("../../hono/openapi/component/oneof/generate-oneof-code");
+const generate_allof_code_1 = require("../../zod-openapi-hono/openapi/component/allof/generate-allof-code");
+const generate_anyof_code_1 = require("../../zod-openapi-hono/openapi/component/anyof/generate-anyof-code");
+const generate_oneof_code_1 = require("../../zod-openapi-hono/openapi/component/oneof/generate-oneof-code");
 const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
 const generate_zod_object_1 = require("../generate-zod-object");
 const generate_zod_enum_1 = require("../generate-zod-enum");
+const generate_zod_max_1 = require("../generate-zod-max");
+const generate_zod_min_1 = require("../generate-zod-min");
 /**
  * Mapping of OpenAPI/JSON Schema types to Zod schema strings
  *
@@ -106,6 +108,7 @@ function generateZodSchema(config, schema, paramName, isPath) {
             minLength: schema.minLength,
             maxLength: schema.maxLength,
             format: schema.format && (0, is_format_string_1.isFormatString)(schema.format) ? schema.format : undefined,
+            nullable: schema.nullable,
             default: schema.default,
             example: schema.example,
             paramName,
@@ -114,7 +117,7 @@ function generateZodSchema(config, schema, paramName, isPath) {
     }
     // number
     if (schema.type === 'number') {
-        return (0, generate_zod_number_schema_1.generateZodNumberSchema)({
+        const res = (0, generate_zod_number_schema_1.generateZodNumberSchema)({
             pattern: schema.pattern,
             minLength: schema.minLength,
             maxLength: schema.maxLength,
@@ -124,7 +127,18 @@ function generateZodSchema(config, schema, paramName, isPath) {
             example: schema.example,
             paramName,
             isPath,
+            exclusiveMinimum: schema.exclusiveMinimum,
+            exclusiveMaximum: schema.exclusiveMaximum,
         });
+        // gt
+        if (res.includes(`min(${schema.minimum})`) && res.includes(`gt(${schema.minimum})`)) {
+            return res.replace(`.min(${schema.minimum})`, '');
+        }
+        // lt
+        if (res.includes(`max(${schema.maximum})`) && res.includes(`lt(${schema.maximum})`)) {
+            return res.replace(`.max(${schema.maximum})`, '');
+        }
+        return res;
     }
     // integer
     if (schema.type === 'integer') {
@@ -140,8 +154,28 @@ function generateZodSchema(config, schema, paramName, isPath) {
         });
     }
     // array
-    if (schema.type === 'array' && schema.items)
+    if (schema.type === 'array' && schema.items) {
+        if (schema.minItems && schema.maxItems) {
+            const minItemsSchema = (0, generate_zod_min_1.generateZodMin)(schema.minItems);
+            const maxItemsSchema = (0, generate_zod_max_1.generateZodMax)(schema.maxItems);
+            const zodArray = (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+            const res = `${zodArray}${minItemsSchema}${maxItemsSchema}`;
+            return res;
+        }
+        if (schema.minItems) {
+            const minItemsSchema = (0, generate_zod_min_1.generateZodMin)(schema.minItems);
+            const zodArray = (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+            const res = `${zodArray}${minItemsSchema}`;
+            return res;
+        }
+        if (schema.maxItems) {
+            const maxItemsSchema = (0, generate_zod_max_1.generateZodMax)(schema.maxItems);
+            const zodArray = (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+            const res = `${zodArray}${maxItemsSchema}`;
+            return res;
+        }
         return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+    }
     if (schema.allOf) {
         return (0, generate_allof_code_1.generateAllOfCode)(schema, config);
     }

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

@@ -1,4 +1,4 @@
-import type { OpenAPISpec } from '../../../types';
+import type { OpenAPISpec } from '../../../../types';
 export declare function generateDocs(openAPISpec: OpenAPISpec): {
     openapi: string | undefined;
     info: OpenAPISpec['info'];

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateApplyOpenapiRoutes = generateApplyOpenapiRoutes;
-const generate_app_route_handler_1 = require("../../../app/generate-app-route-handler");
+const generate_app_route_handler_1 = require("../generate-app-route-handler");
 function generateApplyOpenapiRoutes(routeMappings) {
     return routeMappings
         .map(({ routeName, handlerName }) => {

package/dist/generators/{hono → zod-openapi-hono}/app/helper/get-route-maps.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRouteMaps = getRouteMaps;
-const generate_handler_name_1 = require("../../../handler/generate-handler-name");
+const generate_handler_name_1 = require("../../handler/generate-handler-name");
 const generate_route_name_1 = require("../../openapi/route/generate-route-name");
 function getRouteMaps(openAPISpec) {
     const paths = openAPISpec.paths;

package/dist/generators/{hono → zod-openapi-hono}/app/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateApp = generateApp;
-const generate_docs_1 = require("../../app/docs/generate-docs");
+const generate_docs_1 = require("./docs/generate-docs");
 const get_handler_imports_1 = require("../handler/import/get-handler-imports");
 const get_route_maps_1 = require("./helper/get-route-maps");
 const generate_import_handlers_1 = require("../handler/import/generate-import-handlers");
-const generate_register_component_1 = require("../../app/register-component/generate-register-component");
+const generate_register_component_1 = require("./register-component/generate-register-component");
 const generate_import_routes_1 = require("./generators/generate-import-routes");
 const generate_apply_openapi_routes_1 = require("./generators/generate-apply-openapi-routes");
 const process_import_map_1 = require("./helper/process-import-map");

package/dist/generators/{app → zod-openapi-hono/app}/register-component/generate-register-component.d.ts

@@ -1,2 +1,2 @@
-import type { SecuritySchemes } from '../../../types';
+import type { SecuritySchemes } from '../../../../types';
 export declare function generateRegisterComponent(securitySchemes: SecuritySchemes): string;

package/dist/generators/{handler → zod-openapi-hono/handler}/generate-handler-name.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHandlerName = generateHandlerName;
-const generate_route_name_1 = require("../hono/openapi/route/generate-route-name");
+const generate_route_name_1 = require("../openapi/route/generate-route-name");
 function generateHandlerName(method, path) {
     return `${(0, generate_route_name_1.generateRouteName)(method, path)}Handler`;
 }

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

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodOpenapiHonoHandler = generateZodOpenapiHonoHandler;
 const node_fs_1 = __importDefault(require("node:fs"));
-const generate_handler_1 = require("../../handler/generate-handler");
+const generate_handler_1 = require("./generate-handler");
 const generate_route_name_1 = require("../openapi/route/generate-route-name");
 const group_handlers_by_file_name_helper_1 = require("./helper/group-handlers-by-file-name-helper");
 const format_1 = require("../../../format");
-const generate_handler_name_1 = require("../../handler/generate-handler-name");
+const generate_handler_name_1 = require("../handler/generate-handler-name");
 const ROUTE_HANDLER = `import type { RouteHandler } from '@hono/zod-openapi'`;
 async function generateZodOpenapiHonoHandler(openapi, config) {
     const paths = openapi.paths;

package/dist/generators/zod-openapi-hono/handler/helper/group-handlers-by-file-name-helper.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupHandlersByFileNameHelper = groupHandlersByFileNameHelper;
+function groupHandlersByFileNameHelper(handlers) {
+    return Array.from(handlers
+        .reduce((acc, handler) => {
+        const existing = acc.get(handler.fileName);
+        const mergedHandler = {
+            fileName: handler.fileName,
+            testFileName: handler.testFileName,
+            routeHandlerContents: existing
+                ? [...existing.routeHandlerContents, ...handler.routeHandlerContents]
+                : [...handler.routeHandlerContents],
+            routeNames: existing
+                ? [...existing.routeNames, ...handler.routeNames]
+                : [...handler.routeNames],
+        };
+        return acc.set(handler.fileName, mergedHandler);
+    }, new Map())
+        .values());
+}

package/dist/generators/{hono → zod-openapi-hono}/openapi/route/generate-route-code.js

@@ -23,9 +23,7 @@ const is_operation_1 = require("../../../../core/validator/is-operation");
  * - Generates type-safe route handlers using zod validation
  * - Combines all routes with proper spacing
  */
-function generateRouteCode(openAPIPaths, 
-// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
-config) {
+function generateRouteCode(openAPIPaths, config) {
     const routes = [];
     // 1. flattening and processing OpenAPI paths
     for (const [path, pathItem] of Object.entries(openAPIPaths)) {