1975

pending completion

Build # 1975

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #1917 from kalmi/set-ie11-compat

Make ObservableSet backport compatible with IE11

Run Details

1330 of 1641 branches covered (81.05%)

5 of 5 new or added lines in 3 files covered. (100.0%)

2589 of 2804 relevant lines covered (92.33%)

3387.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.99

/src/types/observableset.ts

import {
    createAtom,
    deepEnhancer,
    getNextId,
    IEnhancer,
    isSpyEnabled,
    hasListeners,
    IListenable,
    invariant,
    registerListener,
    Lambda,
    fail,
    spyReportStart,
    notifyListeners,
    spyReportEnd,
    createInstanceofPredicate,
    hasInterceptors,
    interceptChange,
    IInterceptable,
    IInterceptor,
    registerInterceptor,
    checkIfStateModificationsAreAllowed,
    untracked,
    makeIterable,
    transaction,
    isES6Set,
    toStringTagSymbol,
    declareIterator,
    addHiddenFinalProp,
    iteratorToArray
} from "../internal"

const ObservableSetMarker = {}

export type IObservableSetInitialValues<T> = Set<T> | T[]

export type ISetDidChange<T = any> =
    | {
          object: ObservableSet<T>
          type: "add"
          newValue: T
      }
    | {
          object: ObservableSet<T>
          type: "delete"
          oldValue: T
      }

export type ISetWillChange<T = any> =
    | {
          type: "delete"
          object: ObservableSet<T>
          oldValue: T
      }
    | {
          type: "add"
          object: ObservableSet<T>
          newValue: T
      }

