@meonode/ui 0.2.20 → 0.3.0

package/dist/core.node.js

@@ -1,10 +1,9 @@
-"use strict";var _excluded=["ref","key","children","nodetheme","theme","props"],_excluded2=["style"],_excluded3=["style","css"],_excluded4=["style"],_excluded5=["children","key","nativeProps"];function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}import React,{createElement,Fragment,isValidElement}from"react";import{createStableHash,isNodeInstance,resolveDefaultStyle}from"./helper/node.helper.js";import{isForwardRef,isFragment,isMemo,isReactClassComponent,isValidElementType}from"./helper/react-is.helper.js";import{createRoot}from"react-dom/client";import{getComponentType,getCSSProps,getDOMProps,getElementTypeName,hasNoStyleTag,omit,omitUndefined}from"./helper/common.helper.js";import StyledRenderer from"./components/styled-renderer.client.js";import{resolveObjWithTheme}from"./helper/theme.helper.js";/**
- * Represents a node in a React component tree with theme and styling capabilities.
+"use strict";var _excluded=["ref","key","children","css","props"],_excluded2=["style"],_excluded3=["style"],_excluded4=["children","key","nativeProps"];function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}import React,{createElement,Fragment,isValidElement}from"react";import{isNodeInstance}from"./helper/node.helper.js";import{isForwardRef,isFragment,isMemo,isReactClassComponent,isValidElementType}from"./helper/react-is.helper.js";import{createRoot}from"react-dom/client";import{getComponentType,getCSSProps,getDOMProps,getElementTypeName,hasNoStyleTag,omitUndefined}from"./helper/common.helper.js";import StyledRenderer from"./components/styled-renderer.client.js";/**
+ * Represents a node in a React component tree.
  * This class wraps React elements and handles:
  * - Props processing and normalization
- * - Theme inheritance and resolution
  * - Child node processing and management
- * - Style processing with theme variables
+ * - Style processing
  * @template E The type of React element or component this node represents
  */export class BaseNode{/**
    * Constructs a new BaseNode instance.
@@ -14,205 +13,155 @@
    * 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=this,c=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 *//**
-   * 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
-   *//**
+   */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, ensuring the theme is consistent.
+   * - 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,"_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}),_defineProperty(this,"_normalizeChild",function(a){var c,d;// Handle null/undefined quickly
+   */_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 e=_typeof(a);if("string"===e||"number"===e||"boolean"===e)return a;var f=(null===(c=b.rawProps)||void 0===c?void 0:c.nodetheme)||(null===(d=b.rawProps)||void 0===d?void 0:d.theme)||b.props.nodetheme||b.props.theme;// For BaseNode instances, apply current theme if child has no theme
-if(a instanceof BaseNode||isNodeInstance(a)){var g;return null!==(g=a.rawProps)&&void 0!==g&&g.nodetheme||void 0===f?a.render():new BaseNode(a.element,_objectSpread(_objectSpread({},a.rawProps),{},{nodetheme:f})).render()}// Handle React.Component instances
+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)){var h=getComponentType(a);throw new Error("Invalid element type: ".concat(h," provided!"))}// Return valid React elements as-is
-return a}),this.element=a,this.rawProps=c}/**
+if(!isValidElementType(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}/**
    * Lazily processes and retrieves the final, normalized props for the node.
    *
    * The first time this getter is accessed, it triggers `_processProps` to resolve
-   * themes, styles, and children. Subsequent accesses return the cached result
+   * 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}/**
-   * Performs the core logic of processing raw props into their final, normalized form.
-   *
-   * This method is called by the `props` getter on its first access. It handles:
-   * 1.  **Theme Resolution**: Selects the active theme from `theme` or `nodetheme` props.
-   * 2.  **Prop Resolution**: Resolves theme-aware values (functions) in `rawProps` and `nativeProps.style`.
-   * 3.  **Style Extraction**: Separates style-related props (`css`, `style`) from other DOM/component props.
-   * 4.  **Default Style Merging**: Combines default styles with resolved style props.
-   * 5.  **Child Processing**: Normalizes the `children` prop, propagating the theme.
-   * @returns The processed `FinalNodeProps` object.
+   * 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.nodetheme,f=a.theme,g=a.props,h=void 0===g?{}:g,i=_objectWithoutProperties(a,_excluded),j=f||e,k=h,l=k.style,m=_objectWithoutProperties(k,_excluded2),n=resolveObjWithTheme(i,j),o=resolveObjWithTheme(l,j),p=n.style,q=n.css,r=_objectWithoutProperties(n,_excluded3),s=getCSSProps(r),t=getDOMProps(r),u=resolveDefaultStyle(_objectSpread(_objectSpread({},s),p)),v=this._processChildren(d,j),w=omitUndefined(_objectSpread(_objectSpread({ref:b,key:c,nodetheme:j,theme:f,css:_objectSpread(_objectSpread({},u),q),style:o},t),{},{nativeProps:m,children:v}));// Process children while maintaining theme inheritance
+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
-// Special handling for standard HTML tags vs custom components
-return"string"==typeof this.element&&(hasNoStyleTag(this.element)?w=omit(w,"css","style","theme","nodetheme"):w=omit(w,"theme","nodetheme")),w}/**
-   * Deeply clones processed children before returning them from cache so that each parent receives
-   * independent `BaseNode` instances (prevents sharing cycles and mutation bugs).
-   *
-   * - If the input is an array, each child is cloned recursively.
-   * - If the input is a `BaseNode`, a new instance is created with the same element and copied rawProps.
-   * - For other objects/primitives, the value is returned as-is (they are immutable or safe to reuse).
+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 ensures that cached children are never shared between different parents in the React tree.
-   * @param processed The processed child or array of children to clone.
-   * @returns A deep clone of the processed children, safe for use in multiple parents.
-   * @private
-   */static _cloneProcessedChildren(a){var b=function cloneOne(a){return a instanceof BaseNode?new BaseNode(a.element,_objectSpread({},a.rawProps)):a;// NodeInstance returns its own instances when render() is called - we avoid calling render here.
-// For other objects/primitives, return as-is (they are immutable or safe to reuse).
-};return Array.isArray(a)?a.map(function(a){return b(a)}):b(a)}/**
-   * Retrieves cached processed children for a given set of `children` and an optional `theme`.
-   *
-   * - Skips caching entirely when executed on the server (returns `null`).
-   * - Uses a **WeakMap** for identity-based caching when `children` is an object or array,
-   * ensuring garbage collection safety.
-   * - Falls back to a **Map** keyed by a stable hash of `children` and `theme`
-   * for value-based caching.
-   * - Only returns cached entries that are **not server-side**.
-   * @param children The child node(s) to resolve cached results for.
-   * @param theme The theme context that may influence child processing.
-   * @returns A cloned version of the cached processed children if available, otherwise `null`.
-   * @private
-   */_getCachedChildren(a,b){if(BaseNode._isServer)return null;// No server caching
-// Compute hash once
-var c=createStableHash(a,b);// If children is an object (array or object), try identity-keyed WeakMap first
-if(a&&"object"===_typeof(a)){var d=BaseNode._processedChildrenWeakCache.get(a);if(d&&d.hash===c&&!d.isServerSide)return BaseNode._cloneProcessedChildren(d.children)}// Fallback to string-hash Map cache
-var e=BaseNode._processedChildrenMapCache.get(c);return e&&!e.isServerSide?BaseNode._cloneProcessedChildren(e.children):null}/**
-   * Caches processed children for a given set of children and theme.
-   * This method stores the processed NodeElement(s) in a Map keyed by a stable hash.
-   * The cache is bounded to avoid unbounded memory growth.
-   * No caching is performed on the server to avoid RSC issues.
-   * @param children The original children to cache.
-   * @param theme The theme associated with the children.
-   * @param processed The processed NodeElement(s) to cache.
-   * @private
-   */_setCachedChildren(a,b,c){if(!BaseNode._isServer){var d=createStableHash(a,b);if(a&&"object"===_typeof(a))return void BaseNode._processedChildrenWeakCache.set(a,{hash:d,children:c,isServerSide:!1});// Manage bounded Map cache (FIFO eviction)
-if(BaseNode._processedChildrenMapCache.has(d))return void BaseNode._processedChildrenMapCache.set(d,{children:c,isServerSide:!1});if(BaseNode._processedChildrenMapCache.size>=BaseNode._MAX_PROCESSED_CHILDREN_CACHE){var e=BaseNode._processedChildrenMapCache.keys().next().value;void 0!==e&&BaseNode._processedChildrenMapCache["delete"](e)}BaseNode._processedChildrenMapCache.set(d,{children:c,isServerSide:!1})}}/**
-   * Recursively processes raw children, converting them into `BaseNode` instances as needed
-   * and propagating the provided theme.
-   *
-   * This method ensures consistent theme handling for all children and optimizes performance
-   * using caching strategies: a Map for client-side and no caching for server-side.
+   * 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.
-   * - The processed result is cached on the client to avoid redundant work.
    * @param children The raw child or array of children to process.
-   * @param theme The theme to propagate to the children.
    * @returns The processed children, ready for normalization and rendering.
    * @private
-   */_processChildren(a,b){var c=this;if(a){// Use RSC-safe caching strategy
-var d=this._getCachedChildren(a,b);if(d)return d;var e;return e="function"==typeof a?a:Array.isArray(a)?a.map(function(a,d){return c._processRawNode(a,b,d)}):this._processRawNode(a,b),BaseNode._isServer||this._setCachedChildren(a,b,e),e}}/**
-   * Renders a processed `NodeElement` into a `ReactNode`, applying a theme and key if necessary.
+   */_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 or theme.
+   * - `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 passedTheme The theme to propagate.
    * @param passedKey The React key to assign.
    * @returns A renderable `ReactNode`.
    * @private
    * @static
-   */static _renderProcessedNode(a,b,c){var d={};// 1. BaseNode instance: re-wrap to apply key/theme if needed
-if(void 0!==c&&(d.key=c),a instanceof BaseNode){var e,f,g,h,i,j=(null===(e=a.rawProps)||void 0===e?void 0:e.theme)||(null===(f=a.rawProps)||void 0===f?void 0:f.nodetheme)||b,k=null===(g=a.rawProps)||void 0===g?void 0:g.key;return k===c&&j===((null===(h=a.rawProps)||void 0===h?void 0:h.nodetheme)||(null===(i=a.rawProps)||void 0===i?void 0:i.theme))?a.render():new BaseNode(a.element,_objectSpread(_objectSpread(_objectSpread({},a.rawProps),d),{},{nodetheme:j})).render()}// 2. React class component type: wrap in BaseNode
-return isReactClassComponent(a)?new BaseNode(a,d).render():isNodeInstance(a)?a.render():a instanceof React.Component?a.render():"function"==typeof a?createElement(a,{key:c}):a;// 3. NodeInstance object: call its render
+   */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
 }/**
-   * Determines if a raw node is a function that should be treated as a render prop.
-   * @param rawNode
+   * Renders this node into a `ReactNode`, handling function node element.
+   * @param node The node to render.
    * @private
-   */_isFunctionChild(a){// Basic function check
-return!("function"!=typeof a)&&!isReactClassComponent(a)&&!isMemo(a)&&!isForwardRef(a)&&!("displayName"in a&&a.displayName&&/^[A-Z]/.test(a.displayName))&&!(a.name&&/^[A-Z]/.test(a.name))&&!(a.prototype&&"function"==typeof a.prototype.render);// Exclude React component types
-// Check if it's a component function vs render function
-// Component functions typically have displayName, name starting with capital, or prototype
-// If function has prototype properties (likely a constructor), it's probably a component
-}/**
-   * Renders the output of a function-as-a-child, ensuring theme propagation.
+   * @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}}/**
+   * Renders the output of a function-as-a-child.
    *
    * This method is designed to handle "render prop" style children (`() => ReactNode`).
-   * It invokes the function, processes its result, and ensures the parent's theme is
-   * correctly passed down to any `BaseNode` instances returned by the function.
+   * 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.
-   * @param props.passedTheme The theme to propagate to the rendered child.
-   * @param props.processRawNode A reference to the `_processRawNode` method for recursive processing.
    * @returns The rendered `ReactNode`.
    * @private
-   */_functionRenderer(a){var b,c=a.render,d=a.passedTheme,e=a.processRawNode;// Invoke the render function to get the child node.
+   */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=e(a,d,b);return BaseNode._renderProcessedNode(c,d,"".concat(getElementTypeName(a),"-").concat(b))});// Handle React.Component instance
-if(b instanceof React.Component){var f=b.render(),g=e(f,d);return BaseNode._renderProcessedNode(g,d)}// Handle BaseNode instance or NodeInstance
-if(b instanceof BaseNode||isNodeInstance(b)){var h,i=b;// If nodetheme is missing and passedTheme exists, inject it
-return void 0===(null===(h=i.rawProps)||void 0===h?void 0:h.nodetheme)&&void 0!==d?new BaseNode(i.element,_objectSpread(_objectSpread({},i.rawProps),{},{nodetheme:d})).render():i.render()}// Handle primitives and valid React nodes (JSX, string, number, boolean)
-if("string"==typeof b||"number"==typeof b||"boolean"==typeof b||b&&"object"===_typeof(b)&&"$$typeof"in b// React JSX element
-)return b;// Process any other result types
-var j=e?e(b,d):b;return j?BaseNode._renderProcessedNode(j,d):b}/**
+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
+   *//**
    * 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 theme and key are applied.
+   * - **`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 and propagating the theme.
-   * - **React Component Types**: Wraps them in a `BaseNode` with the parent theme.
+   * - **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 rawNode The raw child node to process.
-   * @param parentTheme The theme inherited from the parent.
+   * @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
-   */_processRawNode(a,b,c// Index for generating stable keys for array children
-){var d=getComponentType(a);// Determine the type of the raw node
+   * @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){var e=a,f=e.rawProps||{},g=f.theme||f.nodetheme||b;// Get initial raw props of the child
-// Prefer child's own theme
+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(f.nodetheme===g&&f.key!==void 0)return e;var h=this._generateKey({nodeIndex:c,element:e.element,existingKey:f.key,children:f.children});// Generate key if needed
-return new BaseNode(e.element,_objectSpread(_objectSpread({},f),{},{nodetheme:g,// Use the determined theme for the new node
-key:h}));// Create a new BaseNode with merged props and theme
+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"===d||"number"===d||"boolean"===d||null===a||void 0===a)return a;// Case 3: Child is a function that needs to be called during render (FunctionRenderer).
-if(this._isFunctionChild(a)){var i=this._generateKey({nodeIndex:c,element:this._functionRenderer});return new BaseNode(this._functionRenderer,{processRawNode:this._processRawNode.bind(this),render:a,passedTheme:b,key:i})}// Case 4: Child is a React Element (JSX element like <div> or <MyComponent>)
-if(isValidElement(a)){var j=a.props,k=j.style,l=_objectWithoutProperties(j,_excluded4),m=_objectSpread(_objectSpread({},l),k||{}),n=m.theme||m.nodetheme||b,o=this._generateKey({nodeIndex:c,element:a.type,existingKey:a.key,children:m.children});return new BaseNode(a.type,_objectSpread(_objectSpread({},m),{},{nodetheme:n,key:o}))}// Case 5: Child is an ElementType (string tag, class component, Memo/ForwardRef)
-if(isReactClassComponent(a)||"object"===d&&(isMemo(a)||isForwardRef(a))){var p,q=this._generateKey({nodeIndex:c,element:a,children:"object"===_typeof(a)&&"props"in a?null===(p=a.props)||void 0===p?void 0:p.children:void 0});// ElementTypes don't have an intrinsic key from the rawNode itself.
-return new BaseNode(a,{nodetheme:b,// Apply parent theme
-key:q})}// Case 6: Handle instances of React.Component
-if(a instanceof React.Component){var r=a.render();// Recursively process the rendered element with a parent theme and index if available
-return this._processRawNode(r,b,c)}// Case 7: Fallback for other ReactNode types (e.g., Fragments, Portals if not caught by isValidElement)
+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.
 return a}/**
@@ -230,7 +179,7 @@ return a}/**
    * @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,_excluded5),h=void 0;if(d!==void 0&&null!==d){if(!this._normalizedChildren||this._childrenHash!==createStableHash(d,this.props.nodetheme||this.props.theme))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
+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
@@ -285,7 +234,7 @@ return this._portalReactRoot}}}/**
  * @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,"_processedChildrenWeakCache",new WeakMap),_defineProperty(BaseNode,"_processedChildrenMapCache",new Map),_defineProperty(BaseNode,"_MAX_PROCESSED_CHILDREN_CACHE",1e3);export function Node(a){var b=1<arguments.length&&void 0!==arguments[1]?arguments[1]:{},c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:{},d=_objectSpread(_objectSpread({},b),c);return d.theme&&!d.nodetheme&&(d.nodetheme=d.theme),new BaseNode(a,d)}/**
+ */_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)}/**
  * 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>`.

package/dist/helper/node.helper.d.ts

@@ -1,5 +1,5 @@
 import type { CSSProperties } from 'react';
-import type { Children, NodeInstance, Theme } from '../node.type.js';
+import type { NodeInstance } from '../node.type.js';
 /**
  * Type guard to check if an object is a NodeInstance.
  *
@@ -893,14 +893,4 @@ export declare const resolveDefaultStyle: (style: CSSProperties) => {
     minHeight: import("csstype").Property.MinHeight<string | number>;
     minWidth: import("csstype").Property.MinWidth<string | number>;
 };
-/**
- * Public: createStableHash
- * Produces a deterministic string signature for children + theme.
- * Keep traversal limited so it is cheap in large trees.
- *
- * If you prefer a shorter hashed output, wrap the returned string in a lightweight
- * hash function (fnv1a, xxhash, etc.). Returning the full signature is useful
- * for debugging and deterministic comparisons.
- */
-export declare function createStableHash(children: Children, theme?: Theme): string;
 //# sourceMappingURL=node.helper.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"node.helper.d.ts","sourceRoot":"","sources":["../../src/helper/node.helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAItE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,4CAS1B,CAAA;AA4DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE/B,CAAA;AA8FD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,KAAK,UAIjE"}
