lakutata/src/lib/ioc/Errors.mjs

An IoC-based universal application framework.

import { DependencyInjectionException as e } from "../../exceptions/di/DependencyInjectionException.mjs";

import { ResolveConstructorNameBySymbol as r } from "../base/internal/ConstructorSymbol.mjs";

import { As as t } from "../helpers/As.mjs";

import { I as o } from "../../../vendor/Package.2.mjs";

import "../base/abstracts/Exception.mjs";

import "../base/internal/BasicInfo.mjs";

import "../../../vendor/Package.6.mjs";

import "../../../vendor/Package.5.mjs";

import "../../../vendor/Package.7.mjs";

import "../base/internal/ThrowWarning.mjs";

import "../helpers/Templating.mjs";

import "../base/internal/CamelCase.mjs";

import "../helpers/NoCase.mjs";

import "../../constants/DIMetadataKey.mjs";

import "../../../vendor/Package.4.mjs";

import "node:crypto";

import "../../../vendor/Package.1.mjs";

import "../base/internal/DataValidator.mjs";

import "node:util/types";

import "../validation/VLD.mjs";

import "../../../vendor/Package.11.mjs";

import "url";

import "../../../vendor/Package.10.mjs";

import "util";

import "../../exceptions/dto/InvalidValueException.mjs";

import "../../../vendor/Package.9.mjs";

import "../helpers/IsHtml.mjs";

import "../helpers/IsXML.mjs";

import "../../constants/DTOMetadataKey.mjs";

import "../helpers/ObjectConstructor.mjs";

import "../helpers/ObjectParentConstructors.mjs";

import "../helpers/ObjectParentConstructor.mjs";

import "../helpers/ObjectPrototype.mjs";

class ExtendableError extends e {
    constructor(e) {
        super(e);
        Object.defineProperty(this, "message", {
            enumerable: false,
            value: e
        });
        Object.defineProperty(this, "name", {
            enumerable: false,
            value: this.constructor.name
        });
        if ("captureStackTrace" in Error) {
            Error.captureStackTrace(this, this.constructor);
        } else {
            Object.defineProperty(this, "stack", {
                enumerable: false,
                value: Error(e).stack,
                writable: true,
                configurable: true
            });
        }
    }
}

class DependencyInjectionTypeError extends ExtendableError {
    constructor(e, r, t, o) {
        super(`${e}: expected ${r} to be ${t}, but got ${o}.`);
    }
    static assert(e, r, t, o, s) {
        if (!e) {
            throw new DependencyInjectionTypeError(r, t, o, s);
        }
        return e;
    }
}

class DependencyInjectionResolutionError extends ExtendableError {
    constructor(e, s, n) {
        if (o(e)) e = r(e).toString();
        const a = e.split("_$$").reverse()[0];
        s = s.map((e => o(e) ? r(e).toString() : e.name));
        s.push(t(a));
        const i = s.join(" -> ");
        let m = `Could not resolve '${a}'.`;
        if (n) m = `${m} ${n}`;
        m = `${m} Resolution path: ${i}`;
        super(m);
    }
}

class DependencyInjectionRegistrationError extends ExtendableError {
    constructor(e, r) {
        const t = e.toString();
        let o = `Could not register '${t}'.`;
        if (r) {
            o += ` ${r}`;
        }
        super(o);
    }
}

export { DependencyInjectionRegistrationError, DependencyInjectionResolutionError, DependencyInjectionTypeError, ExtendableError };