hono-takibi 0.6.5 → 0.6.6

package/dist/config/index.d.ts

@@ -0,0 +1,18 @@
+export type Config = {
+    schema: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    type: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    input?: string;
+    output?: string;
+};
+export declare const DEFAULT_CONFIG: Config;
+/**
+ * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.
+ * @returns { Config } The configuration object.
+ */
+export declare function getConfig(): Config;

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

@@ -0,0 +1,6 @@
+/**
+ * Generates a camelCase schema name from a given schema name.
+ * @param { string } schemaName - The original schema name.
+ * @returns { string } The camelCase schema name.
+ */
+export declare function getCamelCaseSchemaNameHelper(schemaName: string): string;

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

@@ -0,0 +1,6 @@
+/**
+ * Generates a PascalCase schema name from a given schema name.
+ * @param { string } schemaName - The original schema name.
+ * @returns { string } The PascalCase schema name.
+ */
+export declare function getPascalCaseSchemaNameHelper(schemaName: string): string;

package/dist/core/helper/get-to-safe-identifier-helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * getToSafeIdentifierHelper
+ * @param { string } str - The string to be converted to a safe identifier
+ * @returns { string } - A normalized, safe identifier
+ */
+export declare function getToSafeIdentifierHelper(str: string): string;

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

@@ -0,0 +1,8 @@
+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.
+ * @returns { string } The variable name.
+ */
+export declare function getVariableNameHelper(name: string, config: Config): string;

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

@@ -0,0 +1,8 @@
+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.
+ * @returns { string } The variable schema name.
+ */
+export declare function getVariableSchemaNameHelper(name: string, config: Config): string;

package/dist/core/schema/references/extract-refs.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from '../../../types/index.js';
+/**
+ * Extracts all references from a given schema
+ * @param { Schema } schema - The schema to extract references from
+ * @returns { string[] } An array of reference names
+ */
+export declare function extractRefs(schema: Schema): string[];

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

@@ -0,0 +1,25 @@
+import type { Schema } from '../../../types/index.js';
+/**
+ * Collects all $ref references from an OpenAPI schema by recursively traversing it
+ * @param { Schema } schema - The schema to search for references
+ * @returns { Set<string> } A Set of strings containing all schema names referenced via $ref
+ * @example
+ * const schema = {
+ *   type: 'object',
+ *   properties: {
+ *     tags: {
+ *       type: 'array',
+ *       items: {
+ *         $ref: '#/components/schemas/Tag'
+ *       }
+ *     },
+ *     category: {
+ *       $ref: '#/components/schemas/Category'
+ *     }
+ *   }
+ * }
+ *
+ * const refs = findReferences(schema)
+ * // refs contains: Set { 'Tag', 'Category' }
+ */
+export declare function findReferences(schema: Schema): Set<string>;

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

@@ -0,0 +1,33 @@
+/**
+ * Extracts the type name from an OpenAPI schema reference ($ref)
+ * @param { string } ref - OpenAPI schema reference path (e.g., '#/components/schemas/Address')
+ * @returns { string | undefined } The referenced type name, or undefined if the reference is invalid
+ * @example
+ * // Basic usage with Address schema
+ * getRefName('#/components/schemas/Address')
+ * // Returns: 'Address'
+ *
+ * // Nested Address schema
+ * getRefName('#/components/schemas/Location/Address')
+ * // Returns: 'Address'
+ *
+ * // Complex Address reference
+ * getRefName('#/components/schemas/Shipping/Address/Details')
+ * // Returns: 'Details'
+ *
+ * // Invalid path
+ * getRefName('')
+ * // Returns: undefined
+ *
+ * - Expects standard OpenAPI reference paths (e.g., '#/components/schemas/Address')
+ * - Extracts the last segment of the path as the type name
+ * - Returns undefined for empty strings or invalid paths
+ * - Used when processing Address and other schema references in OpenAPI
+ *
+ * Processes OpenAPI $ref strings to extract schema type names.
+ * For example, when processing an Address schema reference:
+ * Input: '#/components/schemas/Address'
+ * Process: Splits by '/' -> ['#', 'components', 'schemas', 'Address']
+ * Output: Returns 'Address'
+ */
+export declare function getRefName(ref: string): string | undefined;

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

