b-ioc-js/dist/cjs/index.js

A magic free, dirt simple IoC container for Javascript.

/**
 * IoC Module
 * @module b-ioc-js
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get bind () {
        return bind;
    },
    get clear () {
        return clear;
    },
    get getBindings () {
        return getBindings;
    },
    get getSingletons () {
        return getSingletons;
    },
    get make () {
        return make;
    },
    get singleton () {
        return singleton;
    },
    get use () {
        return use;
    }
});
_export_star(require("./types.js"), exports);
function _array_like_to_array(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _array_without_holes(arr) {
    if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _construct(Parent, args, Class) {
    if (_is_native_reflect_construct()) {
        _construct = Reflect.construct;
    } else {
        _construct = function construct(Parent, args, Class) {
            var a = [
                null
            ];
            a.push.apply(a, args);
            var Constructor = Function.bind.apply(Parent, a);
            var instance = new Constructor();
            if (Class) _set_prototype_of(instance, Class.prototype);
            return instance;
        };
    }
    return _construct.apply(null, arguments);
}
function _export_star(from, to) {
    Object.keys(from).forEach(function(k) {
        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
            Object.defineProperty(to, k, {
                enumerable: true,
                get: function() {
                    return from[k];
                }
            });
        }
    });
    return from;
}
function _iterable_to_array(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _non_iterable_spread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _set_prototype_of(o, p) {
    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return _set_prototype_of(o, p);
}
function _to_consumable_array(arr) {
    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
function _is_native_reflect_construct() {
    try {
        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
    } catch (_) {}
    return (_is_native_reflect_construct = function() {
        return !!result;
    })();
}
var bindings = {};
var resolvedBindings = {};
var singletons = {};
var resolvedSingletons = {};
function isString(obj) {
    return Object.prototype.toString.call(obj) === '[object String]';
}
function isObject(obj) {
    var type = typeof obj === "undefined" ? "undefined" : _type_of(obj);
    return type === 'function' || type === 'object' && !!obj;
}
function isFunction(obj) {
    return typeof obj === 'function' || false;
}
function inObject(key, obj) {
    // biome-ignore lint/suspicious/noPrototypeBuiltins: Legacy
    return obj.hasOwnProperty(key);
}
function getBindings() {
    return bindings;
}
function getSingletons() {
    return singletons;
}
function clear() {
    bindings = {};
    resolvedBindings = {};
    singletons = {};
    resolvedSingletons = {};
}
function bind(binding, closure) {
    if (inObject(binding, bindings) || inObject(binding, singletons)) throw new Error("Binding: ".concat(binding, " already binded."));
    if (!isFunction(closure)) throw new Error("Binding: ".concat(binding, " does not implement a factory."));
    bindings[binding] = closure;
}
function singleton(binding, closure) {
    if (inObject(binding, singletons) || inObject(binding, bindings)) throw new Error("Singleton: ".concat(binding, " already binded."));
    singletons[binding] = closure;
}
function use(binding) {
    // biome-ignore lint/complexity/noArguments: Apply arguments
    var args = Array.prototype.slice.call(arguments, 1);
    // first check bindings
    if (inObject(binding, bindings)) {
        if (resolvedBindings[binding]) {
            throw new Error("Cyclic dependency detected in binding: ".concat(binding, "."));
        }
        resolvedBindings[binding] = true;
        var instance = bindings[binding].apply(null, args);
        resolvedBindings[binding] = false;
        return instance;
    }
    // then check singletons
    if (inObject(binding, singletons)) {
        if (!inObject(binding, resolvedSingletons)) {
            // we are not guarenteed to receive a factory function for a singleton
            if (isFunction(singletons[binding])) resolvedSingletons[binding] = singletons[binding].apply(null, args);
            else resolvedSingletons[binding] = singletons[binding];
        }
        return resolvedSingletons[binding];
    }
    // finally check node_modules
    throw new Error("Binding: ".concat(binding, " not found."));
}
function make(Obj) {
    if (!isFunction(Obj)) throw new Error(".make implementation error, expected function got: ".concat(typeof Obj === "undefined" ? "undefined" : _type_of(Obj)));
    if (!Obj.inject) throw new Error(".make requires ".concat(Obj.constructor.name, " to have a static inject method."));
    var dependencies = Obj.inject();
    if (dependencies.length === 0) return new Obj();
    var resolved = [];
    dependencies.forEach(function(dependency) {
        if (!isString(dependency) && !isObject(dependency)) {
            throw new Error('static .inject implementation error, a string or object is required.');
        }
        // string based binding
        if (isString(dependency)) resolved.push(exports.use(dependency));
        // binding you want to pass args to
        if (isObject(dependency)) {
            dependency.args.unshift(dependency.key);
            resolved.push(exports.use.apply(null, dependency.args));
        }
    });
    return _construct(Obj, _to_consumable_array(resolved));
}
/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }