@ts-ioc-container/react 0.5.0

package/cjm/OutOfScopeError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutOfScopeError = void 0;
+class OutOfScopeError extends Error {
+    name = 'OutOfScopeError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, OutOfScopeError.prototype);
+    }
+}
+exports.OutOfScopeError = OutOfScopeError;

package/cjm/ScopeContext.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeContext = void 0;
+exports.useScope = useScope;
+exports.useScopeOrFail = useScopeOrFail;
+exports.useResolveOrFail = useResolveOrFail;
+exports.Scope = Scope;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ts_ioc_container_1 = require("ts-ioc-container");
+const OutOfScopeError_1 = require("./OutOfScopeError");
+exports.ScopeContext = (0, react_1.createContext)(null);
+function useScope() {
+    return (0, react_1.useContext)(exports.ScopeContext);
+}
+function useScopeOrFail() {
+    const container = useScope();
+    if (!container) {
+        throw new OutOfScopeError_1.OutOfScopeError('useScopeOrFail must be called inside ScopeContext.Provider');
+    }
+    return container;
+}
+function useResolveOrFail(key) {
+    const container = useScopeOrFail();
+    if (key instanceof ts_ioc_container_1.InjectionToken) {
+        return key.resolve(container);
+    }
+    return container.resolve(key);
+}
+function Scope(props) {
+    const parent = useScopeOrFail();
+    const [child] = (0, react_1.useState)(() => parent.createScope({ tags: props.tags }));
+    (0, react_1.useEffect)(() => () => child.dispose(), [child]);
+    return (0, jsx_runtime_1.jsx)(exports.ScopeContext.Provider, { value: child, children: props.children });
+}

package/cjm/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutOfScopeError = exports.useScopeOrFail = exports.useScope = exports.useResolveOrFail = exports.ScopeContext = exports.Scope = void 0;
+var ScopeContext_1 = require("./ScopeContext");
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return ScopeContext_1.Scope; } });
+Object.defineProperty(exports, "ScopeContext", { enumerable: true, get: function () { return ScopeContext_1.ScopeContext; } });
+Object.defineProperty(exports, "useResolveOrFail", { enumerable: true, get: function () { return ScopeContext_1.useResolveOrFail; } });
+Object.defineProperty(exports, "useScope", { enumerable: true, get: function () { return ScopeContext_1.useScope; } });
+Object.defineProperty(exports, "useScopeOrFail", { enumerable: true, get: function () { return ScopeContext_1.useScopeOrFail; } });
+var OutOfScopeError_1 = require("./OutOfScopeError");
+Object.defineProperty(exports, "OutOfScopeError", { enumerable: true, get: function () { return OutOfScopeError_1.OutOfScopeError; } });

package/esm/OutOfScopeError.js

@@ -0,0 +1,7 @@
+export class OutOfScopeError extends Error {
+    name = 'OutOfScopeError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, OutOfScopeError.prototype);
+    }
+}

package/esm/ScopeContext.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { InjectionToken } from 'ts-ioc-container';
+import { OutOfScopeError } from './OutOfScopeError.js';
+export const ScopeContext = createContext(null);
+export function useScope() {
+    return useContext(ScopeContext);
+}
+export function useScopeOrFail() {
+    const container = useScope();
+    if (!container) {
+        throw new OutOfScopeError('useScopeOrFail must be called inside ScopeContext.Provider');
+    }
+    return container;
+}
+export function useResolveOrFail(key) {
+    const container = useScopeOrFail();
+    if (key instanceof InjectionToken) {
+        return key.resolve(container);
+    }
+    return container.resolve(key);
+}
+export function Scope(props) {
+    const parent = useScopeOrFail();
+    const [child] = useState(() => parent.createScope({ tags: props.tags }));
+    useEffect(() => () => child.dispose(), [child]);
+    return _jsx(ScopeContext.Provider, { value: child, children: props.children });
+}

package/esm/index.js

@@ -0,0 +1,2 @@
+export { Scope, ScopeContext, useResolveOrFail, useScope, useScopeOrFail } from './ScopeContext.js';
+export { OutOfScopeError } from './OutOfScopeError.js';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@ts-ioc-container/react",
+  "version": "0.5.0",
+  "description": "React bindings for ts-ioc-container: a Scope component that maps container scopes onto the component tree, plus hooks to resolve from the surrounding scope.",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": "ibabkin <igba14@gmail.com>",
+  "homepage": "https://igorbabkin.github.io/ts-ioc-container",
+  "license": "ISC",
+  "sideEffects": false,
+  "main": "cjm/index.js",
+  "types": "typings/index.d.ts",
+  "module": "esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "react",
+    "dependency-injection",
+    "inversion-of-control",
+    "container",
+    "ioc",
+    "di",
+    "scope",
+    "scoped-dependencies",
+    "hooks",
+    "ts-ioc-container"
+  ],
+  "files": [
+    "cjm/**/*",
+    "esm/**/*",
+    "typings/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IgorBabkin/ts-ioc-container",
+    "directory": "packages/react"
+  },
+  "scripts": {
+    "build:cjm": "node ../scripts/build.mjs cjm",
+    "build:esm": "node ../scripts/build.mjs esm",
+    "build:types": "node ../scripts/build.mjs types",
+    "build": "run-p build:*",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage --coverage.reporter=lcov",
+    "check:format": "prettier --check \"lib/**/*.ts\" \"lib/**/*.tsx\" \"__tests__/**/*.tsx\"",
+    "check:type": "tsc --noEmit",
+    "check:lint": "eslint lib/**/*.tsx lib/**/*.ts __tests__/**/*.tsx",
+    "check": "run-s check:*"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "ts-ioc-container": ">=56"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.0",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "jsdom": "^27.0.0",
+    "npm-run-all":"^4.1.5",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "reflect-metadata": "^0.2.2",
+    "ts-ioc-container": "56.0.0",
+    "typescript": "5.8.3",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.2"
+  },
+  "engines": {
+    "node": ">= 18"
+  }
+}

package/typings/OutOfScopeError.d.ts

@@ -0,0 +1,4 @@
+export declare class OutOfScopeError extends Error {
+    name: string;
+    constructor(message: string);
+}

package/typings/ScopeContext.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import { type constructor, type IContainer, InjectionToken } from 'ts-ioc-container';
+export declare const ScopeContext: import("react").Context<IContainer | null>;
+export declare function useScope(): IContainer | null;
+export declare function useScopeOrFail(): IContainer;
+export declare function useResolveOrFail<T>(key: InjectionToken<T> | constructor<T>): T;
+interface ScopeProps {
+    tags: string[];
+    children: ReactNode;
+}
+export declare function Scope(props: ScopeProps): import("react").JSX.Element;
+export {};

package/typings/index.d.ts

@@ -0,0 +1,2 @@
+export { Scope, ScopeContext, useResolveOrFail, useScope, useScopeOrFail } from './ScopeContext.js';
+export { OutOfScopeError } from './OutOfScopeError.js';