+{"version":3,"file":"node.helper.d.ts","sourceRoot":"","sources":["../../src/helper/node.helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,4CAS1B,CAAA;AA4DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE/B,CAAA"}

package/dist/helper/node.helper.js

@@ -1,4 +1,4 @@
-"use strict";var _excluded=["flex"];function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}import{getElementTypeName}from"./common.helper.js";import{ObjHelper}from"./obj.helper.js";/**
+"use strict";var _excluded=["flex"];function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}/**
  * Type guard to check if an object is a NodeInstance.
  *
  * A NodeInstance is expected to be a non-null object with:
@@ -109,24 +109,4 @@ if(!f){var k="column"===d.flexDirection||"column-reverse"===d.flexDirection,l="r
 return _objectSpread({flex:c,// Preserve original flex shorthand
 flexShrink:j,// Apply computed or explicit flexShrink
 minHeight:0,// Fix flex item scrolling issues
-minWidth:0},d)};/**
- * Create a stable signature for a React node (children) with bounded traversal.
- * This focuses on the structural identity important for rendering decisions:
- * - element type (string or component name)
- * - key (if present)
- * - basic children shape (recursing within limits)
- */function nodeSignature(a){var b=Math.min,c=1<arguments.length&&void 0!==arguments[1]?arguments[1]:5,d=2<arguments.length&&void 0!==arguments[2]?arguments[2]:6,e=3<arguments.length&&void 0!==arguments[3]?arguments[3]:new WeakSet;if(null===a)return"null";if(void 0===a)return"undefined";var f=_typeof(a);if("string"===f)return"s:".concat(a);if("number"===f)return"n:".concat(a+"");if("boolean"===f)return"b:".concat(a+"");if("function"===f)return"\u0192:(".concat(a+"",")");if("symbol"===f)return"sym:".concat(a+"");// Circular reference check for all objects
-if("object"===f){if(e.has(a))return"[Circular]";e.add(a)}// Arrays
-if(Array.isArray(a)){if(0>=c)return"ary[...]";for(var g=[],h=b(a.length,d),j=0;j<h;j++)g.push(nodeSignature(a[j],c-1,d,e));return a.length>d&&g.push("...len:".concat(a.length)),"ary[".concat(g.join(","),"]")}// React element-ish: require a 'type' property
-if("object"===f&&a&&"type"in a){// Type can be string (div) or function/class. Use helper to get name.
-var l,m=a.type;try{l=getElementTypeName(m)}catch(a){try{l=m+""}catch(a){l="unknown"}}var n,o="object"===f&&"key"in a&&null!=a.key?"#".concat(a.key+""):"",p="props"in a&&"object"===_typeof(a.props)&&a.props||{};try{n=nodeSignature(p.children,c-1,d,e)}catch(a){n="<err>"}var q=p.id?"@id:".concat(p.id+""):"",r=p.className?"@class:".concat(p.className+""):"";return"el:".concat(l).concat(o).concat(q).concat(r,"{").concat(n,"}")}// Plain object: handles any other object
-if("object"===f&&a){if(0>=c)return"obj[...]";for(var s,t=Object.keys(a).sort(),u=[],v=b(t.length,d),w=0;w<v;w++){s=t[w];try{u.push("".concat(s,":").concat(nodeSignature(a[s],c-1,d,e)))}catch(a){u.push("".concat(s,":<err>"))}}return t.length>d&&u.push("...keys:".concat(t.length)),"obj{".concat(u.join(","),"}")}// Fallback
-try{return"o:".concat(a+"")}catch(a){return"o:<unserializable>"}}/**
- * Public: createStableHash
- * Produces a deterministic string signature for children + theme.
- * Keep traversal limited so it is cheap in large trees.
- *
- * If you prefer a shorter hashed output, wrap the returned string in a lightweight
- * hash function (fnv1a, xxhash, etc.). Returning the full signature is useful
- * for debugging and deterministic comparisons.
- */export function createStableHash(a,b){var c=b?ObjHelper.stringify(b,6):"theme:undefined",d=nodeSignature(a,6,8);return"".concat(c,"|").concat(d)}
+minWidth:0},d)};

