@meonode/ui 0.1.96 → 0.1.98

package/dist/common.helper.d.ts

@@ -0,0 +1,85 @@
+import type { FinalNodeProps, NodeElement } from './node.type';
+import type { ComponentProps, CSSProperties, ElementType } from 'react';
+/**
+ * Retrieves a deeply nested value from an object using a dot-separated string path.
+ *
+ * This function traverses an object based on the provided path, which is a
+ * string of keys separated by dots. It returns the value found at the end of
+ * the path or `undefined` if any key in the path is not found or if the object
+ * is nullish at any point during traversal.
+ * @param obj The object to traverse, defaults to an empty object if not provided.
+ * @param path The dot-separated path string (e.g., 'background.primary').
+ * @returns The value at the specified path, or undefined if not found.
+ */
+export declare function getValueByPath(obj: Record<string, any> | undefined, path: string): Record<string, any>;
+/**
+ * Returns a string describing the type of a given React component or element.
+ *
+ * Checks for common React types (class, forwardRef, memo, etc.) and returns a string
+ * such as 'class', 'forwardRef', 'memo', 'object-with-render', 'function', or other
+ * React-specific types. Falls back to `typeof` or 'unknown' if not recognized.
+ * @param component The React component, element type, or element-like object to check.
+ * @returns A string describing the component type.
+ * @example
+ * getComponentType(class extends React.Component {}) // 'class'
+ * getComponentType(React.forwardRef(() => <div/>)) // 'forwardRef'
+ * getComponentType(React.memo(() => <div/>)) // 'memo'
+ * getComponentType(() => <div/>) // 'function'
+ */
+export declare const getComponentType: (component?: NodeElement) => "class" | "forwardRef" | "memo" | "object" | "function" | "fragment" | "portal" | "profiler" | "strict-mode" | "suspense" | "suspense-list" | "context-consumer" | "context-provider" | "lazy" | "element" | "unknown" | string;
+/**
+ * Generates a string name for an ElementType or ReactElement.
+ *
+ * This function attempts to extract a meaningful name from a React ElementType
+ * (string, function, class, HOC) or a ReactElement instance.
+ * It prioritizes `displayName` and `name` properties and unwraps HOCs like
+ * `React.memo` and `React.forwardRef` to get the underlying component name.
+ *
+ * If a name cannot be determined, it returns a fallback like 'UnknownElementType' or 'AnonymousComponent'.
+ * @param node The ElementType or ReactElement (e.g., 'div', MyComponent, <MyComponent />).
+ * @returns A string representation of the element type's name.
+ */
+export declare function getElementTypeName(node: unknown): string;
+/**
+ * A set of valid CSS property names in camelCase, including CSS custom properties, used for validation.
+ * This set contains all CSS properties including non-standard vendor prefixed properties.
+ */
+export declare const CSSPropertySet: Set<string>;
+/**
+ * Filters an object to only include valid CSS properties
+ * @param props The object containing potential CSS properties
+ * @returns An object containing only valid CSS properties
+ * @example
+ * ```ts
+ * getCSSProps({
+ *   backgroundColor: 'red',
+ *   invalid: true
+ * }) // { backgroundColor: 'red' }
+ * ```
+ */
+export declare function getCSSProps<T extends Record<string, any>>(props: T): Partial<CSSProperties>;
+/**
+ * Filters component props to include only valid DOM properties and attributes.
+ *
+ * This function iterates through the provided props and retains only those that
+ * are not CSS properties (as determined by `cssPropertySet`). This is useful for
+ * separating style-related props from standard DOM attributes when rendering
+ * elements.
+ * @ty E - The type of the React element.
+ * @typeParam T - The type of the component props.
+ * @param props The component props to filter.
+ * @returns An object containing only valid DOM props.
+ */
+export declare function getDOMProps<E extends ElementType, T extends ComponentProps<E>>(props: T): Partial<FinalNodeProps>;
+/**
+ * Checks if a property on an object is writable.
+ *
+ * This function uses `Object.getOwnPropertyDescriptor` to determine if the specified
+ * property is writable. If the property descriptor is not found (property does not exist
+ * or is inherited), it returns `true` by default.
+ * @param obj The object to check.
+ * @param key The property name to check for writability.
+ * @returns `true` if the property is writable or not explicitly defined, otherwise `false`.
+ */
+export declare function isWritable(obj: Record<string, any>, key: string): boolean;
+//# sourceMappingURL=common.helper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.helper.d.ts","sourceRoot":"","sources":["../src/common.helper.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAEvE;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAK,EAAE,IAAI,EAAE,MAAM,uBAEzE;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,WAAW,KAErB,OAAO,GACP,YAAY,GACZ,MAAM,GACN,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,aAAa,GACb,UAAU,GACV,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,MAAM,GACN,SAAS,GACT,SAAS,GACT,MAgBH,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAsFxD;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,GAAG,CAAC,MAAM,CAA0B,CAAA;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAU3F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAUjH;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,WAQ/D"}

