@memberjunction/react-runtime 2.70.0

package/dist/runtime/component-hierarchy.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countComponentsInHierarchy = exports.flattenComponentHierarchy = exports.validateComponentSpec = exports.registerComponentHierarchy = exports.ComponentHierarchyRegistrar = void 0;
+class ComponentHierarchyRegistrar {
+    constructor(compiler, registry, runtimeContext) {
+        this.compiler = compiler;
+        this.registry = registry;
+        this.runtimeContext = runtimeContext;
+    }
+    async registerHierarchy(rootSpec, options = {}) {
+        const { styles, namespace = 'Global', version = 'v1', continueOnError = true, allowOverride = true } = options;
+        const registeredComponents = [];
+        const errors = [];
+        const warnings = [];
+        const rootResult = await this.registerSingleComponent(rootSpec, { styles, namespace, version, allowOverride });
+        if (rootResult.success) {
+            registeredComponents.push(rootSpec.componentName);
+        }
+        else {
+            errors.push(rootResult.error);
+            if (!continueOnError) {
+                return { success: false, registeredComponents, errors, warnings };
+            }
+        }
+        const childComponents = rootSpec.childComponents || rootSpec.components || [];
+        if (childComponents.length > 0) {
+            const childResult = await this.registerChildComponents(childComponents, { styles, namespace, version, continueOnError, allowOverride }, registeredComponents, errors, warnings);
+        }
+        return {
+            success: errors.length === 0,
+            registeredComponents,
+            errors,
+            warnings
+        };
+    }
+    async registerSingleComponent(spec, options) {
+        const { styles, namespace = 'Global', version = 'v1', allowOverride = true } = options;
+        try {
+            if (!spec.componentCode) {
+                return {
+                    success: true,
+                    error: undefined
+                };
+            }
+            const existingComponent = this.registry.get(spec.componentName, namespace, version);
+            if (existingComponent && !allowOverride) {
+                return {
+                    success: false,
+                    error: {
+                        componentName: spec.componentName,
+                        error: `Component already registered in ${namespace}/${version}`,
+                        phase: 'registration'
+                    }
+                };
+            }
+            const compileOptions = {
+                componentName: spec.componentName,
+                componentCode: spec.componentCode,
+                styles
+            };
+            const compilationResult = await this.compiler.compile(compileOptions);
+            if (!compilationResult.success) {
+                return {
+                    success: false,
+                    error: {
+                        componentName: spec.componentName,
+                        error: compilationResult.error?.message || 'Unknown compilation error',
+                        phase: 'compilation'
+                    }
+                };
+            }
+            const componentFactory = compilationResult.component.component(this.runtimeContext, styles);
+            this.registry.register(spec.componentName, componentFactory.component, namespace, version);
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    componentName: spec.componentName,
+                    error: error instanceof Error ? error.message : String(error),
+                    phase: 'registration'
+                }
+            };
+        }
+    }
+    async registerChildComponents(children, options, registeredComponents, errors, warnings) {
+        for (const child of children) {
+            const childResult = await this.registerSingleComponent(child, {
+                styles: options.styles,
+                namespace: options.namespace,
+                version: options.version,
+                allowOverride: options.allowOverride
+            });
+            if (childResult.success) {
+                if (child.componentCode) {
+                    registeredComponents.push(child.componentName);
+                }
+            }
+            else {
+                errors.push(childResult.error);
+                if (!options.continueOnError) {
+                    return;
+                }
+            }
+            const nestedChildren = child.childComponents || child.components || [];
+            if (nestedChildren.length > 0) {
+                await this.registerChildComponents(nestedChildren, options, registeredComponents, errors, warnings);
+            }
+        }
+    }
+}
+exports.ComponentHierarchyRegistrar = ComponentHierarchyRegistrar;
+async function registerComponentHierarchy(rootSpec, compiler, registry, runtimeContext, options = {}) {
+    const registrar = new ComponentHierarchyRegistrar(compiler, registry, runtimeContext);
+    return registrar.registerHierarchy(rootSpec, options);
+}
+exports.registerComponentHierarchy = registerComponentHierarchy;
+function validateComponentSpec(spec) {
+    const errors = [];
+    if (!spec.componentName) {
+        errors.push('Component specification must have a componentName');
+    }
+    if (spec.componentCode) {
+        if (typeof spec.componentCode !== 'string') {
+            errors.push(`Component code for ${spec.componentName} must be a string`);
+        }
+        if (spec.componentCode.trim().length === 0) {
+            errors.push(`Component code for ${spec.componentName} cannot be empty`);
+        }
+    }
+    const children = spec.childComponents || spec.components || [];
+    children.forEach((child, index) => {
+        const childErrors = validateComponentSpec(child);
+        childErrors.forEach(error => {
+            errors.push(`Child ${index} (${child.componentName || 'unnamed'}): ${error}`);
+        });
+    });
+    return errors;
+}
+exports.validateComponentSpec = validateComponentSpec;
+function flattenComponentHierarchy(rootSpec) {
+    const components = [rootSpec];
+    const children = rootSpec.childComponents || rootSpec.components || [];
+    children.forEach(child => {
+        components.push(...flattenComponentHierarchy(child));
+    });
+    return components;
+}
+exports.flattenComponentHierarchy = flattenComponentHierarchy;
+function countComponentsInHierarchy(rootSpec, includeEmpty = false) {
+    let count = 0;
+    if (includeEmpty || rootSpec.componentCode) {
+        count = 1;
+    }
+    const children = rootSpec.childComponents || rootSpec.components || [];
+    children.forEach(child => {
+        count += countComponentsInHierarchy(child, includeEmpty);
+    });
+    return count;
+}
+exports.countComponentsInHierarchy = countComponentsInHierarchy;

