@meonode/ui 0.2.14 → 0.2.15

package/CHANGELOG.md

@@ -5,71 +5,107 @@ 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.2.15] - 2025-09-12
+
+### Added
+
+- **feat(cache)**: implement hybrid caching strategy for processed children using WeakMap and Map to improve performance
+  and memory management
+- **feat(helper)**: implement nodeSignature for stable signatures and improve createStableHash with bounded traversal
+- **feat(helper)**: enhance ObjHelper.stringify method for deterministic serialization with sorted keys and special type
+  handling
+
+### Refactor
+
+- **refactor**: improve type definitions and error handling in rendering methods
+
+### Test
+
+- **test(tests)**: add performance tests for rendering a single-page layout in React
+- **test**: add cleanup after each test and verify component display names for debugging
+
 ## [0.2.14] - 2025-09-12
 
 ### Added
+
 - **feat**: Add `Container` alias for `Div` to simplify general-purpose container usage.
 - **feat**: Add caching for processed children to optimize performance in `BaseNode` class.
 
 ### Removed
+
 - **feat**: Remove `shallowEqual` utility function from `common.helper.ts`.
 
 ### Fixed
+
 - **feat**: Improve performance by optimizing existing key checks and handling null values in rendering functions.
 
 ## [0.2.13] - 2025-09-11
 
 ### Added
+
 - **feat**: Add pre-commit hook for linting and testing, update package.json scripts.
 - **feat**: Add Jest configuration and setup for testing with TypeScript.
 - **test**: Add comprehensive tests for BaseNode core functionality.
 
 ### Fixed
-- **core**: Remove stylable elements from NO_STYLE_TAGS to ensure only non-visual/metadata tags are excluded from CSS styling.
+
+- **core**: Remove stylable elements from NO_STYLE_TAGS to ensure only non-visual/metadata tags are excluded from CSS
+  styling.
 
 ## [0.2.12] - 2025-09-11
 
 ### Fixed
-- **core.node**: Removed the child processing cache to fix a critical bug that caused infinite page loads in server-side rendering environments.
+
+- **core.node**: Removed the child processing cache to fix a critical bug that caused infinite page loads in server-side
+  rendering environments.
 - **helper**: Corrected the element type retrieval logic within the hashing function used for child node processing.
 
 ## [0.2.11] - 2025-09-11
 
 ### Enhanced
-- **core.node**: Significantly improved JSDoc documentation for the `BaseNode` class, providing better clarity on prop processing, child handling, and rendering logic.
-- **core.node**: Overhauled the child processing and caching mechanism to improve server-side performance and resolve a memory leak. This includes a move from object stringification to a more performant hashing strategy for cache keys and the introduction of a cache management policy.
+
+- **core.node**: Significantly improved JSDoc documentation for the `BaseNode` class, providing better clarity on prop
+  processing, child handling, and rendering logic.
+- **core.node**: Overhauled the child processing and caching mechanism to improve server-side performance and resolve a
+  memory leak. This includes a move from object stringification to a more performant hashing strategy for cache keys and
+  the introduction of a cache management policy.
 
 ### Fixed
+
 - **helper**: Corrected an issue in flexbox style processing where an unnecessary string check was performed.
 - **core.node**: Updated a function placeholder to adhere to the unused parameter naming convention.
 
 ## [0.2.10] - 2025-09-10
 
 ### Added
-- **core**: add top-level `render` function for a cleaner and simpler API when mounting a Meonode instance to the DOM. This abstracts away the need to manually use `react-dom/client`.
-  - **Before**:
-    ```typescript
-    import { createRoot } from 'react-dom/client';
-    import { Div } from '@meonode/ui';
 
-    const container = document.getElementById('root');
-    const root = createRoot(container);
-    root.render(Div({ children: 'Hello' }).render());
-    ```
-  - **After**:
-    ```typescript
-    import { Div } from '@meonode/ui';
-    import { render } from '@meonode/ui/client';
-
-    const container = document.getElementById('root');
-    render(Div({ children: 'Hello' }), container);
-    ```
+- **core**: add top-level `render` function for a cleaner and simpler API when mounting a Meonode instance to the DOM.
+  This abstracts away the need to manually use `react-dom/client`.
+    - **Before**:
+      ```typescript
+      import { createRoot } from 'react-dom/client';
+      import { Div } from '@meonode/ui';
+  
+      const container = document.getElementById('root');
+      const root = createRoot(container);
+      root.render(Div({ children: 'Hello' }).render());
+      ```
+    - **After**:
+      ```typescript
+      import { Div } from '@meonode/ui';
+      import { render } from '@meonode/ui/client';
+  
+      const container = document.getElementById('root');
+      render(Div({ children: 'Hello' }), container);
+      ```
 - **constants**: add `NO_STYLE_TAGS` array and `noStyleTagsSet` for quick lookup of tags that should not receive styles
 
 ### Enhanced
+
 - **core**: enhance `StyledRenderer` integration to check for no-style tags
 
 ### Changed
+
 - **helper**: update CSS property set to use constants and add no-style tag check
 - **package**: update dependencies to latest versions
 - **directory**: rename `data` directory to `constants` for clarity
@@ -78,14 +114,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.2.9] - 2025-09-05
 
 ### Fixed
+
 - **core.types**: corrected `MergedProps` definition to restore proper TypeScript inference and props autocomplete
