@darkfrost-1107/scaff-z-react 0.1.7

package/dist/packages/indexeddb/builder.esm

@@ -0,0 +1,35 @@
+import { INDEXEDDB_REGISTRY as e } from "./registry.esm";
+//#region src/packages/indexeddb/builder.ts
+var t = class {
+	constructor(e) {
+		this.config = void 0, this.config = {
+			name: e,
+			keyPath: "id",
+			autoIncrement: !1,
+			indexes: []
+		};
+	}
+	setKeyPath(e) {
+		return this.config.keyPath = e, this;
+	}
+	setAutoIncrement(e = !0) {
+		return this.config.autoIncrement = e, this;
+	}
+	addIndex(e, t, n) {
+		let r = {
+			name: e,
+			keyPath: t,
+			unique: n?.unique ?? !1,
+			multiEntry: n?.multiEntry ?? !1
+		};
+		return this.config.indexes?.push(r), this;
+	}
+	build() {
+		return { ...this.config };
+	}
+	register() {
+		return e.register(this.build());
+	}
+};
+//#endregion
+export { t as StoreBuilder };

package/dist/packages/indexeddb/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./registry.cjs`),t=require(`./builder.cjs`),n=require(`./nosql.repo.cjs`),r=require(`./indexeddb.service.cjs`);exports.INDEXEDDB_REGISTRY=e.INDEXEDDB_REGISTRY,exports.INDEXEDDB_SERVICE=r.INDEXEDDB_SERVICE,exports.IndexedDbService=r,exports.NoSqlRepository=n.NoSqlRepository,exports.StoreBuilder=t.StoreBuilder;

package/dist/packages/indexeddb/index.d.ts

@@ -0,0 +1,5 @@
+export { default as IndexedDbService, INDEXEDDB_SERVICE } from './indexeddb.service';
+export * from './nosql.repo';
+export * from './types';
+export * from './builder';
+export * from './registry';

package/dist/packages/indexeddb/index.esm

@@ -0,0 +1,5 @@
+import { INDEXEDDB_REGISTRY as e } from "./registry.esm";
+import { StoreBuilder as t } from "./builder.esm";
+import { NoSqlRepository as n } from "./nosql.repo.esm";
+import r, { INDEXEDDB_SERVICE as i } from "./indexeddb.service.esm";
+export { e as INDEXEDDB_REGISTRY, i as INDEXEDDB_SERVICE, r as IndexedDbService, n as NoSqlRepository, t as StoreBuilder };

package/dist/packages/indexeddb/indexeddb.service.cjs

@@ -0,0 +1 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}}),require(`../../_virtual/_rolldown/runtime.cjs`);const e=require(`../../shared/logic/service/base.service.cjs`),t=require(`../logger/logger.cjs`),n=require(`./nosql.repo.cjs`);let r=require(`sonner`);var i=t.GLOBAL_LOGGER.child(`[IndexedDB]`),a=class t extends e{constructor(){super(),this._db=null,this._config=null,i.debug(`Initializing IndexedDB Service...`)}static get instance(){return this._instance||=new t,this._instance}async initialize(e){return i.info(`Starting initialization for Database "${e.name}" (v${e.version})...`),this._config=e,new Promise((t,n)=>{let a=indexedDB.open(e.name,e.version);a.onupgradeneeded=t=>{let n=t.target.result,r=t.oldVersion,a=t.newVersion;i.info(`Upgrading Database "${e.name}" from v${r} to v${a}`),e.stores.forEach(e=>{if(!n.objectStoreNames.contains(e.name)){i.debug(`Creating object store: ${e.name}`);let t=n.createObjectStore(e.name,{keyPath:e.keyPath,autoIncrement:e.autoIncrement??!1});e.indexes?.forEach(n=>{i.debug(`- Creating index: ${n.name} for ${e.name}`),t.createIndex(n.name,n.keyPath,{unique:n.unique??!1,multiEntry:n.multiEntry??!1})})}})},a.onsuccess=n=>{this._db=n.target.result,i.info(`Database "${e.name}" connected successfully (v${this._db.version})`),this._db.onversionchange=()=>{this._db?.close(),i.warn(`Database version changed in another tab. Closing connection to allow upgrade.`),window.location.reload()},this.setReady(),t()},a.onblocked=()=>{i.warn(`Upgrade blocked! Please close other tabs of "${e.name}" to allow version upgrade.`),r.toast.warning(`Actualización bloqueada`,{description:`Por favor, cierra otras pestañas de la aplicación para completar la migración de datos.`})},a.onerror=t=>{let r=t.target.error;i.error(`Failed to connect to Database "${e.name}"`,r),n(r)}})}getRepository(e){return new n.NoSqlRepository(e)}get db(){if(!this._db)throw Error(`Database not initialized`);return this._db}get config(){return this._config}};a._instance=void 0;var o=a.instance;exports.INDEXEDDB_SERVICE=o,exports.default=a;

package/dist/packages/indexeddb/indexeddb.service.d.ts

@@ -0,0 +1,21 @@
+import { default as BaseService } from '../../shared/logic/service/base.service';
+import { DatabaseConfig } from './types';
+import { NoSqlRepository } from './nosql.repo';
+export default class IndexedDbService extends BaseService {
+    private _db;
+    private _config;
+    private constructor();
+    private static _instance;
+    static get instance(): IndexedDbService;
+    /**
+     * Initializes the database connection
+     */
+    initialize(config: DatabaseConfig): Promise<void>;
+    /**
+     * Gets a repository for a specific object store
+     */
+    getRepository<T>(storeName: string): NoSqlRepository<T>;
+    get db(): IDBDatabase;
+    get config(): DatabaseConfig | null;
+}
+export declare const INDEXEDDB_SERVICE: IndexedDbService;

package/dist/packages/indexeddb/indexeddb.service.esm

@@ -0,0 +1,59 @@
+import e from "../../shared/logic/service/base.service.esm";
+import { GLOBAL_LOGGER as t } from "../logger/logger.esm";
+import { NoSqlRepository as n } from "./nosql.repo.esm";
+import { toast as r } from "sonner";
+//#region src/packages/indexeddb/indexeddb.service.ts
+var i = t.child("[IndexedDB]"), a = class t extends e {
+	constructor() {
+		super(), this._db = null, this._config = null, i.debug("Initializing IndexedDB Service...");
+	}
+	static get instance() {
+		return this._instance ||= new t(), this._instance;
+	}
+	async initialize(e) {
+		return i.info(`Starting initialization for Database "${e.name}" (v${e.version})...`), this._config = e, new Promise((t, n) => {
+			let a = indexedDB.open(e.name, e.version);
+			a.onupgradeneeded = (t) => {
+				let n = t.target.result, r = t.oldVersion, a = t.newVersion;
+				i.info(`Upgrading Database "${e.name}" from v${r} to v${a}`), e.stores.forEach((e) => {
+					if (!n.objectStoreNames.contains(e.name)) {
+						i.debug(`Creating object store: ${e.name}`);
+						let t = n.createObjectStore(e.name, {
+							keyPath: e.keyPath,
+							autoIncrement: e.autoIncrement ?? !1
+						});
+						e.indexes?.forEach((n) => {
+							i.debug(`- Creating index: ${n.name} for ${e.name}`), t.createIndex(n.name, n.keyPath, {
+								unique: n.unique ?? !1,
+								multiEntry: n.multiEntry ?? !1
+							});
+						});
+					}
+				});
+			}, a.onsuccess = (n) => {
+				this._db = n.target.result, i.info(`Database "${e.name}" connected successfully (v${this._db.version})`), this._db.onversionchange = () => {
+					this._db?.close(), i.warn("Database version changed in another tab. Closing connection to allow upgrade."), window.location.reload();
+				}, this.setReady(), t();
+			}, a.onblocked = () => {
+				i.warn(`Upgrade blocked! Please close other tabs of "${e.name}" to allow version upgrade.`), r.warning("Actualización bloqueada", { description: "Por favor, cierra otras pestañas de la aplicación para completar la migración de datos." });
+			}, a.onerror = (t) => {
+				let r = t.target.error;
+				i.error(`Failed to connect to Database "${e.name}"`, r), n(r);
+			};
+		});
+	}
+	getRepository(e) {
+		return new n(e);
+	}
+	get db() {
+		if (!this._db) throw Error("Database not initialized");
+		return this._db;
+	}
+	get config() {
+		return this._config;
+	}
+};
+a._instance = void 0;
+var o = a.instance;
+//#endregion
+export { o as INDEXEDDB_SERVICE, a as default };

package/dist/packages/indexeddb/nosql.repo.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../logger/logger.cjs`),t=require(`./indexeddb.service.cjs`);var n=e.GLOBAL_LOGGER.child(`[NoSqlRepo]`),r=class{constructor(e){this.storeName=e}get db(){return t.INDEXEDDB_SERVICE.db}async save(e){return new Promise((t,r)=>{let i=this.db.transaction([this.storeName],`readwrite`).objectStore(this.storeName).put(e);i.onsuccess=()=>t(e),i.onerror=()=>{n.error(`Error saving item in ${this.storeName}`,i.error),r(i.error)}})}async get(e){return new Promise((t,r)=>{let i=this.db.transaction([this.storeName],`readonly`).objectStore(this.storeName).get(e);i.onsuccess=()=>t(i.result||null),i.onerror=()=>{n.error(`Error getting item ${e} from ${this.storeName}`,i.error),r(i.error)}})}async getAll(){return new Promise((e,t)=>{let r=this.db.transaction([this.storeName],`readonly`).objectStore(this.storeName).getAll();r.onsuccess=()=>e(r.result),r.onerror=()=>{n.error(`Error getting all items from ${this.storeName}`,r.error),t(r.error)}})}async delete(e){return new Promise((t,r)=>{let i=this.db.transaction([this.storeName],`readwrite`).objectStore(this.storeName).delete(e);i.onsuccess=()=>t(),i.onerror=()=>{n.error(`Error deleting item ${e} from ${this.storeName}`,i.error),r(i.error)}})}async clear(){return new Promise((e,t)=>{let r=this.db.transaction([this.storeName],`readwrite`).objectStore(this.storeName).clear();r.onsuccess=()=>e(),r.onerror=()=>{n.error(`Error clearing store ${this.storeName}`,r.error),t(r.error)}})}async findByIndex(e,t){return new Promise((r,i)=>{let a=this.db.transaction([this.storeName],`readonly`).objectStore(this.storeName).index(e).get(t);a.onsuccess=()=>r(a.result||null),a.onerror=()=>{n.error(`Error finding item in ${this.storeName} by index ${e}`,a.error),i(a.error)}})}async findAllByIndex(e,t){return new Promise((r,i)=>{let a=this.db.transaction([this.storeName],`readonly`).objectStore(this.storeName).index(e).getAll(t);a.onsuccess=()=>r(a.result||[]),a.onerror=()=>{n.error(`Error finding items in ${this.storeName} by index ${e}`,a.error),i(a.error)}})}};exports.NoSqlRepository=r;

