chore: merge blocksuite source code (#9213)

blocksuite/framework/global/src/utils/assert.ts

@@ -0,0 +1,107 @@
+// https://stackoverflow.com/questions/31538010/test-if-a-variable-is-a-primitive-rather-than-an-object
+import { ErrorCode } from '../exceptions/code.js';
+import { BlockSuiteError } from '../exceptions/index.js';
+
+export function isPrimitive(
+  a: unknown
+): a is null | undefined | boolean | number | string {
+  return a !== Object(a);
+}
+
+export function assertType<T>(_: unknown): asserts _ is T {}
+
+/**
+ * @deprecated Avoid using this util as escape hatch of error handling.
+ * For non-framework code, please handle error in application level instead.
+ */
+export function assertExists<T>(
+  val: T | null | undefined,
+  message: string | Error = 'val does not exist',
+  errorCode = ErrorCode.ValueNotExists
+): asserts val is T {
+  if (val === null || val === undefined) {
+    if (message instanceof Error) {
+      throw message;
+    }
+    throw new BlockSuiteError(errorCode, message);
+  }
+}
+
+export function assertNotExists<T>(
+  val: T | null | undefined,
+  message = 'val exists',
+  errorCode = ErrorCode.ValueNotExists
+): asserts val is null | undefined {
+  if (val !== null && val !== undefined) {
+    throw new BlockSuiteError(errorCode, message);
+  }
+}
+
+export type Equals<X, Y> =
+  ///
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;
+
+type Allowed =
+  | unknown
+  | void
+  | null
+  | undefined
+  | boolean
+  | number
+  | string
+  | unknown[]
+  | object;
+export function isEqual<T extends Allowed, U extends T>(
+  val: T,
+  expected: U
+): Equals<T, U> {
+  const a = isPrimitive(val);
+  const b = isPrimitive(expected);
+  if (a && b) {
+    if (!Object.is(val, expected)) {
+      return false as Equals<T, U>;
+    }
+  } else if (a !== b) {
+    return false as Equals<T, U>;
+  } else {
+    if (Array.isArray(val) && Array.isArray(expected)) {
+      if (val.length !== expected.length) {
+        return false as Equals<T, U>;
+      }
+      return val.every((x, i) => isEqual(x, expected[i])) as Equals<T, U>;
+    } else if (typeof val === 'object' && typeof expected === 'object') {
+      const obj1 = Object.entries(val as Record<string, unknown>);
+      const obj2 = Object.entries(expected as Record<string, unknown>);
+      if (obj1.length !== obj2.length) {
+        return false as Equals<T, U>;
+      }
+      return obj1.every((x, i) => isEqual(x, obj2[i])) as Equals<T, U>;
+    }
+  }
+  return true as Equals<T, U>;
+}
+export function assertEquals<T extends Allowed, U extends T>(
+  val: T,
+  expected: U,
+  message = 'val is not same as expected',
+  errorCode = ErrorCode.ValueNotEqual
+): asserts val is U {
+  if (!isEqual(val, expected)) {
+    throw new BlockSuiteError(errorCode, message);
+  }
+}
+
+type Class<T> = new (...args: any[]) => T;
+
+export function assertInstanceOf<T>(
+  val: unknown,
+  expected: Class<T>,
+  message = 'val is not instance of expected',
+  errorCode = ErrorCode.ValueNotInstanceOf
+): asserts val is T {
+  if (!(val instanceof expected)) {
+    throw new BlockSuiteError(errorCode, message);
+  }
+}