-    - Fixes regression from v0.2.8 where `createNode` and `createChildrenFirstNode` lost autocomplete for props due to incorrect `MergedProps` typing
+    - Fixes regression from v0.2.8 where `createNode` and `createChildrenFirstNode` lost autocomplete for props due to
+      incorrect `MergedProps` typing
 
 ## [0.2.8] - 2025-09-05
 
 ### Changed
+
 - **core.node**: refactor props handling to use a single utility type:
-    - `MergedProps<E, AdditionalProps>` — merges `NodeProps<E>` with custom props, giving precedence to overlapping keys from `AdditionalProps`.
+    - `MergedProps<E, AdditionalProps>` — merges `NodeProps<E>` with custom props, giving precedence to overlapping keys
+      from `AdditionalProps`.
 - Simplifies and unifies the typing system for node factories (`createNode`, `createChildrenFirstNode`).
 - Improves developer experience when working with prebuilt components:
     - Example:
@@ -100,11 +140,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
         onChange: ({ target }) => console.log(target.value),
       })
       ```
-  Extending prebuilt components is now safer and more predictable, with generic props always taking precedence when keys overlap.
+  Extending prebuilt components is now safer and more predictable, with generic props always taking precedence when keys
+  overlap.
 
 - **helpers**: reorganize helper files and update import paths
 
 ### Fixed
+
 - **styled-renderer**: make `children` prop optional in `StyledRendererProps`
 
 ## [0.2.7] - 2025-09-04
@@ -116,7 +158,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.2.6] - 2025-09-04
 
 - **deps**: update TypeScript ESLint, native-preview, and jsdoc to latest versions
-- **core.node**: improve generateIndexedKeyIfNeeded to accept object parameters and enhance key uniqueness with children count
+- **core.node**: improve generateIndexedKeyIfNeeded to accept object parameters and enhance key uniqueness with children
+  count
 - **imports**: update import paths to include file extensions for compatibility
 
 ## [0.2.5] - 2025-09-03
@@ -126,6 +169,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.2.4] - 2025-09-02
 
 ### Added
+
 - **core**: Exposed the original element via the created Node for easier access and debugging.
     ```typescript
     import { createNode } from "@meonode/ui";
@@ -140,49 +184,61 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.2.3] - 2025-09-01
 
 ### Fixed
+
 - **types**: Remove forbidden css import to resolve RSC error
 
 ### Changed
+
 - **package**: Bump version to 0.2.3
 
 ## [0.2.2] - 2025-09-01
 
 ### Added
+
 - **core**: Include nativeProps in props extraction for improved component flexibility
 
 ### Enhanced
+
 - **types**: Enhance StyledRendererProps and FinalNodeProps for improved type safety
 
 ### Changed
+
 - **package**: Bump version to 0.2.2
 
 ## [0.2.1] - 2025-09-01
 
 ### Changed
+
 - **types**: Update CSS type from CSSObject to CSSInterpolation for better compatibility
 - **package**: Bump version to 0.2.1
 
 ## [0.2.0] - 2025-08-31
 
 ### Added
+
 - **docs**: Add badges for NPM version, license, and bundle size to README
 
 ### Enhanced
+
 - **docs**: Update installation instructions and enhance clarity in core concepts
 - **docs**: Enhance documentation with new examples and improved clarity
 
 ### Removed
+
 - **package**: Remove deprecated hook entry from package.json
 
 ### Fixed
+
 - **core.node**: Add suppressHydrationWarning to propsForCreateElement
 
 ### Changed
+
 - **package**: Bump version to 0.2.0
 
 ## [0.1.121] - 2025-08-30
 
 ### Changed
+
 - **core.node**: Simplify style resolution and improve prop handling
 - **StyledRenderer**: Remove unused style prop and simplify component
 - **package**: Bump version to 0.1.121
@@ -190,6 +246,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.120] - 2025-08-30
 
 ### Added
+
 - **styles**: Add Emotion support and Next.js style registry integration
     - Add @emotion/react and @emotion/cache dependencies
     - Add StyledRenderer and StyleRegistry components for Emotion
@@ -197,37 +254,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     - Add nextjs-registry export for Next.js style registry
 
 ### Enhanced
+
 - **core**: Enhance style handling with StyledRenderer for Emotion support
 
 ### Fixed
+
 - **deps**: Update peerDependencies for Emotion and React to use version constraints
 - **deps**: Update @types/react and @types/react-dom to latest versions
 
 ### Changed
+
 - **package**: Update peerDependencies for @emotion/cache
 - **package**: Bump version to 0.1.120
 
 ## [0.1.118] - 2025-08-30
 
 ### Fixed
+
 - **deps**: Update peerDependencies for Emotion and React to use version constraints
 
 ### Changed
+
 - **package**: Bump version to 0.1.118
 
 ## [0.1.117] - 2025-08-30
 
 ### Added
+
 - **flexbox**: Improve default style resolution and add flex shorthand parser
     - Add parseFlexShorthand to extract flex-grow, shrink, and basis
     - Enhance resolveDefaultStyle to respect explicit flex/flexShrink values
     - Improve handling of minHeight, minWidth, and flexShrink for flex items
 
 ### Enhanced
+
 - **core**: Refine type of finalChildren for improved type safety
 - **docs**: Update documentation for clarity on flexbox scrolling fixes
 
 ### Changed
