hono-takibi 0.4.2 → 0.4.3

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-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/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,9 +6,9 @@ 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");

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)) {

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

@@ -5,7 +5,7 @@ const generate_create_route_1 = require("./generate-create-route");
 const generate_request_parameter_1 = require("./params/generate-request-parameter");
 const generate_response_schema_1 = require("./response/generate-response-schema");
 const generate_route_name_1 = require("./generate-route-name");
-const sanitize_1 = require("../../../../core/text/sanitize");
+const escape_str_1 = require("../../../../core/text/escape-str");
 /**
  * Generates TypeScript code for a Hono route based on OpenAPI operation details
  *
@@ -28,9 +28,7 @@ const sanitize_1 = require("../../../../core/text/sanitize");
  * - Handles optional parameters appropriately
  * - Integrates with Hono's createRoute function
  */
-function generateRoute(path, method, operation, 
-// namingCase: 'camelCase' | 'PascalCase',
-config) {
+function generateRoute(path, method, operation, config) {
     const { tags, summary, description, security, parameters, requestBody, responses } = operation;
     const routeName = (0, generate_route_name_1.generateRouteName)(method, path);
     const tagList = tags ? JSON.stringify(tags) : '[]';
@@ -40,8 +38,8 @@ config) {
         tagsCode: `tags:${tagList},`,
         methodCode: `method:'${method}',`,
         pathCode: `path:'${path}',`,
-        summaryCode: summary ? `summary:'${(0, sanitize_1.sanitize)(summary)}',` : '',
-        descriptionCode: description ? `description:'${(0, sanitize_1.sanitize)(description)}',` : '',
+        summaryCode: summary ? `summary:'${(0, escape_str_1.escapeStr)(summary)}',` : '',
+        descriptionCode: description ? `description:'${(0, escape_str_1.escapeStr)(description)}',` : '',
         securityCode: security ? `security:${JSON.stringify(security)},` : '',
         requestParams: requestParams ? `${requestParams}` : '',
         responsesCode: responses ? `responses:{${(0, generate_response_schema_1.generateResponseSchema)(responses, config)}}` : '',

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

@@ -16,9 +16,7 @@ const generate_zod_schema_1 = require("../../../../zod/schema/generate-zod-schem
  * - Organizes parameters into appropriate objects based on their location
  * - Maintains empty objects for unused parameter locations
  */
-function generateParamsObject(parameters, 
-// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
-config) {
+function generateParamsObject(parameters, config) {
     return parameters.reduce((acc, param) => {
         const optionalSuffix = param.required ? '' : '.optional()';
         // path params are generated with the param name

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateResponseSchema = generateResponseSchema;
-const escape_quote_1 = require("../../../../../core/text/escape-quote");
+const escape_str_1 = require("../../../../../core/text/escape-str");
 const is_unique_content_schema_1 = require("../../../../../core/validator/is-unique-content-schema");
 const generate_zod_property_schema_1 = require("../../../../zod/generate-zod-property-schema");
 /**
@@ -24,9 +24,7 @@ const generate_zod_property_schema_1 = require("../../../../zod/generate-zod-pro
  * - Handles nested schema structures
  * - Automatically resolves schema references
  */
-function generateResponseSchema(responses, 
-// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
-config) {
+function generateResponseSchema(responses, config) {
     // 1. get response codes (200, 404, etc.)
     const responseCodes = Object.keys(responses);
     // 2. processing for each response code
@@ -34,7 +32,7 @@ config) {
         const response = responses[code];
         // 2.1 no content (description only response)
         if (!response.content)
-            return `${code}:{description:'${(0, escape_quote_1.escapeQuote)(response.description ?? '')}',},`;
+            return `${code}:{description:'${(0, escape_str_1.escapeStr)(response.description ?? '')}',},`;
         // check duplication
         const contentTypes = Object.keys(response.content);
         const isUniqueSchema = (0, is_unique_content_schema_1.isUniqueContentSchema)(contentTypes, response.content);
@@ -46,7 +44,7 @@ config) {
                 const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(content.schema, config);
                 contentParts.push(`'${contentType}':{schema:${zodSchema}}`);
             }
-            return `${code}:{description:'${(0, escape_quote_1.escapeQuote)(response.description ?? '')}',content:{${contentParts.join(',')}},},`;
+            return `${code}:{description:'${(0, escape_str_1.escapeStr)(response.description ?? '')}',content:{${contentParts.join(',')}},},`;
         }
     });
     // 3.combine all response definitions

package/dist/index.js

@@ -8,11 +8,11 @@ exports.main = main;
 const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const generate_zod_openapi_hono_1 = require("./generators/hono/openapi/generate-zod-openapi-hono");
-const generate_zod_openapi_hono_handler_1 = require("./generators/hono/handler/generate-zod-openapi-hono-handler");
+const generate_zod_openapi_hono_1 = require("./generators/zod-openapi-hono/openapi/generate-zod-openapi-hono");
+const generate_zod_openapi_hono_handler_1 = require("./generators/zod-openapi-hono/handler/generate-zod-openapi-hono-handler");
 const config_1 = require("./config");
 const format_1 = require("./format");
-const app_1 = require("./generators/hono/app");
+const app_1 = require("./generators/zod-openapi-hono/app");
 /**
  * CLI entry point for hono-takibi
  *

package/dist/vite-plugin/vite-mode.js

@@ -7,7 +7,7 @@ exports.viteMode = viteMode;
 const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const generate_zod_openapi_hono_1 = require("../generators/hono/openapi/generate-zod-openapi-hono");
+const generate_zod_openapi_hono_1 = require("../generators/zod-openapi-hono/openapi/generate-zod-openapi-hono");
 const config_1 = require("../config");
 const format_1 = require("../format");
 async function viteMode(config = (0, config_1.getConfig)()) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "license": "MIT",
   "keywords": [
     "hono",

package/dist/core/schema/references/resolve-schema-order.d.ts

@@ -1,30 +0,0 @@
-/**
- * Resolves the order of schema processing based on their dependencies using depth-first search
- *
- * @function resolveSchemaOrder
- * @param name - The name of the current schema to process
- * @param dependencies - Map of schema names to their dependent schema names
- * @param visited - Set of schema names that have been processed
- * @param ordered - Array to store the resolved order of schema names
- * @returns void
- *
- * @example
- * const dependencies = new Map([
- *   ['User', new Set(['Address'])],
- *   ['Address', new Set(['Country'])],
- *   ['Country', new Set()]
- * ])
- *
- * const visited = new Set<string>()
- * const ordered: string[] = []
- *
- * resolveSchemaOrder('User', dependencies, visited, ordered)
- * // ordered will be: ['Country', 'Address', 'User']
- *
- * @note
- * - Uses depth-first search to resolve dependencies
- * - Prevents circular references by tracking visited schemas
- * - Ensures dependent schemas appear before schemas that depend on them
- * - Modifies the ordered array in-place to build the final sequence
- */
-export declare function resolveSchemaOrder(name: string, dependencies: Map<string, Set<string>>, visited: Set<string>, ordered: string[]): void;

package/dist/core/schema/references/resolve-schema-order.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSchemaOrder = resolveSchemaOrder;
-/**
- * Resolves the order of schema processing based on their dependencies using depth-first search
- *
- * @function resolveSchemaOrder
- * @param name - The name of the current schema to process
- * @param dependencies - Map of schema names to their dependent schema names
- * @param visited - Set of schema names that have been processed
- * @param ordered - Array to store the resolved order of schema names
- * @returns void
- *
- * @example
- * const dependencies = new Map([
- *   ['User', new Set(['Address'])],
- *   ['Address', new Set(['Country'])],
- *   ['Country', new Set()]
- * ])
- *
- * const visited = new Set<string>()
- * const ordered: string[] = []
- *
- * resolveSchemaOrder('User', dependencies, visited, ordered)
- * // ordered will be: ['Country', 'Address', 'User']
- *
- * @note
- * - Uses depth-first search to resolve dependencies
- * - Prevents circular references by tracking visited schemas
- * - Ensures dependent schemas appear before schemas that depend on them
- * - Modifies the ordered array in-place to build the final sequence
- */
-function resolveSchemaOrder(name, dependencies, visited, ordered) {
-    // 1. circulation reference prevention check
-    if (visited.has(name))
-        return;
-    // 2. mark current schema as visited
-    visited.add(name);
-    // 3. get dependencies of current schema
-    const deps = dependencies.get(name);
-    if (deps) {
-        for (const dep of deps) {
-            resolveSchemaOrder(dep, dependencies, visited, ordered);
-        }
-    }
-    // 4. add current schema to ordered list
-    ordered.push(name);
-}

package/dist/core/schema/references/resolve-schema-references.d.ts

@@ -1,49 +0,0 @@
-import type { Schema } from '../../../types';
-/**
- * Creates a dependency map for all schemas and their references in an OpenAPI specification
- *
- * @function resolveSchemaReferences
- * @param schemas - Record mapping schema names to their Schema objects
- * @returns A Map where keys are schema names and values are Sets of referenced schema names
- *
- * @example
- * const schemas = {
- *   User: {
- *     type: 'object',
- *     properties: {
- *       profile: { $ref: '#/components/schemas/Profile' },
- *       addresses: {
- *         type: 'array',
- *         items: { $ref: '#/components/schemas/Address' }
- *       }
- *     }
- *   },
- *   Profile: {
- *     type: 'object',
- *     properties: {
- *       name: { type: 'string' }
- *     }
- *   },
- *   Address: {
- *     type: 'object',
- *     properties: {
- *       street: { type: 'string' }
- *     }
- *   }
- * }
- *
- * const dependencies = resolveSchemaReferences(schemas)
- * // dependencies contains:
- * // Map {
- * //   'User' => Set { 'Profile', 'Address' },
- * //   'Profile' => Set {},
- * //   'Address' => Set {}
- * // }
- *
- * @note
- * - Creates a complete dependency graph for all schemas
- * - Handles nested references in arrays and objects
- * - Empty Sets indicate schemas with no dependencies
- * - Used for determining the correct order of schema generation
- */
-export declare function resolveSchemaReferences(schemas: Record<string, Schema>): Map<string, Set<string>>;

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

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSchemaReferences = resolveSchemaReferences;
-const find_references_1 = require("./find-references");
-/**
- * Creates a dependency map for all schemas and their references in an OpenAPI specification
- *
- * @function resolveSchemaReferences
- * @param schemas - Record mapping schema names to their Schema objects
- * @returns A Map where keys are schema names and values are Sets of referenced schema names
- *
- * @example
- * const schemas = {
- *   User: {
- *     type: 'object',
- *     properties: {
- *       profile: { $ref: '#/components/schemas/Profile' },
- *       addresses: {
- *         type: 'array',
- *         items: { $ref: '#/components/schemas/Address' }
- *       }
- *     }
- *   },
- *   Profile: {
- *     type: 'object',
- *     properties: {
- *       name: { type: 'string' }
- *     }
- *   },
- *   Address: {
- *     type: 'object',
- *     properties: {
- *       street: { type: 'string' }
- *     }
- *   }
- * }
- *
- * const dependencies = resolveSchemaReferences(schemas)
- * // dependencies contains:
- * // Map {
- * //   'User' => Set { 'Profile', 'Address' },
- * //   'Profile' => Set {},
- * //   'Address' => Set {}
- * // }
- *
- * @note
- * - Creates a complete dependency graph for all schemas
- * - Handles nested references in arrays and objects
- * - Empty Sets indicate schemas with no dependencies
- * - Used for determining the correct order of schema generation
- */
-function resolveSchemaReferences(schemas) {
-    // 1. initialize dependencies map
-    const dependencies = new Map();
-    // 2. resolve each schema reference
-    for (const [name, schema] of Object.entries(schemas)) {
-        dependencies.set(name, (0, find_references_1.findReferences)(schema));
-    }
-    // 3. return dependencies map
-    return dependencies;
-}

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

@@ -1,8 +0,0 @@
-/**
- * Escapes single quote in a string
- *
- * @function escapeQuote
- * @param str - The string to escape
- * @returns The escaped string
- */
-export declare function escapeQuote(str: string): string;

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeQuote = escapeQuote;
-/**
- * Escapes single quote in a string
- *
- * @function escapeQuote
- * @param str - The string to escape
- * @returns The escaped string
- */
-function escapeQuote(str) {
-    return str?.replace(/'/g, "\\'");
-}

package/dist/core/text/sanitize.d.ts

@@ -1 +0,0 @@
-export declare function sanitize(text: string): string;

package/dist/core/text/sanitize.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitize = sanitize;
-function sanitize(text) {
-    return text.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
-}

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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupHandlersByFileNameHelper = groupHandlersByFileNameHelper;
-function groupHandlersByFileNameHelper(handlers) {
-    const mergedMap = new Map();
-    for (const handler of handlers) {
-        if (mergedMap.has(handler.fileName)) {
-            const existing = mergedMap.get(handler.fileName);
-            if (existing) {
-                existing.routeHandlerContents.push(...handler.routeHandlerContents);
-                existing.routeNames.push(...handler.routeNames);
-            }
-        }
-        else {
-            mergedMap.set(handler.fileName, {
-                fileName: handler.fileName,
-                testFileName: handler.testFileName,
-                routeHandlerContents: [...handler.routeHandlerContents],
-                routeNames: [...handler.routeNames],
-            });
-        }
-    }
-    return Array.from(mergedMap.values());
-}