livekit-client 1.9.3 → 1.9.5

package/src/utils/AsyncQueue.test.ts

@@ -0,0 +1,99 @@
+import { sleep } from '../room/utils';
+import { AsyncQueue } from './AsyncQueue';
+
+describe('asyncQueue', () => {
+  it('runs multiple tasks in order', async () => {
+    const queue = new AsyncQueue();
+    const tasksExecuted: number[] = [];
+
+    for (let i = 0; i < 5; i++) {
+      queue.run(async () => {
+        await sleep(50);
+        tasksExecuted.push(i);
+      });
+    }
+    await queue.flush();
+    expect(tasksExecuted).toMatchObject([0, 1, 2, 3, 4]);
+  });
+  it('runs tasks sequentially and not in parallel', async () => {
+    const queue = new AsyncQueue();
+    const results: number[] = [];
+    for (let i = 0; i < 5; i++) {
+      queue.run(async () => {
+        results.push(i);
+        await sleep(10);
+        results.push(i);
+      });
+    }
+    await queue.flush();
+    expect(results).toMatchObject([0, 0, 1, 1, 2, 2, 3, 3, 4, 4]);
+  });
+  it('continues executing tasks if one task throws an error', async () => {
+    const queue = new AsyncQueue();
+
+    let task1threw = false;
+    let task2Executed = false;
+
+    queue
+      .run(async () => {
+        await sleep(100);
+        throw Error('task 1 throws');
+      })
+      .catch(() => {
+        task1threw = true;
+      });
+
+    await queue
+      .run(async () => {
+        task2Executed = true;
+      })
+      .catch(() => {
+        fail('task 2 should not have thrown');
+      });
+
+    expect(task1threw).toBeTruthy();
+    expect(task2Executed).toBeTruthy();
+  });
+  it('returns the result of the task', async () => {
+    const queue = new AsyncQueue();
+
+    const result = await queue.run(async () => {
+      await sleep(10);
+      return 'result';
+    });
+
+    expect(result).toBe('result');
+  });
+  it('returns only when the enqueued task and all previous tasks have completed', async () => {
+    const queue = new AsyncQueue();
+    const tasksExecuted: number[] = [];
+    for (let i = 0; i < 10; i += 1) {
+      queue.run(async () => {
+        await sleep(10);
+        tasksExecuted.push(i);
+        return i;
+      });
+    }
+
+    const result = await queue.run(async () => {
+      await sleep(10);
+      tasksExecuted.push(999);
+      return 'result';
+    });
+
+    expect(result).toBe('result');
+    expect(tasksExecuted).toMatchObject([...new Array(10).fill(0).map((_, idx) => idx), 999]);
+  });
+  it('can handle queue sizes of up to 10_000 tasks', async () => {
+    const queue = new AsyncQueue();
+    const tasksExecuted: number[] = [];
+
+    for (let i = 0; i < 10_000; i++) {
+      queue.run(async () => {
+        tasksExecuted.push(i);
+      });
+    }
+    await queue.flush();
+    expect(tasksExecuted).toMatchObject(new Array(10_000).fill(0).map((_, idx) => idx));
+  });
+});

package/src/utils/AsyncQueue.ts

@@ -0,0 +1,57 @@
+import { Mutex } from '../room/utils';
+
+type QueueTask<T> = () => PromiseLike<T>;
+
+enum QueueTaskStatus {
+  'WAITING',
+  'RUNNING',
+  'COMPLETED',
+}
+
+type QueueTaskInfo = {
+  id: number;
+  enqueuedAt: number;
+  executedAt?: number;
+  status: QueueTaskStatus;
+};
+
+export class AsyncQueue {
+  private pendingTasks: Map<number, QueueTaskInfo>;
+
+  private taskMutex: Mutex;
+
+  private nextTaskIndex: number;
+
+  constructor() {
+    this.pendingTasks = new Map();
+    this.taskMutex = new Mutex();
+    this.nextTaskIndex = 0;
+  }
+
+  async run<T>(task: QueueTask<T>) {
+    const taskInfo: QueueTaskInfo = {
+      id: this.nextTaskIndex++,
+      enqueuedAt: Date.now(),
+      status: QueueTaskStatus.WAITING,
+    };
+    this.pendingTasks.set(taskInfo.id, taskInfo);
+    const unlock = await this.taskMutex.lock();
+    try {
+      taskInfo.executedAt = Date.now();
+      taskInfo.status = QueueTaskStatus.RUNNING;
+      return await task();
+    } finally {
+      taskInfo.status = QueueTaskStatus.COMPLETED;
+      this.pendingTasks.delete(taskInfo.id);
+      unlock();
+    }
+  }
+
+  async flush() {
+    return this.run(async () => {});
+  }
+
+  snapshot() {
+    return Array.from(this.pendingTasks.values());
+  }
+}

