@arcaelas/dynamite 1.0.17 → 1.0.19

package/src/decorators/mutate.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = Mutate;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-function Mutate(fn) {
-    if (typeof fn !== "function")
-        throw new TypeError("@Mutate requiere función");
-    return (target, prop) => {
-        const ctor = target.constructor;
-        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
-        const col = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
-        col.mutate ??= [];
-        col.mutate.push(fn);
-        !Object.getOwnPropertyDescriptor(ctor.prototype, prop)?.set &&
-            defineVirtual(ctor.prototype, col, prop);
-    };
-}
-/** Define propiedad virtual con getter/setter para manejo de mutaciones */
-function defineVirtual(proto, col, prop) {
-    Object.defineProperty(proto, prop, {
-        get() {
-            return (this[wrapper_1.STORE] ?? {})[prop];
-        },
-        set(val) {
-            const buf = (this[wrapper_1.STORE] ??= {});
-            val =
-                val === undefined && col.default !== undefined
-                    ? typeof col.default === "function"
-                        ? col.default()
-                        : col.default
-                    : val;
-            if (col.mutate)
-                for (const m of col.mutate)
-                    val = m(val);
-            if (col.validate) {
-                for (const v of col.validate) {
-                    const r = v(val);
-                    r !== true &&
-                        (() => {
-                            throw new Error(typeof r === "string" ? r : "Validación fallida");
-                        })();
-                }
-            }
-            buf[prop] = val;
-        },
-        enumerable: true,
-        configurable: true,
-    });
-}
-//# sourceMappingURL=mutate.js.map

package/src/decorators/name.d.ts

@@ -1 +0,0 @@
-export default function Name(label: string): ClassDecorator & PropertyDecorator;

package/src/decorators/name.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = Name;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-function Name(label) {
-    if (!label || typeof label !== "string")
-        throw new TypeError("@Name requiere una cadena no vacía");
-    return (target, prop) => {
-        const ctor = prop === undefined ? target : target.constructor;
-        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
-        if (prop === undefined) {
-            const auto = (0, naming_1.toSnakePlural)(ctor.name);
-            if (entry.name !== auto && entry.name !== label && entry.name) {
-                throw new Error(`La clase ${ctor.name} ya tiene un @Name distinto (${entry.name})`);
-            }
-            entry.name = label;
-        }
-        else {
-            const col = (0, wrapper_1.ensureColumn)(entry, prop, label);
-            if (col.name && col.name !== label) {
-                throw new Error(`La columna '${String(prop)}' ya tiene @Name distinto (${col.name})`);
-            }
-            col.name = label;
-        }
-    };
-}
-//# sourceMappingURL=name.js.map

package/src/decorators/not_null.d.ts

@@ -1 +0,0 @@
-export default function NotNull(): PropertyDecorator;

package/src/decorators/not_null.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = NotNull;
-const validate_1 = __importDefault(require("./validate"));
-function NotNull() {
-    return validate_1.default((value) => value !== null &&
-        value !== undefined &&
-        (typeof value !== "string" || value.trim() !== ""));
-}
-//# sourceMappingURL=not_null.js.map

package/src/decorators/primary_key.d.ts

@@ -1,6 +0,0 @@
-/**
- * Decorador para marcar una propiedad como clave primaria.
- * Aplica automáticamente @Index y @IndexSort y marca el campo como primaryKey en los metadatos.
- * @param name - Nombre opcional para el índice (no utilizado actualmente, mantenido por compatibilidad)
- */
-export default function PrimaryKey(name?: string): PropertyDecorator;

package/src/decorators/primary_key.js

