@develia/commons 0.4.16 → 0.4.19

package/src/collections/index.ts

@@ -1,4 +1,4 @@
-export {default as DefaultWeakMap} from './default-weak-map.js';
-export {default as DefaultMap} from './default-map.js';
-export {default as CacheDictionary} from './cache-dictionary.js';
+export {default as DefaultWeakMap} from './default-weak-map.js';
+export {default as DefaultMap} from './default-map.js';
+export {default as CacheDictionary} from './cache-dictionary.js';
 export {default as from} from './from.js';

package/src/draft.ts

@@ -69,6 +69,53 @@ type ParentLink = {
     keyInParent: PropertyKey;
 };
 
+const DRAFT_MATERIALIZE = Symbol("draft.materialize");
+
+type InternalDraft = Draft<any> & {
+    [DRAFT_MATERIALIZE]: () => any;
+};
+
+function isDraftValue(value: any): value is InternalDraft {
+    return value !== null &&
+        typeof value === "object" &&
+        typeof value[DRAFT_MATERIALIZE] === "function";
+}
+
+function materializeDraftValue(value: any): any {
+    if (isDraftValue(value)) return value[DRAFT_MATERIALIZE]();
+    if (value === null || typeof value !== "object") return value;
+
+    const objectValue = value as any;
+    if (objectValue instanceof Date) return new Date(objectValue);
+    if (objectValue instanceof RegExp) return new RegExp(objectValue);
+
+    if (objectValue instanceof Map) {
+        const copy = new Map();
+        for (const [k, v] of objectValue) {
+            copy.set(materializeDraftValue(k), materializeDraftValue(v));
+        }
+        return copy;
+    }
+
+    if (objectValue instanceof Set) {
+        const copy = new Set();
+        for (const v of objectValue) {
+            copy.add(materializeDraftValue(v));
+        }
+        return copy;
+    }
+
+    const copy: any = Array.isArray(objectValue)
+        ? []
+        : Object.create(Object.getPrototypeOf(objectValue));
+
+    for (const key of Reflect.ownKeys(objectValue)) {
+        copy[key] = materializeDraftValue(objectValue[key]);
+    }
+
+    return copy;
+}
+
 // ─────────────────────────────────────────────
 // deepDraft (internal)
 // ─────────────────────────────────────────────
