@meonode/ui 0.4.11 → 0.4.13

package/dist/components/react.node.js

@@ -1,43 +0,0 @@
-import{Fragment as BaseFragment,Activity as BaseActivity,Suspense as BaseSuspense}from"react";import{createNode}from"../core.node.js";/**
- * A container that does not render any extra DOM element.
- * @see {@link https://react.dev/reference/react/Fragment React Docs}
- * @example
- *
- * ```typescript
- * import { Fragment, Div, Span } from '@meonode/ui';
- *
- * Fragment({
- *   children: [
- *     Div('First Div'),
- *     Span('A Span inside Fragment'),
- *     Div('Second Div'),
- *   ],
- * })
- * ```
- */export const Fragment=createNode(BaseFragment);/**
- * Lets you hide and restore the UI and internal state of its children.
- * @see {@link https://react.dev/reference/react/Activity React Docs}
- * @example
- *
- * ```typescript
- * import { Activity } from '@meonode/ui';
- *
- * Activity({
- *   mode: isShowingSidebar ? "visible" : "hidden",
- *   children: Div(...),
- * })
- * ```
- */export const Activity=createNode(BaseActivity);/**
- * Lets you display a fallback until its children have finished loading.
- * @see {@link https://react.dev/reference/react/Suspense React Docs}
- * @example
- *
- * ```typescript
- * import { Suspense } from '@meonode/ui';
- *
- * Suspense({
- *   fallback: 'Loading...',
- *   children: Div(...),
- * })
- * ```
- */export const Suspense=createNode(BaseSuspense);

package/dist/components/registry.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.client.d.ts","sourceRoot":"","sources":["../../src/components/registry.client.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,YAAY,EAAY,MAAM,OAAO,CAAA;AAWlE;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,yGA4B7E"}

package/dist/components/registry.client.js

@@ -1,14 +0,0 @@
-"use client";import{createElement,useState}from"react";import{CacheProvider}from"@emotion/react";import createCache from"@emotion/cache";import{Node}from"../core.node.js";import{useServerInsertedHTML}from"next/navigation.js";// Emotion cache setup
-function createEmotionCache(){return createCache({key:"meonode-css"})}/**
- * Style registry for Emotion to support SSR/streaming in Next.js App Router.
- *
- * - Creates a single Emotion cache instance in compat mode.
- * - Uses `useServerInsertedHTML` to inline critical CSS collected during render.
- * @param children React subtree that consumes Emotion styles.
- * @returns React element that provides the cache and injects critical CSS during SSR.
- */export default function StyleRegistry({children:a}){// Lazily create a single Emotion cache; enable compat for SSR/legacy Emotion APIs.
-const[b]=useState(()=>{const a=createEmotionCache();return a.compat=!0,a});// During server rendering, collect styles inserted into the cache and inline them in the HTML.
-// Provide the Emotion cache to descendants.
-return useServerInsertedHTML(()=>{// Ensure deterministic output by sorting ids.
-const a=Object.keys(b.inserted).sort(),c=a.map(a=>b.inserted[a]).join(""),d=a.join(" ");return c?createElement("style",{"data-emotion":`${b.key} ${d}`,dangerouslySetInnerHTML:{__html:c}}):null;// Insert a single style tag with the tracked Emotion ids.
-}),Node(CacheProvider,{value:b,children:a}).render()}

package/dist/components/styled-renderer.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"styled-renderer.client.d.ts","sourceRoot":"","sources":["../../src/components/styled-renderer.client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,SAAS,EAAc,MAAM,OAAO,CAAA;AAE5D,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAInE,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,WAAW;IACxD,OAAO,EAAE,CAAC,CAAA;IACV,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,GAAG,EAAE,OAAO,CAAA;CACb;AAED;;;;;;;;;GASG;AACH,iBAAwB,cAAc,CAAC,CAAC,SAAS,WAAW,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAChG,OAAO,EACP,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,GAAG,CAAC,OAAO,CAoB/C"}

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

@@ -1,10 +0,0 @@
-"use client";const _excluded=["element","children"],_excluded2=["css"];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{useContext}from"react";import{jsx}from"@emotion/react";import{ThemeContext}from"./theme-provider.client.js";import{ThemeUtil}from"../util/theme.util.js";/**
- * A client-side component that renders a styled element using Emotion.
- * It resolves theme values and applies default styles.
- * @template E The type of the HTML element to render.
- * @template TProps The type of the props for the component.
- * @param element The HTML element to render (e.g., 'div', 'span').
- * @param children Optional children to be rendered inside the element.
- * @param props
- * @returns {JSX.Element} The rendered JSX element.
- */export default function StyledRenderer(a){let{element:b,children:c}=a,d=_objectWithoutProperties(a,_excluded);const e=useContext(ThemeContext),f=e?.theme,{css:g}=d,h=_objectWithoutProperties(d,_excluded2);let i=g,j=h;f&&(i=ThemeUtil.resolveObjWithTheme(g,f,{processFunctions:!0}),j=ThemeUtil.resolveObjWithTheme(h,f,{processFunctions:!1}));const k=ThemeUtil.resolveDefaultStyle(i);return jsx(b,_objectSpread(_objectSpread({},j),{},{css:k}),c)}StyledRenderer.displayName="Styled";

package/dist/components/theme-provider.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"theme-provider.client.d.ts","sourceRoot":"","sources":["../../src/components/theme-provider.client.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,SAAS,EAAY,MAAM,OAAO,CAAA;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAG9D,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,CAAA;IACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AAED,eAAO,MAAM,YAAY,mDAAgD,CAAA;AAEzE;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAAG,SAAS,CAgB3G"}

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