@@ -1,30 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = PrimaryKey;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-const index_1 = __importDefault(require("./index"));
-const index_sort_1 = __importDefault(require("./index_sort"));
-/**
- * Decorador para marcar una propiedad como clave primaria.
- * Aplica automáticamente @Index y @IndexSort y marca el campo como primaryKey en los metadatos.
- * @param name - Nombre opcional para el índice (no utilizado actualmente, mantenido por compatibilidad)
- */
-function PrimaryKey(name = "primary") {
-    return (target, prop) => {
-        // Aplicar decoradores de índice
-        (0, index_1.default)()(target, prop);
-        (0, index_sort_1.default)()(target, prop);
-        // Marcar explícitamente como clave primaria en los metadatos
-        const ctor = target.constructor;
-        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
-        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
-        // Establecer metadatos adicionales para clave primaria
-        column.primaryKey = true;
-        column.nullable = false; // Las claves primarias no pueden ser nulas
-    };
-}
-//# sourceMappingURL=primary_key.js.map

package/src/decorators/updated_at.d.ts

@@ -1,12 +0,0 @@
-/**
- * Decorador que marca una propiedad para que se actualice automáticamente con la fecha/hora actual
- * cada vez que se guarde el modelo.
- *
- * @example
- * class User extends Table<User> {
- *   @PrimaryKey() id: string;
- *   name: string;
- *   @UpdatedAt() updated_at: string;
- * }
- */
-export default function UpdatedAt(): (target: any, propertyKey: string | symbol) => void;

package/src/decorators/updated_at.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = UpdatedAt;
-const wrapper_1 = require("../core/wrapper");
-/**
- * Decorador que marca una propiedad para que se actualice automáticamente con la fecha/hora actual
- * cada vez que se guarde el modelo.
- *
- * @example
- * class User extends Table<User> {
- *   @PrimaryKey() id: string;
- *   name: string;
- *   @UpdatedAt() updated_at: string;
- * }
- */
-function UpdatedAt() {
-    return function (target, propertyKey) {
-        const ctor = target.constructor;
-        const entry = (0, wrapper_1.ensureConfig)(ctor, ctor.name);
-        const column = (0, wrapper_1.ensureColumn)(entry, propertyKey, propertyKey);
-        // Marcamos la columna como updatedAt para que se actualice automáticamente al guardar
-        column.updatedAt = true;
-        // No establecemos un valor por defecto aquí, se establecerá en el método save()
-    };
-}
-//# sourceMappingURL=updated_at.js.map

package/src/decorators/validate.d.ts

@@ -1 +0,0 @@
-export default function Validate(validators: ((v: unknown) => true | string) | ((v: unknown) => true | string)[]): PropertyDecorator;

package/src/decorators/validate.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = Validate;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-function Validate(validators) {
-    const list = Array.isArray(validators) ? validators : [validators];
-    if (!list.length || list.some((v) => typeof v !== "function")) {
-        throw new TypeError("@Validate requiere funciones");
-    }
-    return (target, prop) => {
-        const ctor = target.constructor;
-        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
-        const col = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
-        col.validate ??= [];
-        col.validate.push(...list);
-        !Object.getOwnPropertyDescriptor(ctor.prototype, prop)?.set &&
-            defineVirtual(ctor.prototype, col, prop);
-    };
-}
-/** Define propiedad virtual con getter/setter para manejo de validaciones */
-function defineVirtual(proto, col, prop) {
-    Object.defineProperty(proto, prop, {
-        get() {
-            return (this[wrapper_1.STORE] ?? {})[prop];
-        },
-        set(val) {
-            const buf = (this[wrapper_1.STORE] ??= {});
-            val =
-                val === undefined && col.default !== undefined
-                    ? typeof col.default === "function"
-                        ? col.default()
-                        : col.default
-                    : val;
-            if (col.mutate)
-                for (const m of col.mutate)
-                    val = m(val);
-            if (col.validate) {
-                for (const v of col.validate) {
-                    const r = v(val);
-                    r !== true &&
-                        (() => {
-                            throw new Error(typeof r === "string" ? r : "Validación fallida");
-                        })();
-                }
-            }
-            buf[prop] = val;
-        },
-        enumerable: true,
-        configurable: true,
-    });
-}
-//# sourceMappingURL=validate.js.map