@@ -143,12 +190,9 @@ export default function draft<T extends object>(
      */
     const applyCommit = (key: PropertyKey): void => {
         const val = copy[key];
-        if (
-            val !== null &&
-            typeof val === "object" &&
-            "commit" in val
-        ) {
-            (val as Draft<any>).commit();
+        if (isDraftValue(val)) {
+            val.commit();
+            (original as any)[key] = materializeDraftValue(val);
             return;
         }
         if (key in copy) {
@@ -162,17 +206,11 @@ export default function draft<T extends object>(
      * otherwise restore the value from `original`.
      */
     const applyRollback = (key: PropertyKey): void => {
-        const val = copy[key];
-        if (
-            val !== null &&
-            typeof val === "object" &&
-            "rollback" in val
-        ) {
-            (val as Draft<any>).rollback();
-            return;
-        }
         if (key in original) {
-            copy[key] = (original as any)[key];
+            copy[key] = deepDraft((original as any)[key], {
+                parent: methods,
+                keyInParent: key,
+            });
         } else {
             delete copy[key];
         }
@@ -239,6 +277,7 @@ export default function draft<T extends object>(
 
     return new Proxy(copy, {
         get(target, prop, receiver) {
+            if (prop === DRAFT_MATERIALIZE) return () => materializeDraftValue(target);
             if (isMethodKey(prop)) return (methods as any)[prop];
             return Reflect.get(target, prop, receiver);
         },

package/src/event-bus.ts

@@ -1,84 +1,84 @@
-// event.ts
-
-export abstract class Event {
-    readonly timestamp: Date;
-
-    protected constructor() {
-        this.timestamp = new Date();
-    }
-
-    toString(): string {
-        return `${this.constructor.name}(${this.timestamp.toISOString()})`;
-    }
-}
-
-type EventClass<T extends Event> = new (...args: any[]) => T;
-type Handler<T extends Event> = (event: T) => void;
-
-interface HandlerWrapper {
-    original: Function;
-    wrapped: (event: Event) => void;
-}
-
-export class EventBus {
-    private static _instance: EventBus | null = null;
-
-    static get shared(): EventBus {
-        return this._instance ??= new EventBus();
-    }
-
-    private _handlers = new Map<Function, HandlerWrapper[]>();
-
-    on<T extends Event>(type: EventClass<T>, handler: Handler<T>): void {
-        if (!this._handlers.has(type)) {
-            this._handlers.set(type, []);
-        }
-        this._handlers.get(type)!.push({
-            original: handler,
-            wrapped: (event: Event) => handler(event as T),
-        });
-    }
-
-    off<T extends Event>(type: EventClass<T>, handler: Handler<T>): void {
-        const handlers = this._handlers.get(type);
-        if (!handlers) return;
-
-        let index = handlers.findIndex((h) => h.original === handler);
-        if (index !== -1) {
-            handlers.splice(index, 1);
-        }
-    }
-
-    emit<T extends Event>(event: T): void {
-        const handlers = this._handlers.get(event.constructor);
-        if (!handlers) return;
-
-        for (const handler of [...handlers]) {
-            try {
-                handler.wrapped(event);
-            } catch (e) {
-                console.error(`[EventBus] Error en handler de ${event.constructor.name}:`, e);
-            }
-        }
-    }
-
-    once<T extends Event>(type: EventClass<T>, handler: Handler<T>): void {
-        const wrapper: Handler<T> = (event: T) => {
-            handler(event);
-            this.off(type, wrapper);
-        };
-        this.on(type, wrapper);
-    }
-
-    clear<T extends Event>(type: EventClass<T>): void {
-        this._handlers.delete(type);
-    }
-
-    clearAll(): void {
-        this._handlers.clear();
-    }
-
-    hasListeners<T extends Event>(type: EventClass<T>): boolean {
-        return (this._handlers.get(type)?.length ?? 0) > 0;
-    }
+// event.ts
+
+export abstract class Event {
+    readonly timestamp: Date;
+
+    protected constructor() {
+        this.timestamp = new Date();
+    }
+
+    toString(): string {
+        return `${this.constructor.name}(${this.timestamp.toISOString()})`;
+    }
+}
+
+type EventClass<T extends Event> = new (...args: any[]) => T;
+type Handler<T extends Event> = (event: T) => void;
+
+interface HandlerWrapper {
+    original: Function;
+    wrapped: (event: Event) => void;
+}
+
+export class EventBus {
+    private static _instance: EventBus | null = null;
+
+    static get shared(): EventBus {
+        return this._instance ??= new EventBus();
+    }
+
+    private _handlers = new Map<Function, HandlerWrapper[]>();
+
+    on<T extends Event>(type: EventClass<T>, handler: Handler<T>): void {
+        if (!this._handlers.has(type)) {
+            this._handlers.set(type, []);
+        }
+        this._handlers.get(type)!.push({
+            original: handler,
+            wrapped: (event: Event) => handler(event as T),
+        });
+    }
+
+    off<T extends Event>(type: EventClass<T>, handler: Handler<T>): void {
+        const handlers = this._handlers.get(type);
+        if (!handlers) return;
+
+        let index = handlers.findIndex((h) => h.original === handler);
+        if (index !== -1) {
+            handlers.splice(index, 1);
+        }
+    }
+
+    emit<T extends Event>(event: T): void {
+        const handlers = this._handlers.get(event.constructor);
+        if (!handlers) return;
+
+        for (const handler of [...handlers]) {
+            try {
+                handler.wrapped(event);
+            } catch (e) {
+                console.error(`[EventBus] Error en handler de ${event.constructor.name}:`, e);
+            }
+        }
+    }
+
+    once<T extends Event>(type: EventClass<T>, handler: Handler<T>): void {
+        const wrapper: Handler<T> = (event: T) => {
+            this.off(type, wrapper);
+            handler(event);
+        };
+        this.on(type, wrapper);
+    }
+
+    clear<T extends Event>(type: EventClass<T>): void {
+        this._handlers.delete(type);
+    }
+
+    clearAll(): void {
+        this._handlers.clear();
+    }
+
+    hasListeners<T extends Event>(type: EventClass<T>): boolean {
+        return (this._handlers.get(type)?.length ?? 0) > 0;
+    }
 }