Merge pull request #63 from robonen/feat/sync-mutex

fix(packages/stdlib): add SyncMutex primitive

packages/stdlib/src/index.ts

@@ -5,6 +5,7 @@ export * from './math';
 export * from './objects';
 export * from './patterns';
 export * from './structs';
+export * from './sync';
 export * from './text';
 export * from './types';
 export * from './utils'

packages/stdlib/src/sync/index.ts

@@ -0,0 +1 @@
+export * from './mutex';

packages/stdlib/src/sync/mutex/index.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SyncMutex } from '.';
+
+describe('SyncMutex', () => {
+  let mutex: SyncMutex;
+
+  beforeEach(() => {
+    mutex = new SyncMutex();
+  });
+
+  it('unlocked by default', () => {
+    expect(mutex.isLocked).toBe(false);
+  });
+
+  it('lock the mutex', () => {
+    mutex.lock();
+  
+    expect(mutex.isLocked).toBe(true);
+  });
+
+  it('remain locked when locked multiple times', () => {
+    mutex.lock();
+    mutex.lock();
+  
+    expect(mutex.isLocked).toBe(true);
+  });
+
+  it('unlock a locked mutex', () => {
+    mutex.lock();
+    mutex.unlock();
+  
+    expect(mutex.isLocked).toBe(false);
+  });
+
+  it('remain unlocked when unlocked multiple times', () => {
+    mutex.unlock();
+    mutex.unlock();
+
+    expect(mutex.isLocked).toBe(false);
+  });
+
+  it('reflect the current lock state', () => {
+    expect(mutex.isLocked).toBe(false);
+    mutex.lock();
+    expect(mutex.isLocked).toBe(true);
+    mutex.unlock();
+    expect(mutex.isLocked).toBe(false);
+  });
+
+  it('execute a callback when unlocked', async () => {
+    const callback = vi.fn(() => 'done');
+    const result = await mutex.execute(callback);
+  
+    expect(result).toBe('done');
+    expect(callback).toHaveBeenCalled();
+  });
+
+  it('execute a promise callback when unlocked', async () => {
+    const callback = vi.fn(() => Promise.resolve('done'));
+    const result = await mutex.execute(callback);
+  
+    expect(result).toBe('done');
+    expect(callback).toHaveBeenCalled();
+  });
+
+  it('execute concurrent callbacks only one at a time', async () => {
+    const callback = vi.fn(() => Promise.resolve('done'));
+
+    const result = await Promise.all([
+      mutex.execute(callback),
+      mutex.execute(callback),
+      mutex.execute(callback),
+    ]);
+  
+    expect(result).toEqual(['done', undefined, undefined]);
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not execute a callback when locked', async () => {
+    const callback = vi.fn(() => 'done');
+    mutex.lock();
+    const result = await mutex.execute(callback);
+
+    expect(result).toBeUndefined();
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it('unlocks after executing a callback', async () => {
+    const callback = vi.fn(() => 'done');
+    await mutex.execute(callback);
+  
+    expect(mutex.isLocked).toBe(false);
+  });
+});

packages/stdlib/src/sync/mutex/index.ts

@@ -0,0 +1,47 @@
+import type { MaybePromise } from "../../types";
+
+/**
+ * @name SyncMutex
+ * @category Utils
+ * @description A simple synchronous mutex to provide more readable locking and unlocking of code blocks
+ * 
+ * @example
+ * const mutex = new SyncMutex();
+ * 
+ * mutex.lock();
+ *
+ * mutex.unlock();
+ * 
+ * const result = await mutex.execute(() => {
+ *  // do something
+ *  return Promise.resolve('done');  
+ * });
+ * 
+ * @since 0.0.5
+ */
+export class SyncMutex {
+  private state = false;
+
+  public get isLocked() {
+    return this.state;
+  }
+
+  public lock() {
+    this.state = true;
+  }
+
+  public unlock() {
+    this.state = false;
+  }
+
+  public async execute<T>(callback: () => T) {
+    if (this.isLocked)
+      return;
+
+    this.lock();
+    const result = await callback();
+    this.unlock();
+
+    return result;
+  }
+}

packages/vue/src/composables/useRenderInfo/index.ts

@@ -22,9 +22,13 @@ import { getLifeCycleTarger } from '../..';
 export function useRenderInfo(instance?: ComponentInternalInstance) {
     const target = getLifeCycleTarger(instance);
     const duration = ref(0);
+    let renderStartTime = 0;
 
-    const startMark = () => duration.value = performance.now();
-    const endMark = () => duration.value = Math.max(performance.now() - duration.value, 0);
+    const startMark = () => renderStartTime = performance.now();
+    const endMark = () => {
+        duration.value = Math.max(performance.now() - renderStartTime, 0);
+        renderStartTime = 0;
+    };
 
     onBeforeMount(startMark, target);
     onMounted(endMark, target);