+
 - **core**: Move comments position for better readability
 - **imports**: Remove .js extensions from internal imports
 - **package**: Bump version to 0.1.117
@@ -235,6 +300,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.116] - 2025-08-27
 
 ### Changed
+
 - **package**: Bump version to 0.1.116
 
 ---

package/dist/components/styled-renderer.client.js

@@ -1 +1 @@
-"use client";var _excluded=["element","css","children"];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)}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}import{jsx}from"@emotion/react";export default function StyledRenderer(a){var b=a.element,c=a.css,d=a.children,e=_objectWithoutProperties(a,_excluded);return jsx(b,_objectSpread(_objectSpread({},e),{},{css:c}),d)}
+"use client";var _excluded=["element","css","children"];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)}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}import{jsx}from"@emotion/react";export default function StyledRenderer(a){var b=a.element,c=a.css,d=a.children,e=_objectWithoutProperties(a,_excluded);return jsx(b,_objectSpread(_objectSpread({},e),{},{css:c}),d)}StyledRenderer.displayName="Styled";

package/dist/core.node.d.ts

@@ -1,5 +1,5 @@
-import { type ElementType, type ReactNode, type ReactElement } from 'react';
-import type { MergedProps, FinalNodeProps, HasRequiredProps, NodeElement, NodeInstance, NodeProps, PropsOf, RawNodeProps, Theme } from './node.type.js';
+import React, { type ElementType, type ReactElement, type ReactNode } from 'react';
+import type { FinalNodeProps, HasRequiredProps, MergedProps, NodeElement, NodeInstance, NodeProps, PropsOf, RawNodeProps, Theme } from './node.type.js';
 import { type Root as ReactDOMRoot } from 'react-dom/client';
 /**
  * Represents a node in a React component tree with theme and styling capabilities.
@@ -27,8 +27,18 @@ export declare class BaseNode<E extends NodeElement> implements NodeInstance<E>
     private _childrenHash?;
     /** Cache for normalized children */
     private _normalizedChildren?;
-    /** Cache for processed children to avoid redundant processing */
-    private static _processedChildrenCache;
+    /**
+     * WeakMap cache for processed children, keyed by object/array identity for GC friendliness.
+     * Each entry stores the hash, processed children, and a server-side flag.
+     */
+    private static _processedChildrenWeakCache;
+    /**
+     * Map cache for processed children, keyed by a stable string signature.
+     * Used for non-object cases or as a fallback. Each entry stores the processed children and a server-side flag.
+     */
+    private static _processedChildrenMapCache;
+    /** Maximum number of entries in the Map cache to prevent unbounded growth */
+    private static readonly _MAX_PROCESSED_CHILDREN_CACHE = 1000;
     /**
      * Constructs a new BaseNode instance.
      *
@@ -62,21 +72,42 @@ export declare class BaseNode<E extends NodeElement> implements NodeInstance<E>
      */
     private _processProps;
     /**
-     * Attempts to retrieve cached processed children based on the current children and theme.
-     * This method uses a WeakMap for client-side caching and skips caching on the server.
-     * @param children
-     * @param theme
+     * 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).
+     *
+     * 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
+     */
+    private static _cloneProcessedChildren;
+    /**
+     * 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
      */
     private _getCachedChildren;
     /**
      * Caches processed children for a given set of children and theme.
-     * This method stores the processed ReactNode in a WeakMap for client-side caching,
-     * avoiding redundant processing of the same children-theme combination.
-     * No caching is performed on the server to avoid memory leaks.
+     * 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 ReactNode to cache.
+     * @param processed The processed NodeElement(s) to cache.
      * @private
      */
     private _setCachedChildren;
@@ -85,7 +116,7 @@ export declare class BaseNode<E extends NodeElement> implements NodeInstance<E>
      * and propagating the provided theme.
      *
      * This method ensures consistent theme handling for all children and optimizes performance
-     * using caching strategies: a WeakMap for client-side and no caching for server-side.
+     * using caching strategies: a Map for client-side and no caching for server-side.
      *
      * - If `children` is an array, each child is processed individually.
      * - If `children` is a single node, it is processed directly.
@@ -114,7 +145,7 @@ export declare class BaseNode<E extends NodeElement> implements NodeInstance<E>
      * @private
      * @static
      */
-    static _renderProcessedNode(processedElement: NodeElement, passedTheme: Theme | undefined, passedKey: string | undefined): ReactNode;
+    static _renderProcessedNode(processedElement: NodeElement, passedTheme: Theme | undefined, passedKey: string | undefined): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined> | ReactElement<any, string | React.JSXElementConstructor<any>> | null | undefined;
     /**
      * Renders the output of a function-as-a-child, ensuring theme propagation.
      *
@@ -194,7 +225,7 @@ export declare class BaseNode<E extends NodeElement> implements NodeInstance<E>
      * @returns The rendered `ReactElement`.
      * @throws {Error} If the node's `element` is not a valid React element type.
      */