export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
    $mobx = ObservableSetMarker
    private _data: Set<any> = new Set()
    private _atom = createAtom(this.name)
    changeListeners
    interceptors
    dehancer: any
    enhancer: (newV: any, oldV: any | undefined) => any;
    // eslint-disable-next-line
    [Symbol.iterator]: () => IterableIterator<T>; // only used for typings!
    // eslint-disable-next-line
    [Symbol.toStringTag]: string // only used for typings!

    constructor(
        initialData?: IObservableSetInitialValues<T>,
        enhancer: IEnhancer<T> = deepEnhancer,
        public name = "ObservableSet@" + getNextId()
    ) {
        if (typeof Set !== "function") {
            throw new Error(
                "mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js"
            )
        }

        this.enhancer = (newV, oldV) => enhancer(newV, oldV, name)

        if (initialData) {
            this.replace(initialData)
        }
    }

    private dehanceValue<X extends T | undefined>(value: X): X {
        if (this.dehancer !== undefined) {
            return this.dehancer(value)
        }
        return value
    }

    clear() {
        transaction(() => {
            untracked(() => {
                this._data.forEach(value => {
                    this.delete(value)
                })
            })
        })
    }

    forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any) {
        this._data.forEach(value => {
            callbackFn.call(thisArg, value, value, this)
        })
    }

    get size() {
        this._atom.reportObserved()
        return this._data.size
    }

    add(value: T) {
        checkIfStateModificationsAreAllowed(this._atom)
        if (hasInterceptors(this)) {
            const change = interceptChange<ISetWillChange<T>>(this, {
                type: "add",
                object: this,
                newValue: value
            })
            if (!change) return this
            // TODO: ideally, value = change.value would be done here, so that values can be
            // changed by interceptor. Same applies for other Set and Map api's.
        }
        if (!this.has(value)) {
            transaction(() => {
                this._data.add(this.enhancer(value, undefined))
                this._atom.reportChanged()
            })
            const notifySpy = isSpyEnabled()
            const notify = hasListeners(this)
            const change =
                notify || notifySpy
                    ? <ISetDidChange<T>>{
                          type: "add",
                          object: this,
                          newValue: value
                      }
                    : null
            if (notifySpy && process.env.NODE_ENV !== "production") spyReportStart(change)
            if (notify) notifyListeners(this, change)
            if (notifySpy && process.env.NODE_ENV !== "production") spyReportEnd()
        }

        return this
    }

    delete(value: any) {
        if (hasInterceptors(this)) {
            const change = interceptChange<ISetWillChange<T>>(this, {
                type: "delete",
                object: this,
                oldValue: value
            })
            if (!change) return false
        }
        if (this.has(value)) {
            const notifySpy = isSpyEnabled()
            const notify = hasListeners(this)
            const change =
                notify || notifySpy
                    ? <ISetDidChange<T>>{
                          type: "delete",
                          object: this,
                          oldValue: value
                      }
                    : null

            if (notifySpy && process.env.NODE_ENV !== "production")
                spyReportStart({ ...change, name: this.name })
            transaction(() => {
                this._atom.reportChanged()
                this._data.delete(value)
            })
            if (notify) notifyListeners(this, change)
            if (notifySpy && process.env.NODE_ENV !== "production") spyReportEnd()
            return true
        }
        return false
    }

    has(value: any) {
        this._atom.reportObserved()
        return this._data.has(this.dehanceValue(value))
    }

    entries() {
        let nextIndex = 0
        const keys = iteratorToArray(this.keys())
        const values = iteratorToArray(this.values())
        return makeIterable<[T, T]>({
            next() {
                const index = nextIndex
                nextIndex += 1
                return index < values.length
                    ? { value: [keys[index], values[index]], done: false }
                    : { done: true }
            }
        } as any)
    }

    keys(): IterableIterator<T> {
        return this.values()
    }

    values(): IterableIterator<T> {
        this._atom.reportObserved()
        const self = this
        let nextIndex = 0
        let observableValues: any[]

        if (this._data.values !== undefined) {
            observableValues = iteratorToArray(this._data.values())
        } else {
            // There is no values function in IE11
            observableValues = []
            this._data.forEach(e => observableValues.push(e))
        }
        return makeIterable<T>({
            next() {
                return nextIndex < observableValues.length
                    ? { value: self.dehanceValue(observableValues[nextIndex++]), done: false }
                    : { done: true }
            }
        } as any)
    }

    replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T> {
        if (isObservableSet(other)) {
            other = other.toJS()
        }

        transaction(() => {
            if (Array.isArray(other)) {
                this.clear()
                other.forEach(value => this.add(value))
            } else if (isES6Set(other)) {
                this.clear()
                other.forEach(value => this.add(value))
            } else if (other !== null && other !== undefined) {
                fail("Cannot initialize set from " + other)
            }
        })

        return this
    }

    observe(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda {
        // TODO 'fireImmediately' can be true?
        process.env.NODE_ENV !== "production" &&
            invariant(
                fireImmediately !== true,
                "`observe` doesn't support fireImmediately=true in combination with sets."
            )
        return registerListener(this, listener)
    }

    intercept(handler: IInterceptor<ISetWillChange<T>>): Lambda {
        return registerInterceptor(this, handler)
    }

    toJS(): Set<T> {
        return new Set(this)
    }

    toString(): string {
        return this.name + "[ " + iteratorToArray(this.keys()).join(", ") + " ]"
    }
}

declareIterator(ObservableSet.prototype, function() {
    return this.values()
})

addHiddenFinalProp(ObservableSet.prototype, toStringTagSymbol(), "Set")

export const isObservableSet = createInstanceofPredicate("ObservableSet", ObservableSet) as (
    thing: any
) => thing is ObservableSet<any>