package/dist/common.helper.js

@@ -0,0 +1,71 @@
+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{isContextConsumer,isContextProvider,isElement,isForwardRef,isFragment,isLazy,isMemo,isPortal,isProfiler,isReactClassComponent,isStrictMode,isSuspense,isSuspenseList}from"./react-is.helper.js";import cssProperties from"./data/css-properties";/**
+ * Retrieves a deeply nested value from an object using a dot-separated string path.
+ *
+ * This function traverses an object based on the provided path, which is a
+ * string of keys separated by dots. It returns the value found at the end of
+ * the path or `undefined` if any key in the path is not found or if the object
+ * is nullish at any point during traversal.
+ * @param obj The object to traverse, defaults to an empty object if not provided.
+ * @param path The dot-separated path string (e.g., 'background.primary').
+ * @returns The value at the specified path, or undefined if not found.
+ */export function getValueByPath(){var a=0<arguments.length&&arguments[0]!==void 0?arguments[0]:{},b=1<arguments.length?arguments[1]:void 0;return b.split(".").reduce(function(a,b){return null===a||void 0===a?void 0:a[b]},a)}/**
+ * Returns a string describing the type of a given React component or element.
+ *
+ * Checks for common React types (class, forwardRef, memo, etc.) and returns a string
+ * such as 'class', 'forwardRef', 'memo', 'object-with-render', 'function', or other
+ * React-specific types. Falls back to `typeof` or 'unknown' if not recognized.
+ * @param component The React component, element type, or element-like object to check.
+ * @returns A string describing the component type.
+ * @example
+ * getComponentType(class extends React.Component {}) // 'class'
+ * getComponentType(React.forwardRef(() => <div/>)) // 'forwardRef'
+ * getComponentType(React.memo(() => <div/>)) // 'memo'
+ * getComponentType(() => <div/>) // 'function'
+ */export var getComponentType=function getComponentType(a){return isForwardRef(a)?"forwardRef":isMemo(a)?"memo":isFragment(a)?"fragment":isPortal(a)?"portal":isProfiler(a)?"profiler":isStrictMode(a)?"strict-mode":isSuspense(a)?"suspense":isSuspenseList(a)?"suspense-list":isContextConsumer(a)?"context-consumer":isContextProvider(a)?"context-provider":isLazy(a)?"lazy":isElement(a)?"element":isReactClassComponent(a)?"class":_typeof(a)};/**
+ * Generates a string name for an ElementType or ReactElement.
+ *
+ * This function attempts to extract a meaningful name from a React ElementType
+ * (string, function, class, HOC) or a ReactElement instance.
+ * It prioritizes `displayName` and `name` properties and unwraps HOCs like
+ * `React.memo` and `React.forwardRef` to get the underlying component name.
+ *
+ * If a name cannot be determined, it returns a fallback like 'UnknownElementType' or 'AnonymousComponent'.
+ * @param node The ElementType or ReactElement (e.g., 'div', MyComponent, <MyComponent />).
+ * @returns A string representation of the element type's name.
+ */export function getElementTypeName(a){var b,c;function getDisplayName(a,b){var c=(null===a||void 0===a?void 0:a.displayName)||(null===a||void 0===a?void 0:a.name);return!c||"render"===c?b:c}if(null===a||a===void 0)return"UnknownElementType";var d=a,e=getComponentType(d);switch(e){case"string":return a;case"class":return getDisplayName(d,"ClassComponent");case"function":return getDisplayName(d,"AnonymousFunctionComponent");case"forwardRef":return getDisplayName(d,"")||getDisplayName(d.render,"")||"ForwardRefComponent";case"memo":return getDisplayName(d,"")||(d.type?getElementTypeName(d.type):"MemoComponent");case"element":return getElementTypeName(d.type);case"fragment":return"Fragment";case"portal":return"Portal";case"profiler":return getDisplayName(d,"Profiler");case"strict-mode":return"StrictMode";case"suspense":return getDisplayName(d,"Suspense");case"suspense-list":return"SuspenseList";case"context-consumer":return null!==(b=d._context)&&void 0!==b&&b.displayName?"".concat(d._context.displayName,".Consumer"):"ContextConsumer";case"context-provider":return null!==(c=d._context)&&void 0!==c&&c.displayName?"".concat(d._context.displayName,".Provider"):"ContextProvider";case"lazy":return getDisplayName(d,"LazyComponent");case"object":return getDisplayName(d,"")?getDisplayName(d,""):"function"==typeof d.render?getDisplayName(d.render,"ObjectWithRender"):d.type&&d.type!==a?"Wrapped<".concat(getElementTypeName(d.type),">"):getDisplayName(d,"ObjectComponent");case"symbol":if("symbol"===_typeof(a)){var f;return(null===(f=a.description)||void 0===f?void 0:f.replace(/^react\./,"").split(".").map(function(a){var b;return(null===(b=a[0])||void 0===b?void 0:b.toUpperCase())+a.slice(1)}).join(""))||a.toString()}return"SymbolComponent";case"unknown":return"UnknownElementType";default:return"UnsupportedType<".concat(e,">")}}/**
+ * A set of valid CSS property names in camelCase, including CSS custom properties, used for validation.
+ * This set contains all CSS properties including non-standard vendor prefixed properties.
+ */export var CSSPropertySet=new Set(cssProperties);/**
+ * Filters an object to only include valid CSS properties
+ * @param props The object containing potential CSS properties
+ * @returns An object containing only valid CSS properties
+ * @example
+ * ```ts
+ * getCSSProps({
+ *   backgroundColor: 'red',
+ *   invalid: true
+ * }) // { backgroundColor: 'red' }
+ * ```
+ */export function getCSSProps(a){var b={};for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&CSSPropertySet.has(c)&&(b[c]=a[c]);return b}/**
+ * Filters component props to include only valid DOM properties and attributes.
+ *
+ * This function iterates through the provided props and retains only those that
+ * are not CSS properties (as determined by `cssPropertySet`). This is useful for
+ * separating style-related props from standard DOM attributes when rendering
+ * elements.
+ * @ty E - The type of the React element.
+ * @typeParam T - The type of the component props.
+ * @param props The component props to filter.
+ * @returns An object containing only valid DOM props.
+ */export function getDOMProps(a){var b={};for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&!CSSPropertySet.has(c)&&(b[c]=a[c]);return b}/**
+ * Checks if a property on an object is writable.
+ *
+ * This function uses `Object.getOwnPropertyDescriptor` to determine if the specified
+ * property is writable. If the property descriptor is not found (property does not exist
+ * or is inherited), it returns `true` by default.
+ * @param obj The object to check.
+ * @param key The property name to check for writability.
+ * @returns `true` if the property is writable or not explicitly defined, otherwise `false`.
+ */export function isWritable(a,b){var c=Object.getOwnPropertyDescriptor(a,b);// If the property doesn't exist or is inherited, desc will be undefined.
+// In such cases, it's typically considered writable unless explicitly defined otherwise.
+return!c||!!c.writable}

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

