@meonode/ui 0.2.21 → 0.3.0

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;AAI7E;;;;;;;;;;;;;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"}

package/dist/hoc/component.hoc.js

@@ -1,21 +1,20 @@
-"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";import{isNodeInstance}from"../helper/node.helper.js";/**
+"use strict";import{BaseNode,Node}from"../core.node.js";import{getElementTypeName}from"../helper/common.helper.js";import{isNodeInstance}from"../helper/node.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:
  *
- * - 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`.
  *//**
  * 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) => {
@@ -28,7 +27,7 @@
  * 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 {
@@ -47,5 +46,5 @@
  * ```
  *//**
  * Internal implementation of the `Component` HOC.
- * Handles theme propagation, BaseNode conversion, and wrapper creation.
- */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||isNodeInstance(c)){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}
+ * Handles BaseNode conversion and wrapper creation.
+ */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);return c instanceof BaseNode||isNodeInstance(c)?Node(c.element,c.rawProps).render():c};return c.displayName="Renderer(".concat(b,")"),Func.displayName="Component(".concat(b,")"),Func}

package/dist/hoc/portal.hoc.d.ts

@@ -1,53 +1,53 @@
 import type { BasePortalProps, ComponentNode, NodeInstance, PortalLauncher, PortalProps } from '../node.type.js';
+// --- Function Overloads ---
 /**
- * Creates a portal component with a single fixed provider.
- * The content component will be rendered within this provider. This is the preferred method
- * for providing fixed context to your portal content.
- * @param provider A single `NodeInstance` that will wrap the portal content. This should typically
- * be a React context provider (e.g., `ThemeProvider({ theme })`).
- * @param component The React component function that defines the portal's content. It receives
- * props of type `PortalProps<P>` and should return a `ComponentNode`.
- * @returns A launcher function that, when called, creates and controls the portal instance.
+ * Higher-Order Component (HOC) to create and manage React portals with optional provider wrapping.
+ * This function supports two overloads:
+ * 1. `Portal(providerNodeInstance, component)` - Creates a portal with a fixed provider node instance.
+ * 2. `Portal(component)` - Creates a portal without a fixed provider, allowing dynamic providers at launch time.
+ * @template P The prop types for the component rendered inside the portal, extending BasePortalProps.
+ * @param provider Optional NodeInstance to wrap the portal content (fixed provider).
+ * @param component The component function that returns the content to render inside the portal.
+ * @returns A function that launches the portal instance, accepting props and optional dynamic providers.
  * @example
- * ```ts
- * // Example of preferred usage with a single fixed provider:
- * const ThemedModal = Portal(
- *   ThemeProvider({ theme: 'light' }),
- *   (props) => Div({ children: props.children, style: { background: props.nodetheme?.background } })
- * );
+ * // Using Portal with a fixed provider
+ * const MyPortal = Portal(MyProviderNodeInstance, (props) => (
+ *   Div({
+ *     backgroundColor: 'white',
+ *     padding: '20px',
+ *     borderRadius: '8px',
+ *     children: [
+ *       H1({ children: 'Fixed Provider Portal' }),
+ *       Button({
+ *         onClick: () => props.portal.unmount(),
+ *         children: 'Close',
+ *       }),
+ *     ],
+ *   })
+ * ));
  *
- * const modalInstance = ThemedModal({ children: "Preferred content" });
- * modalInstance.unmount();
- * ```
- */
-export declare function Portal<P extends BasePortalProps | Record<string, any> = BasePortalProps>(provider: NodeInstance<any>, component: (props: PortalProps<P>) => ComponentNode): PortalLauncher<P>;
-/**
- * Creates a basic portal component without any fixed providers.
- * Dynamic providers can still be passed as props when launching the portal instance.
- * @param component The React component function that defines the portal's content. It receives
- * props of type `PortalProps<P>` and should return a `ComponentNode`.
- * @returns A launcher function that, when called, creates and controls the portal instance.
+ * // Launching the portal
+ * const portalInstance = MyPortal({ someProp: 'value' });
  * @example
- * ```ts
- * // Example of basic usage without fixed providers:
- * const BasicModal = Portal(
- *   (props) => Div({ children: props.children, style: { padding: '20px', border: '1px solid black' } })
- * );
+ * // Using Portal without a fixed provider
+ * const MyPortal = Portal((props) => (
+ *   Div({
+ *     backgroundColor: 'white',
+ *     padding: '20px',
+ *     borderRadius: '8px',
+ *     children: [
+ *       H1({ children: 'Dynamic Provider Portal' }),
+ *       Button({
+ *         onClick: () => props.portal.unmount(),
+ *         children: 'Close',
+ *       }),
+ *     ],
+ *   })
+ * ));
  *
- * const basicModalInstance = BasicModal({ children: "Hello from a basic portal!" });
- * basicModalInstance.unmount();
- *
- * // Example with dynamic providers when launching:
- * const DynamicThemedModal = Portal(
- *   (props) => Div({ children: props.children, style: { background: props.nodetheme?.background || 'white' } })
- * );
- *
- * const dynamicModalInstance = DynamicThemedModal({
- *   providers: ThemeProvider({ theme: 'blue' }), // Dynamic provider
- *   children: "Content with dynamic theme"
- * });
- * dynamicModalInstance.unmount();
- * ```
+ * // Launching the portal with a dynamic provider
+ * const portalInstance = MyPortal({ provider: AnotherProviderNodeInstance, someProp: 'value' });
  */