package/dist/packages/indexeddb/nosql.repo.d.ts

@@ -0,0 +1,33 @@
+export declare class NoSqlRepository<T> {
+    private storeName;
+    constructor(storeName: string);
+    private get db();
+    /**
+     * Saves or updates an item in the store
+     */
+    save(item: T): Promise<T>;
+    /**
+     * Gets an item by its key
+     */
+    get(id: string | number): Promise<T | null>;
+    /**
+     * Gets all items from the store
+     */
+    getAll(): Promise<T[]>;
+    /**
+     * Deletes an item by its key
+     */
+    delete(id: string | number): Promise<void>;
+    /**
+     * Clears all items from the store
+     */
+    clear(): Promise<void>;
+    /**
+     * Finds an item using an index
+     */
+    findByIndex(indexName: string, value: any): Promise<T | null>;
+    /**
+     * Finds all items using an index
+     */
+    findAllByIndex(indexName: string, value: any): Promise<T[]>;
+}

package/dist/packages/indexeddb/nosql.repo.esm

@@ -0,0 +1,69 @@
+import { GLOBAL_LOGGER as e } from "../logger/logger.esm";
+import { INDEXEDDB_SERVICE as t } from "./indexeddb.service.esm";
+//#region src/packages/indexeddb/nosql.repo.ts
+var n = e.child("[NoSqlRepo]"), r = class {
+	constructor(e) {
+		this.storeName = e;
+	}
+	get db() {
+		return t.db;
+	}
+	async save(e) {
+		return new Promise((t, r) => {
+			let i = this.db.transaction([this.storeName], "readwrite").objectStore(this.storeName).put(e);
+			i.onsuccess = () => t(e), i.onerror = () => {
+				n.error(`Error saving item in ${this.storeName}`, i.error), r(i.error);
+			};
+		});
+	}
+	async get(e) {
+		return new Promise((t, r) => {
+			let i = this.db.transaction([this.storeName], "readonly").objectStore(this.storeName).get(e);
+			i.onsuccess = () => t(i.result || null), i.onerror = () => {
+				n.error(`Error getting item ${e} from ${this.storeName}`, i.error), r(i.error);
+			};
+		});
+	}
+	async getAll() {
+		return new Promise((e, t) => {
+			let r = this.db.transaction([this.storeName], "readonly").objectStore(this.storeName).getAll();
+			r.onsuccess = () => e(r.result), r.onerror = () => {
+				n.error(`Error getting all items from ${this.storeName}`, r.error), t(r.error);
+			};
+		});
+	}
+	async delete(e) {
+		return new Promise((t, r) => {
+			let i = this.db.transaction([this.storeName], "readwrite").objectStore(this.storeName).delete(e);
+			i.onsuccess = () => t(), i.onerror = () => {
+				n.error(`Error deleting item ${e} from ${this.storeName}`, i.error), r(i.error);
+			};
+		});
+	}
+	async clear() {
+		return new Promise((e, t) => {
+			let r = this.db.transaction([this.storeName], "readwrite").objectStore(this.storeName).clear();
+			r.onsuccess = () => e(), r.onerror = () => {
+				n.error(`Error clearing store ${this.storeName}`, r.error), t(r.error);
+			};
+		});
+	}
+	async findByIndex(e, t) {
+		return new Promise((r, i) => {
+			let a = this.db.transaction([this.storeName], "readonly").objectStore(this.storeName).index(e).get(t);
+			a.onsuccess = () => r(a.result || null), a.onerror = () => {
+				n.error(`Error finding item in ${this.storeName} by index ${e}`, a.error), i(a.error);
+			};
+		});
+	}
+	async findAllByIndex(e, t) {
+		return new Promise((r, i) => {
+			let a = this.db.transaction([this.storeName], "readonly").objectStore(this.storeName).index(e).getAll(t);
+			a.onsuccess = () => r(a.result || []), a.onerror = () => {
+				n.error(`Error finding items in ${this.storeName} by index ${e}`, a.error), i(a.error);
+			};
+		});
+	}
+};
+//#endregion
+export { r as NoSqlRepository };

