dynim-react 1.0.7 → 1.0.9

package/dist/builder/EditableZone.js

@@ -1,83 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { forwardRef } from 'react';
-import { VISIBILITY_ATTR } from 'dynim-core';
-/**
- * LockedZone - Wraps content to prevent builder customization
- *
- * Elements inside a LockedZone cannot be:
- * - Dragged/moved by the builder
- * - Used as drop targets
- *
- * Use this to protect parts of your UI that should not be editable,
- * like navigation, footers, or critical UI elements.
- *
- * @example
- * ```tsx
- * <LockedZone>
- *   <Navigation />  {/* Cannot be moved or modified *\/}
- * </LockedZone>
- *
- * <div>
- *   {/* This content is editable *\/}
- * </div>
- * ```
- *
- * @example Nested zones
- * ```tsx
- * <LockedZone>
- *   <Sidebar>
- *     <Logo />  {/* Locked *\/}
- *     <EditableZone>
- *       <CustomWidgets />  {/* Editable "island" inside locked zone *\/}
- *     </EditableZone>
- *   </Sidebar>
- * </LockedZone>
- * ```
- */
-export const LockedZone = forwardRef(function LockedZone({ children, as: Component = 'div', ...props }, ref) {
-    const zoneProps = {
-        ...props,
-        [VISIBILITY_ATTR]: 'false',
-        ref,
-    };
-    // Use createElement to support dynamic tag
-    const Element = Component;
-    return _jsx(Element, { ...zoneProps, children: children });
-});
-/**
- * EditableZone - Explicitly marks content as editable in the builder
- *
- * Use this to:
- * - Create editable "islands" inside a LockedZone
- * - Explicitly mark content as editable (though content is editable by default)
- *
- * @example Create editable area inside locked zone
- * ```tsx
- * <LockedZone>
- *   <Header>
- *     <Logo />  {/* Locked *\/}
- *     <EditableZone>
- *       <UserMenu />  {/* Editable despite being inside LockedZone *\/}
- *     </EditableZone>
- *   </Header>
- * </LockedZone>
- * ```
- */
-export const EditableZone = forwardRef(function EditableZone({ children, as: Component = 'div', ...props }, ref) {
-    const zoneProps = {
-        ...props,
-        [VISIBILITY_ATTR]: 'true',
-        ref,
-    };
-    // Use createElement to support dynamic tag
-    const Element = Component;
-    return _jsx(Element, { ...zoneProps, children: children });
-});
-/**
- * Alias for LockedZone - more explicit naming
- */
-export const NonCustomizable = LockedZone;
-/**
- * Alias for EditableZone - more explicit naming
- */
-export const Customizable = EditableZone;

package/dist/inference/DynimProvider.d.ts

@@ -1,23 +0,0 @@
-import type { DynimProviderProps } from './types';
-/**
- * DynimProvider - A React component that dynamically loads tenant-specific bundles.
- *
- * This provider handles the lifecycle of loading, rendering, and cleaning up
- * tenant customization bundles. It supports optional pre-checks to determine
- * if a tenant has customizations before attempting to load them.
- *
- * @example
- * ```tsx
- * <DynimProvider
- *   tenantId={user?.tenantId}
- *   bundleUrl={(id) => `https://cdn.example.com/bundles/${id}.js`}
- *   loadingComponent={<Spinner />}
- *   errorBanner={true}
- * >
- *   <YourBaseApp />
- * </DynimProvider>
- * ```
- */
-export declare function DynimProvider({ tenantId, bundleUrl, checkCustomizations, loadingComponent, errorBanner, onError, onLoad, children, }: DynimProviderProps): JSX.Element;
-export default DynimProvider;
-//# sourceMappingURL=DynimProvider.d.ts.map

package/dist/inference/DynimProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DynimProvider.d.ts","sourceRoot":"","sources":["../../src/inference/DynimProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,SAAS,CAAC;AA8E9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,SAAS,EACT,mBAAmB,EACnB,gBAAgB,EAChB,WAAmB,EACnB,OAAO,EACP,MAAM,EACN,QAAQ,GACT,EAAE,kBAAkB,GAAG,GAAG,CAAC,OAAO,CAuLlC;AAED,eAAe,aAAa,CAAC"}

package/dist/inference/DynimProvider.js

