.flatMap(nextChallenge => {
if (!nextChallenge) {
return firstChallengeOfNextBlock$;
}
return Observable.just(nextChallenge);
});
.flatMap(function (response) { return Rx.Observable.fromPromise(response.json()); })
return fetch(url).flatMap(function (json) { return Rx.Observable.from(json.data); });
this._closed = process$.flatMap(process => Rx.Observable.fromEvent(process, 'close'))
.flatMapLatest(component => component.router || Rx.Observable.empty())
'use strict';
import Rx from 'rx';
export default {
getDispatchers(store){
return Rx.Observable.merge(
)
}
}
.catch((ex) => Rx.Observable.return(({
id: key,
name: key,
group: null,
error: { message: ex.message }
})))
releaseScanner.factory('ReleaseScannerService', (SettingsModel) => {
const RELEASE_SCANNER_INTERVAL_MS = 10000;
const emitter = new EventEmitter();
const availableReleases = Rx.Observable.timer(0, RELEASE_SCANNER_INTERVAL_MS)
.flatMap(() => {
return Rx.Observable.fromPromise(Versions.getVersions().then((data) => {
var versions = [];
if(data)
{
versions = JSON.parse(data);
}
return versions;
}));
})
.map((releases) => {
if (SettingsModel.get('unsafeMode')) {
return releases;
}
return _.reject(releases, (release) => {
return release.system;
});
})
.pausable(new Rx.Subject());
/*
* This service emits the following events:
*
* - `drives (Object[])`
* - `error (Error)`
*
* For example:
*
* ```
* DriveScannerService.on('drives', (drives) => {
* console.log(drives);
* });
*
* DriveScannerService.on('error', (error) => {
* throw error;
* });
* ```
*/
availableReleases.subscribe((releases) => {
emitter.emit('releases', releases);
}, (error) => {
emitter.emit('error', error);
});
/**
* @summary Start scanning drives
* @function
* @public
*
* @example
* DriveScannerService.start();
*/
emitter.start = () => {
availableReleases.resume();
};
/**
* @summary Stop scanning drives
* @function
* @public
*
* @example
* DriveScannerService.stop();
*/
emitter.stop = () => {
availableReleases.pause();
};
return emitter;
});
function($q, $scope, inject$, observe$, editsService, editsApi, imageList) {
var ctrl = this;
const multiCat = { name: 'Multiple categories', value: 'multi-cat', properties: [] };
// @return Stream.<Array.<UsageRights>>
const usageRights$ = observe$($scope, () => ctrl.usageRights);
// @return Stream.<Array.<Category>>
const categories$ = Rx.Observable.fromPromise(editsApi.getUsageRightsCategories());
// @return Stream.<Array.<Category>>
const displayCategories$ = usageRights$.combineLatest(categories$, (urs, cats) => {
const uniqueCats = getUniqueCats(urs);
if (uniqueCats.length === 1) {
return cats;
} else {
return [multiCat].concat(cats);
}
});
// @return Stream.<Category>
// FIXME: This is not longer the canonical category as we aren't taking the user interaction
// into account so this goes stale.
const category$ = usageRights$.combineLatest(categories$, (urs, cats) => {
const uniqueCats = getUniqueCats(urs);
if (uniqueCats.length === 1) {
const uniqeCat = uniqueCats[0] || '';
return cats.find(cat => cat.value === uniqeCat);
} else {
return multiCat;
}
});
// @return Stream.<Category>
// The filter is used here to stop the initial setting of `undefined` being published.
const categoryFromUserChange$ = observe$($scope, () => ctrl.category).filter(cat => !!cat);
// @return Stream.<Category>
const categoryWithUserChange$ =
category$.merge(categoryFromUserChange$).distinctUntilChanged();
const model$ = usageRights$.map(urs => {
const usageRightsData = (urs.map(ur => ur.data));
// Get a Map(property, Set(values));
const objs = imageList.getSetOfProperties(new List(usageRightsData));
// Return an object with the value, iif there is 1 value
return objs.filter(obj => obj.size === 1).map(obj => obj.first()).toJS();
});
// Stream.<Boolean>
const savingDisabled$ = categoryWithUserChange$.map(cat => cat === multiCat);
// Stream.<Boolean>
const forceRestrictions$ = model$.combineLatest(categoryWithUserChange$, (model, cat) => {
const defaultRestrictions =
cat.properties.find(prop => prop.name === 'defaultRestrictions');
const restrictedProp =
cat.properties.find(prop => prop.name === 'restrictions');
return defaultRestrictions || (restrictedProp && restrictedProp.required);
});
// Stream.<Boolean>
const modelHasRestrictions$ = model$.map(model => angular.isDefined(model.restrictions));
// Stream.<Boolean>
const showRestrictions$ = forceRestrictions$.combineLatest(modelHasRestrictions$,
(forceRestrictions, showRestrictions) => {
if (forceRestrictions) {
return true;
} else {
return showRestrictions;
}
});
inject$($scope, displayCategories$, ctrl, 'categories');
inject$($scope, category$, ctrl, 'category');
inject$($scope, model$, ctrl, 'model');
inject$($scope, savingDisabled$, ctrl, 'savingDisabled');
inject$($scope, forceRestrictions$, ctrl, 'forceRestrictions');
inject$($scope, showRestrictions$, ctrl, 'showRestrictions');
// TODO: Some of these could be streams
ctrl.saving = false;
ctrl.getOptionsFor = property => {
const options = property.options.map(option => ({ key: option, value: option }));
if (property.required) {
return options;
} else {
return [{key: 'None', value: null}].concat(options);
}
};
ctrl.getOptionsMapFor = property => {
const key = ctrl.category
.properties
.find(prop => prop.name === property.optionsMapKey)
.name;
const val = ctrl.model[key];
return property.optionsMap[val] || [];
};
ctrl.save = () => {
ctrl.saving = true;
// we save as `{}` if category isn't defined.
const data = ctrl.category.value ?
angular.extend({}, ctrl.model, { category: ctrl.category.value }) : {};
// unchecking restrictions will remove restriction on save
if (! ctrl.showRestrictions && data.restrictions) {
delete data.restrictions;
}
save(data).
catch(uiError).
finally(saveComplete);
};
ctrl.reset = () => {
ctrl.model = {};
ctrl.showRestrictions = undefined;
};
ctrl.cancel = () => ctrl.onCancel();
function save(data) {
return $q.all(ctrl.usageRights.map(usageRights => {
const image = usageRights.image;
const resource = image.data.userMetadata.data.usageRights;
return editsService.update(resource, data, image).
then(resource => resource.data).
then(() => setMetadataFromUsageRights(image));
}));
}
function saveComplete() {
ctrl.onSave();
ctrl.saving = false;
}
function getUniqueCats(usageRights) {
return unique(usageRights.map(ur => ur.data.category));
}
function unique(arr) {
return arr.reduce((prev, curr) =>
prev.indexOf(curr) !== -1 ? prev : prev.concat(curr), []);
}
function uiError(error) {
// ♫ Very superstitious ♫
ctrl.error = error && error.body && error.body.errorMessage ||
'Unexpected error';
}
// HACK: This should probably live somewhere else, but it's the least intrusive
// here. This updates the metadata based on the usage rights to stop users having
// to enter content twice.
function setMetadataFromUsageRights(image) {
return editsService.updateMetadataFromUsageRights(image);
}
}]);
function ModelEditor({ DOM, HTTP }) {
const modelBatch$ = HTTP
.filter(response$ => response$.request.category == 'fetch-all')
.mergeAll()
.map(response => JSON.parse(response.text));
function swallowErrors(stream$) {
return Observable.create(observer => {
const subscription = stream$.subscribe(
(obj) => observer.onNext(obj),
(err) => observer.onCompleted(),
() => observer.onCompleted()
);
return function onDispose() {
subscription.dispose();
};
});
}
const singleModel$ = HTTP
.filter(response$ => response$.request.category == 'fetch')
.map(response$ => swallowErrors(response$))
.mergeAll()
.map((response) => JSON.parse(response.text));
const model$ = Observable.merge(
modelBatch$.flatMap(models => Observable.fromArray(models)),
singleModel$
).share();
const serverModels$ = model$
.distinctUntilChanged() // This prevents no-op server update from wiping local state
.scan(
(cache, updatedModel) => {
const index = cache.findIndex(obj => obj.id == updatedModel.id);
if (index == -1) {
return cache.concat([updatedModel]);
} else {
return cache.slice(0, index).concat([updatedModel]).concat(cache.slice(index + 1));
}
},
[]
).startWith([])
.distinctUntilChanged();
const serverLog = serverModels$.subscribe(logger('Server'));
const modelUpdate$ = DOM
.select('input')
.events('input')
.map((ev) => {
return {
modelId: parseInt(ev.target.getAttribute('modelId')),
modelField: ev.target.getAttribute('modelField'),
value: ev.target.value,
};
});
// Something to allow user to revert to server state, even when server hasn't changed
const modelRevert$ = undefined;
const localModels$ = Observable.merge(
model$.map((model) => { return { kind: "server", model }; }),
modelUpdate$.map((delta) => { return { kind: "update", delta }; })
).scan((cache, update) => {
const cacheCopy = Array.from(cache);
let updatedModel;
if (update.kind == "server") {
// Blow away any local state when server comes back
updatedModel = update.model;
} else if (update.kind == "update") {
const delta = update.delta;
const localCopy = cacheCopy.find(obj => obj.id == delta.modelId);
updatedModel = shallowCopy(localCopy);
updatedModel[delta.modelField] = delta.value;
}
const index = cache.findIndex((model) => model.id == updatedModel.id);
if (index == -1) {
cacheCopy.push(updatedModel);
} else {
cacheCopy[index] = updatedModel;
}
return cacheCopy;
}, []);
const localLogger = localModels$.subscribe(logger('Local models'));
const idToSave$ = DOM
.select('button.save')
.events('click')
.map((ev) => ev.target.getAttribute('modelId'));
const putRequest$ = idToSave$
.withLatestFrom(
localModels$,
(id, models) => {
const modelToSave = models.find(obj => obj.id == id);
return {
url: putUrl(id),
category: 'fetch',
method: 'PUT',
send: modelToSave,
type: 'form',
};
});
const idToFetch$ = DOM
.select('.fetch-single')
.events('click')
.map(() => 1);
const fetchOneRequest$ = idToFetch$
.map(id => {
return {
url: getUrl(id),
category: 'fetch',
method: 'GET',
};
});
const fetchBatchRequest$ = DOM
.select('.fetch-all')
.events('click')
.startWith(null) // Load data on page load
.map(() => {
return {
url: baseUrl + '/models',
category: 'fetch-all',
method: 'GET',
};
});
const request$ = Observable.merge(
fetchOneRequest$,
fetchBatchRequest$,
putRequest$
);
return {
DOM: view(serverModels$),
HTTP: request$,
};
}
modelBatch$.flatMap(models => Observable.fromArray(models)),
// `npm install rx randomstring es6-promise`
var Rx = require('rx');
var randomstring = require('randomstring');
var transforms = require('./transforms');
var EventEmitter = require('events').EventEmitter;
require('es6-promise').polyfill();
const emitter = new EventEmitter();
var messageStream = Rx.Observable.fromEvent(emitter, 'message');
var subscribe = stream => {
stream
.map(transforms.toJson) // -- 1. Transform the data in to a nice format
.map(data => {
if (Math.random() < 0.1) throw new Error('something pretty bad happened. shut down, exploded');
return data;
})
.flatMap(data => { // -- 2. Example async operation
return Promise
.all([
new Promise((resolve, reject) => { // a response from CAPI
resolve(1);
}),
new Promise((resolve, reject) => { // a response from Session API
setTimeout(() => {
resolve(2);
}, Math.random() * 1000);
function main(sources) {
// Convert the url history into an action stream
const history$ = sources.history
.map(location => {
return {
type: 'URL',
payload: location
}
})
// Convert the responses into an action stream
const response$ = sources.HTTP
.mergeAll()
.map(response => {
return {
type: response.statusCode == 200 ? 'SUCCESS' : 'FAILURE',
payload: response
}
})
// Convert the events into an action stream
const event$ = Observable
.fromArray(events)
.map( config => {
// Extract variables from the config object
const { selector, event, action, key = null, payload = {} } = config
// Find the element in the DOM and bind the action to the event
return sources.DOM
.select(selector)
.events(event)
.map(event => {
console.log( mapStateToObject(payload, {event}))
return {
type: action,
key,
payload: mapStateToObject(payload, {event})
}
}
)
})
.mergeAll()
// Merge all separate actions streams into one
const action$ = event$.merge(response$).merge(history$)
// Perform a request only for actions of type FETCH
const request$ = action$
.filter(action => action.type == 'FETCH')
.map(action => {
const resource = find(resources, action.payload.resource, 'name')
return Object.assign(resource.driver.options, action.payload)
})
// Create virtual DOM tree.
const vtree$ = sources.state
.map( state => build(find(state.collection.nodes, 1), state))
// Return virtual DOM and action stream
return {
DOM: vtree$,
HTTP: request$,
state: action$
}
}
.flatMap(challenges => Observable.from( challenges, null, null, Scheduler.default ))
var subject = createSubject(null, true);
var observer = Rx.Observer.create(function (x) {
subject.onNext(x, true);
});
var observable = Rx.Observable.create(function (obs) {
subject.subscribe(function (data, cb) {
process.nextTick(function () {
obs.onNext(data);
});
cb();
});
});
return Rx.Subject.create(observer, observable);
}
}());
var s = new MySubject();
s.subscribe(function (data) {
console.log('Got data: ' + data);
});
Rx.Observable.timer(0, 500)
.take(10)
.subscribe(function (x) {
s.onNext(x);
});
return rx.Observable.defer(function () {
return rx.Observable.fromPromise(prompt.run().then(function (answer) {
return {name: question.name, answer: answer};
}));
});
function (err, files) {
if (err != null) {
fail('Just another error', err);
}
var eventCount = 0;
var resultsArray = [];
var persistCount = 0;
rx.Observable
.fromArray(files)
.flatMap(function (locSpec) {
var antacid = ingestion[locSpec.source];
if (antacid == null) {
throw except.ISE('Unknown data source[%s]', locSpec.source);
}
return antacid.parse(storage.get(locSpec.location));
})
.map(function (e) {
e.groupId = config.groupId;
var hasher = crypto.createHash('sha1');
if (e._id == null) {
if (e.id == null) {
hasher.update(e.type);
hasher.update(String(e.value));
hasher.update(e.deviceTime);
e.id = base32hex.encodeBuffer(hasher.digest(), { paddingChar: '-' });
hasher = crypto.createHash('sha1');
}
hasher.update(e.id);
hasher.update(e.groupId);
e._id = base32hex.encodeBuffer(hasher.digest(), { paddingChar: '-' });
}
return e;
})
.subscribe(
function (e) {
++eventCount;
resultsArray.push(e);
if (resultsArray.length >= 1000) {
dataBroker.storeData(resultsArray, function (err) {
if (err != null) {
if (err.code === 11000) {
log.info('Got a duplicate id, but continuing anyway.', err.err);
} else {
fail('Problem with DB', err);
}
}
});
resultsArray = [];
}
},
function (err) {
fail('Problem parsing data', err);
},
function () {
dataBroker.storeData(resultsArray, function (err) {
if (err != null) {
if (err.code === 11000) {
log.info('Got a duplicate id, but continuing anyway.', err.err);
} else {
fail('Problem with DB, Oh Noes!', err);
}
}
log.info('Persisted[%s] events to db.', eventCount);
mongoClient.close(function(err, results){
process.exit(0);
});
});
});
}
return rx.Observable.defer(function () {
return rx.Observable.return(question);
});
import test from 'tape';
import { Observable } from 'rx';
import { run } from '@cycle/core';
import { button, makeDOMDriver } from '@cycle/dom';
import { preventDefault, stopPropagation } from '../src/index.js';
const container = document.createElement('div');
container.classList.add('cycle-test');
document.body.appendChild(container);
const domDriver = makeDOMDriver('.cycle-test');
const DOM$ = Observable.just(button());
const button$Factory = DOM => DOM.select('button').observable.skip(1).take(1).flatMap(x => x);
const buttonClick$Factory = DOM => DOM.select('button').events('click');
test.onFinish(window.close);
test('preventDefault', t => {
const main = ({ DOM }) => ({
preventDefault: buttonClick$Factory(DOM),
DOM: DOM$
});
const { sources, sinks } = run(main, {
DOM: domDriver,
preventDefault
});
button$Factory(sources.DOM).subscribe(buttonEl => {
buttonEl.click();
});
sinks.preventDefault.delay(100).take(1).subscribe(ev => {
t.equal(ev.defaultPrevented, true, 'should have prevented');
sources.dispose();
t.end();
driveScanner.factory('DriveScannerService', () => {
const DRIVE_SCANNER_INTERVAL_MS = 2000;
const emitter = new EventEmitter();
const availableDrives = Rx.Observable.timer(0, DRIVE_SCANNER_INTERVAL_MS)
.flatMap(() => {
return Rx.Observable.fromNodeCallback(drivelist.list)();
})
.map((drives) => {
return _.reject(drives, (drive) => {
return drive.system;
});
})
.pausable(new Rx.Subject());
/*
* This service emits the following events:
*
* - `drives (Object[])`
* - `error (Error)`
*
* For example:
*
* ```
* DriveScannerService.on('drives', (drives) => {
* console.log(drives);
* });
*
* DriveScannerService.on('error', (error) => {
* throw error;
* });
* ```
*/
availableDrives.subscribe((drives) => {
emitter.emit('drives', drives);
}, (error) => {
emitter.emit('error', error);
});
/**
* @summary Start scanning drives
* @function
* @public
*
* @example
* DriveScannerService.start();
*/
emitter.start = () => {
availableDrives.resume();
};
/**
* @summary Stop scanning drives
* @function
* @public
*
* @example
* DriveScannerService.stop();
*/
emitter.stop = () => {
availableDrives.pause();
};
return emitter;
});
.flatMapLatest(process => Rx.Observable.fromEvent(process.stdout, 'data'))
.flatMap(() => {
return Rx.Observable.fromNodeCallback(drivelist.list)();
})
const output$ = process$.flatMap(process => Rx.Observable.fromEvent(process, 'message'));
var stripSourceMappingComment = mercator.stripSourceMappingComment;
var fs = require('fs');
var path = require('path');
var globLib = require('glob');
var Rx = require('rx');
// Wrap event-emitter version of glob as an Observable
var glob = function(pattern) {
var globEvents = new globLib.Glob(pattern);
var matches = Rx.Node.fromEvent(globEvents, 'match');
var end = Rx.Node.fromEvent(globEvents, 'end');
return matches.takeUntil(end);
};
var readFile = Rx.Observable.fromNodeCallback(fs.readFile);
function extractType(path) {
var ext = path.split('.').slice(-1)[0];
// FIXME: even if not matched, we should retain extension...
return {
js: 'javascript',
coffee: 'coffeescript',
css: 'css',
scss: 'scss',
less: 'less',
html: 'html',
json: 'json',
jpg: 'jpeg',
jpeg: 'jpeg',
function intent(DOMSource) {
// Make API call to get misspellings.
// Fake the result from the API call.
const response$ = Observable.of([
{
word: 'reallly',
suggestions: [
'really',
'real'
]
},
{
word: 'dooo',
suggestions: [
'do',
'poo'
]
}
]
);
const changeWordClick$ = DOMSource.select('.change-word').events('click')
.map((ev, index) => index);
const ignoreWordClick$ = DOMSource.select('.ignore-word').events('click')
.map(ev => ev.target);
const suggestionSelect$ = DOMSource.select('.suggestions').events('change')
.map(ev => ev.target);
const changeWordInput$ = DOMSource.select('.word').events('input')
.debounce(500)
.map(ev => ev.target);
const misspellingIndex$ = changeWordClick$
.startWith(0)
.merge(ignoreWordClick$)
.scan((prev, curr) => {
return prev + 1;
});
const resetSuggestionSelect$ = changeWordClick$
.merge(ignoreWordClick$)
.withLatestFrom(suggestionSelect$, (click, target) => {
return target;
});
const resetChangeWord$ = changeWordClick$
.merge(ignoreWordClick$)
.map(index => '');
const changeWord$ = suggestionSelect$
.merge(changeWordInput$)
.map(target => target.value)
.startWith('');
const misspellings$ = Observable.combineLatest(
response$,
misspellingIndex$,
(misspellings, index) => {
if (index === 0) {
return {
curr: misspellings[index],
prev: misspellings[index]
};
} else if (index < misspellings.length) {
return {
curr: misspellings[index],
prev: misspellings[index-1]
};
} else if (index === misspellings.length) {
return {
curr: {},
prev: misspellings[index-1]
}
} else {
return {
curr: '',
prev: ''
};
}
}
);
const word$ = changeWordClick$
.withLatestFrom(changeWord$, misspellings$, (index, changeWord, misspellings) => {
return {
oldWord: misspellings.prev.word,
newWord: changeWord
};
});
const sentence$ = Observable.of('This reallly sucks but so dooo you')
.merge(word$)
.scan((prev, curr) => {
if (curr.newWord.length > 0) {
return prev.replace(curr.oldWord, curr.newWord);
}
return prev;
});
const changeWordValue$ = changeWord$.merge(resetChangeWord$);
return {
sentence$,
misspellings$,
changeWordValue$,
resetSuggestionSelect$
};
}
.catch(err => Observable.just({
transform(state) {
return { ...state, err };
}
}));
.flatMap(function (json) {
return Rx.Observable.concat(Rx.Observable.just(json), (json.paging && json.paging.next) ? fetch(json.paging.next, options) : Rx.Observable.empty());
});
const main = () => ({
DOM: Rx.Observable.just(CycleDOM.h('span', 'Hi there!'))
});
function run (api){
console.log('starting!');
var validAddresses = ['/joint_Left_Hand_1', '/joint_Right_Hand_1', '/joint_Head_1'];
// Listen for incoming OSC bundles.
kinect.on("bundle", function (oscBundle) {
console.log("An OSC bundle just arrived!", oscBundle);
});
var hands$ = Rx.Observable.fromEvent(kinect, 'osc')
.filter(function (message) {
return validAddresses.indexOf(message.address) >= 0;
});
var head$ = Rx.Observable.fromEvent(kinect, 'osc')
.filter(function (message) {
return validAddresses.indexOf(message.address) >= 0;
})
.filter(function(message){
return message.address.indexOf(settings.osc.head) >= 0;
});
var leftHand$ = hands$
.filter(function (message) {
return message.address.indexOf(settings.osc.hand.left) >= 0;
})
.map(message => message.args)
.startWith([0,0,0]);
var rightHand$ = hands$
.filter(function (message) {
return message.address.indexOf(settings.osc.hand.right) >= 0;
})
.map(message => message.args)
.startWith([0,0,0]);
var leftHandBehindHead$ = head$.combineLatest(leftHand$);
var leftLight$ = leftHand$.map(handToLight).map(toResult);
var rightLight$ = rightHand$.map(handToLight).map(toResult);
var ripple$ = Ripple({ length: 2 });
var colorsCombined = rxUtil
.combineColors([
LightOff$, ripple$, leftLight$, rightLight$
])
.throttle(16)
// fade stuff
.scan(colorUtil.fadeColors({fastOn : true, ratio: .8}), numLights);
colorsCombined.subscribe(toApi);
// DEBUG
//colorsCombined.timeInterval().map((i) => i.interval).subscribe((interval) => console.log('interval', toHashes(interval/30)));
// Open the socket.
kinect.open();
function handToLight (pos, style) {
var light = ColorLight();
//console.log(toHashes(pos[1]));
light.position = pos[1]; // / 2;
//light.color = colorUtil.colorToInt(Color({h: (360 * ((2 + pos[0]) % 1)), s: 100, v: 100}));
// start with red in the middle, symmetric towards both sides
light.color = colorUtil.colorToInt(Color({h : (360 * Math.abs(pos[0] % 1)), s : 100, v : 100}));
return light;
}
function toApi (colors) {
api.colors.set(colors);
}
function toHashes (i) {
return (new Array(Math.floor(i * 40))).join('#');
}
function toResult (light) {
return light.result();
}
}
.flatMap(blocks => Observable.from(blocks, null, null, Scheduler.default))