+export declare function Portal<P extends BasePortalProps | Record<string, any> = BasePortalProps>(provider: NodeInstance<any>, component: (props: PortalProps<P>) => ComponentNode): PortalLauncher<P>;
 export declare function Portal<P extends BasePortalProps | Record<string, any> = BasePortalProps>(component: (props: PortalProps<P>) => ComponentNode): PortalLauncher<P>;
 //# sourceMappingURL=portal.hoc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"portal.hoc.d.ts","sourceRoot":"","sources":["../../src/hoc/portal.hoc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAe,YAAY,EAAyB,cAAc,EAAE,WAAW,EAAS,MAAM,mBAAmB,CAAA;AAG7J;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,eAAe,EACtF,QAAQ,EAAE,YAAY,CAAC,GAAG,CAAC,EAC3B,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,aAAa,GAClD,cAAc,CAAC,CAAC,CAAC,CAAA;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,eAAe,EACtF,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,aAAa,GAClD,cAAc,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"portal.hoc.d.ts","sourceRoot":"","sources":["../../src/hoc/portal.hoc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAe,YAAY,EAAyB,cAAc,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAGtJ,6BAA6B;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,eAAe,EACtF,QAAQ,EAAE,YAAY,CAAC,GAAG,CAAC,EAC3B,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,aAAa,GAClD,cAAc,CAAC,CAAC,CAAC,CAAA;AAEpB,wBAAgB,MAAM,CAAC,CAAC,SAAS,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,eAAe,EACtF,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,aAAa,GAClD,cAAc,CAAC,CAAC,CAAC,CAAA"}

package/dist/hoc/portal.hoc.js