package/dist/packages/indexeddb/nosql.repo.service.cjs

@@ -0,0 +1 @@
+const e=require(`../../shared/logic/service/base.service.cjs`),t=require(`../logger/logger.cjs`),n=require(`./indexeddb.service.cjs`);var r=class extends e{constructor(e){super(),this.storeName=e,this._repository=void 0,this.defaultLog=t.GLOBAL_LOGGER.child(`[NoSqlRepo]`),n.INDEXEDDB_SERVICE.onReady(()=>{this._repository=n.INDEXEDDB_SERVICE.getRepository(this.storeName),this.setReady()})}async ensureReady(){if(!this.isReady())return new Promise(e=>this.onReady(e))}get isInitialized(){return this._repository!==void 0}get repository(){if(!this.isInitialized)throw Error(`Repository for ${this.storeName} not initialized`);return this._repository}async persist(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`persist:${this.constructor.name}`);try{return await this.repository.save(e)}finally{n.end()}}async remove(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`remove:${this.constructor.name}`);try{if(e.id===void 0)throw Error(`Cannot remove entity without ID`);return await this.repository.delete(e.id),e}finally{n.end()}}async findById(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`findById:${this.constructor.name}`);try{return await this.repository.get(e)}finally{n.end()}}async findAll(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`findAll:${this.constructor.name}`);try{return await this.repository.getAll()}finally{n.end()}}async clear(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`clear:${this.constructor.name}`);try{await this.repository.clear()}finally{n.end()}}async findByIndex(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`findByIndex:${this.constructor.name}`);try{return await this.repository.findByIndex(e.indexName,e.value)}finally{n.end()}}async findAllByIndex(e,t=this.defaultLog){await this.ensureReady();let n=t.trace(`findAllByIndex:${this.constructor.name}`);try{return await this.repository.findAllByIndex(e.indexName,e.value)}finally{n.end()}}};module.exports=r;