-    render(): ReactElement;
+    render(): ReactElement<FinalNodeProps>;
     /**
      * Ensures the necessary DOM elements for portal rendering are created and attached.
      *
@@ -233,7 +264,7 @@ export declare function Node<AdditionalProps extends Record<string, any>, E exte
 /**
  * Creates a curried node factory for a given React element or component type.
  *
- * Returns a function that, when called with props, produces a `BaseNode` instance.
+ * 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.

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,OAAO,KAAK,EAAE,EAAsC,KAAK,WAAW,EAAsC,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC1J,OAAO,KAAK,EACV,cAAc,EAEd,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,SAAS,EACT,OAAO,EACP,YAAY,EACZ,KAAK,EACN,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAc,KAAK,IAAI,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAKxE;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACrE,+EAA+E;IACxE,OAAO,EAAE,CAAC,CAAA;IACjB,kFAAkF;IAC3E,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,CAAK;IACrC,0CAA0C;IAC1C,SAAgB,UAAU,UAAO;IAEjC,wFAAwF;IACxF,OAAO,CAAC,MAAM,CAAC,CAAgB;IAC/B,4CAA4C;IAC5C,OAAO,CAAC,iBAAiB,CAA8B;IACvD,+CAA+C;IAC/C,OAAO,CAAC,gBAAgB,CAA4B;IACpD,+DAA+D;IAC/D,OAAO,CAAC,aAAa,CAAC,CAAQ;IAC9B,oCAAoC;IACpC,OAAO,CAAC,mBAAmB,CAAC,CAAW;IAEvC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAOvC;IAEH;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B,CAMtC;IAEH,6EAA6E;IAC7E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,6BAA6B,QAAO;IAE5D;;;;;;;;OAQG;IACH,YAAY,OAAO,EAAE,CAAC,EAAE,QAAQ,GAAE,YAAY,CAAC,CAAC,CAAM,EAGrD;IAED;;;;;;;OAOG;IACH,IAAW,KAAK,IAAI,cAAc,CAKjC;IAED;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAqCrB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAiBtC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,kBAAkB;IAuB1B;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;IAkC1B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,4TA2CvH;IAED;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,iBAAiB;IAqCzB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,YAAY,CAwBnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,eAAe;IA0FvB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,eAAe,CA6BtB;IAED;;;;;;;;;;;;;;OAcG;IACI,MAAM,IAAI,YAAY,CAAC,cAAc,CAAC,CAsE5C;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,2BAA2B;IAmCnC;;;;;;;;;;;OAWG;IACI,QAAQ,IAAI,YAAY,GAAG,IAAI,CAqBrC;CACF;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,WAAW,EACrF,OAAO,EAAE,CAAC,EACV,KAAK,GAAE,WAAW,CAAC,CAAC,EAAE,eAAe,CAAyC,EAC9E,eAAe,GAAE,eAAuC,GACvD,YAAY,CAAC,CAAC,CAAC,CAOjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,sBAAsB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,WAAW,EAClG,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;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CAAC,sBAAsB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,WAAW,EAC/G,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,WAAW,GAAG,WAAW,EAAE,EACrC,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,WAAW,GAAG,WAAW,EAAE,EACtC,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

@@ -1,4 +1,4 @@
-"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,{Fragment,createElement,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}from"./helper/common.helper.js";import StyledRenderer from"./components/styled-renderer.client.js";import{resolveObjWithTheme}from"./helper/theme.helper.js";/**
+"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}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.
  * This class wraps React elements and handles:
  * - Props processing and normalization
@@ -67,29 +67,52 @@ return a}),this.element=a,this.rawProps=c}/**
 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);// Process children while maintaining theme inheritance
 // Combine processed props into final normalized form
 return _objectSpread(_objectSpread({ref:b,key:c,nodetheme:j,theme:f,css:_objectSpread(_objectSpread({},u),q),style:o},t),{},{nativeProps:m,children:v})}/**
-   * Attempts to retrieve cached processed children based on the current children and theme.
-   * This method uses a WeakMap for client-side caching and skips caching on the server.
-   * @param children
-   * @param theme
+   * 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).
+   *
+   * 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){// Only cache on client-side, and with server-side detection
-if("undefined"==typeof window)return null;// No server caching
-var c=BaseNode._processedChildrenCache.get({children:a,theme:b}),d=createStableHash(a,b);return(null===c||void 0===c?void 0:c.hash)!==d||c.isServerSide?null:c.children}/**
+   */_getCachedChildren(a,b){if("undefined"==typeof window)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 ReactNode in a WeakMap for client-side caching,
-   * avoiding redundant processing of the same children-theme combination.
-   * No caching is performed on the server to avoid memory leaks.
+   * 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 ReactNode to cache.
+   * @param processed The processed NodeElement(s) to cache.
    * @private
-   */_setCachedChildren(a,b,c){// Only cache on client-side to avoid RSC issues
-if("undefined"!=typeof window){var d=createStableHash(a,b);BaseNode._processedChildrenCache.set({children:a,theme:b},{hash:d,children:c,isServerSide:!1})}}/**
+   */_setCachedChildren(a,b,c){if("undefined"!=typeof window){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 WeakMap for client-side and no caching for server-side.
+   * using caching strategies: a Map for client-side and no caching for server-side.
    *
    * - If `children` is an array, each child is processed individually.
    * - If `children` is a single node, it is processed directly.
@@ -200,7 +223,9 @@ return a}/**
 var c=this.props,d=c.children,e=c.key,f=c.nativeProps,g=_objectWithoutProperties(c,_excluded5),h=void 0;if(void 0!==d&&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}// Prepare props for React.createElement
 var j;// 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
-return j=this.element===Fragment||isFragment(this.element)?{key:e}:_objectSpread(_objectSpread(_objectSpread({},g),{},{key:e},f),{},{suppressHydrationWarning:!0}),this.element&&!hasNoStyleTag(this.element)&&j.css?createElement(StyledRenderer,_objectSpread({element:this.element},j),h):createElement(this.element,j,h)}/**
+if(j=this.element===Fragment||isFragment(this.element)?{key:e}:_objectSpread(_objectSpread(_objectSpread({},g),{},{key:e},f),{},{suppressHydrationWarning:!0}),this.element&&!hasNoStyleTag(this.element)&&j.css){var k=_objectSpread({element:this.element},j);try{var l=getElementTypeName(k.element);StyledRenderer.displayName="Styled(".concat(l,")")}catch(a){// swallow: displayName is not critical
+}return createElement(StyledRenderer,k,h)}try{this.element.displayName=getElementTypeName(this.element)}catch(a){// swallow: displayName is not critical
+}return createElement(this.element,j,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
@@ -234,10 +259,10 @@ if(this._portalDOMElement||(this._portalDOMElement=document.createElement("div")
  * @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,"_processedChildrenCache",new WeakMap);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,"_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)}/**
  * Creates a curried node factory for a given React element or component type.
  *
- * Returns a function that, when called with props, produces a `BaseNode` instance.
+ * 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.

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

@@ -894,24 +894,13 @@ export declare const resolveDefaultStyle: (style: CSSProperties) => {
     minWidth: import("csstype").Property.MinWidth<string | number>;
 };
 /**
- * Creates a stable hash string based on the provided children and optional theme.
+ * Public: createStableHash
+ * Produces a deterministic string signature for children + theme.
+ * Keep traversal limited so it is cheap in large trees.
  *
- * This function generates a hash that represents the structure and types of the given
- * children nodes, along with an optional theme. The hash is designed to be stable across
- * renders, meaning that the same input will always produce the same hash output.
- *
- * The hashing strategy includes:
- * - For arrays of children, it includes the length and samples the types of the first few children.
- * - For single child nodes, it includes the type of the node.
- * - For primitive values (strings, numbers, etc.), it includes their type.
- * - If a theme is provided, it includes a stringified version of the theme.
- *
- * This approach avoids deep traversal of potentially large or complex node trees,
- * focusing instead on key characteristics that are likely to change when the structure
- * or content changes.
- * @param children The child nodes to hash, which can be a single node or an array of nodes.
- * @param theme An optional theme object or string to include in the hash.
- * @returns A stable hash string representing the structure and types of the children and theme.
+ * 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: NodeElement | NodeElement[], 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,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAIzE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,4CAS1B,CAAA;AA4DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE/B,CAAA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CA0B7F"}
+{"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,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAIzE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,4CAS1B,CAAA;AA4DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE/B,CAAA;AAiGD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EAAE,KAAK,CAAC,EAAE,KAAK,UAIpF"}

package/dist/helper/node.helper.js

@@ -110,22 +110,22 @@ 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)};/**
- * Creates a stable hash string based on the provided children and optional theme.
+ * 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()";if("symbol"===f)return"sym:".concat(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: detect common shapes (type + props)
+if("object"===f&&(Object.prototype.hasOwnProperty.call(a,"type")||Object.prototype.hasOwnProperty.call(a,"props"))){var l,m,n=null!==(l=a.type)&&void 0!==l?l:a,o="";// Type can be string (div) or function/class. Use helper to get name.
+try{o=getElementTypeName(n)}catch(a){try{o=n+""}catch(a){o="unknown"}}var p="key"in a&&void 0!==a.key&&null!==a.key?"#".concat(a.key+""):"",q="props"in a&&"object"===_typeof(a.props)?null!==(m=a.props)&&void 0!==m?m:{}:{},r="";try{r=nodeSignature(q.children,c-1,d,e)}catch(a){r="<err>"}var s=q&&"object"===_typeof(q)&&"id"in q&&q.id?"@id:".concat(q.id+""):"",t=q&&"object"===_typeof(q)&&"className"in q&&q.className?"@class:".concat(q.className+""):"";return"el:".concat(o).concat(p).concat(s).concat(t,"{").concat(r,"}")}// Plain object
+if("object"===f&&a&&"object"===_typeof(a)&&!("type"in a)&&!("props"in a)){if(e.has(a))return"[Circular]";if(e.add(a),0>=c)return"obj[...]";for(var u,v=Object.keys(a).sort(),w=[],x=b(v.length,d),y=0;y<x;y++){u=v[y];try{w.push("".concat(u,":").concat(nodeSignature(a[u],c-1,d,e)))}catch(a){w.push("".concat(u,":<err>"))}}return v.length>d&&w.push("...keys:".concat(v.length)),"obj{".concat(w.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.
  *
- * This function generates a hash that represents the structure and types of the given
- * children nodes, along with an optional theme. The hash is designed to be stable across
- * renders, meaning that the same input will always produce the same hash output.
- *
- * The hashing strategy includes:
- * - For arrays of children, it includes the length and samples the types of the first few children.
- * - For single child nodes, it includes the type of the node.
- * - For primitive values (strings, numbers, etc.), it includes their type.
- * - If a theme is provided, it includes a stringified version of the theme.
- *
- * This approach avoids deep traversal of potentially large or complex node trees,
- * focusing instead on key characteristics that are likely to change when the structure
- * or content changes.
- * @param children The child nodes to hash, which can be a single node or an array of nodes.
- * @param theme An optional theme object or string to include in the hash.
- * @returns A stable hash string representing the structure and types of the children and theme.
- */export function createStableHash(a,b){var c=Math.min,d="";if(b&&(d+="t:".concat("object"===_typeof(b)?ObjHelper.stringify(b):b+"",";")),Array.isArray(a)){d+="a:".concat(a.length,";");for(var e,f=c(3,a.length),g=0;g<f;g++)e=a[g],d+=e&&"object"===_typeof(e)&&"type"in e?"c".concat(g,":").concat(getElementTypeName(e),";"):"c".concat(g,":").concat(_typeof(e),";")}else d+=a&&"object"===_typeof(a)&&"type"in a?"s:".concat(getElementTypeName(a),";"):"s:".concat(_typeof(a),";");return d}
+ * 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)}