package/dist/helper/theme.helper.d.ts

@@ -1,64 +1,4 @@
-import type { Theme } from '../node.type.js';
-/**
- * Cache manager for theme resolution operations.
- * Provides singleton-based caching with different strategies for server vs client environments.
- */
-declare class ThemeResolverCache {
-    private static _instance;
-    private readonly _resolutionCache;
-    private readonly _pathLookupCache;
-    private readonly _themeRegex;
-    // Track cache statistics for performance monitoring
-    private _stats;
-    private constructor();
-    /**
-     * Get the singleton instance of the cache manager
-     */
-    static getInstance(): ThemeResolverCache;
-    /**
-     * Generate a stable cache key from object and theme
-     */
-    private _generateCacheKey;
-    /**
-     * Check if resolution result exists in cache
-     */
-    getResolution(obj: Record<string, any>, theme: Theme): any | null;
-    /**
-     * Store resolution result in cache
-     */
-    setResolution(obj: Record<string, any>, theme: Theme, result: any): void;
-    /**
-     * Get cached theme path lookup
-     */
-    getPathLookup(theme: Theme, path: string): any | null;
-    /**
-     * Cache theme path lookup result
-     */
-    setPathLookup(theme: Theme, path: string, value: any): void;
-    /**
-     * Get the shared regex instance (reused for performance)
-     */
-    getThemeRegex(): RegExp;
-    /**
-     * Clear all caches (useful for testing or memory management)
-     */
-    clearCaches(): void;
-    /**
-     * Get cache statistics for performance monitoring
-     */
-    getStats(): {
-        hits: number;
-        misses: number;
-        pathHits: number;
-        pathMisses: number;
-    };
-    /**
-     * Check if we should use caching (server-side only for RSC optimization)
-     */
-    shouldCache(): boolean;
-}
-// Module-level cache instance
-declare const themeCache: ThemeResolverCache;
+import type { ThemeSystem } from '../node.type.js';
 /**
  * Resolves theme variable references in an object's values recursively.
  * This function performs a "smart merge" to maintain object reference identity
@@ -71,9 +11,5 @@ declare const themeCache: ThemeResolverCache;
  * @returns A new object (or array) with all theme variables resolved to their corresponding values,
  * or the original object (or array) if no changes were necessary.
  */