package/dist/packages/indexeddb/nosql.repo.service.d.ts

@@ -0,0 +1,46 @@
+import { default as BaseService } from '../../shared/logic/service/base.service';
+import { NoSqlRepository } from './nosql.repo';
+import { Logger } from '../logger/logger';
+import { IRepository } from '../../shared/contracts/repository.contract';
+/**
+ * NoSqlRepoService
+ *
+ * Clase base para servicios de persistencia basados en IndexedDB (NoSQL).
+ * Implementa IRepository y sigue la convención (payload, logger?).
+ */
+export default class NoSqlRepoService<T extends {
+    id?: string | number;
+}> extends BaseService implements IRepository<T> {
+    private storeName;
+    private _repository;
+    protected defaultLog: Logger;
+    protected constructor(storeName: string);
+    /**
+     * Garantiza que el servicio esté listo antes de operar
+     */
+    protected ensureReady(): Promise<void>;
+    get isInitialized(): boolean;
+    protected get repository(): NoSqlRepository<T>;
+    persist(entity: T, logger?: Logger): Promise<T>;
+    remove(entity: T, logger?: Logger): Promise<T>;
+    findById(id: string | number, logger?: Logger): Promise<T | null>;
+    findAll(_?: any, logger?: Logger): Promise<T[]>;
+    /**
+     * Limpia todo el almacén
+     */
+    clear(_?: any, logger?: Logger): Promise<void>;
+    /**
+     * Busca por índice
+     */
+    protected findByIndex(payload: {
+        indexName: string;
+        value: any;
+    }, logger?: Logger): Promise<T | null>;
+    /**
+     * Busca todos por índice
+     */
+    protected findAllByIndex(payload: {
+        indexName: string;
+        value: any;
+    }, logger?: Logger): Promise<T[]>;
+}