package/dist/helper/obj.helper.d.ts

@@ -1,5 +1,16 @@
 export declare class ObjHelper {
     private constructor();
+    /**
+     * Build a deterministic, serializable representation of `value`.
+     * - sorts plain object keys
+     * - preserves encoded placeholders for special types
+     * - emits { $type: 'Circular', ref: id } for circular refs
+     */
+    private static buildSerializable;
+    /**
+     * Deterministic stringify: first build a canonical serializable structure
+     * (with sorted object keys and encoded special types), then JSON.stringify it.
+     */
     static stringify(obj: any, space?: number): string;
     static parse(str: string): any;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"obj.helper.d.ts","sourceRoot":"","sources":["../../src/helper/obj.helper.ts"],"names":[],"mappings":"AAWA,qBAAa,SAAS;IACpB,OAAO,eAAiB;IAExB,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,SAAI,GAAG,MAAM,CAiD5C;IAED,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CA+C7B;CACF"}
+{"version":3,"file":"obj.helper.d.ts","sourceRoot":"","sources":["../../src/helper/obj.helper.ts"],"names":[],"mappings":"AAWA,qBAAa,SAAS;IACpB,OAAO,eAAiB;IAExB;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA2FhC;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,SAAI,GAAG,MAAM,CAO5C;IAED,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CA+C7B;CACF"}