@@ -0,0 +1,10 @@
+import type { Config } from '../../../config/index.js';
+import type { Schema } from '../../../types/index.js';
+/**
+ * Retrieves the referenced schema name from a schema object.
+ * @param { Schema } schema - The schema object
+ * @param { Config } config - The configuration object
+ * @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;

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

@@ -0,0 +1,59 @@
+import type { Schema } from '../../../types/index.js';
+/**
+ * Resolves dependencies between schemas and returns them in topological order for safe processing
+ * @param { Record<string, Schema> } schemas - Record mapping schema names to their Schema objects
+ * @returns { string[] } Array of schema names ordered by their dependencies
+ * @example
+ * const schemas: Record<string, Schema> = {
+ *   A: {
+ *     type: 'object',
+ *     properties: {
+ *       b: {
+ *         $ref: '#/components/schemas/B',
+ *       },
+ *       c: {
+ *         $ref: '#/components/schemas/C',
+ *       },
+ *     },
+ *     required: ['b', 'c'],
+ *   },
+ *   B: {
+ *     type: 'object',
+ *     properties: {
+ *       id: {
+ *         type: 'string',
+ *         description: 'Identifier for schema B',
+ *       },
+ *       message: {
+ *         type: 'string',
+ *         description: 'Message from schema B',
+ *       },
+ *       required: ['id'],
+ *     },
+ *     C: {
+ *       type: 'object',
+ *       properties: {
+ *         count: {
+ *           type: 'integer',
+ *           description: 'Count value',
+ *         },
+ *         flag: {
+ *           type: 'boolean',
+ *           description: 'A boolean flag',
+ *         },
+ *       },
+ *     },
+ *   }
+ * }
+ *
+ * const orderedSchemas = resolveSchemasDependencies(schemas)
+ * // Returns: ['B', 'C', 'A']
+ *
+ * - 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/traverse-schema-dependencies.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '../../../types/index.js';
+/**
+ * Traverses the schema dependencies and returns them in topological order
+ * @param { string } schemaName - The name of the schema to traverse
+ * @param { Record<string, Schema> } schemas - The schemas to traverse
+ * @param { Set<string> } visited - The visited schemas
+ * @param { Set<string> } recursionStack - The recursion stack
+ * @param { string[] } orderedSchemas - The ordered schemas
+ */
+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.d.ts

@@ -0,0 +1,45 @@
+import type { Schema } from '../../../types/index.js';
+/**
+ * Recursively traverses an OpenAPI schema to collect all $ref references
+ * @param { Schema } schema - The OpenAPI schema object to traverse
+ * @param { Set<string> } 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' }
+ *
+ * - 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/text/capitalize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Capitalize the first letter of a string
+ * @param { string } str - String to capitalize
+ * @returns { string } 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/decapitalize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decapitalize the first letter of a string
+ * @param { string } str - String to decapitalize
+ * @returns { string } 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/escape-str.d.ts

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

package/dist/core/text/regex-pattern.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a regex pattern from a string
+ * @param { string } pattern - The pattern to generate a regex from
+ * @returns { string } Generated regex pattern
+ */
+export declare function regexPattern(pattern: string): string;

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

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

package/dist/core/validator/is-all-optional.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if all properties in the object are optional
+ * @param { string[] } objectProperties - An array of strings representing the object properties
+ * @returns { boolean } A boolean indicating if all properties are optional
+ */
+export declare function isAllOptional(objectProperties: string[]): boolean;

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

@@ -0,0 +1,7 @@
+import type { Schema } from '../../types/index.js';
+/**
+ * Check if an array has a schema reference
+ * @param { Schema } schema - The schema to check
+ * @returns { boolean } A boolean indicating if the array has a schema reference
+ */
+export declare function isArrayWithSchemaReference(schema: Schema): boolean;

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

@@ -0,0 +1,7 @@
+import type { Format, FormatNumber } from '../../types/index.js';
+/**
+ * Check if the format is a number type
+ * @param {Format} format - OpenAPI format type
+ * @returns {boolean} true if the format is a number type, false otherwise
+ */
+export declare function isFormatNumber(format: Format): format is FormatNumber;

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

