this._scrollListener = (event) => this._elementScrolled.next(event);
componentWillReceiveProps(nextProps: PropsTypeIn) { this.receive$.next(nextProps); }
error => { data$.error(error); },
switchMap(() => { const frameReady = new Subject(); const consoleProxy = new Subject(); const frameTests = createTestFramer( document, state$, frameReady, consoleProxy ); const challengeResults = frameReady.pipe( // Delay for jQuery ready code, in jQuery challenges delay(250), pluck('checkChallengePayload'), map(checkChallengePayload => ({ checkChallengePayload, tests: challengeTestsSelector(state$.value) })), switchMap(({ checkChallengePayload, tests }) => { const postTests = of( updateConsole('// tests completed'), logsToConsole('// console output'), checkChallenge(checkChallengePayload) ).pipe(delay(250)); return runTestsInTestFrame(document, tests).pipe( switchMap(tests => { return from(tests).pipe( map(({ message }) => message), filter(overEvery(isString, Boolean)), map(updateConsole), concat(of(updateTests(tests))) ); }), concat(postTests) ); }) ); const buildAndFrameChallenge = action$.pipe( ofType(types.executeChallenge), filter(() => { const { challengeType } = challengeMetaSelector(state$.value); return ( challengeType !== challengeTypes.js && challengeType !== challengeTypes.bonfire ); }), debounceTime(executeDebounceTimeout), filter(() => isJSEnabledSelector(state$.value)), switchMap(() => { const state = state$.value; const { challengeType } = challengeMetaSelector(state); const build = challengeType === challengeTypes.backend ? buildBackendChallenge : buildFromFiles; return build(state).pipe( tap(frameTests), ignoreElements(), startWith(initLogs()), startWith(initConsole('// running tests')), catchError(err => { console.error(err); return of(disableJSOnError(err)); }) ); }) ); const proxyConsole = consoleProxy.pipe(map(updateLogs)); return merge(buildAndFrameChallenge, challengeResults, proxyConsole); })
query: function(query) { deferred = $q.defer(); querySubject.next(query); return deferred.promise; },
get onIdChange() { return this.idSubject.asObservable(); }
get messageFromStream() { return this.streamSubject.asObservable(); }
module.exports = function() { let kits = this.kitOptions.list; // let questions = []; let choices = []; Object.keys(kits).forEach(key => { choices.push({ name: `${key} - ${kits[key].description}`, value: key }); }); let answers = {}; let prompts = new Rx.Subject(); inquirer.prompt(prompts).ui.process.subscribe( obj => { switch (obj.name) { case 'kit': { prompts.next({ type: 'list', name: 'ver', message: 'Which version do you need: ', choices: kits[obj.answer].versions }); answers.kit = obj.answer; answers.kitOriginalName = kits[obj.answer].originalName || obj.answer; break; } case 'ver': { prompts.next({ type: 'text', name: 'folder', default: './', message: 'Which folder is your project in: ' }); answers.ver = obj.answer; break; } case 'folder': { answers.folder = obj.answer.trim(); prompts.next({ type: 'text', name: 'projectName', message: 'type your project name:', default: path.basename(answers.folder) }); prompts.complete(); break; } case 'projectName': answers.projectName = obj.answer.trim(); break; } }, () => {}, () => { exports.installProject.bind(this)(answers); } ); prompts.next({ type: 'list', name: 'kit', message: 'Which starterkit do you wanna install: ', choices: choices, pageSize: 100 }); };
/** * @return {?} */ ngOnDestroy() { this._destroyed.next(); this._destroyed.complete(); }
/** * Can be used in conjunction with `verifyNoPendingRequests` to resolve any not-yet-resolve * connections, if it's expected that there are connections that have not yet received a response. * * This method only exists in the mock implementation, not in real Backends. * @return {?} */ resolveAllConnections() { this.connections.subscribe((c) => c.readyState = 4); }
it('listens to bookmark changes to update state', () => { const addRepositoryAction: AddProjectRepositoryAction = { payload: { repository: fakeRepository, }, type: ActionType.ADD_PROJECT_REPOSITORY, }; const input = new Subject(); const resultActionStream = applyActionMiddleware(input, () => oneRepoState); const resultActions: Array<Action> = []; resultActionStream.subscribe(action => resultActions.push(action)); input.next(addRepositoryAction); input.complete(); const fakeHgRepository: HgRepositoryClient = (fakeRepository: any); waitsFor(() => resultActions.length === 1); runs(() => { expect(fakeHgRepository.getBookmarks).toHaveBeenCalled(); expect(fakeHgRepository.onDidChangeBookmarks).toHaveBeenCalled(); expect(fakeHgRepository.onDidChangeShortHead).toHaveBeenCalled(); expect(shortHeadChangeCallback).toBeDefined(); expect(bookmarksChangeCallback).toBeDefined(); expect(destroyCallback).toBeDefined(); const firstAction = resultActions[0]; expect(firstAction.type).toBe(ActionType.UPDATE_REPOSITORY_BOOKMARKS); invariant(firstAction.type === ActionType.UPDATE_REPOSITORY_BOOKMARKS); expect(firstAction.payload.activeShortHead).toBe(SHOTHEAD_1_2); expect(Array.from(firstAction.payload.bookmarkNames)) .toEqual([SHOTHEAD_1_1, SHOTHEAD_1_2, EMPTY_SHORTHEAD]); // Trigger a bookmark update or an active shorthead change. invariant(bookmarksChangeCallback); bookmarksChangeCallback(); }); waitsFor(() => resultActions.length === 2); runs(() => { // The listeners aren't called again, but another fetch of bookmark is done. expect(((fakeHgRepository.onDidChangeBookmarks: any): JasmineSpy).callCount).toBe(1); expect(((fakeHgRepository.onDidChangeShortHead: any): JasmineSpy).callCount).toBe(1); expect(((fakeHgRepository.getBookmarks: any): JasmineSpy).callCount).toBe(2); const secondAction = resultActions[1]; expect(secondAction.type).toBe(ActionType.UPDATE_REPOSITORY_BOOKMARKS); // A repository destroy event would complete the watch. expect(disposeBookmarksChangeSpy).not.toHaveBeenCalled(); expect(disposeShortHeadChangeSpy).not.toHaveBeenCalled(); expect(disposeDestroySpy).not.toHaveBeenCalled(); invariant(destroyCallback); destroyCallback(); }); // Cleanup subscriptions after destroy. waitsForPromise(() => resultActionStream.toPromise()); runs(() => { expect(disposeBookmarksChangeSpy).toHaveBeenCalled(); expect(disposeShortHeadChangeSpy).toHaveBeenCalled(); expect(disposeDestroySpy).toHaveBeenCalled(); }); });
constructor() { this.connectionsArray = []; this.connections = new Subject(); this.connections.subscribe((connection) => this.connectionsArray.push(connection)); this.pendingConnections = new Subject(); }
.subscribe(() => this._scrolled.next(scrollable));
/** * Returns observable that emits when a scroll event is fired on the host element. * @return {?} */ elementScrolled() { return this._elementScrolled.asObservable(); }
next(ieq) { this.querySubject.next(ieq); }
this.subjects.forEach((key) => { const subject = new Subject(); handlers[key] = (data) => subject.next(data); subjects[key] = subject; this.addSubscription(subject); });
subscribe(observerOrNext, error, complete) { let subscription = this.resultsSubject.subscribe(observerOrNext); let resultsSubscription = new ResultsSubscription(subscription, this.resultsUnsubscribeCallback); return resultsSubscription; }
handlers[key] = (data) => subject.next(data);
set id(value) { this._id = value; this.idSubject.next(value); }
const removePackageRepository = gql` mutation { removePackageRepository(name: $name, uri: $uri) { name } } `; const removePackageRepositoryGraphql = (name, uri) => dataLayer.query(removePackageRepository, { name, uri }); const deleteEvent$ = new Subject(); const deleteRepository$ = deleteEvent$.pipe( switchMap(repository => { return removePackageRepositoryGraphql(repository.name, repository.url).pipe( startWith({ pendingRequest: true }), map(result => { return { result, pendingRequest: false }; }), tap(() => { repository.complete(); }) ); }),
"use strict"; var Rx = require("rxjs"); var subject = new Rx.Subject(); subject.subscribe({ next: v => { console.log("observerA: %j", v); }, error: err => { console.error("errorA: %j", err); }, complete: () => { console.log("doneA"); } }); subject.subscribe({ next: v => { console.log("observerB: %j", v); }, error: err => { console.error("errorB: %j", err); }, complete: () => { console.log("doneB"); } }); subject.next({a: 10}); subject.next(2);
onDelete={() => deleteEvent$.next({ complete: props.onClose, ...props.repository })
return function() { var deferred; let searchConfig = { projects: { displayName: 'Projects', displayFormatter: function(entry) { let applications = entry.config && entry.config.applications ? ' (' + entry.config.applications.join(', ') + ')' : ''; let project = entry.name || entry.project; return $q.when(project + applications); }, order: 0, }, applications: { displayName: 'Applications', displayFormatter: simpleField('application'), order: 1, }, clusters: { displayName: 'Clusters', displayFormatter: simpleField('cluster'), order: 2, hideIfEmpty: true, }, serverGroups: { displayName: 'Server Groups', displayFormatter: function(entry) { return $q.when(entry.serverGroup + ' (' + entry.region + ')'); }, order: 3, hideIfEmpty: true, }, instances: { displayName: 'Instances', displayFormatter: function(entry) { let serverGroup = entry.serverGroup || 'standalone instance'; return $q.when(entry.instanceId + ' (' + serverGroup + ' - ' + entry.region + ')'); }, order: 4, hideIfEmpty: true, }, loadBalancers: { displayName: 'Load Balancers', displayFormatter: function(entry, fromRoute) { let name = fromRoute ? entry.name : entry.loadBalancer; return $q.when(name + ' (' + entry.region + ')'); }, order: 5, hideIfEmpty: true, }, securityGroups: { displayName: 'Security Groups', displayFormatter: function(entry) { return $q.when(entry.name + ' (' + entry.region + ')'); }, order: 6, hideIfEmpty: true, } }; function simpleField(field) { return function(entry) { return $q.when(entry[field]); }; } var querySubject = new Subject(); let initializeCategories = () => { let categories = {}; Object.keys(searchConfig).forEach((searchType) => { categories[searchType] = []; }); return categories; }; let formatResult = (category, entry, fromRoute) => { var config = searchConfig[category], formatter = config.displayFormatter; if (serviceDelegate.hasDelegate(entry.provider, 'search.resultFormatter')) { let providerFormatter = serviceDelegate.getDelegate(entry.provider, 'search.resultFormatter'); if (providerFormatter[category]) { formatter = providerFormatter[category]; } } return formatter(entry, fromRoute); }; querySubject .switchMap(function(query) { if (!query || !angular.isDefined(query) || query.length < 1) { return Observable.of(searchService.getFallbackResults()); } return Observable.fromPromise(searchService.search({ q: query, type: Object.keys(searchConfig), })); }) .subscribe(function(result) { var tmp = result.results.reduce(function(categories, entry) { formatResult(entry.type, entry).then((name) => entry.displayName = name); entry.href = urlBuilderService.buildFromMetadata(entry); categories[entry.type].push(entry); return categories; }, initializeCategories()); deferred.resolve(Object.keys(tmp).map(function(cat) { let config = searchConfig[cat]; return { category: config.displayName, order: config.order, hideIfEmpty: config.hideIfEmpty, results: tmp[cat], }; })); }); return { query: function(query) { deferred = $q.defer(); querySubject.next(query); return deferred.promise; }, formatRouteResult: function(type, params) { return formatResult(type, params, true); }, }; };
get channels() { return this.channelsSubject.asObservable(); }
componentWillMount() { this.mounted$.next(true); }
newWebSocket(ws, id, type) { this.channelsSubject.next({ id, channel: new Channel(this.wc, ws, type, id) }); }
componentWillUnmount() { this.mounted$.next(false); this.subscription.unsubscribe(); }
this.updateDimensionOptions = () => { dimensionSubject.next(); };
() => { data$.next(dataToReturn); data$.complete(); }
return fromEvent(window.document, 'scroll').subscribe(() => this._scrolled.next());