@alagoni97/cli 0.72.1

package/dist/codegen/types.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodTheCodegenConfiguration = exports.zodJsonSchemaCodegenConfiguration = exports.zodJsonSchemaTypescriptConfig = exports.zodOpenAPICodegenConfiguration = exports.zodOpenAPITypescriptConfig = exports.zodAsyncAPICodegenConfiguration = exports.zodAsyncAPITypescriptConfig = exports.zodProjectTelemetryConfig = exports.zodImportExtension = exports.zodInputAuth = exports.zodJsonSchemaGenerators = exports.zodJsonSchemaTypeScriptGenerators = exports.zodOpenAPIGenerators = exports.zodOpenAPITypeScriptGenerators = exports.zodAsyncAPIGenerators = exports.zodAsyncAPITypeScriptGenerators = void 0;
+const channels_1 = require("./generators/typescript/channels");
+const parameters_1 = require("./generators/typescript/parameters");
+const payloads_1 = require("./generators/typescript/payloads");
+const custom_1 = require("./generators/generic/custom");
+const zod_1 = require("zod");
+const client_1 = require("./generators/typescript/client");
+const headers_1 = require("./generators/typescript/headers");
+const types_1 = require("./generators/typescript/types");
+const models_1 = require("./generators/typescript/models");
+const utils_1 = require("./utils");
+exports.zodAsyncAPITypeScriptGenerators = zod_1.z.discriminatedUnion('preset', [
+    payloads_1.zodTypeScriptPayloadGenerator,
+    parameters_1.zodTypescriptParametersGenerator,
+    channels_1.zodTypescriptChannelsGenerator,
+    client_1.zodTypescriptClientGenerator,
+    headers_1.zodTypescriptHeadersGenerator,
+    types_1.zodTypescriptTypesGenerator,
+    models_1.zodTypescriptModelsGenerator,
+    custom_1.zodCustomGenerator
+]);
+exports.zodAsyncAPIGenerators = zod_1.z.union([
+    ...exports.zodAsyncAPITypeScriptGenerators.options
+]);
+exports.zodOpenAPITypeScriptGenerators = zod_1.z.discriminatedUnion('preset', [
+    payloads_1.zodTypeScriptPayloadGenerator,
+    parameters_1.zodTypescriptParametersGenerator,
+    headers_1.zodTypescriptHeadersGenerator,
+    types_1.zodTypescriptTypesGenerator,
+    channels_1.zodTypescriptChannelsGenerator,
+    models_1.zodTypescriptModelsGenerator,
+    custom_1.zodCustomGenerator
+]);
+exports.zodOpenAPIGenerators = zod_1.z.union([
+    ...exports.zodOpenAPITypeScriptGenerators.options
+]);
+exports.zodJsonSchemaTypeScriptGenerators = zod_1.z.discriminatedUnion('preset', [models_1.zodTypescriptModelsGenerator, custom_1.zodCustomGenerator]);
+exports.zodJsonSchemaGenerators = zod_1.z.union([
+    ...exports.zodJsonSchemaTypeScriptGenerators.options
+]);
+const SCHEMA_DESCRIPTION = 'JSON Schema reference used by IDEs to enable auto-completion and validation in JSON and YAML configuration files. [Read more about configurations here](https://the-codegen-project.org/docs/configurations)';
+const LANGUAGE_DESCRIPTION = 'Sets the global language for all generators. Either this global value or each generator must define its own language. [Read more about configurations here](https://the-codegen-project.org/docs/configurations)';
+const DOCUMENT_TYPE_DESCRIPTION = 'The type of input document being processed (asyncapi, openapi, or jsonschema). [Read more about inputs here](https://the-codegen-project.org/docs/configurations)';
+const INPUT_PATH_DESCRIPTION = 'Path or URL to the input document used as the source for code generation. [Read more about configurations here](https://the-codegen-project.org/docs/configurations)';
+const GENERATORS_DESCRIPTION = 'The list of generators to run as part of this configuration. [Read more about generators here](https://the-codegen-project.org/docs/generators)';
+const INPUT_AUTH_DESCRIPTION = 'Authentication for fetching remote input specifications via http(s). Ignored for local file paths. ' +
+    'WARNING: these credentials are sent to every URL the loader fetches, including external $ref targets on other hosts. ' +
+    'See https://the-codegen-project.org/docs/configurations#auth-scope-and-security-considerations for details.';
+/**
+ * Authentication configuration for fetching remote input documents.
+ * One of three shapes:
+ *  - bearer: adds `Authorization: Bearer <token>`.
+ *  - apiKey: adds `<header>: <value>`.
+ *  - custom: adds the given headers verbatim.
+ *
+ * The same headers are attached to every URL the loader fetches,
+ * including external `$ref` targets on other hosts.
+ */
+exports.zodInputAuth = zod_1.z
+    .discriminatedUnion('type', [
+    zod_1.z.object({
+        type: zod_1.z.literal('bearer'),
+        token: zod_1.z.string().min(1)
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('apiKey'),
+        header: zod_1.z.string().min(1),
+        value: zod_1.z.string().min(1)
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('custom'),
+        headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string())
+    })
+])
+    .optional()
+    .describe(INPUT_AUTH_DESCRIPTION);
+// Re-export from utils - the canonical source of truth for import extension
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "zodImportExtension", { enumerable: true, get: function () { return utils_2.zodImportExtension; } });
+/**
+ * Project-level telemetry configuration
+ * Allows overriding global telemetry settings for specific projects
+ */
+exports.zodProjectTelemetryConfig = zod_1.z
+    .object({
+    enabled: zod_1.z
+        .boolean()
+        .optional()
+        .describe('Enable or disable anonymous telemetry collection for this project. Overrides the global telemetry setting in ~/.the-codegen-project/config.json. [Read more about telemetry here](https://the-codegen-project.org/docs/telemetry)'),
+    endpoint: zod_1.z
+        .string()
+        .optional()
+        .describe('Custom telemetry endpoint URL for self-hosted analytics. Overrides the global telemetry endpoint. [Read more about telemetry here](https://the-codegen-project.org/docs/telemetry)'),
+    trackingId: zod_1.z
+        .string()
+        .optional()
+        .describe('Custom tracking ID used to attribute telemetry events to a specific project or organization. Overrides the global tracking ID. [Read more about telemetry here](https://the-codegen-project.org/docs/telemetry)')
+})
+    .optional()
+    .describe('Project-level telemetry configuration that overrides the global settings in ~/.the-codegen-project/config.json. [Read more about telemetry here](https://the-codegen-project.org/docs/telemetry)');
+/**
+ * TypeScript-specific configuration options.
+ * These are only valid when language is 'typescript' (or omitted, defaulting to typescript).
+ */
+const zodTypeScriptConfigOptions = {
+    language: zod_1.z.literal('typescript').optional().describe(LANGUAGE_DESCRIPTION),
+    importExtension: utils_1.zodImportExtension
+};
+// =============================================================================
+// AsyncAPI Configuration
+// =============================================================================
+/**
+ * TypeScript configuration for AsyncAPI input.
+ * When other languages are added, this becomes part of a z.union([typescript, python, ...])
+ */
+exports.zodAsyncAPITypescriptConfig = zod_1.z.object({
+    $schema: zod_1.z.string().optional().describe(SCHEMA_DESCRIPTION),
+    inputType: zod_1.z.literal('asyncapi').describe(DOCUMENT_TYPE_DESCRIPTION),
+    inputPath: zod_1.z.string().describe(INPUT_PATH_DESCRIPTION),
+    auth: exports.zodInputAuth,
+    ...zodTypeScriptConfigOptions,
+    generators: zod_1.z
+        .array(exports.zodAsyncAPITypeScriptGenerators)
+        .describe(GENERATORS_DESCRIPTION),
+    telemetry: exports.zodProjectTelemetryConfig
+});
+// For now, only TypeScript is supported. When adding new languages:
+// export const zodAsyncAPICodegenConfiguration = z.union([
+//   zodAsyncAPITypescriptConfig,
+//   zodAsyncAPIPythonConfig,
+// ]);
+exports.zodAsyncAPICodegenConfiguration = exports.zodAsyncAPITypescriptConfig;
+// =============================================================================
+// OpenAPI Configuration
+// =============================================================================
+/**
+ * TypeScript configuration for OpenAPI input.
+ */
+exports.zodOpenAPITypescriptConfig = zod_1.z.object({
+    $schema: zod_1.z.string().optional().describe(SCHEMA_DESCRIPTION),
+    inputType: zod_1.z.literal('openapi').describe(DOCUMENT_TYPE_DESCRIPTION),
+    inputPath: zod_1.z.string().describe(INPUT_PATH_DESCRIPTION),
+    auth: exports.zodInputAuth,
+    ...zodTypeScriptConfigOptions,
+    generators: zod_1.z
+        .array(exports.zodOpenAPITypeScriptGenerators)
+        .describe(GENERATORS_DESCRIPTION),
+    telemetry: exports.zodProjectTelemetryConfig
+});
+// For now, only TypeScript is supported
+exports.zodOpenAPICodegenConfiguration = exports.zodOpenAPITypescriptConfig;
+// =============================================================================
+// JSON Schema Configuration
+// =============================================================================
+/**
+ * TypeScript configuration for JSON Schema input.
+ */
+exports.zodJsonSchemaTypescriptConfig = zod_1.z.object({
+    $schema: zod_1.z.string().optional().describe(SCHEMA_DESCRIPTION),
+    inputType: zod_1.z.literal('jsonschema').describe(DOCUMENT_TYPE_DESCRIPTION),
+    inputPath: zod_1.z.string().describe(INPUT_PATH_DESCRIPTION),
+    auth: exports.zodInputAuth,
+    ...zodTypeScriptConfigOptions,
+    generators: zod_1.z
+        .array(exports.zodJsonSchemaTypeScriptGenerators)
+        .describe(GENERATORS_DESCRIPTION),
+    telemetry: exports.zodProjectTelemetryConfig
+});
+// For now, only TypeScript is supported
+exports.zodJsonSchemaCodegenConfiguration = exports.zodJsonSchemaTypescriptConfig;
+exports.zodTheCodegenConfiguration = zod_1.z.discriminatedUnion('inputType', [
+    exports.zodAsyncAPICodegenConfiguration,
+    exports.zodOpenAPICodegenConfiguration,
+    exports.zodJsonSchemaCodegenConfiguration
+]);