@@ -1 +1 @@
-{"version":3,"file":"core.node.d.ts","sourceRoot":"","sources":["../src/core.node.ts"],"names":[],"mappings":"AACA,OAAc,EAAkF,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC7H,OAAO,KAAK,EAAE,cAAc,EAAyB,WAAW,EAAE,YAAY,EAAE,SAAS,EAAW,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGlJ,OAAO,EAAc,KAAK,IAAI,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAExE;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACnF,+EAA+E;IACxE,OAAO,EAAE,CAAC,CAAA;IAEjB,kFAAkF;IAC3E,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,CAAK;IAErC,wFAAwF;IACjF,KAAK,EAAE,cAAc,CAAA;IAE5B,SAAgB,UAAU,QAAO;IAEjC,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,gBAAgB,CAA4B;IAEpD;;;;;;;;OAQG;gBACS,OAAO,EAAE,CAAC,EAAE,QAAQ,GAAE,YAAY,CAAC,CAAC,CAAM;IAsCtD,OAAO,CAAC,gBAAgB;IAYxB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAwCpI;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,iBAAiB;IAgCzB;;;;;;;;OAQG;IACI,eAAe,CACpB,OAAO,EAAE,WAAW,EACpB,WAAW,CAAC,EAAE,KAAK,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,WAAW;IAyFd;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,eAAe,CAwBtB;IAED;;;;OAIG;IACI,MAAM,IAAI,SAAS;IAsC1B,OAAO,CAAC,2BAA2B;IAsB5B,QAAQ,IAAI,YAAY,GAAG,IAAI;CAsBvC;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,GAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAU1G"}
+{"version":3,"file":"core.node.d.ts","sourceRoot":"","sources":["../src/core.node.ts"],"names":[],"mappings":"AACA,OAAc,EAAkF,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC7H,OAAO,KAAK,EAAE,cAAc,EAAyB,WAAW,EAAE,YAAY,EAAE,SAAS,EAAW,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGlJ,OAAO,EAAc,KAAK,IAAI,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAGxE;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACnF,+EAA+E;IACxE,OAAO,EAAE,CAAC,CAAA;IAEjB,kFAAkF;IAC3E,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,CAAK;IAErC,wFAAwF;IACjF,KAAK,EAAE,cAAc,CAAA;IAE5B,SAAgB,UAAU,QAAO;IAEjC,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,gBAAgB,CAA4B;IAEpD;;;;;;;;OAQG;gBACS,OAAO,EAAE,CAAC,EAAE,QAAQ,GAAE,YAAY,CAAC,CAAC,CAAM;IAsCtD,OAAO,CAAC,gBAAgB;IAYxB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAwCpI;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,iBAAiB;IAgCzB;;;;;;;;OAQG;IACI,eAAe,CACpB,OAAO,EAAE,WAAW,EACpB,WAAW,CAAC,EAAE,KAAK,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,WAAW;IAyFd;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,eAAe,CAwBtB;IAED;;;;OAIG;IACI,MAAM,IAAI,SAAS;IAsC1B,OAAO,CAAC,2BAA2B;IAsB5B,QAAQ,IAAI,YAAY,GAAG,IAAI;CAsBvC;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,GAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAU1G"}

