@meonode/ui 0.3.3 → 0.3.5

package/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.4] - 2025-09-26
+
+### Fixed
+
+- **fix:** add cookie path to prevent duplicate theme cookie
+
 ## [0.3.3] - 2025-09-26
 
 ### Fixed

package/dist/components/theme-provider.client.js

@@ -5,6 +5,6 @@
  * @param {Theme} props.theme The theme to provide.
  * @returns {ReactNode} The rendered component.
  * @private
- */export function _ThemeProvider(a){var b=a.children,c=a.theme,d=useState(c),e=_slicedToArray(d,2),f=e[0],g=e[1];if(!c)throw new Error("`theme` prop must be defined");return Node(ThemeContext.Provider,{value:{theme:f,setTheme:function setTheme(a){document.cookie="theme=".concat(a.mode),g(a)}},children:b}).render()}/**
+ */export function _ThemeProvider(a){var b=a.children,c=a.theme,d=useState(c),e=_slicedToArray(d,2),f=e[0],g=e[1];if(!c)throw new Error("`theme` prop must be defined");return Node(ThemeContext.Provider,{value:{theme:f,setTheme:function setTheme(a){document.cookie="theme=".concat(a.mode,"; path=/;"),g(a)}},children:b}).render()}/**
  * A component that provides a theme to its children.
  */export var ThemeProvider=createNode(_ThemeProvider);

package/dist/core.node.d.ts

@@ -27,202 +27,59 @@ export declare class BaseNode<E extends NodeElementType> implements NodeInstance
     private static _isServer;
     /**
      * Constructs a new BaseNode instance.
-     *
-     * This constructor initializes a node with a given React element or component type
-     * and the raw props passed to it. The props are not processed until they are
-     * accessed via the `props` getter, allowing for lazy evaluation.
-     * @param element The React element or component type this node will represent.
-     * @param rawProps The initial, unprocessed props for the element.
      */
     constructor(element: E, rawProps?: Partial<NodeProps<E>>);
     /**
      * Lazily processes and retrieves the final, normalized props for the node.
-     *
-     * The first time this getter is accessed, it triggers `_processProps` to resolve
-     * styles, and children. Subsequent accesses return the cached result
-     * until the node is cloned or recreated.
-     * @returns The fully processed and normalized `FinalNodeProps`.
      */
     get props(): FinalNodeProps;
     /**
      * Processes raw props into a final, normalized form.
-     * This includes:
-     * - Extracting and separating style-related props
-     * - Merging CSS-in-JS styles with other style props
-     * - Processing and normalizing children
-     * - Combining all parts into a single props object
-     * @private
-     * @returns The processed `FinalNodeProps` ready for rendering.
      */
     private _processProps;
     /**
      * Recursively processes raw children, converting them into `BaseNode` instances as needed.
-     *
-     * This method ensures consistent handling for all children.
-     *
-     * - If `children` is an array, each child is processed individually.
-     * - If `children` is a single node, it is processed directly.
-     * @param children The raw child or array of children to process.
-     * @returns The processed children, ready for normalization and rendering.
-     * @private
      */
     private _processChildren;
     /**
-     * Renders a processed `NodeElement` into a `ReactNode`, applying a key if necessary.
-     *
-     * This static method centralizes the logic for converting various types of processed elements
-     * into renderable React nodes. It handles:
-     * - `BaseNode` instances: Re-wraps them to apply a new key.
-     * - React class components: Wraps them in a new `BaseNode`.
-     * - `NodeInstance` objects: Invokes their `render()` method.
-     * - React component instances: Invokes their `render()` method.
-     * - Functional components: Creates a React element from them.
-     * - Other valid `ReactNode` types (strings, numbers, etc.): Returns them as-is.
-     * @param processedElement The node element to render.
-     * @param passedKey The React key to assign.
-     * @returns A renderable `ReactNode`.
-     * @private
-     * @static
+     * Renders a processed `NodeElement` into a `ReactNode`.
      */
     private static _renderProcessedNode;
     /**
-     * Renders this node into a `ReactNode`, handling function node element.
-     * @param node The node to render.
-     * @private
-     * @static
-     * @example
-     * ```typescript
-     * const myNode = Node('div', { children: [ () => 'Hello' ] });
-     * ```
+     * Checks if a node is a function child (render prop style).
      */
     private static _isFunctionChild;
     /**
      * Renders the output of a function-as-a-child.
-     *
-     * This method is designed to handle "render prop" style children (`() => ReactNode`).
-     * It invokes the function and processes its result.
-     * @param props The properties for the function renderer.
-     * @param props.render The function to execute to get the child content.
-     * @returns The rendered `ReactNode`.
-     * @private
      */
     private static _functionRenderer;
