wip:milestone 0 fixes

control-plane-ui/node_modules/until-async/src/index.ts

@@ -0,0 +1,26 @@
+export type UntilResult<RejectionReason, ResolveData> =
+  | [reason: RejectionReason, data: null]
+  | [reason: null, data: ResolveData]
+
+/**
+ * Gracefully handles a callback that returns a promise.
+ *
+ * @example
+ * await until(() => Promise.resolve(123))
+ * // [null, 123]
+ *
+ * await until(() => Promise.reject(new Error('Oops!')))
+ * // [new Error('Oops!'), null]
+ */
+export async function until<RejectionReason = Error, ResolveData = unknown>(
+  callback: () => Promise<ResolveData>,
+): Promise<UntilResult<RejectionReason, ResolveData>> {
+  try {
+    const data = await callback().catch((error) => {
+      throw error
+    })
+    return [null, data]
+  } catch (error: any) {
+    return [error, null]
+  }
+}

control-plane-ui/node_modules/until-async/src/until.test-d.ts

@@ -0,0 +1,25 @@
+import { until } from './index.js'
+
+it('infers the data type if no type arguments were provided', async () => {
+  const [error, data] = await until(() => Promise.resolve(123))
+
+  if (error) {
+    expectTypeOf(error).toEqualTypeOf<Error>()
+    expectTypeOf(data).toEqualTypeOf<null>()
+  } else {
+    expectTypeOf(error).toEqualTypeOf<null>()
+    expectTypeOf(data).toEqualTypeOf<number>()
+  }
+})
+
+it('treats error/data as a discriminated union type', async () => {
+  const [error, data] = await until<Error, number>(() => Promise.resolve(123))
+
+  if (error) {
+    expectTypeOf(error).toEqualTypeOf<Error>()
+    expectTypeOf(data).toEqualTypeOf<null>()
+  } else {
+    expectTypeOf(error).toEqualTypeOf<null>()
+    expectTypeOf(data).toEqualTypeOf<number>()
+  }
+})

control-plane-ui/node_modules/until-async/src/until.test.ts

@@ -0,0 +1,20 @@
+import { until } from './index.js'
+
+it('resolves with the value returned from the callback', async () => {
+  await expect(until(async () => 'value')).resolves.toEqual([null, 'value'])
+  await expect(until(() => Promise.resolve('value'))).resolves.toEqual([
+    null,
+    'value',
+  ])
+})
+
+it('resolves with the error thrown in the callback', async () => {
+  await expect(
+    until(() => Promise.reject(new Error('error'))),
+  ).resolves.toEqual([new Error('error'), null])
+
+  await expect(until(() => Promise.reject('custom reason'))).resolves.toEqual([
+    'custom reason',
+    null,
+  ])
+})