package/dist/helper/obj.helper.js

@@ -1 +1,19 @@
-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)}export class ObjHelper{constructor(){}static stringify(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:2,c=new Map,d=new Map,e=0,f=0,g=function replacer(a,b){if("function"==typeof b)return d.has(b)||d.set(b,f++),{$type:"Function",name:b.name||"",id:d.get(b)};if("symbol"===_typeof(b)){var g;return{$type:"Symbol",key:null!==(g=b.description)&&void 0!==g?g:""}}if("bigint"==typeof b)return{$type:"BigInt",value:b.toString()};if(b instanceof Date)return{$type:"Date",value:b.toISOString()};if(b instanceof RegExp)return{$type:"RegExp",source:b.source,flags:b.flags};if(b instanceof Map)return{$type:"Map",entries:Array.from(b.entries())};if(b instanceof Set)return{$type:"Set",values:Array.from(b.values())};if("object"===_typeof(b)&&null!==b){if(c.has(b))return{$type:"Circular",ref:c.get(b)};c.set(b,e++)}return b};return JSON.stringify(a,g,b)}static parse(a){var b=[],c=function reviver(a,b){if(b&&"object"===_typeof(b)&&"$type"in b)switch(b.$type){case"Function":return function FunctionPlaceholder(){throw new Error("Function placeholder called: ".concat(b.name||"anonymous","#").concat(b.id))};case"Symbol":return Symbol(b.key);case"BigInt":return BigInt(b.value);case"Date":return new Date(b.value);case"RegExp":return new RegExp(b.source,b.flags);case"Map":return new Map(b.entries);case"Set":return new Set(b.values);case"Circular":return{$circularRef:b.ref}}return b},d=JSON.parse(a,c),e=function fixCirculars(a){if(a&&"object"===_typeof(a)){if(a.$circularRef!==void 0)return b[a.$circularRef];if(!b.includes(a)){b.push(a);for(var c,d=0,f=Object.keys(a);d<f.length;d++)c=f[d],a[c]=e(a[c])}}return a};return e(d)}}
+function _slicedToArray(a,b){return _arrayWithHoles(a)||_iterableToArrayLimit(a,b)||_unsupportedIterableToArray(a,b)||_nonIterableRest()}function _nonIterableRest(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function _iterableToArrayLimit(b,c){var d=null==b?null:"undefined"!=typeof Symbol&&b[Symbol.iterator]||b["@@iterator"];if(null!=d){var g,h,j,k,l=[],a=!0,m=!1;try{if(j=(d=d.call(b)).next,0===c){if(Object(d)!==d)return;a=!1}else for(;!(a=(g=j.call(d)).done)&&(l.push(g.value),l.length!==c);a=!0);}catch(a){m=!0,h=a}finally{try{if(!a&&null!=d["return"]&&(k=d["return"](),Object(k)!==k))return}finally{if(m)throw h}}return l}}function _arrayWithHoles(a){if(Array.isArray(a))return a}function _createForOfIteratorHelper(b,c){var d="undefined"!=typeof Symbol&&b[Symbol.iterator]||b["@@iterator"];if(!d){if(Array.isArray(b)||(d=_unsupportedIterableToArray(b))||c&&b&&"number"==typeof b.length){d&&(b=d);var e=0,f=function F(){};return{s:f,n:function n(){return e>=b.length?{done:!0}:{done:!1,value:b[e++]}},e:function e(a){throw a},f:f}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var g,h=!0,i=!1;return{s:function s(){d=d.call(b)},n:function n(){var a=d.next();return h=a.done,a},e:function e(a){i=!0,g=a},f:function f(){try{h||null==d["return"]||d["return"]()}finally{if(i)throw g}}}}function _unsupportedIterableToArray(b,c){if(b){if("string"==typeof b)return _arrayLikeToArray(b,c);var a={}.toString.call(b).slice(8,-1);return"Object"===a&&b.constructor&&(a=b.constructor.name),"Map"===a||"Set"===a?Array.from(b):"Arguments"===a||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(a)?_arrayLikeToArray(b,c):void 0}}function _arrayLikeToArray(b,c){(null==c||c>b.length)&&(c=b.length);for(var d=0,f=Array(c);d<c;d++)f[d]=b[d];return f}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)}export class ObjHelper{constructor(){}/**
+   * Build a deterministic, serializable representation of `value`.
+   * - sorts plain object keys
+   * - preserves encoded placeholders for special types
+   * - emits { $type: 'Circular', ref: id } for circular refs
+   */static buildSerializable(a,b,c,d){// primitives & simple types
+if(null===a||a===void 0)return a;var e=_typeof(a);if("string"===e||"number"===e||"boolean"===e)return a;if("function"===e)return c.has(a)||c.set(a,d.nextFunctionId++),{$type:"Function",name:a.name||"",id:c.get(a)};if("symbol"===e){var f;return{$type:"Symbol",key:null!==(f=a.description)&&void 0!==f?f:""}}if("bigint"===e)return{$type:"BigInt",value:a.toString()};// Date
+if(a instanceof Date)return{$type:"Date",value:a.toISOString()};// RegExp
+if(a instanceof RegExp)return{$type:"RegExp",source:a.source,flags:a.flags};// Map
+if(a instanceof Map){var g,h=[],j=_createForOfIteratorHelper(a.entries());try{for(j.s();!(g=j.n()).done;){var l=_slicedToArray(g.value,2),m=l[0],n=l[1];h.push([ObjHelper.buildSerializable(m,b,c,d),ObjHelper.buildSerializable(n,b,c,d)])}}catch(a){j.e(a)}finally{j.f()}return{$type:"Map",entries:h}}// Set
+if(a instanceof Set){var o,p=[],q=_createForOfIteratorHelper(a.values());try{for(q.s();!(o=q.n()).done;){var r=o.value;p.push(ObjHelper.buildSerializable(r,b,c,d))}}catch(a){q.e(a)}finally{q.f()}return{$type:"Set",values:p}}// Objects and arrays
+if("object"===e){// Circular detection
+if(b.has(a))return{$type:"Circular",ref:b.get(a)};// assign id
+var s=d.nextObjId++;if(b.set(a,s),Array.isArray(a)){for(var t=[],u=0;u<a.length;u++)t.push(ObjHelper.buildSerializable(a[u],b,c,d));return t}// Plain object: sort keys for determinism
+var w,x=Object.keys(a).sort(),y={},z=_createForOfIteratorHelper(x);try{for(z.s();!(w=z.n()).done;){var A=w.value;try{y[A]=ObjHelper.buildSerializable(a[A],b,c,d)}catch(a){y[A]="<unserializable>"}}}catch(a){z.e(a)}finally{z.f()}return y}// Fallback: try to stringify
+try{return a+""}catch(a){return"<unserializable>"}}/**
+   * Deterministic stringify: first build a canonical serializable structure
+   * (with sorted object keys and encoded special types), then JSON.stringify it.
+   */static stringify(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:2,c=new Map,d=new Map,e=ObjHelper.buildSerializable(a,c,d,{nextObjId:0,nextFunctionId:0});return JSON.stringify(e,null,b)}static parse(a){var b=[],c=function reviver(a,b){if(b&&"object"===_typeof(b)&&"$type"in b)switch(b.$type){case"Function":return function FunctionPlaceholder(){throw new Error("Function placeholder called: ".concat(b.name||"anonymous","#").concat(b.id))};case"Symbol":return Symbol(b.key);case"BigInt":return BigInt(b.value);case"Date":return new Date(b.value);case"RegExp":return new RegExp(b.source,b.flags);case"Map":return new Map(b.entries);case"Set":return new Set(b.values);case"Circular":return{$circularRef:b.ref}}return b},d=JSON.parse(a,c),e=function fixCirculars(a){if(a&&"object"===_typeof(a)){if(a.$circularRef!==void 0)return b[a.$circularRef];if(!b.includes(a)){b.push(a);for(var c,d=0,f=Object.keys(a);d<f.length;d++)c=f[d],a[c]=e(a[c])}}return a};return e(d)}}

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,aAAa,EAAE,yBAAyB,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACrG,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAkB,MAAM,OAAO,CAAA;AAE7E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS,SAAS,GAC7D,OAAO,CAAC;IACN,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,CAAA;IACrC,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,WAAW,GAAG,WAAW,EAAE,CAAA;IACrC,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,aAAa,EAAE,yBAAyB,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACrG,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,WAAW,GAAG,WAAW,EAAE,CAAA;IACrC,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,WAAW,GAAG,WAAW,EAAE,CAAA;IACrC,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"}

package/dist/hoc/component.hoc.js

@@ -1,4 +1,4 @@
-"use strict";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{BaseNode,Node}from"../core.node.js";/**
+"use strict";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{BaseNode,Node}from"../core.node.js";import{getElementTypeName}from"../helper/common.helper.js";/**
  * Props definition for components wrapped using the `Component` higher-order function.
  *
  * This type adapts based on whether the underlying component defines its own props:
@@ -48,4 +48,4 @@
  *//**
  * Internal implementation of the `Component` HOC.
  * Handles theme propagation, BaseNode conversion, and wrapper creation.
- */export function Component(a){var b=function Renderer(b){var c=a(b);if(c instanceof BaseNode){var d,e,f=(null===(d=c.rawProps)||void 0===d?void 0:d.nodetheme)||(null===(e=c.rawProps)||void 0===e?void 0:e.theme)||b.nodetheme||b.theme;return Node(c.element,_objectSpread(_objectSpread({},c.rawProps),{},{nodetheme:f})).render()}return c};return function Func(){var a=0<arguments.length&&arguments[0]!==void 0?arguments[0]:{};return Node(b,a).render()}}
+ */export function Component(a){function Func(){var a=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};return Node(c,a).render()}var b=getElementTypeName(a),c=function Renderer(b){var c=a(b);if(c instanceof BaseNode){var d,e,f=(null===(d=c.rawProps)||void 0===d?void 0:d.nodetheme)||(null===(e=c.rawProps)||void 0===e?void 0:e.theme)||b.nodetheme||b.theme;return Node(c.element,_objectSpread(_objectSpread({},c.rawProps),{},{nodetheme:f})).render()}return c};return c.displayName="Renderer(".concat(b,")"),Func.displayName="Component(".concat(b,")"),Func}

