hono-takibi 0.0.1

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

@@ -0,0 +1,48 @@
+"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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,61 @@
+"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/schema/references/resolve-schemas-dependencies.d.ts

@@ -0,0 +1,49 @@
+import type { Schema } from '../../../types';
+/**
+ * Resolves dependencies between schemas and returns them in topological order for safe processing
+ *
+ * @function resolveSchemasDependencies
+ * @param schemas - Record mapping schema names to their Schema objects
+ * @returns Array of schema names ordered by their dependencies
+ *
+ * @example
+ * const schemas = {
+ *   User: {
+ *     type: 'object',
+ *     properties: {
+ *       profile: { $ref: '#/components/schemas/Profile' },
+ *       settings: { $ref: '#/components/schemas/Settings' }
+ *     }
+ *   },
+ *   Profile: {
+ *     type: 'object',
+ *     properties: {
+ *       address: { $ref: '#/components/schemas/Address' }
+ *     }
+ *   },
+ *   Settings: {
+ *     type: 'object',
+ *     properties: {
+ *       theme: { type: 'string' }
+ *     }
+ *   },
+ *   Address: {
+ *     type: 'object',
+ *     properties: {
+ *       street: { type: 'string' }
+ *     }
+ *   }
+ * }
+ *
+ * const orderedSchemas = resolveSchemasDependencies(schemas)
+ * // Returns: ['Address', 'Profile', 'Settings', 'User']
+ *
+ * @note
+ * - Performs topological sorting of schemas based on their dependencies
+ * - Ensures each schema appears after all its dependencies
+ * - Handles multi-level dependency chains correctly
+ * - Essential for generating valid code where dependent types must be defined first
+ * - Uses depth-first search for dependency resolution
+ * - Automatically handles circular dependencies by preventing infinite recursion
+ */
+export declare function resolveSchemasDependencies(schemas: Record<string, Schema>): string[];

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchemasDependencies = resolveSchemasDependencies;
+const resolve_schema_order_1 = require("./resolve-schema-order");
+const resolve_schema_references_1 = require("./resolve-schema-references");
+/**
+ * Resolves dependencies between schemas and returns them in topological order for safe processing
+ *
+ * @function resolveSchemasDependencies
+ * @param schemas - Record mapping schema names to their Schema objects
+ * @returns Array of schema names ordered by their dependencies
+ *
+ * @example
+ * const schemas = {
+ *   User: {
+ *     type: 'object',
+ *     properties: {
+ *       profile: { $ref: '#/components/schemas/Profile' },
+ *       settings: { $ref: '#/components/schemas/Settings' }
+ *     }
+ *   },
+ *   Profile: {
+ *     type: 'object',
+ *     properties: {
+ *       address: { $ref: '#/components/schemas/Address' }
+ *     }
+ *   },
+ *   Settings: {
+ *     type: 'object',
+ *     properties: {
+ *       theme: { type: 'string' }
+ *     }
+ *   },
+ *   Address: {
+ *     type: 'object',
+ *     properties: {
+ *       street: { type: 'string' }
+ *     }
+ *   }
+ * }
+ *
+ * const orderedSchemas = resolveSchemasDependencies(schemas)
+ * // Returns: ['Address', 'Profile', 'Settings', 'User']
+ *
+ * @note
+ * - Performs topological sorting of schemas based on their dependencies
+ * - Ensures each schema appears after all its dependencies
+ * - Handles multi-level dependency chains correctly
+ * - Essential for generating valid code where dependent types must be defined first
+ * - Uses depth-first search for dependency resolution
+ * - Automatically handles circular dependencies by preventing infinite recursion
+ */
+function resolveSchemasDependencies(schemas) {
+    // 1. get schema reference relations as a map
+    const dependencies = (0, resolve_schema_references_1.resolveSchemaReferences)(schemas);
+    // 2. initialize ordered list and visited set
+    const ordered = [];
+    const visited = new Set();
+    // 3. resolve schema order
+    for (const name of Object.keys(schemas)) {
+        (0, resolve_schema_order_1.resolveSchemaOrder)(name, dependencies, visited, ordered);
+    }
+    // 4. return ordered list
+    return ordered;
+}

package/dist/core/schema/references/traverse_schema.d.ts

@@ -0,0 +1,48 @@
+import type { Schema } from '../../../types';
+/**
+ * Recursively traverses an OpenAPI schema to collect all $ref references
+ *
+ * @function traverseSchema
+ * @param schema - The OpenAPI schema object to traverse
+ * @param refs - Set to collect found reference names
+ *
+ * @example
+ * const refs = new Set<string>()
+ * const schema = {
+ *   type: 'object',
+ *   properties: {
+ *     user: {
+ *       $ref: '#/components/schemas/User'
+ *     },
+ *     orders: {
+ *       type: 'array',
+ *       items: {
+ *         $ref: '#/components/schemas/Order'
+ *       }
+ *     },
+ *     address: {
+ *       type: 'object',
+ *       properties: {
+ *         country: {
+ *           $ref: '#/components/schemas/Country'
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * traverseSchema(schema, refs)
+ * // refs contains: Set { 'User', 'Order', 'Country' }
+ *
+ * @note
+ * - Mutates the provided refs Set by adding found references
+ * - Handles nested references in:
+ *   - Object properties
+ *   - Array items
+ *   - Nested objects
+ * - Skips invalid or non-object schemas
+ * - Extracts only the schema name from $ref paths
+ *   (e.g., '#/components/schemas/User' → 'User')
+ * - Performs depth-first traversal of the schema structure
+ */
+export declare function traverseSchema(schema: Schema, refs: Set<string>): void;