@@ -1,50 +1,51 @@
-"use strict";var _excluded=["nodetheme"],_excluded2=["provider","nodetheme"];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{BaseNode,Node}from"../core.node.js";/**
- * Creates a portal component with a single fixed provider.
- * The content component will be rendered within this provider. This is the preferred method
- * for providing fixed context to your portal content.
- * @param provider A single `NodeInstance` that will wrap the portal content. This should typically
- * be a React context provider (e.g., `ThemeProvider({ theme })`).
- * @param component The React component function that defines the portal's content. It receives
- * props of type `PortalProps<P>` and should return a `ComponentNode`.
- * @returns A launcher function that, when called, creates and controls the portal instance.
+"use strict";var _excluded=["provider"];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 _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 _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";// --- Function Overloads ---
+/**
+ * Higher-Order Component (HOC) to create and manage React portals with optional provider wrapping.
+ * This function supports two overloads:
+ * 1. `Portal(providerNodeInstance, component)` - Creates a portal with a fixed provider node instance.
+ * 2. `Portal(component)` - Creates a portal without a fixed provider, allowing dynamic providers at launch time.
+ * @template P The prop types for the component rendered inside the portal, extending BasePortalProps.
+ * @param provider Optional NodeInstance to wrap the portal content (fixed provider).
+ * @param component The component function that returns the content to render inside the portal.
+ * @returns A function that launches the portal instance, accepting props and optional dynamic providers.
  * @example
- * ```ts
- * // Example of preferred usage with a single fixed provider:
- * const ThemedModal = Portal(
- *   ThemeProvider({ theme: 'light' }),
- *   (props) => Div({ children: props.children, style: { background: props.nodetheme?.background } })
- * );
+ * // Using Portal with a fixed provider
+ * const MyPortal = Portal(MyProviderNodeInstance, (props) => (
+ *   Div({
+ *     backgroundColor: 'white',
+ *     padding: '20px',
+ *     borderRadius: '8px',
+ *     children: [
+ *       H1({ children: 'Fixed Provider Portal' }),
+ *       Button({
+ *         onClick: () => props.portal.unmount(),
+ *         children: 'Close',
+ *       }),
+ *     ],
+ *   })
+ * ));
  *
- * const modalInstance = ThemedModal({ children: "Preferred content" });
- * modalInstance.unmount();
- * ```
- *//**
- * Creates a basic portal component without any fixed providers.
- * Dynamic providers can still be passed as props when launching the portal instance.
- * @param component The React component function that defines the portal's content. It receives
- * props of type `PortalProps<P>` and should return a `ComponentNode`.
- * @returns A launcher function that, when called, creates and controls the portal instance.
+ * // Launching the portal
+ * const portalInstance = MyPortal({ someProp: 'value' });
  * @example
- * ```ts
- * // Example of basic usage without fixed providers:
- * const BasicModal = Portal(
- *   (props) => Div({ children: props.children, style: { padding: '20px', border: '1px solid black' } })
- * );
+ * // Using Portal without a fixed provider
+ * const MyPortal = Portal((props) => (
+ *   Div({
+ *     backgroundColor: 'white',
+ *     padding: '20px',
+ *     borderRadius: '8px',
+ *     children: [
+ *       H1({ children: 'Dynamic Provider Portal' }),
+ *       Button({
+ *         onClick: () => props.portal.unmount(),
+ *         children: 'Close',
+ *       }),
+ *     ],
+ *   })
+ * ));
  *
- * const basicModalInstance = BasicModal({ children: "Hello from a basic portal!" });
- * basicModalInstance.unmount();
- *
- * // Example with dynamic providers when launching:
- * const DynamicThemedModal = Portal(
- *   (props) => Div({ children: props.children, style: { background: props.nodetheme?.background || 'white' } })
- * );
- *
- * const dynamicModalInstance = DynamicThemedModal({
- *   providers: ThemeProvider({ theme: 'blue' }), // Dynamic provider
- *   children: "Content with dynamic theme"
- * });
- * dynamicModalInstance.unmount();
- * ```
+ * // Launching the portal with a dynamic provider
+ * const portalInstance = MyPortal({ provider: AnotherProviderNodeInstance, someProp: 'value' });
  */// --- Implementation ---
 export function Portal(a,b){// --- Initialization ---
 var c,d=void 0,e={unmount:function unmount(){console.warn("Portal instance not yet created. Cannot unmount.")},update:function update(a){console.warn("Portal instance not yet created. Cannot update.",a)}};// --- Argument Parsing and Overload Handling ---
@@ -53,21 +54,20 @@ if("function"==typeof b&&a instanceof BaseNode)// Handles the case where a fixed
 d=[a],c=b;else if("function"==typeof a&&b===void 0)// Handles the case where only the component function is passed.
 c=a;else throw new Error("Invalid arguments for Portal HOC. Use Portal(component) or Portal(providerNodeInstance, component).");// --- Core Content Renderer Function ---
 // This function is the actual React component that will be rendered inside the portal.
-// It receives props and handles theme application and portal control.
-var f=function Renderer(){var a=0<arguments.length&&arguments[0]!==void 0?arguments[0]:{},b=a.nodetheme,d=_objectWithoutProperties(a,_excluded),f=c(_objectSpread(_objectSpread({},d),{},{portal:e// Passes the portal control object to the content component
-}));// Ensures that the theme is correctly applied if the result is a BaseNode.
-if(f instanceof BaseNode){var g,h;return Node(f.element,_objectSpread(_objectSpread({},f.rawProps),{},{nodetheme:(null===(g=f.rawProps)||void 0===g?void 0:g.nodetheme)||(null===(h=f.rawProps)||void 0===h?void 0:h.theme)||a.nodetheme})).render()}return f};// --- Portal Launcher Function (Returned to User) ---
+var f=function Renderer(){var a=0<arguments.length&&arguments[0]!==void 0?arguments[0]:{},b=c(_objectSpread(_objectSpread({},a),{},{portal:e// Passes the portal control object to the content component
+}));// If the result is a BaseNode, render it.
+return b instanceof BaseNode?b.render():b};// --- Portal Launcher Function (Returned to User) ---
 // This is the function that developers call to actually create and manage a portal instance.
 return function Func(){// --- Helper for Deep Content Injection ---
 // Recursively injects content into the deepest child of a provider chain.
-function injectContentDeeply(a,b,c){var d,e,f,g=null===(d=a.rawProps)||void 0===d?void 0:d.children;// If no children, or children is not a NodeInstance, inject directly
-if(!g||!(g instanceof BaseNode)){var h,i;return Node(a.element,_objectSpread(_objectSpread({},a.rawProps),{},{children:b,nodetheme:(null===(h=a.rawProps)||void 0===h?void 0:h.nodetheme)||(null===(i=a.rawProps)||void 0===i?void 0:i.theme)||c}))}// Recursively inject into the deepest node
-var j=injectContentDeeply(g,b);return Node(a.element,_objectSpread(_objectSpread({},a.rawProps),{},{children:j,nodetheme:(null===(e=a.rawProps)||void 0===e?void 0:e.nodetheme)||(null===(f=a.rawProps)||void 0===f?void 0:f.theme)||c}))}// --- Provider Wrapping Logic ---
+function injectContentDeeply(a,b){var c,d=null===(c=a.rawProps)||void 0===c?void 0:c.children;// If no children, or children is not a NodeInstance, inject directly
+if(!d||!(d instanceof BaseNode))return Node(a.element,_objectSpread(_objectSpread({},a.rawProps),{},{children:b}));// Recursively inject into the deepest node
+var e=injectContentDeeply(d,b);return Node(a.element,_objectSpread(_objectSpread({},a.rawProps),{},{children:e}))}// --- Provider Wrapping Logic ---
 // Iterates through the combined providers (fixed + dynamic) to wrap the content.
 // Providers are applied in reverse order to ensure the innermost content is wrapped by the outermost provider.
 var a,b=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{},c=[];// Combine fixed and dynamic providers
-b.provider&&c.push(b.provider);var g=[...(null!==d&&void 0!==d?d:[]),...c],h=b.provider,i=b.nodetheme,j=_objectWithoutProperties(b,_excluded2),k=_objectSpread(_objectSpread({},j),{},{nodetheme:i}),l=Node(f,k);// Separates props for the portal's content from internal props like 'provider' or 'nodetheme'.
+b.provider&&c.push(b.provider);var g=[...(null!==d&&void 0!==d?d:[]),...c],h=b.provider,i=_objectWithoutProperties(b,_excluded),j=Node(f,i);// Separates props for the portal's content from internal props like 'provider'.
 // Creates the base node for the portal's content.
-return a=0<g.length?g.reduceRight(function(a,b){var c,d,e;if(!(b instanceof BaseNode))return console.warn("Portal: Item in provider is not a valid NodeInstance. Skipping.",b),a;var f=(null===(c=b.rawProps)||void 0===c?void 0:c.children)instanceof BaseNode;// If the provider already has nested children, inject content deeply.
+return a=0<g.length?g.reduceRight(function(a,b){var c;if(!(b instanceof BaseNode))return console.warn("Portal: Item in provider is not a valid NodeInstance. Skipping.",b),a;var d=(null===(c=b.rawProps)||void 0===c?void 0:c.children)instanceof BaseNode;// If the provider already has nested children, inject content deeply.
 // Otherwise, simply set currentWrappedContent as its direct child.
-return f?injectContentDeeply(b,a,i):Node(b.element,_objectSpread(_objectSpread({},b.rawProps),{},{children:a,nodetheme:(null===(d=b.rawProps)||void 0===d?void 0:d.nodetheme)||(null===(e=b.rawProps)||void 0===e?void 0:e.theme)||i}))},l):l,e=a.toPortal(),e}}
+return d?injectContentDeeply(b,a):Node(b.element,_objectSpread(_objectSpread({},b.rawProps),{},{children:a}))},j):j,e=a.toPortal(),e}}