1	import {	27✔
2	createAtom,	×
3	deepEnhancer,	×
4	getNextId,	×
5	IEnhancer,	×
6	isSpyEnabled,	×
7	hasListeners,
8	IListenable,	×
9	invariant,
10	registerListener,	×
11	Lambda,
12	fail,	27✔
13	spyReportStart,	27✔
14	notifyListeners,	27✔
15	spyReportEnd,	27✔
16	createInstanceofPredicate,
17	hasInterceptors,	14!
18	interceptChange,	14!
19	IInterceptable,	14✔
20	IInterceptor,	14✔
21	registerInterceptor,	14✔
22	checkIfStateModificationsAreAllowed,	14✔
23	untracked,	14!
24	makeIterable,	×
25	transaction,
26	isES6Set,	26✔
27	toStringTagSymbol,	14✔
28	declareIterator,	10✔
29	addHiddenFinalProp,
30	iteratorToArray
31	} from "../internal"	27✔
32		130!
33	const ObservableSetMarker = {}	×
34
35	export type IObservableSetInitialValues<T> = Set<T> \| T[]	130✔
36
37	export type ISetDidChange<T = any> =	27✔
38	\| {	16✔
39	object: ObservableSet<T>	16✔
40	type: "add"	16✔
41	newValue: T	16✔
42	}	7✔
43	\| {
44	object: ObservableSet<T>
45	type: "delete"
46	oldValue: T
47	}	27✔
48		2✔
49	export type ISetWillChange<T = any> =	2✔
50	\| {	3✔
51	type: "delete"
52	object: ObservableSet<T>
53	oldValue: T	27✔
54	}
55	\| {	29✔
56	type: "add"	29✔
57	object: ObservableSet<T>
58	newValue: T
59	}
60
61	export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {	27✔
62	$mobx = ObservableSetMarker	28✔
63	private _data: Set<any> = new Set()	28✔
64	private _atom = createAtom(this.name)	28!
65	changeListeners	×
66	interceptors
67	dehancer: any
68	enhancer: (newV: any, oldV: any \| undefined) => any;
69	// eslint-disable-next-line
70	[Symbol.iterator]: () => IterableIterator<T>; // only used for typings!	×
71	// eslint-disable-next-line	×
72	[Symbol.toStringTag]: string // only used for typings!
73
74	constructor(
75	initialData?: IObservableSetInitialValues<T>,	28✔
76	enhancer: IEnhancer<T> = deepEnhancer,	26✔
77	public name = "ObservableSet@" + getNextId()	26✔
78	) {	26✔
79	if (typeof Set !== "function") {
80	throw new Error(	26✔
81	"mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js"	26✔
82	)	26✔
83	}
84
85	this.enhancer = (newV, oldV) => enhancer(newV, oldV, name)
86
87	if (initialData) {
88	this.replace(initialData)
89	}	26!
90	}	×
91		26✔
92	private dehanceValue<X extends T \| undefined>(value: X): X {	4✔
93	if (this.dehancer !== undefined) {	26!
94	return this.dehancer(value)	×
95	}
96	return value	28✔
97	}
98		27✔
99	clear() {	11✔
100	transaction(() => {	11!
101	untracked(() => {	×
102	this._data.forEach(value => {
103	this.delete(value)
104	})
105	})
106	})	×
107	}	×
108
109	forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any) {	11✔
110	this._data.forEach(value => {	10✔
111	callbackFn.call(thisArg, value, value, this)	10✔
112	})	10✔
113	}
114
115	get size() {
116	this._atom.reportObserved()
117	return this._data.size
118	}
119		10!
120	add(value: T) {	×
121	checkIfStateModificationsAreAllowed(this._atom)	10✔
122	if (hasInterceptors(this)) {	10✔
123	const change = interceptChange<ISetWillChange<T>>(this, {	10✔
124	type: "add",
125	object: this,	10✔
126	newValue: value	4✔
127	})	10!
128	if (!change) return this	×
129	// TODO: ideally, value = change.value would be done here, so that values can be	10✔
130	// changed by interceptor. Same applies for other Set and Map api's.
131	}	1✔
132	if (!this.has(value)) {
133	transaction(() => {	27✔
134	this._data.add(this.enhancer(value, undefined))	66✔
135	this._atom.reportChanged()	66✔
136	})
137	const notifySpy = isSpyEnabled()	27✔
138	const notify = hasListeners(this)	8✔
139	const change =	8✔
140	notify \|\| notifySpy	8✔
141	? <ISetDidChange<T>>{	8✔
142	type: "add",
143	object: this,	20✔
144	newValue: value	20✔
145	}	20✔
146	: null
147	if (notifySpy && process.env.NODE_ENV !== "production") spyReportStart(change)
148	if (notify) notifyListeners(this, change)
149	if (notifySpy && process.env.NODE_ENV !== "production") spyReportEnd()
150	}
151		27✔
152	return this	22✔
153	}
154		27✔
155	delete(value: any) {	56✔
156	if (hasInterceptors(this)) {	56✔
157	const change = interceptChange<ISetWillChange<T>>(this, {	56✔
158	type: "delete",
159	object: this,	56!
160	oldValue: value	56✔
161	})
162	if (!change) return false
163	}
164	if (this.has(value)) {	×
165	const notifySpy = isSpyEnabled()	×
166	const notify = hasListeners(this)
167	const change =	56✔
168	notify \|\| notifySpy
169	? <ISetDidChange<T>>{	120✔
170	type: "delete",
171	object: this,
172	oldValue: value
173	}
174	: null
175		27✔
176	if (notifySpy && process.env.NODE_ENV !== "production")	15✔
177	spyReportStart({ ...change, name: this.name })	15✔
178	transaction(() => {	1✔
179	this._atom.reportChanged()
180	this._data.delete(value)	15✔
181	})	15✔
182	if (notify) notifyListeners(this, change)	11✔
183	if (notifySpy && process.env.NODE_ENV !== "production") spyReportEnd()	14✔
184	return true
185	}	4✔
186	return false	3✔
187	}	4✔
188
189	has(value: any) {	1!
190	this._atom.reportObserved()	1✔
191	return this._data.has(this.dehanceValue(value))
192	}
193		14✔
194	entries() {
195	let nextIndex = 0	27✔
196	const keys = iteratorToArray(this.keys())
197	const values = iteratorToArray(this.values())	2✔
198	return makeIterable<[T, T]>({
199	next() {	2✔
200	const index = nextIndex
201	nextIndex += 1	27✔
202	return index < values.length	×
203	? { value: [keys[index], values[index]], done: false }
204	: { done: true }	27✔
205	}	5✔
206	} as any)
207	}	27✔
208		4✔
209	keys(): IterableIterator<T> {
210	return this.values()	27✔
211	}
212		27✔
213	values(): IterableIterator<T> {	27✔
214	this._atom.reportObserved()	16✔
215	const self = this
216	let nextIndex = 0	27✔
217	let observableValues: any[]	27✔
218
219	if (this._data.values !== undefined) {
220	observableValues = iteratorToArray(this._data.values())
221	} else {
222	// There is no values function in IE11
223	observableValues = []
224	this._data.forEach(e => observableValues.push(e))
225	}
226	return makeIterable<T>({
227	next() {
228	return nextIndex < observableValues.length
229	? { value: self.dehanceValue(observableValues[nextIndex++]), done: false }
230	: { done: true }
231	}
232	} as any)
233	}
234
235	replace(other: ObservableSet<T> \| IObservableSetInitialValues<T>): ObservableSet<T> {
236	if (isObservableSet(other)) {
237	other = other.toJS()
238	}
239
240	transaction(() => {
241	if (Array.isArray(other)) {
242	this.clear()
243	other.forEach(value => this.add(value))
244	} else if (isES6Set(other)) {
245	this.clear()
246	other.forEach(value => this.add(value))
247	} else if (other !== null && other !== undefined) {
248	fail("Cannot initialize set from " + other)
249	}
250	})
251
252	return this
253	}
254
255	observe(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda {
256	// TODO 'fireImmediately' can be true?
257	process.env.NODE_ENV !== "production" &&
258	invariant(
259	fireImmediately !== true,
260	"`observe` doesn't support fireImmediately=true in combination with sets."
261	)
262	return registerListener(this, listener)
263	}
264
265	intercept(handler: IInterceptor<ISetWillChange<T>>): Lambda {
266	return registerInterceptor(this, handler)
267	}
268
269	toJS(): Set<T> {
270	return new Set(this)
271	}
272
273	toString(): string {
274	return this.name + "[ " + iteratorToArray(this.keys()).join(", ") + " ]"
275	}
276	}
277
278	declareIterator(ObservableSet.prototype, function() {
279	return this.values()
280	})
281
282	addHiddenFinalProp(ObservableSet.prototype, toStringTagSymbol(), "Set")
283
284	export const isObservableSet = createInstanceofPredicate("ObservableSet", ObservableSet) as (
285	thing: any
286	) => thing is ObservableSet<any>

mobxjs / mobx / 1975

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous