mobx 6.12.5 → 6.13.0

package/dist/types/observableset.d.ts

@@ -42,6 +42,13 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     entries(): IterableIterator<[T, T]>;
     keys(): IterableIterator<T>;
     values(): IterableIterator<T>;
+    intersection<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T & U>;
+    union<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U>;
+    difference<U>(otherSet: ReadonlySetLike<U>): Set<T>;
+    symmetricDifference<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U>;
+    isSubsetOf(otherSet: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(otherSet: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(otherSet: ReadonlySetLike<unknown> | Set<unknown>): boolean;
     replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T>;
     observe_(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda;
     intercept_(handler: IInterceptor<ISetWillChange<T>>): Lambda;

package/dist/utils/utils.d.ts

@@ -1,7 +1,7 @@
 export declare const assign: {
     <T extends {}, U>(target: T, source: U): T & U;
-    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
-    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
     (target: object, ...sources: any[]): any;
 };
 export declare const getDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.12.5",
+    "version": "6.13.0",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/types/observableset.ts

@@ -243,6 +243,54 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
         } as any)
     }
 
+    intersection<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T & U> {
+        if (isES6Set(otherSet)) {
+            return otherSet.intersection(this)
+        } else {
+            const dehancedSet = new Set(this)
+            return dehancedSet.intersection(otherSet)
+        }
+    }
+
+    union<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U> {
+        if (isES6Set(otherSet)) {
+            return otherSet.union(this)
+        } else {
+            const dehancedSet = new Set(this)
+            return dehancedSet.union(otherSet)
+        }
+    }
+
+    difference<U>(otherSet: ReadonlySetLike<U>): Set<T> {
+        return new Set(this).difference(otherSet)
+    }
+
+    symmetricDifference<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U> {
+        if (isES6Set(otherSet)) {
+            return otherSet.symmetricDifference(this)
+        } else {
+            const dehancedSet = new Set(this)
+            return dehancedSet.symmetricDifference(otherSet)
+        }
+    }
+
+    isSubsetOf(otherSet: ReadonlySetLike<unknown>): boolean {
+        return new Set(this).isSubsetOf(otherSet)
+    }
+
+    isSupersetOf(otherSet: ReadonlySetLike<unknown>): boolean {
+        return new Set(this).isSupersetOf(otherSet)
+    }
+
+    isDisjointFrom(otherSet: ReadonlySetLike<unknown> | Set<unknown>): boolean {
+        if (isES6Set(otherSet)) {
+            return otherSet.isDisjointFrom(this)
+        } else {
+            const dehancedSet = new Set(this)
+            return dehancedSet.isDisjointFrom(otherSet)
+        }
+    }
+
     replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T> {
         if (isObservableSet(other)) {
             other = new Set(other)