@@ -1,8 +0,0 @@
-"use client";import{createContext,useState}from"react";import{Node}from"../core.node.js";export const ThemeContext=createContext(null);/**
- * The internal implementation of the ThemeProvider component.
- * @param {object} props The props for the component.
- * @param {Children} [props.children] The children to render.
- * @param {Theme} props.theme The theme to provide.
- * @returns {ReactNode} The rendered component.
- * @private
- */export default function ThemeProvider({children:a,theme:b}){const[c,d]=useState(b);if(!b)throw new Error("`theme` prop must be defined");return Node(ThemeContext.Provider,{value:{theme:c,setTheme:a=>{document.cookie=`theme=${a.mode}; path=/;`,d(a)}},children:a}).render()}

package/dist/components/theme-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"theme-provider.d.ts","sourceRoot":"","sources":["../../src/components/theme-provider.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,MAAM,0CAA0C,CAAA;AAErE;;GAEG;AACH,eAAO,MAAM,aAAa;;CAA6B,CAAA"}

package/dist/components/theme-provider.js

@@ -1,3 +0,0 @@
-import{createNode}from"../core.node.js";import _ThemeProvider from"./theme-provider.client.js";/**
- * A component that provides a theme to its children.
- */export const ThemeProvider=createNode(_ThemeProvider);

package/dist/constant/common.const.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.const.d.ts","sourceRoot":"","sources":["../../src/constant/common.const.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,uOAwBhB,CAAA;AAEV,eAAO,MAAM,cAAc,uPAAyB,CAAA;AACpD,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAA;AAEhD,eAAO,IAAI,SAAS,SAAQ,CAAA;AAE5B,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,QAK5C"}

package/dist/constant/common.const.js

@@ -1 +0,0 @@
-export const NO_STYLE_TAGS=["html","head","meta","link","script","style","noscript","template","slot","base","param","source","track","wbr","embed","object","iframe","frame","frameset","applet","bgsound","noembed","noframes"];export const noStyleTagsSet=new Set(NO_STYLE_TAGS);export let __DEBUG__=!1;export function setDebugMode(a){__DEBUG__=a,__DEBUG__&&console.log("[MeoNode] Debug mode enabled.")}

package/dist/constant/css-properties.const.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"css-properties.const.d.ts","sourceRoot":"","sources":["../../src/constant/css-properties.const.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa,k0ZAirBT,CAAA;AAEV,eAAe,aAAa,CAAA"}

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

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

package/dist/core.node.js

