feat(testing/unstable): add type test for mutual assignability

testing/deno.json

@@ -6,6 +6,7 @@
     "./mock": "./mock.ts",
     "./snapshot": "./snapshot.ts",
     "./time": "./time.ts",
-    "./types": "./types.ts"
+    "./types": "./types.ts",
+    "./unstable-types": "./unstable_types.ts"
   }
 }

testing/unstable_types.ts

@@ -0,0 +1,28 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+/**
+ * Checks if the actual type `A` is assignable to the expected type `E`, and
+ * vice versa.
+ *
+ * This is often less strict than `IsExact` because the two type parameters are
+ * allowed to have a different structure as long as they are assignable to each
+ * other. This is often more strict than `Has` because none of the two type
+ * parameters may be a union that contains the other, as this would fail the
+ * check for mutual assignability.
+ *
+ * @example Usage
+ * ```ts
+ * import { assertType } from "@std/testing/types";
+ * import type { IsMutuallyAssignable } from "@std/testing/unstable-types";
+ *
+ * // false because E is not assignable to A
+ * assertType<IsMutuallyAssignable<string & RegExpMatchArray, string>>(false);
+ * // false because A is not assignable to E
+ * assertType<IsMutuallyAssignable<string | RegExpMatchArray, string>>(false);
+ * // true because both types are assignable to each other
+ * assertType<IsMutuallyAssignable<string | (string & RegExpMatchArray), string>>(true);
+ * ```
+ */
+export type IsMutuallyAssignable<A, E> = [E] extends [A]
+  ? [A] extends [E] ? true : false
+  : false;

testing/unstable_types_test.ts

@@ -0,0 +1,28 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// deno-lint-ignore-file
+
+import { assertType } from "./types.ts";
+import type { IsMutuallyAssignable } from "./unstable_types.ts";
+
+// IsMutuallyAssignable
+{
+  // matching
+  assertType<IsMutuallyAssignable<string | (string & Date), string>>(true);
+  assertType<IsMutuallyAssignable<string & (string | Date), string>>(true);
+  assertType<
+    IsMutuallyAssignable<string, string | (string & RegExpMatchArray)>
+  >(true);
+  assertType<
+    IsMutuallyAssignable<(Date & string) | (string & Date), Date & string>
+  >(
+    true,
+  );
+  assertType<IsMutuallyAssignable<never, 0 & 1>>(true);
+
+  // not matching
+  assertType<IsMutuallyAssignable<string & RegExpMatchArray, string>>(false);
+  assertType<IsMutuallyAssignable<string | RegExpMatchArray, string>>(false);
+  assertType<IsMutuallyAssignable<string | number, Date>>(false);
+  assertType<IsMutuallyAssignable<string, number>>(false);
+  assertType<IsMutuallyAssignable<never, any>>(false);
+}