@@ -0,0 +1,7 @@
+import type { Format, FormatString } from '../../types/index.js';
+/**
+ *  Check if the format is a string type
+ * @param { Format } format - OpenAPI format type
+ * @returns { boolean } true if the format is a string type, false otherwise
+ */
+export declare function isFormatString(format: Format): format is FormatString;

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

@@ -0,0 +1,7 @@
+import type { HttpMethod } from '../../types/index.js';
+/**
+ * Check if a string is a valid HTTP method
+ * @param { string } method - The string to check against valid HTTP methods
+ * @returns { boolean } 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-nullable-schema.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from '../../types/index.js';
+/**
+ * Check if a given sub-schema is `nullable`
+ * @param { Schema } schema - The sub-schema to evaluate
+ * @returns { boolean } `true` if `nullable` is set to `true` and it is the only key in the schema, otherwise `false`
+ */
+export declare function isNullableSchema(schema: Schema): boolean;

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

@@ -0,0 +1,13 @@
+import type { Operation } from '../../types/index.js';
+/**
+ * Check if an object is an Operation
+ * @param { Operation } obj - The object to check
+ * @returns { boolean } True if the object is an Operation, with type narrowing support
+ *
+ * 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-ref-object.d.ts

@@ -0,0 +1,11 @@
+type RefObject = {
+    $ref?: string;
+    [key: string]: unknown;
+};
+/**
+ * Check if the value is a reference object
+ * @param { unknown } value - The value to check
+ * @returns { boolean } true if the value is a reference object, false otherwise
+ */
+export declare function isRefObject(value: unknown): value is RefObject;
+export {};

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

@@ -0,0 +1,7 @@
+import type { Schema } from '../../types/index.js';
+/**
+ * Check if the schema is a reference
+ * @param { Schema } schema - The schema to check
+ * @returns { boolean } A boolean indicating if the schema is a reference
+ */
+export declare function isSchemaReference(schema: Schema): boolean;

package/dist/core/validator/is-unique-content-schema.d.ts

@@ -0,0 +1,8 @@
+import type { Content } from '../../types/index.js';
+/**
+ * Get unique content schema
+ * @param { string[] } contentTypes - Content types
+ * @param { Content } content - Content
+ * @returns { boolean } Unique content schema
+ */
+export declare function isUniqueContentSchema(contentTypes: string[], content: Content): boolean;

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

@@ -0,0 +1,30 @@
+import type { FormatString } from '../../types/index.js';
+/**
+ * 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;

package/dist/format/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formats TypeScript code using Prettier
+ * @param { string } code - The TypeScript code to format
+ * @returns { Promise<string> } The formatted code
+ */
+export declare function formatCode(code: string): Promise<string>;

package/dist/generator/zod/generate-zod-array.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Generates a Zod array schema with the specified schema type
+ * @param { string } zodSchema - Schema type for array elements (e.g., 'Address', 'z.string().min(3)')
+ * @returns { string } Zod array schema string wrapped with z.array()
+ * @example
+ * // With type reference
+ * generateZodArray('Address')
+ * // Returns: 'z.array(Address)'
+ *
+ * // With primitive Zod schema
+ * generateZodArray('z.string()')
+ * // Returns: 'z.array(z.string())'
+ *
+ * // With complex Zod schema
+ * generateZodArray('z.string().min(3).max(10)')
+ * // Returns: 'z.array(z.string().min(3).max(10))'
+ *
+ * // With nested schema
+ * generateZodArray('z.object({ name: z.string() })')
+ * // Returns: 'z.array(z.object({ name: z.string() }))'
+ */
+export declare function generateZodArray(zodSchema: string): string;

package/dist/generator/zod/generate-zod-coerce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates a zod pipe function to coerce a value to a zod schema.
+ * @param { string } z - The zod schema to coerce to.
+ * @param { string } zodSchema - The zod schema to coerce.
+ * @returns { string } Generated zod pipe function to coerce a value to a zod schema.
+ */
+export declare function generateZodCoerce(z: string, zodSchema: string): string;

package/dist/generator/zod/generate-zod-default.d.ts