package/dist/runtime/component-wrapper.d.ts

@@ -0,0 +1,18 @@
+import { ComponentProps, ComponentLifecycle } from '../types';
+export interface WrapperOptions {
+    displayName?: string;
+    enableProfiling?: boolean;
+    logProps?: boolean;
+    lifecycle?: ComponentLifecycle;
+    defaultProps?: Partial<ComponentProps>;
+}
+export declare function wrapComponent(React: any, Component: any, options?: WrapperOptions): any;
+export declare function memoizeComponent(React: any, Component: any, propsAreEqual?: (prevProps: any, nextProps: any) => boolean): any;
+export declare function lazyComponent(React: any, loader: () => Promise<{
+    default: any;
+}>, fallback?: any): any;
+export declare function injectProps(React: any, Component: any, injectedProps: any): any;
+export declare function conditionalComponent(React: any, Component: any, condition: boolean | ((props: any) => boolean), fallback?: any): any;
+export declare function withErrorHandler(React: any, Component: any, errorHandler: (error: Error) => void): any;
+export declare function portalComponent(React: any, ReactDOM: any, Component: any, container: Element | string): any;
+//# sourceMappingURL=component-wrapper.d.ts.map

package/dist/runtime/component-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-wrapper.d.ts","sourceRoot":"","sources":["../../src/runtime/component-wrapper.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAK9D,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAE/B,YAAY,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CACxC;AASD,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,GAAE,cAAmB,GAAG,GAAG,CA+E3F;AASD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,GAAG,EACV,SAAS,EAAE,GAAG,EACd,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,OAAO,GAC1D,GAAG,CAEL;AASD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,MAAM,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,EACvC,QAAQ,CAAC,EAAE,GAAG,GACb,GAAG,CAYL;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,GAAG,GAAG,CAK/E;AAUD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,GAAG,EACV,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,EAC9C,QAAQ,CAAC,EAAE,GAAG,GACb,GAAG,CAUL;AASD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,GAAG,EACV,SAAS,EAAE,GAAG,EACd,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GACnC,GAAG,CAUL;AAUD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,GAAG,EACV,QAAQ,EAAE,GAAG,EACb,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,OAAO,GAAG,MAAM,GAC1B,GAAG,CAqBL"}