package/dist/packages/indexeddb/nosql.repo.service.esm

@@ -0,0 +1,87 @@
+import e from "../../shared/logic/service/base.service.esm";
+import { GLOBAL_LOGGER as t } from "../logger/logger.esm";
+import { INDEXEDDB_SERVICE as n } from "./indexeddb.service.esm";
+//#region src/packages/indexeddb/nosql.repo.service.ts
+var r = class extends e {
+	constructor(e) {
+		super(), this.storeName = e, this._repository = void 0, this.defaultLog = t.child("[NoSqlRepo]"), n.onReady(() => {
+			this._repository = n.getRepository(this.storeName), this.setReady();
+		});
+	}
+	async ensureReady() {
+		if (!this.isReady()) return new Promise((e) => this.onReady(e));
+	}
+	get isInitialized() {
+		return this._repository !== void 0;
+	}
+	get repository() {
+		if (!this.isInitialized) throw Error(`Repository for ${this.storeName} not initialized`);
+		return this._repository;
+	}
+	async persist(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`persist:${this.constructor.name}`);
+		try {
+			return await this.repository.save(e);
+		} finally {
+			n.end();
+		}
+	}
+	async remove(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`remove:${this.constructor.name}`);
+		try {
+			if (e.id === void 0) throw Error("Cannot remove entity without ID");
+			return await this.repository.delete(e.id), e;
+		} finally {
+			n.end();
+		}
+	}
+	async findById(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`findById:${this.constructor.name}`);
+		try {
+			return await this.repository.get(e);
+		} finally {
+			n.end();
+		}
+	}
+	async findAll(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`findAll:${this.constructor.name}`);
+		try {
+			return await this.repository.getAll();
+		} finally {
+			n.end();
+		}
+	}
+	async clear(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`clear:${this.constructor.name}`);
+		try {
+			await this.repository.clear();
+		} finally {
+			n.end();
+		}
+	}
+	async findByIndex(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`findByIndex:${this.constructor.name}`);
+		try {
+			return await this.repository.findByIndex(e.indexName, e.value);
+		} finally {
+			n.end();
+		}
+	}
+	async findAllByIndex(e, t = this.defaultLog) {
+		await this.ensureReady();
+		let n = t.trace(`findAllByIndex:${this.constructor.name}`);
+		try {
+			return await this.repository.findAllByIndex(e.indexName, e.value);
+		} finally {
+			n.end();
+		}
+	}
+};
+//#endregion
+export { r as default };

package/dist/packages/indexeddb/registry.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=class e{constructor(){this._stores=new Map}static get instance(){return this._instance||=new e,this._instance}register(e){return this._stores.set(e.name,e),e}getStores(){return Array.from(this._stores.values())}getStore(e){return this._stores.get(e)}};e._instance=void 0;var t=e.instance;exports.INDEXEDDB_REGISTRY=t;

package/dist/packages/indexeddb/registry.d.ts