package/dist/node.type.d.ts

@@ -1,4 +1,4 @@
-import React, { type Attributes as ReactAttributes, type CSSProperties, type ReactNode, type JSX, type ElementType, type ComponentType, type JSXElementConstructor, type Component, type Ref, type ExoticComponent, type FragmentProps, type ReactElement } from 'react';
+import React, { type Attributes as ReactAttributes, type CSSProperties, type ReactNode, type JSX, type ElementType, type ComponentType, type JSXElementConstructor, type Component, type ExoticComponent, type ReactElement } from 'react';
 import type { Root as ReactDOMRoot } from 'react-dom/client';
 import type { CSSInterpolation } from '@emotion/serialize';
 import type { NO_STYLE_TAGS } from './constants/common.const.js';
@@ -17,7 +17,7 @@ export type NonArrayReactNode = Exclude<ReactNode, ReactNode[]>;
  * Defines the various types that can represent a "node" in the Meonode system.
  * This includes React elements, components, promises resolving to React nodes, and NodeInstance objects.
  */
-export type NodeElement = ExoticComponent<FragmentProps> | NonArrayReactNode | Promise<Awaited<NonArrayReactNode>> | Component<any, any, any> | ElementType | ComponentType<any> | NodeInstance<any> | ((props?: any) => NonArrayReactNode | Promise<Awaited<NonArrayReactNode>> | Component<any, any, any> | NodeInstance<any> | ComponentNode);
+export type NodeElement = ExoticComponent<any> | NonArrayReactNode | Promise<Awaited<NonArrayReactNode>> | Component<any, any, any> | ElementType | ComponentType<any> | NodeInstance<any> | ((props?: any) => NonArrayReactNode | Promise<Awaited<NonArrayReactNode>> | Component<any, any, any> | NodeInstance<any> | ComponentNode);
 /**
  * Forward declaration of the BaseNode interface to avoid circular dependencies.
  * Defines the core structure and capabilities of a BaseNode instance.
@@ -65,15 +65,18 @@ export type Theme = Partial<{
  * - Handles theme context propagation
  * @template E - The element type these props apply to
  */