package/dist/runtime/component-wrapper.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalComponent = exports.withErrorHandler = exports.conditionalComponent = exports.injectProps = exports.lazyComponent = exports.memoizeComponent = exports.wrapComponent = void 0;
+function wrapComponent(React, Component, options = {}) {
+    const { displayName, enableProfiling = false, logProps = false, lifecycle = {}, defaultProps = {} } = options;
+    const WrappedComponent = React.forwardRef((props, ref) => {
+        const mergedProps = { ...defaultProps, ...props };
+        React.useEffect(() => {
+            if (logProps) {
+                console.log(`[${displayName || Component.name}] Props:`, mergedProps);
+            }
+        }, [mergedProps]);
+        React.useEffect(() => {
+            if (lifecycle.beforeMount) {
+                lifecycle.beforeMount();
+            }
+            if (lifecycle.afterMount) {
+                lifecycle.afterMount();
+            }
+            return () => {
+                if (lifecycle.beforeUnmount) {
+                    lifecycle.beforeUnmount();
+                }
+            };
+        }, []);
+        const prevPropsRef = React.useRef(mergedProps);
+        React.useEffect(() => {
+            const prevProps = prevPropsRef.current;
+            if (lifecycle.beforeUpdate) {
+                lifecycle.beforeUpdate(prevProps, mergedProps);
+            }
+            if (lifecycle.afterUpdate) {
+                Promise.resolve().then(() => {
+                    lifecycle.afterUpdate(prevProps, mergedProps);
+                });
+            }
+            prevPropsRef.current = mergedProps;
+        });
+        if (enableProfiling && React.Profiler) {
+            return React.createElement(React.Profiler, {
+                id: displayName || Component.name || 'WrappedComponent',
+                onRender: (id, phase, actualDuration) => {
+                    console.log(`[Profiler] ${id} (${phase}): ${actualDuration.toFixed(2)}ms`);
+                }
+            }, React.createElement(Component, { ...mergedProps, ref }));
+        }
+        return React.createElement(Component, { ...mergedProps, ref });
+    });
+    WrappedComponent.displayName = displayName || `Wrapped(${Component.displayName || Component.name || 'Component'})`;
+    return WrappedComponent;
+}
+exports.wrapComponent = wrapComponent;
+function memoizeComponent(React, Component, propsAreEqual) {
+    return React.memo(Component, propsAreEqual);
+}
+exports.memoizeComponent = memoizeComponent;
+function lazyComponent(React, loader, fallback) {
+    const LazyComponent = React.lazy(loader);
+    if (fallback) {
+        return (props) => React.createElement(React.Suspense, { fallback }, React.createElement(LazyComponent, props));
+    }
+    return LazyComponent;
+}
+exports.lazyComponent = lazyComponent;
+function injectProps(React, Component, injectedProps) {
+    return React.forwardRef((props, ref) => {
+        const mergedProps = { ...injectedProps, ...props };
+        return React.createElement(Component, { ...mergedProps, ref });
+    });
+}
+exports.injectProps = injectProps;
+function conditionalComponent(React, Component, condition, fallback) {
+    return (props) => {
+        const shouldRender = typeof condition === 'function' ? condition(props) : condition;
+        if (shouldRender) {
+            return React.createElement(Component, props);
+        }
+        return fallback || null;
+    };
+}
+exports.conditionalComponent = conditionalComponent;
+function withErrorHandler(React, Component, errorHandler) {
+    return class extends React.Component {
+        componentDidCatch(error, errorInfo) {
+            errorHandler(error);
+        }
+        render() {
+            return React.createElement(Component, this.props);
+        }
+    };
+}
+exports.withErrorHandler = withErrorHandler;
+function portalComponent(React, ReactDOM, Component, container) {
+    return (props) => {
+        const [mountNode, setMountNode] = React.useState(null);
+        React.useEffect(() => {
+            const node = typeof container === 'string'
+                ? document.querySelector(container)
+                : container;
+            setMountNode(node);
+        }, []);
+        if (!mountNode || !ReactDOM.createPortal) {
+            return null;
+        }
+        return ReactDOM.createPortal(React.createElement(Component, props), mountNode);
+    };
+}
+exports.portalComponent = portalComponent;

package/dist/runtime/error-boundary.d.ts

@@ -0,0 +1,6 @@
+import { ErrorBoundaryOptions, ComponentError } from '../types';
+export declare function createErrorBoundary(React: any, options?: ErrorBoundaryOptions): any;
+export declare function withErrorBoundary(React: any, Component: any, options?: ErrorBoundaryOptions): any;
+export declare function formatComponentError(error: Error, componentName: string, phase: ComponentError['phase']): ComponentError;
+export declare function createErrorLogger(componentName: string): (error: Error, errorInfo: any) => void;
+//# sourceMappingURL=error-boundary.d.ts.map

