@khairold/xml-render 0.1.0

package/dist/registry.js

@@ -0,0 +1,93 @@
+/**
+ * Create an immutable tag registry from tag definitions.
+ *
+ * The registry provides type-safe access to tag definitions and their
+ * Zod schemas for attribute validation.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * import { createRegistry } from '@aura/xml-render';
+ *
+ * const registry = createRegistry({
+ *   chart: {
+ *     schema: z.object({
+ *       type: z.enum(['bar', 'line', 'pie']),
+ *       title: z.string().optional(),
+ *     }),
+ *     hasContent: true,
+ *   },
+ *   image: {
+ *     schema: z.object({
+ *       src: z.string(),
+ *       alt: z.string().optional(),
+ *     }),
+ *     selfClosing: true,
+ *     hasContent: false,
+ *   },
+ * });
+ *
+ * // TypeScript knows the exact tag names
+ * registry.tagNames; // ['chart', 'image']
+ *
+ * // Attribute types are inferred from Zod schemas
+ * type ChartAttrs = InferAttributes<typeof registry.definitions.chart>;
+ * // { type: 'bar' | 'line' | 'pie'; title?: string }
+ * ```
+ *
+ * @param definitions - Record of tag names to their definitions
+ * @returns An immutable registry instance
+ */
+export function createRegistry(definitions) {
+    // Freeze the definitions to make the registry immutable
+    const frozenDefs = Object.freeze(Object.fromEntries(Object.entries(definitions).map(([name, def]) => [
+        name,
+        Object.freeze({
+            ...def,
+            hasContent: def.hasContent ?? true,
+            selfClosing: def.selfClosing ?? false,
+        }),
+    ])));
+    const tagNames = Object.freeze(Object.keys(frozenDefs));
+    const tagNameSet = new Set(tagNames);
+    const registry = {
+        tagNames,
+        definitions: frozenDefs,
+        getTag(name) {
+            return frozenDefs[name];
+        },
+        hasTag(name) {
+            return tagNameSet.has(name);
+        },
+        getSchema(name) {
+            return frozenDefs[name]?.schema;
+        },
+        validateAttributes(name, attributes) {
+            const schema = frozenDefs[name]?.schema;
+            if (!schema) {
+                return {
+                    success: false,
+                    error: new Error(`Unknown tag: ${String(name)}`),
+                };
+            }
+            // Use Zod's safeParse and normalize the result
+            const result = schema.safeParse(attributes);
+            if (result.success) {
+                return {
+                    success: true,
+                    data: result.data,
+                };
+            }
+            return { success: false, error: result.error };
+        },
+        isSelfClosing(name) {
+            return frozenDefs[name]?.selfClosing ?? false;
+        },
+        hasContent(name) {
+            return frozenDefs[name]?.hasContent ?? true;
+        },
+    };
+    // Freeze the registry itself
+    return Object.freeze(registry);
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,UAAU,cAAc,CAC5B,WAAkB;IAElB,wDAAwD;IACxD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAC9B,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;QAC/C,IAAI;QACJ,MAAM,CAAC,MAAM,CAAC;YACZ,GAAG,GAAG;YACN,UAAU,EAAE,GAAG,CAAC,UAAU,IAAI,IAAI;YAClC,WAAW,EAAE,GAAG,CAAC,WAAW,IAAI,KAAK;SACtC,CAAC;KACH,CAAC,CACH,CACiB,CAAC;IAErB,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAErD,CAAC;IAEF,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAErC,MAAM,QAAQ,GAAoB;QAChC,QAAQ;QACR,WAAW,EAAE,UAAU;QAEvB,MAAM,CAAwB,IAAO;YACnC,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;QAED,MAAM,CAAC,IAAY;YACjB,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QAED,SAAS,CAAwB,IAAO;YACtC,OAAO,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAClC,CAAC;QAED,kBAAkB,CAChB,IAAO,EACP,UAAmB;YAEnB,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YACxC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,KAAK,EAAE,IAAI,KAAK,CAAC,gBAAgB,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;iBACjD,CAAC;YACJ,CAAC;YACD,+CAA+C;YAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAC5C,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,OAAO;oBACL,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE,MAAM,CAAC,IAAiC;iBAC/C,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QACjD,CAAC;QAED,aAAa,CAAwB,IAAO;YAC1C,OAAO,UAAU,CAAC,IAAI,CAAC,EAAE,WAAW,IAAI,KAAK,CAAC;QAChD,CAAC;QAED,UAAU,CAAwB,IAAO;YACvC,OAAO,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,IAAI,IAAI,CAAC;QAC9C,CAAC;KACF,CAAC;IAEF,6BAA6B;IAC7B,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACjC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,436 @@
+/**
+ * @aura/xml-render - TypeScript Type Definitions
+ *
+ * This file consolidates all public TypeScript types for the xml-render library.
+ * Import types from here for the best developer experience and autocomplete support.
+ *
+ * @packageDocumentation
+ */
+import type { ZodType, infer as ZodInfer } from "zod";
+import type { ComponentType, ReactNode } from "react";
+/**
+ * Definition for a single XML tag in the registry.
+ *
+ * @typeParam TSchema - The Zod schema type for attribute validation
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * import type { TagDefinition } from '@aura/xml-render';
+ *
+ * const chartDefinition: TagDefinition<typeof chartSchema> = {
+ *   schema: z.object({ type: z.enum(['bar', 'line', 'pie']) }),
+ *   hasContent: true,
+ *   selfClosing: false,
+ * };
+ * ```
+ */
+export interface TagDefinition<TSchema extends ZodType = ZodType> {
+    /** Zod schema for validating and typing tag attributes */
+    schema: TSchema;
+    /** Whether the tag contains inner content (default: true) */
+    hasContent?: boolean;
+    /** Whether the tag is self-closing like `<image />` (default: false) */
+    selfClosing?: boolean;
+}
+/**
+ * Input type for createRegistry - a record of tag names to their definitions.
+ *
+ * @example
+ * ```ts
+ * import type { TagDefinitions } from '@aura/xml-render';
+ *
+ * const definitions: TagDefinitions = {
+ *   chart: { schema: chartSchema, hasContent: true },
+ *   image: { schema: imageSchema, selfClosing: true },
+ * };
+ * ```
+ */
+export type TagDefinitions = Record<string, TagDefinition>;
+/**
+ * Infer the TypeScript type of tag attributes from a TagDefinition's Zod schema.
+ *
+ * This is a key utility type that allows you to extract the attribute types
+ * that TypeScript will use for a given tag definition.
+ *
+ * @typeParam T - The TagDefinition to infer attributes from
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * import type { TagDefinition, InferAttributes } from '@aura/xml-render';
+ *
+ * const chartDef = {
+ *   schema: z.object({
+ *     type: z.enum(['bar', 'line', 'pie']),
+ *     title: z.string().optional(),
+ *   }),
+ * } satisfies TagDefinition;
+ *
+ * // ChartAttrs = { type: 'bar' | 'line' | 'pie'; title?: string }
+ * type ChartAttrs = InferAttributes<typeof chartDef>;
+ * ```
+ */
+export type InferAttributes<T extends TagDefinition> = ZodInfer<T["schema"]>;
+/**
+ * Safe parse result type for attribute validation.
+ *
+ * This is a normalized result type that doesn't depend on specific Zod versions,
+ * ensuring compatibility across Zod v3 and v4.
+ *
+ * @typeParam T - The expected data type on success
+ */
+export type SafeParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: unknown;
+};
+/**
+ * The immutable registry interface returned by createRegistry.
+ *
+ * The registry provides type-safe access to tag definitions and their
+ * Zod schemas for attribute validation. All methods preserve type inference.
+ *
+ * @typeParam TDefs - The tag definitions record type
+ */
+export interface Registry<TDefs extends TagDefinitions> {
+    /** Get all registered tag names as a readonly array */
+    readonly tagNames: ReadonlyArray<keyof TDefs & string>;
+    /** Get the definition for a specific tag */
+    getTag<K extends keyof TDefs>(name: K): Readonly<TDefs[K]> | undefined;
+    /** Check if a tag name is registered (acts as type guard) */
+    hasTag(name: string): name is keyof TDefs & string;
+    /** Get the Zod schema for a tag's attributes */
+    getSchema<K extends keyof TDefs>(name: K): TDefs[K]["schema"] | undefined;
+    /** Validate attributes for a tag using its Zod schema */
+    validateAttributes<K extends keyof TDefs>(name: K, attributes: unknown): SafeParseResult<InferAttributes<TDefs[K]>>;
+    /** Check if a tag is self-closing (e.g., `<image />`) */
+    isSelfClosing<K extends keyof TDefs>(name: K): boolean;
+    /** Check if a tag has content (can contain inner text/elements) */
+    hasContent<K extends keyof TDefs>(name: K): boolean;
+    /** The raw definitions (frozen for immutability) */
+    readonly definitions: Readonly<TDefs>;
+}
+/**
+ * A parsed segment representing either plain text or a recognized tag.
+ *
+ * This is the core output type from the parser. Each segment contains:
+ * - `type`: Either 'text' for plain content or a registered tag name
+ * - `content`: The inner content of the tag or the text content
+ * - `attributes`: Typed attributes (only for tag segments, undefined for text)
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ * @typeParam TType - The specific segment type (defaults to union of all types)
+ *
+ * @example
+ * ```ts
+ * // After parsing "<callout type="info">Hello</callout>"
+ * const segment: ParsedSegment<MyRegistry, 'callout'> = {
+ *   type: 'callout',
+ *   content: 'Hello',
+ *   attributes: { type: 'info' }, // TypeScript knows the exact shape!
+ * };
+ * ```
+ */
+export interface ParsedSegment<TDefs extends TagDefinitions = TagDefinitions, TType extends keyof TDefs | "text" = keyof TDefs | "text"> {
+    /** The segment type: 'text' or a registered tag name */
+    type: TType;
+    /** The content inside the tag, or the text content for 'text' segments */
+    content: string;
+    /** Attributes parsed from the tag (undefined for 'text' segments) */
+    attributes?: TType extends keyof TDefs ? InferAttributes<TDefs[TType]> : undefined;
+}
+/**
+ * Union type of all valid segment types for a given registry.
+ *
+ * This includes all registered tag names plus the 'text' type for plain content.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ *
+ * @example
+ * ```ts
+ * type MyTypes = SegmentType<typeof registry.definitions>;
+ * // 'text' | 'callout' | 'chart' | 'image' | ...
+ * ```
+ */
+export type SegmentType<TDefs extends TagDefinitions> = keyof TDefs | "text";
+/**
+ * An array of parsed segments that can contain any valid segment type.
+ *
+ * This is the return type of `parser.parse()` and represents the complete
+ * parsed output of an XML-containing text string.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export type Segments<TDefs extends TagDefinitions> = Array<ParsedSegment<TDefs, keyof TDefs | "text">>;
+/**
+ * Parser state for handling incomplete/streaming content.
+ *
+ * This state object is passed between `parseChunk` calls to track:
+ * - Buffered content that might be part of an incomplete tag
+ * - Whether we're currently inside an opened component tag
+ * - The tag being processed and its attributes
+ *
+ * Create initial state with `parser.createState()`.
+ */
+export interface ParserState {
+    /** Accumulated text buffer */
+    buffer: string;
+    /** Whether we're currently inside an unclosed component tag */
+    inComponent: boolean;
+    /** The tag name being processed, if any */
+    currentTag: string | null;
+    /** Attributes string for the current tag */
+    currentAttrs: string;
+    /** Index in buffer where current tag started */
+    tagStartIndex: number;
+}
+/**
+ * Result of parsing a streaming chunk.
+ *
+ * Contains the segments that are complete and ready to render,
+ * plus the updated state for the next chunk.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface StreamingParseResult<TDefs extends TagDefinitions> {
+    /** Segments that are complete and can be rendered */
+    segments: Segments<TDefs>;
+    /** Updated parser state for next chunk */
+    state: ParserState;
+    /** Whether we're currently buffering (waiting for more data) */
+    isBuffering: boolean;
+    /** The type of tag being buffered, if any (useful for showing loading states) */
+    bufferingTag: keyof TDefs | null;
+}
+/**
+ * The parser interface returned by createParser.
+ *
+ * Provides methods for both complete text parsing and streaming parsing.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface Parser<TDefs extends TagDefinitions> {
+    /**
+     * Parse a complete text string into segments.
+     * This is the main entry point for non-streaming use cases.
+     *
+     * @param text - The complete text to parse
+     * @returns Array of parsed segments in order
+     */
+    parse(text: string): Segments<TDefs>;
+    /**
+     * Create initial parser state for streaming parsing.
+     *
+     * @returns Fresh parser state
+     */
+    createState(): ParserState;
+    /**
+     * Parse a chunk of streaming text.
+     * Handles incomplete tags by buffering until complete.
+     *
+     * @param chunk - New text chunk to process
+     * @param state - Current parser state
+     * @returns Parse result with complete segments and updated state
+     */
+    parseChunk(chunk: string, state: ParserState): StreamingParseResult<TDefs>;
+    /**
+     * Finalize parsing, returning any remaining buffered content as text.
+     * Call this when streaming is complete.
+     *
+     * @param state - Current parser state
+     * @returns Final segments including any buffered content
+     */
+    finalize(state: ParserState): Segments<TDefs>;
+    /** The registry used by this parser */
+    readonly registry: Registry<TDefs>;
+}
+/**
+ * Props passed to segment renderer components.
+ *
+ * Your custom renderer components receive these props to render each segment.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ * @typeParam TType - The specific segment type this component renders
+ *
+ * @example
+ * ```tsx
+ * import type { SegmentProps } from '@aura/xml-render/react';
+ *
+ * function CalloutRenderer({ segment, index }: SegmentProps<MyRegistry, 'callout'>) {
+ *   // segment.attributes is fully typed: { type: 'info' | 'warning' | 'error' }
+ *   return <div className={`callout-${segment.attributes?.type}`}>{segment.content}</div>;
+ * }
+ * ```
+ */
+export interface SegmentProps<TDefs extends TagDefinitions, TType extends keyof TDefs | "text"> {
+    /** The segment being rendered */
+    segment: ParsedSegment<TDefs, TType>;
+    /** Index of this segment in the segments array */
+    index: number;
+}
+/**
+ * Props for the text segment renderer.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface TextSegmentProps<TDefs extends TagDefinitions> {
+    /** The text segment to render */
+    segment: ParsedSegment<TDefs, "text">;
+    /** Index of this segment in the segments array */
+    index: number;
+}
+/**
+ * A React component that renders a specific segment type.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ * @typeParam TType - The segment type this renderer handles
+ */
+export type SegmentRenderer<TDefs extends TagDefinitions, TType extends keyof TDefs> = ComponentType<SegmentProps<TDefs, TType>>;
+/**
+ * A React component that renders text segments.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export type TextRenderer<TDefs extends TagDefinitions> = ComponentType<TextSegmentProps<TDefs>>;
+/**
+ * Component definitions for the catalog - maps tag names to renderer components.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export type CatalogComponents<TDefs extends TagDefinitions> = {
+    [K in keyof TDefs]: SegmentRenderer<TDefs, K>;
+};
+/**
+ * Options for creating a component catalog.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface CatalogOptions<TDefs extends TagDefinitions> {
+    /** Component renderers for each tag type (can be partial) */
+    components: Partial<CatalogComponents<TDefs>>;
+    /** Optional text segment renderer (default renders plain text) */
+    textRenderer?: TextRenderer<TDefs>;
+}
+/**
+ * The catalog interface returned by createCatalog.
+ *
+ * Maps segment types to their renderer components with full type safety.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface Catalog<TDefs extends TagDefinitions> {
+    /** Get the renderer component for a specific segment type */
+    getRenderer<K extends keyof TDefs>(type: K): SegmentRenderer<TDefs, K> | undefined;
+    /** Get the text segment renderer */
+    getTextRenderer(): TextRenderer<TDefs> | undefined;
+    /** Check if a renderer exists for a segment type */
+    hasRenderer(type: keyof TDefs | "text"): boolean;
+    /** The registry this catalog is based on */
+    readonly registry: Registry<TDefs>;
+    /** All registered component renderers */
+    readonly components: Readonly<Partial<CatalogComponents<TDefs>>>;
+}
+/**
+ * Props for the XmlRenderProvider component.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface XmlRenderProviderProps<TDefs extends TagDefinitions> {
+    /** The component catalog to provide to the tree */
+    catalog: Catalog<TDefs>;
+    /** Child components that can use XmlRender */
+    children: ReactNode;
+}
+/**
+ * Props for the XmlRender component.
+ *
+ * @typeParam TDefs - The tag definitions from the registry
+ */
+export interface XmlRenderProps<TDefs extends TagDefinitions> {
+    /** Array of parsed segments to render */
+    segments: Segments<TDefs>;
+    /** Optional fallback renderer for unknown segment types */
+    fallback?: (segment: ParsedSegment<TDefs>, index: number) => ReactNode;
+    /** Optional catalog override (uses context catalog if not provided) */
+    catalog?: Catalog<TDefs>;
+    /** Optional custom error fallback renderer */
+    errorFallback?: (error: Error, segmentType: string) => ReactNode;
+}
+/**
+ * Props for the ErrorBoundary component.
+ */
+export interface ErrorBoundaryProps {
+    /** The child components to render */
+    children: ReactNode;
+    /** The segment type being rendered (for error messages) */
+    segmentType: string;
+    /** Optional custom fallback renderer for errors */
+    fallback?: (error: Error, segmentType: string) => ReactNode;
+}
+/**
+ * Extract the tag definitions type from a Registry instance.
+ *
+ * Useful when you have a registry and need to reference its definitions type.
+ *
+ * @typeParam R - The Registry type
+ *
+ * @example
+ * ```ts
+ * const registry = createRegistry({ ... });
+ * type MyDefs = ExtractRegistryDefs<typeof registry>;
+ * ```
+ */
+export type ExtractRegistryDefs<R> = R extends Registry<infer TDefs> ? TDefs : never;
+/**
+ * Extract the parser's tag definitions type from a Parser instance.
+ *
+ * @typeParam P - The Parser type
+ */
+export type ExtractParserDefs<P> = P extends Parser<infer TDefs> ? TDefs : never;
+/**
+ * Extract the catalog's tag definitions type from a Catalog instance.
+ *
+ * @typeParam C - The Catalog type
+ */
+export type ExtractCatalogDefs<C> = C extends Catalog<infer TDefs> ? TDefs : never;
+/**
+ * Get the attribute type for a specific tag from a registry's definitions.
+ *
+ * @typeParam TDefs - The tag definitions type
+ * @typeParam K - The tag name
+ *
+ * @example
+ * ```ts
+ * type ChartAttrs = TagAttributes<MyDefs, 'chart'>;
+ * // { type: 'bar' | 'line' | 'pie'; title?: string }
+ * ```
+ */
+export type TagAttributes<TDefs extends TagDefinitions, K extends keyof TDefs> = InferAttributes<TDefs[K]>;
+/**
+ * Get a typed ParsedSegment for a specific tag from a registry.
+ *
+ * @typeParam TDefs - The tag definitions type
+ * @typeParam K - The tag name
+ */
+export type TypedSegment<TDefs extends TagDefinitions, K extends keyof TDefs | "text"> = ParsedSegment<TDefs, K>;
+/**
+ * Type guard helper to check if a segment is of a specific type.
+ *
+ * @param segment - The segment to check
+ * @param type - The type to check for
+ * @returns Type predicate indicating if segment is of the specified type
+ *
+ * @example
+ * ```ts
+ * const segment: ParsedSegment<MyDefs> = ...;
+ * if (isSegmentType(segment, 'chart')) {
+ *   // TypeScript now knows segment.attributes has chart's attribute type
+ *   console.log(segment.attributes?.type); // 'bar' | 'line' | 'pie'
+ * }
+ * ```
+ */
+export declare function isSegmentType<TDefs extends TagDefinitions, K extends keyof TDefs | "text">(segment: ParsedSegment<TDefs>, type: K): segment is ParsedSegment<TDefs, K>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,QAAQ,EAAE,MAAM,KAAK,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAMtD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAa,CAAC,OAAO,SAAS,OAAO,GAAG,OAAO;IAC9D,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,wEAAwE;IACxE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,aAAa,IAAI,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IACzB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAC1B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAEvC;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ,CAAC,KAAK,SAAS,cAAc;IACpD,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC;IAEvD,4CAA4C;IAC5C,MAAM,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEvE,6DAA6D;IAC7D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,MAAM,KAAK,GAAG,MAAM,CAAC;IAEnD,gDAAgD;IAChD,SAAS,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IAE1E,yDAAyD;IACzD,kBAAkB,CAAC,CAAC,SAAS,MAAM,KAAK,EACtC,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,OAAO,GAClB,eAAe,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9C,yDAAyD;IACzD,aAAa,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC;IAEvD,mEAAmE;IACnE,UAAU,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC;IAEpD,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;CACvC;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,aAAa,CAC5B,KAAK,SAAS,cAAc,GAAG,cAAc,EAC7C,KAAK,SAAS,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,KAAK,GAAG,MAAM;IAEzD,wDAAwD;IACxD,IAAI,EAAE,KAAK,CAAC;IACZ,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,UAAU,CAAC,EAAE,KAAK,SAAS,MAAM,KAAK,GAClC,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAC7B,SAAS,CAAC;CACf;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,SAAS,cAAc,IAAI,MAAM,KAAK,GAAG,MAAM,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,cAAc,IAAI,KAAK,CACxD,aAAa,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,MAAM,CAAC,CAC3C,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,WAAW,EAAE,OAAO,CAAC;IACrB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,4CAA4C;IAC5C,YAAY,EAAE,MAAM,CAAC;IACrB,gDAAgD;IAChD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB,CAAC,KAAK,SAAS,cAAc;IAChE,qDAAqD;IACrD,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,KAAK,EAAE,WAAW,CAAC;IACnB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,iFAAiF;IACjF,YAAY,EAAE,MAAM,KAAK,GAAG,IAAI,CAAC;CAClC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,MAAM,CAAC,KAAK,SAAS,cAAc;IAClD;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAErC;;;;OAIG;IACH,WAAW,IAAI,WAAW,CAAC;IAE3B;;;;;;;OAOG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAE3E;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE9C,uCAAuC;IACvC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,YAAY,CAC3B,KAAK,SAAS,cAAc,EAC5B,KAAK,SAAS,MAAM,KAAK,GAAG,MAAM;IAElC,iCAAiC;IACjC,OAAO,EAAE,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACrC,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,cAAc;IAC5D,iCAAiC;IACjC,OAAO,EAAE,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACtC,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CACzB,KAAK,SAAS,cAAc,EAC5B,KAAK,SAAS,MAAM,KAAK,IACvB,aAAa,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,SAAS,cAAc,IAAI,aAAa,CACpE,gBAAgB,CAAC,KAAK,CAAC,CACxB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,cAAc,IAAI;KAC3D,CAAC,IAAI,MAAM,KAAK,GAAG,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC;CAC9C,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,cAAc;IAC1D,6DAA6D;IAC7D,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9C,kEAAkE;IAClE,YAAY,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;CACpC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO,CAAC,KAAK,SAAS,cAAc;IACnD,6DAA6D;IAC7D,WAAW,CAAC,CAAC,SAAS,MAAM,KAAK,EAC/B,IAAI,EAAE,CAAC,GACN,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;IAEzC,oCAAoC;IACpC,eAAe,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAEnD,oDAAoD;IACpD,WAAW,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAEjD,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAEnC,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAClE;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CAAC,KAAK,SAAS,cAAc;IAClE,mDAAmD;IACnD,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,cAAc;IAC1D,yCAAyC;IACzC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC;IACvE,uEAAuE;IACvE,OAAO,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACzB,8CAA8C;IAC9C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,SAAS,CAAC;CAClE;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,QAAQ,EAAE,SAAS,CAAC;IACpB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,SAAS,CAAC;CAC7D;AAMD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,KAAK,CAAC,GAChE,KAAK,GACL,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAC5D,KAAK,GACL,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,KAAK,CAAC,GAC9D,KAAK,GACL,KAAK,CAAC;AAEV;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,CACvB,KAAK,SAAS,cAAc,EAC5B,CAAC,SAAS,MAAM,KAAK,IACnB,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,cAAc,EAC5B,CAAC,SAAS,MAAM,KAAK,GAAG,MAAM,IAC5B,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AAE5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,SAAS,cAAc,EAC5B,CAAC,SAAS,MAAM,KAAK,GAAG,MAAM,EAE9B,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,IAAI,EAAE,CAAC,GACN,OAAO,IAAI,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,CAEpC"}

