@navios/adapter-xml 0.1.0

package/lib/_tsup-dts-rollup.d.ts

@@ -0,0 +1,414 @@
+import type { AbstractHttpHandlerAdapterInterface } from '@navios/core';
+import type { AnyInjectableType } from '@navios/di';
+import type { BaseStreamConfig } from '@navios/builder';
+import type { ClassType } from '@navios/di';
+import { Container } from '@navios/di';
+import type { EndpointFunctionArgs } from '@navios/builder';
+import type { HandlerMetadata } from '@navios/core';
+import type { HttpMethod } from '@navios/builder';
+import { InjectionToken } from '@navios/di';
+import type { Registry } from '@navios/di';
+import type { RequestContextHolder } from '@navios/di';
+import type { Util_FlatObject } from '@navios/builder';
+import type { z } from 'zod/v4';
+import type { ZodObject } from 'zod/v4';
+import type { ZodRawShape } from 'zod/v4';
+import type { ZodType } from 'zod/v4';
+
+/** Union type for all possible node types */
+declare type AnyXmlNode = XmlNode | AsyncXmlNode | CDataNode | RawXmlNode | ClassComponentNode | string | number | null | undefined;
+export { AnyXmlNode }
+export { AnyXmlNode as AnyXmlNode_alias_1 }
+export { AnyXmlNode as AnyXmlNode_alias_2 }
+
+declare const AsyncComponent: unique symbol;
+export { AsyncComponent }
+export { AsyncComponent as AsyncComponent_alias_1 }
+export { AsyncComponent as AsyncComponent_alias_2 }
+
+declare type AsyncComponentFn = (props: any) => Promise<XmlNode | AsyncXmlNode | ClassComponentNode>;
+
+/** Represents an async component that needs to be resolved before rendering */
+declare interface AsyncXmlNode {
+    type: typeof AsyncComponent;
+    promise: Promise<AnyXmlNode>;
+}
+export { AsyncXmlNode }
+export { AsyncXmlNode as AsyncXmlNode_alias_1 }
+export { AsyncXmlNode as AsyncXmlNode_alias_2 }
+
+declare interface BaseXmlStreamConfig<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = undefined> extends BaseStreamConfig<Method, Url, QuerySchema, RequestSchema> {
+    /** Content-Type header, defaults to 'application/xml' */
+    contentType?: 'application/xml' | 'text/xml' | 'application/rss+xml' | 'application/atom+xml';
+    /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
+    xmlDeclaration?: boolean;
+    /** XML encoding, defaults to 'UTF-8' */
+    encoding?: string;
+}
+export { BaseXmlStreamConfig }
+export { BaseXmlStreamConfig as BaseXmlStreamConfig_alias_1 }
+export { BaseXmlStreamConfig as BaseXmlStreamConfig_alias_2 }
+
+/**
+ * CDATA component - wraps content in <![CDATA[...]]>
+ * Use for text content that may contain characters like < > &
+ * that would otherwise need escaping.
+ *
+ * Note: If content contains "]]>", it will be split into multiple CDATA sections.
+ */
+declare function CData({ children }: {
+    children: string;
+}): CDataNode;
+export { CData }
+export { CData as CData_alias_1 }
+export { CData as CData_alias_2 }
+
+/** Represents a CDATA section - content is wrapped in <![CDATA[...]]> */
+declare interface CDataNode {
+    type: typeof CDataSymbol;
+    content: string;
+}
+export { CDataNode }
+export { CDataNode as CDataNode_alias_1 }
+export { CDataNode as CDataNode_alias_2 }
+
+declare const CDataSymbol: unique symbol;
+export { CDataSymbol }
+export { CDataSymbol as CDataSymbol_alias_1 }
+export { CDataSymbol as CDataSymbol_alias_2 }
+
+declare const ClassComponent: unique symbol;
+export { ClassComponent }
+export { ClassComponent as ClassComponent_alias_1 }
+export { ClassComponent as ClassComponent_alias_2 }
+
+/** Represents a class component that needs to be resolved via DI */
+declare interface ClassComponentNode {
+    type: typeof ClassComponent;
+    componentClass: ComponentClass;
+    props: Record<string, unknown>;
+}
+export { ClassComponentNode }
+export { ClassComponentNode as ClassComponentNode_alias_1 }
+export { ClassComponentNode as ClassComponentNode_alias_2 }
+
+declare function Component(): <T extends ComponentClass>(target: T, context?: ClassDecoratorContext) => T;
+
+declare function Component<Schema extends ZodObject<ZodRawShape>>(options: {
+    schema: Schema;
+    registry?: Registry;
+}): <T extends new (props: z.output<Schema>, ...args: any[]) => XmlComponent>(target: T, context?: ClassDecoratorContext) => T;
+
+declare function Component(options: {
+    registry: Registry;
+}): <T extends ComponentClass>(target: T, context?: ClassDecoratorContext) => T;
+export { Component }
+export { Component as Component_alias_1 }
+export { Component as Component_alias_2 }
+
+/**
+ * Type for class component constructors.
+ */
+declare interface ComponentClass {
+    new (...args: any[]): XmlComponent;
+}
+export { ComponentClass }
+export { ComponentClass as ComponentClass_alias_1 }
+export { ComponentClass as ComponentClass_alias_2 }
+
+declare const ComponentMeta: unique symbol;
+export { ComponentMeta }
+export { ComponentMeta as ComponentMeta_alias_1 }
+
+declare type ComponentType = FunctionalComponent | ComponentClass;
+
+/**
+ * Classic createElement for manual usage.
+ * Children are passed as rest arguments.
+ */
+declare function createElement(type: string | typeof Fragment | ComponentType, props: Record<string, unknown> | null, ...children: any[]): XmlNode | AsyncXmlNode | ClassComponentNode;
+export { createElement }
+export { createElement as createElement_alias_1 }
+export { createElement as createElement_alias_2 }
+
+/**
+ * DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping
+ *
+ * WARNING: This bypasses all XML escaping. Only use with trusted content!
+ * Use cases:
+ * - Pre-rendered XML fragments
+ * - HTML content in RSS/Atom feeds (in description/content:encoded)
+ * - Including XML from external sources that's already valid
+ */
+declare function DangerouslyInsertRawXml({ children }: {
+    children: string;
+}): RawXmlNode;
+export { DangerouslyInsertRawXml }
+export { DangerouslyInsertRawXml as DangerouslyInsertRawXml_alias_1 }
+export { DangerouslyInsertRawXml as DangerouslyInsertRawXml_alias_2 }
+
+/**
+ * Declares an XML Stream endpoint configuration for use with @XmlStream decorator.
+ *
+ * @example
+ * ```typescript
+ * import { declareXmlStream } from '@navios/adapter-xml'
+ *
+ * export const getRssFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   querySchema: undefined,
+ *   requestSchema: undefined,
+ *   contentType: 'application/rss+xml',
+ *   xmlDeclaration: true,
+ * })
+ * ```
+ */
+declare function declareXmlStream<Method extends HttpMethod, Url extends string, QuerySchema = undefined, RequestSchema = undefined>(config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>): {
+    config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+};
+export { declareXmlStream }
+export { declareXmlStream as declareXmlStream_alias_1 }
+export { declareXmlStream as declareXmlStream_alias_2 }
+
+/**
+ * Creates a type-safe XML tag component with optional Zod schema validation.
+ *
+ * @param name - The tag name (supports namespace prefixes like 'atom:link')
+ * @param propsSchema - Optional Zod schema for validating props
+ * @returns A component function that can be used in JSX
+ *
+ * @example
+ * ```tsx
+ * // Simple tag
+ * const item = defineTag('item')
+ * <item>Content</item>
+ *
+ * // Namespaced tag with Zod validation
+ * const atomLink = defineTag('atom:link', z.object({
+ *   href: z.string().url(),
+ *   rel: z.enum(['self', 'alternate']),
+ *   type: z.string().optional(),
+ * }))
+ * <atomLink href="https://example.com/feed" rel="self" />
+ * ```
+ */
+declare function defineTag<T extends ZodRawShape>(name: string, propsSchema?: ZodObject<T>): TagComponent<T extends ZodRawShape ? z.infer<ZodObject<T>> : Record<string, never>>;
+export { defineTag }
+export { defineTag as defineTag_alias_1 }
+export { defineTag as defineTag_alias_2 }
+
+/**
+ * Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).
+ *
+ * @example
+ * ```typescript
+ * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+ * import { defineXmlEnvironment } from '@navios/adapter-xml'
+ * import { NaviosFactory } from '@navios/core'
+ *
+ * const fastifyEnv = defineFastifyEnvironment()
+ * const xmlEnv = defineXmlEnvironment()
+ *
+ * // Merge environments
+ * const mergedEnv = {
+ *   httpTokens: new Map([
+ *     ...fastifyEnv.httpTokens,
+ *     ...xmlEnv.httpTokens,
+ *   ]),
+ * }
+ *
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: mergedEnv,
+ * })
+ * ```
+ */
+declare function defineXmlEnvironment(): {
+    httpTokens: Map<InjectionToken<any, undefined, false>, AnyInjectableType>;
+};
+export { defineXmlEnvironment }
+export { defineXmlEnvironment as defineXmlEnvironment_alias_1 }
+
+declare const Fragment: unique symbol;
+export { Fragment }
+export { Fragment as Fragment_alias_1 }
+export { Fragment as Fragment_alias_2 }
+export { Fragment as Fragment_alias_3 }
+export { Fragment as Fragment_alias_4 }
+export { Fragment as Fragment_alias_5 }
+export { Fragment as Fragment_alias_6 }
+export { Fragment as Fragment_alias_7 }
+
+declare type FunctionalComponent = SyncComponent | AsyncComponentFn;
+
+/**
+ * Type guard to check if a class is a component
+ */
+declare function isComponentClass(value: unknown): value is ComponentClass;
+export { isComponentClass }
+export { isComponentClass as isComponentClass_alias_1 }
+export { isComponentClass as isComponentClass_alias_2 }
+
+/**
+ * JSX automatic runtime function.
+ * Used by the JSX transformer when jsxImportSource is set.
+ * Children are passed as part of props.children.
+ */
+declare function jsx(type: string | typeof Fragment | ComponentType, props: Record<string, unknown> | null): XmlNode | AsyncXmlNode | ClassComponentNode;
+export { jsx }
+export { jsx as jsx_alias_1 }
+export { jsx as jsx_alias_2 }
+
+export declare const jsxDEV: typeof jsx;
+
+/**
+ * JSX automatic runtime function for static children.
+ * Identical to jsx() for XML - React uses this for optimization hints.
+ */
+declare const jsxs: typeof jsx;
+export { jsxs }
+export { jsxs as jsxs_alias_1 }
+export { jsxs as jsxs_alias_2 }
+
+declare class MissingContainerError extends Error {
+    constructor(componentName: string);
+}
+export { MissingContainerError }
+export { MissingContainerError as MissingContainerError_alias_1 }
+export { MissingContainerError as MissingContainerError_alias_2 }
+
+/** Represents raw XML content - inserted without any escaping or wrapping */
+declare interface RawXmlNode {
+    type: typeof RawXmlSymbol;
+    content: string;
+}
+export { RawXmlNode }
+export { RawXmlNode as RawXmlNode_alias_1 }
+export { RawXmlNode as RawXmlNode_alias_2 }
+
+declare const RawXmlSymbol: unique symbol;
+export { RawXmlSymbol }
+export { RawXmlSymbol as RawXmlSymbol_alias_1 }
+export { RawXmlSymbol as RawXmlSymbol_alias_2 }
+
+declare interface RenderOptions {
+    /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
+    declaration?: boolean;
+    /** XML encoding, defaults to 'UTF-8' */
+    encoding?: string;
+    /** Pretty print with indentation */
+    pretty?: boolean;
+    /**
+     * DI container for resolving class components.
+     * Required if the tree contains any class components.
+     */
+    container?: Container;
+}
+export { RenderOptions }
+export { RenderOptions as RenderOptions_alias_1 }
+export { RenderOptions as RenderOptions_alias_2 }
+
+declare function renderToXml(node: AnyXmlNode, options?: RenderOptions): Promise<string>;
+export { renderToXml }
+export { renderToXml as renderToXml_alias_1 }
+export { renderToXml as renderToXml_alias_2 }
+
+declare type SyncComponent = (props: any) => XmlNode | AsyncXmlNode | ClassComponentNode;
+
+declare interface TagComponent<Props extends Record<string, unknown>> {
+    (props: Props & {
+        children?: AnyXmlNode | AnyXmlNode[];
+    }): XmlNode;
+    tagName: string;
+}
+export { TagComponent }
+export { TagComponent as TagComponent_alias_1 }
+export { TagComponent as TagComponent_alias_2 }
+
+/**
+ * Base interface for class components.
+ * The render method takes no arguments - props are received via constructor.
+ */
+declare interface XmlComponent {
+    render(): AnyXmlNode | Promise<AnyXmlNode>;
+}
+export { XmlComponent }
+export { XmlComponent as XmlComponent_alias_1 }
+export { XmlComponent as XmlComponent_alias_2 }
+
+declare interface XmlNode {
+    type: string | typeof Fragment;
+    props: Record<string, unknown>;
+    children: AnyXmlNode[];
+}
+export { XmlNode }
+export { XmlNode as XmlNode_alias_1 }
+export { XmlNode as XmlNode_alias_2 }
+
+/**
+ * Decorator for XML Stream endpoints that return JSX-based XML responses.
+ *
+ * @example
+ * ```typescript
+ * import { XmlStream } from '@navios/adapter-xml'
+ * import { Controller } from '@navios/core'
+ *
+ * const getRssFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   querySchema: undefined,
+ *   requestSchema: undefined,
+ *   contentType: 'application/rss+xml',
+ * })
+ *
+ * @Controller('/api')
+ * class FeedController {
+ *   @XmlStream(getRssFeed)
+ *   async getFeed() {
+ *     return (
+ *       <rss version="2.0">
+ *         <channel>
+ *           <title>My Feed</title>
+ *         </channel>
+ *       </rss>
+ *     )
+ *   }
+ * }
+ * ```
+ */
+declare function XmlStream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType>(endpoint: {
+    config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+}): (target: (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>) => Promise<any>, // Returns XmlNode
+context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>) => Promise<any>;
+export { XmlStream }
+export { XmlStream as XmlStream_alias_1 }
+export { XmlStream as XmlStream_alias_2 }
+
+declare class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {
+    protected container: Container;
+    /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */
+    protected streamAdapter: AbstractHttpHandlerAdapterInterface;
+    /**
+     * Proxy to base StreamAdapter - reuses existing argument preparation logic
+     * (handles querySchema, requestSchema, URL params for both Fastify and Bun)
+     */
+    prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): ((target: Record<string, any>, request: any) => Promise<void> | void)[];
+    provideSchema(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): Record<string, any>;
+    hasSchema(handlerMetadata: HandlerMetadata<any>): boolean;
+    /**
+     * Custom handler - renders JSX to XML and handles response for both Fastify and Bun
+     */
+    provideHandler(controller: ClassType, handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): (context: RequestContextHolder, request: any, reply: any) => Promise<any>;
+}
+export { XmlStreamAdapterService }
+export { XmlStreamAdapterService as XmlStreamAdapterService_alias_1 }
+export { XmlStreamAdapterService as XmlStreamAdapterService_alias_2 }
+
+declare type XmlStreamParams<EndpointDeclaration extends {
+    config: BaseXmlStreamConfig<any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends ZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>;
+export { XmlStreamParams }
+export { XmlStreamParams as XmlStreamParams_alias_1 }
+export { XmlStreamParams as XmlStreamParams_alias_2 }
+
+export { }

package/lib/chunk-6OR6LGJA.mjs

@@ -0,0 +1,153 @@
+import { InjectionToken, globalRegistry, InjectableScope, InjectableType, InjectableTokenMeta } from '@navios/di';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/types/xml-node.mts
+var Fragment = /* @__PURE__ */ Symbol.for("xml.fragment");
+var AsyncComponent = /* @__PURE__ */ Symbol.for("xml.async");
+var CDataSymbol = /* @__PURE__ */ Symbol.for("xml.cdata");
+var RawXmlSymbol = /* @__PURE__ */ Symbol.for("xml.raw");
+var ClassComponent = /* @__PURE__ */ Symbol.for("xml.class-component");
+var ComponentMeta = /* @__PURE__ */ Symbol.for("xml.component.meta");
+function Component(options = {}) {
+  const { schema, registry = globalRegistry } = options;
+  return (target, context) => {
+    if (context && context.kind !== "class" || target instanceof Function && !context) {
+      throw new Error(
+        "[@navios/adapter-xml] @Component decorator can only be used on classes."
+      );
+    }
+    if (typeof target.prototype.render !== "function") {
+      throw new Error(
+        `[@navios/adapter-xml] @Component class "${target.name}" must implement render() method.`
+      );
+    }
+    const injectableToken = schema ? InjectionToken.create(target, schema) : InjectionToken.create(target);
+    registry.set(
+      injectableToken,
+      InjectableScope.Request,
+      target,
+      InjectableType.Class
+    );
+    target[InjectableTokenMeta] = injectableToken;
+    target[ComponentMeta] = true;
+    return target;
+  };
+}
+function isComponentClass(value) {
+  return typeof value === "function" && // @ts-expect-error - Checking metadata
+  value[ComponentMeta] === true;
+}
+
+// src/runtime/create-element.mts
+function flattenChildren(children) {
+  if (children == null || children === false) {
+    return [];
+  }
+  if (Array.isArray(children)) {
+    return children.flat(Infinity).filter((c) => c != null && c !== false);
+  }
+  return [children];
+}
+function jsx(type, props) {
+  const { children, ...restProps } = props ?? {};
+  const flatChildren = flattenChildren(children);
+  if (isComponentClass(type)) {
+    return {
+      type: ClassComponent,
+      componentClass: type,
+      props: { ...restProps, children: flatChildren }
+    };
+  }
+  if (typeof type === "function") {
+    const result = type({ ...restProps, children: flatChildren });
+    if (result instanceof Promise) {
+      return {
+        type: AsyncComponent,
+        promise: result
+      };
+    }
+    return result;
+  }
+  return {
+    type,
+    props: restProps,
+    children: flatChildren
+  };
+}
+var jsxs = jsx;
+function createElement(type, props, ...children) {
+  const flatChildren = flattenChildren(children);
+  if (isComponentClass(type)) {
+    return {
+      type: ClassComponent,
+      componentClass: type,
+      props: { ...props, children: flatChildren }
+    };
+  }
+  if (typeof type === "function") {
+    const result = type({ ...props, children: flatChildren });
+    if (result instanceof Promise) {
+      return {
+        type: AsyncComponent,
+        promise: result
+      };
+    }
+    return result;
+  }
+  return {
+    type,
+    props: props ?? {},
+    children: flatChildren
+  };
+}
+
+export { AsyncComponent, CDataSymbol, ClassComponent, Component, Fragment, RawXmlSymbol, __decorateElement, __decoratorStart, __runInitializers, createElement, isComponentClass, jsx, jsxs };
+//# sourceMappingURL=chunk-6OR6LGJA.mjs.map
+//# sourceMappingURL=chunk-6OR6LGJA.mjs.map

package/lib/chunk-6OR6LGJA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/xml-node.mts","../src/decorators/component.decorator.mts","../src/runtime/create-element.mts"],"names":[],"mappings":"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","file":"chunk-6OR6LGJA.mjs","sourcesContent":["import type { ComponentClass } from './component.mjs'\n\nexport const Fragment = Symbol.for('xml.fragment')\nexport const AsyncComponent = Symbol.for('xml.async')\nexport const CDataSymbol = Symbol.for('xml.cdata')\nexport const RawXmlSymbol = Symbol.for('xml.raw')\nexport const ClassComponent = Symbol.for('xml.class-component')\n\n/** Represents a CDATA section - content is wrapped in <![CDATA[...]]> */\nexport interface CDataNode {\n  type: typeof CDataSymbol\n  content: string\n}\n\n/** Represents raw XML content - inserted without any escaping or wrapping */\nexport interface RawXmlNode {\n  type: typeof RawXmlSymbol\n  content: string\n}\n\n/** Represents a class component that needs to be resolved via DI */\nexport interface ClassComponentNode {\n  type: typeof ClassComponent\n  componentClass: ComponentClass\n  props: Record<string, unknown>\n}\n\nexport interface XmlNode {\n  type: string | typeof Fragment\n  props: Record<string, unknown>\n  children: AnyXmlNode[]\n}\n\n/** Represents an async component that needs to be resolved before rendering */\nexport interface AsyncXmlNode {\n  type: typeof AsyncComponent\n  promise: Promise<AnyXmlNode>\n}\n\n/** Union type for all possible node types */\nexport type AnyXmlNode =\n  | XmlNode\n  | AsyncXmlNode\n  | CDataNode\n  | RawXmlNode\n  | ClassComponentNode\n  | string\n  | number\n  | null\n  | undefined\n","import type { z, ZodObject, ZodRawShape } from 'zod/v4'\n\nimport type { Registry } from '@navios/di'\n\nimport {\n  InjectableScope,\n  InjectableType,\n  InjectableTokenMeta,\n  InjectionToken,\n  globalRegistry,\n} from '@navios/di'\n\nimport type { ComponentClass, XmlComponent } from '../types/component.mjs'\n\nexport const ComponentMeta = Symbol.for('xml.component.meta')\n\n// #1 Component without props (no schema)\nexport function Component(): <T extends ComponentClass>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n\n// #2 Component with props schema\nexport function Component<Schema extends ZodObject<ZodRawShape>>(options: {\n  schema: Schema\n  registry?: Registry\n}): <T extends new (props: z.output<Schema>, ...args: any[]) => XmlComponent>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n\n// #3 Component with custom registry only\nexport function Component(options: {\n  registry: Registry\n}): <T extends ComponentClass>(\n  target: T,\n  context?: ClassDecoratorContext,\n) => T\n\nexport function Component(\n  options: {\n    schema?: ZodObject<ZodRawShape>\n    registry?: Registry\n  } = {},\n) {\n  const { schema, registry = globalRegistry } = options\n\n  return <T extends ComponentClass>(\n    target: T,\n    context?: ClassDecoratorContext,\n  ): T => {\n    if (\n      (context && context.kind !== 'class') ||\n      (target instanceof Function && !context)\n    ) {\n      throw new Error(\n        '[@navios/adapter-xml] @Component decorator can only be used on classes.',\n      )\n    }\n\n    // Verify the class has a render method\n    if (typeof target.prototype.render !== 'function') {\n      throw new Error(\n        `[@navios/adapter-xml] @Component class \"${target.name}\" must implement render() method.`,\n      )\n    }\n\n    // Create token with schema if provided\n    const injectableToken = schema\n      ? InjectionToken.create(target, schema)\n      : InjectionToken.create(target)\n\n    // Register with Request scope - each render gets fresh instances\n    registry.set(\n      injectableToken,\n      InjectableScope.Request,\n      target,\n      InjectableType.Class,\n    )\n\n    // Store token metadata on the class (same pattern as @Injectable)\n    // @ts-expect-error - Adding metadata to class\n    target[InjectableTokenMeta] = injectableToken\n\n    // Mark as component for JSX runtime detection\n    // @ts-expect-error - Adding metadata to class\n    target[ComponentMeta] = true\n\n    return target\n  }\n}\n\n/**\n * Type guard to check if a class is a component\n */\nexport function isComponentClass(value: unknown): value is ComponentClass {\n  return (\n    typeof value === 'function' &&\n    // @ts-expect-error - Checking metadata\n    value[ComponentMeta] === true\n  )\n}\n","import type { AnyXmlNode, AsyncXmlNode, ClassComponentNode, XmlNode } from '../types/xml-node.mjs'\nimport type { ComponentClass } from '../types/component.mjs'\n\nimport { isComponentClass } from '../decorators/component.decorator.mjs'\nimport { AsyncComponent, ClassComponent, Fragment } from '../types/xml-node.mjs'\n\ntype SyncComponent = (props: any) => XmlNode | AsyncXmlNode | ClassComponentNode\ntype AsyncComponentFn = (props: any) => Promise<XmlNode | AsyncXmlNode | ClassComponentNode>\ntype FunctionalComponent = SyncComponent | AsyncComponentFn\ntype ComponentType = FunctionalComponent | ComponentClass\n\nfunction flattenChildren(children: any): AnyXmlNode[] {\n  if (children == null || children === false) {\n    return []\n  }\n  if (Array.isArray(children)) {\n    return children.flat(Infinity).filter((c) => c != null && c !== false)\n  }\n  return [children]\n}\n\n/**\n * JSX automatic runtime function.\n * Used by the JSX transformer when jsxImportSource is set.\n * Children are passed as part of props.children.\n */\nexport function jsx(\n  type: string | typeof Fragment | ComponentType,\n  props: Record<string, unknown> | null,\n): XmlNode | AsyncXmlNode | ClassComponentNode {\n  const { children, ...restProps } = props ?? {}\n  const flatChildren = flattenChildren(children)\n\n  // Handle class components - create ClassComponentNode for later resolution\n  if (isComponentClass(type)) {\n    return {\n      type: ClassComponent,\n      componentClass: type,\n      props: { ...restProps, children: flatChildren },\n    }\n  }\n\n  // Handle function components (sync or async)\n  if (typeof type === 'function') {\n    const result = type({ ...restProps, children: flatChildren })\n\n    // If component returns a Promise, wrap it in AsyncXmlNode\n    if (result instanceof Promise) {\n      return {\n        type: AsyncComponent,\n        promise: result,\n      }\n    }\n\n    return result\n  }\n\n  return {\n    type,\n    props: restProps,\n    children: flatChildren,\n  }\n}\n\n/**\n * JSX automatic runtime function for static children.\n * Identical to jsx() for XML - React uses this for optimization hints.\n */\nexport const jsxs = jsx\n\n/**\n * Classic createElement for manual usage.\n * Children are passed as rest arguments.\n */\nexport function createElement(\n  type: string | typeof Fragment | ComponentType,\n  props: Record<string, unknown> | null,\n  ...children: any[]\n): XmlNode | AsyncXmlNode | ClassComponentNode {\n  const flatChildren = flattenChildren(children)\n\n  // Handle class components - create ClassComponentNode for later resolution\n  if (isComponentClass(type)) {\n    return {\n      type: ClassComponent,\n      componentClass: type,\n      props: { ...props, children: flatChildren },\n    }\n  }\n\n  // Handle function components (sync or async)\n  if (typeof type === 'function') {\n    const result = type({ ...props, children: flatChildren })\n\n    // If component returns a Promise, wrap it in AsyncXmlNode\n    if (result instanceof Promise) {\n      return {\n        type: AsyncComponent,\n        promise: result,\n      }\n    }\n\n    return result\n  }\n\n  return {\n    type,\n    props: props ?? {},\n    children: flatChildren,\n  }\n}\n\nexport { Fragment }\n"]}

package/lib/index.d.mts

@@ -0,0 +1,29 @@
+export { XmlNode } from './_tsup-dts-rollup.mjs';
+export { AsyncXmlNode } from './_tsup-dts-rollup.mjs';
+export { CDataNode } from './_tsup-dts-rollup.mjs';
+export { RawXmlNode } from './_tsup-dts-rollup.mjs';
+export { ClassComponentNode } from './_tsup-dts-rollup.mjs';
+export { AnyXmlNode } from './_tsup-dts-rollup.mjs';
+export { BaseXmlStreamConfig } from './_tsup-dts-rollup.mjs';
+export { XmlComponent } from './_tsup-dts-rollup.mjs';
+export { ComponentClass } from './_tsup-dts-rollup.mjs';
+export { Fragment } from './_tsup-dts-rollup.mjs';
+export { AsyncComponent } from './_tsup-dts-rollup.mjs';
+export { CDataSymbol } from './_tsup-dts-rollup.mjs';
+export { RawXmlSymbol } from './_tsup-dts-rollup.mjs';
+export { ClassComponent } from './_tsup-dts-rollup.mjs';
+export { createElement } from './_tsup-dts-rollup.mjs';
+export { CData } from './_tsup-dts-rollup.mjs';
+export { DangerouslyInsertRawXml } from './_tsup-dts-rollup.mjs';
+export { renderToXml } from './_tsup-dts-rollup.mjs';
+export { MissingContainerError } from './_tsup-dts-rollup.mjs';
+export { RenderOptions } from './_tsup-dts-rollup.mjs';
+export { defineTag } from './_tsup-dts-rollup.mjs';
+export { TagComponent } from './_tsup-dts-rollup.mjs';
+export { XmlStream } from './_tsup-dts-rollup.mjs';
+export { Component } from './_tsup-dts-rollup.mjs';
+export { isComponentClass } from './_tsup-dts-rollup.mjs';
+export { XmlStreamParams } from './_tsup-dts-rollup.mjs';
+export { declareXmlStream } from './_tsup-dts-rollup.mjs';
+export { XmlStreamAdapterService } from './_tsup-dts-rollup.mjs';
+export { defineXmlEnvironment_alias_1 as defineXmlEnvironment } from './_tsup-dts-rollup.mjs';

package/lib/index.d.ts

@@ -0,0 +1,29 @@
+export { XmlNode } from './_tsup-dts-rollup.js';
+export { AsyncXmlNode } from './_tsup-dts-rollup.js';
+export { CDataNode } from './_tsup-dts-rollup.js';
+export { RawXmlNode } from './_tsup-dts-rollup.js';
+export { ClassComponentNode } from './_tsup-dts-rollup.js';
+export { AnyXmlNode } from './_tsup-dts-rollup.js';
+export { BaseXmlStreamConfig } from './_tsup-dts-rollup.js';
+export { XmlComponent } from './_tsup-dts-rollup.js';
+export { ComponentClass } from './_tsup-dts-rollup.js';
+export { Fragment } from './_tsup-dts-rollup.js';
+export { AsyncComponent } from './_tsup-dts-rollup.js';
+export { CDataSymbol } from './_tsup-dts-rollup.js';
+export { RawXmlSymbol } from './_tsup-dts-rollup.js';
+export { ClassComponent } from './_tsup-dts-rollup.js';
+export { createElement } from './_tsup-dts-rollup.js';
+export { CData } from './_tsup-dts-rollup.js';
+export { DangerouslyInsertRawXml } from './_tsup-dts-rollup.js';
+export { renderToXml } from './_tsup-dts-rollup.js';
+export { MissingContainerError } from './_tsup-dts-rollup.js';
+export { RenderOptions } from './_tsup-dts-rollup.js';
+export { defineTag } from './_tsup-dts-rollup.js';
+export { TagComponent } from './_tsup-dts-rollup.js';
+export { XmlStream } from './_tsup-dts-rollup.js';
+export { Component } from './_tsup-dts-rollup.js';
+export { isComponentClass } from './_tsup-dts-rollup.js';
+export { XmlStreamParams } from './_tsup-dts-rollup.js';
+export { declareXmlStream } from './_tsup-dts-rollup.js';
+export { XmlStreamAdapterService } from './_tsup-dts-rollup.js';
+export { defineXmlEnvironment_alias_1 as defineXmlEnvironment } from './_tsup-dts-rollup.js';