package/src/utils/batch-relations.d.ts

@@ -1,14 +0,0 @@
-/**
- * @file batch-relations.ts
- * @description Optimized batch loading for relations
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-/** Batch loader para hasMany relations */
-export declare const batchLoadHasMany: (Model: any, parentItems: any[], relation: any) => Promise<Map<any, any>>;
-/** Batch loader para belongsTo relations con cache */
-export declare const batchLoadBelongsTo: (Model: any, parentItems: any[], relation: any) => Promise<Map<any, any>>;
-/** Optimized processIncludes con batch loading */
-export declare const processIncludesBatch: (Model: any, items: any[], include: any, depth?: number) => Promise<any[]>;
-/** Clear expired cache entries */
-export declare const cleanupRelationCache: () => void;

package/src/utils/batch-relations.js

@@ -1,131 +0,0 @@
-"use strict";
-/**
- * @file batch-relations.ts
- * @description Optimized batch loading for relations
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanupRelationCache = exports.processIncludesBatch = exports.batchLoadBelongsTo = exports.batchLoadHasMany = void 0;
-const wrapper_1 = require("../core/wrapper");
-/** Cache multi-nivel con TTL */
-const relCache = new Map();
-/** Batch loader para hasMany relations */
-const batchLoadHasMany = async (Model, parentItems, relation) => {
-    const { targetModel, foreignKey, localKey } = relation;
-    const TargetModel = targetModel();
-    // Agrupar claves para batch query
-    const parentKeys = parentItems.map((item) => item[localKey]).filter(Boolean);
-    if (!parentKeys.length)
-        return new Map();
-    // Single query con 'in' operator
-    const relatedItems = await TargetModel.where({
-        [foreignKey]: { in: parentKeys },
-    });
-    // Group by foreign key
-    const grouped = new Map();
-    relatedItems.forEach((item) => {
-        const key = item[foreignKey];
-        if (!grouped.has(key))
-            grouped.set(key, []);
-        grouped.get(key).push(item);
-    });
-    return grouped;
-};
-exports.batchLoadHasMany = batchLoadHasMany;
-/** Batch loader para belongsTo relations con cache */
-const batchLoadBelongsTo = async (Model, parentItems, relation) => {
-    const { targetModel, localKey, foreignKey } = relation;
-    const TargetModel = targetModel();
-    const cacheKey = `${TargetModel.name}_belongsTo`;
-    // Verificar cache existente
-    const cache = relCache.get(cacheKey) || new Map();
-    relCache.set(cacheKey, cache);
-    const now = Date.now();
-    // Separar keys en cache vs no-cache
-    const keysToFetch = [];
-    const cachedResults = new Map();
-    parentItems.forEach((item) => {
-        const key = item[localKey];
-        if (!key)
-            return;
-        const cached = cache.get(key);
-        if (cached && cached.expires > now) {
-            cachedResults.set(key, cached.data);
-        }
-        else {
-            keysToFetch.push(key);
-        }
-    });
-    // Fetch missing items
-    if (keysToFetch.length) {
-        const fetchedItems = await TargetModel.where({
-            [foreignKey]: { in: keysToFetch },
-        });
-        // Update cache (5min TTL)
-        const expires = now + 300000;
-        fetchedItems.forEach((item) => {
-            const key = item[foreignKey];
-            cache.set(key, { data: item, expires });
-            cachedResults.set(key, item);
-        });
-    }
-    return cachedResults;
-};
-exports.batchLoadBelongsTo = batchLoadBelongsTo;
-/** Optimized processIncludes con batch loading */
-const processIncludesBatch = async (Model, items, include, depth = 0) => {
-    if (!include || depth > 10 || !items.length)
-        return items;
-    const meta = (0, wrapper_1.mustMeta)(Model);
-    // Process all relations in parallel
-    const relationPromises = Object.entries(include).map(async ([relationKey, relationOptions]) => {
-        const relation = meta.relations.get(relationKey);
-        if (!relation)
-            return;
-        let relatedData;
-        // Use batch loading based on relation type
-        if (relation.type === "hasMany") {
-            relatedData = await (0, exports.batchLoadHasMany)(Model, items, relation);
-        }
-        else {
-            relatedData = await (0, exports.batchLoadBelongsTo)(Model, items, relation);
-        }
-        // Assign relations to items
-        items.forEach((item) => {
-            const key = item[relation.localKey];
-            const related = relatedData.get(key);
-            if (relation.type === "hasMany") {
-                item[relationKey] = related || [];
-            }
-            else {
-                item[relationKey] = related || null;
-            }
-        });
-        // Recursive processing for nested includes
-        if (relationOptions?.include && relatedData.size) {
-            const allRelated = Array.from(relatedData.values()).flat();
-            const TargetModel = relation.targetModel();
-            await (0, exports.processIncludesBatch)(TargetModel, allRelated, relationOptions.include, depth + 1);
-        }
-    });
-    await Promise.all(relationPromises);
-    return items;
-};
-exports.processIncludesBatch = processIncludesBatch;
-/** Clear expired cache entries */
-const cleanupRelationCache = () => {
-    const now = Date.now();
-    relCache.forEach((cache, modelKey) => {
-        cache.forEach((entry, key) => {
-            if (entry.expires <= now)
-                cache.delete(key);
-        });
-        if (cache.size === 0)
-            relCache.delete(modelKey);
-    });
-};
-exports.cleanupRelationCache = cleanupRelationCache;
-// Auto cleanup every 5 minutes
-setInterval(exports.cleanupRelationCache, 300000);
-//# sourceMappingURL=batch-relations.js.map

package/src/utils/circular-detector.d.ts

@@ -1,82 +0,0 @@
-/**
- * @file circular-detector.ts
- * @description Detection and prevention of circular references in relations
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-interface TraversalPath {
-    modelName: string;
-    relationKey: string;
-    depth: number;
-}
-interface CircularDetectionConfig {
-    maxDepth: number;
-    maxIncludeDepth: number;
-    trackingEnabled: boolean;
-}
-declare class CircularReferenceDetector {
-    private static readonly DEFAULT_CONFIG;
-    private config;
-    private activePaths;
-    private pathHistory;
-    constructor(config?: Partial<CircularDetectionConfig>);
-    /**
-     * Verificar si una ruta de inclusión es segura
-     */
-    validateIncludePath(modelName: string, includeOptions: any, currentDepth?: number, visitedModels?: Set<string>): void;
-    /**
-     * Validar estructura de relaciones en tiempo de definición
-     */
-    validateRelationStructure(models: Map<string, any>, maxAllowedCycles?: number): ValidationResult;
-    /**
-     * Construir grafo de relaciones
-     */
-    private buildRelationGraph;
-    /**
-     * Detectar ciclos usando DFS
-     */
-    private detectCycles;
-    /**
-     * Generar sugerencias para resolver ciclos
-     */
-    private generateSuggestions;
-    /**
-     * Inferir nombre del modelo target (simplificado)
-     */
-    private inferTargetModelName;
-    /**
-     * Crear contexto de rastreo para includes anidados
-     */
-    createTrackingContext(): CircularTracker;
-    /**
-     * Obtener historial de paths para debugging
-     */
-    getPathHistory(): TraversalPath[];
-    /**
-     * Limpiar historial
-     */
-    clearHistory(): void;
-}
-/**
- * Tracker específico para una operación de include
- */
-declare class CircularTracker {
-    private visitedModels;
-    private currentPath;
-    private maxDepth;
-    constructor(maxDepth: number);
-    enter(modelName: string): void;
-    exit(modelName: string): void;
-    getCurrentPath(): string[];
-}
-interface ValidationResult {
-    isValid: boolean;
-    cycles: string[][];
-    suggestions: string[];
-}
-declare class CircularReferenceError extends Error {
-    constructor(message: string);
-}
-declare const circularDetector: CircularReferenceDetector;
-export { CircularReferenceDetector, CircularReferenceError, CircularTracker, ValidationResult, circularDetector, };
-export default circularDetector;

package/src/utils/circular-detector.js

@@ -1,212 +0,0 @@
-"use strict";
-/**
- * @file circular-detector.ts
- * @description Detection and prevention of circular references in relations
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.circularDetector = exports.CircularTracker = exports.CircularReferenceError = exports.CircularReferenceDetector = void 0;
-class CircularReferenceDetector {
-    static { this.DEFAULT_CONFIG = {
-        maxDepth: 10,
-        maxIncludeDepth: 5,
-        trackingEnabled: true,
-    }; }
-    constructor(config) {
-        this.activePaths = new Set();
-        this.pathHistory = [];
-        this.config = { ...CircularReferenceDetector.DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Verificar si una ruta de inclusión es segura
-     */
-    validateIncludePath(modelName, includeOptions, currentDepth = 0, visitedModels = new Set()) {
-        // Verificar profundidad máxima
-        if (currentDepth > this.config.maxIncludeDepth) {
-            throw new CircularReferenceError(`Include depth exceeded limit of ${this.config.maxIncludeDepth} at model: ${modelName}`);
-        }
-        // Detectar referencia circular directa
-        if (visitedModels.has(modelName)) {
-            const path = Array.from(visitedModels).join(" -> ") + ` -> ${modelName}`;
-            throw new CircularReferenceError(`Circular reference detected in include path: ${path}`);
-        }
-        if (!includeOptions || typeof includeOptions !== "object") {
-            return;
-        }
-        const newVisited = new Set(visitedModels);
-        newVisited.add(modelName);
-        // Validar cada relación incluida
-        for (const [relationKey, relationOptions] of Object.entries(includeOptions)) {
-            if (this.config.trackingEnabled) {
-                this.pathHistory.push({
-                    modelName,
-                    relationKey,
-                    depth: currentDepth,
-                });
-            }
-            // Si la relación tiene sus propios includes, validar recursivamente
-            if (relationOptions &&
-                typeof relationOptions === "object" &&
-                "include" in relationOptions) {
-                // Aquí necesitaríamos obtener el modelo target de la relación
-                // Por simplicidad, usamos el relationKey como modelo (esto debería mejorar)
-                const targetModelName = this.inferTargetModelName(relationKey);
-                this.validateIncludePath(targetModelName, relationOptions.include, currentDepth + 1, newVisited);
-            }
-        }
-    }
-    /**
-     * Validar estructura de relaciones en tiempo de definición
-     */
-    validateRelationStructure(models, maxAllowedCycles = 0) {
-        const graph = this.buildRelationGraph(models);
-        const cycles = this.detectCycles(graph);
-        return {
-            isValid: cycles.length <= maxAllowedCycles,
-            cycles,
-            suggestions: this.generateSuggestions(cycles),
-        };
-    }
-    /**
-     * Construir grafo de relaciones
-     */
-    buildRelationGraph(models) {
-        const graph = new Map();
-        for (const [modelName, model] of models.entries()) {
-            const relations = [];
-            // Esto necesitaría acceso a los metadatos del modelo
-            // Por ahora simulamos la extracción de relaciones
-            const meta = model.getMeta?.();
-            if (meta?.relations) {
-                for (const [relationKey, relation] of meta.relations.entries()) {
-                    const targetModel = relation.targetModel?.()?.name || relationKey;
-                    relations.push(targetModel);
-                }
-            }
-            graph.set(modelName, relations);
-        }
-        return graph;
-    }
-    /**
-     * Detectar ciclos usando DFS
-     */
-    detectCycles(graph) {
-        const cycles = [];
-        const visited = new Set();
-        const recursionStack = new Set();
-        const dfs = (node, path) => {
-            if (recursionStack.has(node)) {
-                // Ciclo detectado
-                const cycleStart = path.indexOf(node);
-                const cycle = path.slice(cycleStart).concat(node);
-                cycles.push(cycle);
-                return;
-            }
-            if (visited.has(node)) {
-                return;
-            }
-            visited.add(node);
-            recursionStack.add(node);
-            path.push(node);
-            const neighbors = graph.get(node) || [];
-            for (const neighbor of neighbors) {
-                dfs(neighbor, [...path]);
-            }
-            recursionStack.delete(node);
-        };
-        for (const node of graph.keys()) {
-            if (!visited.has(node)) {
-                dfs(node, []);
-            }
-        }
-        return cycles;
-    }
-    /**
-     * Generar sugerencias para resolver ciclos
-     */
-    generateSuggestions(cycles) {
-        const suggestions = [];
-        for (const cycle of cycles) {
-            if (cycle.length === 2) {
-                suggestions.push(`Circular reference between ${cycle[0]} and ${cycle[1]}. Consider using lazy loading or removing one direction.`);
-            }
-            else {
-                suggestions.push(`Complex circular reference detected: ${cycle.join(" -> ")}. Consider breaking the cycle at the weakest relationship.`);
-            }
-        }
-        if (cycles.length > 0) {
-            suggestions.push("General: Use @NonAttribute for computed relationships or implement lazy loading to break cycles.");
-        }
-        return suggestions;
-    }
-    /**
-     * Inferir nombre del modelo target (simplificado)
-     */
-    inferTargetModelName(relationKey) {
-        // Conversión simple: posts -> Post, user -> User
-        return (relationKey.charAt(0).toUpperCase() +
-            relationKey.slice(1).replace(/s$/, ""));
-    }
-    /**
-     * Crear contexto de rastreo para includes anidados
-     */
-    createTrackingContext() {
-        return new CircularTracker(this.config.maxIncludeDepth);
-    }
-    /**
-     * Obtener historial de paths para debugging
-     */
-    getPathHistory() {
-        return [...this.pathHistory];
-    }
-    /**
-     * Limpiar historial
-     */
-    clearHistory() {
-        this.pathHistory = [];
-        this.activePaths.clear();
-    }
-}
-exports.CircularReferenceDetector = CircularReferenceDetector;
-/**
- * Tracker específico para una operación de include
- */
-class CircularTracker {
-    constructor(maxDepth) {
-        this.visitedModels = new Set();
-        this.currentPath = [];
-        this.maxDepth = maxDepth;
-    }
-    enter(modelName) {
-        if (this.currentPath.length >= this.maxDepth) {
-            throw new CircularReferenceError(`Maximum include depth ${this.maxDepth} exceeded at: ${modelName}`);
-        }
-        if (this.visitedModels.has(modelName)) {
-            const cyclePath = this.currentPath.join(" -> ") + ` -> ${modelName}`;
-            throw new CircularReferenceError(`Circular reference detected: ${cyclePath}`);
-        }
-        this.visitedModels.add(modelName);
-        this.currentPath.push(modelName);
-    }
-    exit(modelName) {
-        this.currentPath.pop();
-        this.visitedModels.delete(modelName);
-    }
-    getCurrentPath() {
-        return [...this.currentPath];
-    }
-}
-exports.CircularTracker = CircularTracker;
-class CircularReferenceError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "CircularReferenceError";
-    }
-}
-exports.CircularReferenceError = CircularReferenceError;
-// Instancia singleton
-const circularDetector = new CircularReferenceDetector();
-exports.circularDetector = circularDetector;
-exports.default = circularDetector;
-//# sourceMappingURL=circular-detector.js.map