package/dist/core/schema/references/traverse_schema.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSchema = traverseSchema;
+const get_ref_name_1 = require("./get-ref-name");
+/**
+ * Recursively traverses an OpenAPI schema to collect all $ref references
+ *
+ * @function traverseSchema
+ * @param schema - The OpenAPI schema object to traverse
+ * @param refs - Set to collect found reference names
+ *
+ * @example
+ * const refs = new Set<string>()
+ * const schema = {
+ *   type: 'object',
+ *   properties: {
+ *     user: {
+ *       $ref: '#/components/schemas/User'
+ *     },
+ *     orders: {
+ *       type: 'array',
+ *       items: {
+ *         $ref: '#/components/schemas/Order'
+ *       }
+ *     },
+ *     address: {
+ *       type: 'object',
+ *       properties: {
+ *         country: {
+ *           $ref: '#/components/schemas/Country'
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * traverseSchema(schema, refs)
+ * // refs contains: Set { 'User', 'Order', 'Country' }
+ *
+ * @note
+ * - Mutates the provided refs Set by adding found references
+ * - Handles nested references in:
+ *   - Object properties
+ *   - Array items
+ *   - Nested objects
+ * - Skips invalid or non-object schemas
+ * - Extracts only the schema name from $ref paths
+ *   (e.g., '#/components/schemas/User' → 'User')
+ * - Performs depth-first traversal of the schema structure
+ */
+function traverseSchema(schema, refs) {
+    // 1. input check
+    if (!schema || typeof schema !== 'object')
+        return;
+    // 2. $ref process
+    if (schema.$ref) {
+        const ref = (0, get_ref_name_1.getRefName)(schema.$ref);
+        if (ref)
+            refs.add(ref);
+    }
+    // 3. recursive property search
+    if (schema.properties) {
+        for (const property of Object.values(schema.properties)) {
+            traverseSchema(property, refs);
+        }
+    }
+    // 4. recursive items search
+    if (schema.items)
+        traverseSchema(schema.items, refs);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Capitalizes the first letter of a string
+ *
+ * @function capitalize
+ * @param str - String to capitalize
+ * @returns String with first letter capitalized
+ *
+ * @example
+ * capitalize('posts')    // Returns: 'Posts'
+ * capitalize('user')     // Returns: 'User'
+ * capitalize('api')      // Returns: 'Api'
+ *
+ * @remarks
+ * - Leaves rest of the string unchanged
+ * - Returns empty string if input is empty
+ * - Commonly used for generating type names and class names
+ */
+export declare function capitalize(str: string): string;

package/dist/core/text/capitalize.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = capitalize;
+/**
+ * Capitalizes the first letter of a string
+ *
+ * @function capitalize
+ * @param str - String to capitalize
+ * @returns String with first letter capitalized
+ *
+ * @example
+ * capitalize('posts')    // Returns: 'Posts'
+ * capitalize('user')     // Returns: 'User'
+ * capitalize('api')      // Returns: 'Api'
+ *
+ * @remarks
+ * - Leaves rest of the string unchanged
+ * - Returns empty string if input is empty
+ * - Commonly used for generating type names and class names
+ */
+function capitalize(str) {
+    return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Decapitalizes the first letter of a string
+ *
+ * @function decapitalize
+ * @param str - String to decapitalize
+ * @returns String with the first letter in lowercase
+ *
+ * @example
+ * decapitalize('Posts')    // Returns: 'posts'
+ * decapitalize('User')     // Returns: 'user'
+ * decapitalize('Api')      // Returns: 'api'
+ *
+ * @remarks
+ * - Leaves the rest of the string unchanged
+ * - Returns an empty string if the input is empty
+ */
+export declare function decapitalize(str: string): string;

package/dist/core/text/decapitalize.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decapitalize = decapitalize;
+/**
+ * Decapitalizes the first letter of a string
+ *
+ * @function decapitalize
+ * @param str - String to decapitalize
+ * @returns String with the first letter in lowercase
+ *
+ * @example
+ * decapitalize('Posts')    // Returns: 'posts'
+ * decapitalize('User')     // Returns: 'user'
+ * decapitalize('Api')      // Returns: 'api'
+ *
+ * @remarks
+ * - Leaves the rest of the string unchanged
+ * - Returns an empty string if the input is empty
+ */
+function decapitalize(str) {
+    return `${str.charAt(0).toLowerCase()}${str.slice(1)}`;
+}

package/dist/core/text/remove-zod-prefix.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Removes the zod prefix from a zod schema.
+ *
+ * @function removeZodPrefix
+ * @param zodSchema - The zod schema to remove the prefix from.
+ * @returns The zod schema without the prefix.
+ */
+export declare function removeZodPrefix(zodSchema: string): string;

package/dist/core/text/remove-zod-prefix.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeZodPrefix = removeZodPrefix;
+/**
+ * Removes the zod prefix from a zod schema.
+ *
+ * @function removeZodPrefix
+ * @param zodSchema - The zod schema to remove the prefix from.
+ * @returns The zod schema without the prefix.
+ */
+function removeZodPrefix(zodSchema) {
+    return zodSchema.replace('z.', '');
+}

package/dist/core/validator/is-format-number.d.ts

@@ -0,0 +1,2 @@
+import type { Format, FormatNumber } from '../../types';
+export declare function isFormatNumber(format: Format): format is FormatNumber;

package/dist/core/validator/is-format-number.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFormatNumber = isFormatNumber;
+function isFormatNumber(format) {
+    return ['int32', 'int64', 'float', 'double'].includes(format);
+}

package/dist/core/validator/is-format-string.d.ts

@@ -0,0 +1,2 @@
+import type { Format, FormatString } from '../../types';
+export declare function isFormatString(format: Format): format is FormatString;

package/dist/core/validator/is-format-string.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFormatString = isFormatString;
+function isFormatString(format) {
+    return [
+        'email',
+        'uri',
+        'emoji',
+        'uuid',
+        'cuid',
+        'cuid2',
+        'ulid',
+        'date-time',
+        'ip',
+        'cidr',
+        'trim',
+        'toLowerCase',
+        'toUpperCase',
+        'date',
+        'time',
+        'duration',
+        'base64',
+    ].includes(format);
+}

package/dist/core/validator/is-http-method.d.ts

@@ -0,0 +1,9 @@
+import type { HttpMethod } from '../../types';
+/**
+ * Type guard function to check if a string is a valid HTTP method
+ *
+ * @function
+ * @param method - The string to check against valid HTTP methods
+ * @returns True if the string is a valid HTTP method, with type narrowing to HttpMethod
+ */
+export declare function isHttpMethod(method: string): method is HttpMethod;

package/dist/core/validator/is-http-method.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpMethod = isHttpMethod;
+/**
+ * Type guard function to check if a string is a valid HTTP method
+ *
+ * @function
+ * @param method - The string to check against valid HTTP methods
+ * @returns True if the string is a valid HTTP method, with type narrowing to HttpMethod
+ */
+function isHttpMethod(method) {
+    return (method === 'get' ||
+        method === 'post' ||
+        method === 'put' ||
+        method === 'delete' ||
+        method === 'patch' ||
+        method === 'options' ||
+        method === 'head');
+}

package/dist/core/validator/is-operation.d.ts

@@ -0,0 +1,15 @@
+import type { Operation } from '../../types';
+/**
+ * Type guard function to check if an object is an Operation
+ *
+ * @function isOperation
+ * @param obj - The object to check
+ * @returns True if the object is an Operation, with type narrowing support
+ *
+ * @note Consider using `unknown` type instead of `Operation` for better type guarding:
+ * ```typescript
+ * function isOperation(obj: unknown): obj is Operation
+ * ```
+ * This would provide more strict type checking for arbitrary values.
+ */
+export declare function isOperation(obj: Operation): obj is Operation;

package/dist/core/validator/is-operation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOperation = isOperation;
+/**
+ * Type guard function to check if an object is an Operation
+ *
+ * @function isOperation
+ * @param obj - The object to check
+ * @returns True if the object is an Operation, with type narrowing support
+ *
+ * @note Consider using `unknown` type instead of `Operation` for better type guarding:
+ * ```typescript
+ * function isOperation(obj: unknown): obj is Operation
+ * ```
+ * This would provide more strict type checking for arbitrary values.
+ */
+function isOperation(obj) {
+    return obj && typeof obj === 'object' && 'responses' in obj;
+}

package/dist/core/zod/get-zod-string-format.d.ts

@@ -0,0 +1,30 @@
+import type { FormatString } from '../../types';
+/**
+ * Converts OpenAPI format to Zod validation method
+ *
+ * @function getZodFormatString
+ * @param format - OpenAPI format type
+ * @returns Zod validation method string
+ *
+ * @example
+ * // String validations
+ * getZodFormatString('email')      // Returns: '.email()'
+ * getZodFormatString('uri')        // Returns: '.url()'
+ * getZodFormatString('uuid')       // Returns: '.uuid()'
+ * getZodFormatString('date-time')  // Returns: '.datetime()'
+ *
+ * @example
+ * // Number types
+ * getZodFormatString('int32')      // Returns: 'z.number()'
+ * getZodFormatString('float')      // Returns: 'z.number()'
+ *
+ * @example
+ * // Unknown format
+ * getZodFormatString('unknown')    // Returns: ''
+ *
+ * @remarks
+ * - Returns the corresponding Zod validation method for known formats
+ * - Returns empty string for unrecognized formats
+ * - Used in schema generation for request/response validation
+ */
+export declare function getZodFormatString(format: FormatString): string;