/**
* Checks all connections, and raises an exception if any connection has not received a response.
*
* This method only exists in the mock implementation, not in real Backends.
* @return {?}
*/
verifyNoPendingRequests() {
/** @type {?} */
let pending = 0;
this.pendingConnections.subscribe((c) => pending++);
if (pending > 0)
throw new Error(`${pending} pending connections to be resolved`);
}
constructor() {
this._states = new Subject();
this._states.subscribe(state => { this.state = state; });
// Create an observable that contains the current, and all future, states. Since the initial
// state is set directly (assigned to `this.state`), we can't just use a ReplaySubject
// TODO: Use a computed property key when that's supported.
(this: any)[$$observable] = () => Observable.of(this.state).concat(this._states);
}
setTimeout(() => {
//closeClick$.withLastestFrom(response$
subject.subscribe(
(value) => console.log(`subscribeXX ${value}`),
(err) => console.log(`subscribeXX error ${err}`),
() => console.log(`completeXX`)
);
}, 5000);
// Subject<MockConnection>
constructor() {
this.connectionsArray = [];
this.connections = new Subject();
this.connections.subscribe((/**
* @param {?} connection
* @return {?}
*/
(connection) => this.connectionsArray.push(connection)));
this.pendingConnections = new Subject();
}
constructor() {
this._buffers = new Map();
this._fileEvents = new Subject();
this._directoryEvents = new BehaviorSubject(new Set());
this._requests = new FileVersionNotifier();
this._resources = new UniversalDisposable();
this._resources.add(this._requests);
this._resources.add(this._fileEvents.subscribe(event => { this._requests.onEvent(event); }));
}
constructor(rawState: ?Object) {
const action$ = new Rx.Subject();
const initialState = deserializeAppState(rawState);
this._state$ = new Rx.BehaviorSubject(initialState);
createStateStream(
action$.asObservable(),
initialState,
)
.sampleTime(100)
.subscribe(this._state$);
this._commands = new Commands(
action$,
() => this._state$.getValue(),
);
this._outputService = new OutputService(this._commands);
this._disposables = new CompositeDisposable(
atom.contextMenu.add({
'.nuclide-console-record': [
{
label: 'Copy Message',
command: 'nuclide-console:copy-message',
},
],
}),
atom.commands.add(
'.nuclide-console-record',
'nuclide-console:copy-message',
event => {
const el = event.target;
if (el == null || el.innerText == null) {
return;
}
atom.clipboard.write(el.innerText);
},
),
featureConfig.observe(
'nuclide-console.maximumMessageCount',
maxMessageCount => this._commands.setMaxMessageCount(maxMessageCount),
),
// Action side-effects
new DisposableSubscription(
action$.subscribe(action => {
if (action.type !== ActionTypes.EXECUTE) {
return;
}
const {executorId, code} = action.payload;
const executors = this._state$.getValue().executors;
const executor = executors.get(executorId);
invariant(executor);
executor.execute(code);
})
),
);
}
constructor(initialState: ?SwiftPMTaskRunnerStoreState) {
this.id = 'swiftpm';
this.name = 'Swift';
this._initialState = initialState;
this._projectRoot = new Subject();
this._disposables = new UniversalDisposable(
this._projectRoot.subscribe(path =>
this._getFlux().actions.updateProjectRoot(path),
),
);
}
constructor(sendMessageToClient: (message: Object) => void) {
this._connections = new Set();
this._sendMessageToClient = message => sendMessageToClient(message);
this._freshConnectionId = 0;
this._newConnections = new Subject();
this._breakpointManager = new BreakpointManager(this._sendMessageToClient.bind(this));
this._disposables = new UniversalDisposable(
this._newConnections.subscribe(this._handleNewConnection.bind(this)),
this._breakpointManager,
);
}
constructor(execInfoContainer: FlowExecInfoContainer) {
this._execInfoContainer = execInfoContainer;
this._disposed = false;
this._flowRootMap = new Map();
// No need to dispose of this subscription since we want to keep it for the entire life of this
// object. When this object is garbage collected the subject should be too.
this._flowRoot$ = new Subject();
this._flowRoot$.subscribe(flowRoot => {
this._flowRootMap.set(flowRoot.getPathToRoot(), flowRoot);
});
}
return this._platform.isBrowser ? Observable.create(observer => {
if (!this._globalSubscription) {
this._addGlobalListener();
}
// In the case of a 0ms delay, use an observable without auditTime
// since it does add a perceptible delay in processing overhead.
const /** @type {?} */ subscription = auditTimeInMs > 0 ?
this._scrolled.pipe(auditTime(auditTimeInMs)).subscribe(observer) :
this._scrolled.subscribe(observer);
this._scrolledCount++;
return () => {
subscription.unsubscribe();
this._scrolledCount--;
if (!this._scrolledCount) {
this._removeGlobalListener();
}
};
}) : of();
function onPropUpdated(synapse, dotted_path, callback, dispose) {
var js_path = dotted_path;
if (js_path[0] != '.') {
js_path = '.'+js_path;
}
var watch_path = dotted_path.split('.').filter(function(part) {
return (part && true);
});
// Subscription
var subscription = subject.subscribe(function(updated_path) {
var match = true;
for (var i=0, ii=watch_path.length, iii = updated_path.length; i<ii; i++) {
if (watch_path[i] != undefined && updated_path[i] != undefined && watch_path[i] != updated_path[i]) {
match = false;
break;
}
else if (i == iii-1) {
break;
}
}
if (match) {
var res = JSPath.apply(js_path, synapse);
if (res.length == 1) { res = res[0]; }
else if (res.length == 0) { res = undefined; }
if (res) {
callback(res);
if (dispose) {
subscription.dispose();
}
}
}
});
return subscription;
}
constructor(state: ?Object) {
this._toggleEvents = new Subject();
this._shouldRenderDiagnostics = this._toggleEvents.scan(prev => !prev, false);
this._disposables = new CompositeDisposable();
this._activeEditorRegistry = new ActiveEditorRegistry(
resultFunction,
{updateOnEdit: false},
);
this._disposables.add(
atom.commands.add(
'atom-workspace',
'nuclide-type-coverage:toggle-inline-display',
() => this._toggleEvents.next(),
),
);
this._disposables.add(new DisposableSubscription(
this._toggleEvents.subscribe(() => track('nuclide-type-coverage:toggle')),
),
);
}
const saveEvents = Observable.create(observer => {
const realSave = editor.save;
const newSaves = new Subject();
// HACK: intercept the real TextEditor.save and handle it ourselves.
// Atom has no way of injecting content into the buffer asynchronously
// before a save operation.
// If we try to format after the save, and then save again,
// it's a poor user experience (and also races the text buffer's reload).
const editor_ = (editor: any);
editor_.save = () => {
newSaves.next('new-save');
return this._safeFormatCodeOnSave(editor)
.takeUntil(newSaves)
.toPromise()
.then(() => realSave.call(editor));
};
const subscription = newSaves.subscribe(observer);
return () => {
// Restore the save function when we're done.
editor_.save = realSave;
subscription.unsubscribe();
};
});
constructor() {
this.connectionsArray = [];
this.connections = new Subject();
this.connections.subscribe((connection) => this.connectionsArray.push(connection));
this.pendingConnections = new Subject();
}
"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);
clearInterval(inter);
obs.complete();
}
}, time);
});
;
const stream1 = createStream(2, 1000).map(v => `stream1: ${v}`);
const stream2 = createStream(4, 500).map(v => `stream1: ${v}`);
const stream3 = stream1.merge(stream2);
const subject = new Rx.Subject();
stream3.subscribe(subject);
subject.subscribe(
(value) => console.log(`subscribe ${value}`),
(err) => console.log(`subscribe error ${err}`),
() => console.log(`complete`)
);
setTimeout(() => {
//closeClick$.withLastestFrom(response$
subject.subscribe(
(value) => console.log(`subscribeXX ${value}`),
(err) => console.log(`subscribeXX error ${err}`),
() => console.log(`completeXX`)
);
}, 5000);
return new rxjs_1.Observable(subject => {
// Handle input.
inboundBus.subscribe(message => {
switch (message.kind) {
case api_1.JobInboundMessageKind.Ping:
subject.next({ kind: api_1.JobOutboundMessageKind.Pong, description, id: message.id });
break;
case api_1.JobInboundMessageKind.Stop:
// There's no way to cancel a promise or a synchronous function, but we do cancel
// observables where possible.
if (subscription) {
subscription.unsubscribe();
}
subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
subject.complete();
// Close all channels.
channels.forEach(x => x.complete());
break;
case api_1.JobInboundMessageKind.Input:
inputChannel.next(message.value);
break;
}
});
// Configure a logger to pass in as additional context.
const logger = new index_2.Logger('job');
logger.subscribe(entry => {
subject.next({
kind: api_1.JobOutboundMessageKind.Log,
description,
entry,
});
});
// Execute the function with the additional context.
subject.next({ kind: api_1.JobOutboundMessageKind.Start, description });
const channels = new Map();
const newContext = Object.assign({}, context, { input: inputChannel.asObservable(), logger,
createChannel(name) {
if (channels.has(name)) {
throw new ChannelAlreadyExistException(name);
}
const channelSubject = new rxjs_1.Subject();
channelSubject.subscribe(message => {
subject.next({
kind: api_1.JobOutboundMessageKind.ChannelMessage, description, name, message,
});
}, error => {
subject.next({ kind: api_1.JobOutboundMessageKind.ChannelError, description, name, error });
// This can be reopened.
channels.delete(name);
}, () => {
subject.next({ kind: api_1.JobOutboundMessageKind.ChannelComplete, description, name });
// This can be reopened.
channels.delete(name);
});
channels.set(name, channelSubject);
return channelSubject;
} });
const result = fn(argument, newContext);
// If the result is a promise, simply wait for it to complete before reporting the result.
if (index_3.isPromise(result)) {
result.then(result => {
subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value: result });
subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
subject.complete();
}, err => subject.error(err));
}
else if (rxjs_1.isObservable(result)) {
subscription = result.subscribe((value) => subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value }), error => subject.error(error), () => {
subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
subject.complete();
});
return subscription;
}
else {
// If it's a scalar value, report it synchronously.
subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value: result });
subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
subject.complete();
}
});
subscribe: listener => consoleListener.subscribe({next: listener})
observable = new LoggerObservable(observer => {
return events.subscribe(observer);
});
__Synapse.updated = function(callback) {
return subject.subscribe(callback);
}
subscribe(action) {
const subscription = this.rxSubject.subscribe(action);
this.rxSubject.next(this.version);
return subscription;
}
/**
* @param {?} fn
* @return {?}
*/
onHashChange(fn) { this.hashUpdate.subscribe(fn); }
/**
* 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); }
/**
* 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((/**
* @param {?} c
* @return {?}
*/
(c) => c.readyState = 4)); }
subscribe(observerOrNext, error, complete) {
let subscription = this.resultsSubject.subscribe(observerOrNext);
let resultsSubscription = new ResultsSubscription(subscription, this.resultsUnsubscribeCallback);
return resultsSubscription;
}
const vm = require('vm');
const Rx = require('rxjs');
const scenarioApiManager = require('./scenario-api.manager');
const inputStream = new Rx.Subject();
const outputStream = new Rx.Subject();
//0 comand arg is node, 1 is path to file
const ARGV_SCRIPT_INDEX = 2;
outputStream.subscribe((data) => {
process.send({
type: 'message',
content: data
});
});
const SMART_HOUSE = scenarioApiManager.create(inputStream, outputStream);
const sandbox = {
setTimeout,
console,
SMART_HOUSE
};
vm.runInNewContext(process.argv[ARGV_SCRIPT_INDEX], sandbox);