lakutata/src/lib/ioc/Errors.mjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
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.internal.7.mjs";

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

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

import "../../../vendor/Package.internal.2.mjs";

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

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

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

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

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

import "../helpers/DevNull.mjs";

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

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

import "node:crypto";

import "../../../vendor/Package.internal.3.mjs";

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

import "node:util/types";

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

import "url";

import "util";

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

import "../../../vendor/Package.internal.8.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, n) {
        if (!e) {
            throw new DependencyInjectionTypeError(r, t, o, n);
        }
        return e;
    }
}

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

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 };