@adimm/x-injection-reactjs 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -1,18 +1,16 @@
-import { ProviderModuleOptions, IProviderModule, IProviderModuleNaked, ProviderToken, ProviderModuleGetManyParam, ProviderModuleGetManySignature, ProviderModule } from '@adimm/x-injection';
 import * as react from 'react';
+import react__default from 'react';
+import { IProviderModule, IProviderModuleNaked, ProviderToken, ProviderModuleGetManyParam, ProviderModuleGetManySignature, ProviderModule, ProviderModuleOptions, CloneParams } from '@adimm/x-injection';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 interface IComponentProviderModuleNaked extends IComponentProviderModule {
     /** Indicates if this module has been initialized by a React Component or not. */
     _initializedFromComponent: boolean;
-    /** The {@link ProviderModuleOptions | options} with which the module has been originally initialized. */
-    _initialOptions: ProviderModuleOptions;
     /**
-     * Instantiate a new {@link IComponentProviderModule} which will be supplied to the React Component.
-     *
-     * All the `providers` will be injected into a `singleton` scope.
+     * It is used internally by the `ProviderModule` to create a new cloned
+     * module which will be consumed only by that specific component instance.
      */
-    _convertToContextualizedComponentInstance(): IComponentProviderModule;
+    _createContextualizedComponentInstance(): IComponentProviderModule;
 }
 
 interface IComponentProviderModule extends IProviderModule {
@@ -30,217 +28,140 @@ interface IComponentProviderModule extends IProviderModule {
     dispose(): void;
 }
 
-interface UseInjectSharedOptions {
-}
+type PropsWithModule<P extends Record<string, any>> = P & {
+    /**
+     * The {@link IComponentProviderModule | Module} which this component should consume.
+     *
+     * **Note:** _You can easily override this in your unit tests to provide a module having mocked providers_
+     * _without the need to create a new mocked component by using the composable `ProvideModule` method._
+     */
+    module?: IComponentProviderModule;
+};
+
+declare const REACT_X_INJECTION_PROVIDER_MODULE_CONTEXT: react.Context<IComponentProviderModule>;
 
 /**
- * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.
+ * Low-level hook which can be used to resolve a single dependency from the current
+ * context module.
  *
- * **Note:** _By using this hook, the dependency will be injected on each re-render process._
- * _If you need to inject the dependency only once, you must use the `useInject` hook._
- * _It basically acts like a `Transient` scope, ensuring that a new dependency is injected on each re-render._
+ * **Note:** _In order to better modularize your code-base, you should strive to create custom hooks by using the_
+ * _`hookFactory` method to compose a custom hook._
  *
  * @param provider The {@link ProviderToken}.
- * @param options See {@link UseInjectSharedOptions}.
- * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.
+ * @param options See {@link UseInjectOptions}.
+ * @returns The resolved {@link T | dependency}.
  */
-declare function useInjectOnRender<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T;
-type UseInjectOptions = UseInjectSharedOptions & {
+declare function useInject<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T;
+type UseInjectOptions = {
     /** When set to `false` _(default)_ an exception will be thrown when the `providerOrIdentifier` isn't bound. */
     isOptional?: boolean;
 };
 
 /**
- * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.
+ * Low-level hook which can be used to resolve multiple dependencies at once from the current
+ * context module.
  *
- * **Note:** _By using this hook, the dependency will be injected only once after the first component mount process._
- * _If you need to re-inject the dependency on each re-render, you must use the `useInjectOnRender` hook._
- * _It basically acts like a `Request` scope, ensuring that even a `Transient` dependency does not mutate during re-renders._
+ * **Note:** _In order to better modularize your code-base, you should strive to create custom hooks by using the_
+ * _`hookFactory` method to compose a custom hook._
  *
- * @param provider The {@link ProviderToken}.
- * @param options See {@link UseInjectSharedOptions}.
- * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.
- */
-declare function useInject<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T;
-
-/**
- * Can be used to retrieve many resolved `dependencies` from the module container at once.
- *
- * **Note:** _By using this hook, the dependencies will be injected only once after the first component mount process._
- * _If you need to re-inject the dependencies on each re-render, you must use the `useInjectManyOnRender` hook._
- *
- * @param options See {@link UseInjectSharedOptions}.
  * @param deps Either one or more {@link ProviderToken}.
  * @returns Tuple containing the {@link D | dependencies}.
  */
-declare function useInjectMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>({ deps, options, }: {
-    deps: [...(D | unknown[])];
-    options?: UseInjectSharedOptions;
-}): ProviderModuleGetManySignature<D>;
-
-/**
- * Can be used to retrieve many resolved `dependencies` from the module container at once.
- *
- * **Note:** _By using this hook, the dependencies will be injected on each re-render process._
- * _If you need to inject the dependencies only once, you must use the `useInjectMany` hook._
- *
- * @param options See {@link UseInjectSharedOptions}.
- * @param deps Either one or more {@link ProviderToken}.
- * @returns Tuple containing the {@link D | dependencies}.
- */
-declare function useInjectManyOnRender<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>({ deps, }: {
-    deps: [...(D | unknown[])];
-    options?: UseInjectSharedOptions;
-}): ProviderModuleGetManySignature<D>;
-
-declare function useExposeComponentModuleContext(): void;
-
-/**
- * This is an **experimental** hook which can be used to make sure that a component will re-render when a children
- * exposes its internal context module.
- *
- * It works best with the `useInjectOnRender` hook, as it'll re-resolve all the required dependencies
- * of the injected ProviderToken.
- *
- * **Use it carefully as it may lead to unnecessary re-render cycles or it may even not work as expected!**
- * **It's safer to use the `TapIntoComponent` wrapper component with the `contextInstance` to manually inject the**
- * **contextualized dependencies of the children into a parent component service!**
- *
- * @experimental
- */
-declare function useRerenderOnChildrenModuleContextLoaded(): void;
-
-/**
- * The `React.Context` value to be provided to a `React.Provider`.
- *
- * Its default value is a reference to the {@link AppModule}.
- */
-declare const REACT_X_INJECTION_CONTEXT: react.Context<{
-    ctx: IComponentProviderModule;
-}>;
-declare const REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT: react.Context<Map<string, IComponentProviderModule>>;
-declare const REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE: react.Context<{
-    r: number;
-}>;
-
-interface ModuleProviderProps {
-    children?: React.ReactNode;
-    render?: () => React.ReactNode;
-    /** The {@link IComponentProviderModule | ComponentProviderModule} instance which must be accessible by this component. */
-    module: IComponentProviderModule;
-    /**
-     * Provide an object containing the initialization {@link ProviderModuleConstructor | options} so the {@link ModuleProviderProps.module | module}
-     * can be re-initialized when the component re-mounts _**(It'll happen only if it has been previously disposed!)**_.
-     *
-     * **Note:** _This is an advanced option and should be used only if you fully understand how the {@link ModuleProviderProps.module | module}_
-     * _initialization process works!_
-     * _For more details refer to the {@link https://adimarianmutu.github.io/x-injection/index.html | xInjection} offical docs._
-     */
-    tryReInitModuleOnMount?: ProviderModuleOptions;
-    /**
-     * When set to `true` it'll automatically dispose
-     * the provided {@link ModuleProviderProps.module | module} during the
-     * component `unmount` process.
-     *
-     * **Note:** _This is an advanced option and should be used only if you fully understand how the {@link ModuleProviderProps.module | module}_
-     * _dispose process works!_
-     * _For more details refer to the {@link https://adimarianmutu.github.io/x-injection/index.html | xInjection} offical docs._
-     *
-     * Defaults to `false`.
-     */
-    disposeModuleOnUnmount?: boolean;
-}
+declare function useInjectMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>(...deps: D | unknown[]): ProviderModuleGetManySignature<D>;
 
-declare function ModuleProvider({ children, render, module, tryReInitModuleOnMount, disposeModuleOnUnmount, }: ModuleProviderProps): react_jsx_runtime.JSX.Element;
+/** Can be used to retrieve the {@link IComponentProviderModule} from the current context. */
+declare function useComponentModule(): IComponentProviderModule;
 
 /** A superset of the {@link ProviderModule} used to integrate within a `React` component. */
 declare class ComponentProviderModule extends ProviderModule implements IComponentProviderModule {
     protected readonly _initializedFromComponent: IComponentProviderModuleNaked['_initializedFromComponent'];
-    protected readonly _initialOptions: IComponentProviderModuleNaked['_initialOptions'];
     constructor(options: ProviderModuleOptions);
     toNaked(): IComponentProviderModuleNaked & IProviderModuleNaked;
+    clone(options?: CloneParams): IComponentProviderModule;
     dispose(): void;
     /**
      * **Publicly visible when the instance is casted to {@link IComponentProviderModuleNaked}.**
      *
-     * See {@link IComponentProviderModuleNaked._convertToContextualizedComponentInstance}.
+     * See {@link IComponentProviderModuleNaked._createContextualizedComponentInstance}.
      */
-    protected _convertToContextualizedComponentInstance(): IComponentProviderModule;
+    protected _createContextualizedComponentInstance(): IComponentProviderModule;
 }
 
-interface TapIntoComponentContextProps {
-    children: React.ReactNode;
-    /**
-     * A callback can be provided to fully get access to the `ProviderModule` of the component instance,
-     * as long as the component is exposing it by using the `useExposeComponentModuleContext` hook.
-     *
-     * @param ctx A context map of modules.
-     *
-     * @example
-     * ```tsx
-     * function UserComponent(props: UserComponentProps) {
-     *   // This is required in order to correctly expose the ctx!
-     *   useExposeComponentModuleContext();
-     *
-     *   const [userProfileSettings, userSecuritySettings] = useInjectMany({ deps: [UserProfileSettings, UserSecuritySettings] });
-     *
-     *   return null;
-     * }
-     *
-     * function UserPage(props: UserPageProps) {
-     *   return (
-     *     <TapIntoComponent
-     *       contextInstance={(ctx)) => ({
-     *         tryGet: UserComponentModule,
-     *         thenDo: (ctx) => {
-     *           const services = ctx.getMany(...);
-     *         }
-     *       })}>
-     *       <UserComponent {...props.userComponentProps} />
-     *     </TapIntoComponent>
-     *   );
-     * }
-     * ```
-     *
-     * **Or without the fluid syntax:**
-     *
-     * ```tsx
-     * function UserPage(props: UserPageProps) {
-     *   return (
-     *     <TapIntoComponent
-     *       contextInstance={(ctxMap)) => {
-     *         const ctx = ctxMap.get(UserComponentModule.toString());
-     *         if (!ctx) return;
-     *
-     *         const services = ctx.getMany(...);
-     *       }}>
-     *       <UserComponent {...props.userComponentProps} />
-     *     </TapIntoComponent>
-     *   );
-     * }
-     * ````
-     */
-    contextInstance?: (ctx: Map<string, IComponentProviderModule>) => void | WithComponentInstanceCtxFluidSyntax;
-}
-interface WithComponentInstanceCtxFluidSyntax {
-    /** The {@link IComponentProviderModule | module} to look for in the `context map`. */
-    tryGet: IComponentProviderModule;
-    /**
-     * Provide a callback which will be invoked when the `context map` has
-     * the {@link tryGet | module} requested.
-     *
-     * @param module The contextualized instance of the {@link IComponentProviderModule} extracted from the children.
-     */
-    thenDo: (module: IComponentProviderModule) => void | Promise<void>;
-}
+/**
+ * Can be used to easily provide a {@link module} to any component.
+ *
+ * @example
+ * ```tsx
+ * interface MyComponentProps {
+ *   firstName: string;
+ *   lastName: string;
+ * }
+ *
+ * export const MyComponent = provideModuleToComponent(
+ *   MyComponentModule,
+ *   ({ firstName, lastName }: MyComponentProps) => {
+ *     const service = useInject(MyComponentService);
+ *
+ *     return <h1>Hello {service.computeUserName(firstName, lastName)}!</h1>
+ *   }
+ * );
+ *
+ * function App() {
+ *   return <MyComponent firstName={'John'} lastName={'Doe'} />;
+ * }
+ * ```
+ *
+ * @param module The {@link IComponentProviderModule | Module} which should be consumed by the {@link component}.
+ * @returns The provided {@link toComponent | Component}.
+ */
+declare function provideModuleToComponent<P extends Record<string, any>, C extends ReactElementWithProviderModule<P> = ReactElementWithProviderModule<P>>(module: IComponentProviderModule, component: ReactElementWithProviderModule<P>): C;
+type ReactElementWithProviderModule<P extends Record<string, any>> = (p: PropsWithModule<P>) => React.ReactNode;
 
 /**
- * This component is the standard way to "tap into" an instance of the component
- * in order to get access to its scoped module container and its _(exposed)_ dependencies _instances_.
+ * Can be used to easily provide a {@link module} to any component.
  *
- * @param contextInstance See {@link TapIntoComponentContextProps.contextInstance}.
- * @param exposed See {@link TapIntoComponentContextProps.exposed}.
+ * @example
+ * ```tsx
+ * interface MyComponentProps {
+ *   firstName: string;
+ *   lastName: string;
+ * }
+ *
+ * function MyComponent({ firstName, lastName }: MyComponentProps) {
+ *   const service = useInject(MyComponentService);
+ *
+ *   return <h1>Hello {service.computeUserName(firstName, lastName)}!</h1>
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <ProvideModule module={MyComponentModule}>
+ *       <MyComponent firstName={'John'} lastName={'Doe'} />
+ *     </ProvideModule>
+ *   );
+ * }
+ * ```
+ *
+ * @param param0 See {@link ProvideModuleFunctionParams}.
+ * @returns The provided {@link toComponent | Component}.
  */
-declare function TapIntoComponent({ children, contextInstance }: TapIntoComponentContextProps): react_jsx_runtime.JSX.Element;
+declare function ProvideModule({ module, children }: ProvideModuleFunctionParams): react_jsx_runtime.JSX.Element;
+interface ProvideModuleFunctionParams {
+    /** The {@link IComponentProviderModule | Module} which should be consumed by the {@link children | component}. */
+    module: IComponentProviderModule;
+    children: react__default.ReactElement;
+}
+
+declare function hookFactory<P extends HookParams, D extends any[], T>({ use: hook, inject, }: HookFactoryParams<P, D, T>): (p: P) => T;
+interface HookFactoryParams<P extends HookParams, D extends any[], T> {
+    use: HookWithProviderModuleDependencies<P, D, T>;
+    inject: ProviderToken[];
+}
+type HookWithProviderModuleDependencies<P extends HookParams, D extends any[], T> = (p: HookWithDeps<P, D>) => T;
+type HookWithDeps<P extends HookParams, D extends any[]> = P & {
+    /** Array containing the resolved dependencies from the component context. */
+    deps: D;
+};
+type HookParams = Record<string, any> | void;
 
-export { ComponentProviderModule, type IComponentProviderModule, type IComponentProviderModuleNaked, ModuleProvider, REACT_X_INJECTION_CONTEXT, REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT, REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE, TapIntoComponent, type TapIntoComponentContextProps, type UseInjectOptions, type UseInjectSharedOptions, type WithComponentInstanceCtxFluidSyntax, useExposeComponentModuleContext, useInject, useInjectMany, useInjectManyOnRender, useInjectOnRender, useRerenderOnChildrenModuleContextLoaded };
+export { ComponentProviderModule, type HookFactoryParams, type HookWithDeps, type HookWithProviderModuleDependencies, type IComponentProviderModule, type IComponentProviderModuleNaked, type PropsWithModule, ProvideModule, type ProvideModuleFunctionParams, REACT_X_INJECTION_PROVIDER_MODULE_CONTEXT, type ReactElementWithProviderModule, type UseInjectOptions, hookFactory, provideModuleToComponent, useComponentModule, useInject, useInjectMany };

package/dist/index.js

@@ -1,186 +1,160 @@
-var e = Object.defineProperty, t = (t, n) => e(t, "name", {
-    value: n,
+var e = Object.defineProperty, t = (t, o) => e(t, "name", {
+    value: o,
     configurable: !0
 });
 
-import { useRef as n } from "react";
+import { AppModule as o } from "@adimm/x-injection";
 
-function o(e) {
-    const t = n(null);
-    return null === t.current && (t.current = {
-        value: e()
-    }), t.current?.value;
-}
+import { createContext as n } from "react";
 
-t(o, "useOnce");
+var r = n(o);
 
-import { useEffect as r, useRef as i, useState as s } from "react";
+import { useContext as i } from "react";
 
-function c(e) {
-    const t = i(void 0), n = i(!1), o = i(!1), [, c] = s(0);
-    n.current && (o.current = !0), r((() => (n.current || (t.current = e(), n.current = !0), 
-    c((e => e + 1)), () => {
-        o.current && t.current?.();
-    })), []);
+function s() {
+    return i(r);
 }
 
-t(c, "useEffectOnce");
-
-import { useContext as u } from "react";
+function c(e, t) {
+    return s().get(e, t?.isOptional);
+}
 
-import { AppModule as a } from "@adimm/x-injection";
+function a(...e) {
+    return s().getMany(...e);
+}
 
-import { createContext as d } from "react";
+t(s, "useComponentModule"), t(c, "useInject"), t(a, "useInjectMany");
 
-var l = d(a), p = d(new Map), m = d({
-    r: 0
-});
+import { InjectionScope as m, ProviderModule as p, ProviderModuleHelpers as d } from "@adimm/x-injection";
 
-import { useCallback as f, useContext as x } from "react";
+var u = class e extends p {
+    static {
+        t(this, "ComponentProviderModule");
+    }
+    _initializedFromComponent;
+    constructor(e) {
+        super(d.buildInternalConstructorParams({
+            ...e,
+            defaultScope: e.defaultScope ?? m.Singleton,
+            identifier: Symbol(`Component${e.identifier.description}`)
+        })), this._initializedFromComponent = !1;
+    }
+    toNaked() {
+        return this;
+    }
+    clone(t) {
+        let o = [ ...this.providers ];
+        t?.providersMap && (o = o.map((e => t.providersMap(e, this))));
+        const n = new e(d.buildInternalConstructorParams({
+            isAppModule: this.isAppModule,
+            identifier: Symbol(this.identifier.description.replace("Component", "")),
+            defaultScope: this.defaultScope.native,
+            dynamicExports: this.dynamicExports,
+            onReady: this.onReady,
+            onDispose: this.onDispose,
+            importedProvidersMap: t?.importedProvidersMap,
+            imports: [ ...this.imports ],
+            providers: o,
+            exports: [ ...this.exports ]
+        }));
+        return n._initializedFromComponent = this._initializedFromComponent, n;
+    }
+    dispose() {
+        this._dispose();
+    }
+    _createContextualizedComponentInstance() {
+        if (this._initializedFromComponent) return this;
+        const e = this.clone().toNaked();
+        return e.identifier = Symbol(`Contextualized${e.identifier.description}`), e._initializedFromComponent = !0, 
+        e;
+    }
+};
 
-function C({children: e, render: t, module: n, tryReInitModuleOnMount: o, disposeModuleOnUnmount: r}) {
-    const i = n.toNaked().isAppModule, s = f((() => t?.()), []), c = {
-        ctx: i ? n : n.toNaked()._convertToContextualizedComponentInstance()
-    };
-    return React.createElement(l.Provider, {
-        value: c
-    }, React.createElement(m.Provider, {
-        value: {
-            r: 0
-        }
-    }, React.createElement(v, {
-        children: e ?? React.createElement(s, null),
-        module: c,
-        tryReInitModuleOnMount: o,
-        disposeModuleOnUnmount: r
-    })));
-}
+import { useMemo as l } from "react";
 
-function v({children: e, module: t, tryReInitModuleOnMount: n, disposeModuleOnUnmount: o = !1}) {
-    const r = x(p), i = x(m);
-    return c((() => {
-        const e = t.ctx.toNaked();
-        if (r) {
-            const e = t.ctx.toNaked().imports.map((e => r.get(e.toString())?.toString() === e.toString() ? r.get(e.toString()) : e));
-            e.length > 0 && (t.ctx.toNaked()._lazyInit({
-                ...t.ctx.toNaked()._initialOptions,
-                imports: e
-            }), i.r++);
-        }
-        return e.isDisposed && n && e._lazyInit(n), () => {
-            o && !e.isDisposed && e._dispose();
-        };
-    })), e;
-}
+import { useEffect as f, useRef as h, useState as v } from "react";
 
-function M(e, t) {
-    return u(l).ctx.get(e, t?.isOptional);
+function C(e) {
+    const t = h(void 0), o = h(!1), n = h(!1), [, r] = v(0);
+    o.current && (n.current = !0), f((() => (o.current || (t.current = e(), o.current = !0), 
+    r((e => e + 1)), () => {
+        n.current && t.current?.();
+    })), []);
 }
 
-function h(e, t) {
-    return o((() => M(e, t)));
+function y(e, t) {
+    const o = l((() => (t ?? e).toNaked()._createContextualizedComponentInstance()), [ e, t ]);
+    return C((() => () => {
+        o.dispose();
+    })), o;
 }
 
-t(C, "ModuleProvider"), t(v, "XInjectionChildrenRenderer"), t(M, "useInjectOnRender"), 
-t(h, "useInject");
+t(C, "useEffectOnce"), t(y, "useContextualizedModule");
 
-import { useContext as I } from "react";
+import { isFunction as M } from "@adimm/x-injection";
 
-function O({deps: e}) {
-    return I(l).ctx.getMany(...e);
+function x(e, t, o) {
+    const n = {
+        ...t
+    };
+    return ("object" == typeof e && "type" in e && M(e.type) || M(e)) && (n.module = o), 
+    n;
 }
 
-function g({deps: e, options: t}) {
-    return o((() => O({
-        options: t,
-        deps: e
-    })));
+function P(e, t) {
+    return o => {
+        const n = y(e, o.module);
+        return React.createElement(r.Provider, {
+            value: n
+        }, React.createElement(j, {
+            module: n,
+            componentProps: o,
+            component: t
+        }));
+    };
 }
 
-t(O, "useInjectManyOnRender"), t(g, "useInjectMany");
-
-import { useContext as R } from "react";
-
-function _() {
-    const e = R(l);
-    R(p).set(e.ctx.toString(), e.ctx);
+function j({module: e, component: t, componentProps: o}) {
+    return React.createElement(React.Fragment, null, t(x(t, o, e)));
 }
 
-t(_, "useExposeComponentModuleContext");
+t(x, "forwardPropsWithModule"), t(P, "provideModuleToComponent"), t(j, "ComponentRenderer");
 
-import { useContext as S, useEffect as y, useState as E } from "react";
+import z from "react";
 
-function j() {
-    const e = S(m), [, t] = E(0);
-    y((() => {
-        t((e => e + 1));
-    }), [ e.r ]);
+function E({module: e, children: t}) {
+    const o = t.props ?? {}, n = y(e, o.module);
+    return z.createElement(r.Provider, {
+        value: n
+    }, z.cloneElement(t, x(t, o, n)));
 }
 
-t(j, "useRerenderOnChildrenModuleContextLoaded");
+t(E, "ProvideModule");
+
+import { useMemo as F } from "react";
 
-import { InjectionScope as P, isClass as k, isClassOrFunction as z, ProviderModule as N, ProviderModuleHelpers as b } from "@adimm/x-injection";
+import { XInjectionProviderModuleError as _ } from "@adimm/x-injection";
 
-var D = class e extends N {
+var b = class e extends _ {
     static {
-        t(this, "ComponentProviderModule");
-    }
-    _initializedFromComponent;
-    _initialOptions;
-    constructor(e) {
-        super(b.buildInternalConstructorParams({
-            ...e,
-            defaultScope: e.defaultScope ?? P.Transient,
-            identifier: Symbol(`Component${e.identifier.description}`)
-        })), this._initializedFromComponent = !1, this._initialOptions = e;
-    }
-    toNaked() {
-        return this;
-    }
-    dispose() {
-        this._dispose();
-    }
-    _convertToContextualizedComponentInstance() {
-        if (this.isAppModule || this.isDisposed) return this;
-        const t = this._getProviders().map((e => z(e) ? k(e) ? {
-            scope: P.Singleton,
-            provide: e,
-            useClass: e
-        } : {
-            provide: e,
-            useValue: e
-        } : {
-            ...e,
-            scope: P.Singleton
-        })), n = new e({
-            ...this._initialOptions,
-            providers: t
-        });
-        return n._initializedFromComponent = !0, n;
+        t(this, "XInjectionHookFactoryError");
     }
+    name=e.name;
 };
 
-import { useContext as T, useEffect as w, useMemo as F } from "react";
-
-function U({children: e, contextInstance: t}) {
-    const n = F((() => new Map), []);
-    return React.createElement(p.Provider, {
-        value: n
-    }, React.createElement(A, {
-        contextInstance: t
-    }), e);
-}
-
-function A({contextInstance: e}) {
-    const t = T(p);
-    return w((() => {
-        const n = e?.(t);
-        if (!n) return;
-        const o = t.get(n.tryGet.toString());
-        o && n.thenDo(o);
-    }), [ t ]), null;
+function g({use: e, inject: t}) {
+    return o => {
+        const n = s(), r = F((() => {
+            if (0 === t.length) throw new b(n, "The 'deps' property array is missing!");
+            return n.getMany(...t);
+        }), [ t ]);
+        return e({
+            ...o,
+            deps: [ ...r ]
+        });
+    };
 }
 
-t(U, "TapIntoComponent"), t(A, "CtxExposer");
+t(g, "hookFactory");
 
-export { D as ComponentProviderModule, C as ModuleProvider, l as REACT_X_INJECTION_CONTEXT, p as REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT, m as REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE, U as TapIntoComponent, _ as useExposeComponentModuleContext, h as useInject, g as useInjectMany, O as useInjectManyOnRender, M as useInjectOnRender, j as useRerenderOnChildrenModuleContextLoaded };//# sourceMappingURL=index.js.map
+export { u as ComponentProviderModule, E as ProvideModule, r as REACT_X_INJECTION_PROVIDER_MODULE_CONTEXT, g as hookFactory, P as provideModuleToComponent, s as useComponentModule, c as useInject, a as useInjectMany };//# sourceMappingURL=index.js.map