@rnaga/wp-node/core/components.js

👉 **[View Full Documentation at rnaga.github.io/wp-node →](https://rnaga.github.io/wp-node/)**

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var Components_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Components = void 0;
const constants_1 = require("../constants");
const scope_1 = require("../constants/scope");
const component_1 = require("../decorators/component");
const async_init_reflect_1 = require("./async-init-reflect");
let Components = class Components {
    static { Components_1 = this; }
    env;
    static globalInstanceMap = {};
    instanceMap = new WeakMap();
    constructor(env = "default") {
        this.env = env;
        if (!Components_1.globalInstanceMap[env]) {
            Components_1.globalInstanceMap[env] = new WeakMap();
        }
        this.register(Components_1, this);
    }
    register(target, instance) {
        if (!instance?.__scope) {
            instance.__scope =
                Reflect.getMetadata(constants_1.REFLECT_METADATA_KEY_COMPONENT, target)?.scope ??
                    scope_1.Scope.Context;
        }
        instance.__scope === scope_1.Scope.Context
            ? this.instanceMap.set(target, instance)
            : Components_1.globalInstanceMap[this.env].set(target, instance);
    }
    async asyncGetWithArgs(target, ...args) {
        return this.asyncGet(target, args);
    }
    getWithArgs(target, ...args) {
        return this.get(target, args);
    }
    async asyncGet(target, constructorArgs = [], args = {}) {
        const instance = this.get(target, constructorArgs, args);
        const asyncInit = async_init_reflect_1.AsyncInitReflect.get(instance, target);
        if (!asyncInit) {
            return new Promise((ok) => ok(instance));
        }
        return asyncInit.then(() => instance);
    }
    get(target, constructorArgs = [], args = {}) {
        if (!target) {
            return undefined;
        }
        let componentsOptions = Reflect.getMetadata(constants_1.REFLECT_METADATA_KEY_COMPONENT, target) ?? {};
        args = {
            failFast: false,
            forceToInstantiate: false,
            instantiatedByQueryBuilders: false,
            ...args,
            depth: args?.depth ?? 0,
        };
        if (!args.refList) {
            args.refList = new WeakMap();
        }
        componentsOptions = {
            scope: scope_1.Scope.Context,
            injectable: false,
            ...componentsOptions,
        };
        if (!componentsOptions.injectable) {
            if (!args.failFast) {
                throw new Error(`Target not found`);
            }
            return undefined;
        }
        let instance;
        const instanceMap = (() => {
            if (scope_1.Scope.Transient === componentsOptions.scope) {
                return undefined;
            }
            return scope_1.Scope.Singleton === componentsOptions.scope
                ? Components_1.globalInstanceMap[this.env]
                : this.instanceMap;
        })();
        if (instanceMap) {
            instance = instanceMap.get(target);
            if (instance && !args.forceToInstantiate) {
                return instance;
            }
        }
        const dependencies = Reflect.getMetadata("design:paramtypes", target) || [];
        const instances = [];
        const argsPassedByDecorator = Reflect.getMetadata(constants_1.REFLECT_METADATA_KEY_COMPONENT_ARGUMENTS, target);
        for (const [index, dep] of dependencies.entries()) {
            const refTarget = args.refList.get(dep);
            if (refTarget) {
                instances.push(refTarget);
            }
            else {
                instances.push(this.get(dep, argsPassedByDecorator?.get(index) ?? [], {
                    failFast: true,
                    depth: args.depth + 1,
                    refList: args.refList,
                }));
            }
        }
        instance = new target(...[
            ...instances.filter((i) => typeof i !== "undefined"),
            ...constructorArgs,
        ]);
        if ("queryBuilder" === componentsOptions.componentType) {
            if (args.depth > 0) {
                throw Error("Can't inject query builder in query builder");
            }
        }
        instance.__scope = componentsOptions;
        instanceMap?.set(target, instance);
        return instance;
    }
};
exports.Components = Components;
exports.Components = Components = Components_1 = __decorate([
    (0, component_1.component)(),
    __metadata("design:paramtypes", [String])
], Components);