@@ -0,0 +1,21 @@
+import { ObjectStoreConfig } from './types';
+declare class IndexedDbRegistry {
+    private static _instance;
+    private _stores;
+    private constructor();
+    static get instance(): IndexedDbRegistry;
+    /**
+     * Registers an object store configuration
+     */
+    register(config: ObjectStoreConfig): ObjectStoreConfig;
+    /**
+     * Gets all registered stores
+     */
+    getStores(): ObjectStoreConfig[];
+    /**
+     * Gets a specific store configuration by name
+     */
+    getStore(name: string): ObjectStoreConfig | undefined;
+}
+export declare const INDEXEDDB_REGISTRY: IndexedDbRegistry;
+export {};

package/dist/packages/indexeddb/registry.esm

@@ -0,0 +1,22 @@
+//#region src/packages/indexeddb/registry.ts
+var e = class e {
+	constructor() {
+		this._stores = /* @__PURE__ */ new Map();
+	}
+	static get instance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	register(e) {
+		return this._stores.set(e.name, e), e;
+	}
+	getStores() {
+		return Array.from(this._stores.values());
+	}
+	getStore(e) {
+		return this._stores.get(e);
+	}
+};
+e._instance = void 0;
+var t = e.instance;
+//#endregion
+export { t as INDEXEDDB_REGISTRY };

package/dist/packages/indexeddb/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Configuration for an IndexedDB Object Store
+ */
+export interface ObjectStoreConfig {
+    name: string;
+    keyPath: string;
+    autoIncrement?: boolean;
+    indexes?: IndexConfig[];
+}
+/**
+ * Configuration for an IndexedDB Index
+ */
+export interface IndexConfig {
+    name: string;
+    keyPath: string | string[];
+    unique?: boolean;
+    multiEntry?: boolean;
+}
+/**
+ * Configuration for an IndexedDB Database
+ */
+export interface DatabaseConfig {
+    name: string;
+    version: number;
+    stores: ObjectStoreConfig[];
+}
+/**
+ * Generic interface for NoSQL entities
+ */
+export interface BaseEntity {
+    id?: string | number;
+    [key: string]: any;
+}