package/dist/codegen/utils.d.ts

@@ -0,0 +1,126 @@
+import { ChannelInterface, OperationInterface, OperationReplyInterface } from '@asyncapi/parser';
+import { z } from 'zod';
+/**
+ * Deep partial type that does NOT partial function arguments.
+ */
+export type DeepPartial<T> = T extends Function ? T : T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/**
+ * Merge a non optional value with custom optional values to form a full value that has all properties sat.
+ */
+export declare function mergePartialAndDefault<T extends Record<string, any>>(defaultNonOptional: T, customOptional?: DeepPartial<T>): T;
+/**
+ * Find duplicates in array of objects based on property
+ */
+export declare function findDuplicatesInArray(array: any[], property: string): any[];
+/**
+ * Get OS type, abstracted away from special cases
+ */
+export declare function getOSType(): 'windows' | 'unix' | 'macos';
+/**
+ * Windows renders relative paths weird i.e. '\' instead of '/'
+ */
+export declare function ensureRelativePath(pathToCheck: string): string;
+/**
+ * Ensure array has unique values only.
+ */
+export declare function ensureUniqueValuesInArray(array: any[]): any[];
+export declare function findExtensionObject(parsedObj: any): any;
+export declare function findNameFromChannel(channel: ChannelInterface): string;
+export declare function findOperationId(operation: OperationInterface, channel: ChannelInterface): any;
+export declare function findNameFromOperation(operation: OperationInterface, channel: ChannelInterface): string;
+export declare function firstLowercase(name: string): string;
+export declare function findReplyId(operation: OperationInterface, reply: OperationReplyInterface, channel: ChannelInterface): string;
+/**
+ * Extract JSDoc metadata from an AsyncAPI operation.
+ * Returns description and deprecated flag for use in generated JSDoc comments.
+ */
+export declare function getOperationMetadata(operation: OperationInterface): {
+    description?: string;
+    deprecated?: boolean;
+};
+export declare function onlyUnique(array: any[]): any[];
+/**
+ * Shared Zod schema for import extension configuration.
+ * Used both globally (typescript.importExtension) and per-generator.
+ *
+ * - 'none': No extension (default, for bundlers and classic moduleResolution)
+ * - '.ts': Add .ts extension (for moduleResolution: "node16"/"nodenext" with allowImportingTsExtensions)
+ * - '.js': Add .js extension (for compiled ESM output)
+ */
+export declare const zodImportExtension: z.ZodOptional<z.ZodEnum<[".ts", ".js", "none"]>>;
+/**
+ * Import extension type for TypeScript imports.
+ * - 'none': No extension added (default, for bundlers and classic moduleResolution)
+ * - '.ts': Add .ts extension (for moduleResolution: "node16" / "nodenext" with allowImportingTsExtensions)
+ * - '.js': Add .js extension (for compiled ESM output)
+ */
+export type ImportExtension = 'none' | '.ts' | '.js';
+/**
+ * Appends file extension to import path based on configuration.
+ * Used to support modern TypeScript moduleResolution settings like "node16" or "nodenext"
+ * which require explicit file extensions in import statements.
+ *
+ * @param importPath - The relative import path (e.g., './payloads/User')
+ * @param extension - The extension to append ('none', '.ts', or '.js')
+ * @returns The import path with extension appended (or unchanged if 'none')
+ *
+ * @example
+ * appendImportExtension('./payloads/User', '.ts') // => './payloads/User.ts'
+ * appendImportExtension('./payloads/User', 'none') // => './payloads/User'
+ */
+export declare function appendImportExtension(importPath: string, extension: ImportExtension): string;
+/**
+ * Resolves the effective import extension from generator config or global config.
+ * Priority: generator.importExtension > config.importExtension > 'none'
+ *
+ * @param generator - Generator configuration that may have importExtension override
+ * @param config - Global configuration that may have importExtension (optional)
+ * @returns The resolved import extension ('none', '.ts', or '.js')
+ *
+ * @example
+ * // Generator override takes precedence
+ * resolveImportExtension({importExtension: '.js'}, {importExtension: '.ts'})
+ * // => '.js'
+ *
+ * // Falls back to global config
+ * resolveImportExtension({}, {importExtension: '.ts'})
+ * // => '.ts'
+ *
+ * // Defaults to 'none' for backward compatibility
+ * resolveImportExtension({}, {})
+ * // => 'none'
+ */
+export declare function resolveImportExtension(generator: {
+    importExtension?: ImportExtension;
+}, config?: {
+    importExtension?: ImportExtension;
+}): ImportExtension;
+/**
+ * Portable path join function that works in both Node.js and browser environments.
+ * Joins path segments with forward slashes and normalizes the result.
+ *
+ * @param segments - Path segments to join
+ * @returns Joined path with normalized slashes
+ *
+ * @example
+ * joinPath('src/models', 'User.ts') // => 'src/models/User.ts'
+ * joinPath('src/models/', '/User.ts') // => 'src/models/User.ts'
+ * joinPath('./src', './models', 'User.ts') // => './src/models/User.ts'
+ */
+export declare function joinPath(...segments: string[]): string;
+/**
+ * Portable relative path function that works in both Node.js and browser environments.
+ * Computes the relative path from one location to another.
+ *
+ * @param from - The starting directory path
+ * @param to - The target path
+ * @returns Relative path from 'from' to 'to'
+ *
+ * @example
+ * relativePath('src/channels', 'src/models/User') // => '../models/User'
+ * relativePath('src/a/b', 'src/a/c') // => '../c'
+ * relativePath('src/models', 'src/models/User') // => 'User'
+ */
+export declare function relativePath(from: string, to: string): string;

