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());