@@ -1,139 +0,0 @@
-const _excluded=["ref","children"],_excluded2=["key"],_excluded3=["children","key","css","nativeProps","disableEmotion"];var _BaseNode;function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function _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{createElement,Fragment,isValidElement}from"react";import{isFragment,isValidElementType}from"./helper/react-is.helper.js";import{getComponentType,getElementTypeName,hasNoStyleTag}from"./helper/common.helper.js";import StyledRenderer from"./components/styled-renderer.client.js";import{__DEBUG__}from"./constant/common.const.js";import{MountTrackerUtil}from"./util/mount-tracker.util.js";import MeoNodeUnmounter from"./components/meonode-unmounter.client.js";import{NavigationCacheManagerUtil}from"./util/navigation-cache-manager.util.js";import{NodeUtil}from"./util/node.util.js";import{ThemeUtil}from"./util/theme.util.js";/**
- * The core abstraction of the MeoNode library. It wraps a React element or component,
- * providing a unified interface for processing props, normalizing children, and handling styles.
- * This class is central to the library's ability to offer a JSX-free, fluent API for building UIs.
- * It uses an iterative rendering approach to handle deeply nested structures without causing stack overflows.
- * @class BaseNode
- * @template E - The type of React element or component this node represents.
- */export class BaseNode{static acquireRenderContext(){const a=BaseNode.renderContextPool;return 0<a.length?a.pop():{workStack:Array(512),renderedElements:new Map}}static releaseRenderContext(a){50>BaseNode.renderContextPool.length&&2048>a.workStack.length&&(a.workStack.length=0,a.renderedElements.clear(),BaseNode.renderContextPool.push(a))}constructor(a,b={},c){// Element type validation is performed once at construction to prevent invalid nodes from being created.
-if(_defineProperty(this,"instanceId",Math.random().toString(36).slice(2)+Date.now().toString(36)),_defineProperty(this,"rawProps",{}),_defineProperty(this,"isBaseNode",!0),!isValidElementType(a)){const b=getComponentType(a);throw new Error(`Invalid element type: ${b} provided!`)}this.element=a,this.rawProps=b,this._deps=c;// Extract commonly handled props; the remaining `propsForSignature` are used to compute a stable hash.
-const{ref:d,children:e}=b,f=_objectWithoutProperties(b,_excluded);// Generate or get cached stable key
-this.stableKey=this._getStableKey(f),NodeUtil.isServer||BaseNode._navigationStarted||(NavigationCacheManagerUtil.getInstance().start(),BaseNode._navigationStarted=!0)}/**
-   * Lazily processes and retrieves the final, normalized props for the node.
-   * The props are processed only once and then cached for subsequent accesses.
-   * @getter props
-   */get props(){return this._props||(this._props=NodeUtil.processProps(this.element,this.rawProps,this.stableKey)),this._props}/**
-   * Returns the dependency list associated with this node.
-   * Used by the renderer to decide if the node (and subtree) should update.
-   * Mirrors React hook semantics: `undefined` means always update; when an
-   * array is provided a shallow comparison against previous deps determines
-   * whether a re-render is required.
-   * @getter deps
-   */get dependencies(){return this._deps}/**
-   * Generates or returns a cached signature representing the props shape and values.
-   * The signature is used as a stable key for caching prop-derived computations (e.g. CSS extraction).
-   * - Uses a fast reference check to return the previous signature if the same props object is passed.
-   * - For very large prop objects (> 100 keys) it builds a smaller "criticalProps" fingerprint
-   * containing only style-related keys, event handlers, className/css and a `_keyCount` to avoid
-   * expensive serialization of huge objects while still retaining reasonable cache discrimination.
-   * - Stores the last props reference and computed signature to speed up repeated calls with the same object.
-   * @param key Key passed for prefix if exist
-   * @param props The props object to create a signature for.
-   * @returns A compact string signature suitable for use as a cache key.
-   */_getStableKey(a){let{key:b}=a,c=_objectWithoutProperties(a,_excluded2);if(NodeUtil.isServer)return;if(this.lastPropsObj===c)return this.lastSignature;this.lastPropsObj=c;const d=Object.keys(c),e=d.length;if(100<e){const a=NodeUtil.extractCriticalProps(c,d);this.lastSignature=NodeUtil.createPropSignature(this.element,a),__DEBUG__&&200<e&&console.warn(`MeoNode: Large props (${e} keys) on "${getElementTypeName(this.element)}". Consider splitting.`)}else this.lastSignature=NodeUtil.createPropSignature(this.element,c);return b!==void 0&&null!==b?`${b+""}:${this.lastSignature}`:this.lastSignature}/**
-   * FinalizationRegistry for cleaning up `elementCache` entries when the associated `BaseNode` instance
-   * is garbage-collected. This helps prevent memory leaks by ensuring that cache entries for
-   * unreferenced nodes are eventually removed.
-   *
-   * The held value must include `cacheKey` which is used to identify and delete the corresponding
-   * entry from `BaseNode.elementCache`.
-   * @public
-   *//**
-   * Renders the `BaseNode` and its entire subtree into a ReactElement, with support for opt-in reactivity
-   * via dependency arrays and inherited blocking.
-   *
-   * This method uses an **iterative (non-recursive) approach** with a manual work stack.
-   * This is a crucial architectural choice to prevent "Maximum call stack size exceeded" errors
-   * when rendering very deeply nested component trees, a common limitation of naive recursive rendering.
-   *
-   * The process works in two phases for each node:
-   * 1. **Begin Phase:** When a node is first visited, its children are pushed onto the stack. This ensures a bottom-up build.
-   * 2. **Complete Phase:** After all of a node's descendants have been rendered, the loop returns to the node.
-   *    It then collects the rendered children from a temporary map and creates its own React element.
-   * @method render
-   */render(a=!1){!NodeUtil.isServer&&this.stableKey&&MountTrackerUtil.trackMount(this.stableKey);// On server, we never reuse cached elements because that can cause hydration mismatches.
-const b=NodeUtil.isServer||!this.stableKey?void 0:BaseNode.elementCache.get(this.stableKey),c=NodeUtil.shouldNodeUpdate(b?.prevDeps,this._deps,a);// Decide whether this node (and its subtree) should update given dependency arrays.
-// Fast return: if nothing should update and we have a cached element, reuse it.
-if(!c&&b?.renderedElement)return b.accessCount+=1,b.renderedElement;// When this node doesn't need update, its children are considered "blocked" and may be skipped.
-const d=BaseNode.acquireRenderContext();// Acquire context from pool to reduce allocation pressure
-let{workStack:e}=d;const{renderedElements:f}=d;let g=0;try{// Fast capacity check with exponential growth
-const a=a=>{if(a>e.length){// Double capacity or use exact requirement (whichever is larger)
-const b=Math.max(a,e.length<<1),c=Array(b);// Manual copy is faster than Array methods for primitive/object arrays
-for(let a=0;a<g;a++)c[a]=e[a];e=c}};// Push initial work item
-// Iterative depth-first traversal with explicit begin/complete phases to avoid recursion.
-for(e[g++]={node:this,isProcessed:!1,blocked:!c};0<g;){const b=e[g-1];if(!b){g--;continue}const{node:c,isProcessed:d,blocked:h}=b;if(!d){b.isProcessed=!0;const d=c.props.children;if(d){// Only consider BaseNode children for further traversal; primitives and React elements are terminal.
-const b=(Array.isArray(d)?d:[d]).filter(NodeUtil.isNodeInstance),c=g+b.length;// --- Check capacity ONCE before loop ---
-a(c);for(let a=b.length-1;0<=a;a--){const c=b[a],d=NodeUtil.isServer||!c.stableKey?void 0:BaseNode.elementCache.get(c.stableKey),i=NodeUtil.shouldNodeUpdate(d?.prevDeps,c._deps,h);// Respect server/client differences for child cache lookup.
-// Determine whether the child should update given its deps and the parent's blocked state.
-// If child doesn't need update and has cached element, reuse it immediately (no push).
-if(!i&&d?.renderedElement){f.set(c,d.renderedElement);continue}// Otherwise push child for processing; childBlocked inherits parent's blocked state.
-const j=h||!i;e[g++]={node:c,isProcessed:!1,blocked:j}}}}else{g--;// Extract node props. Non-present props default to undefined via destructuring.
-const a=c.props,{children:b,key:d,css:e,nativeProps:h,disableEmotion:i}=a,j=_objectWithoutProperties(a,_excluded3);let k=[];if(b){// Convert child placeholders into concrete React nodes:
-// - If it's a BaseNode, lookup its rendered ReactElement from the map.
-// - If it's already a React element, use it directly.
-// - Otherwise treat as primitive ReactNode.
-const a=Array.isArray(b)?b:[b],c=a.length;// Pre-allocate array to avoid resizing during iteration
-k=Array(c);for(let b=0;b<c;b++){const c=a[b];if(NodeUtil.isNodeInstance(c)){const a=f.get(c);if(!a)throw new Error(`[MeoNode] Missing rendered element for child node: ${c.stableKey}`);k[b]=a}else k[b]=isValidElement(c)?c:c}}// Merge element props: explicit other props + DOM native props + React key.
-const l=_objectSpread(_objectSpread({},j),{},{key:d},h);let m;// Handle fragments specially: create fragment element with key and children.
-if(c.element===Fragment||isFragment(c.element))m=createElement(c.element,{key:d},...k);else{// StyledRenderer for emotion-based styling unless explicitly disabled or no styles are present.
-// StyledRenderer handles SSR hydration and emotion CSS injection when css prop exists or element has style tags.
-const a=!i&&(e||!hasNoStyleTag(c.element));m=a?createElement(StyledRenderer,_objectSpread(_objectSpread({element:c.element},l),{},{css:e,suppressHydrationWarning:!0}),...k):createElement(c.element,l,...k)}// Cache the generated element on client-side to speed up future renders.
-if(!NodeUtil.isServer&&c.stableKey){const a=BaseNode.elementCache.get(c.stableKey);if(a)a.prevDeps=c._deps,a.renderedElement=m,a.accessCount+=1;else{// Create new cache entry and register for cleanup
-const a={prevDeps:c._deps,renderedElement:m,nodeRef:new WeakRef(c),createdAt:Date.now(),accessCount:1,instanceId:c.instanceId};// Set new cache entry
-BaseNode.elementCache.set(c.stableKey,a),BaseNode.cacheCleanupRegistry.register(c,{cacheKey:c.stableKey,instanceId:c.instanceId},c)}}// Store the rendered element so parent nodes can reference it.
-f.set(c,m)}}// Get the final rendered element for the root node of this render cycle.
-const b=f.get(this);return!NodeUtil.isServer&&this.stableKey?createElement(MeoNodeUnmounter,{node:this},b):b}finally{// Always release context back to pool, even if an exception occurred
-// Null out workStack slots to help GC before releasing
-for(let a=0;a<g;a++)e[a]=null;BaseNode.releaseRenderContext({workStack:e,renderedElements:f})}}/**
-   * Renders the node into a React Portal, mounting it directly under `document.body`.
-   * Returns a handle with `update` and `unmount` methods to control the portal's lifecycle.
-   * @method toPortal
-   */toPortal(){if(!NodeUtil.ensurePortalInfrastructure(this))throw new Error("toPortal() can only be called in a client-side environment");const a=NodeUtil.portalInfrastructure.get(this),{domElement:b,reactRoot:c}=a,d=()=>{try{c.render(this.render())}catch(a){__DEBUG__&&console.error("[MeoNode] Portal render error:",a)}};d();// Track if already unmounted to make unmount idempotent
-let e=!1;const f=c.unmount.bind(c);return c.update=a=>{if(e)return void(__DEBUG__&&console.warn("[MeoNode] Attempt to update already-unmounted portal"));try{const b=NodeUtil.isNodeInstance(a)?a.render():a;c.render(b)}catch(a){__DEBUG__&&console.error("[MeoNode] Portal update error:",a)}},c.unmount=()=>{// Idempotent guard
-if(e)return void(__DEBUG__&&console.warn("[MeoNode] Portal already unmounted"));e=!0;// Unregister FIRST to prevent FinalizationRegistry from firing
-try{BaseNode.portalCleanupRegistry.unregister(this)}catch(a){__DEBUG__&&console.warn("[MeoNode] Portal unregister warning:",a)}// Remove from WeakMap
-NodeUtil.portalInfrastructure.delete(this);// Now do the actual cleanup
-try{b?.isConnected&&f()}catch(a){__DEBUG__&&console.error("[MeoNode] Portal unmount error:",a)}try{b?.isConnected&&b.remove()}catch(a){__DEBUG__&&console.error("[MeoNode] Portal DOM cleanup error:",a)}},c}/**
-   * A static method to clear all internal caches.
-   *
-   * This method performs manual cleanup of all cache entries, calling their
-   * `onEvict` callbacks before clearing. Note that FinalizationRegistry entries
-   * are not manually cleared as they will be garbage collected naturally when
-   * the associated nodes are collected.
-   * @method clearCaches
-   */static clearCaches(){// Collect all cache keys first
-const a=Array.from(BaseNode.elementCache.keys());__DEBUG__&&console.log(`[MeoNode] clearCaches: Clearing ${a.length} entries`);// Call onEvict for all entries (idempotent) and clear node properties
-for(const b of a){const a=BaseNode.elementCache.get(b);if(a){// Try to unregister from FinalizationRegistry
-const c=a.nodeRef?.deref();if(c)try{BaseNode.cacheCleanupRegistry.unregister(c),c.lastSignature=void 0,c.lastPropsObj=void 0}catch(a){__DEBUG__&&console.warn(`[MeoNode] Could not unregister ${b} from FinalizationRegistry`)}}}// Clear all caches
-// Clear mount tracking
-BaseNode.propProcessingCache.clear(),BaseNode.elementCache.clear(),ThemeUtil.clearThemeCache(),MountTrackerUtil.cleanup(),__DEBUG__&&console.log("[MeoNode] All caches cleared")}// --- Utilities ---
-}// --- Factory Functions ---
-/**
- * The primary factory function for creating a `BaseNode` instance.
- * It's the simplest way to wrap a component or element.
- * @function Node
- */_BaseNode=BaseNode,_defineProperty(BaseNode,"elementCache",new Map),_defineProperty(BaseNode,"propProcessingCache",new Map),_defineProperty(BaseNode,"scheduledCleanup",!1),_defineProperty(BaseNode,"_navigationStarted",!1),_defineProperty(BaseNode,"renderContextPool",[]),_defineProperty(BaseNode,"cacheCleanupRegistry",new FinalizationRegistry(a=>{const{cacheKey:b,instanceId:c}=a,d=_BaseNode.elementCache.get(b);d?.instanceId===c&&_BaseNode.elementCache.delete(b),MountTrackerUtil.mountedNodes.has(b)&&MountTrackerUtil.untrackMount(b)})),_defineProperty(BaseNode,"portalCleanupRegistry",new FinalizationRegistry(a=>{const{domElement:b,reactRoot:c}=a;__DEBUG__&&console.log("[MeoNode] FinalizationRegistry auto-cleaning portal");// Guard: Check if already unmounted
-try{c&&"function"==typeof c.unmount&&c.unmount()}catch(a){__DEBUG__&&console.error("[MeoNode] Portal auto-cleanup unmount error:",a)}// Guard: Check if DOM element still connected
-try{b?.isConnected&&b.remove()}catch(a){__DEBUG__&&console.error("[MeoNode] Portal auto-cleanup DOM removal error:",a)}}));function Node(a,b={},c){return new BaseNode(a,b,c)}/**
- * Static alias on the `Node` factory for clearing all internal caches used by `BaseNode`.
- *
- * Use cases include:
- *   - resetting state between tests,
- *   - hot-module-replacement (HMR) cycles,
- *   - manual resets in development,
- *   - or during SPA navigation to avoid stale cached elements/styles.
- *
- * Notes:
- *   - Clears only internal prop/element caches; does not touch portal infrastructure or external runtime state.
- *   - Safe to call on the server, but most useful on the client.
- * @method Node.clearCaches
- */Node.clearCaches=BaseNode.clearCaches;// Export the Node factory as the main export
-export{Node};/**
- * Creates a curried node factory for a given React element or component type.
- * This is useful for creating reusable, specialized factory functions (e.g., `const Div = createNode('div')`).
- * @function createNode
- */export function createNode(a,b){const c=(c,d)=>Node(a,_objectSpread(_objectSpread({},b),c),d);return c.element=a,c}/**
- * Creates a node factory function where the first argument is `children` and the second is `props`.
- * This provides a more ergonomic API for components that primarily wrap content (e.g., `P('Some text')`).
- * @function createChildrenFirstNode
- */export function createChildrenFirstNode(a,b){const c=(c,d,e)=>Node(a,_objectSpread(_objectSpread(_objectSpread({},b),d),{},{children:c}),e);return c.element=a,c}

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

