@blac/react 0.0.3 → 0.0.4-0

package/dist/blac-react.d.ts

@@ -1,7 +1,10 @@
-import { Blac, BlocBase, ValueType, BlocClass } from 'blac';
+import { Blac, BlocBase, BlocClass, ValueType } from 'blac';
 import React, { FC, ReactNode } from 'react';
 
-declare const BlacContext: React.Context<Blac<any, any> | null>;
+declare const BlacApp: FC<{
+    children: JSX.Element;
+    blac: Blac<any, any>;
+}>;
 
 /**
  * Keep track of the hierarchy of Blac BlocProvider components, so that
@@ -13,6 +16,42 @@ interface ProviderItem {
     parent?: string;
     bloc: BlocBase<any>;
 }
+declare class BlacReact {
+    blac: Blac<any, any>;
+    blacContext: React.Context<Blac<any, any>>;
+    localContextProvider: React.Context<BlocBase<any> | null>;
+    static pluginKey: string;
+    constructor(blac: Blac<any, any>, blacContext: React.Context<Blac<any, any>>);
+    static getInstance(): BlacReact;
+    setup(): void;
+    /**
+     * React hook to get the bloc instance from the nearest BlocProvider
+     */
+    useLocalBlocContext(): BlocBase<any> | null;
+    private _contextLocalProviderKey;
+    get LocalProvider(): React.Provider<string>;
+    /**
+     * React hook to get the id from the nearest BlocProvider
+     */
+    useLocalProviderKey(): string;
+    addLocalBloc: (item: ProviderItem) => void;
+    removeLocalBloc: (id: string) => void;
+    createProviderId: () => string;
+    providerList: ProviderItem[];
+    getLocalBlocForProvider<B>(id: string, blocClass: BlocClass<B>): BlocBase<B> | undefined;
+    providerMounted(options: {
+        providerId: string;
+        localProviderKey?: string;
+    } & Parameters<BlacReact['useLocalProvider']>[0]): {
+        instance: BlocBase<any> | undefined;
+        destroyOnUnmount: boolean;
+    };
+    providerUnmounted(providerId: string | undefined): void;
+    readonly useLocalProvider: (options: {
+        bloc: BlocBase<any> | (() => BlocBase<any>);
+        debug?: boolean;
+    }) => string | undefined;
+}
 
 declare const BlocProvider: FC<{
     children?: ReactNode;
@@ -25,6 +64,7 @@ interface ExternalStore<B extends BlocBase<any>> {
     getSnapshot: () => ValueType<B>;
     getServerSnapshot?: () => ValueType<B>;
 }
+declare const externalBlocStore: <B extends BlocBase<any>>(bloc: B) => ExternalStore<B>;
 
 type BlocHookData<B extends BlocBase<S>, S> = [
     value: ValueType<B>,
@@ -39,4 +79,4 @@ interface BlocHookOptions {
 }
 declare const useBloc: <B extends BlocBase<S>, S>(bloc: BlocClass<B> | (() => B), options?: BlocHookOptions) => BlocHookData<B, S>;
 
-export { BlacContext, BlocHookData, BlocHookOptions, BlocProvider, ExternalStore, ProviderItem, useBloc };
+export { BlacApp, BlacReact, BlocProvider, ExternalStore, externalBlocStore, useBloc };

package/dist/blac-react.esm.js

@@ -133,7 +133,15 @@ class BlacReact {
     };
 }
 
-const BlacContext = createContext(null);
+const BlacContext = createContext(null);
+const BlacApp = (props) => {
+    const { children, blac } = props;
+    const blacApp = useMemo(() => new BlacReact(blac, BlacContext), [blac]);
+    if (!blacApp) {
+        throw new Error('BlacReact failed to initialize');
+    }
+    return React.createElement(BlacContext.Provider, { value: blac }, children);
+};
 
 const BlocProvider = ({ children, bloc, debug }) => {
     const blacReact = BlacReact.getInstance();
@@ -201,5 +209,5 @@ const useBloc = (bloc, options = {}) => {
     return [state, resolvedBloc];
 };
 
-export { BlacContext, BlocProvider, useBloc };
+export { BlacApp, BlacReact, BlocProvider, externalBlocStore, useBloc };
 //# sourceMappingURL=blac-react.esm.js.map

package/dist/blac-react.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"blac-react.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"blac-react.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/blac-react.js

@@ -135,7 +135,15 @@ class BlacReact {
     };
 }
 
-const BlacContext = React.createContext(null);
+const BlacContext = React.createContext(null);
+const BlacApp = (props) => {
+    const { children, blac } = props;
+    const blacApp = React.useMemo(() => new BlacReact(blac, BlacContext), [blac]);
+    if (!blacApp) {
+        throw new Error('BlacReact failed to initialize');
+    }
+    return React.createElement(BlacContext.Provider, { value: blac }, children);
+};
 
 const BlocProvider = ({ children, bloc, debug }) => {
     const blacReact = BlacReact.getInstance();
@@ -203,7 +211,9 @@ const useBloc = (bloc, options = {}) => {
     return [state, resolvedBloc];
 };
 
-exports.BlacContext = BlacContext;
+exports.BlacApp = BlacApp;
+exports.BlacReact = BlacReact;
 exports.BlocProvider = BlocProvider;
+exports.externalBlocStore = externalBlocStore;
 exports.useBloc = useBloc;
 //# sourceMappingURL=blac-react.js.map

package/dist/blac-react.js.map

@@ -1 +1 @@
-{"version":3,"file":"blac-react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"blac-react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blac/react",
-  "version": "0.0.3",
+  "version": "0.0.4-0",
   "license": "MIT",
   "main": "dist/blac-react.js",
   "module": "dist/blac-react.esm.js",