hono-takibi 0.6.4 → 0.6.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 - present, Hono Takibi Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/config/index.js

@@ -1,12 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONFIG = void 0;
-exports.getConfig = getConfig;
-const node_fs_1 = __importDefault(require("node:fs"));
-exports.DEFAULT_CONFIG = {
+import fs from 'node:fs';
+export const DEFAULT_CONFIG = {
     schema: {
         name: 'PascalCase',
         export: false,
@@ -20,9 +13,9 @@ exports.DEFAULT_CONFIG = {
  * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.
  * @returns { Config } The configuration object.
  */
-function getConfig() {
-    const config = node_fs_1.default.existsSync('hono-takibi.json')
-        ? { ...exports.DEFAULT_CONFIG, ...JSON.parse(node_fs_1.default.readFileSync('hono-takibi.json', 'utf-8')) }
-        : exports.DEFAULT_CONFIG;
+export function getConfig() {
+    const config = fs.existsSync('hono-takibi.json')
+        ? { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync('hono-takibi.json', 'utf-8')) }
+        : DEFAULT_CONFIG;
     return config;
 }

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

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCamelCaseSchemaNameHelper = getCamelCaseSchemaNameHelper;
-const decapitalize_1 = require("../text/decapitalize");
+import { decapitalize } from '../text/decapitalize.js';
 /**
  * Generates a camelCase schema name from a given schema name.
  * @param { string } schemaName - The original schema name.
  * @returns { string } The camelCase schema name.
  */
-function getCamelCaseSchemaNameHelper(schemaName) {
-    const decapitalizedSchemaName = (0, decapitalize_1.decapitalize)(schemaName);
+export function getCamelCaseSchemaNameHelper(schemaName) {
+    const decapitalizedSchemaName = decapitalize(schemaName);
     return `${decapitalizedSchemaName}Schema`;
 }

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

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPascalCaseSchemaNameHelper = getPascalCaseSchemaNameHelper;
-const capitalize_1 = require("../text/capitalize");
+import { capitalize } from '../text/capitalize.js';
 /**
  * Generates a PascalCase schema name from a given schema name.
  * @param { string } schemaName - The original schema name.
  * @returns { string } The PascalCase schema name.
  */
-function getPascalCaseSchemaNameHelper(schemaName) {
-    const capitalizedSchemaName = (0, capitalize_1.capitalize)(schemaName);
+export function getPascalCaseSchemaNameHelper(schemaName) {
+    const capitalizedSchemaName = capitalize(schemaName);
     return `${capitalizedSchemaName}Schema`;
 }

package/dist/core/helper/get-to-safe-identifier-helper.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToSafeIdentifierHelper = getToSafeIdentifierHelper;
 /**
  * getToSafeIdentifierHelper
- * @param {string} str - The string to be converted to a safe identifier
- * @returns {string} - A normalized, safe identifier
+ * @param { string } str - The string to be converted to a safe identifier
+ * @returns { string } - A normalized, safe identifier
  */
-function getToSafeIdentifierHelper(str) {
+export function getToSafeIdentifierHelper(str) {
     const trimmed = str.trim();
     if (trimmed.includes('-')) {
         return trimmed.replace(/\s*-\s*/g, '_');

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

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVariableNameHelper = getVariableNameHelper;
-const capitalize_1 = require("../text/capitalize");
-const decapitalize_1 = require("../text/decapitalize");
+import { capitalize } from '../text/capitalize.js';
+import { decapitalize } from '../text/decapitalize.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.
  */
-function getVariableNameHelper(name, config) {
-    return config.type.name === 'camelCase' ? (0, decapitalize_1.decapitalize)(name) : (0, capitalize_1.capitalize)(name);
+export function getVariableNameHelper(name, config) {
+    return config.type.name === 'camelCase' ? decapitalize(name) : capitalize(name);
 }

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

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVariableSchemaNameHelper = getVariableSchemaNameHelper;
-const get_camel_case_schema_name_helper_1 = require("./get-camel-case-schema-name-helper");
-const get_pascal_case_schema_name_helper_1 = require("./get-pascal-case-schema-name-helper");
+import { getCamelCaseSchemaNameHelper } from './get-camel-case-schema-name-helper.js';
+import { getPascalCaseSchemaNameHelper } from './get-pascal-case-schema-name-helper.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.
  */
-function getVariableSchemaNameHelper(name, config) {
+export function getVariableSchemaNameHelper(name, config) {
     return config.schema.name === 'camelCase'
-        ? (0, get_camel_case_schema_name_helper_1.getCamelCaseSchemaNameHelper)(name)
-        : (0, get_pascal_case_schema_name_helper_1.getPascalCaseSchemaNameHelper)(name);
+        ? getCamelCaseSchemaNameHelper(name)
+        : getPascalCaseSchemaNameHelper(name);
 }

package/dist/core/schema/references/extract-refs.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractRefs = extractRefs;
-const is_ref_object_1 = require("../../validator/is-ref-object");
+import { isRefObject } from '../../validator/is-ref-object.js';
 /**
  * Extracts all references from a given schema
  * @param { Schema } schema - The schema to extract references from
  * @returns { string[] } An array of reference names
  */
-function extractRefs(schema) {
+export function extractRefs(schema) {
     const refs = [];
     const traverse = (obj) => {
-        if (!(0, is_ref_object_1.isRefObject)(obj))
+        if (!isRefObject(obj))
             return;
         for (const [key, value] of Object.entries(obj)) {
             if (key !== '$ref') {
-                if ((0, is_ref_object_1.isRefObject)(value)) {
+                if (isRefObject(value)) {
                     traverse(value);
                 }
                 continue;

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findReferences = findReferences;
-const traverse_schema_1 = require("./traverse-schema");
+import { traverseSchema } from './traverse-schema.js';
 /**
  * Collects all $ref references from an OpenAPI schema by recursively traversing it
  * @param { Schema } schema - The schema to search for references
@@ -25,8 +22,8 @@ const traverse_schema_1 = require("./traverse-schema");
  * const refs = findReferences(schema)
  * // refs contains: Set { 'Tag', 'Category' }
  */
-function findReferences(schema) {
+export function findReferences(schema) {
     const refs = new Set();
-    (0, traverse_schema_1.traverseSchema)(schema, refs);
+    traverseSchema(schema, refs);
     return refs;
 }

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

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRefName = getRefName;
 /**
  * Extracts the type name from an OpenAPI schema reference ($ref)
  * @param { string } ref - OpenAPI schema reference path (e.g., '#/components/schemas/Address')
@@ -33,7 +30,7 @@ exports.getRefName = getRefName;
  * Process: Splits by '/' -> ['#', 'components', 'schemas', 'Address']
  * Output: Returns 'Address'
  */
-function getRefName(ref) {
+export function getRefName(ref) {
     // split('/'): Split a string into an array using slashes
     // 1. ["#", "components", "schemas", "Address"]
     // pop() to get the last element

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRefSchemaName = getRefSchemaName;
-const get_variable_schema_name_helper_1 = require("../../helper/get-variable-schema-name-helper");
-const get_ref_name_1 = require("./get-ref-name");
+import { getVariableSchemaNameHelper } from '../../helper/get-variable-schema-name-helper.js';
+import { getRefName } from './get-ref-name.js';
 /**
  * Retrieves the referenced schema name from a schema object.
  * @param { Schema } schema - The schema object
@@ -10,13 +7,13 @@ const get_ref_name_1 = require("./get-ref-name");
  * @returns { string } The referenced schema name
  * @throws { Error } Will throw an error if the $ref property or the reference name is not found
  */
-function getRefSchemaName(schema, config) {
+export function getRefSchemaName(schema, config) {
     if (!schema.$ref) {
         throw new Error('refName is not found');
     }
-    const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
+    const refName = getRefName(schema.$ref);
     if (!refName) {
         throw new Error('refName is not found');
     }
-    return (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
+    return getVariableSchemaNameHelper(refName, config);
 }

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSchemasDependencies = resolveSchemasDependencies;
-const traverse_schema_dependencies_1 = require("./traverse-schema-dependencies");
+import { traverseSchemaDependencies } from './traverse-schema-dependencies.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
@@ -59,13 +56,13 @@ const traverse_schema_dependencies_1 = require("./traverse-schema-dependencies")
  * - Uses depth-first search for dependency resolution
  * - Automatically handles circular dependencies by preventing infinite recursion
  */
-function resolveSchemasDependencies(schemas) {
+export function resolveSchemasDependencies(schemas) {
     const visited = new Set();
     const recursionStack = new Set();
     const orderedSchemas = [];
     for (const schemaName of Object.keys(schemas)) {
         if (!visited.has(schemaName)) {
-            (0, traverse_schema_dependencies_1.traverseSchemaDependencies)(schemaName, schemas, visited, recursionStack, orderedSchemas);
+            traverseSchemaDependencies(schemaName, schemas, visited, recursionStack, orderedSchemas);
         }
     }
     return orderedSchemas;

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSchemaDependencies = traverseSchemaDependencies;
-const extract_refs_1 = require("./extract-refs");
+import { extractRefs } from './extract-refs.js';
 /**
  * Traverses the schema dependencies and returns them in topological order
  * @param { string } schemaName - The name of the schema to traverse
@@ -10,7 +7,7 @@ const extract_refs_1 = require("./extract-refs");
  * @param { Set<string> } recursionStack - The recursion stack
  * @param { string[] } orderedSchemas - The ordered schemas
  */
-function traverseSchemaDependencies(schemaName, schemas, visited, recursionStack, orderedSchemas) {
+export function traverseSchemaDependencies(schemaName, schemas, visited, recursionStack, orderedSchemas) {
     if (visited.has(schemaName))
         return;
     if (recursionStack.has(schemaName)) {
@@ -19,7 +16,7 @@ function traverseSchemaDependencies(schemaName, schemas, visited, recursionStack
     recursionStack.add(schemaName);
     const schema = schemas[schemaName];
     if (schema) {
-        for (const ref of (0, extract_refs_1.extractRefs)(schema)) {
+        for (const ref of extractRefs(schema)) {
             if (schemas[ref]) {
                 traverseSchemaDependencies(ref, schemas, visited, recursionStack, orderedSchemas);
             }

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSchema = traverseSchema;
-const get_ref_name_1 = require("./get-ref-name");
+import { getRefName } from './get-ref-name.js';
 /**
  * Recursively traverses an OpenAPI schema to collect all $ref references
  * @param { Schema } schema - The OpenAPI schema object to traverse
@@ -45,13 +42,13 @@ const get_ref_name_1 = require("./get-ref-name");
  *   (e.g., '#/components/schemas/User' → 'User')
  * - Performs depth-first traversal of the schema structure
  */
-function traverseSchema(schema, refs) {
+export function traverseSchema(schema, refs) {
     // Exit if schema is undefined or not an object
     if (!schema || typeof schema !== 'object')
         return;
     // If schema has a $ref property, extract and store the referenced schema name
     if (schema.$ref) {
-        const ref = (0, get_ref_name_1.getRefName)(schema.$ref);
+        const ref = getRefName(schema.$ref);
         if (ref)
             refs.add(ref);
     }

package/dist/core/text/capitalize.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.capitalize = capitalize;
 /**
  * Capitalize the first letter of a string
- * @param {string} str - String to capitalize
- * @returns {string} String with first letter capitalized
+ * @param { string } str - String to capitalize
+ * @returns { string } String with first letter capitalized
  *
  * @example
  * capitalize('posts')    // Returns: 'Posts'
@@ -16,6 +13,6 @@ exports.capitalize = capitalize;
  * - Returns empty string if input is empty
  * - Commonly used for generating type names and class names
  */
-function capitalize(str) {
+export function capitalize(str) {
     return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
 }

package/dist/core/text/decapitalize.js

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

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

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeStr = escapeStr;
 /**
  * Escape text for use in TypeScript code
- * @param {string} text - The text to escape
- * @returns {string} The escaped text
+ * @param { string } text - The text to escape
+ * @returns { string } The escaped text
  */
-function escapeStr(text) {
+export function escapeStr(text) {
     return (text
         // Basic text cleaning
         .replace(/\n/g, ' ') // Replace line breaks with spaces

package/dist/core/text/regex-pattern.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.regexPattern = regexPattern;
 /**
  * Generates a regex pattern from a string
- * @param {string} pattern - The pattern to generate a regex from
- * @returns {string} Generated regex pattern
+ * @param { string } pattern - The pattern to generate a regex from
+ * @returns { string } Generated regex pattern
  */
-function regexPattern(pattern) {
+export function regexPattern(pattern) {
     const escapedPattern = pattern.replace(/(?<!\\)\//g, '\\/');
     const res = `/${escapedPattern}/`;
     return res;

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

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeZodPrefix = removeZodPrefix;
 /**
  * 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
+ * @param { string } zodSchema - The zod schema to remove the prefix from
+ * @returns { string } The zod schema without the prefix
  */
-function removeZodPrefix(zodSchema) {
+export function removeZodPrefix(zodSchema) {
     return zodSchema.replace('z.', '');
 }

package/dist/core/validator/is-all-optional.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAllOptional = isAllOptional;
 /**
  * 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
+ * @param { string[] } objectProperties - An array of strings representing the object properties
+ * @returns { boolean } A boolean indicating if all properties are optional
  */
-function isAllOptional(objectProperties) {
+export function isAllOptional(objectProperties) {
     return objectProperties.every((prop) => prop.includes('.optional()'));
 }

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

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArrayWithSchemaReference = isArrayWithSchemaReference;
 /**
  * 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
+ * @param { Schema } schema - The schema to check
+ * @returns { boolean } A boolean indicating if the array has a schema reference
  */
-function isArrayWithSchemaReference(schema) {
+export function isArrayWithSchemaReference(schema) {
     return schema.type === 'array' && Boolean(schema.items?.$ref);
 }

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

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFormatNumber = isFormatNumber;
 /**
  * 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
  */
-function isFormatNumber(format) {
+export function isFormatNumber(format) {
     return ['int32', 'int64', 'float', 'double'].includes(format);
 }

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

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFormatString = isFormatString;
 /**
  *  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
+ * @param { Format } format - OpenAPI format type
+ * @returns { boolean } true if the format is a string type, false otherwise
  */
-function isFormatString(format) {
+export function isFormatString(format) {
     return [
         'email',
         'uri',

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

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHttpMethod = isHttpMethod;
 /**
  * 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
+ * @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
  */
-function isHttpMethod(method) {
+export function isHttpMethod(method) {
     return (method === 'get' ||
         method === 'post' ||
         method === 'put' ||

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

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNullableSchema = isNullableSchema;
 /**
  * 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`
+ * @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`
  */
-function isNullableSchema(schema) {
+export function isNullableSchema(schema) {
     return 'nullable' in schema && schema.nullable === true && Object.keys(schema).length === 1;
 }

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOperation = isOperation;
 /**
  * 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
+ * @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
@@ -12,6 +9,6 @@ exports.isOperation = isOperation;
  * ```
  * This would provide more strict type checking for arbitrary values.
  */
-function isOperation(obj) {
+export function isOperation(obj) {
     return obj && typeof obj === 'object' && 'responses' in obj;
 }

package/dist/core/validator/is-ref-object.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRefObject = isRefObject;
 /**
  * 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
+ * @param { unknown } value - The value to check
+ * @returns { boolean } true if the value is a reference object, false otherwise
  */
-function isRefObject(value) {
+export function isRefObject(value) {
     return typeof value === 'object' && value !== null;
 }

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

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSchemaReference = isSchemaReference;
 /**
  * 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
+ * @param { Schema } schema - The schema to check
+ * @returns { boolean } A boolean indicating if the schema is a reference
  */
-function isSchemaReference(schema) {
+export function isSchemaReference(schema) {
     return Boolean(schema.$ref);
 }

package/dist/core/validator/is-unique-content-schema.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUniqueContentSchema = isUniqueContentSchema;
 /**
  * Get unique content schema
- * @param {string[]} contentTypes - Content types
- * @param {Content} content - Content
- * @returns {boolean} Unique content schema
+ * @param { string[] } contentTypes - Content types
+ * @param { Content } content - Content
+ * @returns { boolean } Unique content schema
  */
-function isUniqueContentSchema(contentTypes, content) {
+export function isUniqueContentSchema(contentTypes, content) {
     const schema = new Set(contentTypes.map((type) => JSON.stringify(content?.[type].schema)));
     return schema.size === 1;
 }

package/dist/core/zod/get-zod-string-format.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getZodFormatString = getZodFormatString;
 /**
  * Mapping of OpenAPI formats to Zod validation methods
  *
@@ -61,6 +58,6 @@ const FORMAT_STRING_TO_ZOD_VALIDATION = {
  * - Returns empty string for unrecognized formats
  * - Used in schema generation for request/response validation
  */
-function getZodFormatString(format) {
+export function getZodFormatString(format) {
     return FORMAT_STRING_TO_ZOD_VALIDATION[format];
 }

package/dist/format/index.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatCode = formatCode;
-const prettier_1 = require("prettier");
+import { format } from 'prettier';
 /**
  * Formats TypeScript code using Prettier
  * @param { string } code - The TypeScript code to format
  * @returns { Promise<string> } The formatted code
  */
-async function formatCode(code) {
-    return await (0, prettier_1.format)(code, {
+export async function formatCode(code) {
+    return await format(code, {
         parser: 'typescript',
         printWidth: 100,
         singleQuote: true,

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

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateZodArray = generateZodArray;
 /**
  * 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)')
@@ -22,6 +19,6 @@ exports.generateZodArray = generateZodArray;
  * generateZodArray('z.object({ name: z.string() })')
  * // Returns: 'z.array(z.object({ name: z.string() }))'
  */
-function generateZodArray(zodSchema) {
+export function generateZodArray(zodSchema) {
     return `z.array(${zodSchema})`;
 }