package/src/utils/browserParser.test.ts

@@ -0,0 +1,58 @@
+import { compareVersions } from '../room/utils';
+import { getBrowser } from './browserParser';
+
+describe('browser parser', () => {
+  const safariUA =
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15';
+  const firefoxUA =
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/112.0';
+
+  const chromeUA =
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36';
+
+  const braveUA =
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36';
+
+  it('parses Safari correctly', () => {
+    const details = getBrowser(safariUA, true);
+    expect(details?.name).toBe('Safari');
+    expect(details?.version).toBe('16.3');
+  });
+  it('parses Firefox correctly', () => {
+    const details = getBrowser(firefoxUA, true);
+    expect(details?.name).toBe('Firefox');
+    expect(details?.version).toBe('112.0');
+  });
+  it('parses Chrome correctly', () => {
+    const details = getBrowser(chromeUA, true);
+    expect(details?.name).toBe('Chrome');
+    expect(details?.version).toBe('112.0.0.0');
+  });
+  it('detects brave as chromium based', () => {
+    const details = getBrowser(braveUA, true);
+    expect(details?.name).toBe('Chrome');
+    expect(details?.version).toBe('103.0.5060.134');
+  });
+});
+
+describe('version compare', () => {
+  it('compares versions correctly', () => {
+    expect(compareVersions('12.3.5', '11.8.9')).toBe(1);
+    expect(compareVersions('12.3.5', '12.3.5')).toBe(0);
+    expect(compareVersions('12.3.5', '14.1.5')).toBe(-1);
+  });
+  it('can handle different version lengths', () => {
+    expect(compareVersions('12', '11.8.9')).toBe(1);
+    expect(compareVersions('12', '12.0.0')).toBe(0);
+    expect(compareVersions('12', '14.1.5')).toBe(-1);
+
+    expect(compareVersions('12.3.5', '11')).toBe(1);
+    expect(compareVersions('12.0.0', '12')).toBe(0);
+    expect(compareVersions('12.3.5', '14')).toBe(-1);
+  });
+
+  it('treats empty strings as smaller', () => {
+    expect(compareVersions('12', '')).toBe(1);
+    expect(compareVersions('', '12.0.0')).toBe(-1);
+  });
+});

package/src/utils/browserParser.ts

@@ -0,0 +1,72 @@
+// tiny, simplified version of https://github.com/lancedikson/bowser/blob/master/src/parser-browsers.js
+// reduced to only differentiate Chrome(ium) based browsers / Firefox / Safari
+
+const commonVersionIdentifier = /version\/(\d+(\.?_?\d+)+)/i;
+
+export type DetectableBrowser = 'Chrome' | 'Firefox' | 'Safari';
+
+export type BrowserDetails = {
+  name: DetectableBrowser;
+  version: string;
+};
+
+let browserDetails: BrowserDetails | undefined;
+
+/**
+ * @internal
+ */
+export function getBrowser(userAgent?: string, force = true) {
+  if (
+    userAgent === undefined &&
+    (typeof document !== 'undefined' || typeof navigator === 'undefined')
+  ) {
+    return;
+  }
+  const ua = (userAgent ?? navigator.userAgent).toLowerCase();
+  if (browserDetails === undefined || force) {
+    const browser = browsersList.find(({ test }) => test.test(ua));
+    browserDetails = browser?.describe(ua);
+  }
+  return browserDetails;
+}
+
+const browsersList = [
+  {
+    test: /firefox|iceweasel|fxios/i,
+    describe(ua: string) {
+      const browser: BrowserDetails = {
+        name: 'Firefox',
+        version: getMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, ua),
+      };
+      return browser;
+    },
+  },
+  {
+    test: /chrom|crios|crmo/i,
+    describe(ua: string) {
+      const browser: BrowserDetails = {
+        name: 'Chrome',
+        version: getMatch(/(?:chrome|chromium|crios|crmo)\/(\d+(\.?_?\d+)+)/i, ua),
+      };
+
+      return browser;
+    },
+  },
+  /* Safari */
+  {
+    test: /safari|applewebkit/i,
+    describe(ua: string) {
+      const browser: BrowserDetails = {
+        name: 'Safari',
+        version: getMatch(commonVersionIdentifier, ua),
+      };
+
+      return browser;
+    },
+  },
+];
+
+function getMatch(exp: RegExp, ua: string, id = 1) {
+  const match = ua.match(exp);
+  return (match && match.length >= id && match[id]) || '';
+}