fix intersection with not type

Author: devanshj

packages/predicate/README.md

@@ -5,7 +5,7 @@
 An eDSL to write typed predicates
 
 ```ts
-import { ps } from "@sthir/predicate"
+import { p } from "@sthir/predicate"
 
 declare let xs:
   (undefined | { a: string | number } | { b: string })[]
@@ -35,7 +35,7 @@ xs
 ```
 
 ```ts
-import { pa, ps } from "@sthir/predicate"
+import { pa, p } from "@sthir/predicate"
 
 declare let foo:
   | { bar: { type: "x" }
@@ -56,7 +56,7 @@ if (foo.bar.type === "x") {
 
 // With @sthir/predicate ...
 
-if (pa(foo, ps(".bar.type ===", "x"))) {
+if (pa(foo, p(".bar.type ===", "x"))) {
   foo.x
 }
 ```
@@ -108,7 +108,7 @@ export const pa:
 ### Supported comparators
 
 - `===`
-- `!==` (does not work in [some cases](https://github.com/devanshj/sthir/blob/8a195542cf2b204e8d30fa63fb2abcc5571bf800/packages/predicate/tests/types.twoslash-test.ts#L71-L78) because of [#47283](https://github.com/microsoft/TypeScript/issues/47283))
+- `!==`
 
 ### Future
 

packages/predicate/src/types.ts

@@ -218,7 +218,7 @@ namespace A {
   declare const $$not: unique symbol
   export type Not<T> = { [$$not]: T }
 
-  export type NotAwareIntersect<A, B> = 
+  export type NotAwareIntersect<A, B, A_ = A> = 
     B extends Not<infer NotB>
       ? A extends object
           ? A.Get<U.ToIntersection<
@@ -228,8 +228,11 @@ namespace A {
                       ? O.Normalize<
                           & A
                           & O.Normalize<{
-                              [K in Extract<keyof NotB, keyof A>]:
-                                NotAwareIntersect<A[K], A.Not<NotB[K]>>
+                              [K in keyof NotB]:
+                                NotAwareIntersect<
+                                  A_ extends unknown ? A.Get<A_, K> : never,
+                                  A.Not<NotB[K]>
+                                >
                             }>
                         >
                       : A
@@ -239,7 +242,6 @@ namespace A {
           : A extends NotB
               ? never
               : A
-        
       : A & B
 
   A.test(A.areEqual
@@ -254,19 +256,26 @@ namespace A {
     >()
   )
 
+  A.test(A.areEqual
+    < NotAwareIntersect<{ a: string | undefined } | { b: string }, A.Not<{ a: undefined }>>
+    , | ({ a: string | undefined } & { a: string })
+      | ({ b: string } & { a: string })
+    >()
+  )
+
   A.test(A.areEqual
     < NotAwareIntersect<
         { x: "A" } | { y: "X" | "Z" } | "B" | "C"
       , A.Not<{ x: "A" } | { y: "X" } | "B">
       >
-    , | ({ y: "X" | "Z" } & { y: "Z" })
+    , | ({ y: "X" | "Z" } & { x: undefined } & { y: "Z" | undefined })
       | "C"
     >()
   )
 
   A.test(A.areEqual
     < NotAwareIntersect<{ x: "A" | "Z" } | "B" | "C", A.Not<{ x: "A" } | "B">>
-    , | ({ x: "A" | "Z" } & { x: "Z" })
+    , | ({ x: "A" | "Z" } & { x: "Z" | undefined })
       | "C"
     >()
   )
@@ -280,17 +289,21 @@ namespace A {
         | "B"
         | "C"
       , A.Not<
-          | { x: "A", y: { x: "B" } }
+          | { y: { x: "B" } }
           | { z: "T" | "U" }
           | "B"
         >
       >
     , | ( { x: "A"
           , y: { x: "B" | "Z" }
           }
-        & { x: never
-          , y: { x: "B" | "Z" } & { x: "Z" }
+        & { y:
+            | ( { x: "B" | "Z" }
+              & { x: "Z" | undefined }
+              )
+            | undefined;
           }
+        & { z: undefined }
         )
       | "C"
     >()
@@ -302,14 +315,19 @@ namespace A {
     >()
   )
 
+  A.test(A.areEqual
+    < NotAwareIntersect<{ a?: string }, A.Not<{ a: A.Falsy }>>
+    , { a?: string } & { a: string }
+    >()
+  )
+
   export type Falsy = 
     false | undefined | null | 0 | 0n | ""
 
   export type Get<T, P> =
     B.Not<A.DoesExtend<P, unknown[]>> extends true ? Get<T, [P]> :
     P extends [] ? T :
     P extends [infer Ph] ?
-      object extends T ? unknown :
       Ph extends keyof T ? T[Ph] :
       T extends null ? null :
       T extends undefined ? undefined :
@@ -370,7 +388,4 @@ namespace O {
   export type Normalize<T> =
     {} extends T ? unknown :
     T[keyof T] extends never ? never : T
-
-  export type Key<T> = 
-    object extends T ? keyof any : keyof T
 }

packages/predicate/tests/types.twoslash-test.ts

@@ -72,7 +72,6 @@ test("index typeof !==", () => {
   let x = {} as { a: string | number | undefined } | { b: string }
 
   if (pa(x, p(".a typeof !==", "undefined"))) {
-    // @ts-expect-error https://github.com/microsoft/TypeScript/issues/47283
     expectAreTypesEqual<typeof x.a, string | number>().toBe(true)
   }
 })
@@ -117,4 +116,4 @@ const expectAreTypesEqual =
             ? true
             : false
       ) => {}
-  })
+  })