ckeditor5-blazor 0.1.0

package/src/shared/wait-for.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import { waitFor } from './wait-for.js';
+
+describe('waitFor', () => {
+  it('should resolve when the callback succeeds', async () => {
+    const result = await waitFor(() => Promise.resolve('success'));
+
+    expect(result).toBe('success');
+  });
+
+  it('should reject when the callback throws an error', async () => {
+    await expect(waitFor(() => Promise.reject(new Error('failed')))).rejects.toThrow('failed');
+  });
+
+  it('should reject when the timeout is reached', async () => {
+    await expect(
+      waitFor(() => new Promise(resolve => setTimeout(resolve, 2000)), {
+        timeOutAfter: 200,
+        retryAfter: 100,
+      }),
+    ).rejects.toThrow('Timeout');
+  });
+});

package/src/shared/wait-for.ts

@@ -0,0 +1,56 @@
+import type { CanBePromise } from '../types';
+
+/**
+ * Waits for the provided callback to succeed. The callback is executed multiple times until it succeeds or the timeout is reached.
+ * It's executed immediately and then with a delay defined by the `retry` option.
+ *
+ * @param callback The callback to execute.
+ * @param config Configuration for the function.
+ * @param config.timeOutAfter The maximum time to wait for the callback to succeed, in milliseconds. Default is 500ms.
+ * @param config.retryAfter The time to wait between retries, in milliseconds. Default is 100ms.
+ * @returns A promise that resolves when the callback succeeds.
+ */
+export function waitFor<R>(
+  callback: () => CanBePromise<R>,
+  {
+    timeOutAfter = 500,
+    retryAfter = 100,
+  }: WaitForConfig = {},
+): Promise<R> {
+  return new Promise<R>((resolve, reject) => {
+    const startTime = Date.now();
+    let lastError: Error | null = null;
+
+    const timeoutTimerId = setTimeout(() => {
+      reject(lastError ?? new Error('Timeout'));
+    }, timeOutAfter);
+
+    const tick = async () => {
+      try {
+        const result = await callback();
+        clearTimeout(timeoutTimerId);
+        resolve(result);
+      }
+      catch (err: any) {
+        lastError = err;
+
+        if (Date.now() - startTime > timeOutAfter) {
+          reject(err);
+        }
+        else {
+          setTimeout(tick, retryAfter);
+        }
+      }
+    };
+
+    void tick();
+  });
+}
+
+/**
+ * Configuration for the `waitFor` function.
+ */
+export type WaitForConfig = {
+  timeOutAfter?: number;
+  retryAfter?: number;
+};

package/src/types/can-be-promise.type.ts

@@ -0,0 +1 @@
+export type CanBePromise<T> = T | Promise<T>;

package/src/types/dot-net-interop.type.ts

@@ -0,0 +1,6 @@
+/**
+ * Represents the .NET interop helper for communication with Blazor.
+ */
+export type DotNetInterop = {
+  invokeMethodAsync: (methodName: string, ...args: any[]) => Promise<void>;
+};

package/src/types/dotnet-global.d.ts

@@ -0,0 +1,14 @@
+export {};
+
+declare global {
+  // eslint-disable-next-line vars-on-top
+  var DotNet: {
+    createJSObjectReference: <T extends object>(obj: T) => object;
+    disposeJSObjectReference: (ref: object) => void;
+  };
+
+  // eslint-disable-next-line ts/consistent-type-definitions
+  interface GlobalThis {
+    DotNet: typeof DotNet;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './can-be-promise.type';
+export * from './dot-net-interop.type';
+export * from './required-by.type';

package/src/types/required-by.type.ts

@@ -0,0 +1 @@
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;