package/dist/runtime/error-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-boundary.d.ts","sourceRoot":"","sources":["../../src/runtime/error-boundary.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAQhE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,GAAE,oBAAyB,GAAG,GAAG,CAyKvF;AASD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,GAAE,oBAAyB,GAAG,GAAG,CAUrG;AASD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAC7B,cAAc,CAWhB;AAOD,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,KAAK,IAAI,CAQ/F"}

package/dist/runtime/error-boundary.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorLogger = exports.formatComponentError = exports.withErrorBoundary = exports.createErrorBoundary = void 0;
+function createErrorBoundary(React, options = {}) {
+    const { onError, fallback, logErrors = true, recovery = 'none' } = options;
+    return class ErrorBoundary extends React.Component {
+        constructor(props) {
+            super(props);
+            this.handleRetry = () => {
+                this.setState((prevState) => ({
+                    hasError: false,
+                    error: null,
+                    errorInfo: null,
+                    retryCount: prevState.retryCount + 1
+                }));
+            };
+            this.handleReset = () => {
+                this.setState({
+                    hasError: false,
+                    error: null,
+                    errorInfo: null,
+                    retryCount: 0
+                });
+            };
+            this.state = {
+                hasError: false,
+                error: null,
+                errorInfo: null,
+                retryCount: 0
+            };
+        }
+        static getDerivedStateFromError(error) {
+            return { hasError: true, error };
+        }
+        componentDidCatch(error, errorInfo) {
+            if (logErrors) {
+                console.error('React Error Boundary caught error:', error);
+                console.error('Error Info:', errorInfo);
+            }
+            if (onError) {
+                try {
+                    onError(error, errorInfo);
+                }
+                catch (handlerError) {
+                    console.error('Error in custom error handler:', handlerError);
+                }
+            }
+            this.setState({ errorInfo });
+        }
+        render() {
+            if (this.state.hasError) {
+                if (fallback) {
+                    if (typeof fallback === 'function') {
+                        return fallback({
+                            error: this.state.error,
+                            errorInfo: this.state.errorInfo,
+                            retry: this.handleRetry,
+                            reset: this.handleReset,
+                            retryCount: this.state.retryCount
+                        });
+                    }
+                    return fallback;
+                }
+                const showRetry = recovery === 'retry' && this.state.retryCount < 3;
+                const showReset = recovery === 'reset';
+                return React.createElement('div', {
+                    style: {
+                        padding: '20px',
+                        backgroundColor: '#f8f8f8',
+                        border: '1px solid #ddd',
+                        borderRadius: '4px',
+                        margin: '10px'
+                    }
+                }, React.createElement('h2', { style: { color: '#d32f2f' } }, 'Component Error'), React.createElement('p', { style: { color: '#666' } }, 'An error occurred while rendering this component.'), this.state.error && React.createElement('details', { style: { marginTop: '10px' } }, React.createElement('summary', { style: { cursor: 'pointer', color: '#333' } }, 'Error Details'), React.createElement('pre', {
+                    style: {
+                        backgroundColor: '#f0f0f0',
+                        padding: '10px',
+                        marginTop: '10px',
+                        overflow: 'auto',
+                        fontSize: '12px'
+                    }
+                }, this.state.error.toString(), '\n\n', this.state.error.stack)), (showRetry || showReset) && React.createElement('div', { style: { marginTop: '10px' } }, showRetry && React.createElement('button', {
+                    onClick: this.handleRetry,
+                    style: {
+                        padding: '8px 16px',
+                        marginRight: '10px',
+                        backgroundColor: '#1976d2',
+                        color: 'white',
+                        border: 'none',
+                        borderRadius: '4px',
+                        cursor: 'pointer'
+                    }
+                }, `Retry (${3 - this.state.retryCount} attempts left)`), showReset && React.createElement('button', {
+                    onClick: this.handleReset,
+                    style: {
+                        padding: '8px 16px',
+                        backgroundColor: '#757575',
+                        color: 'white',
+                        border: 'none',
+                        borderRadius: '4px',
+                        cursor: 'pointer'
+                    }
+                }, 'Reset Component')));
+            }
+            return this.props.children;
+        }
+    };
+}
+exports.createErrorBoundary = createErrorBoundary;
+function withErrorBoundary(React, Component, options = {}) {
+    const ErrorBoundaryComponent = createErrorBoundary(React, options);
+    return (props) => {
+        return React.createElement(ErrorBoundaryComponent, null, React.createElement(Component, props));
+    };
+}
+exports.withErrorBoundary = withErrorBoundary;
+function formatComponentError(error, componentName, phase) {
+    return {
+        message: error.message || 'Unknown error',
+        stack: error.stack,
+        componentName,
+        phase,
+        details: {
+            name: error.name,
+            timestamp: new Date().toISOString()
+        }
+    };
+}
+exports.formatComponentError = formatComponentError;
+function createErrorLogger(componentName) {
+    return (error, errorInfo) => {
+        console.group(`🚨 React Component Error: ${componentName}`);
+        console.error('Error:', error);
+        console.error('Component Stack:', errorInfo.componentStack);
+        console.error('Props:', errorInfo.props);
+        console.groupEnd();
+    };
+}
+exports.createErrorLogger = createErrorLogger;

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { createErrorBoundary, withErrorBoundary, formatComponentError, createErrorLogger } from './error-boundary';
+export { wrapComponent, memoizeComponent, lazyComponent, injectProps, conditionalComponent, withErrorHandler, portalComponent, WrapperOptions } from './component-wrapper';
+export { buildComponentProps, normalizeCallbacks, normalizeStyles, validateComponentProps, mergeProps, createPropsTransformer, wrapCallbacksWithLogging, extractPropPaths, PropBuilderOptions } from './prop-builder';
+export { ComponentHierarchyRegistrar, registerComponentHierarchy, validateComponentSpec, flattenComponentHierarchy, countComponentsInHierarchy, HierarchyRegistrationResult, ComponentRegistrationError, HierarchyRegistrationOptions } from './component-hierarchy';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,UAAU,EACV,sBAAsB,EACtB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,EAC1B,qBAAqB,EACrB,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,uBAAuB,CAAC"}