@@ -1,231 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState, useEffect, useCallback, useRef } from 'react';
-/**
- * Default loading component shown while bundle is loading
- */
-function DefaultLoadingComponent() {
-    return (_jsx("div", { style: {
-            display: 'flex',
-            justifyContent: 'center',
-            alignItems: 'center',
-            padding: '20px',
-        }, children: _jsx("span", { children: "Loading customizations..." }) }));
-}
-/**
- * Default error banner component
- */
-function DefaultErrorBanner({ error }) {
-    return (_jsxs("div", { style: {
-            background: '#fee2e2',
-            border: '1px solid #ef4444',
-            borderRadius: '4px',
-            padding: '12px 16px',
-            marginBottom: '16px',
-            color: '#991b1b',
-        }, children: [_jsx("strong", { children: "Customization Error:" }), " ", error.message] }));
-}
-/**
- * Container for rendering tenant bundle content
- */
-function BundleContainer() {
-    return _jsx("div", { id: "dynim-root" });
-}
-/**
- * Loads a script from a URL and returns a promise that resolves when loaded
- */
-function loadScript(url) {
-    return new Promise((resolve, reject) => {
-        // Check if script already exists
-        const existingScript = document.querySelector(`script[src="${url}"]`);
-        if (existingScript) {
-            resolve();
-            return;
-        }
-        const script = document.createElement('script');
-        script.src = url;
-        script.async = true;
-        script.onload = () => resolve();
-        script.onerror = () => reject(new Error(`Failed to load bundle from ${url}`));
-        document.head.appendChild(script);
-    });
-}
-/**
- * Removes a previously loaded script
- */
-function removeScript(url) {
-    const script = document.querySelector(`script[src="${url}"]`);
-    if (script) {
-        script.remove();
-    }
-}
-/**
- * DynimProvider - A React component that dynamically loads tenant-specific bundles.
- *
- * This provider handles the lifecycle of loading, rendering, and cleaning up
- * tenant customization bundles. It supports optional pre-checks to determine
- * if a tenant has customizations before attempting to load them.
- *
- * @example
- * ```tsx
- * <DynimProvider
- *   tenantId={user?.tenantId}
- *   bundleUrl={(id) => `https://cdn.example.com/bundles/${id}.js`}
- *   loadingComponent={<Spinner />}
- *   errorBanner={true}
- * >
- *   <YourBaseApp />
- * </DynimProvider>
- * ```
- */
-export function DynimProvider({ tenantId, bundleUrl, checkCustomizations, loadingComponent, errorBanner = false, onError, onLoad, children, }) {
-    const [state, setState] = useState({
-        status: 'idle',
-        error: null,
-        currentTenantId: null,
-    });
-    const loadedUrlRef = useRef(null);
-    /**
-     * Resolves the bundle URL for a given tenant ID
-     */
-    const resolveBundleUrl = useCallback((id) => {
-        if (typeof bundleUrl === 'function') {
-            return bundleUrl(id);
-        }
-        // If bundleUrl is a string template, replace {tenantId} placeholder
-        return bundleUrl.replace('{tenantId}', id);
-    }, [bundleUrl]);
-    /**
-     * Cleans up previously loaded bundle
-     */
-    const cleanup = useCallback(() => {
-        if (loadedUrlRef.current) {
-            removeScript(loadedUrlRef.current);
-            loadedUrlRef.current = null;
-        }
-        // Clear the bundle render target
-        const root = document.getElementById('dynim-root');
-        if (root) {
-            root.innerHTML = '';
-        }
-    }, []);
-    /**
-     * Main effect to handle tenant bundle loading
-     */
-    useEffect(() => {
-        // No tenant - reset to idle and show children
-        if (!tenantId) {
-            cleanup();
-            setState({
-                status: 'idle',
-                error: null,
-                currentTenantId: null,
-            });
-            return;
-        }
-        // Same tenant already loaded - do nothing
-        if (state.currentTenantId === tenantId && state.status === 'loaded') {
-            return;
-        }
-        let cancelled = false;
-        async function loadBundle() {
-            try {
-                // Step 1: Check if tenant has customizations (if check function provided)
-                if (checkCustomizations) {
-                    setState((prev) => ({ ...prev, status: 'checking' }));
-                    const hasCustomizations = await checkCustomizations(tenantId);
-                    if (cancelled)
-                        return;
-                    if (!hasCustomizations) {
-                        cleanup();
-                        setState({
-                            status: 'no-customization',
-                            error: null,
-                            currentTenantId: tenantId,
-                        });
-                        return;
-                    }
-                }
-                // Step 2: Load the bundle
-                setState((prev) => ({ ...prev, status: 'loading' }));
-                // Clean up previous bundle
-                cleanup();
-                const url = resolveBundleUrl(tenantId);
-                await loadScript(url);
-                if (cancelled) {
-                    removeScript(url);
-                    return;
-                }
-                loadedUrlRef.current = url;
-                setState({
-                    status: 'loaded',
-                    error: null,
-                    currentTenantId: tenantId,
-                });
-                onLoad?.(tenantId);
-            }
-            catch (err) {
-                if (cancelled)
-                    return;
-                const error = err instanceof Error ? err : new Error(String(err));
-                setState({
-                    status: 'error',
-                    error,
-                    currentTenantId: tenantId,
-                });
-                onError?.(error, tenantId);
-            }
-        }
-        loadBundle();
-        return () => {
-            cancelled = true;
-        };
-    }, [
-        tenantId,
-        checkCustomizations,
-        resolveBundleUrl,
-        cleanup,
-        onError,
-        onLoad,
-        state.currentTenantId,
-        state.status,
-    ]);
-    /**
-     * Cleanup on unmount
-     */
-    useEffect(() => {
-        return () => {
-            cleanup();
-        };
-    }, [cleanup]);
-    // Render error banner if enabled and there's an error
-    const renderErrorBanner = () => {
-        if (!errorBanner || state.status !== 'error' || !state.error) {
-            return null;
-        }
-        if (errorBanner === true) {
-            return _jsx(DefaultErrorBanner, { error: state.error });
-        }
-        return errorBanner;
-    };
-    // Determine what to render based on state
-    const renderContent = () => {
-        switch (state.status) {
-            case 'checking':
-            case 'loading':
-                return loadingComponent ?? _jsx(DefaultLoadingComponent, {});
-            case 'loaded':
-                // Bundle is loaded and will render itself into #dynim-root
-                return _jsx(BundleContainer, {});
-            case 'error':
-                // Show children as fallback with optional error banner
-                return (_jsxs(_Fragment, { children: [renderErrorBanner(), children] }));
-            case 'no-customization':
-            case 'idle':
-            default:
-                // No customizations or no tenant - render base app
-                return children;
-        }
-    };
-    return _jsx(_Fragment, { children: renderContent() });
-}
-export default DynimProvider;

