private handleHighResImageLoad(fullResImage){ if (!fullResImage) { return; } const image = new Image(); image.src = fullResImage; if (!image.complete) { const onLoadObservable = Observable.create(obs => { image.onload = () => { obs.next(image); obs.complete(); } }); // We want the animation to finish before replacing the pic // as the calculation has been done with the smaller image Observable.zip(onLoadObservable, this.didEnter) .subscribe(() => this.instance.updateImageSrcWithTransition(fullResImage)); } else { this.instance.updateImageSrc(fullResImage) } }
.concatMap<{errors: string[], config: {[key: string]: string}, appSettings: {[key: string]: string} }>(() => Observable.zip( this._functionsService.getHostErrors().catch(e => Observable.of([])), this._armService.getConfig(this._globalStateService.FunctionContainer), this._armService.getFunctionContainerAppSettings(this._globalStateService.FunctionContainer), (e, c, a) => ({errors: e, config: c, appSettings: a}) )
getEventLoops(event: EventModel): Observable<TrackModel[]> { if (!event) { return Observable.of([]); } const loopObservables: Observable<TrackModel>[] = _([event.loop1, event.loop2, event.loop3]) .filter((loopId: string) => loopId) .map((loop: string) => this.getTrack(loop)) .value(); if (loopObservables.length === 0) { return Observable.of([]); } return Observable.zip(...loopObservables); }
constructor( dispatcher$: Dispatcher<Action> ) { const initState: AppState = { heroes: initialHeroes }; this.stateSubject$ = new BehaviorSubject(initState); Observable .zip<AppState>( heroReducer(initState.heroes, dispatcher$), (heroes) => { return { heroes } as AppState; } ) .subscribe(appState => { this.stateSubject$.next(appState); }); }
export const stateFn = (initial: AppState, action$: Observable<Action>): Observable<AppState> => { const subject$ = new BehaviorSubject(initial); Observable .zip( todosReducer(initial.todos, action$), filtersReducer(initial.filters, action$), logReducer(initial.log, action$), (todos, filters, log) => { return { todos, filters, log } as AppState; } ) .do(v => console.log(v)) .subscribe(state => { subject$.next(state); }); return subject$; };
dragulaService.drop.subscribe(([bag, element, target, source, next]) => { // Look at the adjacent tasks in the list and pick a priority in the middle let prev = element.previousElementSibling; if (bag === 'taskBag') { let observables: Observable<Task>[] = [Observable.of(undefined), Observable.of(undefined), Observable.of(undefined)]; // Get the keys from the DOM. Stored in data-key attributes. if (prev != null && prev.className === 'task') observables[0] = (af.object(this.boardURL + '/tasks/' + prev.dataset.key)); if (element != null && element.className === 'task') observables[1] = (af.object(this.boardURL + '/tasks/' + element.dataset.key)); if (next != null && next.className === 'task') observables[2] = (af.object(this.boardURL + '/tasks/' + next.dataset.key)); Observable.zip(...observables) // Combine the observables then subscribe asynchronously .take(1) // only subscribe once .subscribe(([previousTask, movedTask, nextTask]: Task[]) => { let lower = -4; // arbitrary let upper = 4; // arbitrary if (previousTask && previousTask.priority != null) { lower = previousTask.priority; } else if (nextTask && nextTask.priority != null) { lower = nextTask.priority - 4; } if (nextTask && nextTask.priority != null) { upper = nextTask.priority; } else if (previousTask && previousTask.priority != null) { upper = previousTask.priority + 4; } // Update the priority of the moved task in the database movedTask.priority = lower + (Math.abs(upper - lower) / 2); // Check if it swapped to a different list if (target.dataset.key !== source.dataset.key) { movedTask.list = target.dataset.key; } this.taskObservable.update(element.dataset.key, movedTask); }); } else if (bag === 'listBag') { // TODO reorder the lists, similar as above } });
constructor(todoStore: TodoStorage) { super([ "areAllTodosComplete", "todos", "editedTodo", "newTodo", "status", "_visibleTodos", "remainingText" ]); this._store = todoStore; this.editedTodo = null; this.newTodo = new Todo(); this.todos = new ReactiveArray<Todo>(); this.areAllTodosComplete = false; this.completedTodos = this.todos.derived.whenAnyItemProperty().filter(t => t.completed).build(); this.incompleteTodos = this.todos.derived.whenAnyItemProperty().filter(t => !t.completed).build(); this.save = ReactiveCommand.createFromTask((a) => { return this._store.putTodos(this.todos.toArray()); }); var isNotSaving = this.save.isExecuting.map(executing => !executing); this.loadTodos = ReactiveCommand.createFromTask((a) => { return this._store.getTodos(); }); this.loadTodos.results.subscribe(todos => { this.todos.splice(0, this.todos.length, ...todos); }); this.deleteTodo = ReactiveCommand.createFromObservable((a: Todo) => { var todoIndex = this.todos.indexOf(a); if (todoIndex >= 0) { this.todos.splice(todoIndex, 1); return this.save.execute(); } else { return Observable.of(false); } }); this.toggleTodo = ReactiveCommand.createFromObservable((todo: Todo) => { todo.completed = !todo.completed; return this.save.execute(); }, isNotSaving); var hasValidNewTodo = this.whenAnyValue(vm => vm.newTodo.title) .map(title => this.isValidTitle(title)); var canAddTodo = Observable.combineLatest( hasValidNewTodo, isNotSaving, (validTodo, isNotSaving) => validTodo && isNotSaving); this.addTodo = ReactiveCommand.createFromObservable((a) => { this.newTodo.title = this.newTodo.title.trim(); this.todos.unshift(this.newTodo.copy()); this.resetNewTodo(); return this.save.execute(); }, canAddTodo); this.editTodo = ReactiveCommand.create((todo: Todo) => { this._originalTodo = todo.copy(); this.editedTodo = todo; return {}; }); this.finishEditing = ReactiveCommand.createFromObservable(a => { if (this.editedTodo) { this.editedTodo.title = this.editedTodo.title.trim(); if (this.editedTodo.title.length == 0) { return this.deleteTodo.execute(this.editedTodo); } this.editedTodo = null; } return this.save.execute().do(saved => { if (saved) { this._originalTodo = null; this.editedTodo = null; } }); }, isNotSaving); var canUndo = this.whenAnyValue(vm => vm.editedTodo, vm => vm.todos, (e, todos) => e !== null && todos !== null); this.undo = ReactiveCommand.create(a => { if (this.editedTodo && this._originalTodo) { this.editedTodo.title = this._originalTodo.title; this.editedTodo.completed = this._originalTodo.completed; } this.editedTodo = null; this._originalTodo = null; return true; }, canUndo); var areAllComplete = this.todos.computed.every(t => t.completed); var hasTodos = this.todos.whenAnyValue(t => t.length).map(length => length > 0); var canMarkAllComplete = Observable.combineLatest(hasTodos, areAllComplete, isNotSaving, (hasTodos, complete, notSaving) => hasTodos && !complete && notSaving); var canMarkAllIncomplete = Observable.combineLatest(hasTodos, areAllComplete, isNotSaving, (hasTodos, complete, notSaving) => hasTodos && complete && notSaving); Observable.zip(hasTodos, areAllComplete, (hasTodos, complete) => hasTodos && complete) .subscribe(complete => { this.areAllTodosComplete = complete; }); this.markAllComplete = ReactiveCommand.createFromObservable(a => { var completedTodos = this.todos; completedTodos.forEach(t => { t.completed = true; }); return this.save.execute(); }, canMarkAllComplete); this.markAllIncomplete = ReactiveCommand.createFromObservable(a => { var incompleteTodos = this.todos; incompleteTodos.forEach(t => { t.completed = false; }); return this.save.execute(); }, canMarkAllIncomplete); this.toggleAllComplete = ReactiveCommand.createFromObservable(a => { var allComplete = this.todos.every(t => t.completed); if (allComplete) { return this.markAllIncomplete.execute(); } else { return this.markAllComplete.execute(); } }, isNotSaving); this.clearComplete = ReactiveCommand.createFromObservable(a => { var todos = this.todos; for (var i = todos.length - 1; i >= 0; i--) { var t = todos.getItem(i); if (t.completed) { todos.splice(i, 1); } } return this.save.execute(); }, isNotSaving); this.whenAnyValue(vm => vm.todos, vm => vm.status, (todos, status) => ({ todos, status })) .filter(args => args.todos !== null) .map(args => { if (args.status === "all") { return args.todos; } else if (args.status === "complete") { return args.todos.derived.whenAnyItemProperty().filter(t => t.completed).build(); } else { return args.todos.derived.whenAnyItemProperty().filter(t => !t.completed).build(); } }).subscribe(todos => { this._visibleTodos = todos; }); this.whenAnyValue(vm => vm._visibleTodos) .map(arr => arr.toObservable()) .switch() .subscribe(arr => { this.set("visibleTodos", arr); }); this.incompleteTodos.whenAnyValue(incomplete => incomplete.length) .map(l => l === 1 ? 'item left' : 'items left') .subscribe(text => this.remainingText = text); this.status = "all"; }
.mergeMap((todo) => { return Observable.zip( this.detail(todo.id), this.newestEpisode(todo.id), (detail, episode) => ({ id: todo.id, todo, detail, episode })); })
.switchMap(fi => Observable.zip( this._functionsService.getFileContent(fi.script_href), fi.clientOnly ? Observable.of({}) : this._functionsService.getSecrets(fi), this._functionsService.getFunction(fi), (c, s, f) => ({ content: c, secrets: s, functionInfo: f }))
const observable3: any = constructorZone1.run(() => { return Rx.Observable.zip(observable1, observable2, function(n: number, str: string) { expect(Zone.current.name).toEqual(constructorZone1.name); return {n: n, str: str}; }); });