package/dist/packages/logger/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./registry.cjs`),t=require(`./logger.cjs`);exports.GLOBAL_LOGGER=t.GLOBAL_LOGGER,exports.Logger=t.Logger,exports.TRACE_REGISTRY=e.TRACE_REGISTRY;

package/dist/packages/logger/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logger';
+export * from './registry';

package/dist/packages/logger/index.esm

@@ -0,0 +1,3 @@
+import { TRACE_REGISTRY as e } from "./registry.esm";
+import { GLOBAL_LOGGER as t, Logger as n } from "./logger.esm";
+export { t as GLOBAL_LOGGER, n as Logger, e as TRACE_REGISTRY };

package/dist/packages/logger/logger.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./registry.cjs`);var t={debug:0,info:1,success:2,warn:3,error:4,silent:99},n={debug:`color:#94a3b8;font-weight:600;`,info:`color:#38bdf8;font-weight:600;`,success:`color:#4ade80;font-weight:600;`,warn:`color:#fb923c;font-weight:600;`,error:`color:#f87171;font-weight:600;`,context:`color:#a78bfa;font-weight:700;background:#1e1b4b;padding:1px 4px;border-radius:3px;`,trace:`color:#f0abfc;font-weight:700;background:#4a044e;padding:1px 4px;border-radius:3px;`,ended:`color:#f87171;font-weight:700;`,dim:`color:#475569;`},r={debug:`[⬡ DEBUG  ]`,info:`[◈ INFO   ]`,success:`[◉ SUCCESS]`,warn:`[⚠ WARN   ]`,error:`[✖ ERROR  ]`,silent:``},i=class i{constructor(e){this.context=void 0,this.minLevel=void 0,this.capture=void 0,this.broadcast=void 0,this.traceId=void 0,this.parent=void 0,this.startedAt=void 0,this.history=void 0,this.traces=[],this.ended=!1,this.context=e.context,this.capture=e.capture??!1,this.broadcast=e.broadcast??!1,this.traceId=e._traceId,this.parent=e._parent,this.startedAt=e._startedAt,this.history=e._history??[],this.minLevel=t[e.minLevel??`warn`]}debug(e,t){this._log(`debug`,e,t)}info(e,t){this._log(`info`,e,t)}success(e,t){this._log(`success`,e,t)}warn(e,t){this._log(`warn`,e,t)}error(e,t){this._log(`error`,e,t)}trace(e){let t=e??this._generateTraceId(),n=new Date().toISOString();return new i({context:this.context,minLevel:this._levelName(),capture:this.capture,broadcast:this.broadcast,_traceId:t,_history:[],_parent:this,_startedAt:n})}child(e){return new i({context:`${this.context} › ${e}`,minLevel:this._levelName(),capture:this.capture,broadcast:this.broadcast,_traceId:this.traceId,_history:this.history,_parent:this.parent,_startedAt:this.startedAt})}end(e=`ok`){if(!this.traceId){console.warn(`[Logger] end() llamado en un logger de módulo, no en un trace. Ignorado.`);return}if(this.ended){console.warn(`[Logger] end() llamado más de una vez en trace #${this.traceId}. Ignorado.`);return}this.ended=!0;let t=new Date().toISOString(),r=this.startedAt??t,i=new Date(t).getTime()-new Date(r).getTime(),a={traceId:this.traceId,context:this.context,startedAt:r,endedAt:t,durationMs:i,status:e,entries:[...this.history]};this.parent?._receiveTrace(a);let o=e===`ok`?`◎`:`✖`,s=e===`ok`?n.success:n.error;console.log(`%c${o} %c${this.context}%c #${this.traceId}%c  trace ended — ${i}ms  [${e}]`,s,n.context,n.trace,n.dim)}async timeAsync(e,t){let n=this.child(e),r=performance.now();n.debug(`starting`);try{let e=await t(n),i=(performance.now()-r).toFixed(1);return n.success(`done  ${i}ms`),e}catch(e){let t=(performance.now()-r).toFixed(1);throw n.error(`failed  ${t}ms`,e),e}}time(e,t){let n=this.child(e),r=performance.now();n.debug(`starting`);try{let e=t(n),i=(performance.now()-r).toFixed(1);return n.success(`done  ${i}ms`),e}catch(e){let t=(performance.now()-r).toFixed(1);throw n.error(`failed  ${t}ms`,e),e}}group(e,t){let r=this.traceId?` #${this.traceId}`:``;console.groupCollapsed(`%c${this.context}%c${r}%c  ${e}`,n.context,n.trace,n.dim),t(),console.groupEnd()}getTraces(){return this.traces}dumpTraces(){return JSON.stringify(this.traces,null,2)}getFailedTraces(){return this.traces.filter(e=>e.status===`error`)}clearTraces(){this.traces.length=0}getHistory(){return this.history}dumpHistory(){return JSON.stringify(this.history,null,2)}getTraceId(){return this.traceId}_receiveTrace(t){this.traces.push(t),e.TRACE_REGISTRY.register(t)}_log(e,r,i){if(this.ended){console.warn(`%c[Logger] log ignorado — trace #${this.traceId} ya fue cerrado con end()`,n.ended);return}if(t[e]<this.minLevel)return;let a=new Date().toISOString(),o={level:e,context:this.context,message:r,timestamp:a,...this.traceId!==void 0&&{traceId:this.traceId},...i!==void 0&&{data:i}};(this.capture||this.traceId!==void 0)&&this.history.push(o),this.broadcast&&this._emit(o),this._print(e,r,a,i)}_print(e,t,i,a){let o=r[e],s=i.slice(11,23),c=this.traceId?`#${this.traceId}`:``,l=e===`error`?console.error:e===`warn`?console.warn:console.log,u=c?`%c${o} %c${this.context}%c ${c}%c  ${t}  %c${s}`:`%c${o} %c${this.context}%c  ${t}  %c${s}`,d=c?[n[e],n.context,n.trace,``,n.dim]:[n[e],n.context,``,n.dim];a===void 0?l(u,...d):l(u,...d,a)}_emit(e){window.dispatchEvent(new CustomEvent(`app:log`,{detail:e}))}_levelName(){return Object.keys(t).find(e=>t[e]===this.minLevel)??`debug`}_generateTraceId(){return Math.random().toString(16).slice(2,10)}},a=new i({context:`GLOBAL`});exports.GLOBAL_LOGGER=a,exports.Logger=i;

package/dist/packages/logger/logger.d.ts

