ditox-react 3.2.0 → 3.3.0

package/dist/index.cjs

@@ -0,0 +1,175 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let ditox = require("ditox");
+let react = require("react");
+react = __toESM(react);
+
+//#region src/DependencyContainer.tsx
+const DependencyContainerContext = (0, react.createContext)(void 0);
+/**
+* Provides a new dependency container to React app
+*
+* This component creates a new container and provides it to React children.
+*
+* If a `binder` callback is specified, it will be called for the new container
+* to bind it with dependencies.
+*
+* If a parent container exists, it is connected to the current one by default.
+* To create a root container specify `root` parameter as `true`,
+* and the container will not depend on any parent container.
+*
+* @param params.binder - A callback which sets up bindings for the container.
+* @param params.root - If `true` then a new container does not depend on any parent containers
+*
+* @example
+*
+* ```tsx
+* const TOKEN = token();
+*
+* function appDependencyBinder(container: Container) {
+*   container.bindValue(TOKEN, 'value');
+* }
+*
+* function App() {
+*   return (
+*     <DependencyContainer root binder={appDependencyBinder}>
+*       <NestedComponent />
+*     </DependencyContainer>
+*   );
+* }
+* ```
+*
+*/
+function DependencyContainer(params) {
+	const { children, root, binder } = params;
+	const parentContainer = (0, react.useContext)(DependencyContainerContext);
+	const container = (0, react.useMemo)(() => {
+		const container = (0, ditox.createContainer)(root ? void 0 : parentContainer);
+		binder === null || binder === void 0 || binder(container);
+		return container;
+	}, [
+		binder,
+		parentContainer,
+		root
+	]);
+	(0, react.useEffect)(() => {
+		return () => container.removeAll();
+	}, [container]);
+	return /* @__PURE__ */ react.default.createElement(DependencyContainerContext.Provider, { value: container }, children);
+}
+/**
+* Provides a custom dependency container to React app
+*
+* @param params.container - a custom container
+*
+* @example
+* ```tsx
+* const container = useMemo(() => {
+*   return createContainer();
+* });
+*
+* return (
+*   <CustomDependencyContainer container={container}>
+*     {children}
+*   </CustomDependencyContainer>
+* );
+* ```
+*/
+function CustomDependencyContainer(params) {
+	const { children, container } = params;
+	return /* @__PURE__ */ react.default.createElement(DependencyContainerContext.Provider, { value: container }, children);
+}
+
+//#endregion
+//#region src/DependencyModule.tsx
+/**
+* Binds the module to a new dependency container.
+*
+* If a parent container exists, it is connected to the current one by default.
+*
+* @param params.module - Module declaration for binding
+* @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.
+*
+* @example
+*
+* ```tsx
+* const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {};
+*
+* function App() {
+*   return (
+*     <DependencyModule module={LOGGER_MODULE}>
+*       <NestedComponent />
+*     </DependencyModule>
+*   );
+* }
+* ```
+*/
+function DependencyModule(params) {
+	const { children, module, scope } = params;
+	const binder = (0, react.useCallback)((container) => (0, ditox.bindModule)(container, module, { scope }), [module, scope]);
+	return /* @__PURE__ */ react.default.createElement(DependencyContainer, { binder }, children);
+}
+
+//#endregion
+//#region src/hooks.ts
+/**
+* @internal
+*/
+function useDependencyContainer(mode) {
+	const container = (0, react.useContext)(DependencyContainerContext);
+	if (!container && mode === "strict") throw new Error("Container is not provided by DependencyContainer component");
+	return container;
+}
+/**
+* @category Hook
+*
+* Returns a dependency by token, or fails with an error.
+*/
+function useDependency(token) {
+	const container = useDependencyContainer("strict");
+	return (0, react.useMemo)(() => container.resolve(token), [container, token]);
+}
+/**
+* @category Hook
+*
+* Returns a dependency by token, or `undefined` in case the dependency is not provided.
+*/
+function useOptionalDependency(token) {
+	const container = useDependencyContainer();
+	return (0, react.useMemo)(() => container === null || container === void 0 ? void 0 : container.get(token), [container, token]);
+}
+
+//#endregion
+exports.CustomDependencyContainer = CustomDependencyContainer;
+exports.DependencyContainer = DependencyContainer;
+exports.DependencyModule = DependencyModule;
+exports.useDependency = useDependency;
+exports.useDependencyContainer = useDependencyContainer;
+exports.useOptionalDependency = useOptionalDependency;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/DependencyContainer.tsx","../src/DependencyModule.tsx","../src/hooks.ts"],"sourcesContent":["import type { Container } from 'ditox';\nimport { createContainer } from 'ditox';\nimport React, {\n  createContext,\n  ReactElement,\n  ReactNode,\n  useContext,\n  useEffect,\n  useMemo,\n} from 'react';\n\nexport const DependencyContainerContext = createContext<Container | undefined>(\n  undefined,\n);\n\n/**\n * A callback for binding dependencies to a container\n */\nexport type DependencyContainerBinder = (container: Container) => unknown;\n\n/**\n * Specifies options for a new container:\n * @property binder - A callback which sets up bindings for the container.\n * @property root - If `true` then a new container does not depend on any parent containers\n */\nexport type DependencyContainerParams = {\n  children: ReactNode;\n  root?: boolean;\n  binder?: DependencyContainerBinder;\n};\n\n/**\n * Provides a new dependency container to React app\n *\n * This component creates a new container and provides it to React children.\n *\n * If a `binder` callback is specified, it will be called for the new container\n * to bind it with dependencies.\n *\n * If a parent container exists, it is connected to the current one by default.\n * To create a root container specify `root` parameter as `true`,\n * and the container will not depend on any parent container.\n *\n * @param params.binder - A callback which sets up bindings for the container.\n * @param params.root - If `true` then a new container does not depend on any parent containers\n *\n * @example\n *\n * ```tsx\n * const TOKEN = token();\n *\n * function appDependencyBinder(container: Container) {\n *   container.bindValue(TOKEN, 'value');\n * }\n *\n * function App() {\n *   return (\n *     <DependencyContainer root binder={appDependencyBinder}>\n *       <NestedComponent />\n *     </DependencyContainer>\n *   );\n * }\n * ```\n *\n */\nexport function DependencyContainer(\n  params: DependencyContainerParams,\n): ReactElement {\n  const { children, root, binder } = params;\n  const parentContainer = useContext(DependencyContainerContext);\n\n  const container = useMemo(() => {\n    const container = createContainer(root ? undefined : parentContainer);\n    binder?.(container);\n\n    return container;\n  }, [binder, parentContainer, root]);\n\n  useEffect(() => {\n    return () => container.removeAll();\n  }, [container]);\n\n  return (\n    <DependencyContainerContext.Provider value={container}>\n      {children}\n    </DependencyContainerContext.Provider>\n  );\n}\n\n/**\n * Provides a custom dependency container to React app\n *\n * @param params.container - a custom container\n *\n * @example\n * ```tsx\n * const container = useMemo(() => {\n *   return createContainer();\n * });\n *\n * return (\n *   <CustomDependencyContainer container={container}>\n *     {children}\n *   </CustomDependencyContainer>\n * );\n * ```\n */\nexport function CustomDependencyContainer(params: {\n  children: ReactNode;\n  container: Container;\n}): ReactElement {\n  const { children, container } = params;\n\n  return (\n    <DependencyContainerContext.Provider value={container}>\n      {children}\n    </DependencyContainerContext.Provider>\n  );\n}\n","import type { Module, ModuleDeclaration } from 'ditox';\nimport { bindModule } from 'ditox';\nimport React, { ReactElement, ReactNode, useCallback } from 'react';\nimport {\n  DependencyContainer,\n  DependencyContainerBinder,\n} from './DependencyContainer';\n\n/**\n * Binds the module to a new dependency container.\n *\n * If a parent container exists, it is connected to the current one by default.\n *\n * @param params.module - Module declaration for binding\n * @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.\n *\n * @example\n *\n * ```tsx\n * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {};\n *\n * function App() {\n *   return (\n *     <DependencyModule module={LOGGER_MODULE}>\n *       <NestedComponent />\n *     </DependencyModule>\n *   );\n * }\n * ```\n */\nexport function DependencyModule(params: {\n  children: ReactNode;\n  module: ModuleDeclaration<Module<Record<string, unknown>>>;\n  scope?: 'scoped' | 'singleton';\n}): ReactElement {\n  const { children, module, scope } = params;\n\n  const binder: DependencyContainerBinder = useCallback(\n    (container) => bindModule(container, module, { scope }),\n    [module, scope],\n  );\n\n  return <DependencyContainer binder={binder}>{children}</DependencyContainer>;\n}\n","import { Container, Token } from 'ditox';\nimport { useContext, useMemo } from 'react';\nimport { DependencyContainerContext } from './DependencyContainer';\n\n/**\n * @category Hook\n *\n * Returns a dependency container. Throws an error in case the container is not provided.\n */\nexport function useDependencyContainer(mode: 'strict'): Container;\n/**\n * @category Hook\n *\n * Returns a dependency container, or `undefined` in case the container is not provided.\n */\nexport function useDependencyContainer(\n  mode?: 'optional',\n): Container | undefined;\n/**\n * @internal\n */\nexport function useDependencyContainer(\n  mode?: 'strict' | 'optional',\n): Container | undefined {\n  const container = useContext(DependencyContainerContext);\n\n  if (!container && mode === 'strict') {\n    throw new Error(\n      'Container is not provided by DependencyContainer component',\n    );\n  }\n\n  return container;\n}\n\n/**\n * @category Hook\n *\n * Returns a dependency by token, or fails with an error.\n */\nexport function useDependency<T>(token: Token<T>): T {\n  const container = useDependencyContainer('strict');\n  const value = useMemo(() => container.resolve(token), [container, token]);\n  return value;\n}\n\n/**\n * @category Hook\n *\n * Returns a dependency by token, or `undefined` in case the dependency is not provided.\n */\nexport function useOptionalDependency<T>(token: Token<T>): T | undefined {\n  const container = useDependencyContainer();\n  const value = useMemo(() => container?.get(token), [container, token]);\n  return value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,MAAa,sDACX,OACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,oBACd,QACc;CACd,MAAM,EAAE,UAAU,MAAM,WAAW;CACnC,MAAM,wCAA6B,2BAA2B;CAE9D,MAAM,qCAA0B;EAC9B,MAAM,uCAA4B,OAAO,SAAY,gBAAgB;AACrE,iDAAS,UAAU;AAEnB,SAAO;IACN;EAAC;EAAQ;EAAiB;EAAK,CAAC;AAEnC,4BAAgB;AACd,eAAa,UAAU,WAAW;IACjC,CAAC,UAAU,CAAC;AAEf,QACE,4CAAC,2BAA2B,YAAS,OAAO,aACzC,SACmC;;;;;;;;;;;;;;;;;;;;AAsB1C,SAAgB,0BAA0B,QAGzB;CACf,MAAM,EAAE,UAAU,cAAc;AAEhC,QACE,4CAAC,2BAA2B,YAAS,OAAO,aACzC,SACmC;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtF1C,SAAgB,iBAAiB,QAIhB;CACf,MAAM,EAAE,UAAU,QAAQ,UAAU;CAEpC,MAAM,iCACH,oCAAyB,WAAW,QAAQ,EAAE,OAAO,CAAC,EACvD,CAAC,QAAQ,MAAM,CAChB;AAED,QAAO,4CAAC,uBAA4B,UAAS,SAA+B;;;;;;;;ACrB9E,SAAgB,uBACd,MACuB;CACvB,MAAM,kCAAuB,2BAA2B;AAExD,KAAI,CAAC,aAAa,SAAS,SACzB,OAAM,IAAI,MACR,6DACD;AAGH,QAAO;;;;;;;AAQT,SAAgB,cAAiB,OAAoB;CACnD,MAAM,YAAY,uBAAuB,SAAS;AAElD,iCAD4B,UAAU,QAAQ,MAAM,EAAE,CAAC,WAAW,MAAM,CAAC;;;;;;;AAS3E,SAAgB,sBAAyB,OAAgC;CACvE,MAAM,YAAY,wBAAwB;AAE1C,uFAD4B,UAAW,IAAI,MAAM,EAAE,CAAC,WAAW,MAAM,CAAC"}

package/dist/{browser/index.d.ts → index.d.cts}

@@ -1,6 +1,7 @@
-import { Container, Token, ModuleDeclaration, Module } from 'ditox';
-import { ReactNode, ReactElement } from 'react';
+import { Container, Module, ModuleDeclaration, Token } from "ditox";
+import { ReactElement, ReactNode } from "react";
 
+//#region src/DependencyContainer.d.ts
 /**
  * A callback for binding dependencies to a container
  */
@@ -11,9 +12,9 @@ type DependencyContainerBinder = (container: Container) => unknown;
  * @property root - If `true` then a new container does not depend on any parent containers
  */
 type DependencyContainerParams = {
-    children: ReactNode;
-    root?: boolean;
-    binder?: DependencyContainerBinder;
+  children: ReactNode;
+  root?: boolean;
+  binder?: DependencyContainerBinder;
 };
 /**
  * Provides a new dependency container to React app
@@ -59,7 +60,7 @@ declare function DependencyContainer(params: DependencyContainerParams): ReactEl
  * ```tsx
  * const container = useMemo(() => {
  *   return createContainer();
- * }
+ * });
  *
  * return (
  *   <CustomDependencyContainer container={container}>
@@ -69,10 +70,40 @@ declare function DependencyContainer(params: DependencyContainerParams): ReactEl
  * ```
  */
 declare function CustomDependencyContainer(params: {
-    children: ReactNode;
-    container: Container;
+  children: ReactNode;
+  container: Container;
 }): ReactElement;
-
+//#endregion
+//#region src/DependencyModule.d.ts
+/**
+ * Binds the module to a new dependency container.
+ *
+ * If a parent container exists, it is connected to the current one by default.
+ *
+ * @param params.module - Module declaration for binding
+ * @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.
+ *
+ * @example
+ *
+ * ```tsx
+ * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {};
+ *
+ * function App() {
+ *   return (
+ *     <DependencyModule module={LOGGER_MODULE}>
+ *       <NestedComponent />
+ *     </DependencyModule>
+ *   );
+ * }
+ * ```
+ */
+declare function DependencyModule(params: {
+  children: ReactNode;
+  module: ModuleDeclaration<Module<Record<string, unknown>>>;
+  scope?: 'scoped' | 'singleton';
+}): ReactElement;
+//#endregion
+//#region src/hooks.d.ts
 /**
  * @category Hook
  *
@@ -97,33 +128,6 @@ declare function useDependency<T>(token: Token<T>): T;
  * Returns a dependency by token, or `undefined` in case the dependency is not provided.
  */
 declare function useOptionalDependency<T>(token: Token<T>): T | undefined;
-
-/**
- * Binds the module to a new dependency container.
- *
- * If a parent container exists, it is connected to the current one by default.
- *
- * @param params.module - Module declaration for binding
- * @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.
- *
- * @example
- *
- * ```tsx
- * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {
- *
- * function App() {
- *   return (
- *     <DependencyModule module={LOGGER_MODULE}>
- *       <NestedComponent />
- *     </DependencyModule>
- *   );
- * }
- * ```
- */
-declare function DependencyModule(params: {
-    children: ReactNode;
-    module: ModuleDeclaration<Module<Record<string, unknown>>>;
-    scope?: 'scoped' | 'singleton';
-}): ReactElement;
-
-export { CustomDependencyContainer, DependencyContainer, DependencyContainerBinder, DependencyContainerParams, DependencyModule, useDependency, useDependencyContainer, useOptionalDependency };
+//#endregion
+export { CustomDependencyContainer, DependencyContainer, type DependencyContainerBinder, type DependencyContainerParams, DependencyModule, useDependency, useDependencyContainer, useOptionalDependency };
+//# sourceMappingURL=index.d.cts.map

package/dist/{umd/index.d.ts → index.d.ts}

@@ -1,6 +1,7 @@
-import { Container, Token, ModuleDeclaration, Module } from 'ditox';
-import { ReactNode, ReactElement } from 'react';
+import { Container, Module, ModuleDeclaration, Token } from "ditox";
+import React, { ReactElement, ReactNode } from "react";
 
+//#region src/DependencyContainer.d.ts
 /**
  * A callback for binding dependencies to a container
  */
@@ -11,9 +12,9 @@ type DependencyContainerBinder = (container: Container) => unknown;
  * @property root - If `true` then a new container does not depend on any parent containers
  */
 type DependencyContainerParams = {
-    children: ReactNode;
-    root?: boolean;
-    binder?: DependencyContainerBinder;
+  children: ReactNode;
+  root?: boolean;
+  binder?: DependencyContainerBinder;
 };
 /**
  * Provides a new dependency container to React app
@@ -59,7 +60,7 @@ declare function DependencyContainer(params: DependencyContainerParams): ReactEl
  * ```tsx
  * const container = useMemo(() => {
  *   return createContainer();
- * }
+ * });
  *
  * return (
  *   <CustomDependencyContainer container={container}>
@@ -69,10 +70,40 @@ declare function DependencyContainer(params: DependencyContainerParams): ReactEl
  * ```
  */
 declare function CustomDependencyContainer(params: {
-    children: ReactNode;
-    container: Container;
+  children: ReactNode;
+  container: Container;
 }): ReactElement;
-
+//#endregion
+//#region src/DependencyModule.d.ts
+/**
+ * Binds the module to a new dependency container.
+ *
+ * If a parent container exists, it is connected to the current one by default.
+ *
+ * @param params.module - Module declaration for binding
+ * @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.
+ *
+ * @example
+ *
+ * ```tsx
+ * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {};
+ *
+ * function App() {
+ *   return (
+ *     <DependencyModule module={LOGGER_MODULE}>
+ *       <NestedComponent />
+ *     </DependencyModule>
+ *   );
+ * }
+ * ```
+ */
+declare function DependencyModule(params: {
+  children: ReactNode;
+  module: ModuleDeclaration<Module<Record<string, unknown>>>;
+  scope?: 'scoped' | 'singleton';
+}): ReactElement;
+//#endregion
+//#region src/hooks.d.ts
 /**
  * @category Hook
  *
@@ -97,33 +128,6 @@ declare function useDependency<T>(token: Token<T>): T;
  * Returns a dependency by token, or `undefined` in case the dependency is not provided.
  */
 declare function useOptionalDependency<T>(token: Token<T>): T | undefined;
-
-/**
- * Binds the module to a new dependency container.
- *
- * If a parent container exists, it is connected to the current one by default.
- *
- * @param params.module - Module declaration for binding
- * @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.
- *
- * @example
- *
- * ```tsx
- * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {
- *
- * function App() {
- *   return (
- *     <DependencyModule module={LOGGER_MODULE}>
- *       <NestedComponent />
- *     </DependencyModule>
- *   );
- * }
- * ```
- */
-declare function DependencyModule(params: {
-    children: ReactNode;
-    module: ModuleDeclaration<Module<Record<string, unknown>>>;
-    scope?: 'scoped' | 'singleton';
-}): ReactElement;
-
-export { CustomDependencyContainer, DependencyContainer, DependencyContainerBinder, DependencyContainerParams, DependencyModule, useDependency, useDependencyContainer, useOptionalDependency };
+//#endregion
+export { CustomDependencyContainer, DependencyContainer, type DependencyContainerBinder, type DependencyContainerParams, DependencyModule, useDependency, useDependencyContainer, useOptionalDependency };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,141 @@
+import { bindModule, createContainer } from "ditox";
+import React, { createContext, useCallback, useContext, useEffect, useMemo } from "react";
+
+//#region src/DependencyContainer.tsx
+const DependencyContainerContext = createContext(void 0);
+/**
+* Provides a new dependency container to React app
+*
+* This component creates a new container and provides it to React children.
+*
+* If a `binder` callback is specified, it will be called for the new container
+* to bind it with dependencies.
+*
+* If a parent container exists, it is connected to the current one by default.
+* To create a root container specify `root` parameter as `true`,
+* and the container will not depend on any parent container.
+*
+* @param params.binder - A callback which sets up bindings for the container.
+* @param params.root - If `true` then a new container does not depend on any parent containers
+*
+* @example
+*
+* ```tsx
+* const TOKEN = token();
+*
+* function appDependencyBinder(container: Container) {
+*   container.bindValue(TOKEN, 'value');
+* }
+*
+* function App() {
+*   return (
+*     <DependencyContainer root binder={appDependencyBinder}>
+*       <NestedComponent />
+*     </DependencyContainer>
+*   );
+* }
+* ```
+*
+*/
+function DependencyContainer(params) {
+	const { children, root, binder } = params;
+	const parentContainer = useContext(DependencyContainerContext);
+	const container = useMemo(() => {
+		const container = createContainer(root ? void 0 : parentContainer);
+		binder === null || binder === void 0 || binder(container);
+		return container;
+	}, [
+		binder,
+		parentContainer,
+		root
+	]);
+	useEffect(() => {
+		return () => container.removeAll();
+	}, [container]);
+	return /* @__PURE__ */ React.createElement(DependencyContainerContext.Provider, { value: container }, children);
+}
+/**
+* Provides a custom dependency container to React app
+*
+* @param params.container - a custom container
+*
+* @example
+* ```tsx
+* const container = useMemo(() => {
+*   return createContainer();
+* });
+*
+* return (
+*   <CustomDependencyContainer container={container}>
+*     {children}
+*   </CustomDependencyContainer>
+* );
+* ```
+*/
+function CustomDependencyContainer(params) {
+	const { children, container } = params;
+	return /* @__PURE__ */ React.createElement(DependencyContainerContext.Provider, { value: container }, children);
+}
+
+//#endregion
+//#region src/DependencyModule.tsx
+/**
+* Binds the module to a new dependency container.
+*
+* If a parent container exists, it is connected to the current one by default.
+*
+* @param params.module - Module declaration for binding
+* @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.
+*
+* @example
+*
+* ```tsx
+* const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {};
+*
+* function App() {
+*   return (
+*     <DependencyModule module={LOGGER_MODULE}>
+*       <NestedComponent />
+*     </DependencyModule>
+*   );
+* }
+* ```
+*/
+function DependencyModule(params) {
+	const { children, module, scope } = params;
+	const binder = useCallback((container) => bindModule(container, module, { scope }), [module, scope]);
+	return /* @__PURE__ */ React.createElement(DependencyContainer, { binder }, children);
+}
+
+//#endregion
+//#region src/hooks.ts
+/**
+* @internal
+*/
+function useDependencyContainer(mode) {
+	const container = useContext(DependencyContainerContext);
+	if (!container && mode === "strict") throw new Error("Container is not provided by DependencyContainer component");
+	return container;
+}
+/**
+* @category Hook
+*
+* Returns a dependency by token, or fails with an error.
+*/
+function useDependency(token) {
+	const container = useDependencyContainer("strict");
+	return useMemo(() => container.resolve(token), [container, token]);
+}
+/**
+* @category Hook
+*
+* Returns a dependency by token, or `undefined` in case the dependency is not provided.
+*/
+function useOptionalDependency(token) {
+	const container = useDependencyContainer();
+	return useMemo(() => container === null || container === void 0 ? void 0 : container.get(token), [container, token]);
+}
+
+//#endregion
+export { CustomDependencyContainer, DependencyContainer, DependencyModule, useDependency, useDependencyContainer, useOptionalDependency };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/DependencyContainer.tsx","../src/DependencyModule.tsx","../src/hooks.ts"],"sourcesContent":["import type { Container } from 'ditox';\nimport { createContainer } from 'ditox';\nimport React, {\n  createContext,\n  ReactElement,\n  ReactNode,\n  useContext,\n  useEffect,\n  useMemo,\n} from 'react';\n\nexport const DependencyContainerContext = createContext<Container | undefined>(\n  undefined,\n);\n\n/**\n * A callback for binding dependencies to a container\n */\nexport type DependencyContainerBinder = (container: Container) => unknown;\n\n/**\n * Specifies options for a new container:\n * @property binder - A callback which sets up bindings for the container.\n * @property root - If `true` then a new container does not depend on any parent containers\n */\nexport type DependencyContainerParams = {\n  children: ReactNode;\n  root?: boolean;\n  binder?: DependencyContainerBinder;\n};\n\n/**\n * Provides a new dependency container to React app\n *\n * This component creates a new container and provides it to React children.\n *\n * If a `binder` callback is specified, it will be called for the new container\n * to bind it with dependencies.\n *\n * If a parent container exists, it is connected to the current one by default.\n * To create a root container specify `root` parameter as `true`,\n * and the container will not depend on any parent container.\n *\n * @param params.binder - A callback which sets up bindings for the container.\n * @param params.root - If `true` then a new container does not depend on any parent containers\n *\n * @example\n *\n * ```tsx\n * const TOKEN = token();\n *\n * function appDependencyBinder(container: Container) {\n *   container.bindValue(TOKEN, 'value');\n * }\n *\n * function App() {\n *   return (\n *     <DependencyContainer root binder={appDependencyBinder}>\n *       <NestedComponent />\n *     </DependencyContainer>\n *   );\n * }\n * ```\n *\n */\nexport function DependencyContainer(\n  params: DependencyContainerParams,\n): ReactElement {\n  const { children, root, binder } = params;\n  const parentContainer = useContext(DependencyContainerContext);\n\n  const container = useMemo(() => {\n    const container = createContainer(root ? undefined : parentContainer);\n    binder?.(container);\n\n    return container;\n  }, [binder, parentContainer, root]);\n\n  useEffect(() => {\n    return () => container.removeAll();\n  }, [container]);\n\n  return (\n    <DependencyContainerContext.Provider value={container}>\n      {children}\n    </DependencyContainerContext.Provider>\n  );\n}\n\n/**\n * Provides a custom dependency container to React app\n *\n * @param params.container - a custom container\n *\n * @example\n * ```tsx\n * const container = useMemo(() => {\n *   return createContainer();\n * });\n *\n * return (\n *   <CustomDependencyContainer container={container}>\n *     {children}\n *   </CustomDependencyContainer>\n * );\n * ```\n */\nexport function CustomDependencyContainer(params: {\n  children: ReactNode;\n  container: Container;\n}): ReactElement {\n  const { children, container } = params;\n\n  return (\n    <DependencyContainerContext.Provider value={container}>\n      {children}\n    </DependencyContainerContext.Provider>\n  );\n}\n","import type { Module, ModuleDeclaration } from 'ditox';\nimport { bindModule } from 'ditox';\nimport React, { ReactElement, ReactNode, useCallback } from 'react';\nimport {\n  DependencyContainer,\n  DependencyContainerBinder,\n} from './DependencyContainer';\n\n/**\n * Binds the module to a new dependency container.\n *\n * If a parent container exists, it is connected to the current one by default.\n *\n * @param params.module - Module declaration for binding\n * @param params.scope - Optional scope for binding: `singleton` (default) or `scoped`.\n *\n * @example\n *\n * ```tsx\n * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {};\n *\n * function App() {\n *   return (\n *     <DependencyModule module={LOGGER_MODULE}>\n *       <NestedComponent />\n *     </DependencyModule>\n *   );\n * }\n * ```\n */\nexport function DependencyModule(params: {\n  children: ReactNode;\n  module: ModuleDeclaration<Module<Record<string, unknown>>>;\n  scope?: 'scoped' | 'singleton';\n}): ReactElement {\n  const { children, module, scope } = params;\n\n  const binder: DependencyContainerBinder = useCallback(\n    (container) => bindModule(container, module, { scope }),\n    [module, scope],\n  );\n\n  return <DependencyContainer binder={binder}>{children}</DependencyContainer>;\n}\n","import { Container, Token } from 'ditox';\nimport { useContext, useMemo } from 'react';\nimport { DependencyContainerContext } from './DependencyContainer';\n\n/**\n * @category Hook\n *\n * Returns a dependency container. Throws an error in case the container is not provided.\n */\nexport function useDependencyContainer(mode: 'strict'): Container;\n/**\n * @category Hook\n *\n * Returns a dependency container, or `undefined` in case the container is not provided.\n */\nexport function useDependencyContainer(\n  mode?: 'optional',\n): Container | undefined;\n/**\n * @internal\n */\nexport function useDependencyContainer(\n  mode?: 'strict' | 'optional',\n): Container | undefined {\n  const container = useContext(DependencyContainerContext);\n\n  if (!container && mode === 'strict') {\n    throw new Error(\n      'Container is not provided by DependencyContainer component',\n    );\n  }\n\n  return container;\n}\n\n/**\n * @category Hook\n *\n * Returns a dependency by token, or fails with an error.\n */\nexport function useDependency<T>(token: Token<T>): T {\n  const container = useDependencyContainer('strict');\n  const value = useMemo(() => container.resolve(token), [container, token]);\n  return value;\n}\n\n/**\n * @category Hook\n *\n * Returns a dependency by token, or `undefined` in case the dependency is not provided.\n */\nexport function useOptionalDependency<T>(token: Token<T>): T | undefined {\n  const container = useDependencyContainer();\n  const value = useMemo(() => container?.get(token), [container, token]);\n  return value;\n}\n"],"mappings":";;;;AAWA,MAAa,6BAA6B,cACxC,OACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,oBACd,QACc;CACd,MAAM,EAAE,UAAU,MAAM,WAAW;CACnC,MAAM,kBAAkB,WAAW,2BAA2B;CAE9D,MAAM,YAAY,cAAc;EAC9B,MAAM,YAAY,gBAAgB,OAAO,SAAY,gBAAgB;AACrE,iDAAS,UAAU;AAEnB,SAAO;IACN;EAAC;EAAQ;EAAiB;EAAK,CAAC;AAEnC,iBAAgB;AACd,eAAa,UAAU,WAAW;IACjC,CAAC,UAAU,CAAC;AAEf,QACE,oCAAC,2BAA2B,YAAS,OAAO,aACzC,SACmC;;;;;;;;;;;;;;;;;;;;AAsB1C,SAAgB,0BAA0B,QAGzB;CACf,MAAM,EAAE,UAAU,cAAc;AAEhC,QACE,oCAAC,2BAA2B,YAAS,OAAO,aACzC,SACmC;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtF1C,SAAgB,iBAAiB,QAIhB;CACf,MAAM,EAAE,UAAU,QAAQ,UAAU;CAEpC,MAAM,SAAoC,aACvC,cAAc,WAAW,WAAW,QAAQ,EAAE,OAAO,CAAC,EACvD,CAAC,QAAQ,MAAM,CAChB;AAED,QAAO,oCAAC,uBAA4B,UAAS,SAA+B;;;;;;;;ACrB9E,SAAgB,uBACd,MACuB;CACvB,MAAM,YAAY,WAAW,2BAA2B;AAExD,KAAI,CAAC,aAAa,SAAS,SACzB,OAAM,IAAI,MACR,6DACD;AAGH,QAAO;;;;;;;AAQT,SAAgB,cAAiB,OAAoB;CACnD,MAAM,YAAY,uBAAuB,SAAS;AAElD,QADc,cAAc,UAAU,QAAQ,MAAM,EAAE,CAAC,WAAW,MAAM,CAAC;;;;;;;AAS3E,SAAgB,sBAAyB,OAAgC;CACvE,MAAM,YAAY,wBAAwB;AAE1C,QADc,oEAAc,UAAW,IAAI,MAAM,EAAE,CAAC,WAAW,MAAM,CAAC"}