fix sync promise stuff

Author: mydea

packages/core/src/index.ts

@@ -247,7 +247,6 @@ export {
   SyncPromise,
   rejectedSyncPromise,
   resolvedSyncPromise,
-  makeSyncPromise,
 } from './utils/syncpromise';
 export { browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds } from './utils/time';
 export {

packages/core/src/utils/syncpromise.ts

@@ -11,21 +11,6 @@ type Executor<T> = (resolve: (value?: T | PromiseLike<T> | null) => void, reject
 type PromiseTry = <T>(executor: Executor<T>) => PromiseLike<T>;
 type PromiseWithTry = PromiseConstructor & { try: PromiseTry };
 
-/**
- * Takes an executor and returns a promise that is executed synchronously (if the executor is synchronous) or else asynchronously.
- * It always returns a promise.
- *
- * This uses the native Promise.try, if it exists, else our SyncPromise implementation.
- */
-export function makeSyncPromise<T>(executor: Executor<T>): PromiseLike<T> {
-  if (hasPromiseTry(Promise)) {
-    return Promise.try(executor);
-  }
-
-  // eslint-disable-next-line deprecation/deprecation
-  return new SyncPromise(executor);
-}
-
 function hasPromiseTry(Promise: typeof globalThis.Promise): Promise is PromiseWithTry {
   return 'try' in Promise && typeof Promise.try === 'function';
 }
@@ -41,7 +26,8 @@ export function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T
  * @returns the resolved sync promise
  */
 export function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {
-  return makeSyncPromise(() => value);
+  // eslint-disable-next-line deprecation/deprecation
+  return hasPromiseTry(Promise) ? Promise.try(() => value) : new SyncPromise(resolve => resolve(value));
 }
 
 /**
@@ -51,16 +37,19 @@ export function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<
  * @returns the rejected sync promise
  */
 export function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {
-  return makeSyncPromise(() => {
-    throw reason;
-  });
+  return hasPromiseTry(Promise)
+    ? Promise.try(() => {
+        throw reason;
+      })
+    : // eslint-disable-next-line deprecation/deprecation
+      new SyncPromise((_, reject) => reject(reason));
 }
 
 /**
  * Thenable class that behaves like a Promise and follows it's interface
  * but is not async internally
  *
- * @deprecated Use makeSyncPromise instead.
+ * @deprecated This export will be removed in a future version.
  */
 export class SyncPromise<T> implements PromiseLike<T> {
   private _state: State;

packages/core/test/lib/utils/syncpromise.test.ts

@@ -1,8 +1,21 @@
 /* eslint-disable deprecation/deprecation */
-import { describe, expect, test, vi } from 'vitest';
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
 import { rejectedSyncPromise, resolvedSyncPromise, SyncPromise } from '../../../src/utils/syncpromise';
 
 describe('SyncPromise', () => {
+  // @ts-expect-error We want to ensure to test this without the native Promise.try
+  const promiseTry = Promise.try;
+
+  beforeAll(() => {
+    // @ts-expect-error We want to ensure to test this without the native Promise.try
+    Promise.try = undefined;
+  });
+
+  afterAll(() => {
+    // @ts-expect-error Restore this
+    Promise.try = promiseTry;
+  });
+
   test('simple', async () => {
     expect.assertions(1);
 
@@ -13,6 +26,35 @@ describe('SyncPromise', () => {
     });
   });
 
+  test('simple error catching', async () => {
+    expect.assertions(1);
+
+    const error = new Error('test error');
+
+    return new SyncPromise<number>(() => {
+      throw error;
+    }).catch(val => {
+      expect(val).toBe(error);
+    });
+  });
+
+  test('simple error in then', async () => {
+    expect.assertions(1);
+
+    const error = new Error('test error');
+
+    return new SyncPromise<number>(() => {
+      throw error;
+    }).then(
+      () => {
+        throw new Error('THIS SHOULD NOT BE CALLED!');
+      },
+      val => {
+        expect(val).toBe(error);
+      },
+    );
+  });
+
   test('simple chaining', async () => {
     expect.assertions(1);
 
@@ -99,6 +141,9 @@ describe('SyncPromise', () => {
     expect.assertions(1);
 
     const p = resolvedSyncPromise(10);
+
+    console.log(p);
+
     return p.then(val => {
       expect(val).toBe(10);
     });
@@ -267,3 +312,245 @@ describe('SyncPromise', () => {
       });
   });
 });
+
+describe('resolvedSyncPromise', () => {
+  test('simple chaining', async () => {
+    expect.assertions(1);
+
+    return new SyncPromise<number>(resolve => {
+      resolve(42);
+    })
+      .then(_ => resolvedSyncPromise('a'))
+      .then(_ => resolvedSyncPromise(0.1))
+      .then(_ => resolvedSyncPromise(false))
+      .then(val => {
+        expect(val).toBe(false);
+      });
+  });
+
+  test('compare to regular promise', async () => {
+    expect.assertions(2);
+
+    const ap = new Promise<string>(resolve => {
+      resolve('1');
+    });
+
+    const bp = new Promise<string>(resolve => {
+      resolve('2');
+    });
+
+    const cp = new Promise<string>(resolve => {
+      resolve('3');
+    });
+
+    const fp = async (s: PromiseLike<string>, prepend: string) =>
+      new Promise<string>(resolve => {
+        void s
+          .then(val => {
+            resolve(prepend + val);
+          })
+          .then(null, _ => {
+            // bla
+          });
+      });
+
+    const res = await cp
+      .then(async val => fp(Promise.resolve('x'), val))
+      .then(async val => fp(bp, val))
+      .then(async val => fp(ap, val));
+
+    expect(res).toBe('3x21');
+
+    const a = new SyncPromise<string>(resolve => {
+      resolve('1');
+    });
+
+    const b = new SyncPromise<string>(resolve => {
+      resolve('2');
+    });
+
+    const c = new SyncPromise<string>(resolve => {
+      resolve('3');
+    });
+
+    const f = (s: SyncPromise<string>, prepend: string) =>
+      new SyncPromise<string>(resolve => {
+        void s
+          .then(val => {
+            resolve(prepend + val);
+          })
+          .then(null, () => {
+            // no-empty
+          });
+      });
+
+    return (
+      c
+        // @ts-expect-error Argument of type 'PromiseLike<string>' is not assignable to parameter of type 'SyncPromise<string>'
+        .then(val => f(resolvedSyncPromise('x'), val))
+        .then(val => f(b, val))
+        .then(val => f(a, val))
+        .then(val => {
+          expect(val).toBe(res);
+        })
+    );
+  });
+
+  test('simple static', async () => {
+    expect.assertions(1);
+
+    const p = resolvedSyncPromise(10);
+
+    return p.then(val => {
+      expect(val).toBe(10);
+    });
+  });
+
+  test('calling the callback immediately', () => {
+    expect.assertions(1);
+
+    let foo: number = 1;
+
+    new SyncPromise<number>(_ => {
+      foo = 2;
+    });
+
+    expect(foo).toEqual(2);
+  });
+
+  test('calling the callback not immediately', () => {
+    vi.useFakeTimers();
+    expect.assertions(4);
+
+    const qp = new SyncPromise<number>(resolve =>
+      setTimeout(() => {
+        resolve(2);
+      }),
+    );
+    void qp
+      .then(value => {
+        expect(value).toEqual(2);
+      })
+      .then(null, () => {
+        // no-empty
+      });
+    expect(qp).not.toHaveProperty('_value');
+    void qp
+      .then(value => {
+        expect(value).toEqual(2);
+      })
+      .then(null, () => {
+        // no-empty
+      });
+    vi.runAllTimers();
+    expect(qp).toHaveProperty('_value');
+  });
+
+  test('multiple then returning undefined', async () => {
+    expect.assertions(3);
+
+    return resolvedSyncPromise(2)
+      .then(result => {
+        expect(result).toEqual(2);
+      })
+      .then(result => {
+        expect(result).toBeUndefined();
+      })
+      .then(result => {
+        expect(result).toBeUndefined();
+      });
+  });
+
+  test('multiple then returning different values', async () => {
+    expect.assertions(3);
+
+    return resolvedSyncPromise(2)
+      .then(result => {
+        expect(result).toEqual(2);
+        return 3;
+      })
+      .then(result => {
+        expect(result).toEqual(3);
+        return 4;
+      })
+      .then(result => {
+        expect(result).toEqual(4);
+      });
+  });
+
+  test('multiple then returning different SyncPromise', async () => {
+    expect.assertions(2);
+
+    return resolvedSyncPromise(2)
+      .then(result => {
+        expect(result).toEqual(2);
+        return resolvedSyncPromise('yo');
+      })
+      .then(result => {
+        expect(result).toEqual('yo');
+      });
+  });
+});
+
+describe('rejectedSyncPromise', () => {
+  test('simple', async () => {
+    expect.assertions(1);
+
+    return new SyncPromise<number>(resolve => {
+      resolve(42);
+    }).then(val => {
+      expect(val).toBe(42);
+    });
+  });
+
+  test('simple error catching', async () => {
+    expect.assertions(1);
+
+    const error = new Error('test error');
+
+    return rejectedSyncPromise(error).then(
+      () => {
+        throw new Error('THIS SHOULD NOT BE CALLED!');
+      },
+      val => {
+        expect(val).toBe(error);
+      },
+    );
+  });
+  test('reject immediately and do not call then', async () => {
+    expect.assertions(1);
+
+    return new SyncPromise<number>((_, reject) => {
+      reject('test');
+    })
+      .then(_ => {
+        expect(true).toBeFalsy();
+      })
+      .then(null, reason => {
+        expect(reason).toBe('test');
+      });
+  });
+
+  test('reject', async () => {
+    expect.assertions(1);
+
+    return new SyncPromise<number>((_, reject) => {
+      reject('test');
+    }).then(null, reason => {
+      expect(reason).toBe('test');
+    });
+  });
+
+  test('rejecting after first then', async () => {
+    expect.assertions(2);
+
+    return resolvedSyncPromise(2)
+      .then(value => {
+        expect(value).toEqual(2);
+        return rejectedSyncPromise('wat');
+      })
+      .then(null, reason => {
+        expect(reason).toBe('wat');
+      });
+  });
+});