ckeditor5-blazor 1.9.0 → 1.10.0

package/src/shared/async-registry.ts

@@ -1,3 +1,5 @@
+import { areMapsEqual } from './are-maps-equal';
+
 /**
  * Generic async registry for objects with an async destroy method.
  * Provides a way to register, unregister, and execute callbacks on objects by ID.
@@ -23,6 +25,18 @@ export class AsyncRegistry<T extends Destructible> {
    */
   private readonly watchers = new Set<RegistryWatcher<T>>();
 
+  /**
+   * Batch nesting depth. When > 0, watcher notifications are deferred.
+   */
+  private batchDepth = 0;
+
+  /**
+   * Snapshot of the last state dispatched to watchers, used for change detection.
+   */
+  private lastNotifiedItems: Map<any, any> | null = null;
+
+  private lastNotifiedErrors: Map<any, any> | null = null;
+
   /**
    * Executes a function on an item.
    * If the item is not yet registered, it will wait for it to be registered.
@@ -68,6 +82,66 @@ export class AsyncRegistry<T extends Destructible> {
     });
   }
 
+  /**
+   * Reactively binds a mount/unmount lifecycle to a single registry item.
+   *
+   * @param id The ID of the item to observe.
+   * @param onMount Function executed when the item mounts.
+   * @returns A function that stops observing and immediately runs any pending cleanup.
+   */
+  mountEffect<E extends T = T>(
+    id: RegistryId | null,
+    onMount: (item: E) => (() => void) | void,
+  ): () => void {
+    let cleanup: VoidFunction | void;
+    let mountedItem: T | undefined;
+    let unmounted = false;
+
+    const unwatch = this.watch((items) => {
+      const item = items.get(id);
+
+      if (item === mountedItem) {
+        return;
+      }
+
+      cleanup?.();
+      cleanup = undefined;
+      mountedItem = item;
+
+      if (!item) {
+        return;
+      }
+
+      try {
+        const newCleanup = onMount(item as E);
+
+        if (unmounted) {
+          newCleanup?.();
+          unwatch();
+        }
+        else {
+          cleanup = newCleanup;
+        }
+      }
+      catch (err) {
+        /* v8 ignore start -- @preserve */
+        console.error(err);
+        throw err;
+        /* v8 ignore end */
+      }
+    });
+
+    return () => {
+      unmounted = true;
+
+      if (mountedItem) {
+        unwatch();
+        cleanup?.();
+        cleanup = undefined;
+      }
+    };
+  }
+
   /**
    * Registers an item.
    *
@@ -75,24 +149,27 @@ export class AsyncRegistry<T extends Destructible> {
    * @param item The item instance.
    */
   register(id: RegistryId | null, item: T): void {
-    if (this.items.has(id)) {
-      throw new Error(`Item with ID "${id}" is already registered.`);
-    }
+    this.batch(() => {
+      if (this.items.has(id)) {
+        throw new Error(`Item with ID "${id}" is already registered.`);
+      }
 
-    this.resetErrors(id);
-    this.items.set(id, item);
+      this.resetErrors(id);
+      this.items.set(id, item);
 
-    // Execute all pending callbacks for this item (synchronously).
-    const pending = this.pendingCallbacks.get(id);
+      // Execute all pending callbacks for this item (synchronously).
+      const pending = this.pendingCallbacks.get(id);
 
-    if (pending) {
-      pending.success.forEach(callback => callback(item));
-      this.pendingCallbacks.delete(id);
-    }
+      if (pending) {
+        pending.success.forEach(callback => callback(item));
+        this.pendingCallbacks.delete(id);
+      }
 
-    // Register the first item as the default item (null ID).
-    this.registerAsDefault(id, item);
-    this.notifyWatchers();
+      // Register the first item as the default item (null ID).
+      if (this.items.size === 1 && id !== null) {
+        this.register(null, item);
+      }
+    });
   }
 
   /**
@@ -102,24 +179,23 @@ export class AsyncRegistry<T extends Destructible> {
    * @param error The error to register.
    */
   error(id: RegistryId | null, error: any): void {
-    this.items.delete(id);
-    this.initializationErrors.set(id, error);
+    this.batch(() => {
+      this.items.delete(id);
+      this.initializationErrors.set(id, error);
 
-    // Execute all pending error callbacks for this item.
-    const pending = this.pendingCallbacks.get(id);
+      // Execute all pending error callbacks for this item.
+      const pending = this.pendingCallbacks.get(id);
 
-    if (pending) {
-      pending.error.forEach(callback => callback(error));
-      this.pendingCallbacks.delete(id);
-    }
-
-    // Set as default error if this is the first error and no items exist.
-    if (this.initializationErrors.size === 1 && !this.items.size) {
-      this.error(null, error);
-    }
+      if (pending) {
+        pending.error.forEach(callback => callback(error));
+        this.pendingCallbacks.delete(id);
+      }
 
-    // Notify watchers about the error state.
-    this.notifyWatchers();
+      // Set as default error if this is the first error and no items exist.
+      if (this.initializationErrors.size === 1 && !this.items.size) {
+        this.error(null, error);
+      }
+    });
   }
 
   /**
@@ -142,21 +218,23 @@ export class AsyncRegistry<T extends Destructible> {
    * Un-registers an item.
    *
    * @param id The ID of the item.
+   * @param resetPendingCallbacks If true resets pending callbacks.
    */