-    /**
-     * Generates a stable key for a node, especially for elements within an array.
-     *
-     * If an `existingKey` is provided, it is returned. Otherwise, a key is generated
-     * based on the element's type name and its index within a list of siblings.
-     * This helps prevent re-rendering issues in React when dealing with dynamic lists.
-     * @param options The options for key generation.
-     * @param options.nodeIndex The index of the node in an array of children.
-     * @param options.element The element for which to generate a key.
-     * @param options.existingKey An existing key, if one was already provided.
-     * @param options.children The children of the node, used to add complexity to the key.
-     * @returns A React key, or `undefined` if no key could be generated.
-     * @private
-     * @static
-     */
-    private static _generateKey;
     /**
      * Processes a single raw node, recursively converting it into a `BaseNode` or other renderable type.
-     *
-     * This is a central method for normalizing children. It handles various types of input:
-     * - **`BaseNode` instances**: Re-creates them to ensure the correct key is applied.
-     * - **Primitives**: Returns strings, numbers, booleans, null, and undefined as-is.
-     * - **Functions (Render Props)**: Wraps them in a `BaseNode` that uses `_functionRenderer` to delay execution.
-     * - **Valid React Elements**: Converts them into `BaseNode` instances, extracting props.
-     * - **React Component Types**: Wraps them in a `BaseNode`.
-     * - **React Component Instances**: Renders them and processes the output recursively.
-     *
-     * It also generates a stable key for elements within an array if one is not provided.
-     * @param node The raw child node to process.
-     * @param nodeIndex The index of the child if it is in an array, used for key generation.
-     * @returns A processed `NodeElement` (typically a `BaseNode` instance or a primitive).
-     * @private
-     * @static
      */
     private static _processRawNode;
     /**
      * Normalizes a processed child node into a final, renderable `ReactNode`.
-     *
-     * This method is called during the `render` phase. It takes a child that has already
-     * been processed by `_processChildren` and prepares it for `React.createElement`.
-     *
-     * - For `BaseNode` instances, it calls their `render()` method.
-     * - It validates that other children are valid React element types.
-     * - Primitives and other valid nodes are returned as-is.
-     * @param child The processed child node to normalize.
-     * @returns A renderable `ReactNode`.
-     * @throws {Error} If the child is not a valid React element type.
-     * @private
      */
     private _normalizeChild;
     /**
      * Renders the `BaseNode` into a `ReactElement`.
-     *
-     * This method is the final step in the rendering pipeline. It constructs a React element
-     * by:
-     * 1.  Validating that the node's `element` type is renderable.
-     * 2.  Normalizing processed children into `ReactNode`s using `_normalizeChild`.
-     * 3.  Caching normalized children to avoid re-processing on subsequent renders.
-     * 4.  Assembling the final props, including `key`, `style`, and other attributes.
-     * 5.  If the element has a `css` prop, it may be wrapped in a `StyledRenderer` to handle
-     * CSS-in-JS styling.
-     * 6.  Finally, calling `React.createElement` with the element, props, and children.
-     * @returns The rendered `ReactElement`.
-     * @throws {Error} If the node's `element` is not a valid React element type.
      */
     render(): ReactElement<FinalNodeProps>;
     /**
-     * Ensures the necessary DOM elements for portal rendering are created and attached.
-     *
-     * On the client-side, this method checks for or creates a `div` element appended
-     * to the `document.body` and initializes a React root on it. This setup is
-     * required for the `toPortal` method to function. It is idempotent and safe
-     * to call multiple times.
-     * @returns `true` if the portal infrastructure is ready, `false` if on the server.
-     * @private
+     * Portal infrastructure setup
      */
     private _ensurePortalInfrastructure;
     /**
-     * Renders the node into a React Portal.
-     *
-     * Mounts the node's rendered output into a detached DOM tree (a `div` appended to `document.body`),
-     * enabling UI elements like modals, tooltips, or notifications to appear above the main app content.
-     *
-     * Returns a `NodePortal` object with:
-     * - `render(content)`: Renders new content into the portal.
-     * - `update(next?)`: Rerenders the current node or new content.
-     * - `unmount()`: Unmounts the portal and removes the DOM element.
-     *
-     * Throws if called on the server (where `document.body` is unavailable).
-     * @returns A `NodePortal` instance for managing the portal.
+     * Portal rendering
      */
     toPortal(): NodePortal;
 }
 /**
  * Factory function to create a `BaseNode` instance.
- * @template AdditionalProps Additional props to merge with node props.
- * @template E The React element or component type.
- * @param element The React element or component type to wrap.
- * @param props The props for the node (optional).
- * @param additionalProps Additional props to merge into the node (optional).
- * @returns A new `BaseNode` instance as a `NodeInstance<E>`.
  */
 export declare function Node<AdditionalProps extends Record<string, any>, E extends NodeElementType>(element: E, props?: MergedProps<E, AdditionalProps>, additionalProps?: AdditionalProps): NodeInstance<E>;
 /**
  * Creates a curried node factory for a given React element or component type.
- *
- * Returns a function that, when called with props, produces a `NodeInstance<E>`.
- * Useful for creating reusable node factories for specific components or element types.
- * @template AdditionalInitialProps Additional initial props to merge with node props.
- * @template E The React element or component type.
- * @param element The React element or component type to wrap.
- * @param initialProps Initial props to apply to every node instance.
- * @returns A function that takes node props and returns a `NodeInstance<E>`.
- * @example
- * const ButtonNode = createNode('button', { type: 'button' });
- * const myButton = ButtonNode({ children: 'Click me', style: { color: 'red' } });
  */
 export declare function createNode<AdditionalInitialProps extends Record<string, any>, E extends NodeElementType>(element: E, initialProps?: MergedProps<E, AdditionalInitialProps>): HasRequiredProps<PropsOf<E>> extends true ? (<AdditionalProps extends Record<string, any> = Record<string, any>>(props: MergedProps<E, AdditionalProps>) => NodeInstance<E>) & {
     element: E;
@@ -231,22 +88,6 @@ export declare function createNode<AdditionalInitialProps extends Record<string,
 };
 /**
  * Creates a node factory function where the first argument is `children` and the second is `props`.
- *
- * Useful for ergonomic creation of nodes where children are the primary concern,
- * such as layout or container components.
- *
- * The returned function takes `children` as the first argument and `props` (excluding `children`) as the second.
- * It merges any `initialProps` provided at factory creation, then creates a `BaseNode` instance.
- *
- * Type parameters:
- * - `AdditionalInitialProps`: Extra props to merge with node props.
- * - `E`: The React element or component type.
- * @param element The React element or component type to wrap.
- * @param initialProps Initial props to apply to every node instance (excluding `children`).
- * @returns A function that takes `children` and `props`, returning a `NodeInstance<E>`.
- * @example
- * const Text = createChildrenFirstNode('p');
- * const myDiv = Text('Hello', { className: 'text-lg' });
  */
 export declare function createChildrenFirstNode<AdditionalInitialProps extends Record<string, any>, E extends NodeElementType>(element: E, initialProps?: Omit<NodeProps<E>, keyof AdditionalInitialProps | 'children'> & AdditionalInitialProps): HasRequiredProps<PropsOf<E>> extends true ? (<AdditionalProps extends Record<string, any> = Record<string, any>>(children: Children, props: Omit<MergedProps<E, AdditionalProps>, 'children'>) => NodeInstance<E>) & {
     element: E;

package/dist/core.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.node.d.ts","sourceRoot":"","sources":["../src/core.node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"core.node.d.ts","sourceRoot":"","sources":["../src/core.node.ts"],"names":[],"mappings":"AACA,OAAc,EAQZ,KAAK,YAAY,EAElB,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EAEd,gBAAgB,EAChB,WAAW,EAEX,eAAe,EAEf,YAAY,EACZ,UAAU,EACV,SAAS,EACT,OAAO,EACR,MAAM,mBAAmB,CAAA;AAO1B;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,eAAe,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACzE,+EAA+E;IACxE,OAAO,EAAE,CAAC,CAAA;IACjB,kFAAkF;IAC3E,QAAQ,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAK;IAC3C,0CAA0C;IAC1C,SAAgB,UAAU,UAAO;IAEjC,sEAAsE;IACtE,OAAO,CAAC,MAAM,CAAC,CAAgB;IAC/B,4CAA4C;IAC5C,OAAO,CAAC,iBAAiB,CAA8B;IACvD,+CAA+C;IAC/C,OAAO,CAAC,gBAAgB,CAA0E;IAClG,oCAAoC;IACpC,OAAO,CAAC,mBAAmB,CAAC,CAAyB;IACrD,mFAAmF;IACnF,OAAO,CAAC,MAAM,CAAC,SAAS,CAAgC;IAExD;;OAEG;IACH,YAAY,OAAO,EAAE,CAAC,EAAE,QAAQ,GAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAM,EAG3D;IAED;;OAEG;IACH,IAAW,KAAK,IAAI,cAAc,CAKjC;IAED;;OAEG;IACH,OAAO,CAAC,aAAa;IAmBrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAqCnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAuChC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IA2C9B;;OAEG;IACH,OAAO,CAAC,eAAe,CAoBtB;IAED;;OAEG;IACI,MAAM,IAAI,YAAY,CAAC,cAAc,CAAC,CA0E5C;IAED;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAmCnC;;OAEG;IACI,QAAQ,IAAI,UAAU,CA+D5B;CACF;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,eAAe,EACzF,OAAO,EAAE,CAAC,EACV,KAAK,GAAE,WAAW,CAAC,CAAC,EAAE,eAAe,CAAyC,EAC9E,eAAe,GAAE,eAAuC,GACvD,YAAY,CAAC,CAAC,CAAC,CAGjB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,sBAAsB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,eAAe,EACtG,OAAO,EAAE,CAAC,EACV,YAAY,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,sBAAsB,CAAC,GACpD,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACxC,CAAC,CAAC,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,EAAE,eAAe,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,GACjJ,CAAC,CAAC,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,eAAe,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,CAMrJ;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,sBAAsB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,eAAe,EACnH,OAAO,EAAE,CAAC,EACV,YAAY,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,sBAAsB,GAAG,UAAU,CAAC,GAAG,sBAAsB,GACpG,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACxC,CAAC,CAAC,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjE,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,eAAe,CAAC,EAAE,UAAU,CAAC,KACrD,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,GACtC,CAAC,CAAC,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjE,QAAQ,CAAC,EAAE,QAAQ,EACnB,KAAK,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,eAAe,CAAC,EAAE,UAAU,CAAC,KACtD,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,CAQzC"}