package/dist/inference/createDynimSDK.d.ts

@@ -1,39 +0,0 @@
-import type { DynimSDKConfig, DynimGlobal } from './types';
-/**
- * Creates and registers the Dynim SDK on the window object.
- * This makes React, ReactDOM, hooks, and contexts available to tenant bundles.
- *
- * @param config - Configuration object containing React, ReactDOM, hooks, and contexts
- * @returns The created SDK object
- *
- * @example
- * ```tsx
- * import { createDynimSDK } from 'dynim-react';
- * import React from 'react';
- * import ReactDOM from 'react-dom';
- * import { useAuth, useNotifications } from './hooks';
- * import { AuthContext, NotificationContext } from './contexts';
- *
- * createDynimSDK({
- *   React,
- *   ReactDOM,
- *   hooks: { useAuth, useNotifications },
- *   contexts: { AuthContext, NotificationContext }
- * });
- * ```
- */
-export declare function createDynimSDK(config: DynimSDKConfig): DynimGlobal;
-/**
- * Gets the current Dynim SDK instance from the window object.
- * Useful for tenant bundles to access the SDK.
- *
- * @returns The SDK instance or undefined if not initialized
- */
-export declare function getDynimSDK(): DynimGlobal | undefined;
-/**
- * Checks if the Dynim SDK has been initialized.
- *
- * @returns true if the SDK is available
- */
-export declare function isDynimSDKReady(): boolean;
-//# sourceMappingURL=createDynimSDK.d.ts.map

package/dist/inference/createDynimSDK.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createDynimSDK.d.ts","sourceRoot":"","sources":["../../src/inference/createDynimSDK.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAqBlE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,WAAW,GAAG,SAAS,CAKrD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC"}

package/dist/inference/createDynimSDK.js

@@ -1,61 +0,0 @@
-/**
- * Creates and registers the Dynim SDK on the window object.
- * This makes React, ReactDOM, hooks, and contexts available to tenant bundles.
- *
- * @param config - Configuration object containing React, ReactDOM, hooks, and contexts
- * @returns The created SDK object
- *
- * @example
- * ```tsx
- * import { createDynimSDK } from 'dynim-react';
- * import React from 'react';
- * import ReactDOM from 'react-dom';
- * import { useAuth, useNotifications } from './hooks';
- * import { AuthContext, NotificationContext } from './contexts';
- *
- * createDynimSDK({
- *   React,
- *   ReactDOM,
- *   hooks: { useAuth, useNotifications },
- *   contexts: { AuthContext, NotificationContext }
- * });
- * ```
- */
-export function createDynimSDK(config) {
-    const { React, ReactDOM, hooks = {}, contexts = {}, globals = {} } = config;
-    const sdk = {
-        React,
-        ReactDOM,
-        hooks,
-        contexts,
-        ...globals,
-    };
-    // Register on window for tenant bundles to access
-    if (typeof window !== 'undefined') {
-        window.__DYNIM__ = sdk;
-        // Also expose React and ReactDOM directly on window for bundles using standard imports
-        window.React = React;
-        window.ReactDOM = ReactDOM;
-    }
-    return sdk;
-}
-/**
- * Gets the current Dynim SDK instance from the window object.
- * Useful for tenant bundles to access the SDK.
- *
- * @returns The SDK instance or undefined if not initialized
- */
-export function getDynimSDK() {
-    if (typeof window !== 'undefined') {
-        return window.__DYNIM__;
-    }
-    return undefined;
-}
-/**
- * Checks if the Dynim SDK has been initialized.
- *
- * @returns true if the SDK is available
- */
-export function isDynimSDKReady() {
-    return typeof window !== 'undefined' && window.__DYNIM__ !== undefined;
-}