-export declare const resolveObjWithTheme: (obj?: Record<string, any>, theme?: Partial<{
-    [key: string]: any;
-}> | undefined) => any;
-// Export cache instance for testing and monitoring
-export { themeCache as ThemeResolverCache };
+export declare const resolveObjWithTheme: (obj?: Record<string, any>, theme?: ThemeSystem | undefined) => any;
 //# sourceMappingURL=theme.helper.d.ts.map

package/dist/helper/theme.helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.helper.d.ts","sourceRoot":"","sources":["../../src/helper/theme.helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAG9C;;;GAGG;AACH,cAAM,kBAAkB;IACtB,OAAO,CAAC,MAAM,CAAC,SAAS,CAAkC;IAE1D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyB;IAC1D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyB;IAC1D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAE1D,oDAAoD;IACpD,OAAO,CAAC,MAAM,CAKb;IAED,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,kBAAkB,CAKvC;IAED;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG,GAAG,IAAI,CAUhE;IAED;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,IAAI,CAGvE;IAED;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAUpD;IAED;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAG1D;IAED;;OAEG;IACH,aAAa,IAAI,MAAM,CAItB;IAED;;OAEG;IACH,WAAW,IAAI,IAAI,CAIlB;IAED;;OAEG;IACH,QAAQ;;;;;MAEP;IAED;;OAEG;IACH,WAAW,IAAI,OAAO,CAErB;CACF;AAED,8BAA8B;AAC9B,QAAA,MAAM,UAAU,oBAAmC,CAAA;AAEnD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB;;sBAwI/B,CAAA;AAED,mDAAmD;AACnD,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,CAAA"}
+{"version":3,"file":"theme.helper.d.ts","sourceRoot":"","sources":["../../src/helper/theme.helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AA8GpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,qEAwI/B,CAAA"}

package/dist/helper/theme.helper.js

@@ -1,4 +1,4 @@
-function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}import{getValueByPath}from"./common.helper.js";import{ObjHelper}from"./obj.helper.js";/**
+function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}import{getValueByPath}from"./common.helper.js";import{ObjHelper}from"./obj.helper.js";/**
  * Cache manager for theme resolution operations.
  * Provides singleton-based caching with different strategies for server vs client environments.
  */class ThemeResolverCache{constructor(){// Track cache statistics for performance monitoring
@@ -19,10 +19,6 @@ return"".concat(ObjHelper.stringify(a),"_").concat(ObjHelper.stringify(b))}/**
    */setPathLookup(a,b,c){var d="".concat(ObjHelper.stringify(a),"_").concat(b);this._pathLookupCache.set(d,c)}/**
    * Get the shared regex instance (reused for performance)
    */getThemeRegex(){return this._themeRegex.lastIndex=0,this._themeRegex}/**
-   * Clear all caches (useful for testing or memory management)
-   */clearCaches(){this._resolutionCache.clear(),this._pathLookupCache.clear(),this._stats={hits:0,misses:0,pathHits:0,pathMisses:0}}/**
-   * Get cache statistics for performance monitoring
-   */getStats(){return _objectSpread({},this._stats)}/**
    * Check if we should use caching (server-side only for RSC optimization)
    */shouldCache(){return"undefined"==typeof window}}// Module-level cache instance
 _defineProperty(ThemeResolverCache,"_instance",null);var themeCache=ThemeResolverCache.getInstance();/**
@@ -55,5 +51,4 @@ g=g.replace(i,function(a,c){// Check path lookup cache first
 var d=themeCache.getPathLookup(b,c);return null===d&&(d=getValueByPath(b,c),themeCache.setPathLookup(b,c,d)),void 0!==d&&null!==d?(h=!0,"object"===_typeof(d)&&!Array.isArray(d)&&"default"in d?d["default"]:d):a}),f=h&&g!==e?g:e}else"object"===_typeof(e)&&null!==e&&(// Recursively process nested objects or arrays
 f=d(e,c));f===e?l&&(k[n]=e):(!l&&(k=_objectSpread({},a),l=!0),k[n]=f)};for(var n in a)m();return k},e=d(a,new Set);// Perform the resolution
 // Cache the result (only on server-side)
-return themeCache.shouldCache()&&themeCache.setResolution(a,b,e),e};// Export cache instance for testing and monitoring
-export{themeCache as ThemeResolverCache};
+return themeCache.shouldCache()&&themeCache.setResolution(a,b,e),e};

package/dist/hoc/component.hoc.d.ts

@@ -1,32 +1,29 @@
-import type { Children, ComponentNode, HasCSSCompatibleStyleProp, Theme } from '../node.type.js';
+import type { Children, ComponentNode, HasCSSCompatibleStyleProp } from '../node.type.js';
 import { type CSSProperties, type ReactElement } from 'react';
 /**
  * Props definition for components wrapped using the `Component` higher-order function.
  *
  * This type adapts based on whether the underlying component defines its own props:
  *
- * - If `TProps` is `undefined`, only `children` and `theme` can be passed.
+ * - If `TProps` is `undefined`, only `children` can be passed.
  * - If `TProps` is defined, the component will accept:
  *   - The full prop shape `TProps`
  *   - Optional `props` to override part of `TProps` (excluding `children`)
  *   - Optional `children`
- *   - Optional `theme`
  *
  * If the component supports inline styles (determined via `HasCSSCompatibleStyleProp`), the props also allow `CSSProperties`.
  */
 export type ComponentNodeProps<TProps> = TProps extends undefined ? Partial<{
     children: Children;
-    theme: Theme;
 }> : TProps & (HasCSSCompatibleStyleProp<TProps> extends true ? CSSProperties : object) & Partial<{
     props: Partial<Omit<TProps, 'children'>>;
     children: Children;
-    theme: Theme;
 }>;
 /**
  * Creates a component from a function that uses no custom props.
  * @template TProps Must be `undefined`
- * @param component A function that returns a MeoNode `ComponentNode` and only uses basic props like `children` and `theme`.
- * @returns A React-compatible component that can accept `children` and `theme`.
+ * @param component A function that returns a MeoNode `ComponentNode` and only uses basic props like `children`.
+ * @returns A React-compatible component that can accept `children`.
  * @example
  * ```ts
  * const Title = Component((props) => {
@@ -41,7 +38,7 @@ export declare function Component<TProps extends undefined>(component: (props: C
  * Creates a component from a function that uses a defined props interface.
  * @template TProps Props interface expected by the component.
  * @param component A function that returns a MeoNode `ComponentNode` using props of type `TProps`.
- * @returns A React-compatible component that supports full prop shape and `theme`/`children`/`props` overrides.
+ * @returns A React-compatible component that supports full prop shape and `children`/`props` overrides.
  * @example
  * ```ts
  * interface ButtonProps {

package/dist/hoc/component.hoc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.hoc.d.ts","sourceRoot":"","sources":["../../src/hoc/component.hoc.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,yBAAyB,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAClG,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAkB,MAAM,OAAO,CAAA;AAG7E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS,SAAS,GAC7D,OAAO,CAAC;IACN,QAAQ,EAAE,QAAQ,CAAA;IAClB,KAAK,EAAE,KAAK,CAAA;CACb,CAAC,GACF,MAAM,GACJ,CAAC,yBAAyB,CAAC,MAAM,CAAC,SAAS,IAAI,GAAG,aAAa,GAAG,MAAM,CAAC,GACzE,OAAO,CAAC;IACN,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;IACxC,QAAQ,EAAE,QAAQ,CAAA;IAClB,KAAK,EAAE,KAAK,CAAA;CACb,CAAC,CAAA;AAER;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,SAAS,EAChD,SAAS,EAAE,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,aAAa,GAC9D,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA;AAExF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1D,SAAS,EAAE,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,aAAa,GAC9D,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA"}
+{"version":3,"file":"component.hoc.d.ts","sourceRoot":"","sources":["../../src/hoc/component.hoc.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAC3F,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAkB,MAAM,OAAO,CAAA;AAI7E;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS,SAAS,GAC7D,OAAO,CAAC;IACN,QAAQ,EAAE,QAAQ,CAAA;CACnB,CAAC,GACF,MAAM,GACJ,CAAC,yBAAyB,CAAC,MAAM,CAAC,SAAS,IAAI,GAAG,aAAa,GAAG,MAAM,CAAC,GACzE,OAAO,CAAC;IACN,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;IACxC,QAAQ,EAAE,QAAQ,CAAA;CACnB,CAAC,CAAA;AAER;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,SAAS,EAChD,SAAS,EAAE,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,aAAa,GAC9D,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA;AAExF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1D,SAAS,EAAE,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,aAAa,GAC9D,CAAC,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA"}