mirrors/vector-im-hydrogen-web
1
0
Fork 0
mirror of https://github.com/vector-im/hydrogen-web.git synced 2024-11-20 03:25:52 +01:00
Code Issues Projects Releases Wiki Activity

updates ts-eslint and fixes errors in src/observable

Browse Source
This commit is contained in:
Isaiah Becker-Mayer 2022-07-09 12:43:24 -04:00
parent deab8bdaf0
commit 0203ece3bd
18 changed files with 159 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.ts-eslintrc.js
View File

@ -20,8 +20,10 @@ module.exports = {
rules: {
"@typescript-eslint/no-floating-promises": 2,
"@typescript-eslint/no-misused-promises": 2,
'no-unused-vars': 'off',
'@typescript-eslint/no-unused-vars': ['warn'],
'no-undef': 'off',
"no-unused-vars": "off",
"@typescript-eslint/no-unused-vars": ["warn"],
"no-undef": "off",
"semi": ["error", "always"],
"@typescript-eslint/explicit-function-return-type": ["error"]
}
};

9
src/observable/BaseObservable.ts
View File

@ -34,7 +34,7 @@ export abstract class BaseObservable<T> {
if (this._handlers.size === 1) {
this.onSubscribeFirst();
}
return () => {
return (): undefined => {
return this.unsubscribe(handler);
};
}
@ -63,17 +63,18 @@ export abstract class BaseObservable<T> {
// Add iterator over handlers here
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
class Collection extends BaseObservable<{}> {
firstSubscribeCalls: number = 0;
firstUnsubscribeCalls: number = 0;
onSubscribeFirst() { this.firstSubscribeCalls += 1; }
onUnsubscribeLast() { this.firstUnsubscribeCalls += 1; }
onSubscribeFirst(): void { this.firstSubscribeCalls += 1; }
onUnsubscribeLast(): void { this.firstUnsubscribeCalls += 1; }
}
return {
test_unsubscribe(assert) {
test_unsubscribe(assert): void {
const c = new Collection();
const unsubscribe = c.subscribe({});
unsubscribe();

29
src/observable/ObservableValue.ts
View File

@ -20,7 +20,7 @@ import type {SubscriptionHandle} from "./BaseObservable";
// like an EventEmitter, but doesn't have an event type
export abstract class BaseObservableValue<T> extends BaseObservable<(value: T) => void> {
emit(argument: T) {
emit(argument: T): void {
for (const h of this._handlers) {
h(argument);
}
@ -68,7 +68,7 @@ class WaitForHandle<T> implements IWaitHandle<T> {
return this._promise;
}
dispose() {
dispose(): void {
if (this._subscription) {
this._subscription();
this._subscription = null;
@ -82,7 +82,7 @@ class WaitForHandle<T> implements IWaitHandle<T> {
class ResolvedWaitForHandle<T> implements IWaitHandle<T> {
constructor(public promise: Promise<T>) {}
dispose() {}
dispose(): void {}
}
export class ObservableValue<T> extends BaseObservableValue<T> {
@ -113,7 +113,7 @@ export class RetainedObservableValue<T> extends ObservableValue<T> {
this._freeCallback = freeCallback;
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
this._freeCallback();
}
@ -130,7 +130,7 @@ export class FlatMapObservableValue<P, C> extends BaseObservableValue<C | undefi
super();
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
this.sourceSubscription = this.sourceSubscription!();
if (this.targetSubscription) {
@ -138,7 +138,7 @@ export class FlatMapObservableValue<P, C> extends BaseObservableValue<C | undefi
}
}
onSubscribeFirst() {
onSubscribeFirst(): void {
super.onSubscribeFirst();
this.sourceSubscription = this.source.subscribe(() => {
this.updateTargetSubscription();
@ -147,7 +147,7 @@ export class FlatMapObservableValue<P, C> extends BaseObservableValue<C | undefi
this.updateTargetSubscription();
}
private updateTargetSubscription() {
private updateTargetSubscription(): void {
const sourceValue = this.source.get();
if (sourceValue) {
const target = this.mapper(sourceValue);
@ -174,9 +174,10 @@ export class FlatMapObservableValue<P, C> extends BaseObservableValue<C | undefi
}
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
return {
"set emits an update": assert => {
"set emits an update": (assert): void => {
const a = new ObservableValue<number>(0);
let fired = false;
const subscription = a.subscribe(v => {
@ -187,7 +188,7 @@ export function tests() {
assert(fired);
subscription();
},
"set doesn't emit if value hasn't changed": assert => {
"set doesn't emit if value hasn't changed": (assert): void => {
const a = new ObservableValue(5);
let fired = false;
const subscription = a.subscribe(() => {
@ -198,7 +199,7 @@ export function tests() {
assert(!fired);
subscription();
},
"waitFor promise resolves on matching update": async assert => {
"waitFor promise resolves on matching update": async (assert): Promise<void> => {
const a = new ObservableValue(5);
const handle = a.waitFor(v => v === 6);
await Promise.resolve().then(() => {
@ -207,7 +208,7 @@ export function tests() {
await handle.promise;
assert.strictEqual(a.get(), 6);
},
"waitFor promise rejects when disposed": async assert => {
"waitFor promise rejects when disposed": async (assert): Promise<void> => {
const a = new ObservableValue<number>(0);
const handle = a.waitFor(() => false);
await Promise.resolve().then(() => {
@ -215,7 +216,7 @@ export function tests() {
});
await assert.rejects(handle.promise, AbortError);
},
"flatMap.get": assert => {
"flatMap.get": (assert): void => {
const a = new ObservableValue<undefined | {count: ObservableValue<number>}>(undefined);
const countProxy = a.flatMap(a => a!.count);
assert.strictEqual(countProxy.get(), undefined);
@ -223,7 +224,7 @@ export function tests() {
a.set({count});
assert.strictEqual(countProxy.get(), 0);
},
"flatMap update from source": assert => {
"flatMap update from source": (assert): void => {
const a = new ObservableValue<undefined | {count: ObservableValue<number>}>(undefined);
const updates: (number | undefined)[] = [];
a.flatMap(a => a!.count).subscribe(count => {
@ -233,7 +234,7 @@ export function tests() {
a.set({count});
assert.deepEqual(updates, [0]);
},
"flatMap update from target": assert => {
"flatMap update from target": (assert): void => {
const a = new ObservableValue<undefined | {count: ObservableValue<number>}>(undefined);
const updates: (number | undefined)[] = [];
a.flatMap(a => a!.count).subscribe(count => {

6
src/observable/list/AsyncMappedList.ts
View File

@ -135,10 +135,12 @@ class ResetEvent<F> {
import {ObservableArray} from "./ObservableArray";
import {ListObserver} from "../../mocks/ListObserver.js";
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
return {
"events are emitted in order": async assert => {
const double = n => n * n;
"events are emitted in order": async (assert): Promise<void> => {
const double = (n: number): number => n * n;
const source = new ObservableArray<number>();
const mapper = new AsyncMappedList(source, async n => {
await new Promise(r => setTimeout(r, n));

5
src/observable/list/BaseMappedList.ts
View File

@ -37,14 +37,15 @@ export class BaseMappedList<F,T,R = T> extends BaseObservableList<T> {
this._removeCallback = removeCallback;
}
findAndUpdate(predicate: (value: T) => boolean, updater: (value: T) => any | false) {
findAndUpdate(predicate: (value: T) => boolean, updater: (value: T) => any | false): boolean {
return findAndUpdateInArray(predicate, this._mappedValues!, this, updater);
}
get length() {
get length(): number {
return this._mappedValues!.length;
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return this._mappedValues!.values();
}

12
src/observable/list/BaseObservableList.ts
View File

@ -26,17 +26,17 @@ export interface IListObserver<T> {
export function defaultObserverWith<T>(overrides: { [key in keyof IListObserver<T>]?: IListObserver<T>[key] }): IListObserver<T> {
const defaults = {
onReset(){},
onAdd(){},
onUpdate(){},
onRemove(){},
onMove(){},
onReset(): void {},
onAdd(): void {},
onUpdate(): void {},
onRemove(): void {},
onMove(): void {},
};
return Object.assign(defaults, overrides);
}
export abstract class BaseObservableList<T> extends BaseObservable<IListObserver<T>> implements Iterable<T> {
emitReset() {
emitReset(): void {
for(let h of this._handlers) {
h.onReset(this);
}

13
src/observable/list/ConcatList.ts
View File

@ -86,10 +86,12 @@ export class ConcatList<T> extends BaseObservableList<T> implements IListObserve
return len;
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
let sourceListIdx = 0;
let it = this._sourceLists[0][Symbol.iterator]();
return {
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
next: () => {
let result = it.next();
while (result.done) {
@ -108,16 +110,19 @@ export class ConcatList<T> extends BaseObservableList<T> implements IListObserve
import {ObservableArray} from "./ObservableArray";
import {defaultObserverWith} from "./BaseObservableList";
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export async function tests() {
return {
test_length(assert) {
test_length(assert): void {
const all = new ConcatList(
new ObservableArray([1, 2, 3]),
new ObservableArray([11, 12, 13])
);
assert.equal(all.length, 6);
},
test_iterator(assert) {
test_iterator(assert): void {
const all = new ConcatList(
new ObservableArray([1, 2, 3]),
new ObservableArray([11, 12, 13])
@ -131,7 +136,7 @@ export async function tests() {
assert.equal(it.next().value, 13);
assert(it.next().done);
},
test_add(assert) {
test_add(assert): void {
const list1 = new ObservableArray([1, 2, 3]);
const list2 = new ObservableArray([11, 12, 13]);
const all = new ConcatList(list1, list2);
@ -146,7 +151,7 @@ export async function tests() {
list2.insert(1, 11.5);
assert(fired);
},
test_update(assert) {
test_update(assert): void {
const list1 = new ObservableArray([1, 2, 3]);
const list2 = new ObservableArray([11, 12, 13]);
const all = new ConcatList(list1, list2);

17
src/observable/list/MappedList.ts
View File

@ -19,7 +19,7 @@ import {IListObserver} from "./BaseObservableList";
import {BaseMappedList, runAdd, runUpdate, runRemove, runMove, runReset} from "./BaseMappedList";
export class MappedList<F,T> extends BaseMappedList<F,T> implements IListObserver<F> {
onSubscribeFirst() {
onSubscribeFirst(): void {
this._sourceUnsubscribe = this._sourceList.subscribe(this);
this._mappedValues = [];
for (const item of this._sourceList) {
@ -61,18 +61,21 @@ import {ObservableArray} from "./ObservableArray";
import {BaseObservableList} from "./BaseObservableList";
import {defaultObserverWith} from "./BaseObservableList";
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export async function tests() {
class MockList extends BaseObservableList<number> {
get length() {
get length(): 0 {
return 0;
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return [].values();
}
}
return {
test_add(assert) {
test_add(assert): void {
const source = new MockList();
const mapped = new MappedList(source, n => {return {n: n*n};});
let fired = false;
@ -87,7 +90,7 @@ export async function tests() {
assert(fired);
unsubscribe();
},
test_update(assert) {
test_update(assert): void {
const source = new MockList();
const mapped = new MappedList<number, { n: number, m?: number }>(
source,
@ -109,7 +112,7 @@ export async function tests() {
assert(fired);
unsubscribe();
},
"test findAndUpdate not found": assert => {
"test findAndUpdate not found": (assert): void => {
const source = new ObservableArray([1, 3, 4]);
const mapped = new MappedList(
source,
@ -123,7 +126,7 @@ export async function tests() {
() => assert.fail()
), false);
},
"test findAndUpdate found but updater bails out of update": assert => {
"test findAndUpdate found but updater bails out of update": (assert): void => {
const source = new ObservableArray([1, 3, 4]);
const mapped = new MappedList(
source,
@ -143,7 +146,7 @@ export async function tests() {
), true);
assert.equal(fired, true);
},
"test findAndUpdate emits update": assert => {
"test findAndUpdate emits update": (assert): void => {
const source = new ObservableArray([1, 3, 4]);
const mapped = new MappedList(
source,

1
src/observable/list/ObservableArray.ts
View File

@ -75,6 +75,7 @@ export class ObservableArray<T> extends BaseObservableList<T> {
return this._items.length;
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return this._items.values();
}

9
src/observable/list/SortedArray.ts
View File

@ -112,6 +112,7 @@ export class SortedArray<T> extends BaseObservableList<T> {
return this._items.length;
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return new Iterator(this);
}
@ -127,6 +128,7 @@ class Iterator<T> {
this._current = null;
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
next() {
if (this._sortedArray) {
if (this._current) {
@ -147,9 +149,10 @@ class Iterator<T> {
}
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
return {
"setManyUnsorted": assert => {
"setManyUnsorted": (assert): void => {
const sa = new SortedArray<string>((a, b) => a.localeCompare(b));
sa.setManyUnsorted(["b", "a", "c"]);
assert.equal(sa.length, 3);
@ -157,7 +160,7 @@ export function tests() {
assert.equal(sa.get(1), "b");
assert.equal(sa.get(2), "c");
},
"_getNext": assert => {
"_getNext": (assert): void => {
const sa = new SortedArray<string>((a, b) => a.localeCompare(b));
sa.setManyUnsorted(["b", "a", "f"]);
assert.equal(sa._getNext("a"), "b");
@ -166,7 +169,7 @@ export function tests() {
assert.equal(sa._getNext("c"), "f");
assert.equal(sa._getNext("f"), undefined);
},
"iterator with removals": assert => {
"iterator with removals": (assert): void => {
const queue = new SortedArray<{idx: number}>((a, b) => a.idx - b.idx);
queue.setManyUnsorted([{idx: 5}, {idx: 3}, {idx: 1}, {idx: 4}, {idx: 2}]);
const it = queue[Symbol.iterator]();

7
src/observable/list/common.ts
View File

@ -17,7 +17,12 @@ limitations under the License.
import {BaseObservableList} from "./BaseObservableList";
/* inline update of item in collection backed by array, without replacing the preexising item */
export function findAndUpdateInArray<T>(predicate: (value: T) => boolean, array: T[], observable: BaseObservableList<T>, updater: (value: T) => any | false) {
export function findAndUpdateInArray<T>(
predicate: (value: T) => boolean,
array: T[],
observable: BaseObservableList<T>,
updater: (value: T) => any | false
): boolean {
const index = array.findIndex(predicate);
if (index !== -1) {
const value = array[index];

23
src/observable/map/ApplyMap.ts
View File

@ -36,42 +36,42 @@ export class ApplyMap<K, V> extends BaseObservableMap<K, V> {
this._config = config<K, V>();
}
hasApply() {
hasApply(): boolean {
return !!this._apply;
}
setApply(apply?: Apply<K, V>) {
setApply(apply?: Apply<K, V>): void {
this._apply = apply;
if (this._apply) {
this.applyOnce(this._apply);
}
}
applyOnce(apply: Apply<K, V>) {
applyOnce(apply: Apply<K, V>): void {
for (const [key, value] of this._source) {
apply(key, value);
}
}
onAdd(key: K, value: V) {
onAdd(key: K, value: V): void {
if (this._apply) {
this._apply(key, value);
}
this.emitAdd(key, value);
}
onRemove(key: K, value: V) {
onRemove(key: K, value: V): void {
this.emitRemove(key, value);
}
onUpdate(key: K, value: V, params: any) {
onUpdate(key: K, value: V, params: any): void {
if (this._apply) {
this._apply(key, value, params);
}
this.emitUpdate(key, value, params);
}
onSubscribeFirst() {
onSubscribeFirst(): void {
this._subscription = this._source.subscribe(this);
if (this._apply) {
this.applyOnce(this._apply);
@ -79,27 +79,28 @@ export class ApplyMap<K, V> extends BaseObservableMap<K, V> {
super.onSubscribeFirst();
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
if (this._subscription) this._subscription = this._subscription();
}
onReset() {
onReset(): void {
if (this._apply) {
this.applyOnce(this._apply);
}
this.emitReset();
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return this._source[Symbol.iterator]();
}
get size() {
get size(): number {
return this._source.size;
}
get(key: K) {
get(key: K): V | undefined {
return this._source.get(key);
}

8
src/observable/map/BaseObservableMap.ts
View File

@ -36,26 +36,26 @@ export type BaseObservableMapConfig<K, V> = {
}
export abstract class BaseObservableMap<K, V> extends BaseObservable<IMapObserver<K, V>> {
emitReset() {
emitReset(): void {
for(let h of this._handlers) {
h.onReset();
}
}
// we need batch events, mostly on index based collection though?
// maybe we should get started without?
emitAdd(key: K, value: V) {
emitAdd(key: K, value: V): void {
for(let h of this._handlers) {
h.onAdd(key, value);
}
}
emitUpdate(key: K, value: V, params: any) {
emitUpdate(key: K, value: V, params: any): void {
for(let h of this._handlers) {
h.onUpdate(key, value, params);
}
}
emitRemove(key: K, value: V) {
emitRemove(key: K, value: V): void {
for(let h of this._handlers) {
h.onRemove(key, value);
}

36
src/observable/map/FilteredMap.ts
View File

@ -35,7 +35,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
this._config = config<K, V>();
}
setFilter(filter: Filter<K, V>) {
setFilter(filter: Filter<K, V>): void {
this._filter = filter;
if (this._subscription) {
this._reapplyFilter();
@ -45,7 +45,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
/**
* reapply the filter
*/
_reapplyFilter(silent = false) {
_reapplyFilter(silent = false): void {
if (this._filter) {
const oldIncluded = this._included;
this._included = this._included || new Map();
@ -71,7 +71,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
}
}
onAdd(key: K, value: V) {
onAdd(key: K, value: V): void {
if (this._filter) {
if (this._included) {
const included = this._filter(value, key);
@ -86,7 +86,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
this.emitAdd(key, value);
}
onRemove(key: K, value: V) {
onRemove(key: K, value: V): void {
const wasIncluded = !this._filter || this._included?.get(key);
if (this._included) {
this._included.delete(key);
@ -98,7 +98,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
}
}
onUpdate(key: K, value: V, params: any) {
onUpdate(key: K, value: V, params: any): void {
// if an update is emitted while calling source.subscribe() from onSubscribeFirst, ignore it
if (!this._included) {
return;
@ -113,7 +113,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
}
}
_emitForUpdate(wasIncluded: boolean | undefined, isIncluded: boolean, key: K, value: V, params: any = null) {
_emitForUpdate(wasIncluded: boolean | undefined, isIncluded: boolean, key: K, value: V, params: any = null): void {
if (wasIncluded && !isIncluded) {
this.emitRemove(key, value);
} else if (!wasIncluded && isIncluded) {
@ -123,13 +123,13 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
}
}
onSubscribeFirst() {
onSubscribeFirst(): void {
this._subscription = this._source.subscribe(this);
this._reapplyFilter(true);
super.onSubscribeFirst();
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
this._included = undefined;
if (this._subscription) {
@ -137,16 +137,17 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
}
}
onReset() {
onReset(): void {
this._reapplyFilter();
this.emitReset();
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return new FilterIterator<K, V>(this._source, this._included);
}
get size() {
get size(): number {
let count = 0;
this._included?.forEach(included => {
if (included) {
@ -156,7 +157,7 @@ export class FilteredMap<K, V> extends BaseObservableMap<K, V> {
return count;
}
get(key) {
get(key): V | undefined{
const value = this._source.get(key);
if (value && this._filter(value, key)) {
return value;
@ -188,6 +189,7 @@ class FilterIterator<K, V> {
this._sourceIterator = map[Symbol.iterator]();
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
next() {
// eslint-disable-next-line no-constant-condition
while (true) {
@ -204,9 +206,11 @@ class FilterIterator<K, V> {
}
import {ObservableMap} from "..";
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
return {
"filter preloaded list": assert => {
"filter preloaded list": (assert): void => {
const source = new ObservableMap();
source.add("one", 1);
source.add("two", 2);
@ -233,17 +237,17 @@ export function tests() {
assert.deepEqual(it.next().value, ["three", 3]);
assert.equal(it.next().done, true);
},
// "filter added values": assert => {
// "filter added values": (assert): void => {
// },
// "filter removed values": assert => {
// "filter removed values": (assert): void => {
// },
// "filter changed values": assert => {
// "filter changed values": (assert): void => {
// },
"emits must trigger once": assert => {
"emits must trigger once": (assert): void => {
const source = new ObservableMap();
let count_add = 0, count_update = 0, count_remove = 0;
source.add("num1", 1);

49
src/observable/map/JoinedMap.ts
View File

@ -33,7 +33,7 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
this._config = config<K, V>();
}
onAdd(source: BaseObservableMap<K, V>, key: K, value: V) {
onAdd(source: BaseObservableMap<K, V>, key: K, value: V): void {
if (!this._isKeyAtSourceOccluded(source, key)) {
const occludingValue = this._getValueFromOccludedSources(source, key);
if (occludingValue !== undefined) {
@ -45,7 +45,7 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
}
}
onRemove(source: BaseObservableMap<K, V>, key: K, value: V) {
onRemove(source: BaseObservableMap<K, V>, key: K, value: V): void {
if (!this._isKeyAtSourceOccluded(source, key)) {
this.emitRemove(key, value);
const occludedValue = this._getValueFromOccludedSources(source, key);
@ -57,7 +57,7 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
}
}
onUpdate(source: BaseObservableMap<K, V>, key: K, value: V, params: any) {
onUpdate(source: BaseObservableMap<K, V>, key: K, value: V, params: any): void {
// if an update is emitted while calling source.subscribe() from onSubscribeFirst, ignore it
if (!this._subscriptions) {
return;
@ -67,16 +67,16 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
}
}
onReset() {
onReset(): void {
this.emitReset();
}
onSubscribeFirst() {
onSubscribeFirst(): void {
this._subscriptions = this._sources.map(source => new SourceSubscriptionHandler(source, this).subscribe());
super.onSubscribeFirst();
}
_isKeyAtSourceOccluded(source: BaseObservableMap<K, V>, key: K) {
_isKeyAtSourceOccluded(source: BaseObservableMap<K, V>, key: K): boolean {
// sources that come first in the sources array can
// hide the keys in later sources, to prevent events
// being emitted for the same key and different values,
@ -91,7 +91,7 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
}
// get the value that the given source and key occlude, if any
_getValueFromOccludedSources(source: BaseObservableMap<K, V>, key: K) {
_getValueFromOccludedSources(source: BaseObservableMap<K, V>, key: K): V | undefined{
// sources that come first in the sources array can
// hide the keys in later sources, to prevent events
// being emitted for the same key and different values,
@ -107,7 +107,7 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
return undefined;
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
if (this._subscriptions) {
for (const s of this._subscriptions) {
@ -116,15 +116,16 @@ export class JoinedMap<K, V> extends BaseObservableMap<K, V> {
}
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return new JoinedIterator<K, V>(this._sources);
}
get size() {
get size(): number {
return this._sources.reduce((sum, s) => sum + s.size, 0);
}
get(key: K): V | undefined{
get(key: K): V | undefined {
for (const s of this._sources) {
const value = s.get(key);
if (value) {
@ -199,28 +200,28 @@ class SourceSubscriptionHandler<K, V> {
this._subscription = undefined;
}
subscribe() {
subscribe(): this {
this._subscription = this._source.subscribe(this);
return this;
}
dispose() {
dispose(): void {
if (this._subscription) this._subscription = this._subscription();
}
onAdd(key: K, value: V) {
onAdd(key: K, value: V): void {
this._joinedMap.onAdd(this._source, key, value);
}
onRemove(key: K, value: V) {
onRemove(key: K, value: V): void {
this._joinedMap.onRemove(this._source, key, value);
}
onUpdate(key: K, value: V, params: any) {
onUpdate(key: K, value: V, params: any): void {
this._joinedMap.onUpdate(this._source, key, value, params);
}
onReset() {
onReset(): void {
this._joinedMap.onReset();
}
}
@ -228,9 +229,9 @@ class SourceSubscriptionHandler<K, V> {
import {ObservableMap} from "..";
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
function observeMap(map: JoinedMap<any, any>) {
function observeMap(map: JoinedMap<any, any>): { type: string; key: any; value: any; params?: any; }[] {
const events: { type: string, key: any, value: any, params?: any }[] = [];
map.subscribe({
onAdd(key, value) { events.push({ type: "add", key, value }); },
@ -244,7 +245,7 @@ export function tests() {
}
return {
"joined iterator": assert => {
"joined iterator": (assert): void => {
const firstKV: [string, number] = ["a", 1];
const secondKV: [string, number] = ["b", 2];
const thirdKV: [string, number] = ["c", 3];
@ -254,7 +255,7 @@ export function tests() {
assert.equal(it.next().value, thirdKV);
assert.equal(it.next().done, true);
},
"prevent key collision during iteration": assert => {
"prevent key collision during iteration": (assert): void => {
const first = new ObservableMap();
const second = new ObservableMap();
const join = new JoinedMap([first, second]);
@ -266,7 +267,7 @@ export function tests() {
assert.deepEqual(it.next().value, ["b", 3]);
assert.equal(it.next().done, true);
},
"adding occluded key doesn't emit add": assert => {
"adding occluded key doesn't emit add": (assert): void => {
const first = new ObservableMap();
const second = new ObservableMap();
const join = new JoinedMap([first, second]);
@ -278,7 +279,7 @@ export function tests() {
assert.equal(events[0].key, "a");
assert.equal(events[0].value, 1);
},
"updating occluded key doesn't emit update": assert => {
"updating occluded key doesn't emit update": (assert): void => {
const first = new ObservableMap();
const second = new ObservableMap();
const join = new JoinedMap([first, second]);
@ -288,7 +289,7 @@ export function tests() {
second.update("a", 3);
assert.equal(events.length, 0);
},
"removal of occluding key emits add after remove": assert => {
"removal of occluding key emits add after remove": (assert): void => {
const first = new ObservableMap();
const second = new ObservableMap();
const join = new JoinedMap([first, second]);
@ -304,7 +305,7 @@ export function tests() {
assert.equal(events[1].key, "a");
assert.equal(events[1].value, 2);
},
"adding occluding key emits remove first": assert => {
"adding occluding key emits remove first": (assert): void => {
const first = new ObservableMap();
const second = new ObservableMap();
const join = new JoinedMap([first, second]);

17
src/observable/map/LogMap.ts
View File

@ -42,47 +42,48 @@ export class LogMap<K, V> extends BaseObservableMap<K, V> {
return this._log.log(labelOrValues, logLevel);
}
onAdd(key: K, value: V) {
onAdd(key: K, value: V): void {
this.log("add " + JSON.stringify({key, value}));
this.emitAdd(key, value);
}
onRemove(key: K, value: V) {
onRemove(key: K, value: V): void {
this.log("remove " + JSON.stringify({key, value}));
this.emitRemove(key, value);
}
onUpdate(key: K, value: V, params: any) {
onUpdate(key: K, value: V, params: any): void {
this.log("update" + JSON.stringify({key, value, params}));
this.emitUpdate(key, value, params);
}
onSubscribeFirst() {
onSubscribeFirst(): void {
this.log("subscribeFirst");
this._subscription = this._source.subscribe(this);
super.onSubscribeFirst();
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
if (this._subscription) this._subscription = this._subscription();
this.log("unsubscribeLast");
}
onReset() {
onReset(): void {
this.log("reset");
this.emitReset();
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return this._source[Symbol.iterator]();
}
get size() {
get size(): number {
return this._source.size;
}
get(key: K) {
get(key: K): V | undefined{
return this._source.get(key);
}

17
src/observable/map/MappedMap.ts
View File

@ -46,28 +46,28 @@ export class MappedMap<K, V> extends BaseObservableMap<K, V> {
this._config = config<K, V>();
}
_emitSpontaneousUpdate(key: K, params: any) {
_emitSpontaneousUpdate(key: K, params: any): void {
const value = this._mappedValues.get(key);
if (value) {
this.emitUpdate(key, value, params);
}
}
onAdd(key: K, value: V) {
onAdd(key: K, value: V): void {
const emitSpontaneousUpdate = this._emitSpontaneousUpdate.bind(this, key);
const mappedValue = this._mapper(value, emitSpontaneousUpdate);
this._mappedValues.set(key, mappedValue);
this.emitAdd(key, mappedValue);
}
onRemove(key: K/*, _value*/) {
onRemove(key: K/*, _value*/): void {
const mappedValue = this._mappedValues.get(key);
if (this._mappedValues.delete(key)) {
if (mappedValue) this.emitRemove(key, mappedValue);
}
}
onUpdate(key: K, value: V, params: any) {
onUpdate(key: K, value: V, params: any): void {
// if an update is emitted while calling source.subscribe() from onSubscribeFirst, ignore it
if (!this._mappedValues) {
return;
@ -80,7 +80,7 @@ export class MappedMap<K, V> extends BaseObservableMap<K, V> {
}
}
onSubscribeFirst() {
onSubscribeFirst(): void {
this._subscription = this._source.subscribe(this);
for (let [key, value] of this._source) {
const emitSpontaneousUpdate = this._emitSpontaneousUpdate.bind(this, key);
@ -90,22 +90,23 @@ export class MappedMap<K, V> extends BaseObservableMap<K, V> {
super.onSubscribeFirst();
}
onUnsubscribeLast() {
onUnsubscribeLast(): void {
super.onUnsubscribeLast();
if (this._subscription) this._subscription = this._subscription();
this._mappedValues.clear();
}
onReset() {
onReset(): void {
this._mappedValues.clear();
this.emitReset();
}
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
[Symbol.iterator]() {
return this._mappedValues.entries();
}
get size() {
get size(): number {
return this._mappedValues.size;
}

17
src/observable/map/ObservableMap.ts
View File

@ -117,9 +117,10 @@ export class ObservableMap<K, V> extends BaseObservableMap<K, V> {
}
};
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
export function tests() {
return {
test_initial_values(assert) {
test_initial_values(assert): void {
const map = new ObservableMap([
["a", 5],
["b", 10]
@ -129,7 +130,7 @@ export function tests() {
assert.equal(map.get("b"), 10);
},
test_add(assert) {
test_add(assert): void {
let fired = 0;
const map = new ObservableMap<number, {value: number}>();
map.subscribe({
@ -147,7 +148,7 @@ export function tests() {
assert.equal(fired, 1);
},
test_update(assert) {
test_update(assert): void {
let fired = 0;
const map = new ObservableMap<number, {number: number}>();
const value = {number: 5};
@ -168,7 +169,7 @@ export function tests() {
assert.equal(fired, 1);
},
test_update_unknown(assert) {
test_update_unknown(assert): void {
let fired = 0;
const map = new ObservableMap<number, {number: number}>();
map.subscribe({
@ -182,7 +183,7 @@ export function tests() {
assert.equal(result, false);
},
test_set(assert) {
test_set(assert): void {
let add_fired = 0, update_fired = 0;
const map = new ObservableMap<number, {value: number}>();
map.subscribe({
@ -209,7 +210,7 @@ export function tests() {
assert.equal(update_fired, 1);
},
test_remove(assert) {
test_remove(assert): void {
let fired = 0;
const map = new ObservableMap<number, {value: number}>();
const value = {value: 5};
@ -229,7 +230,7 @@ export function tests() {
assert.equal(fired, 1);
},
test_iterate(assert) {
test_iterate(assert): void {
const results: any[] = [];
const map = new ObservableMap<number, {number: number}>();
map.add(1, {number: 5});
@ -243,7 +244,7 @@ export function tests() {
assert.equal(results.find(([key]) => key === 2)[1].number, 6);
assert.equal(results.find(([key]) => key === 3)[1].number, 7);
},
test_size(assert) {
test_size(assert): void {
const map = new ObservableMap<number, {number: number}>();
map.add(1, {number: 5});
map.add(2, {number: 6});