react-obsidian/dist/src/injectors/class/ClassInjector.js

Dependency injection framework for React and React Native applications

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const InjectionMetadata_1 = __importDefault(require("./InjectionMetadata"));
const LateInjector_1 = require("./LateInjector");
const ReferenceCounter_1 = __importDefault(require("../../ReferenceCounter"));
class ClassInjector {
    constructor(graphRegistry, injectionMetadata = new InjectionMetadata_1.default()) {
        this.graphRegistry = graphRegistry;
        this.injectionMetadata = injectionMetadata;
    }
    inject(Graph) {
        return (Target) => {
            return new Proxy(Target, this.createProxyHandler(Graph, this.graphRegistry, this.injectionMetadata));
        };
    }
    createProxyHandler(Graph, graphRegistry, injectionMetadata) {
        return new class Handler {
            construct(target, args, newTarget) {
                var _a;
                const isReactClassComponent = (_a = target.prototype) === null || _a === void 0 ? void 0 : _a.isReactComponent;
                const source = isReactClassComponent ? 'lifecycleOwner' : 'classInjection';
                const graph = graphRegistry.resolve(Graph, source, args.length > 0 ? args[0] : undefined);
                if (isReactClassComponent) {
                    ReferenceCounter_1.default.retain(graph);
                }
                Reflect.defineMetadata(LateInjector_1.GRAPH_INSTANCE_NAME_KEY, graph.name, target);
                const argsToInject = this.injectConstructorArgs(args, graph, target);
                graph.onBind(target);
                const createdObject = Reflect.construct(target, argsToInject, newTarget);
                this.injectProperties(target, createdObject, graph);
                const originalComponentWillUnmount = createdObject.componentWillUnmount;
                createdObject.componentWillUnmount = () => {
                    originalComponentWillUnmount === null || originalComponentWillUnmount === void 0 ? void 0 : originalComponentWillUnmount();
                    ReferenceCounter_1.default.release(graph, (g) => graphRegistry.clear(g));
                };
                return createdObject;
            }
            injectConstructorArgs(args, graph, target) {
                const argsToInject = injectionMetadata.getConstructorArgsToInject(target);
                if (!argsToInject.hasArgs())
                    return args;
                return [...args, ...new Array(Math.abs(args.length - argsToInject.size()))].map((value, idx) => {
                    return value !== null && value !== void 0 ? value : graph.retrieve(argsToInject.getProperty(idx));
                });
            }
            injectProperties(target, createdObject, graph) {
                injectionMetadata.getPropertiesToInject(target).forEach((key) => {
                    Reflect.set(createdObject, key, graph.retrieve(key));
                });
            }
        }();
    }
}
exports.default = ClassInjector;
//# sourceMappingURL=ClassInjector.js.map