package/dist/core.node.js

@@ -1,4 +1,4 @@
-"use strict";var _excluded=["ref","children","nodetheme","theme","props"],_excluded2=["style"],_excluded3=["style"],_excluded4=["style"],_excluded5=["children","key"];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 React,{createElement,isValidElement}from"react";import{getComponentType,getCSSProps,getDOMProps,getElementTypeName,isNodeInstance,resolveDefaultStyle,resolveObjWithTheme}from"./node.helper.js";import{isForwardRef,isMemo,isReactClassComponent,isValidElementType}from"./react-is.helper.js";import{createRoot}from"react-dom/client";/**
+"use strict";var _excluded=["ref","children","nodetheme","theme","props"],_excluded2=["style"],_excluded3=["style"],_excluded4=["style"],_excluded5=["children","key"];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 React,{createElement,isValidElement}from"react";import{isNodeInstance,resolveDefaultStyle,resolveObjWithTheme}from"./node.helper.js";import{isForwardRef,isMemo,isReactClassComponent,isValidElementType}from"./react-is.helper.js";import{createRoot}from"react-dom/client";import{getComponentType,getCSSProps,getDOMProps,getElementTypeName}from"./common.helper";/**
  * Represents a node in a React component tree with theme and styling capabilities.
  * This class wraps React elements and handles:
  * - Props processing and normalization

package/dist/node.helper.d.ts

@@ -1,76 +1,5 @@
-import type { ComponentProps, CSSProperties, ElementType } from 'react';
-import type { NodeElement, FinalNodeProps, NodeInstance, Theme } from './node.type.js';
-/**
- * Returns a string describing the type of a given React component or element.
- *
- * Checks for common React types (class, forwardRef, memo, etc.) and returns a string
- * such as 'class', 'forwardRef', 'memo', 'object-with-render', 'function', or other
- * React-specific types. Falls back to `typeof` or 'unknown' if not recognized.
- * @param component The React component, element type, or element-like object to check.
- * @returns A string describing the component type.
- * @example
- * getComponentType(class extends React.Component {}) // 'class'
- * getComponentType(React.forwardRef(() => <div/>)) // 'forwardRef'
- * getComponentType(React.memo(() => <div/>)) // 'memo'
- * getComponentType(() => <div/>) // 'function'
- */
-export declare const getComponentType: (component?: NodeElement) => "class" | "forwardRef" | "memo" | "object" | "function" | "fragment" | "portal" | "profiler" | "strict-mode" | "suspense" | "suspense-list" | "context-consumer" | "context-provider" | "lazy" | "element" | "unknown" | string;
-/**
- * Generates a string name for an ElementType or ReactElement.
- *
- * This function attempts to extract a meaningful name from a React ElementType
- * (string, function, class, HOC) or a ReactElement instance.
- * It prioritizes `displayName` and `name` properties and unwraps HOCs like
- * `React.memo` and `React.forwardRef` to get the underlying component name.
- *
- * If a name cannot be determined, it returns a fallback like 'UnknownElementType' or 'AnonymousComponent'.
- * @param node The ElementType or ReactElement (e.g., 'div', MyComponent, <MyComponent />).
- * @returns A string representation of the element type's name.
- */
-export declare function getElementTypeName(node: unknown): string;
-/**
- * A set of valid CSS property names in camelCase, including CSS custom properties, used for validation.
- * This set contains all CSS properties including non-standard vendor prefixed properties.
- */
-export declare const CSSPropertySet: Set<string>;
-/**
- * Filters an object to only include valid CSS properties
- * @param props The object containing potential CSS properties
- * @returns An object containing only valid CSS properties
- * @example
- * ```ts
- * getCSSProps({
- *   backgroundColor: 'red',
- *   invalid: true
- * }) // { backgroundColor: 'red' }
- * ```
- */
-export declare function getCSSProps<T extends Record<string, any>>(props: T): Partial<CSSProperties>;
-/**
- * Filters component props to include only valid DOM properties and attributes.
- *
- * This function iterates through the provided props and retains only those that
- * are not CSS properties (as determined by `cssPropertySet`). This is useful for
- * separating style-related props from standard DOM attributes when rendering
- * elements.
- * @ty E - The type of the React element.
- * @typeParam T - The type of the component props.
- * @param props The component props to filter.
- * @returns An object containing only valid DOM props.
- */
-export declare function getDOMProps<E extends ElementType, T extends ComponentProps<E>>(props: T): Partial<FinalNodeProps>;
-/**
- * Retrieves a deeply nested value from an object using a dot-separated string path.
- *
- * This function traverses an object based on the provided path, which is a
- * string of keys separated by dots. It returns the value found at the end of
- * the path or `undefined` if any key in the path is not found or if the object
- * is nullish at any point during traversal.
- * @param obj The object to traverse. Defaults to an empty object if not provided.
- * @param path The dot-separated path string (e.g., 'background.primary').
- * @returns The value at the specified path, or undefined if not found.
- */
-export declare function getValueByPath(obj: Record<string, any> | undefined, path: string): Record<string, any>;
+import type { CSSProperties } from 'react';
+import type { NodeInstance, Theme } from './node.type.js';
 /**
  * Type guard to check if an object is a NodeInstance.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"node.helper.d.ts","sourceRoot":"","sources":["../src/node.helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAkBzF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,WAAW,KAErB,OAAO,GACP,YAAY,GACZ,MAAM,GACN,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,aAAa,GACb,UAAU,GACV,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,MAAM,GACN,SAAS,GACT,SAAS,GACT,MAgBH,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAsFxD;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,GAAG,CAAC,MAAM,CAA0B,CAAA;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAU3F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAUjH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAK,EAAE,IAAI,EAAE,MAAM,uBAEzE;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,YAAY,CAAC,GAAG,CASpE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EAAE,QAAQ,KAAK,wBAmE/E,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvD,CAAA"}
+{"version":3,"file":"node.helper.d.ts","sourceRoot":"","sources":["../src/node.helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAG5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,YAAY,CAAC,GAAG,CASpE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EAAE,QAAQ,KAAK,wBAwE/E,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvD,CAAA"}

package/dist/node.helper.js

@@ -1,63 +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{isContextConsumer,isContextProvider,isElement,isForwardRef,isFragment,isLazy,isMemo,isPortal,isProfiler,isReactClassComponent,isStrictMode,isSuspense,isSuspenseList}from"./react-is.helper.js";import cssProperties from"./data/css-properties";/**
- * Returns a string describing the type of a given React component or element.
- *
- * Checks for common React types (class, forwardRef, memo, etc.) and returns a string
- * such as 'class', 'forwardRef', 'memo', 'object-with-render', 'function', or other
- * React-specific types. Falls back to `typeof` or 'unknown' if not recognized.
- * @param component The React component, element type, or element-like object to check.
- * @returns A string describing the component type.
- * @example
- * getComponentType(class extends React.Component {}) // 'class'
- * getComponentType(React.forwardRef(() => <div/>)) // 'forwardRef'
- * getComponentType(React.memo(() => <div/>)) // 'memo'
- * getComponentType(() => <div/>) // 'function'
- */export var getComponentType=function getComponentType(a){return isForwardRef(a)?"forwardRef":isMemo(a)?"memo":isFragment(a)?"fragment":isPortal(a)?"portal":isProfiler(a)?"profiler":isStrictMode(a)?"strict-mode":isSuspense(a)?"suspense":isSuspenseList(a)?"suspense-list":isContextConsumer(a)?"context-consumer":isContextProvider(a)?"context-provider":isLazy(a)?"lazy":isElement(a)?"element":isReactClassComponent(a)?"class":_typeof(a)};/**
- * Generates a string name for an ElementType or ReactElement.
- *
- * This function attempts to extract a meaningful name from a React ElementType
- * (string, function, class, HOC) or a ReactElement instance.
- * It prioritizes `displayName` and `name` properties and unwraps HOCs like
- * `React.memo` and `React.forwardRef` to get the underlying component name.
- *
- * If a name cannot be determined, it returns a fallback like 'UnknownElementType' or 'AnonymousComponent'.
- * @param node The ElementType or ReactElement (e.g., 'div', MyComponent, <MyComponent />).
- * @returns A string representation of the element type's name.
- */export function getElementTypeName(a){var b,c;function getDisplayName(a,b){var c=(null===a||void 0===a?void 0:a.displayName)||(null===a||void 0===a?void 0:a.name);return!c||"render"===c?b:c}if(null===a||a===void 0)return"UnknownElementType";var d=a,e=getComponentType(d);switch(e){case"string":return a;case"class":return getDisplayName(d,"ClassComponent");case"function":return getDisplayName(d,"AnonymousFunctionComponent");case"forwardRef":return getDisplayName(d,"")||getDisplayName(d.render,"")||"ForwardRefComponent";case"memo":return getDisplayName(d,"")||(d.type?getElementTypeName(d.type):"MemoComponent");case"element":return getElementTypeName(d.type);case"fragment":return"Fragment";case"portal":return"Portal";case"profiler":return getDisplayName(d,"Profiler");case"strict-mode":return"StrictMode";case"suspense":return getDisplayName(d,"Suspense");case"suspense-list":return"SuspenseList";case"context-consumer":return null!==(b=d._context)&&void 0!==b&&b.displayName?"".concat(d._context.displayName,".Consumer"):"ContextConsumer";case"context-provider":return null!==(c=d._context)&&void 0!==c&&c.displayName?"".concat(d._context.displayName,".Provider"):"ContextProvider";case"lazy":return getDisplayName(d,"LazyComponent");case"object":return getDisplayName(d,"")?getDisplayName(d,""):"function"==typeof d.render?getDisplayName(d.render,"ObjectWithRender"):d.type&&d.type!==a?"Wrapped<".concat(getElementTypeName(d.type),">"):getDisplayName(d,"ObjectComponent");case"symbol":if("symbol"===_typeof(a)){var f;return(null===(f=a.description)||void 0===f?void 0:f.replace(/^react\./,"").split(".").map(function(a){var b;return(null===(b=a[0])||void 0===b?void 0:b.toUpperCase())+a.slice(1)}).join(""))||a.toString()}return"SymbolComponent";case"unknown":return"UnknownElementType";default:return"UnsupportedType<".concat(e,">")}}/**
- * A set of valid CSS property names in camelCase, including CSS custom properties, used for validation.
- * This set contains all CSS properties including non-standard vendor prefixed properties.
- */export var CSSPropertySet=new Set(cssProperties);/**
- * Filters an object to only include valid CSS properties
- * @param props The object containing potential CSS properties
- * @returns An object containing only valid CSS properties
- * @example
- * ```ts
- * getCSSProps({
- *   backgroundColor: 'red',
- *   invalid: true
- * }) // { backgroundColor: 'red' }
- * ```
- */export function getCSSProps(a){var b={};for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&CSSPropertySet.has(c)&&(b[c]=a[c]);return b}/**
- * Filters component props to include only valid DOM properties and attributes.
- *
- * This function iterates through the provided props and retains only those that
- * are not CSS properties (as determined by `cssPropertySet`). This is useful for
- * separating style-related props from standard DOM attributes when rendering
- * elements.
- * @ty E - The type of the React element.
- * @typeParam T - The type of the component props.
- * @param props The component props to filter.
- * @returns An object containing only valid DOM props.
- */export function getDOMProps(a){var b={};for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&!CSSPropertySet.has(c)&&(b[c]=a[c]);return b}/**
- * Retrieves a deeply nested value from an object using a dot-separated string path.
- *
- * This function traverses an object based on the provided path, which is a
- * string of keys separated by dots. It returns the value found at the end of
- * the path or `undefined` if any key in the path is not found or if the object
- * is nullish at any point during traversal.
- * @param obj The object to traverse. Defaults to an empty object if not provided.
- * @param path The dot-separated path string (e.g., 'background.primary').
- * @returns The value at the specified path, or undefined if not found.
- */export function getValueByPath(){var a=0<arguments.length&&arguments[0]!==void 0?arguments[0]:{},b=1<arguments.length?arguments[1]:void 0;return b.split(".").reduce(function(a,b){return null===a||void 0===a?void 0:a[b]},a)}/**
+"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{getValueByPath}from"./common.helper";/**
  * Type guard to check if an object is a NodeInstance.
  *
  * A NodeInstance is expected to be a non-null object with:
@@ -75,20 +16,19 @@
  * @param theme Optional theme object containing variable definitions
  * @returns A new object with all theme variables resolved to their values
  */export var resolveObjWithTheme=function resolveObjWithTheme(){var a=0<arguments.length&&arguments[0]!==void 0?arguments[0]:{},b=1<arguments.length?arguments[1]:void 0;// Early return if no theme or empty object
-if(!b||0===Object.keys(a).length)return a;/**
-   * Recursively resolves theme variables in an object, tracking visited objects
-   * to prevent infinite recursion with circular references.
-   */var c=function resolveRecursively(a,d){// Skip functions and non-plain objects to prevent unintended flattening or
-// modification of complex instances like React components, DOM elements, or Date objects.
-if(!a||"object"!==_typeof(a)||Array.isArray(a)||Object.getPrototypeOf(a)!==Object.prototype)return a;// Prevent processing same object multiple times
-if(d.has(a))return a;// Track this object to detect circular references
-d.add(a);var e={};for(var f in a){var g=a[f];// Skip functions and non-plain objects to prevent unintended flattening or
+if(!b||0===Object.keys(a).length)return a;var c=new Set(["ref","key"]),d=function resolveRecursively(a,e){// Skip functions and non-plain objects to prevent unintended flattening or
 // modification of complex instances like React components, DOM elements, or Date objects.
-if("function"==typeof g||g&&"object"===_typeof(g)&&!Array.isArray(g)&&Object.getPrototypeOf(g)!==Object.prototype||"ref"===f){e[f]=g;continue}// Resolve theme variables in string values
+if(!a||"object"!==_typeof(a)||Array.isArray(a)||Object.getPrototypeOf(a)!==Object.prototype)return a;// Prevent processing the same object multiple times
+if(e.has(a))return a;// Track this object to detect circular references
+for(var f in e.add(a),a)try{var g=a[f];// Conditions for direct assignment (no resolution or deep processing needed)
+if(c.has(f)||"function"==typeof g||"object"===_typeof(g)&&null!==g&&!Array.isArray(g)&&Object.getPrototypeOf(g)!==Object.prototype||"string"==typeof g&&!g.includes("theme.")||"object"!==_typeof(g)&&"string"!=typeof g&&"function"!=typeof g||"symbol"===_typeof(g))continue;// Resolve theme variables in string values
 if("string"==typeof g&&g.includes("theme.")){var h=g;h=h.replace(/theme\.([a-zA-Z0-9_.-]+)/g,function(a,c){var d=getValueByPath(b,c);// Only convert string/number theme values
 return void 0!==d&&null!==d?"object"===_typeof(d)&&!Array.isArray(d)&&"default"in d?d["default"]:d:a;// Keep original if no valid theme value found
-}),e[f]=h}// Recursively process nested objects
-else e[f]=c(g,d)}return e};return c(a,new Set)};/**
+}),a[f]=h}// Recursively process nested objects
+else a[f]=d(g,e)}catch(a){/* empty */}return a};/**
+   * Recursively resolves theme variables in an object, tracking visited objects
+   * to prevent infinite recursion with circular references.
+   */return d(a,new Set)};/**
  * Resolves default styles for a given CSSProperties object.
  * This method ensures that certain default styles, such as `minHeight`, `minWidth`,
  * and `flexShrink`, are applied based on the provided style properties.

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