package/dist/runtime/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countComponentsInHierarchy = exports.flattenComponentHierarchy = exports.validateComponentSpec = exports.registerComponentHierarchy = exports.ComponentHierarchyRegistrar = exports.extractPropPaths = exports.wrapCallbacksWithLogging = exports.createPropsTransformer = exports.mergeProps = exports.validateComponentProps = exports.normalizeStyles = exports.normalizeCallbacks = exports.buildComponentProps = exports.portalComponent = exports.withErrorHandler = exports.conditionalComponent = exports.injectProps = exports.lazyComponent = exports.memoizeComponent = exports.wrapComponent = exports.createErrorLogger = exports.formatComponentError = exports.withErrorBoundary = exports.createErrorBoundary = void 0;
+var error_boundary_1 = require("./error-boundary");
+Object.defineProperty(exports, "createErrorBoundary", { enumerable: true, get: function () { return error_boundary_1.createErrorBoundary; } });
+Object.defineProperty(exports, "withErrorBoundary", { enumerable: true, get: function () { return error_boundary_1.withErrorBoundary; } });
+Object.defineProperty(exports, "formatComponentError", { enumerable: true, get: function () { return error_boundary_1.formatComponentError; } });
+Object.defineProperty(exports, "createErrorLogger", { enumerable: true, get: function () { return error_boundary_1.createErrorLogger; } });
+var component_wrapper_1 = require("./component-wrapper");
+Object.defineProperty(exports, "wrapComponent", { enumerable: true, get: function () { return component_wrapper_1.wrapComponent; } });
+Object.defineProperty(exports, "memoizeComponent", { enumerable: true, get: function () { return component_wrapper_1.memoizeComponent; } });
+Object.defineProperty(exports, "lazyComponent", { enumerable: true, get: function () { return component_wrapper_1.lazyComponent; } });
+Object.defineProperty(exports, "injectProps", { enumerable: true, get: function () { return component_wrapper_1.injectProps; } });
+Object.defineProperty(exports, "conditionalComponent", { enumerable: true, get: function () { return component_wrapper_1.conditionalComponent; } });
+Object.defineProperty(exports, "withErrorHandler", { enumerable: true, get: function () { return component_wrapper_1.withErrorHandler; } });
+Object.defineProperty(exports, "portalComponent", { enumerable: true, get: function () { return component_wrapper_1.portalComponent; } });
+var prop_builder_1 = require("./prop-builder");
+Object.defineProperty(exports, "buildComponentProps", { enumerable: true, get: function () { return prop_builder_1.buildComponentProps; } });
+Object.defineProperty(exports, "normalizeCallbacks", { enumerable: true, get: function () { return prop_builder_1.normalizeCallbacks; } });
+Object.defineProperty(exports, "normalizeStyles", { enumerable: true, get: function () { return prop_builder_1.normalizeStyles; } });
+Object.defineProperty(exports, "validateComponentProps", { enumerable: true, get: function () { return prop_builder_1.validateComponentProps; } });
+Object.defineProperty(exports, "mergeProps", { enumerable: true, get: function () { return prop_builder_1.mergeProps; } });
+Object.defineProperty(exports, "createPropsTransformer", { enumerable: true, get: function () { return prop_builder_1.createPropsTransformer; } });
+Object.defineProperty(exports, "wrapCallbacksWithLogging", { enumerable: true, get: function () { return prop_builder_1.wrapCallbacksWithLogging; } });
+Object.defineProperty(exports, "extractPropPaths", { enumerable: true, get: function () { return prop_builder_1.extractPropPaths; } });
+var component_hierarchy_1 = require("./component-hierarchy");
+Object.defineProperty(exports, "ComponentHierarchyRegistrar", { enumerable: true, get: function () { return component_hierarchy_1.ComponentHierarchyRegistrar; } });
+Object.defineProperty(exports, "registerComponentHierarchy", { enumerable: true, get: function () { return component_hierarchy_1.registerComponentHierarchy; } });
+Object.defineProperty(exports, "validateComponentSpec", { enumerable: true, get: function () { return component_hierarchy_1.validateComponentSpec; } });
+Object.defineProperty(exports, "flattenComponentHierarchy", { enumerable: true, get: function () { return component_hierarchy_1.flattenComponentHierarchy; } });
+Object.defineProperty(exports, "countComponentsInHierarchy", { enumerable: true, get: function () { return component_hierarchy_1.countComponentsInHierarchy; } });

