@wizecorp/stratusjs/dist/services/ServiceContext.js

Stratus React Framework

import { jsx as _jsx } from "react/jsx-runtime";
import { createContext, useContext, useEffect, useState } from 'react';
import { ServiceContainer } from './ServiceContainer';
// Service context
const ServiceContext = createContext(null);
/**
 * Service provider component
 */
export const ServiceProvider = ({ children, container: providedContainer, services = [] }) => {
    const [container] = useState(() => providedContainer || new ServiceContainer());
    const [initialized, setInitialized] = useState(false);
    // Register services on mount
    useEffect(() => {
        const initializeServices = async () => {
            // Register provided services
            for (const { token, service, options } of services) {
                if (service) {
                    container.register(token, service, options);
                }
            }
            setInitialized(true);
        };
        initializeServices();
        // Cleanup on unmount
        return () => {
            container.clear();
        };
    }, [container, services]);
    if (!initialized) {
        return _jsx("div", { children: "Initializing services..." });
    }
    const contextValue = {
        container
    };
    return (_jsx(ServiceContext.Provider, { value: contextValue, children: children }));
};
/**
 * Hook to get the service container
 */
export const useServiceContainer = () => {
    const context = useContext(ServiceContext);
    if (!context) {
        throw new Error('useServiceContainer must be used within a ServiceProvider');
    }
    return context.container;
};
/**
 * Hook to get a specific service
 */
export const useService = (token) => {
    const container = useServiceContainer();
    const [service, setService] = useState(null);
    const [error, setError] = useState(null);
    useEffect(() => {
        const loadService = async () => {
            try {
                const serviceInstance = await container.getAsync(token);
                setService(serviceInstance);
                setError(null);
            }
            catch (err) {
                setError(err instanceof Error ? err : new Error('Failed to load service'));
                setService(null);
            }
        };
        loadService();
    }, [container, token]);
    if (error) {
        throw error;
    }
    if (!service) {
        throw new Error(`Service "${String(token)}" is still loading`);
    }
    return service;
};
/**
 * Hook for optional service (doesn't throw if not found)
 */
export const useOptionalService = (token) => {
    const container = useServiceContainer();
    const [service, setService] = useState(null);
    useEffect(() => {
        const loadService = async () => {
            try {
                if (container.has(token)) {
                    const serviceInstance = await container.getAsync(token);
                    setService(serviceInstance);
                }
            }
            catch {
                // Ignore errors for optional services
                setService(null);
            }
        };
        loadService();
    }, [container, token]);
    return service;
};
//# sourceMappingURL=ServiceContext.js.map