-export type FinalNodeProps = ReactAttributes & {
-    ref?: Ref<unknown>;
-    style?: CSSProperties;
-    css?: CSSInterpolation;
-    children?: NodeElement | NodeElement[];
-    theme?: Theme;
-    nodetheme?: Theme;
-    nativeProps?: Record<string, unknown>;
-};
+export type FinalNodeProps = ReactAttributes & Partial<{
+    nativeProps: Omit<Omit<PropsOf<NodeElement>, 'children'>, 'style'>;
+    key: React.Key | any | null | undefined;
+    ref: any | React.Ref<unknown> | undefined;
+    style: any;
+    css: any;
+    children: NodeElement | NodeElement[];
+    theme: Partial<{
+        [p: string]: any;
+    }> | any | undefined;
+    nodetheme: Theme;
+}>;
 /**
  * Helper type to determine if the props P have a 'style' property
  * that is compatible with CSSProperties.

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

@@ -1 +1 @@
-{"version":3,"file":"node.type.d.ts","sourceRoot":"","sources":["../src/node.type.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.type.d.ts","sourceRoot":"","sources":["../src/node.type.ts"],"names":[],"mappings":"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"}

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.2.14",
+  "version": "0.2.15",
   "type": "module",
   "main": "./dist/main.js",
   "types": "./dist/main.d.ts",