ditox-react 3.1.0 → 3.3.0

package/README.md

@@ -2,14 +2,14 @@
 
 <img alt="lemon" src="https://raw.githubusercontent.com/mnasyrov/ditox/master/lemon.svg" width="120" />
 
-**Dependency injection container for React.js**
+**Dependency injection helpers for React.js**
 
 Please see the documentation at [ditox.js.org](https://ditox.js.org)
 
-[![npm](https://img.shields.io/npm/v/ditox)](https://www.npmjs.com/package/ditox)
+[![npm](https://img.shields.io/npm/v/ditox-react)](https://www.npmjs.com/package/ditox-react)
 [![stars](https://img.shields.io/github/stars/mnasyrov/ditox)](https://github.com/mnasyrov/ditox/stargazers)
-[![types](https://img.shields.io/npm/types/ditox)](https://www.npmjs.com/package/ditox)
-[![licence](https://img.shields.io/github/license/mnasyrov/ditox)](https://github.com/mnasyrov/ditox/blob/master/LICENSE)
+[![types](https://img.shields.io/npm/types/ditox-react)](https://www.npmjs.com/package/ditox-react)
+[![license](https://img.shields.io/github/license/mnasyrov/ditox)](https://github.com/mnasyrov/ditox/blob/master/LICENSE)
 [![coverage](https://coveralls.io/repos/github/mnasyrov/ditox/badge)](https://coveralls.io/github/mnasyrov/ditox)
 
 ## Installation
@@ -20,14 +20,14 @@ You can use the following command to install this package:
 npm install --save ditox-react
 ```
 
-The packages can be used as [UMD](https://github.com/umdjs/umd) modules. Use
-[jsdelivr.com](https://jsdelivr.com) CDN site to load
+Packages can be used as [UMD](https://github.com/umdjs/umd) modules. Use
+[jsdelivr.com](https://jsdelivr.com) CDN to load
 [ditox](https://www.jsdelivr.com/package/npm/ditox) and
 [ditox-react](https://www.jsdelivr.com/package/npm/ditox-react):
 
 ```html
-<script src="//cdn.jsdelivr.net/npm/ditox/dist/umd/index.js" />
-<script src="//cdn.jsdelivr.net/npm/ditox-react@2.3.0/dist/umd/index.js" />
+<script src="//cdn.jsdelivr.net/npm/ditox/dist/umd/index.js"></script>
+<script src="//cdn.jsdelivr.net/npm/ditox-react/dist/umd/index.js"></script>
 <script>
   const container = Ditox.createContainer();
   // DitoxReact.useDependency(SOME_TOKEN);
@@ -40,20 +40,24 @@ The packages can be used as [UMD](https://github.com/umdjs/umd) modules. Use
 in React apps:
 
 - Components:
-  - `DepencencyContainer` - provides a new or existed container to React
-    components.
-  - `DepencencyModule` - binds a dependency module to a new container.
-  - `CustomDepencencyContainer` - provides an existed dependency container.
+  - `DependencyContainer` — creates and provides a new container to React
+    children. Optionally binds dependencies via a binder callback. Can start a
+    new root container with `root` flag.
+  - `DependencyModule` — binds a dependency module to a new container (supports
+    `scope`: `singleton` (default) or `scoped`).
+  - `CustomDependencyContainer` — provides an existing dependency container.
 - Hooks:
-  - `useDependencyContainer()` - returns a provided dependency container.
-  - `useDependency()` - returns a resolved value by a specified token. It throws
-    an error in case a container or value is not found.
-  - `useOptionalDependency()` - returns a resolved value by a specified token,
-    or returns `undefined` in case a container or value is not found.
+  - `useDependencyContainer(mode?)` — returns a provided dependency container.
+    With `mode = 'strict'` it throws if the container is not provided; by
+    default it returns `undefined` when not provided.
+  - `useDependency(token)` — resolves and returns a value by a specified token.
+    Throws if a container or the value is not found.
+  - `useOptionalDependency(token)` — returns a resolved value by a specified
+    token, or `undefined` if not found or not provided.
 
 ## Usage Examples
 
-```jsx
+```tsx
 import {token} from 'ditox';
 import {
   DependencyContainer,
@@ -62,8 +66,8 @@ import {
   useOptionalDependency,
 } from 'ditox-react';
 
-const FOO_TOKEN = token();
-const BAR_TOKEN = token();
+const FOO_TOKEN = token<string>();
+const BAR_TOKEN = token<string>();
 
 function appDependencyBinder(container) {
   container.bindValue(FOO_TOKEN, 'foo');
@@ -71,15 +75,15 @@ function appDependencyBinder(container) {
 
 function App() {
   return (
-    <DependencyContainer binder={appDependencyBinder}>
+    <DependencyContainer root binder={appDependencyBinder}>
       <NestedComponent />
     </DependencyContainer>
   );
 }
 
 function NestedComponent() {
-  // Get access to the container
-  const container = useDependencyContainer();
+  // Get access to the container (optionally)
+  const container = useDependencyContainer(); // or useDependencyContainer('strict') to enforce presence
 
   // Use a resolved value
   const foo = useDependency(FOO_TOKEN);
@@ -95,21 +99,85 @@ function NestedComponent() {
 }
 ```
 
+### Providing an existing container
+
+```tsx
+import {createContainer, token} from 'ditox';
+import {CustomDependencyContainer, useDependency} from 'ditox-react';
+
+const GREETING_TOKEN = token<string>();
+
+const container = createContainer();
+container.bindValue(GREETING_TOKEN, 'Hello');
+
+function App() {
+  return (
+    <CustomDependencyContainer container={container}>
+      <Greeting />
+    </CustomDependencyContainer>
+  );
+}
+
+function Greeting() {
+  const text = useDependency(GREETING_TOKEN);
+  return <>{text}</>;
+}
+```
+
 ## Dependency Modules
 
-Dependency modules can be provided to the app with `<DependencyModule />`
-component:
+Dependency modules can be provided to the app with the `<DependencyModule />`
+component. You can also specify a binding scope (`singleton` by default or
+`scoped`):
 
 ```tsx
 function App() {
   return (
-    <DependencyModule module={LOGGER_MODULE}>
+    <DependencyModule module={LOGGER_MODULE} scope="singleton">
       <NestedComponent />
     </DependencyModule>
   );
 }
 ```
 
+## API Reference
+
+- Components
+
+  - DependencyContainer(props)
+    - props.children: ReactNode — React children to wrap
+    - props.root?: boolean — if true, create a new root container that does not
+      inherit from any parent container
+    - props.binder?: (container: Container) => unknown — optional callback to
+      set up bindings for the newly created container
+    - Behavior: creates a new container linked to the parent container by
+      default; removes all bindings on unmount
+  - CustomDependencyContainer(props)
+    - props.children: ReactNode — React children to wrap
+    - props.container: Container — an existing container instance to provide
+  - DependencyModule(props)
+    - props.children: ReactNode — React children to wrap
+    - props.module: ModuleDeclaration — module to bind to a new container
+    - props.scope?: 'singleton' | 'scoped' — scope for the module bindings
+      (default: 'singleton')
+
+- Hooks
+  - useDependencyContainer(mode?: 'optional' | 'strict')
+    - Returns the container. In 'strict' mode throws if not provided; in
+      optional mode returns undefined if not provided
+  - useDependency<T>(token: Token<T>): T
+    - Resolves and returns the value; throws if not bound or container is
+      missing
+  - useOptionalDependency<T>(token: Token<T>): T | undefined
+    - Returns the value if bound, otherwise undefined
+
+Notes:
+
+- A parent container (if provided higher in the tree) is used as the parent for
+  new containers created by DependencyContainer and DependencyModule, unless
+  root is set to true.
+- All bindings made inside a DependencyContainer are removed on unmount.
+
 ---
 
 This project is licensed under the

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,33 +1,34 @@
-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
  */
 type DependencyContainerBinder = (container: Container) => unknown;
 /**
- * Specifies an existed container or options for a new container:
- * @property binder - A callback which setup bindings to the container.
+ * Specifies options for a new container:
+ * @property binder - A callback which sets up bindings for the container.
  * @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
  *
- * This component creates a new container and provides it down to React children.
+ * This component creates a new container and provides it to React children.
  *
- * If `binder` callback is specified, it will be called for a new container
- * to binds it with dependencies.
+ * If a `binder` callback is specified, it will be called for the new container
+ * to bind it with dependencies.
  *
- * If a parent container is exist, it is connected to the current one by default.
- * For making a new root container specify `root` parameter as `true`,
+ * 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 setup bindings to the 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
@@ -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 is exist, 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,33 +1,34 @@
-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
  */
 type DependencyContainerBinder = (container: Container) => unknown;
 /**
- * Specifies an existed container or options for a new container:
- * @property binder - A callback which setup bindings to the container.
+ * Specifies options for a new container:
+ * @property binder - A callback which sets up bindings for the container.
  * @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
  *
- * This component creates a new container and provides it down to React children.
+ * This component creates a new container and provides it to React children.
  *
- * If `binder` callback is specified, it will be called for a new container
- * to binds it with dependencies.
+ * If a `binder` callback is specified, it will be called for the new container
+ * to bind it with dependencies.
  *
- * If a parent container is exist, it is connected to the current one by default.
- * For making a new root container specify `root` parameter as `true`,
+ * 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 setup bindings to the 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
@@ -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 is exist, 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