@@ -1 +0,0 @@
-{"version":3,"file":"common.helper.d.ts","sourceRoot":"","sources":["../../src/helper/common.helper.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAExF,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAGvE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,iCAE1B,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,oDAmC5B,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;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,WAAW,GAAG,OAAO,CAGxD;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAQ1F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAQlE"}

package/dist/helper/common.helper.js

@@ -1,73 +0,0 @@
-import{isContextConsumer,isContextProvider,isElement,isForwardRef,isFragment,isLazy,isMemo,isPortal,isProfiler,isReactClassComponent,isStrictMode,isSuspense,isSuspenseList}from"./react-is.helper.js";import cssProperties from"../constant/css-properties.const.js";import{noStyleTagsSet}from"../constant/common.const.js";/**
- * 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 const getValueByPath=(a,b)=>b.split(".").reduce((a,b)=>a&&void 0!==a[b]?a[b]:void 0,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 const getComponentType=a=>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){function getDisplayName(a,b){const c=a?.displayName||a?.name;return!c||"render"===c?b:c}if(null===a||a===void 0)return"UnknownElementType";const b=a,c=getComponentType(b);return"string"===c?a:"class"===c?getDisplayName(b,"ClassComponent"):"function"===c?getDisplayName(b,"AnonymousFunctionComponent"):"forwardRef"===c?getDisplayName(b,"")||getDisplayName(b.render,"")||"ForwardRefComponent":"memo"===c?getDisplayName(b,"")||(b.type?getElementTypeName(b.type):"MemoComponent"):"element"===c?getElementTypeName(b.type):"fragment"===c?"Fragment":"portal"===c?"Portal":"profiler"===c?getDisplayName(b,"Profiler"):"strict-mode"===c?"StrictMode":"suspense"===c?getDisplayName(b,"Suspense"):"suspense-list"===c?"SuspenseList":"context-consumer"===c?b._context?.displayName?`${b._context.displayName}.Consumer`:"ContextConsumer":"context-provider"===c?b._context?.displayName?`${b._context.displayName}.Provider`:"ContextProvider":"lazy"===c?getDisplayName(b,"LazyComponent"):"object"===c?getDisplayName(b,"")?getDisplayName(b,""):"function"==typeof b.render?getDisplayName(b.render,"ObjectWithRender"):b.type&&b.type!==a?`Wrapped<${getElementTypeName(b.type)}>`:getDisplayName(b,"ObjectComponent"):"symbol"===c?"symbol"==typeof a?a.description?.replace(/^react\./,"").split(".").map(a=>a[0]?.toUpperCase()+a.slice(1)).join("")||a.toString():"SymbolComponent":"unknown"===c?"UnknownElementType":`UnsupportedType<${c}>`}/**
- * 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 const 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){const b={};for(const 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){const b={};for(const c in a)Object.prototype.hasOwnProperty.call(a,c)&&!CSSPropertySet.has(c)&&(b[c]=a[c]);return b}/**
- * Checks if a given tag is in the set of tags that should not receive style props.
- * @param tag The tag name to check (e.g., 'script', 'style').
- * @returns `true` if the tag is in the no-style set, otherwise `false`.
- */export function hasNoStyleTag(a){return!!(a&&"string"==typeof a)&&noStyleTagsSet.has(a.toLowerCase())}/**
- * Returns a shallow copy of the object with the specified keys omitted.
- * @param obj The source object.
- * @param keys The property keys to omit.
- * @returns A new object without the omitted keys.
- */export function omit(a,...b){const c={};for(const d in a)Object.prototype.hasOwnProperty.call(a,d)&&!b.includes(d)&&(c[d]=a[d]);return c}/**
- * Removes keys from an object whose values are `undefined`.
- * @param obj The source object.
- * @returns A new object without keys that have `undefined` values.
- */export function omitUndefined(a){const b={};for(const c in a)Object.prototype.hasOwnProperty.call(a,c)&&void 0!==a[c]&&(b[c]=a[c]);return b}

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

@@ -1 +0,0 @@
-{"version":3,"file":"obj.helper.d.ts","sourceRoot":"","sources":["../../src/helper/obj.helper.ts"],"names":[],"mappings":"AAOA,qBAAa,SAAS;IACpB,OAAO,eAAiB;IAExB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAmGhC;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,SAAI,GAAG,MAAM,CAU5C;CACF"}

package/dist/helper/obj.helper.js

@@ -1,23 +0,0 @@
-export class ObjHelper{constructor(){}/**
-   * Build a serializable representation of `value`.
-   * - preserves encoded placeholders for special types
-   * - emits { $type: 'Circular', ref: id } for circular refs
-   */static buildSerializable(a,b){// Fast path for primitives
-if(null===a||void 0===a)return a;const c=typeof a;// Handle primitives first (most common case)
-if("string"==c||"number"===c||"boolean"===c)return a;// Handle functions
-if("function"==c){let c=b.functionIds.get(a);return void 0===c&&(c=b.nextFunctionId++,b.functionIds.set(a,c)),{$type:"Function",name:a.name||"",id:c}}// Handle other primitives
-if("symbol"==c)return{$type:"Symbol",key:a.description??""};if("bigint"==c)return{$type:"BigInt",value:a.toString()};// Only objects beyond this point
-if("object"!=c)// Fallback for unknown types
-try{return a+""}catch(a){return"<unserializable>"}// Handle built-in object types before circular check (they're less likely to be circular)
-if(a instanceof Date)return{$type:"Date",value:a.toISOString()};if(a instanceof RegExp)return{$type:"RegExp",source:a.source,flags:a.flags};// Circular detection
-const d=b.seen.get(a);if(void 0!==d)return{$type:"Circular",ref:d};// Assign ID and mark as seen
-const e=b.nextObjId++;// Handle Map
-if(b.seen.set(a,e),a instanceof Map){const c=[];for(const[d,e]of a.entries())c.push([this.buildSerializable(d,b),this.buildSerializable(e,b)]);return{$type:"Map",entries:c}}// Handle Set
-if(a instanceof Set){const c=[];for(const d of a.values())c.push(this.buildSerializable(d,b));return{$type:"Set",values:c}}// Handle Arrays
-if(Array.isArray(a))// Use map for cleaner code and potential engine optimizations
-return a.map(a=>this.buildSerializable(a,b));// Handle plain objects
-try{const c=Object.keys(a),d={};for(const e of c)try{d[e]=this.buildSerializable(a[e],b)}catch(a){d[e]="<unserializable>"}return d}catch(a){return"<unserializable>"}}/**
-   * Stringify with performance optimizations.
-   * @param obj Object to serialize
-   * @param space JSON.stringify space parameter
-   */static stringify(a,b=0){const c={nextObjId:0,nextFunctionId:0,seen:new Map,functionIds:new Map},d=this.buildSerializable(a,c);return JSON.stringify(d,null,b)}}

package/dist/helper/react-is.helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-is.helper.d.ts","sourceRoot":"","sources":["../../src/helper/react-is.helper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB;;;GAGG;AACH,eAAO,MAAM,kBAAkB,eAA2C,CAAA;AAC1E,eAAO,MAAM,iBAAiB,eAA6B,CAAA;AAC3D,eAAO,MAAM,mBAAmB,eAA+B,CAAA;AAC/D,eAAO,MAAM,sBAAsB,eAAkC,CAAA;AACrE,eAAO,MAAM,mBAAmB,eAA+B,CAAA;AAC/D,eAAO,MAAM,mBAAmB,eAA+B,CAAA;AAC/D,eAAO,MAAM,mBAAmB,eAA+B,CAAA;AAC/D,eAAO,MAAM,kBAAkB,eAA8B,CAAA;AAC7D,eAAO,MAAM,sBAAsB,eAAkC,CAAA;AACrE,eAAO,MAAM,mBAAmB,eAA+B,CAAA;AAC/D,eAAO,MAAM,wBAAwB,eAAoC,CAAA;AACzE,eAAO,MAAM,eAAe,eAA2B,CAAA;AACvD,eAAO,MAAM,eAAe,eAA2B,CAAA;AACvD,eAAO,MAAM,0BAA0B,eAAsC,CAAA;AAC7E,eAAO,MAAM,sBAAsB,eAAuC,CAAA;AAC1E,eAAO,MAAM,mBAAmB,eAA+B,CAAA;AAE/D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GACxB,OAAO,kBAAkB,GACzB,OAAO,iBAAiB,GACxB,OAAO,mBAAmB,GAC1B,OAAO,sBAAsB,GAC7B,OAAO,mBAAmB,GAC1B,OAAO,mBAAmB,GAC1B,OAAO,mBAAmB,GAC1B,OAAO,kBAAkB,GACzB,OAAO,sBAAsB,GAC7B,OAAO,mBAAmB,GAC1B,OAAO,wBAAwB,GAC/B,OAAO,eAAe,GACtB,OAAO,eAAe,GACtB,OAAO,0BAA0B,GACjC,OAAO,sBAAsB,GAC7B,OAAO,mBAAmB,CAAA;AAE9B;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,GAAG,CAAA;IAEV,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAoCpE;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8BAAuE,CAAA;AAErG;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,8BAAuE,CAAA;AAErG;;;;GAIG;AACH,eAAO,MAAM,SAAS,8BACyF,CAAA;AAE/G;;;;GAIG;AACH,eAAO,MAAM,YAAY,8BAA0E,CAAA;AAEnG;;;;GAIG;AACH,eAAO,MAAM,UAAU,8BAAuE,CAAA;AAE9F;;;;GAIG;AACH,eAAO,MAAM,MAAM,8BAAmE,CAAA;AAEtF;;;;GAIG;AACH,eAAO,MAAM,MAAM,8BAAmE,CAAA;AAEtF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,8BAAqE,CAAA;AAE1F;;;;GAIG;AACH,eAAO,MAAM,UAAU,8BAAuE,CAAA;AAE9F;;;;GAIG;AACH,eAAO,MAAM,YAAY,8BAA0E,CAAA;AAEnG;;;;GAIG;AACH,eAAO,MAAM,UAAU,8BAAuE,CAAA;AAE9F;;;;GAIG;AACH,eAAO,MAAM,cAAc,8BAA4E,CAAA;AAEvG;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,8BAA8E,CAAA;AAE3G;;;;GAIG;AACH,eAAO,MAAM,UAAU,8BAAuE,CAAA;AAiB9F;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,qBAgBnC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,8DAQjC,CAAA"}

package/dist/helper/react-is.helper.js

@@ -1,94 +0,0 @@
-/**
- * Custom React Type Checker (TypeScript Version)
- * Provides utilities for identifying and checking React component/element types.
- * Inspired by react-is package but implemented in TypeScript with type safety.
- *//**
- * Symbol identifiers for React internal component types
- * These are used to identify different kinds of React elements and components
- */export const REACT_ELEMENT_TYPE=Symbol.for("react.transitional.element");export const REACT_PORTAL_TYPE=Symbol.for("react.portal");export const REACT_FRAGMENT_TYPE=Symbol.for("react.fragment");export const REACT_STRICT_MODE_TYPE=Symbol.for("react.strict_mode");export const REACT_PROFILER_TYPE=Symbol.for("react.profiler");export const REACT_PROVIDER_TYPE=Symbol.for("react.provider");export const REACT_CONSUMER_TYPE=Symbol.for("react.consumer");export const REACT_CONTEXT_TYPE=Symbol.for("react.context");export const REACT_FORWARD_REF_TYPE=Symbol.for("react.forward_ref");export const REACT_SUSPENSE_TYPE=Symbol.for("react.suspense");export const REACT_SUSPENSE_LIST_TYPE=Symbol.for("react.suspense_list");export const REACT_MEMO_TYPE=Symbol.for("react.memo");export const REACT_LAZY_TYPE=Symbol.for("react.lazy");export const REACT_VIEW_TRANSITION_TYPE=Symbol.for("react.view_transition");export const REACT_CLIENT_REFERENCE=Symbol.for("react.client.reference");export const REACT_ACTIVITY_TYPE=Symbol.for("react.activity");/**
- * Union type of all possible React internal type symbols.
- * Used to strongly type return values from type checking functions.
- *//**
- * Interface describing the minimal shape of a React element-like object.
- * Used for type checking without coupling to React's internal element type.
- *//**
- * Determines the internal React type of an object.
- * Examines the object's $$typeof property and nested type properties
- * to identify what kind of React element or component it represents.
- * @param {unknown} object The object to check
- * @returns {boolean} - The matching React type symbol or undefined if not a React object
- */export function typeOf(a){if("object"==typeof a&&null!==a){const b=a.$$typeof;switch(b){case REACT_ELEMENT_TYPE:{const c=a.type;switch(c){case REACT_FRAGMENT_TYPE:case REACT_PROFILER_TYPE:case REACT_STRICT_MODE_TYPE:case REACT_SUSPENSE_TYPE:case REACT_SUSPENSE_LIST_TYPE:case REACT_VIEW_TRANSITION_TYPE:return c;default:{const a=c?.$$typeof;return a===REACT_CONTEXT_TYPE||a===REACT_FORWARD_REF_TYPE||a===REACT_LAZY_TYPE||a===REACT_MEMO_TYPE||a===REACT_PROVIDER_TYPE||a===REACT_CONSUMER_TYPE?a:b}}}case REACT_PORTAL_TYPE:return b}}}/**
- * Checks if an object is a React Context Consumer
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a Context.Consumer
- */export const isContextConsumer=a=>typeOf(a)===REACT_CONSUMER_TYPE;/**
- * Checks if an object is a React Context Provider
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a Context.Provider
- */export const isContextProvider=a=>typeOf(a)===REACT_PROVIDER_TYPE;/**
- * Checks if an object is a valid React element
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a React element
- */export const isElement=a=>"object"==typeof a&&null!==a&&a.$$typeof===REACT_ELEMENT_TYPE;/**
- * Checks if an object is a React forwardRef component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a forwardRef component
- */export const isForwardRef=a=>typeOf(a)===REACT_FORWARD_REF_TYPE;/**
- * Checks if an object is a React Fragment
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a Fragment
- */export const isFragment=a=>typeOf(a)===REACT_FRAGMENT_TYPE;/**
- * Checks if an object is a React lazy component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a lazy component
- */export const isLazy=a=>typeOf(a)===REACT_LAZY_TYPE;/**
- * Checks if an object is a React memo component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a memo component
- */export const isMemo=a=>typeOf(a)===REACT_MEMO_TYPE;/**
- * Checks if an object is a React portal
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a portal
- */export const isPortal=a=>typeOf(a)===REACT_PORTAL_TYPE;/**
- * Checks if an object is a React Profiler
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is a Profiler
- */export const isProfiler=a=>typeOf(a)===REACT_PROFILER_TYPE;/**
- * Checks if an object is a React StrictMode component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is StrictMode
- */export const isStrictMode=a=>typeOf(a)===REACT_STRICT_MODE_TYPE;/**
- * Checks if an object is a React Suspense component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is Suspense
- */export const isSuspense=a=>typeOf(a)===REACT_SUSPENSE_TYPE;/**
- * Checks if an object is a React SuspenseList component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if `object` is SuspenseList
- */export const isSuspenseList=a=>typeOf(a)===REACT_SUSPENSE_LIST_TYPE;/**
- * Checks if an object is a React ViewTransition component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is ViewTransition
- */export const isViewTransition=a=>typeOf(a)===REACT_VIEW_TRANSITION_TYPE;/**
- * Checks if an object is a React Activity component
- * @param {unknown} object Object to check
- * @returns {boolean} - True if object is Activity
- */export const isActivity=a=>typeOf(a)===REACT_ACTIVITY_TYPE;/**
- * Set of known valid React special element types.
- * Used for quick validation of element types in isValidElementType().
- * Includes Fragment, Profiler, StrictMode, Suspense and SuspenseList.
- */const knownValidSymbols=new Set([REACT_FRAGMENT_TYPE,REACT_PROFILER_TYPE,REACT_STRICT_MODE_TYPE,REACT_SUSPENSE_TYPE,REACT_SUSPENSE_LIST_TYPE,REACT_VIEW_TRANSITION_TYPE,REACT_ACTIVITY_TYPE]);/**
- * Checks if a type is a valid React element type that can be rendered.
- * This includes strings (for DOM elements), functions (for components),
- * and various React-specific types like Fragment, Context, etc.
- * @param {any} type The type to validate
- * @returns {boolean} - True if the type can be rendered as a React element
- */export const isValidElementType=a=>{if("string"==typeof a||"number"==typeof a||"bigint"==typeof a||"function"==typeof a)return!0;if(knownValidSymbols.has(a))return!0;if("object"==typeof a&&null!==a){const b=a.$$typeof;return b===REACT_LAZY_TYPE||b===REACT_MEMO_TYPE||b===REACT_CONTEXT_TYPE||b===REACT_CONSUMER_TYPE||b===REACT_FORWARD_REF_TYPE||b===REACT_CLIENT_REFERENCE||b===REACT_PROVIDER_TYPE}return!1};/**
- * Type guard that checks if a component is a React class component.
- * Examines the component's prototype for the isReactComponent marker property
- * that React adds to all class components.
- * @param {unknown} component Component to check
- * @returns {boolean} - True if component is a React class component
- */export const isReactClassComponent=a=>{if("function"!=typeof a)return!1;// Check for `isReactComponent` flag which is set on class components.
-// Also handles components created with React.createClass.
-const b=a.prototype;return!!(b&&b.isReactComponent)};

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

@@ -1 +0,0 @@
-{"version":3,"file":"component.hoc.d.ts","sourceRoot":"","sources":["../../src/hoc/component.hoc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AACjH,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,EAAE,IAAI,CAAC,EAAE,cAAc,KAAK,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA;AAE/G;;;;;;;;;;;;;;;;;;;;;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,EAAE,IAAI,CAAC,EAAE,cAAc,KAAK,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA"}

package/dist/hoc/component.hoc.js

@@ -1,50 +0,0 @@
-import{BaseNode,Node}from"../core.node.js";import{getElementTypeName}from"../helper/common.helper.js";import{NodeUtil}from"../util/node.util.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` 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`
- *
- * 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`.
- * @returns A React-compatible component that can accept `children`.
- * @example
- * ```ts
- * const Title = Component((props) => {
- *   return H1(props.children)
- * })
- *
- * Title({ children: 'Hello' })
- * ```
- *//**
- * 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 `children`/`props` overrides.
- * @example
- * ```ts
- * interface ButtonProps {
- *   label: string
- *   onClick: () => void
- * }
- *
- * const Button = Component<ButtonProps>((props) => {
- *   return Div({
- *     children: props.label,
- *     onClick: props.onClick,
- *   })
- * })
- *
- * Button({ label: 'Click me', onClick: () => alert('clicked')})
- * ```
- *//**
- * Internal implementation of the `Component` HOC.
- * Handles BaseNode conversion and wrapper creation.
- */export function Component(a){function Func(a={},b){return Node(c,a,b).render()}const b=getElementTypeName(a),c=b=>{const c=a(b);return c instanceof BaseNode||NodeUtil.isNodeInstance(c)?Node(c.element,c.rawProps).render():c};return c.displayName=`Renderer(${b})`,Func.displayName=`Component(${b})`,Func}

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

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

package/dist/hoc/index.js

@@ -1 +0,0 @@
-export*from"./portal.hoc.js";export*from"./component.hoc.js";

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

@@ -1 +0,0 @@
-{"version":3,"file":"portal.hoc.d.ts","sourceRoot":"","sources":["../../src/hoc/portal.hoc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAe,YAAY,EAAyB,cAAc,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAK5J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}