package/dist/hook/index.d.ts

@@ -1,2 +1,3 @@
 export * from '../hook/usePortal.js';
+export * from '../hook/useTheme.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/hook/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hook/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hook/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA"}

package/dist/hook/index.js

@@ -1 +1 @@
-export*from"./usePortal.js";
+export*from"./usePortal.js";export*from"./useTheme.js";

package/dist/hook/useTheme.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A hook that provides access to the theme context.
+ * It also handles side effects like updating localStorage and applying the theme to the document root.
+ * @returns {ThemeContextValue} The theme context value.
+ * @throws {Error} If used outside of a ThemeProvider.
+ */
+export declare const useTheme: () => import("../main").ThemeContextValue;
+//# sourceMappingURL=useTheme.d.ts.map

package/dist/hook/useTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../src/hook/useTheme.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,6CA+BpB,CAAA"}

package/dist/hook/useTheme.js

@@ -0,0 +1,8 @@
+"use client";import{useContext,useEffect}from"react";import{ThemeContext}from"../components/theme-provider.client.js";/**
+ * A hook that provides access to the theme context.
+ * It also handles side effects like updating localStorage and applying the theme to the document root.
+ * @returns {ThemeContextValue} The theme context value.
+ * @throws {Error} If used outside of a ThemeProvider.
+ */export var useTheme=function useTheme(){var a=useContext(ThemeContext);if(!a)throw new Error("useTheme must be used within a ThemeProvider");var b=a.theme;return useEffect(function(){// Sync theme mode with localStorage
+var a=localStorage.getItem("theme");a&&a===b.mode||localStorage.setItem("theme",b.mode);// Apply theme to document root
+var c=document.documentElement;"dark"===b.mode?(c.setAttribute("data-theme","dark"),c.classList.add("dark-theme"),c.classList.remove("light-theme")):(c.setAttribute("data-theme","light"),c.classList.add("light-theme"),c.classList.remove("dark-theme"))},[b.mode,b.system]),a};

package/dist/main.d.ts

@@ -3,5 +3,6 @@ export * from './hoc/index.js';
 export * from './helper/node.helper.js';
 export * from './node.type.js';
 export * from './components/html.node.js';
+export * from './components/theme-provider.client.js';
 export * from './hook/index.js';
 //# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAC7E,cAAc,mBAAmB,CAAA;AACjC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAE7E,cAAc,mBAAmB,CAAA;AAEjC,cAAc,4BAA4B,CAAA;AAE1C,cAAc,mBAAmB,CAAA;AAEjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,0CAA0C,CAAA;AAExD,cAAc,oBAAoB,CAAA"}

package/dist/main.js

@@ -1 +1 @@
-export{Node,createNode,createChildrenFirstNode}from"./core.node.js";export*from"./hoc/index.js";export*from"./helper/node.helper.js";export*from"./node.type.js";export*from"./components/html.node.js";export*from"./hook/index.js";
+export{Node,createNode,createChildrenFirstNode}from"./core.node.js";export*from"./hoc/index.js";export*from"./helper/node.helper.js";export*from"./node.type.js";export*from"./components/html.node.js";export*from"./components/theme-provider.client.js";export*from"./hook/index.js";