@@ -0,0 +1,137 @@
+export type LogLevel = 'debug' | 'info' | 'success' | 'warn' | 'error' | 'silent';
+export interface LogEntry {
+    level: LogLevel;
+    context: string;
+    message: string;
+    timestamp: string;
+    traceId?: string;
+    data?: unknown;
+}
+/** Snapshot que el padre guarda al recibir un flush */
+export interface TraceRecord {
+    traceId: string;
+    context: string;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    status: 'ok' | 'error';
+    entries: LogEntry[];
+}
+export interface LoggerOptions {
+    context: string;
+    minLevel?: LogLevel;
+    capture?: boolean;
+    broadcast?: boolean;
+    _traceId?: string;
+    _history?: LogEntry[];
+    _parent?: Logger;
+    _startedAt?: string;
+}
+export declare class Logger {
+    private readonly context;
+    private readonly minLevel;
+    private readonly capture;
+    private readonly broadcast;
+    private readonly traceId;
+    private readonly parent;
+    private readonly startedAt;
+    private readonly history;
+    private readonly traces;
+    private ended;
+    constructor(options: LoggerOptions);
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    success(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    /**
+     * Crea un logger de operación.
+     * - Genera un traceId único (o reutiliza uno externo)
+     * - Guarda referencia al padre (this) para el flush en end()
+     * - Comparte una historia vacía entre todos sus children
+     *
+     * @example
+     * const op = authLogger.trace()
+     * // ... operación ...
+     * op.end()   // ← flush al padre al terminar
+     */
+    trace(externalTraceId?: string): Logger;
+    /**
+     * Crea un sub-logger con contexto anidado.
+     * Hereda traceId, historia y padre — es parte del mismo trace.
+     *
+     * @example
+     * const op    = authLogger.trace()       // [auth] #a3f9
+     * const apiOp = op.child('api')          // [auth › api] #a3f9 — mismo trace
+     */
+    child(subContext: string): Logger;
+    /**
+     * Cierra el trace y hace flush al padre.
+     *
+     * El padre (logger de módulo) guarda un TraceRecord con:
+     * - traceId, contexto, timestamps, duración, status, y todos los entries
+     *
+     * Después de end(), cualquier intento de loguear emite un warning y no-op.
+     *
+     * @param status - 'ok' (default) o 'error' si el use case terminó con fallo
+     *
+     * @example
+     * const op = authLogger.trace()
+     * try {
+     *   await doSomething(op)
+     *   op.success('done')
+     *   op.end()              // flush con status 'ok'
+     * } catch (err) {
+     *   op.error('failed', err)
+     *   op.end('error')       // flush con status 'error'
+     *   throw err
+     * }
+     */
+    end(status?: 'ok' | 'error'): void;
+    /**
+     * Mide el tiempo de ejecución de una función async.
+     * Propaga traceId y padre automáticamente.
+     *
+     * @example
+     * const user = await op.timeAsync('fetchUser', async (scoped) => {
+     *   scoped.debug('calling endpoint')
+     *   return api.getUser(id)
+     * })
+     */
+    timeAsync<T>(label: string, fn: (scoped: Logger) => Promise<T>): Promise<T>;
+    time<T>(label: string, fn: (scoped: Logger) => T): T;
+    /**
+     * Agrupa logs visualmente en devtools.
+     */
+    group(label: string, fn: () => void): void;
+    /**
+     * Retorna todos los TraceRecords completados que este módulo ha recibido.
+     * Solo disponible en loggers de módulo (sin traceId).
+     *
+     * @example
+     * authLogger.getTraces()
+     * // → [{ traceId: 'a3f9', status: 'ok', durationMs: 143, entries: [...] }, ...]
+     */
+    getTraces(): ReadonlyArray<TraceRecord>;
+    /**
+     * Dump estructurado de todo el audit log del módulo.
+     * Ideal para mandar a Sentry, DataDog, o una IA para análisis post-mortem.
+     */
+    dumpTraces(): string;
+    /**
+     * Retorna solo los traces fallidos.
+     */
+    getFailedTraces(): ReadonlyArray<TraceRecord>;
+    clearTraces(): void;
+    getHistory(): ReadonlyArray<LogEntry>;
+    dumpHistory(): string;
+    getTraceId(): string | undefined;
+    /** Llamado por end() del trace hijo — no usar directamente */
+    _receiveTrace(record: TraceRecord): void;
+    private _log;
+    private _print;
+    private _emit;
+    private _levelName;
+    private _generateTraceId;
+}
+export declare const GLOBAL_LOGGER: Logger;