@adimm/x-injection-reactjs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adi-Marian Mutu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+<h1 align="center">
+xInjection ReactJS&nbsp;<a href="https://www.npmjs.com/package/@adimm/x-injection-reactjs" target="__blank" alt="Release Version"><img src="https://img.shields.io/npm/v/@adimm/x-injection-reactjs?color=0476bc&label="></a>
+<img src="https://flat.badgen.net/npm/license/@adimm/x-injection-reactjs" alt="License">
+</h1>
+
+<p align="center">
+<a href="https://github.com/AdiMarianMutu/x-injection-reactjs/actions/workflows/ci.yml?query=branch%3Amain" target="__blank"><img src="https://github.com/AdiMarianMutu/x-injection-reactjs/actions/workflows/ci.yml/badge.svg?branch=main"></a>
+<a href="https://github.com/AdiMarianMutu/x-injection-reactjs/actions/workflows/publish.yml" target="__blank"><img src="https://github.com/AdiMarianMutu/x-injection-reactjs/actions/workflows/publish.yml/badge.svg"></a>
+<br>
+<img src="https://flat.badgen.net/bundlephobia/minzip/@adimm/x-injection-reactjs">
+<a href="https://www.npmjs.com/package/@adimm/x-injection-reactjs" target="__blank" alt="Monthly Downloads"><img src="https://flat.badgen.net/npm/dm/@adimm/x-injection-reactjs"></a>
+</p>
+
+## Table of Contents
+
+- [Table of Contents](#table-of-contents)
+- [Overview](#overview)
+- [Installation](#installation)
+  - [TypeScript Configuration](#typescript-configuration)
+- [Getting Started](#getting-started)
+- [Examples](#examples)
+  - [Component with private context](#component-with-private-context)
+  - [Component with public context](#component-with-public-context)
+    - [Safe method](#safe-method)
+    - [Experimental method](#experimental-method)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+
+## Overview
+
+**xInjection** is a robust Inversion of Control [(IoC)](https://en.wikipedia.org/wiki/Inversion_of_control) library that extends [InversifyJS](https://github.com/inversify/InversifyJS) with a modular, [NestJS](https://github.com/nestjs/nest)-inspired Dependency Injection [(DI)](https://en.wikipedia.org/wiki/Dependency_injection) system. It enables you to **encapsulate** dependencies with fine-grained control using **[ProviderModule](https://adimarianmutu.github.io/x-injection/classes/ProviderModule.html)** classes, allowing for clean **separation** of concerns and **scalable** architecture.
+
+Each `ProviderModule` manages its _own_ container, supporting easy **decoupling** and _explicit_ control over which providers are **exported** and **imported** across modules. The global **[AppModule](https://adimarianmutu.github.io/x-injection/variables/AppModule.html)** is always available, ensuring a seamless foundation for your application's DI needs.
+
+> For more details and info please access the [xInjection](https://github.com/AdiMarianMutu/x-injection) library repository.
+
+## Installation
+
+First, ensure you have [`reflect-metadata`](https://www.npmjs.com/package/reflect-metadata) installed:
+
+```sh
+npm i reflect-metadata
+```
+
+Then install `xInjection` for React:
+
+```sh
+npm i @adimm/x-injection-reactjs
+```
+
+> You may also have to install the parent library via `npm i @adimm/x-injection`
+
+### TypeScript Configuration
+
+Add the following options to your `tsconfig.json` to enable decorator metadata:
+
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+## Getting Started
+
+If you never used the parent library (`xInjection`), then please access the official [xInjection Repository](https://github.com/AdiMarianMutu/x-injection?tab=readme-ov-file#registering-global-providers) to better understand how to use its `ReactJS` implementation.
+
+## Examples
+
+### Component with private context
+
+A component with a private context it means that when it'll inject dependencies from a module within its instance,
+a parent component will not be able to access those dependencies instances.
+
+```tsx
+export class RandomNumberService {
+  generate(): number {
+    /* ... */
+  }
+}
+
+// Make sure to use the `ComponentProviderModule` from `@adimm/x-injection-reactjs` not the `ProviderModule` from `@adimm/x-injection`!
+export const RandomNumberComponentModule = new ComponentProviderModule({
+  identifier: Symbol('RandomNumberComponentModule'),
+  providers: [RandomNumberService],
+});
+
+export function RandomNumberComponent(props: RandomNumberComponentProps) {
+  const service = useInject(RandomNumberService);
+
+  return <h1>A random number: {service.generate()}</h1>;
+}
+```
+
+### Component with public context
+
+#### Safe method
+
+```tsx
+export class RandomNumberService {
+  generate(): number {
+    /* ... */
+  }
+}
+
+// Make sure to use the `ComponentProviderModule` from `@adimm/x-injection-reactjs` not the `ProviderModule` from `@adimm/x-injection`!
+export const RandomNumberComponentModule = new ComponentProviderModule({
+  identifier: Symbol('RandomNumberComponentModule'),
+  providers: [RandomNumberService],
+  exports: [RandomNumberService],
+});
+
+export function RandomNumberComponent(props: RandomNumberComponentProps) {
+  // This hook is necessary in order to expose the component instance
+  // context up to the parent component
+  useExposeComponentModuleContext();
+
+  const service = useInject(RandomNumberService);
+
+  return <h1>A random number: {service.generate()}</h1>;
+}
+
+////////////////////////////////////////
+
+export class ParentService {
+  constructor(public readonly randomNumberService: RandomNumberService) {}
+
+  injectRandomNumberService(service: RandomNumberService): void {
+    this.randomNumberService = service;
+  }
+}
+
+export const ParentServiceComponentModule = new ComponentProviderModule({
+  identifier: Symbol('ParentServiceComponentModule'),
+  imports: [RandomNumberComponentModule],
+  providers: [ParentService],
+});
+
+export function ParentComponent(props: ParentComponentProps) {
+  const service = useInject(ParentService);
+
+  return (
+    <>
+      <TapIntoComponent
+        // By using the fluid syntax
+        contextInstance={() => ({
+          // If one of the children did expose the `RandomNumberComponentModule`
+          // module, we'll be able to access its instance.
+          tryGet: RandomNumberComponentModule,
+          thenDo: (ctx) => {
+            const randomNumberService_FromComponentInstance = ctx.get(RandomNumberComponentModule);
+
+            service.injectRandomNumberService(randomNumberService_FromComponentInstance);
+          },
+        })}>
+        <RandomNumberComponent />
+      </TapIntoComponent>
+
+      <TapIntoComponent
+        // By accessing the entire underlying context map which may contain even more
+        // modules exposed by more children down the tree.
+        contextInstance={(ctxMap) => {
+          const ctx = ctxMap.get(RandomNumberComponentModule.toString());
+          if (!ctx) return;
+
+          const randomNumberService_FromComponentInstance = ctx.get(RandomNumberComponentModule);
+
+          service.injectRandomNumberService(randomNumberService_FromComponentInstance);
+        }}>
+        <RandomNumberComponent />
+      </TapIntoComponent>
+    </>
+  );
+}
+```
+
+#### Experimental method
+
+There is another method which is currently in _experimental_ mode and it may not always work as expected, it may even produce unnecessary re-render cycles
+or introduce unknown bugs, please use it carefully and with diligence!
+
+```tsx
+export function ParentComponent(props: ParentComponentProps) {
+  // By using this hook, the component will always re-render whenever
+  // a child using a ProviderModule which is also imported into the parent ProviderModule,
+  // has mounted and rendered!
+  useRerenderOnChildrenModuleContextLoaded();
+
+  // We should use the `useInjectOnRender` instead of the default `useInject`
+  // hook which re-uses the same instance of the injected dependency
+  // between re-renders.
+  //
+  // Note: It may still work with the `useInject` hook too, but it may not be predictable.
+  const service = useInjectOnRender(ParentService);
+
+  // At this point the `service.randomNumberService` instance should be the one
+  // from the `RandomNumberComponent` below.
+  //
+  // Note: Expect during the 1st render cycle to not be the same instance as the one used by the child component!
+  // The `xInjection` container will still supply the correct provider to the
+  // constructor parameter, but it'll be a new transient instance.
+  console.log(service.randomNumberService.generate());
+
+  // As we are now using the `useRerenderOnChildrenModuleContextLoaded` hook
+  // there's no need anymore for the `TapIntoComponent` wrapper.
+  return <RandomNumberComponent />;
+}
+```
+
+## Documentation
+
+Comprehensive, auto-generated documentation is available at:
+
+👉 [https://adimarianmutu.github.io/x-injection-reactjs/index.html](https://adimarianmutu.github.io/x-injection-reactjs/index.html)
+
+## Contributing
+
+Pull requests are warmly welcomed! 😃
+
+Please ensure your contributions adhere to the project's code style. See the repository for more details.
+
+---
+
+> For questions, feature requests, or bug reports, feel free to open an [issue](https://github.com/AdiMarianMutu/x-injection-reactjs/issues) on GitHub!

package/dist/index.cjs

@@ -0,0 +1,204 @@
+"use strict";
+
+var e, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, o = Object.getOwnPropertyNames, r = Object.prototype.hasOwnProperty, i = (e, n) => t(e, "name", {
+    value: n,
+    configurable: !0
+}), u = {};
+
+((e, n) => {
+    for (var o in n) t(e, o, {
+        get: n[o],
+        enumerable: !0
+    });
+})(u, {
+    ComponentProviderModule: () => S,
+    ModuleProvider: () => M,
+    REACT_X_INJECTION_CONTEXT: () => m,
+    REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT: () => f,
+    REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE: () => O,
+    TapIntoComponent: () => b,
+    useExposeComponentModuleContext: () => h,
+    useInject: () => E,
+    useInjectMany: () => N,
+    useInjectManyOnRender: () => R,
+    useInjectOnRender: () => v,
+    useRerenderOnChildrenModuleContextLoaded: () => y
+}), module.exports = (e = u, ((e, i, u, s) => {
+    if (i && "object" == typeof i || "function" == typeof i) for (let c of o(i)) r.call(e, c) || c === u || t(e, c, {
+        get: () => i[c],
+        enumerable: !(s = n(i, c)) || s.enumerable
+    });
+    return e;
+})(t({}, "__esModule", {
+    value: !0
+}), e));
+
+var s = require("react");
+
+function c(e) {
+    const t = (0, s.useRef)(null);
+    return null === t.current && (t.current = {
+        value: e()
+    }), t.current?.value;
+}
+
+i(c, "useOnce");
+
+var a = require("react");
+
+function d(e) {
+    const t = (0, a.useRef)(void 0), n = (0, a.useRef)(!1), o = (0, a.useRef)(!1), [, r] = (0, 
+    a.useState)(0);
+    n.current && (o.current = !0), (0, a.useEffect)((() => (n.current || (t.current = e(), 
+    n.current = !0), r((e => e + 1)), () => {
+        o.current && t.current?.();
+    })), []);
+}
+
+i(d, "useEffectOnce");
+
+var l = require("react"), p = require("@adimm/x-injection"), C = require("react"), m = (0, 
+C.createContext)(p.AppModule), f = (0, C.createContext)(new Map), O = (0, C.createContext)({
+    r: 0
+}), x = require("react");
+
+function M({children: e, module: t, tryReInitModuleOnMount: n, disposeModuleOnUnmount: o}) {
+    const r = t.toNaked().isAppModule, i = {
+        ctx: (0, x.useMemo)((() => r ? t : t.toNaked()._convertToContextualizedComponentInstance()), [ e, t, n, o ])
+    };
+    return React.createElement(m.Provider, {
+        value: i
+    }, React.createElement(O.Provider, {
+        value: {
+            r: 0
+        }
+    }, React.createElement(_, {
+        children: e,
+        module: i,
+        tryReInitModuleOnMount: n,
+        disposeModuleOnUnmount: o
+    })));
+}
+
+function _({children: e, module: t, tryReInitModuleOnMount: n, disposeModuleOnUnmount: o = !1}) {
+    const r = (0, x.useContext)(f), i = (0, x.useContext)(O);
+    return d((() => {
+        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;
+}
+
+function v(e, t) {
+    return (0, l.useContext)(m).ctx.get(e, t?.isOptional);
+}
+
+function E(e, t) {
+    return c((() => v(e, t)));
+}
+
+i(M, "ModuleProvider"), i(_, "XInjectionChildrenRenderer"), i(v, "useInjectOnRender"), 
+i(E, "useInject");
+
+var I = require("react");
+
+function R({deps: e}) {
+    return (0, I.useContext)(m).ctx.getMany(...e);
+}
+
+function N({deps: e, options: t}) {
+    return c((() => R({
+        options: t,
+        deps: e
+    })));
+}
+
+i(R, "useInjectManyOnRender"), i(N, "useInjectMany");
+
+var g = require("react");
+
+function h() {
+    const e = (0, g.useContext)(m);
+    (0, g.useContext)(f).set(e.ctx.toString(), e.ctx);
+}
+
+i(h, "useExposeComponentModuleContext");
+
+var j = require("react");
+
+function y() {
+    const e = (0, j.useContext)(O), [, t] = (0, j.useState)(0);
+    (0, j.useEffect)((() => {
+        t((e => e + 1));
+    }), [ e.r ]);
+}
+
+i(y, "useRerenderOnChildrenModuleContextLoaded");
+
+var P = require("@adimm/x-injection"), S = class e extends P.ProviderModule {
+    static {
+        i(this, "ComponentProviderModule");
+    }
+    _initializedFromComponent;
+    _initialOptions;
+    constructor(e) {
+        super(P.ProviderModuleHelpers.buildInternalConstructorParams({
+            ...e,
+            defaultScope: e.defaultScope ?? P.InjectionScope.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 => (0, P.isClassOrFunction)(e) ? (0, P.isClass)(e) ? {
+            scope: P.InjectionScope.Singleton,
+            provide: e,
+            useClass: e
+        } : {
+            provide: e,
+            useValue: e
+        } : {
+            ...e,
+            scope: P.InjectionScope.Singleton
+        })), n = new e({
+            ...this._initialOptions,
+            providers: t
+        });
+        return n._initializedFromComponent = !0, n;
+    }
+}, T = require("react");
+
+function b({children: e, contextInstance: t}) {
+    const n = (0, T.useMemo)((() => new Map), []);
+    return React.createElement(f.Provider, {
+        value: n
+    }, React.createElement(q, {
+        contextInstance: t
+    }), e);
+}
+
+function q({contextInstance: e}) {
+    const t = (0, T.useContext)(f);
+    return (0, T.useEffect)((() => {
+        const n = e?.(t);
+        if (!n) return;
+        const o = t.get(n.tryGet.toString());
+        o && n.thenDo(o);
+    }), [ t ]), null;
+}
+
+i(b, "TapIntoComponent"), i(q, "CtxExposer");//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/helpers/hooks/use-once.ts","../src/helpers/hooks/use-effect-once.ts","../src/core/hooks/use-inject-on-render.ts","../src/core/providers/module-provider/react-context.ts","../src/core/providers/module-provider/module.provider.tsx","../src/core/hooks/use-inject.ts","../src/core/hooks/use-inject-many-on-render.ts","../src/core/hooks/use-inject-many.ts","../src/core/hooks/use-expose-component-module-context.ts","../src/core/hooks/use-rerender-on-children-module-context-loaded.ts","../src/core/component-provider-module.ts","../src/core/utils/tap-into-component-context/tap-into-component-context.tsx"],"sourcesContent":["export * from './core';\nexport type * from './types';\n","import { useRef } from 'react';\n\nexport function useOnce<T>(fn: () => T): T {\n  const ref = useRef<OnceValue<T> | null>(null);\n\n  if (ref.current === null) {\n    ref.current = { value: fn() };\n  }\n\n  return ref.current?.value;\n}\n\ntype OnceValue<T> = { value: T };\n","import { useEffect, useRef, useState } from 'react';\n\n// Credits: https://stackoverflow.com/a/74000921\n\n/** Custom {@link useEffect} hook which will be run once. _(In `StrictMode` as well)_ */\nexport function useEffectOnce(effect: () => React.EffectCallback) {\n  const destroyFunc = useRef<React.EffectCallback>(undefined);\n  const effectCalled = useRef(false);\n  const renderAfterCalled = useRef(false);\n  const [, forceRerender] = useState(0);\n\n  if (effectCalled.current) renderAfterCalled.current = true;\n\n  useEffect(() => {\n    // only execute the effect first time around\n    if (!effectCalled.current) {\n      destroyFunc.current = effect();\n      effectCalled.current = true;\n    }\n\n    // this forces one render after the effect is run\n    forceRerender((x) => x + 1);\n\n    return () => {\n      // if the comp didn't render since the useEffect was called,\n      // we know it's the dummy React cycle\n      if (!renderAfterCalled.current) return;\n\n      destroyFunc.current?.();\n    };\n  }, []);\n}\n","import type { ProviderToken } from '@adimm/x-injection';\nimport { useContext } from 'react';\n\nimport type { UseInjectSharedOptions } from '../../types';\nimport { REACT_X_INJECTION_CONTEXT } from '../providers';\n\n/**\n * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.\n *\n * **Note:** _By using this hook, the dependency will be injected on each re-render process._\n * _If you need to inject the dependency only once, you must use the `useInject` hook._\n * _It basically acts like a `Transient` scope, ensuring that a new dependency is injected on each re-render._\n *\n * @param provider The {@link ProviderToken}.\n * @param options See {@link UseInjectSharedOptions}.\n * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.\n */\nexport function useInjectOnRender<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T {\n  const componentModule = useContext(REACT_X_INJECTION_CONTEXT);\n\n  return componentModule.ctx.get(provider, options?.isOptional);\n}\n\nexport type UseInjectOptions = UseInjectSharedOptions & {\n  /** When set to `false` _(default)_ an exception will be thrown when the `providerOrIdentifier` isn't bound. */\n  isOptional?: boolean;\n};\n","import { AppModule } from '@adimm/x-injection';\nimport { createContext } from 'react';\n\nimport type { IComponentProviderModule } from '../../../types';\n\n/**\n * The `React.Context` value to be provided to a `React.Provider`.\n *\n * Its default value is a reference to the {@link AppModule}.\n */\nexport const REACT_X_INJECTION_CONTEXT = createContext<{ ctx: IComponentProviderModule }>(AppModule as any);\n\nexport const REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT = createContext<Map<string, IComponentProviderModule>>(\n  new Map()\n);\n\nexport const REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE = createContext<{ r: number }>({ r: 0 });\n","import { useContext, useMemo } from 'react';\nimport type { Except } from 'type-fest';\n\nimport { useEffectOnce } from '../../../helpers';\nimport type { IComponentProviderModule, IComponentProviderModuleNaked } from '../../../types';\nimport type { ModuleProviderProps } from './models';\nimport {\n  REACT_X_INJECTION_CONTEXT,\n  REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT,\n  REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE,\n} from './react-context';\n\nexport function ModuleProvider({\n  children,\n  module,\n  tryReInitModuleOnMount,\n  disposeModuleOnUnmount,\n}: ModuleProviderProps) {\n  const isAppModule = module.toNaked().isAppModule;\n\n  const moduleCtxReference = {\n    ctx: useMemo(() => {\n      return isAppModule ? module : module.toNaked()._convertToContextualizedComponentInstance();\n    }, [children, module, tryReInitModuleOnMount, disposeModuleOnUnmount]),\n  };\n\n  return (\n    <REACT_X_INJECTION_CONTEXT.Provider value={moduleCtxReference}>\n      <REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE.Provider value={{ r: 0 }}>\n        <XInjectionChildrenRenderer\n          children={children}\n          module={moduleCtxReference}\n          tryReInitModuleOnMount={tryReInitModuleOnMount}\n          disposeModuleOnUnmount={disposeModuleOnUnmount}\n        />\n      </REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE.Provider>\n    </REACT_X_INJECTION_CONTEXT.Provider>\n  );\n}\n\nfunction XInjectionChildrenRenderer({\n  children,\n  module,\n  tryReInitModuleOnMount,\n  disposeModuleOnUnmount = false,\n}: Except<ModuleProviderProps, 'module'> & { module: { ctx: IComponentProviderModule } }) {\n  const componentModuleInstance = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT);\n  const rerenderParentCtx = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE);\n\n  // We use the `useEffectOnce` custom hook in order\n  // to make sure that if the developer is providing the\n  // `tryReInitModuleOnMount` and/or `disposeModuleOnUnmount` options\n  // we do not early dispose the module when React double re-renders the\n  // component while StrictMode is enabled.\n  // This hook guarantees that the same behavior is expected with or without StrictMode.\n  //\n  // https://react.dev/reference/react/StrictMode\n  useEffectOnce(() => {\n    // ON MOUNT\n\n    const moduleNaked = module.ctx.toNaked();\n\n    if (componentModuleInstance) {\n      const contextualizedImportedModules = module.ctx.toNaked().imports.map((importedModule) => {\n        const shouldReplaceImportedModuleWithContextualized =\n          componentModuleInstance.get(importedModule.toString())?.toString() === importedModule.toString();\n\n        /* istanbul ignore next */\n        if (!shouldReplaceImportedModuleWithContextualized)\n          return importedModule as unknown as IComponentProviderModuleNaked;\n\n        return componentModuleInstance.get(importedModule.toString()) as IComponentProviderModuleNaked;\n      });\n\n      if (contextualizedImportedModules.length > 0) {\n        module.ctx.toNaked()._lazyInit({\n          ...module.ctx.toNaked()._initialOptions,\n          imports: contextualizedImportedModules,\n        });\n\n        // This will force the parent to re-render when using the `useRerenderOnChildrenModuleContextLoaded` hook.\n        rerenderParentCtx.r++;\n      }\n    }\n\n    /* istanbul ignore next */\n    if (moduleNaked.isDisposed && tryReInitModuleOnMount) {\n      /* istanbul ignore next */\n      moduleNaked._lazyInit(tryReInitModuleOnMount);\n    }\n\n    return () => {\n      // ON UNMOUNT\n\n      if (!disposeModuleOnUnmount || moduleNaked.isDisposed) return;\n\n      moduleNaked._dispose();\n    };\n  });\n\n  return children;\n}\n","import type { ProviderToken } from '@adimm/x-injection';\n\nimport { useOnce } from '../../helpers';\nimport { useInjectOnRender, type UseInjectOptions } from './use-inject-on-render';\n\n/**\n * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.\n *\n * **Note:** _By using this hook, the dependency will be injected only once after the first component mount process._\n * _If you need to re-inject the dependency on each re-render, you must use the `useInjectOnRender` hook._\n * _It basically acts like a `Request` scope, ensuring that even a `Transient` dependency does not mutate during re-renders._\n *\n * @param provider The {@link ProviderToken}.\n * @param options See {@link UseInjectSharedOptions}.\n * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.\n */\nexport function useInject<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T {\n  return useOnce(() => useInjectOnRender(provider, options));\n}\n","import type {\n  ProviderModuleGetManyParam,\n  ProviderModuleGetManySignature,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  ProviderToken,\n} from '@adimm/x-injection';\nimport { useContext } from 'react';\n\nimport type { UseInjectSharedOptions } from '../../types';\nimport { REACT_X_INJECTION_CONTEXT } from '../providers';\n\n/**\n * Can be used to retrieve many resolved `dependencies` from the module container at once.\n *\n * **Note:** _By using this hook, the dependencies will be injected on each re-render process._\n * _If you need to inject the dependencies only once, you must use the `useInjectMany` hook._\n *\n * @param options See {@link UseInjectSharedOptions}.\n * @param deps Either one or more {@link ProviderToken}.\n * @returns Tuple containing the {@link D | dependencies}.\n */\nexport function useInjectManyOnRender<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>({\n  deps,\n}: {\n  deps: [...(D | unknown[])];\n  options?: UseInjectSharedOptions;\n}): ProviderModuleGetManySignature<D> {\n  const componentModule = useContext(REACT_X_INJECTION_CONTEXT);\n\n  return componentModule.ctx.getMany(...deps);\n}\n","import type { ProviderModuleGetManyParam, ProviderModuleGetManySignature, ProviderToken } from '@adimm/x-injection';\n\nimport { useOnce } from '../../helpers';\nimport type { UseInjectSharedOptions } from '../../types';\nimport { useInjectManyOnRender } from './use-inject-many-on-render';\n\n/**\n * Can be used to retrieve many resolved `dependencies` from the module container at once.\n *\n * **Note:** _By using this hook, the dependencies will be injected only once after the first component mount process._\n * _If you need to re-inject the dependencies on each re-render, you must use the `useInjectManyOnRender` hook._\n *\n * @param options See {@link UseInjectSharedOptions}.\n * @param deps Either one or more {@link ProviderToken}.\n * @returns Tuple containing the {@link D | dependencies}.\n */\nexport function useInjectMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>({\n  deps,\n  options,\n}: {\n  deps: [...(D | unknown[])];\n  options?: UseInjectSharedOptions;\n}): ProviderModuleGetManySignature<D> {\n  return useOnce(() => useInjectManyOnRender({ options, deps }));\n}\n","import { useContext } from 'react';\n\nimport { REACT_X_INJECTION_CONTEXT, REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT } from '../providers';\n\nexport function useExposeComponentModuleContext(): void {\n  const componentModule = useContext(REACT_X_INJECTION_CONTEXT);\n  const exposed = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT);\n\n  exposed.set(componentModule.ctx.toString(), componentModule.ctx);\n}\n","import { useContext, useEffect, useState } from 'react';\n\nimport { REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE } from '../providers';\n\n/**\n * This is an **experimental** hook which can be used to make sure that a component will re-render when a children\n * exposes its internal context module.\n *\n * It works best with the `useInjectOnRender` hook, as it'll re-resolve all the required dependencies\n * of the injected ProviderToken.\n *\n * **Use it carefully as it may lead to unnecessary re-render cycles or it may even not work as expected!**\n * **It's safer to use the `TapIntoComponent` wrapper component with the `contextInstance` to manually inject the**\n * **contextualized dependencies of the children into a parent component service!**\n *\n * @experimental\n */\nexport function useRerenderOnChildrenModuleContextLoaded(): void {\n  const rerenderParentCtx = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE);\n  const [, setRerender] = useState(0);\n\n  useEffect(() => {\n    setRerender((x) => x + 1);\n  }, [rerenderParentCtx.r]);\n}\n","import {\n  InjectionScope,\n  isClass,\n  isClassOrFunction,\n  ProviderModule,\n  ProviderModuleHelpers,\n  type DependencyProvider,\n  type IProviderModuleNaked,\n  type ProviderClassToken,\n  type ProviderModuleOptions,\n  type ProviderValueToken,\n} from '@adimm/x-injection';\n\nimport type { IComponentProviderModule, IComponentProviderModuleNaked } from '../types';\n\n/** A superset of the {@link ProviderModule} used to integrate within a `React` component. */\nexport class ComponentProviderModule extends ProviderModule implements IComponentProviderModule {\n  protected readonly _initializedFromComponent: IComponentProviderModuleNaked['_initializedFromComponent'];\n  protected readonly _initialOptions: IComponentProviderModuleNaked['_initialOptions'];\n\n  constructor(options: ProviderModuleOptions) {\n    super(\n      ProviderModuleHelpers.buildInternalConstructorParams({\n        ...options,\n        // By default components should have all their providers\n        // defined as transient because a component may have more than one instance of itself.\n        defaultScope: options.defaultScope ?? InjectionScope.Transient,\n        identifier: Symbol(`Component${options.identifier.description}`),\n      })\n    );\n\n    this._initializedFromComponent = false;\n    this._initialOptions = options;\n  }\n\n  override toNaked(): IComponentProviderModuleNaked & IProviderModuleNaked {\n    return this as any;\n  }\n\n  /* istanbul ignore next */\n  dispose(): void {\n    this._dispose();\n  }\n\n  /**\n   * **Publicly visible when the instance is casted to {@link IComponentProviderModuleNaked}.**\n   *\n   * See {@link IComponentProviderModuleNaked._convertToContextualizedComponentInstance}.\n   */\n  /* istanbul ignore next */\n  protected _convertToContextualizedComponentInstance(): IComponentProviderModule {\n    if (this.isAppModule || this.isDisposed) return this;\n\n    const contextualizedProviders = this._getProviders().map((provider) => {\n      if (!isClassOrFunction(provider)) {\n        return {\n          ...provider,\n          scope: InjectionScope.Singleton,\n        } as DependencyProvider;\n      }\n\n      if (isClass(provider)) {\n        return {\n          scope: InjectionScope.Singleton,\n          provide: provider,\n          useClass: provider,\n        } as ProviderClassToken<any>;\n      }\n\n      return {\n        provide: provider,\n        useValue: provider,\n      } as ProviderValueToken<any>;\n    });\n\n    const componentModule = new ComponentProviderModule({\n      ...this._initialOptions,\n      providers: contextualizedProviders,\n    });\n\n    //@ts-expect-error Read-only property.\n    componentModule._initializedFromComponent = true;\n\n    return componentModule;\n  }\n}\n","import { useContext, useEffect, useMemo } from 'react';\nimport type { Except } from 'type-fest';\n\nimport { REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT } from '../../providers';\nimport type { TapIntoComponentContextProps } from './interfaces';\n\n/**\n * This component is the standard way to \"tap into\" an instance of the component\n * in order to get access to its scoped module container and its _(exposed)_ dependencies _instances_.\n *\n * @param contextInstance See {@link TapIntoComponentContextProps.contextInstance}.\n * @param exposed See {@link TapIntoComponentContextProps.exposed}.\n */\nexport function TapIntoComponent({ children, contextInstance }: TapIntoComponentContextProps) {\n  const moduleContextMap = useMemo(() => new Map(), []);\n\n  return (\n    <REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT.Provider value={moduleContextMap}>\n      <CtxExposer contextInstance={contextInstance} />\n      {children}\n    </REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT.Provider>\n  );\n}\n\nfunction CtxExposer({ contextInstance }: Except<TapIntoComponentContextProps, 'children'>) {\n  const ctxMap = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT);\n\n  useEffect(() => {\n    const fluidSyntax = contextInstance?.(ctxMap);\n    if (!fluidSyntax) return;\n\n    const moduleCtx = ctxMap.get(fluidSyntax.tryGet.toString());\n    /* istanbul ignore next */\n    if (!moduleCtx) return;\n\n    fluidSyntax.thenDo(moduleCtx);\n  }, [ctxMap]);\n\n  return null;\n}\n"],"mappings":"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","names":["useOnce","fn","ref","useRef","current","value","import_react","useEffectOnce","effect","destroyFunc","useRef","undefined","effectCalled","renderAfterCalled","forceRerender","useState","current","useEffect","x","import_react","import_react","REACT_X_INJECTION_CONTEXT","createContext","AppModule","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","Map","REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE","r","import_react","ModuleProvider","children","module","tryReInitModuleOnMount","disposeModuleOnUnmount","isAppModule","toNaked","moduleCtxReference","ctx","useMemo","_convertToContextualizedComponentInstance","REACT_X_INJECTION_CONTEXT","Provider","value","REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE","r","XInjectionChildrenRenderer","componentModuleInstance","useContext","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","rerenderParentCtx","useEffectOnce","moduleNaked","contextualizedImportedModules","imports","map","importedModule","shouldReplaceImportedModuleWithContextualized","get","toString","length","_lazyInit","_initialOptions","isDisposed","_dispose","useInjectOnRender","provider","options","componentModule","useContext","REACT_X_INJECTION_CONTEXT","ctx","get","isOptional","useInject","provider","options","useOnce","useInjectOnRender","import_react","useInjectManyOnRender","deps","componentModule","useContext","REACT_X_INJECTION_CONTEXT","ctx","getMany","useInjectMany","deps","options","useOnce","useInjectManyOnRender","import_react","useExposeComponentModuleContext","componentModule","useContext","REACT_X_INJECTION_CONTEXT","exposed","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","set","ctx","toString","import_react","useRerenderOnChildrenModuleContextLoaded","rerenderParentCtx","useContext","REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE","setRerender","useState","useEffect","x","r","import_x_injection","ComponentProviderModule","ProviderModule","_initializedFromComponent","_initialOptions","constructor","options","ProviderModuleHelpers","buildInternalConstructorParams","defaultScope","InjectionScope","Transient","identifier","Symbol","description","toNaked","dispose","_dispose","_convertToContextualizedComponentInstance","isAppModule","isDisposed","contextualizedProviders","_getProviders","map","provider","isClassOrFunction","scope","Singleton","isClass","provide","useClass","useValue","componentModule","providers","import_react","TapIntoComponent","children","contextInstance","moduleContextMap","useMemo","Map","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","Provider","value","CtxExposer","ctxMap","useContext","useEffect","fluidSyntax","moduleCtx","get","tryGet","toString","thenDo"]}

package/dist/index.d.cts

@@ -0,0 +1,245 @@
+import { ProviderModuleOptions, IProviderModule, IProviderModuleNaked, ProviderToken, ProviderModuleGetManyParam, ProviderModuleGetManySignature, ProviderModule } from '@adimm/x-injection';
+import * as react from 'react';
+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.
+     */
+    _convertToContextualizedComponentInstance(): IComponentProviderModule;
+}
+
+interface IComponentProviderModule extends IProviderModule {
+    /**
+     * Casts the current module type to the {@link IComponentProviderModuleNaked} type.
+     *
+     * **Internally used and for testing purposes!**
+     */
+    toNaked(): IComponentProviderModuleNaked & IProviderModuleNaked;
+    /**
+     * Should be invoked only when the component is not needed anymore.
+     *
+     * _eg: When changing page, removable components and so on._
+     */
+    dispose(): void;
+}
+
+interface UseInjectSharedOptions {
+}
+
+/**
+ * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.
+ *
+ * **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._
+ *
+ * @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 useInjectOnRender<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T;
+type UseInjectOptions = UseInjectSharedOptions & {
+    /** 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}.
+ *
+ * **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._
+ *
+ * @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;
+    /** 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 ModuleProvider({ children, module, tryReInitModuleOnMount, disposeModuleOnUnmount, }: ModuleProviderProps): react_jsx_runtime.JSX.Element;
+
+/** 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;
+    dispose(): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IComponentProviderModuleNaked}.**
+     *
+     * See {@link IComponentProviderModuleNaked._convertToContextualizedComponentInstance}.
+     */
+    protected _convertToContextualizedComponentInstance(): 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>;
+}
+
+/**
+ * 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_.
+ *
+ * @param contextInstance See {@link TapIntoComponentContextProps.contextInstance}.
+ * @param exposed See {@link TapIntoComponentContextProps.exposed}.
+ */
+declare function TapIntoComponent({ children, contextInstance }: TapIntoComponentContextProps): react_jsx_runtime.JSX.Element;
+
+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 };

package/dist/index.d.ts

@@ -0,0 +1,245 @@
+import { ProviderModuleOptions, IProviderModule, IProviderModuleNaked, ProviderToken, ProviderModuleGetManyParam, ProviderModuleGetManySignature, ProviderModule } from '@adimm/x-injection';
+import * as react from 'react';
+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.
+     */
+    _convertToContextualizedComponentInstance(): IComponentProviderModule;
+}
+
+interface IComponentProviderModule extends IProviderModule {
+    /**
+     * Casts the current module type to the {@link IComponentProviderModuleNaked} type.
+     *
+     * **Internally used and for testing purposes!**
+     */
+    toNaked(): IComponentProviderModuleNaked & IProviderModuleNaked;
+    /**
+     * Should be invoked only when the component is not needed anymore.
+     *
+     * _eg: When changing page, removable components and so on._
+     */
+    dispose(): void;
+}
+
+interface UseInjectSharedOptions {
+}
+
+/**
+ * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.
+ *
+ * **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._
+ *
+ * @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 useInjectOnRender<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T;
+type UseInjectOptions = UseInjectSharedOptions & {
+    /** 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}.
+ *
+ * **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._
+ *
+ * @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;
+    /** 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 ModuleProvider({ children, module, tryReInitModuleOnMount, disposeModuleOnUnmount, }: ModuleProviderProps): react_jsx_runtime.JSX.Element;
+
+/** 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;
+    dispose(): void;
+    /**
+     * **Publicly visible when the instance is casted to {@link IComponentProviderModuleNaked}.**
+     *
+     * See {@link IComponentProviderModuleNaked._convertToContextualizedComponentInstance}.
+     */
+    protected _convertToContextualizedComponentInstance(): 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>;
+}
+
+/**
+ * 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_.
+ *
+ * @param contextInstance See {@link TapIntoComponentContextProps.contextInstance}.
+ * @param exposed See {@link TapIntoComponentContextProps.exposed}.
+ */
+declare function TapIntoComponent({ children, contextInstance }: TapIntoComponentContextProps): react_jsx_runtime.JSX.Element;
+
+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 };

package/dist/index.js

@@ -0,0 +1,186 @@
+var e = Object.defineProperty, t = (t, n) => e(t, "name", {
+    value: n,
+    configurable: !0
+});
+
+import { useRef as n } from "react";
+
+function o(e) {
+    const t = n(null);
+    return null === t.current && (t.current = {
+        value: e()
+    }), t.current?.value;
+}
+
+t(o, "useOnce");
+
+import { useEffect as r, useRef as i, useState as s } 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?.();
+    })), []);
+}
+
+t(c, "useEffectOnce");
+
+import { useContext as u } from "react";
+
+import { AppModule as a } from "@adimm/x-injection";
+
+import { createContext as d } from "react";
+
+var p = d(a), l = d(new Map), m = d({
+    r: 0
+});
+
+import { useContext as f, useMemo as x } from "react";
+
+function C({children: e, module: t, tryReInitModuleOnMount: n, disposeModuleOnUnmount: o}) {
+    const r = t.toNaked().isAppModule, i = {
+        ctx: x((() => r ? t : t.toNaked()._convertToContextualizedComponentInstance()), [ e, t, n, o ])
+    };
+    return React.createElement(p.Provider, {
+        value: i
+    }, React.createElement(m.Provider, {
+        value: {
+            r: 0
+        }
+    }, React.createElement(v, {
+        children: e,
+        module: i,
+        tryReInitModuleOnMount: n,
+        disposeModuleOnUnmount: o
+    })));
+}
+
+function v({children: e, module: t, tryReInitModuleOnMount: n, disposeModuleOnUnmount: o = !1}) {
+    const r = f(l), i = f(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;
+}
+
+function M(e, t) {
+    return u(p).ctx.get(e, t?.isOptional);
+}
+
+function h(e, t) {
+    return o((() => M(e, t)));
+}
+
+t(C, "ModuleProvider"), t(v, "XInjectionChildrenRenderer"), t(M, "useInjectOnRender"), 
+t(h, "useInject");
+
+import { useContext as I } from "react";
+
+function O({deps: e}) {
+    return I(p).ctx.getMany(...e);
+}
+
+function g({deps: e, options: t}) {
+    return o((() => O({
+        options: t,
+        deps: e
+    })));
+}
+
+t(O, "useInjectManyOnRender"), t(g, "useInjectMany");
+
+import { useContext as _ } from "react";
+
+function R() {
+    const e = _(p);
+    _(l).set(e.ctx.toString(), e.ctx);
+}
+
+t(R, "useExposeComponentModuleContext");
+
+import { useContext as S, useEffect as y, useState as E } from "react";
+
+function j() {
+    const e = S(m), [, t] = E(0);
+    y((() => {
+        t((e => e + 1));
+    }), [ e.r ]);
+}
+
+t(j, "useRerenderOnChildrenModuleContextLoaded");
+
+import { InjectionScope as P, isClass as k, isClassOrFunction as z, ProviderModule as N, ProviderModuleHelpers as b } from "@adimm/x-injection";
+
+var D = class e extends N {
+    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;
+    }
+};
+
+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(l.Provider, {
+        value: n
+    }, React.createElement(A, {
+        contextInstance: t
+    }), e);
+}
+
+function A({contextInstance: e}) {
+    const t = T(l);
+    return w((() => {
+        const n = e?.(t);
+        if (!n) return;
+        const o = t.get(n.tryGet.toString());
+        o && n.thenDo(o);
+    }), [ t ]), null;
+}
+
+t(U, "TapIntoComponent"), t(A, "CtxExposer");
+
+export { D as ComponentProviderModule, C as ModuleProvider, p as REACT_X_INJECTION_CONTEXT, l as REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT, m as REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE, U as TapIntoComponent, R as useExposeComponentModuleContext, h as useInject, g as useInjectMany, O as useInjectManyOnRender, M as useInjectOnRender, j as useRerenderOnChildrenModuleContextLoaded };//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helpers/hooks/use-once.ts","../src/helpers/hooks/use-effect-once.ts","../src/core/hooks/use-inject-on-render.ts","../src/core/providers/module-provider/react-context.ts","../src/core/providers/module-provider/module.provider.tsx","../src/core/hooks/use-inject.ts","../src/core/hooks/use-inject-many-on-render.ts","../src/core/hooks/use-inject-many.ts","../src/core/hooks/use-expose-component-module-context.ts","../src/core/hooks/use-rerender-on-children-module-context-loaded.ts","../src/core/component-provider-module.ts","../src/core/utils/tap-into-component-context/tap-into-component-context.tsx"],"sourcesContent":["import { useRef } from 'react';\n\nexport function useOnce<T>(fn: () => T): T {\n  const ref = useRef<OnceValue<T> | null>(null);\n\n  if (ref.current === null) {\n    ref.current = { value: fn() };\n  }\n\n  return ref.current?.value;\n}\n\ntype OnceValue<T> = { value: T };\n","import { useEffect, useRef, useState } from 'react';\n\n// Credits: https://stackoverflow.com/a/74000921\n\n/** Custom {@link useEffect} hook which will be run once. _(In `StrictMode` as well)_ */\nexport function useEffectOnce(effect: () => React.EffectCallback) {\n  const destroyFunc = useRef<React.EffectCallback>(undefined);\n  const effectCalled = useRef(false);\n  const renderAfterCalled = useRef(false);\n  const [, forceRerender] = useState(0);\n\n  if (effectCalled.current) renderAfterCalled.current = true;\n\n  useEffect(() => {\n    // only execute the effect first time around\n    if (!effectCalled.current) {\n      destroyFunc.current = effect();\n      effectCalled.current = true;\n    }\n\n    // this forces one render after the effect is run\n    forceRerender((x) => x + 1);\n\n    return () => {\n      // if the comp didn't render since the useEffect was called,\n      // we know it's the dummy React cycle\n      if (!renderAfterCalled.current) return;\n\n      destroyFunc.current?.();\n    };\n  }, []);\n}\n","import type { ProviderToken } from '@adimm/x-injection';\nimport { useContext } from 'react';\n\nimport type { UseInjectSharedOptions } from '../../types';\nimport { REACT_X_INJECTION_CONTEXT } from '../providers';\n\n/**\n * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.\n *\n * **Note:** _By using this hook, the dependency will be injected on each re-render process._\n * _If you need to inject the dependency only once, you must use the `useInject` hook._\n * _It basically acts like a `Transient` scope, ensuring that a new dependency is injected on each re-render._\n *\n * @param provider The {@link ProviderToken}.\n * @param options See {@link UseInjectSharedOptions}.\n * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.\n */\nexport function useInjectOnRender<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T {\n  const componentModule = useContext(REACT_X_INJECTION_CONTEXT);\n\n  return componentModule.ctx.get(provider, options?.isOptional);\n}\n\nexport type UseInjectOptions = UseInjectSharedOptions & {\n  /** When set to `false` _(default)_ an exception will be thrown when the `providerOrIdentifier` isn't bound. */\n  isOptional?: boolean;\n};\n","import { AppModule } from '@adimm/x-injection';\nimport { createContext } from 'react';\n\nimport type { IComponentProviderModule } from '../../../types';\n\n/**\n * The `React.Context` value to be provided to a `React.Provider`.\n *\n * Its default value is a reference to the {@link AppModule}.\n */\nexport const REACT_X_INJECTION_CONTEXT = createContext<{ ctx: IComponentProviderModule }>(AppModule as any);\n\nexport const REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT = createContext<Map<string, IComponentProviderModule>>(\n  new Map()\n);\n\nexport const REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE = createContext<{ r: number }>({ r: 0 });\n","import { useContext, useMemo } from 'react';\nimport type { Except } from 'type-fest';\n\nimport { useEffectOnce } from '../../../helpers';\nimport type { IComponentProviderModule, IComponentProviderModuleNaked } from '../../../types';\nimport type { ModuleProviderProps } from './models';\nimport {\n  REACT_X_INJECTION_CONTEXT,\n  REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT,\n  REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE,\n} from './react-context';\n\nexport function ModuleProvider({\n  children,\n  module,\n  tryReInitModuleOnMount,\n  disposeModuleOnUnmount,\n}: ModuleProviderProps) {\n  const isAppModule = module.toNaked().isAppModule;\n\n  const moduleCtxReference = {\n    ctx: useMemo(() => {\n      return isAppModule ? module : module.toNaked()._convertToContextualizedComponentInstance();\n    }, [children, module, tryReInitModuleOnMount, disposeModuleOnUnmount]),\n  };\n\n  return (\n    <REACT_X_INJECTION_CONTEXT.Provider value={moduleCtxReference}>\n      <REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE.Provider value={{ r: 0 }}>\n        <XInjectionChildrenRenderer\n          children={children}\n          module={moduleCtxReference}\n          tryReInitModuleOnMount={tryReInitModuleOnMount}\n          disposeModuleOnUnmount={disposeModuleOnUnmount}\n        />\n      </REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE.Provider>\n    </REACT_X_INJECTION_CONTEXT.Provider>\n  );\n}\n\nfunction XInjectionChildrenRenderer({\n  children,\n  module,\n  tryReInitModuleOnMount,\n  disposeModuleOnUnmount = false,\n}: Except<ModuleProviderProps, 'module'> & { module: { ctx: IComponentProviderModule } }) {\n  const componentModuleInstance = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT);\n  const rerenderParentCtx = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE);\n\n  // We use the `useEffectOnce` custom hook in order\n  // to make sure that if the developer is providing the\n  // `tryReInitModuleOnMount` and/or `disposeModuleOnUnmount` options\n  // we do not early dispose the module when React double re-renders the\n  // component while StrictMode is enabled.\n  // This hook guarantees that the same behavior is expected with or without StrictMode.\n  //\n  // https://react.dev/reference/react/StrictMode\n  useEffectOnce(() => {\n    // ON MOUNT\n\n    const moduleNaked = module.ctx.toNaked();\n\n    if (componentModuleInstance) {\n      const contextualizedImportedModules = module.ctx.toNaked().imports.map((importedModule) => {\n        const shouldReplaceImportedModuleWithContextualized =\n          componentModuleInstance.get(importedModule.toString())?.toString() === importedModule.toString();\n\n        /* istanbul ignore next */\n        if (!shouldReplaceImportedModuleWithContextualized)\n          return importedModule as unknown as IComponentProviderModuleNaked;\n\n        return componentModuleInstance.get(importedModule.toString()) as IComponentProviderModuleNaked;\n      });\n\n      if (contextualizedImportedModules.length > 0) {\n        module.ctx.toNaked()._lazyInit({\n          ...module.ctx.toNaked()._initialOptions,\n          imports: contextualizedImportedModules,\n        });\n\n        // This will force the parent to re-render when using the `useRerenderOnChildrenModuleContextLoaded` hook.\n        rerenderParentCtx.r++;\n      }\n    }\n\n    /* istanbul ignore next */\n    if (moduleNaked.isDisposed && tryReInitModuleOnMount) {\n      /* istanbul ignore next */\n      moduleNaked._lazyInit(tryReInitModuleOnMount);\n    }\n\n    return () => {\n      // ON UNMOUNT\n\n      if (!disposeModuleOnUnmount || moduleNaked.isDisposed) return;\n\n      moduleNaked._dispose();\n    };\n  });\n\n  return children;\n}\n","import type { ProviderToken } from '@adimm/x-injection';\n\nimport { useOnce } from '../../helpers';\nimport { useInjectOnRender, type UseInjectOptions } from './use-inject-on-render';\n\n/**\n * React `hook` which can be used inside a component to inject the required {@link provider | dependency}.\n *\n * **Note:** _By using this hook, the dependency will be injected only once after the first component mount process._\n * _If you need to re-inject the dependency on each re-render, you must use the `useInjectOnRender` hook._\n * _It basically acts like a `Request` scope, ensuring that even a `Transient` dependency does not mutate during re-renders._\n *\n * @param provider The {@link ProviderToken}.\n * @param options See {@link UseInjectSharedOptions}.\n * @returns Either the {@link T | dependency} or `undefined` if {@link isOptional} is set to `true`.\n */\nexport function useInject<T>(provider: ProviderToken<T>, options?: UseInjectOptions): T {\n  return useOnce(() => useInjectOnRender(provider, options));\n}\n","import type {\n  ProviderModuleGetManyParam,\n  ProviderModuleGetManySignature,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  ProviderToken,\n} from '@adimm/x-injection';\nimport { useContext } from 'react';\n\nimport type { UseInjectSharedOptions } from '../../types';\nimport { REACT_X_INJECTION_CONTEXT } from '../providers';\n\n/**\n * Can be used to retrieve many resolved `dependencies` from the module container at once.\n *\n * **Note:** _By using this hook, the dependencies will be injected on each re-render process._\n * _If you need to inject the dependencies only once, you must use the `useInjectMany` hook._\n *\n * @param options See {@link UseInjectSharedOptions}.\n * @param deps Either one or more {@link ProviderToken}.\n * @returns Tuple containing the {@link D | dependencies}.\n */\nexport function useInjectManyOnRender<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>({\n  deps,\n}: {\n  deps: [...(D | unknown[])];\n  options?: UseInjectSharedOptions;\n}): ProviderModuleGetManySignature<D> {\n  const componentModule = useContext(REACT_X_INJECTION_CONTEXT);\n\n  return componentModule.ctx.getMany(...deps);\n}\n","import type { ProviderModuleGetManyParam, ProviderModuleGetManySignature, ProviderToken } from '@adimm/x-injection';\n\nimport { useOnce } from '../../helpers';\nimport type { UseInjectSharedOptions } from '../../types';\nimport { useInjectManyOnRender } from './use-inject-many-on-render';\n\n/**\n * Can be used to retrieve many resolved `dependencies` from the module container at once.\n *\n * **Note:** _By using this hook, the dependencies will be injected only once after the first component mount process._\n * _If you need to re-inject the dependencies on each re-render, you must use the `useInjectManyOnRender` hook._\n *\n * @param options See {@link UseInjectSharedOptions}.\n * @param deps Either one or more {@link ProviderToken}.\n * @returns Tuple containing the {@link D | dependencies}.\n */\nexport function useInjectMany<D extends (ProviderModuleGetManyParam<any> | ProviderToken)[]>({\n  deps,\n  options,\n}: {\n  deps: [...(D | unknown[])];\n  options?: UseInjectSharedOptions;\n}): ProviderModuleGetManySignature<D> {\n  return useOnce(() => useInjectManyOnRender({ options, deps }));\n}\n","import { useContext } from 'react';\n\nimport { REACT_X_INJECTION_CONTEXT, REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT } from '../providers';\n\nexport function useExposeComponentModuleContext(): void {\n  const componentModule = useContext(REACT_X_INJECTION_CONTEXT);\n  const exposed = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT);\n\n  exposed.set(componentModule.ctx.toString(), componentModule.ctx);\n}\n","import { useContext, useEffect, useState } from 'react';\n\nimport { REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE } from '../providers';\n\n/**\n * This is an **experimental** hook which can be used to make sure that a component will re-render when a children\n * exposes its internal context module.\n *\n * It works best with the `useInjectOnRender` hook, as it'll re-resolve all the required dependencies\n * of the injected ProviderToken.\n *\n * **Use it carefully as it may lead to unnecessary re-render cycles or it may even not work as expected!**\n * **It's safer to use the `TapIntoComponent` wrapper component with the `contextInstance` to manually inject the**\n * **contextualized dependencies of the children into a parent component service!**\n *\n * @experimental\n */\nexport function useRerenderOnChildrenModuleContextLoaded(): void {\n  const rerenderParentCtx = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE);\n  const [, setRerender] = useState(0);\n\n  useEffect(() => {\n    setRerender((x) => x + 1);\n  }, [rerenderParentCtx.r]);\n}\n","import {\n  InjectionScope,\n  isClass,\n  isClassOrFunction,\n  ProviderModule,\n  ProviderModuleHelpers,\n  type DependencyProvider,\n  type IProviderModuleNaked,\n  type ProviderClassToken,\n  type ProviderModuleOptions,\n  type ProviderValueToken,\n} from '@adimm/x-injection';\n\nimport type { IComponentProviderModule, IComponentProviderModuleNaked } from '../types';\n\n/** A superset of the {@link ProviderModule} used to integrate within a `React` component. */\nexport class ComponentProviderModule extends ProviderModule implements IComponentProviderModule {\n  protected readonly _initializedFromComponent: IComponentProviderModuleNaked['_initializedFromComponent'];\n  protected readonly _initialOptions: IComponentProviderModuleNaked['_initialOptions'];\n\n  constructor(options: ProviderModuleOptions) {\n    super(\n      ProviderModuleHelpers.buildInternalConstructorParams({\n        ...options,\n        // By default components should have all their providers\n        // defined as transient because a component may have more than one instance of itself.\n        defaultScope: options.defaultScope ?? InjectionScope.Transient,\n        identifier: Symbol(`Component${options.identifier.description}`),\n      })\n    );\n\n    this._initializedFromComponent = false;\n    this._initialOptions = options;\n  }\n\n  override toNaked(): IComponentProviderModuleNaked & IProviderModuleNaked {\n    return this as any;\n  }\n\n  /* istanbul ignore next */\n  dispose(): void {\n    this._dispose();\n  }\n\n  /**\n   * **Publicly visible when the instance is casted to {@link IComponentProviderModuleNaked}.**\n   *\n   * See {@link IComponentProviderModuleNaked._convertToContextualizedComponentInstance}.\n   */\n  /* istanbul ignore next */\n  protected _convertToContextualizedComponentInstance(): IComponentProviderModule {\n    if (this.isAppModule || this.isDisposed) return this;\n\n    const contextualizedProviders = this._getProviders().map((provider) => {\n      if (!isClassOrFunction(provider)) {\n        return {\n          ...provider,\n          scope: InjectionScope.Singleton,\n        } as DependencyProvider;\n      }\n\n      if (isClass(provider)) {\n        return {\n          scope: InjectionScope.Singleton,\n          provide: provider,\n          useClass: provider,\n        } as ProviderClassToken<any>;\n      }\n\n      return {\n        provide: provider,\n        useValue: provider,\n      } as ProviderValueToken<any>;\n    });\n\n    const componentModule = new ComponentProviderModule({\n      ...this._initialOptions,\n      providers: contextualizedProviders,\n    });\n\n    //@ts-expect-error Read-only property.\n    componentModule._initializedFromComponent = true;\n\n    return componentModule;\n  }\n}\n","import { useContext, useEffect, useMemo } from 'react';\nimport type { Except } from 'type-fest';\n\nimport { REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT } from '../../providers';\nimport type { TapIntoComponentContextProps } from './interfaces';\n\n/**\n * This component is the standard way to \"tap into\" an instance of the component\n * in order to get access to its scoped module container and its _(exposed)_ dependencies _instances_.\n *\n * @param contextInstance See {@link TapIntoComponentContextProps.contextInstance}.\n * @param exposed See {@link TapIntoComponentContextProps.exposed}.\n */\nexport function TapIntoComponent({ children, contextInstance }: TapIntoComponentContextProps) {\n  const moduleContextMap = useMemo(() => new Map(), []);\n\n  return (\n    <REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT.Provider value={moduleContextMap}>\n      <CtxExposer contextInstance={contextInstance} />\n      {children}\n    </REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT.Provider>\n  );\n}\n\nfunction CtxExposer({ contextInstance }: Except<TapIntoComponentContextProps, 'children'>) {\n  const ctxMap = useContext(REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT);\n\n  useEffect(() => {\n    const fluidSyntax = contextInstance?.(ctxMap);\n    if (!fluidSyntax) return;\n\n    const moduleCtx = ctxMap.get(fluidSyntax.tryGet.toString());\n    /* istanbul ignore next */\n    if (!moduleCtx) return;\n\n    fluidSyntax.thenDo(moduleCtx);\n  }, [ctxMap]);\n\n  return null;\n}\n"],"mappings":"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","names":["useRef","useOnce","fn","ref","useRef","current","value","useEffect","useRef","useState","useEffectOnce","effect","destroyFunc","useRef","undefined","effectCalled","renderAfterCalled","forceRerender","useState","current","useEffect","x","useContext","AppModule","createContext","REACT_X_INJECTION_CONTEXT","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","Map","REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE","r","useContext","useMemo","ModuleProvider","children","module","tryReInitModuleOnMount","disposeModuleOnUnmount","isAppModule","toNaked","moduleCtxReference","ctx","useMemo","_convertToContextualizedComponentInstance","REACT_X_INJECTION_CONTEXT","Provider","value","REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE","r","XInjectionChildrenRenderer","componentModuleInstance","useContext","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","rerenderParentCtx","useEffectOnce","moduleNaked","contextualizedImportedModules","imports","map","importedModule","shouldReplaceImportedModuleWithContextualized","get","toString","length","_lazyInit","_initialOptions","isDisposed","_dispose","useInjectOnRender","provider","options","componentModule","useContext","REACT_X_INJECTION_CONTEXT","ctx","get","isOptional","useInject","provider","options","useOnce","useInjectOnRender","useContext","useInjectManyOnRender","deps","componentModule","useContext","REACT_X_INJECTION_CONTEXT","ctx","getMany","useInjectMany","deps","options","useOnce","useInjectManyOnRender","useContext","useExposeComponentModuleContext","componentModule","useContext","REACT_X_INJECTION_CONTEXT","exposed","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","set","ctx","toString","useContext","useEffect","useState","useRerenderOnChildrenModuleContextLoaded","rerenderParentCtx","useContext","REACT_X_INJECTION_EXPOSED_COMPONENT_RERENDER_ON_CTX_CHANGE","setRerender","useState","useEffect","x","r","InjectionScope","isClass","isClassOrFunction","ProviderModule","ProviderModuleHelpers","ComponentProviderModule","ProviderModule","_initializedFromComponent","_initialOptions","constructor","options","ProviderModuleHelpers","buildInternalConstructorParams","defaultScope","InjectionScope","Transient","identifier","Symbol","description","toNaked","dispose","_dispose","_convertToContextualizedComponentInstance","isAppModule","isDisposed","contextualizedProviders","_getProviders","map","provider","isClassOrFunction","scope","Singleton","isClass","provide","useClass","useValue","componentModule","providers","useContext","useEffect","useMemo","TapIntoComponent","children","contextInstance","moduleContextMap","useMemo","Map","REACT_X_INJECTION_EXPOSED_COMPONENT_MODULE_CONTEXT","Provider","value","CtxExposer","ctxMap","useContext","useEffect","fluidSyntax","moduleCtx","get","tryGet","toString","thenDo"]}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@adimm/x-injection-reactjs",
+  "description": "ReactJS integration of the `xInjection` library.",
+  "version": "0.1.0",
+  "author": "Adi-Marian Mutu",
+  "homepage": "https://github.com/AdiMarianMutu/x-injection-reactjs#readme",
+  "bugs": "https://github.com/AdiMarianMutu/x-injection-reactjs/issues",
+  "keywords": [
+    "inversion of control",
+    "ioc",
+    "di",
+    "dependency injection",
+    "reactjs",
+    "components",
+    "inversify",
+    "nest",
+    "ts",
+    "typescript"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup --config ./config/tsup.config.ts",
+    "docs:build": "typedoc --options ./config/typedoc.json",
+    "docs:serve": "npm run docs:build && http-server ./docs --cors -p 8080 -c-1",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" --config ./config/.eslintrc.cjs",
+    "lint:fix": "npm run lint -- --fix",
+    "prebuild": "rimraf dist",
+    "prepare": "husky install",
+    "pretest": "rimraf coverage",
+    "prettier:format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\" \"config/**/*\" --config config/.prettierrc.cjs",
+    "start": "npm run build && node dist/index.js",
+    "start:watch": "tsup src/index.ts --config ./config/tsup.config.ts --watch --onSuccess 'node dist/index.js'",
+    "test": "jest --config ./config/jest.config.ts",
+    "test:coverage": "npm run test && http-server ./coverage/lcov-report --cors -p 8081 -c-1",
+    "v:bump-patch": "npm version patch -m \"chore: update `package.json` patch version to %s\"",
+    "v:bump-minor": "npm version minor -m \"chore: update `package.json` minor version to %s\"",
+    "v:bump-major": "npm version major -m \"chore: update `package.json` major version %s\""
+  },
+  "dependencies": {
+    "@adimm/x-injection": "^0.4.0",
+    "react": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "^4.4.1",
+    "@swc/core": "^1.11.24",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@tsconfig/node18": "^18.2.4",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.1.2",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.3.1",
+    "http-server": "^14.1.1",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "node-notifier": "^10.0.1",
+    "prettier": "3.2.4",
+    "rimraf": "^5.0.10",
+    "terser": "^5.39.0",
+    "ts-jest": "^29.3.2",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
+    "type-fest": "^4.40.1",
+    "typedoc": "^0.28.4",
+    "typedoc-theme-hierarchy": "^6.0.0",
+    "typescript": "^5.8.3"
+  },
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-gnu": "4.40.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false
+}