package/dist/codegen/utils.js

@@ -0,0 +1,373 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* eslint-disable security/detect-object-injection */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativePath = exports.joinPath = exports.resolveImportExtension = exports.appendImportExtension = exports.zodImportExtension = exports.onlyUnique = exports.getOperationMetadata = exports.findReplyId = exports.firstLowercase = exports.findNameFromOperation = exports.findOperationId = exports.findNameFromChannel = exports.findExtensionObject = exports.ensureUniqueValuesInArray = exports.ensureRelativePath = exports.getOSType = exports.findDuplicatesInArray = exports.mergePartialAndDefault = void 0;
+const process_1 = require("process");
+const utils_1 = require("./generators/typescript/utils");
+const zod_1 = require("zod");
+/**
+ * Return true or false based on whether the input object is a regular object or a class
+ *
+ * Taken from: https://stackoverflow.com/a/43197340/6803886
+ * @param obj
+ */
+function isClass(obj) {
+    const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === 'class';
+    if (obj.prototype === undefined) {
+        return isCtorClass;
+    }
+    const isPrototypeCtorClass = obj.prototype.constructor &&
+        obj.prototype.constructor.toString &&
+        obj.prototype.constructor.toString().substring(0, 5) === 'class';
+    return isCtorClass || isPrototypeCtorClass;
+}
+/**
+ * Merge a non optional value with custom optional values to form a full value that has all properties sat.
+ */
+function mergePartialAndDefault(defaultNonOptional, customOptional) {
+    if (customOptional === undefined) {
+        return Object.assign({}, defaultNonOptional);
+    }
+    // create a new object
+    const target = Object.assign({}, defaultNonOptional);
+    // deep merge the object into the target object
+    for (const [propName, prop] of Object.entries(customOptional)) {
+        const isObjectOrClass = typeof prop === 'object' && target[propName] !== undefined;
+        const isRegularObject = !isClass(prop);
+        const isArray = Array.isArray(prop);
+        if (isArray) {
+            // merge array into target with a new array instance so we dont touch the default value
+            target[propName] = ensureUniqueValuesInArray([
+                ...(target[propName] ?? []),
+                ...(prop ?? [])
+            ]);
+        }
+        else if (isObjectOrClass && isRegularObject) {
+            target[propName] = mergePartialAndDefault(target[propName], prop);
+        }
+        else if (prop) {
+            target[propName] = prop;
+        }
+    }
+    return target;
+}
+exports.mergePartialAndDefault = mergePartialAndDefault;
+/**
+ * Find duplicates in array of objects based on property
+ */
+function findDuplicatesInArray(array, property) {
+    const foundValues = array.map((generator) => {
+        return generator[property];
+    });
+    const duplicates = foundValues.filter((item, index) => foundValues.indexOf(item) !== index);
+    return Array.from(new Set(duplicates));
+}
+exports.findDuplicatesInArray = findDuplicatesInArray;
+/**
+ * Get OS type, abstracted away from special cases
+ */
+function getOSType() {
+    if (process_1.platform === 'win32') {
+        return 'windows';
+    }
+    if (process_1.platform === 'darwin') {
+        return 'macos';
+    }
+    return 'unix';
+}
+exports.getOSType = getOSType;
+/**
+ * Windows renders relative paths weird i.e. '\' instead of '/'
+ */
+function ensureRelativePath(pathToCheck) {
+    if (getOSType() === 'windows') {
+        return pathToCheck.replace(/\\/g, '/');
+    }
+    return pathToCheck;
+}
+exports.ensureRelativePath = ensureRelativePath;
+/**
+ * Ensure array has unique values only.
+ */
+function ensureUniqueValuesInArray(array) {
+    return array.filter((value, index, filteredArray) => {
+        return filteredArray.indexOf(value) === index;
+    });
+}
+exports.ensureUniqueValuesInArray = ensureUniqueValuesInArray;
+function findExtensionObject(parsedObj) {
+    return parsedObj?.extensions()?.get('x-the-codegen-project')?.value();
+}
+exports.findExtensionObject = findExtensionObject;
+function findNameFromChannel(channel) {
+    const channelId = channel.id();
+    const userSpecificName = findExtensionObject(channel)
+        ? findExtensionObject(channel)['channelName']
+        : undefined;
+    if (userSpecificName) {
+        return userSpecificName;
+    }
+    return (0, utils_1.pascalCase)(channelId.replace(/\W/g, ' '));
+}
+exports.findNameFromChannel = findNameFromChannel;
+function findOperationId(operation, channel) {
+    const userSpecificName = findExtensionObject(operation)
+        ? findExtensionObject(operation)['channelName']
+        : undefined;
+    if (userSpecificName) {
+        return userSpecificName;
+    }
+    let operationId = operation.id();
+    operationId = operation.hasOperationId()
+        ? operation.operationId()
+        : operationId;
+    return operationId ?? channel.id();
+}
+exports.findOperationId = findOperationId;
+function findNameFromOperation(operation, channel) {
+    const operationId = findOperationId(operation, channel);
+    return (0, utils_1.pascalCase)(operationId.replace(/\W/g, ' '));
+}
+exports.findNameFromOperation = findNameFromOperation;
+function firstLowercase(name) {
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+exports.firstLowercase = firstLowercase;
+function findReplyId(operation, reply, channel) {
+    return `${findOperationId(operation, reply.channel() ?? channel)}_reply`;
+}
+exports.findReplyId = findReplyId;
+/**
+ * Extract JSDoc metadata from an AsyncAPI operation.
+ * Returns description and deprecated flag for use in generated JSDoc comments.
+ */
+function getOperationMetadata(operation) {
+    // Get description - prefer description() over summary()
+    let description;
+    if (operation.hasDescription()) {
+        description = operation.description();
+    }
+    else if (operation.hasSummary()) {
+        description = operation.summary();
+    }
+    // Check if operation is deprecated - access from raw JSON since no typed method exists
+    // The parser doesn't expose a deprecated() method, but the raw JSON contains it
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const rawJson = operation.json?.() ?? operation._json;
+    const deprecated = rawJson?.deprecated === true;
+    return { description, deprecated };
+}
+exports.getOperationMetadata = getOperationMetadata;
+function onlyUnique(array) {
+    const onlyUnique = (value, index, array) => {
+        return array.indexOf(value) === index;
+    };
+    return array.filter(onlyUnique);
+}
+exports.onlyUnique = onlyUnique;
+/**
+ * Shared Zod schema for import extension configuration.
+ * Used both globally (typescript.importExtension) and per-generator.
+ *
+ * - 'none': No extension (default, for bundlers and classic moduleResolution)
+ * - '.ts': Add .ts extension (for moduleResolution: "node16"/"nodenext" with allowImportingTsExtensions)
+ * - '.js': Add .js extension (for compiled ESM output)
+ */
+exports.zodImportExtension = zod_1.z
+    .enum(['.ts', '.js', 'none'])
+    .optional()
+    .describe('File extension appended to relative import paths. Use ".ts" for moduleResolution: "node16"/"nodenext" with allowImportingTsExtensions, ".js" for compiled ESM output, or "none" (default) for bundlers and classic Node.js resolution. [Read more about import extensions here](https://the-codegen-project.org/docs/configurations)');
+/**
+ * Appends file extension to import path based on configuration.
+ * Used to support modern TypeScript moduleResolution settings like "node16" or "nodenext"
+ * which require explicit file extensions in import statements.
+ *
+ * @param importPath - The relative import path (e.g., './payloads/User')
+ * @param extension - The extension to append ('none', '.ts', or '.js')
+ * @returns The import path with extension appended (or unchanged if 'none')
+ *
+ * @example
+ * appendImportExtension('./payloads/User', '.ts') // => './payloads/User.ts'
+ * appendImportExtension('./payloads/User', 'none') // => './payloads/User'
+ */
+function appendImportExtension(importPath, extension) {
+    if (extension === 'none') {
+        return importPath;
+    }
+    return `${importPath}${extension}`;
+}
+exports.appendImportExtension = appendImportExtension;
+/**
+ * Resolves the effective import extension from generator config or global config.
+ * Priority: generator.importExtension > config.importExtension > 'none'
+ *
+ * @param generator - Generator configuration that may have importExtension override
+ * @param config - Global configuration that may have importExtension (optional)
+ * @returns The resolved import extension ('none', '.ts', or '.js')
+ *
+ * @example
+ * // Generator override takes precedence
+ * resolveImportExtension({importExtension: '.js'}, {importExtension: '.ts'})
+ * // => '.js'
+ *
+ * // Falls back to global config
+ * resolveImportExtension({}, {importExtension: '.ts'})
+ * // => '.ts'
+ *
+ * // Defaults to 'none' for backward compatibility
+ * resolveImportExtension({}, {})
+ * // => 'none'
+ */
+function resolveImportExtension(generator, config) {
+    return generator.importExtension ?? config?.importExtension ?? 'none';
+}
+exports.resolveImportExtension = resolveImportExtension;
+/**
+ * Portable path join function that works in both Node.js and browser environments.
+ * Joins path segments with forward slashes and normalizes the result.
+ *
+ * @param segments - Path segments to join
+ * @returns Joined path with normalized slashes
+ *
+ * @example
+ * joinPath('src/models', 'User.ts') // => 'src/models/User.ts'
+ * joinPath('src/models/', '/User.ts') // => 'src/models/User.ts'
+ * joinPath('./src', './models', 'User.ts') // => './src/models/User.ts'
+ */
+function joinPath(...segments) {
+    // Filter out empty segments
+    const filtered = segments.filter((s) => s !== '');
+    if (filtered.length === 0) {
+        return '';
+    }
+    // Join all segments, preserving leading ./ if present
+    const preserveLeadingDot = filtered[0].startsWith('./');
+    const preserveLeadingSlash = filtered[0].startsWith('/');
+    // Join and normalize
+    const joined = filtered
+        .map((segment, index) => {
+        // Remove leading slash from non-first segments
+        if (index > 0 && segment.startsWith('/')) {
+            segment = segment.slice(1);
+        }
+        // Remove leading ./ from non-first segments
+        if (index > 0 && segment.startsWith('./')) {
+            segment = segment.slice(2);
+        }
+        // Remove trailing slash from all but last segment
+        if (index < filtered.length - 1 && segment.endsWith('/')) {
+            segment = segment.slice(0, -1);
+        }
+        return segment;
+    })
+        .join('/');
+    // Normalize multiple slashes
+    let result = joined.replace(/\/+/g, '/');
+    // Restore leading pattern if needed
+    if (preserveLeadingDot && !result.startsWith('./')) {
+        result = `./${result}`;
+    }
+    else if (preserveLeadingSlash && !result.startsWith('/')) {
+        result = `/${result}`;
+    }
+    return result;
+}
+exports.joinPath = joinPath;
+/**
+ * Checks if a path is absolute (starts with drive letter or /)
+ */
+function isAbsolutePath(p) {
+    // Windows drive letter (C:/) or Unix absolute (/)
+    return /^[a-zA-Z]:[\\/]/.test(p) || p.startsWith('/');
+}
+/**
+ * Returns the current working directory in Node environments, or undefined
+ * in browser environments where no such concept exists.
+ */
+function getNodeCwd() {
+    // eslint-disable-next-line no-undef
+    const g = globalThis;
+    const proc = g.process;
+    if (proc && typeof proc.cwd === 'function') {
+        return proc.cwd().replace(/\\/g, '/');
+    }
+    return undefined;
+}
+/**
+ * Portable relative path function that works in both Node.js and browser environments.
+ * Computes the relative path from one location to another.
+ *
+ * @param from - The starting directory path
+ * @param to - The target path
+ * @returns Relative path from 'from' to 'to'
+ *
+ * @example
+ * relativePath('src/channels', 'src/models/User') // => '../models/User'
+ * relativePath('src/a/b', 'src/a/c') // => '../c'
+ * relativePath('src/models', 'src/models/User') // => 'User'
+ */
+function relativePath(from, to) {
+    // Normalize Windows backslashes to forward slashes first
+    const normalizedFrom = from.replace(/\\/g, '/');
+    const normalizedTo = to.replace(/\\/g, '/');
+    const fromIsAbsolute = isAbsolutePath(normalizedFrom);
+    const toIsAbsolute = isAbsolutePath(normalizedTo);
+    // Handle mixed absolute/relative paths by resolving the relative one
+    // against the current working directory (Node). This mirrors
+    // `path.relative`, giving a deterministic result that doesn't depend on
+    // the depth of the absolute path from the filesystem root.
+    const cwd = getNodeCwd();
+    if (fromIsAbsolute !== toIsAbsolute && cwd !== undefined) {
+        const resolvedFrom = fromIsAbsolute
+            ? normalizedFrom
+            : joinPath(cwd, normalizedFrom);
+        const resolvedTo = toIsAbsolute
+            ? normalizedTo
+            : joinPath(cwd, normalizedTo);
+        return relativePath(resolvedFrom, resolvedTo);
+    }
+    // Fallback for browser: strip any absolute prefix so the two paths can be
+    // compared as relative paths (CWD-dependent, but browsers shouldn't see
+    // real absolute filesystem paths).
+    if (fromIsAbsolute && !toIsAbsolute) {
+        const fromWithoutRoot = normalizedFrom
+            .replace(/^[a-zA-Z]:\//, '')
+            .replace(/^\//, '');
+        return relativePath(fromWithoutRoot, normalizedTo);
+    }
+    if (!fromIsAbsolute && toIsAbsolute) {
+        const toWithoutRoot = normalizedTo
+            .replace(/^[a-zA-Z]:\//, '')
+            .replace(/^\//, '');
+        return relativePath(normalizedFrom, toWithoutRoot);
+    }
+    // Normalize paths: remove leading ./ and trailing /
+    const normFrom = normalizedFrom.replace(/^\.\//, '').replace(/\/$/, '');
+    const normTo = normalizedTo.replace(/^\.\//, '').replace(/\/$/, '');
+    const fromParts = normFrom.split('/').filter((p) => p !== '');
+    const toParts = normTo.split('/').filter((p) => p !== '');
+    // Find common prefix length
+    let commonLength = 0;
+    const minLength = Math.min(fromParts.length, toParts.length);
+    for (let i = 0; i < minLength; i++) {
+        if (fromParts[i] === toParts[i]) {
+            commonLength++;
+        }
+        else {
+            break;
+        }
+    }
+    // Number of directories to go up from 'from'
+    const upCount = fromParts.length - commonLength;
+    // Remaining path in 'to' after common prefix
+    const remainingTo = toParts.slice(commonLength);
+    // Build relative path
+    const upParts = Array(upCount).fill('..');
+    const relativeParts = [...upParts, ...remainingTo];
+    if (relativeParts.length === 0) {
+        return '.';
+    }
+    return relativeParts.join('/');
+}
+exports.relativePath = relativePath;