package/dist/types.js

@@ -0,0 +1,28 @@
+/**
+ * @aura/xml-render - TypeScript Type Definitions
+ *
+ * This file consolidates all public TypeScript types for the xml-render library.
+ * Import types from here for the best developer experience and autocomplete support.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Type guard helper to check if a segment is of a specific type.
+ *
+ * @param segment - The segment to check
+ * @param type - The type to check for
+ * @returns Type predicate indicating if segment is of the specified type
+ *
+ * @example
+ * ```ts
+ * const segment: ParsedSegment<MyDefs> = ...;
+ * if (isSegmentType(segment, 'chart')) {
+ *   // TypeScript now knows segment.attributes has chart's attribute type
+ *   console.log(segment.attributes?.type); // 'bar' | 'line' | 'pie'
+ * }
+ * ```
+ */
+export function isSegmentType(segment, type) {
+    return segment.type === type;
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkfH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,aAAa,CAI3B,OAA6B,EAC7B,IAAO;IAEP,OAAO,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;AAC/B,CAAC"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@khairold/xml-render",
+  "version": "0.1.0",
+  "description": "A type-safe XML-like tag parser and renderer framework for React and React Native",
+  "keywords": [
+    "xml",
+    "parser",
+    "react",
+    "react-native",
+    "streaming",
+    "llm",
+    "ai",
+    "render",
+    "zod",
+    "typescript"
+  ],
+  "author": "Khairul Kamarudin",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/khairold/aura.git",
+    "directory": "packages/xml-render"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    },
+    "./react-native": {
+      "types": "./dist/react-native/index.d.ts",
+      "default": "./dist/react-native/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.70.0",
+    "zod": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  }
+}