package/dist/core.node.js

@@ -7,262 +7,50 @@
  * @template E The type of React element or component this node represents
  */export class BaseNode{/**
    * Constructs a new BaseNode instance.
-   *
-   * This constructor initializes a node with a given React element or component type
-   * and the raw props passed to it. The props are not processed until they are
-   * accessed via the `props` getter, allowing for lazy evaluation.
-   * @param element The React element or component type this node will represent.
-   * @param rawProps The initial, unprocessed props for the element.
    */constructor(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:{};/** The underlying React element or component type that this node represents *//** Original props passed during construction, preserved for cloning/recreation *//** Flag to identify BaseNode instances *//** DOM element used for portal rendering *//** React root instance for portal rendering *//**
    * Normalizes a processed child node into a final, renderable `ReactNode`.
-   *
-   * This method is called during the `render` phase. It takes a child that has already
-   * been processed by `_processChildren` and prepares it for `React.createElement`.
-   *
-   * - For `BaseNode` instances, it calls their `render()` method.
-   * - It validates that other children are valid React element types.
-   * - Primitives and other valid nodes are returned as-is.
-   * @param child The processed child node to normalize.
-   * @returns A renderable `ReactNode`.
-   * @throws {Error} If the child is not a valid React element type.
-   * @private
-   */_defineProperty(this,"rawProps",{}),_defineProperty(this,"isBaseNode",!0),_defineProperty(this,"_portalDOMElement",null),_defineProperty(this,"_portalReactRoot",null),_defineProperty(this,"_normalizeChild",function(a){// Handle null/undefined quickly
-if(null===a||a===void 0)return a;// Primitives should be returned as-is (text nodes, numbers, booleans)
-var b=_typeof(a);if("string"===b||"number"===b||"boolean"===b)return a;// For BaseNode instances, apply current theme if child has no theme
-if(a instanceof BaseNode||isNodeInstance(a))return a.render();// Handle React.Component instances
-if("function"==typeof a.render)// React.Component instance
-return a.render();// Validate element type before returning
-if(!isValidElementType(a)&&!isPortal(a)){var c=getComponentType(a);throw new Error("Invalid element type: ".concat(c," provided!"))}// Return valid React elements as-is
-return a}),this.element=a,this.rawProps=b}/**
+   */_defineProperty(this,"rawProps",{}),_defineProperty(this,"isBaseNode",!0),_defineProperty(this,"_portalDOMElement",null),_defineProperty(this,"_portalReactRoot",null),_defineProperty(this,"_normalizeChild",function(a){if(null===a||a===void 0)return a;var b=_typeof(a);if("string"===b||"number"===b||"boolean"===b)return a;if(a instanceof BaseNode||isNodeInstance(a))return a.render();if("function"==typeof a.render)return a.render();if(!isValidElementType(a)&&!isPortal(a)){var c=getComponentType(a);throw new Error("Invalid element type: ".concat(c," provided!"))}return a}),this.element=a,this.rawProps=b}/**
    * Lazily processes and retrieves the final, normalized props for the node.
-   *
-   * The first time this getter is accessed, it triggers `_processProps` to resolve
-   * styles, and children. Subsequent accesses return the cached result
-   * until the node is cloned or recreated.
-   * @returns The fully processed and normalized `FinalNodeProps`.
    */get props(){return this._props||(this._props=this._processProps()),this._props}/**
    * Processes raw props into a final, normalized form.
-   * This includes:
-   * - Extracting and separating style-related props
-   * - Merging CSS-in-JS styles with other style props
-   * - Processing and normalizing children
-   * - Combining all parts into a single props object
-   * @private
-   * @returns The processed `FinalNodeProps` ready for rendering.
-   */_processProps(){// Destructure raw props into relevant parts
-var a=this.rawProps,b=a.ref,c=a.key,d=a.children,e=a.css,f=a.props,g=void 0===f?{}:f,h=_objectWithoutProperties(a,_excluded),i=g,j=i.style,k=_objectWithoutProperties(i,_excluded2),l=getCSSProps(h),m=getDOMProps(h),n=this._processChildren(d);// Process children
-// Combine processed props into final normalized form
-return omitUndefined(_objectSpread(_objectSpread({ref:b,key:c,css:_objectSpread(_objectSpread({},l),e),style:j},m),{},{nativeProps:k,children:n}))}/**
+   */_processProps(){var a=this.rawProps,b=a.ref,c=a.key,d=a.children,e=a.css,f=a.props,g=void 0===f?{}:f,h=_objectWithoutProperties(a,_excluded),i=g,j=i.style,k=_objectWithoutProperties(i,_excluded2),l=getCSSProps(h),m=getDOMProps(h),n=this._processChildren(d);return omitUndefined(_objectSpread(_objectSpread({ref:b,key:c,css:_objectSpread(_objectSpread({},l),e),style:j},m),{},{nativeProps:k,children:n}))}/**
    * Recursively processes raw children, converting them into `BaseNode` instances as needed.
-   *
-   * This method ensures consistent handling for all children.
-   *
-   * - If `children` is an array, each child is processed individually.
-   * - If `children` is a single node, it is processed directly.
-   * @param children The raw child or array of children to process.
-   * @returns The processed children, ready for normalization and rendering.
-   * @private
-   */_processChildren(a){if(a){var b;return b="function"==typeof a?a:Array.isArray(a)?a.map(function(a,b){return BaseNode._processRawNode(a,b)}):BaseNode._processRawNode(a),b}}/**
-   * Renders a processed `NodeElement` into a `ReactNode`, applying a key if necessary.
-   *
-   * This static method centralizes the logic for converting various types of processed elements
-   * into renderable React nodes. It handles:
-   * - `BaseNode` instances: Re-wraps them to apply a new key.
-   * - React class components: Wraps them in a new `BaseNode`.
-   * - `NodeInstance` objects: Invokes their `render()` method.
-   * - React component instances: Invokes their `render()` method.
-   * - Functional components: Creates a React element from them.
-   * - Other valid `ReactNode` types (strings, numbers, etc.): Returns them as-is.
-   * @param processedElement The node element to render.
-   * @param passedKey The React key to assign.
-   * @returns A renderable `ReactNode`.
-   * @private
-   * @static
-   */static _renderProcessedNode(a,b){var c={};// 1. BaseNode instance: re-wrap to apply key/theme if needed
-if(void 0!==b&&(c.key=b),a instanceof BaseNode||isNodeInstance(a)){var d,e=null===(d=a.rawProps)||void 0===d?void 0:d.key;return e===b?a.render():new BaseNode(a.element,_objectSpread(_objectSpread({},a.rawProps),c)).render()}// 2. React class component type: wrap in BaseNode
-return isReactClassComponent(a)?new BaseNode(a,c).render():isNodeInstance(a)?a.render():a instanceof React.Component?a.render():"function"==typeof a?createElement(a,{key:b}):a;// 3. NodeInstance object: call its render
-// 4. React.Component instance: call its render
-// 5. Functional component: create element with key
-// 6. Other valid ReactNode types
-}/**
-   * Renders this node into a `ReactNode`, handling function node element.
-   * @param node The node to render.
-   * @private
-   * @static
-   * @example
-   * ```typescript
-   * const myNode = Node('div', { children: [ () => 'Hello' ] });
-   * ```
-   */static _isFunctionChild(a){// Basic function check
-if("function"!=typeof a)return!1;// Exclude React component types
-if(isReactClassComponent(a))return!1;if(isMemo(a))return!1;if(isForwardRef(a))return!1;try{// Try to check if it's a React component instance using prototype
-return!(a.prototype&&"function"==typeof a.prototype.render)}catch(a){// If accessing prototype fails (due to cross-realm), assume it's a function child
-return!0}}/**
+   */_processChildren(a){if(a){var b;return b="function"==typeof a?a:Array.isArray(a)?a.map(function(a){return BaseNode._processRawNode(a)}):BaseNode._processRawNode(a),b}}/**
+   * Renders a processed `NodeElement` into a `ReactNode`.
+   */static _renderProcessedNode(a,b){var c={};if(void 0!==b&&(c.key=b),a instanceof BaseNode||isNodeInstance(a)){var d,e=null===(d=a.rawProps)||void 0===d?void 0:d.key;return e===b?a.render():new BaseNode(a.element,_objectSpread(_objectSpread({},a.rawProps),c)).render()}return isReactClassComponent(a)?new BaseNode(a,c).render():isNodeInstance(a)?a.render():a instanceof React.Component?a.render():"function"==typeof a?createElement(a,{key:b}):a}/**
+   * Checks if a node is a function child (render prop style).
+   */static _isFunctionChild(a){if("function"!=typeof a)return!1;if(isReactClassComponent(a))return!1;if(isMemo(a))return!1;if(isForwardRef(a))return!1;try{return!(a.prototype&&"function"==typeof a.prototype.render)}catch(a){return!0}}/**
    * Renders the output of a function-as-a-child.
-   *
-   * This method is designed to handle "render prop" style children (`() => ReactNode`).
-   * It invokes the function and processes its result.
-   * @param props The properties for the function renderer.
-   * @param props.render The function to execute to get the child content.
-   * @returns The rendered `ReactNode`.
-   * @private
-   */static _functionRenderer(a){var b,c=a.render;// Invoke the render function to get the child node.
-try{b=c()}catch(a){b=null}// Handle null/undefined
-if(null===b||b===void 0)return b;// Handle arrays of elements (common in render props)
-if(Array.isArray(b))return b.map(function(a,b){var c=BaseNode._processRawNode(a,b);return BaseNode._renderProcessedNode(c,"".concat(getElementTypeName(a),"-").concat(b))});// Handle React.Component instance
-if(b instanceof React.Component){var d=b.render(),e=BaseNode._processRawNode(d);return BaseNode._renderProcessedNode(e)}// Handle BaseNode instance or NodeInstance
-if(b instanceof BaseNode||isNodeInstance(b))return b.render();// Handle primitives and valid React nodes (string, number, boolean)
-if("string"==typeof b||"number"==typeof b||"boolean"==typeof b)return b;// Process any other result types
-var f=BaseNode._processRawNode(b);return f?BaseNode._renderProcessedNode(f):b}/**
-   * Generates a stable key for a node, especially for elements within an array.
-   *
-   * If an `existingKey` is provided, it is returned. Otherwise, a key is generated
-   * based on the element's type name and its index within a list of siblings.
-   * This helps prevent re-rendering issues in React when dealing with dynamic lists.
-   * @param options The options for key generation.
-   * @param options.nodeIndex The index of the node in an array of children.
-   * @param options.element The element for which to generate a key.
-   * @param options.existingKey An existing key, if one was already provided.
-   * @param options.children The children of the node, used to add complexity to the key.
-   * @returns A React key, or `undefined` if no key could be generated.
-   * @private
-   * @static
-   *//**
+   */static _functionRenderer(a){var b,c=a.render;try{b=c()}catch(a){b=null}if(null===b||b===void 0)return b;if(Array.isArray(b))return b.map(function(a,b){var c=BaseNode._processRawNode(a);return BaseNode._renderProcessedNode(c,"".concat(getElementTypeName(a),"-").concat(b))});if(b instanceof React.Component){var d=b.render(),e=BaseNode._processRawNode(d);return BaseNode._renderProcessedNode(e)}if(b instanceof BaseNode||isNodeInstance(b))return b.render();if("string"==typeof b||"number"==typeof b||"boolean"==typeof b)return b;var f=BaseNode._processRawNode(b);return f?BaseNode._renderProcessedNode(f):b}/**
    * Processes a single raw node, recursively converting it into a `BaseNode` or other renderable type.
-   *
-   * This is a central method for normalizing children. It handles various types of input:
-   * - **`BaseNode` instances**: Re-creates them to ensure the correct key is applied.
-   * - **Primitives**: Returns strings, numbers, booleans, null, and undefined as-is.
-   * - **Functions (Render Props)**: Wraps them in a `BaseNode` that uses `_functionRenderer` to delay execution.
-   * - **Valid React Elements**: Converts them into `BaseNode` instances, extracting props.
-   * - **React Component Types**: Wraps them in a `BaseNode`.
-   * - **React Component Instances**: Renders them and processes the output recursively.
-   *
-   * It also generates a stable key for elements within an array if one is not provided.
-   * @param node The raw child node to process.
-   * @param nodeIndex The index of the child if it is in an array, used for key generation.
-   * @returns A processed `NodeElement` (typically a `BaseNode` instance or a primitive).
-   * @private
-   * @static
-   */static _processRawNode(a,b// Index for generating stable keys for array children
-){var c=getComponentType(a);// Determine the type of the raw node
-// Case 1: Child is already a BaseNode instance
-if(a instanceof BaseNode||isNodeInstance(a)){var d=a.rawProps||{};// Get initial raw props of the child
-// Check if we can reuse the existing node
-if(d.key!==void 0)return a;var e=BaseNode._generateKey({nodeIndex:b,element:a.element,existingKey:d.key,children:d.children});// Generate key if needed
-return new BaseNode(a.element,_objectSpread(_objectSpread({},d),{},{key:e}));// Create a new BaseNode with merged props and theme
-}// Case 2: Child is a primitive (string, number, boolean, null, undefined)
-if("string"===c||"number"===c||"boolean"===c||null===a||void 0===a)return a;// Case 3: Child is a function that needs to be called during render (FunctionRenderer).
-if(BaseNode._isFunctionChild(a)){// The key is for the BaseNode that wraps the _functionRenderer component.
-// Functions themselves don't have a .key prop that we can access here.
-var f=BaseNode._generateKey({nodeIndex:b,element:BaseNode._functionRenderer});// Generate key for function renderer
-return new BaseNode(BaseNode._functionRenderer,{render:a,key:f})}// Case 4: Child is a React Element (JSX element like <div> or <MyComponent>)
-if(isValidElement(a)){var g=a.props,h=g.style,i=_objectWithoutProperties(g,_excluded3),j=_objectSpread(_objectSpread({},i),h||{}),k=BaseNode._generateKey({nodeIndex:b,element:a.type,existingKey:a.key,children:j.children});return new BaseNode(a.type,_objectSpread(_objectSpread({},j),{},{key:k}))}// Case 5: Child is an ElementType (string tag, class component, Memo/ForwardRef)
-if(isReactClassComponent(a)||"object"===c&&(isMemo(a)||isForwardRef(a))){var l,m=BaseNode._generateKey({nodeIndex:b,element:a,children:"object"===_typeof(a)&&"props"in a?null===(l=a.props)||void 0===l?void 0:l.children:void 0});// ElementTypes don't have an intrinsic key from the node itself.
-return new BaseNode(a,{key:m})}// Case 6: Handle instances of React.Component
-if(a instanceof React.Component){var n=a.render();// Recursively process the rendered element with a parent theme and index if available
-return BaseNode._processRawNode(n,b)}// Case 7: Fallback for other ReactNode types (e.g., Fragments, Portals if not caught by isValidElement)
-// These are returned as-is. If they are elements within an array, React expects them to have keys.
-// This logic primarily adds keys to BaseNode instances we create, other ReactNodes are returned as-is.
+   */static _processRawNode(a){// Primitives and null/undefined - return as-is
+if(null===a||a===void 0||"string"==typeof a||"number"==typeof a||"boolean"==typeof a)return a;// Already processed nodes - return as-is
+if(a instanceof BaseNode||isNodeInstance(a))return a;// Function children (render props) - wrap in function renderer
+if(BaseNode._isFunctionChild(a))return new BaseNode(BaseNode._functionRenderer,{render:a});// React elements - extract props and wrap in BaseNode
+if(isValidElement(a)){var b=a.props,c=b.style,d=_objectWithoutProperties(b,_excluded3),e=_objectSpread(_objectSpread({},d),c||{});return new BaseNode(a.type,_objectSpread(_objectSpread({},e),null!==a.key&&void 0!==a.key?{key:a.key}:{}))}// Component types - wrap in BaseNode
+if(isReactClassComponent(a)||isMemo(a)||isForwardRef(a))return new BaseNode(a,{});// React.Component instances - render and process recursively
+if(a instanceof React.Component){var f=a.render();return BaseNode._processRawNode(f)}// Everything else - return as-is
 return a}/**
    * Renders the `BaseNode` into a `ReactElement`.
-   *
-   * This method is the final step in the rendering pipeline. It constructs a React element
-   * by:
-   * 1.  Validating that the node's `element` type is renderable.
-   * 2.  Normalizing processed children into `ReactNode`s using `_normalizeChild`.
-   * 3.  Caching normalized children to avoid re-processing on subsequent renders.
-   * 4.  Assembling the final props, including `key`, `style`, and other attributes.
-   * 5.  If the element has a `css` prop, it may be wrapped in a `StyledRenderer` to handle
-   * CSS-in-JS styling.
-   * 6.  Finally, calling `React.createElement` with the element, props, and children.
-   * @returns The rendered `ReactElement`.
-   * @throws {Error} If the node's `element` is not a valid React element type.
-   */render(){var a=this;if(!isValidElementType(this.element)){var b=getComponentType(this.element);throw new Error("Invalid element type: ".concat(b," provided!"))}// Extract children and key
-var c=this.props,d=c.children,e=c.key,f=c.nativeProps,g=_objectWithoutProperties(c,_excluded4),h=void 0;if(d!==void 0&&null!==d){if(!this._normalizedChildren)if(!Array.isArray(d))this._normalizedChildren=this._normalizeChild(d);else if(0<d.length){var i=d.map(function(b){return a._normalizeChild(b)});this._normalizedChildren=i.every(function(a){return null===a||void 0===a})?void 0:i}else this._normalizedChildren=void 0;h=this._normalizedChildren}// If the element is a Fragment, use React.createElement directly
-if(this.element===Fragment||isFragment(this.element))return createElement(this.element,{key:e},h);// If the element has a `css` prop and has style tag, render using the `StyledRenderer` component
-// This enables emotion-based style handling for the element
-if(this.element&&!hasNoStyleTag(this.element)&&g.css){// Set displayName for easier debugging in React DevTools
-try{var j=getElementTypeName(this.element);StyledRenderer.displayName="Styled(".concat(j,")")}catch(a){// swallow: displayName is not critical
-}return createElement(StyledRenderer,_objectSpread(_objectSpread({element:this.element},g),{},{key:e,suppressHydrationWarning:!0},f),h)}// For other elements, create the React element directly
-// Set displayName for easier debugging in React DevTools
+   */render(){var a=this;if(!isValidElementType(this.element)){var b=getComponentType(this.element);throw new Error("Invalid element type: ".concat(b," provided!"))}var c=this.props,d=c.children,e=c.key,f=c.nativeProps,g=_objectWithoutProperties(c,_excluded4),h=void 0;if(d!==void 0&&null!==d){if(!this._normalizedChildren)if(!Array.isArray(d))this._normalizedChildren=this._normalizeChild(d);else if(0<d.length){var i=d.map(function(b){return a._normalizeChild(b)});this._normalizedChildren=i.every(function(a){return null===a||void 0===a})?void 0:i}else this._normalizedChildren=void 0;h=this._normalizedChildren}// Common props for all createElement calls
+var j=_objectSpread(_objectSpread({},g),{},{key:e},f);// Fragment handling
+if(this.element===Fragment||isFragment(this.element))return Array.isArray(h)?createElement(this.element,{key:e},...h):createElement(this.element,{key:e},h);// Styled component handling
+if(this.element&&!hasNoStyleTag(this.element)&&g.css){try{var k=getElementTypeName(this.element);StyledRenderer.displayName="Styled(".concat(k,")")}catch(a){// swallow: displayName is not critical
+}return createElement(StyledRenderer,_objectSpread(_objectSpread({element:this.element},j),{},{suppressHydrationWarning:!0}),...(Array.isArray(h)?h:[h]))}// Regular element handling with spread children
 try{this.element.displayName=getElementTypeName(this.element)}catch(a){// swallow: displayName is not critical
-}return createElement(this.element,_objectSpread(_objectSpread({},g),{},{key:e},f),h)}/**
-   * Ensures the necessary DOM elements for portal rendering are created and attached.
-   *
-   * On the client-side, this method checks for or creates a `div` element appended
-   * to the `document.body` and initializes a React root on it. This setup is
-   * required for the `toPortal` method to function. It is idempotent and safe
-   * to call multiple times.
-   * @returns `true` if the portal infrastructure is ready, `false` if on the server.
-   * @private
-   */_ensurePortalInfrastructure(){if(BaseNode._isServer)return!1;// If both exist and DOM is connected, we're ready
-if(this._portalDOMElement&&this._portalReactRoot&&this._portalDOMElement.isConnected)return!0;// If DOM element exists but isn't connected, clear both DOM element and root
-if(this._portalDOMElement&&!this._portalDOMElement.isConnected){// attempt to unmount root if present
-if(this._portalReactRoot){try{this._portalReactRoot.unmount()}catch(a){// swallow: unmount might fail if already removed; avoid breaking the app
-}this._portalReactRoot=null}this._portalDOMElement=null}// Create DOM element if needed
-// Create react root if needed
-if(this._portalDOMElement||(this._portalDOMElement=document.createElement("div"),document.body.appendChild(this._portalDOMElement)),!this._portalReactRoot){if(!this._portalDOMElement)return!1;var a=createRoot(this._portalDOMElement);this._portalReactRoot={render:a.render.bind(a),unmount:a.unmount.bind(a),update:function update(){/* will be patched later */}}}return!0}/**
-   * Renders the node into a React Portal.
-   *
-   * Mounts the node's rendered output into a detached DOM tree (a `div` appended to `document.body`),
-   * enabling UI elements like modals, tooltips, or notifications to appear above the main app content.
-   *
-   * Returns a `NodePortal` object with:
-   * - `render(content)`: Renders new content into the portal.
-   * - `update(next?)`: Rerenders the current node or new content.
-   * - `unmount()`: Unmounts the portal and removes the DOM element.
-   *
-   * Throws if called on the server (where `document.body` is unavailable).
-   * @returns A `NodePortal` instance for managing the portal.
-   */toPortal(){var a=this;if(!this._ensurePortalInfrastructure()||!this._portalReactRoot)throw new Error("toPortal() can only be called in a client-side environment where document.body is available.");// Initial render
-(function renderCurrent(){try{var b=a.render();a._portalReactRoot.render(b)}catch(a){// swallow render errors to avoid breaking caller
-}})();// Patch the root with an update() method and a safe unmount that also removes DOM element.
-try{var b=this._portalReactRoot.unmount.bind(this._portalReactRoot),c=this._portalReactRoot;// Create typed handle
-return c.update=function(b){try{if(!a._portalReactRoot)return;// If next is a BaseNode or NodeInstance, render its output
-if(b instanceof BaseNode||b&&"function"==typeof b.render){var c=b.render?b.render():b;return void a._portalReactRoot.render(c)}// Otherwise assume a ReactNode and render directly
-a._portalReactRoot.render(b)}catch(a){// swallow
+}return createElement(this.element,j,...(Array.isArray(h)?h:[h]))}/**
+   * Portal infrastructure setup
+   */_ensurePortalInfrastructure(){if(BaseNode._isServer)return!1;if(this._portalDOMElement&&this._portalReactRoot&&this._portalDOMElement.isConnected)return!0;if(this._portalDOMElement&&!this._portalDOMElement.isConnected){if(this._portalReactRoot){try{this._portalReactRoot.unmount()}catch(a){// swallow
+}this._portalReactRoot=null}this._portalDOMElement=null}if(this._portalDOMElement||(this._portalDOMElement=document.createElement("div"),document.body.appendChild(this._portalDOMElement)),!this._portalReactRoot){if(!this._portalDOMElement)return!1;var a=createRoot(this._portalDOMElement);this._portalReactRoot={render:a.render.bind(a),unmount:a.unmount.bind(a),update:function update(){}}}return!0}/**
+   * Portal rendering
+   */toPortal(){var a=this;if(!this._ensurePortalInfrastructure()||!this._portalReactRoot)throw new Error("toPortal() can only be called in a client-side environment where document.body is available.");(function renderCurrent(){try{var b=a.render();a._portalReactRoot.render(b)}catch(a){// swallow render errors to avoid breaking caller
+}})();try{var b=this._portalReactRoot.unmount.bind(this._portalReactRoot),c=this._portalReactRoot;return c.update=function(b){try{if(!a._portalReactRoot)return;if(b instanceof BaseNode||b&&"function"==typeof b.render){var c=b.render?b.render():b;return void a._portalReactRoot.render(c)}a._portalReactRoot.render(b)}catch(a){// swallow
 }},c.unmount=function(){try{b()}catch(a){// swallow
-}// Clear references and remove DOM element
-if(a._portalDOMElement){try{a._portalDOMElement.parentNode&&a._portalDOMElement.parentNode.removeChild(a._portalDOMElement)}catch(a){// swallow
-}a._portalDOMElement=null}a._portalReactRoot=null},c}catch(a){// fallback: return the raw root as-is (without update/unmount patch)
-return this._portalReactRoot}}}/**
+}if(a._portalDOMElement){try{a._portalDOMElement.parentNode&&a._portalDOMElement.parentNode.removeChild(a._portalDOMElement)}catch(a){// swallow
+}a._portalDOMElement=null}a._portalReactRoot=null},c}catch(a){return this._portalReactRoot}}}/**
  * Factory function to create a `BaseNode` instance.
- * @template AdditionalProps Additional props to merge with node props.
- * @template E The React element or component type.
- * @param element The React element or component type to wrap.
- * @param props The props for the node (optional).
- * @param additionalProps Additional props to merge into the node (optional).
- * @returns A new `BaseNode` instance as a `NodeInstance<E>`.
- */_defineProperty(BaseNode,"_isServer","undefined"==typeof window),_defineProperty(BaseNode,"_generateKey",function(a){var b=a.nodeIndex,c=a.element,d=a.existingKey,e=a.children;if(d)return d;var f,g=getElementTypeName(c);return f=Array.isArray(e)&&0<e.length?void 0===b?"".concat(g,"-").concat(e.length):"".concat(g,"-").concat(b,"-").concat(e.length):void 0===b?g:"".concat(g,"-").concat(b),f});export function Node(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:{},c=2<arguments.length&&arguments[2]!==void 0?arguments[2]:{},d=_objectSpread(_objectSpread({},b),c);return new BaseNode(a,d)}/**
+ */_defineProperty(BaseNode,"_isServer","undefined"==typeof window);export function Node(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:{},c=2<arguments.length&&arguments[2]!==void 0?arguments[2]:{},d=_objectSpread(_objectSpread({},b),c);return new BaseNode(a,d)}/**
  * Creates a curried node factory for a given React element or component type.
- *
- * Returns a function that, when called with props, produces a `NodeInstance<E>`.
- * Useful for creating reusable node factories for specific components or element types.
- * @template AdditionalInitialProps Additional initial props to merge with node props.
- * @template E The React element or component type.
- * @param element The React element or component type to wrap.
- * @param initialProps Initial props to apply to every node instance.
- * @returns A function that takes node props and returns a `NodeInstance<E>`.
- * @example
- * const ButtonNode = createNode('button', { type: 'button' });
- * const myButton = ButtonNode({ children: 'Click me', style: { color: 'red' } });
  */export function createNode(a,b){var c=function Instance(c){return Node(a,_objectSpread(_objectSpread({},b),c))};return c.element=a,c}/**
  * Creates a node factory function where the first argument is `children` and the second is `props`.
- *
- * Useful for ergonomic creation of nodes where children are the primary concern,
- * such as layout or container components.
- *
- * The returned function takes `children` as the first argument and `props` (excluding `children`) as the second.
- * It merges any `initialProps` provided at factory creation, then creates a `BaseNode` instance.
- *
- * Type parameters:
- * - `AdditionalInitialProps`: Extra props to merge with node props.
- * - `E`: The React element or component type.
- * @param element The React element or component type to wrap.
- * @param initialProps Initial props to apply to every node instance (excluding `children`).
- * @returns A function that takes `children` and `props`, returning a `NodeInstance<E>`.
- * @example
- * const Text = createChildrenFirstNode('p');
- * const myDiv = Text('Hello', { className: 'text-lg' });
  */export function createChildrenFirstNode(a,b){var c=function Instance(c,d){return Node(a,_objectSpread(_objectSpread(_objectSpread({},b),d),{},{children:c}))};return c.element=a,c}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meonode/ui",
   "description": "A structured approach to component composition, direct CSS-first prop styling, built-in theming, smart prop handling (including raw property pass-through), and dynamic children.",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "main": "./dist/main.js",
   "types": "./dist/main.d.ts",