package/dist/runtime/prop-builder.d.ts

@@ -0,0 +1,16 @@
+import { ComponentProps, ComponentCallbacks, ComponentStyles } from '../types';
+export interface PropBuilderOptions {
+    validate?: boolean;
+    merge?: boolean;
+    transformData?: (data: any) => any;
+    transformState?: (state: any) => any;
+}
+export declare function buildComponentProps(data?: any, userState?: any, utilities?: any, callbacks?: ComponentCallbacks, components?: Record<string, any>, styles?: ComponentStyles, options?: PropBuilderOptions): ComponentProps;
+export declare function normalizeCallbacks(callbacks: any): ComponentCallbacks;
+export declare function normalizeStyles(styles?: any): any;
+export declare function validateComponentProps(props: ComponentProps): void;
+export declare function mergeProps(...propsList: Partial<ComponentProps>[]): ComponentProps;
+export declare function createPropsTransformer(transformations: Record<string, (value: any) => any>): (props: ComponentProps) => ComponentProps;
+export declare function wrapCallbacksWithLogging(callbacks: ComponentCallbacks, componentName: string): ComponentCallbacks;
+export declare function extractPropPaths(componentCode: string): string[];
+//# sourceMappingURL=prop-builder.d.ts.map

package/dist/runtime/prop-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-builder.d.ts","sourceRoot":"","sources":["../../src/runtime/prop-builder.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK/E,MAAM,WAAW,kBAAkB;IAEjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;IAEnC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;CACtC;AAaD,wBAAgB,mBAAmB,CACjC,IAAI,GAAE,GAAQ,EACd,SAAS,GAAE,GAAQ,EACnB,SAAS,GAAE,GAAQ,EACnB,SAAS,GAAE,kBAAuB,EAClC,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACpC,MAAM,CAAC,EAAE,eAAe,EACxB,OAAO,GAAE,kBAAuB,GAC/B,cAAc,CA2BhB;AAOD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,GAAG,GAAG,kBAAkB,CAqBrE;AAOD,wBAAgB,eAAe,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,CAKjD;AAOD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CA2BlE;AAOD,wBAAgB,UAAU,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,cAAc,CAAC,EAAE,GAAG,cAAc,CAqClF;AAOD,wBAAgB,sBAAsB,CACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,GACnD,CAAC,KAAK,EAAE,cAAc,KAAK,cAAc,CAyB3C;AAQD,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,kBAAkB,EAC7B,aAAa,EAAE,MAAM,GACpB,kBAAkB,CAgCpB;AAOD,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,CAmBhE"}