@@ -0,0 +1,7 @@
+import type { DefaultValue } from '../../types/index.js';
+/**
+ * Generates a Zod default validation string
+ * @param { DefaultValue } defaultValue - The default value to set
+ * @returns { string } Generated Zod default validation string
+ */
+export declare function generateZodDefault(defaultValue: DefaultValue): string;

package/dist/generator/zod/generate-zod-enum.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from '../../types/index.js';
+/**
+ * Generates a Zod enum string
+ * @param { Schema } schema - The schema definition
+ * @returns { string } Generated Zod enum string
+ */
+export declare function generateZodEnum(schema: Schema): string;

package/dist/generator/zod/generate-zod-gt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a Zod gt validation string
+ * @param { number } minimum - The minimum value
+ * @returns { string } Generated Zod gt validation string
+ */
+export declare function generateZodGt(minimum: number): string;

package/dist/generator/zod/generate-zod-infer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates a TypeScript type definition for an inferred Zod schema.
+ * @param { string } typeVariableName - The name of the TypeScript type variable.
+ * @param { string } schemaName - The name of the Zod schema to infer.
+ * @returns { string } Generated TypeScript type definition string
+ */
+export declare function generateZodInfer(typeVariableName: string, schemaName: string): string;

package/dist/generator/zod/generate-zod-integer-schema.d.ts

@@ -0,0 +1,19 @@
+import type { DefaultValue, ExampleValue } from '../../types/index.js';
+type GenerateZodIntegerSchemaParams = {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    default?: DefaultValue;
+    example?: ExampleValue;
+    paramName?: string;
+    isPath?: boolean;
+};
+/**
+ * Generates a zod schema for an integer.
+ * @param { GenerateZodIntegerSchemaParams } args - The parameters to generate the zod schema.
+ * @returns { string } Generated Zod integer schema string
+ */
+export declare function generateZodIntegerSchema(args: GenerateZodIntegerSchemaParams): string;
+export {};

package/dist/generator/zod/generate-zod-intersection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a Zod intersection schema.
+ * @param { string[] } schemas - The schemas to intersect.
+ * @returns { string } Generated Zod intersection schema string
+ */
+export declare function generateZodIntersection(schemas: string[]): string;

package/dist/generator/zod/generate-zod-length.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates a Zod length validation string
+ * @param { number } length - The length value to validate against
+ * @returns { string } Generated Zod length validation string
+ * @example
+ * const lengthValidation = generateZodLength(10)
+ * // Returns: 'length(10)'
+ */
+export declare function generateZodLength(length: number): string;

package/dist/generator/zod/generate-zod-lt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a Zod lt validation string
+ * @param { number } maximum - The maximum value
+ * @returns { string } Generated Zod lt validation string
+ */
+export declare function generateZodLt(maximum: number): string;

package/dist/generator/zod/generate-zod-max.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a Zod max validation string
+ * @param { number } max - The maximum value
+ * @returns { string } Generated Zod max validation string
+ */
+export declare function generateZodMax(max: number): string;

package/dist/generator/zod/generate-zod-min.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate Zod min validation
+ * @param { number } min - The minimum value
+ * @returns { string } Generated Zod min validation string
+ * @example
+ * generateZodMin(1) -> ".min(1)"
+ * generateZodMin(10) -> ".min(10)"
+ */
+export declare function generateZodMin(min: number): string;

package/dist/generator/zod/generate-zod-nullable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates a zod nullable validation
+ * @returns { string } Generated Zod nullable schema string
+ * @example
+ * generateZodNullable() -> ".nullable()"
+ */
+export declare function generateZodNullable(): string;

package/dist/generator/zod/generate-zod-number.d.ts

@@ -0,0 +1,21 @@
+import type { DefaultValue, ExampleValue } from '../../types/index.js';
+type GenerateZodNumberParams = {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    default?: DefaultValue;
+    example?: ExampleValue;
+    paramName?: string;
+    isPath?: boolean;
+};
+/**
+ * Generates a Zod number schema string
+ * @param { GenerateZodNumberParams } args - The parameters to generate the zod number schema.
+ * @returns { string } Generated Zod number schema string
+ */
+export declare function generateZodNumber(args: GenerateZodNumberParams): string;
+export {};