-  unregister(id: RegistryId | null): void {
-    if (!this.items.has(id)) {
-      throw new Error(`Item with ID "${id}" is not registered.`);
-    }
+  unregister(id: RegistryId | null, resetPendingCallbacks: boolean = true): void {
+    this.batch(() => {
+      // If unregistering the default item, clear it.
+      if (id && this.items.get(null) === this.items.get(id)) {
+        this.unregister(null, false);
+      }
 
-    // If unregistering the default item, clear it.
-    if (id && this.items.get(null) === this.items.get(id)) {
-      this.unregister(null);
-    }
+      this.items.delete(id);
 
-    this.items.delete(id);
-    this.pendingCallbacks.delete(id);
+      if (resetPendingCallbacks) {
+        this.pendingCallbacks.delete(id);
+      }
 
-    this.notifyWatchers();
+      this.resetErrors(id);
+    });
   }
 
   /**
@@ -168,6 +246,15 @@ export class AsyncRegistry<T extends Destructible> {
     return Array.from(this.items.values());
   }
 
+  /**
+   * Returns single registered item.
+   *
+   * @returns Registered item.
+   */
+  getItem(id: RegistryId | null): T | undefined {
+    return this.items.get(id);
+  }
+
   /**
    * Checks if an item with the given ID is registered.
    *
@@ -183,46 +270,11 @@ export class AsyncRegistry<T extends Destructible> {
    * If the item is not registered yet, it will wait for it to be registered.
    *
    * @param id The ID of the item.
-   * @param timeout Optional timeout in milliseconds.
    * @returns A promise that resolves with the item instance.
    */
-  waitFor<E extends T = T>(id: RegistryId | null, timeout?: number): Promise<E> {
+  waitFor<E extends T = T>(id: RegistryId | null): Promise<E> {
     return new Promise<E>((resolve, reject) => {
-      let exceedTimeout = false;
-      let timer: ReturnType<typeof setTimeout> | null = null;
-
-      void this.execute(
-        id,
-        (value: E) => {
-          if (exceedTimeout) {
-            return;
-          }
-
-          if (timer !== null) {
-            clearTimeout(timer!);
-          }
-
-          (resolve as (value: E) => void)(value);
-        },
-        (error: any) => {
-          if (exceedTimeout) {
-            return;
-          }
-
-          if (timer !== null) {
-            clearTimeout(timer!);
-          }
-
-          reject(error);
-        },
-      );
-
-      if (timeout) {
-        timer = setTimeout(() => {
-          exceedTimeout = true;
-          reject(new Error(`Timeout waiting for item with ID "${id}" to be registered.`));
-        }, timeout);
-      }
+      void this.execute(id, resolve as (value: E) => void, reject);
     });
   }
 
@@ -242,7 +294,41 @@ export class AsyncRegistry<T extends Destructible> {
 
     await Promise.all(promises);
 
-    this.notifyWatchers();
+    this.flushWatchers();
+  }
+
+  /**
+   * Destroys all registered editors and removes all watchers.
+   */
+  async reset() {
+    await this.destroyAll();
+    this.watchers.clear();
+  }
+
+  /**
+   * Executes a callback while deferring all watcher notifications.
+   * A single notification is fired synchronously after the callback returns,
+   * but only if the registry actually changed.
+   *
+   * Batches can be nested — watchers are notified only when the outermost
+   * batch completes.
+   *
+   * @param fn The callback to execute.
+   * @returns The return value of the callback.
+   */
+  batch<R>(fn: () => R): R {
+    this.batchDepth++;
+
+    try {
+      return fn();
+    }
+    finally {
+      this.batchDepth--;
+
+      if (this.batchDepth === 0) {
+        this.flushWatchers();
+      }
+    }
   }
 
   /**
@@ -273,25 +359,23 @@ export class AsyncRegistry<T extends Destructible> {
   }
 
   /**
-   * Resets the registry by clearing all items, errors, and pending callbacks.
+   * Immediately dispatches the current state to all watchers if it changed.
    */
-  reset(): void {
-    this.items.clear();
-    this.initializationErrors.clear();
-    this.pendingCallbacks.clear();
-    this.notifyWatchers();
-  }
+  private flushWatchers(): void {
+    if (
+      areMapsEqual(this.lastNotifiedItems, this.items)
+      && areMapsEqual(this.lastNotifiedErrors, this.initializationErrors)
+    ) {
+      return;
+    }
 
-  /**
-   * Notifies all watchers about changes to the registry.
-   */
-  private notifyWatchers(): void {
-    this.watchers.forEach(
-      watcher => watcher(
-        new Map(this.items),
-        new Map(this.initializationErrors),
-      ),
-    );
+    this.lastNotifiedItems = new Map(this.items);
+    this.lastNotifiedErrors = new Map(this.initializationErrors);
+
+    this.watchers.forEach(watcher => watcher(
+      new Map(this.items),
+      new Map(this.initializationErrors),
+    ));
   }
 
   /**
@@ -310,18 +394,6 @@ export class AsyncRegistry<T extends Destructible> {
 
     return pending;
   }
-
-  /**
-   * Registers an item as the default (null ID) item if it's the first one.
-   *
-   * @param id The ID of the item being registered.
-   * @param item The item instance.
-   */
-  private registerAsDefault(id: RegistryId | null, item: T): void {
-    if (this.items.size === 1 && id !== null) {
-      this.register(null, item);
-    }
-  }
 }
 
 /**

package/src/shared/index.ts

@@ -1,3 +1,4 @@
+export * from './are-maps-equal';
 export * from './async-registry';
 export * from './camel-case';
 export * from './debounce';