mobx 6.12.4 → 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;
@@ -31,6 +31,7 @@ export declare function addHiddenProp(object: any, propName: PropertyKey, value:
 export declare function addHiddenFinalProp(object: any, propName: PropertyKey, value: any): void;
 export declare function createInstanceofPredicate<T>(name: string, theClass: new (...args: any[]) => T): (x: any) => x is T;
 export declare function isES6Map(thing: any): thing is Map<any, any>;
+export declare function isPlainES6Map(thing: Map<any, any>): boolean;
 export declare function isES6Set(thing: any): thing is Set<any>;
 /**
  * Returns the following: own enumerable keys and symbols.

package/package.json

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

package/src/types/observablemap.ts

@@ -16,6 +16,7 @@ import {
     hasListeners,
     interceptChange,
     isES6Map,
+    isPlainES6Map,
     isPlainObject,
     isSpyEnabled,
     makeIterable,
@@ -351,7 +352,7 @@ export class ObservableMap<K = any, V = any>
             } else if (Array.isArray(other)) {
                 other.forEach(([key, value]) => this.set(key, value))
             } else if (isES6Map(other)) {
-                if (other.constructor !== Map) {
+                if (!isPlainES6Map(other)) {
                     die(19, other)
                 }
                 other.forEach((value, key) => this.set(key, value))

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)

package/src/utils/utils.ts

@@ -141,11 +141,18 @@ export function createInstanceofPredicate<T>(
 }
 
 export function isES6Map(thing: any): thing is Map<any, any> {
-    return thing instanceof Map
+    return thing != null && Object.prototype.toString.call(thing) === "[object Map]"
+}
+
+export function isPlainES6Map(thing: Map<any, any>): boolean {
+    const mapProto = Object.getPrototypeOf(thing)
+    const objectProto = Object.getPrototypeOf(mapProto)
+    const nullProto = Object.getPrototypeOf(objectProto)
+    return nullProto === null
 }
 
 export function isES6Set(thing: any): thing is Set<any> {
-    return thing instanceof Set
+    return thing != null && Object.prototype.toString.call(thing) === "[object Set]"
 }
 
 const hasGetOwnPropertySymbols = typeof Object.getOwnPropertySymbols !== "undefined"