Publish Vulpes Preview 15 sources for desktop, Android and Tundra
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
This commit is contained in:
OverSu
parent
93e3a48004
commit
b38dea0597
25901 changed files with 9982925 additions and 369 deletions
|
|
@ -0,0 +1,441 @@
|
|||
'use strict';
|
||||
|
||||
/**
|
||||
* Dependencies
|
||||
* @ignore
|
||||
*/
|
||||
|
||||
var createPort = require('./port-adaptors');
|
||||
var Emitter = require('../emitter');
|
||||
var utils = require('../utils');
|
||||
var defer = utils.deferred;
|
||||
var uuid = utils.uuid;
|
||||
|
||||
/**
|
||||
* Exports
|
||||
* @ignore
|
||||
*/
|
||||
|
||||
exports = module.exports = type => new Message(type);
|
||||
exports.receiver = (id, n) => new Receiver(id, n);
|
||||
exports.Receiver = Receiver;
|
||||
exports.Message = Message;
|
||||
|
||||
/**
|
||||
* Mini Logger
|
||||
*
|
||||
* 0: off
|
||||
* 1: performance
|
||||
* 2: console.log
|
||||
*
|
||||
* @type {Function}
|
||||
* @private
|
||||
*/
|
||||
var debug = {
|
||||
0: () => {},
|
||||
1: arg => performance.mark(`[${self.constructor.name}][Message] - ${arg}`),
|
||||
2: (arg1, ...args) => {
|
||||
var type = `[${self.constructor.name}][${location.pathname}]`;
|
||||
console.log(`[Message]${type} - "${arg1}"`, ...args);
|
||||
}
|
||||
}[0];
|
||||
|
||||
/**
|
||||
* Default response timeout.
|
||||
* @type {Number}
|
||||
* @private
|
||||
*/
|
||||
var TIMEOUT = 1000;
|
||||
|
||||
/**
|
||||
* Initialize a new `Message`
|
||||
*
|
||||
* @class Message
|
||||
* @borrows Emitter#on as #on
|
||||
* @borrows Emitter#off as #off
|
||||
* @borrows Emitter#emit as #emit
|
||||
* @param {String} type Message type
|
||||
*/
|
||||
function Message(type) {
|
||||
this.cancelled = false;
|
||||
this.listeners = [];
|
||||
this.deferred = defer();
|
||||
this.onMessage = this.onMessage.bind(this);
|
||||
this.onTimeout = this.onTimeout.bind(this);
|
||||
if (typeof type === 'object') this.setupInbound(type);
|
||||
else this.setupOutbound(type);
|
||||
debug('initialized', type);
|
||||
}
|
||||
|
||||
Message.prototype = {
|
||||
setupOutbound(type) {
|
||||
this.id = uuid();
|
||||
this.type = type;
|
||||
this.sent = false;
|
||||
this.recipient = '*';
|
||||
},
|
||||
|
||||
setupInbound (e) {
|
||||
debug('inbound');
|
||||
this.hasResponded = false;
|
||||
this.setSourcePort(e.source || e.target);
|
||||
|
||||
// Keep a reference to the MessageEvent
|
||||
this.event = e;
|
||||
|
||||
// Mixin the properties of the original message
|
||||
Object.assign(this, e.data);
|
||||
},
|
||||
|
||||
setSourcePort(endpoint) {
|
||||
debug('set source', endpoint.constructor.name);
|
||||
this.sourcePort = createPort(endpoint, { ready: true });
|
||||
return this;
|
||||
},
|
||||
|
||||
set(key, value) {
|
||||
debug('set', key, value);
|
||||
if (typeof key == 'object') Object.assign(this, key);
|
||||
else this[key] = value;
|
||||
return this;
|
||||
},
|
||||
|
||||
serialize() {
|
||||
return {
|
||||
id: this.id,
|
||||
type: this.type,
|
||||
data: this.data,
|
||||
recipient: this.recipient,
|
||||
noRespond: this.noRespond
|
||||
};
|
||||
},
|
||||
|
||||
preventDefault() {
|
||||
debug('prevent default');
|
||||
this.defaultPrevented = true;
|
||||
},
|
||||
|
||||
/**
|
||||
* Send the message to an endpoint.
|
||||
*
|
||||
* @param {(Iframe|Window|Worker|MessagePort)} endpoint
|
||||
* @return {Promise}
|
||||
*/
|
||||
send(endpoint) {
|
||||
debug('send', this.type);
|
||||
if (this.sent) throw error(1);
|
||||
var serialized = this.serialize();
|
||||
var expectsResponse = !this.noRespond;
|
||||
|
||||
// A port is resolved from either a predefined
|
||||
// port, or an endpoint given as first argument
|
||||
this.port = endpoint ? createPort(endpoint) : this.port;
|
||||
if (!this.port) throw error(3);
|
||||
|
||||
// If we're expecting a response listen
|
||||
// on the port else resolve promise instantly
|
||||
if (expectsResponse) {
|
||||
this.listen(this.port);
|
||||
this.setResponseTimeout();
|
||||
} else this.deferred.resolve();
|
||||
|
||||
this.port.postMessage(serialized, this.getTransfer());
|
||||
debug('sent', serialized);
|
||||
return this.deferred.promise;
|
||||
},
|
||||
|
||||
/**
|
||||
* Set the response timeout.
|
||||
*
|
||||
* When set to `false` no timeout
|
||||
* is installed.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
setResponseTimeout() {
|
||||
if (this.timeout === false) return;
|
||||
var ms = this.timeout || TIMEOUT;
|
||||
this._timer = setTimeout(this.onTimeout, ms);
|
||||
},
|
||||
|
||||
/**
|
||||
* Clear the response timeout.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
clearResponseTimeout() {
|
||||
clearTimeout(this._timer);
|
||||
},
|
||||
|
||||
getTransfer() {
|
||||
return this.transfer || this.event && this.event.ports;
|
||||
},
|
||||
|
||||
onMessage(e) {
|
||||
var valid = !!e.data.response
|
||||
&& e.data.id === this.id
|
||||
&& !this.cancelled;
|
||||
|
||||
if (valid) this.onResponse(e);
|
||||
},
|
||||
|
||||
onTimeout() {
|
||||
debug('response timeout', this.type);
|
||||
if (!this.silentTimeout) this.deferred.reject(error(4));
|
||||
this.teardown();
|
||||
},
|
||||
|
||||
listen(thing) {
|
||||
debug('add response listener', thing);
|
||||
var port = createPort(thing);
|
||||
port.addListener(this.onMessage);
|
||||
this.listeners.push(port);
|
||||
return this;
|
||||
},
|
||||
|
||||
unlisten() {
|
||||
debug('remove response listeners');
|
||||
this.listeners.forEach(port => port.removeListener(this.onMessage));
|
||||
this.listeners = [];
|
||||
},
|
||||
|
||||
/**
|
||||
* Cancel a pending Message.
|
||||
*
|
||||
* @example
|
||||
*
|
||||
* var msg = message('foo')
|
||||
*
|
||||
* msg.send(new Worker('my-worker.js'))
|
||||
* .then(response => {
|
||||
* // this will never run
|
||||
* })
|
||||
*
|
||||
* msg.cancel();
|
||||
*
|
||||
* @public
|
||||
*/
|
||||
cancel() {
|
||||
this.teardown();
|
||||
this.cancelled = true;
|
||||
this.emit('cancel');
|
||||
},
|
||||
|
||||
teardown() {
|
||||
this.clearResponseTimeout();
|
||||
this.unlisten();
|
||||
},
|
||||
|
||||
/**
|
||||
* Respond to a message.
|
||||
*
|
||||
* @example
|
||||
*
|
||||
* receiver.on('hello', message => {
|
||||
* message.respond('world');
|
||||
* });
|
||||
*
|
||||
* @public
|
||||
* @param {*} [result] Data to send back with the response
|
||||
*/
|
||||
respond(result) {
|
||||
debug('respond', result);
|
||||
|
||||
if (this.hasResponded) throw error(2);
|
||||
if (!this.sourcePort) return;
|
||||
if (this.noRespond) return;
|
||||
|
||||
var self = this;
|
||||
this.hasResponded = true;
|
||||
|
||||
// Repsond with rejection when result is an `Error`
|
||||
if (result instanceof Error) reject(result);
|
||||
|
||||
// Call the handler and make
|
||||
// sure return value is a promise.
|
||||
// If the returned value is unclonable
|
||||
// then the send() method will throw,
|
||||
// the .catch() will reject in this case.
|
||||
Promise.resolve(result)
|
||||
.then(resolve, reject)
|
||||
.catch(reject);
|
||||
|
||||
function resolve(value) {
|
||||
debug('resolve', value);
|
||||
respond({
|
||||
type: 'resolve',
|
||||
value: value
|
||||
});
|
||||
}
|
||||
|
||||
function reject(err) {
|
||||
var msg = err && err.message || err;
|
||||
debug('reject', msg);
|
||||
respond({
|
||||
type: 'reject',
|
||||
value: msg
|
||||
});
|
||||
}
|
||||
|
||||
function respond(response) {
|
||||
self.response = response;
|
||||
self.sourcePort.postMessage({
|
||||
id: self.id,
|
||||
response: response
|
||||
}, self.transfer);
|
||||
|
||||
debug('responded with:', response);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Forward a `Message` onto another endpoint.
|
||||
*
|
||||
* The `silentTrue` option prevents the
|
||||
* message request timing out should
|
||||
* the response come back via an
|
||||
* alternative route.
|
||||
*
|
||||
* @param {(HTMLIframeElement|MessagePort|Window)} endpoint
|
||||
* @public
|
||||
*/
|
||||
forward(endpoint) {
|
||||
debug('forward');
|
||||
return this
|
||||
.set('silentTimeout', true)
|
||||
.send(endpoint)
|
||||
.then(result => this.respond(result.value));
|
||||
},
|
||||
|
||||
onResponse(e) {
|
||||
debug('on response', e.data);
|
||||
var response = e.data.response;
|
||||
var type = response.type;
|
||||
var value = type == 'reject'
|
||||
? response.value
|
||||
: response;
|
||||
|
||||
response.event = e;
|
||||
this.response = response;
|
||||
this.teardown();
|
||||
|
||||
this.deferred[this.response.type](value);
|
||||
this.emit('response', response);
|
||||
}
|
||||
};
|
||||
|
||||
// Mixin Emitter methods
|
||||
Emitter(Message.prototype);
|
||||
|
||||
/**
|
||||
* Initialize a new `Receiver`.
|
||||
*
|
||||
* @class Receiver
|
||||
* @extends Emitter
|
||||
* @param {String} name - corresponds to `Message.recipient`
|
||||
*/
|
||||
function Receiver(name) {
|
||||
this.name = name;
|
||||
this.ports = new Set();
|
||||
this.onMessage = this.onMessage.bind(this);
|
||||
this['listen'] = this['listen'].bind(this);
|
||||
this['unlisten'] = this['unlisten'].bind(this);
|
||||
debug('receiver initialized', name);
|
||||
}
|
||||
|
||||
Receiver.prototype = {
|
||||
|
||||
/**
|
||||
* Begin listening for inbound messages.
|
||||
*
|
||||
* @example
|
||||
*
|
||||
* // When no arguments are given
|
||||
* // messages will be listened for
|
||||
* // on the default global scope
|
||||
* .listen();
|
||||
*
|
||||
* // When an endpoint is out of reach
|
||||
* // BroadcastChannel can be used.
|
||||
* .listen(new BroadcastChannel('foo'));
|
||||
*
|
||||
* @param {(HTMLIframeElement|Worker|MessagePort|
|
||||
* BroadcastChannel|Window|Object)} [thing]
|
||||
* @public
|
||||
*/
|
||||
listen(thing) {
|
||||
debug('listen');
|
||||
var _port = createPort(thing || self, { receiver: true });
|
||||
if (this.ports.has(_port)) return;
|
||||
_port.addListener(this.onMessage, this.listen);
|
||||
this.ports.add(_port);
|
||||
return this;
|
||||
},
|
||||
|
||||
/**
|
||||
* Stop listening for inbound messages
|
||||
* on all endpoints listened to prior.
|
||||
*
|
||||
* @public
|
||||
*/
|
||||
unlisten() {
|
||||
debug('unlisten');
|
||||
this.ports.forEach(port => {
|
||||
port.removeListener(this.onMessage, this.unlisten);
|
||||
});
|
||||
},
|
||||
|
||||
/**
|
||||
* Callback to handle inbound messages.
|
||||
* @param {MessageEvent} e
|
||||
* @private
|
||||
*/
|
||||
onMessage(e) {
|
||||
if (!e.data.id) return;
|
||||
if (!e.data.type) return;
|
||||
if (!this.isRecipient(e.data.recipient)) return;
|
||||
debug('receiver on message', e.data);
|
||||
var message = new Message(e);
|
||||
|
||||
// Before hook
|
||||
this.emit('message', message);
|
||||
if (message.defaultPrevented) return;
|
||||
|
||||
try { this.emit(message.type, message); }
|
||||
catch (e) {
|
||||
message.respond(e);
|
||||
throw e;
|
||||
}
|
||||
},
|
||||
|
||||
isRecipient(recipient) {
|
||||
return recipient == this.name
|
||||
|| recipient == '*'
|
||||
|| this.name == '*';
|
||||
},
|
||||
|
||||
destroy: function() {
|
||||
this.unlisten();
|
||||
delete this.name;
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
// Mixin Emitter methods
|
||||
Emitter(Receiver.prototype);
|
||||
|
||||
/**
|
||||
* Creates new `Error` from registry.
|
||||
*
|
||||
* @param {Number} id Error Id
|
||||
* @return {Error}
|
||||
* @private
|
||||
*/
|
||||
function error(id, ...args) {
|
||||
return new Error({
|
||||
1: '.send() can only be called once',
|
||||
2: 'response already sent for this message',
|
||||
3: 'a port must be defined',
|
||||
4: 'timeout'
|
||||
}[id]);
|
||||
}
|
||||
|
|
@ -0,0 +1,282 @@
|
|||
'use strict';
|
||||
|
||||
/**
|
||||
* Dependencies
|
||||
* @ignore
|
||||
*/
|
||||
|
||||
var deferred = require('../utils').deferred;
|
||||
|
||||
/**
|
||||
* Message event name
|
||||
* @type {String}
|
||||
*/
|
||||
const MSG = 'message';
|
||||
|
||||
/**
|
||||
* Mini Logger
|
||||
* @type {Function}
|
||||
* @private
|
||||
*/
|
||||
var debug = 0 ? function(arg1, ...args) {
|
||||
var type = `[${self.constructor.name}][${location.pathname}]`;
|
||||
console.log(`[PortAdaptor]${type} - "${arg1}"`, ...args);
|
||||
} : () => {};
|
||||
|
||||
/**
|
||||
* Creates a bridge.js port abstraction
|
||||
* with a consistent interface.
|
||||
*
|
||||
* @param {Object} target
|
||||
* @param {Object} options
|
||||
* @return {PortAdaptor}
|
||||
*/
|
||||
module.exports = function create(target, options) {
|
||||
if (!target) throw error(1);
|
||||
if (isEndpoint(target)) return target;
|
||||
var type = target.constructor.name;
|
||||
var CustomAdaptor = adaptors[type];
|
||||
debug('creating port adaptor for', type);
|
||||
if (CustomAdaptor) return CustomAdaptor(target, options);
|
||||
return new PortAdaptor(target, options);
|
||||
};
|
||||
|
||||
/**
|
||||
* The default adaptor.
|
||||
* @private
|
||||
*/
|
||||
function PortAdaptor(target) {
|
||||
debug('PortAdaptor');
|
||||
this.target = target;
|
||||
}
|
||||
|
||||
var PortAdaptorProto = PortAdaptor.prototype = {
|
||||
constructor: PortAdaptor,
|
||||
addListener(callback) { on(this.target, MSG, callback); },
|
||||
removeListener(callback) { off(this.target, MSG, callback); },
|
||||
postMessage(data, transfer) { this.target.postMessage(data, transfer); }
|
||||
};
|
||||
|
||||
/**
|
||||
* A registry of specific adaptors
|
||||
* for when the default PortAdaptor
|
||||
* is not suitable.
|
||||
*
|
||||
* @type {Object}
|
||||
*/
|
||||
var adaptors = {
|
||||
|
||||
/**
|
||||
* Create an HTMLIframeElement PortAdaptor.
|
||||
*
|
||||
* @param {HTMLIframeElement} iframe
|
||||
*/
|
||||
'HTMLIFrameElement': function(iframe) {
|
||||
debug('HTMLIFrameElement');
|
||||
var ready = windowReady(iframe);
|
||||
return {
|
||||
addListener(callback, listen) { on(window, MSG, callback); },
|
||||
removeListener(callback, listen) { off(window, MSG, callback); },
|
||||
postMessage(data, transfer) {
|
||||
ready.then(() => postMessageSync(iframe.contentWindow, data, transfer));
|
||||
}
|
||||
};
|
||||
},
|
||||
|
||||
/**
|
||||
* Create a BroadcastChannel port-adaptor.
|
||||
*
|
||||
* @param {Object} channel
|
||||
* @param {[type]} options [description]
|
||||
*/
|
||||
'BroadcastChannel': function(channel, options) {
|
||||
debug('BroadcastChannel', channel.name);
|
||||
var receiver = options && options.receiver;
|
||||
var ready = options && options.ready;
|
||||
var sendReady = () => {
|
||||
channel.postMessage('ready');
|
||||
debug('sent ready');
|
||||
};
|
||||
|
||||
ready = ready || receiver
|
||||
? Promise.resolve()
|
||||
: setupSender();
|
||||
|
||||
if (receiver) {
|
||||
sendReady();
|
||||
on(channel, MSG, e => {
|
||||
if (e.data != 'ready?') return;
|
||||
sendReady();
|
||||
});
|
||||
}
|
||||
|
||||
function setupSender() {
|
||||
debug('setup sender');
|
||||
var promise = deferred();
|
||||
|
||||
channel.postMessage('ready?');
|
||||
on(channel, MSG, function fn(e) {
|
||||
if (e.data != 'ready') return;
|
||||
off(channel, MSG, fn);
|
||||
debug('BroadcastChannel: ready');
|
||||
promise.resolve();
|
||||
});
|
||||
|
||||
return promise.promise;
|
||||
}
|
||||
|
||||
return {
|
||||
target: channel,
|
||||
addListener: PortAdaptorProto.addListener,
|
||||
removeListener: PortAdaptorProto.removeListener,
|
||||
postMessage(data, transfer) {
|
||||
ready.then(() => channel.postMessage(data, transfer));
|
||||
}
|
||||
};
|
||||
},
|
||||
|
||||
'Window': function(win, options) {
|
||||
debug('Window');
|
||||
var ready = options && options.ready
|
||||
|| win === parent // parent always ready
|
||||
|| win === self; // self always ready
|
||||
|
||||
ready = ready ? Promise.resolve() : windowReady(win);
|
||||
|
||||
return {
|
||||
addListener(callback, listen) { on(window, MSG, callback); },
|
||||
removeListener(callback, listen) { off(window, MSG, callback); },
|
||||
postMessage(data, transfer) {
|
||||
ready.then(() => postMessageSync(win, data, transfer));
|
||||
}
|
||||
};
|
||||
},
|
||||
|
||||
'SharedWorker': function(worker) {
|
||||
worker.port.start();
|
||||
return new PortAdaptor(worker.port);
|
||||
},
|
||||
|
||||
'SharedWorkerGlobalScope': function() {
|
||||
var ports = [];
|
||||
|
||||
return {
|
||||
postMessage() {}, // noop
|
||||
addListener(callback, listen) {
|
||||
this.onconnect = e => {
|
||||
var port = e.ports[0];
|
||||
ports.push(port);
|
||||
port.start();
|
||||
listen(port);
|
||||
};
|
||||
|
||||
on(self, 'connect', this.onconnect);
|
||||
},
|
||||
|
||||
removeListener(callback, unlisten) {
|
||||
off(self, 'connect', this.onconnect);
|
||||
ports.forEach(port => {
|
||||
port.close();
|
||||
unlisten(port);
|
||||
});
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Return a Promise that resolves
|
||||
* when a Window is ready to start
|
||||
* recieving messages.
|
||||
*
|
||||
* @param {Window} target
|
||||
* @return {Promise}
|
||||
*/
|
||||
var windowReady = (function() {
|
||||
if (typeof window == 'undefined') return;
|
||||
var parent = window.opener || window.parent;
|
||||
var domReady = 'DOMContentLoaded';
|
||||
var windows = new WeakSet();
|
||||
|
||||
// Side B: Dispatches 'load'
|
||||
// from the child window
|
||||
if (parent != self) {
|
||||
on(window, domReady, function fn() {
|
||||
off(window, domReady, fn);
|
||||
postMessageSync(parent, 'load');
|
||||
});
|
||||
}
|
||||
|
||||
// Side A: Listens for 'ready' in the parent window
|
||||
on(self, 'message', e => e.data == 'load' && windows.add(e.source));
|
||||
|
||||
return target => {
|
||||
var win = target.contentWindow || target;
|
||||
|
||||
// Ready if the target has previously announces itself ready
|
||||
if (windows.has(win)) return Promise.resolve();
|
||||
|
||||
// Ready if the target is the parent window
|
||||
if (win == window.parent) return Promise.resolve();
|
||||
|
||||
var def = deferred();
|
||||
debug('waiting for Window to be ready ...');
|
||||
on(window, 'message', function fn(e) {
|
||||
if (e.data == 'load' && e.source == win) {
|
||||
debug('Window ready');
|
||||
off(window, 'message', fn);
|
||||
def.resolve();
|
||||
}
|
||||
});
|
||||
return def.promise;
|
||||
};
|
||||
})();
|
||||
|
||||
/**
|
||||
* Utils
|
||||
* @ignore
|
||||
*/
|
||||
|
||||
function isEndpoint(thing) {
|
||||
return !!(thing && thing.addListener);
|
||||
}
|
||||
|
||||
// Shorthand
|
||||
function on(target, name, fn) { target.addEventListener(name, fn); }
|
||||
function off(target, name, fn) { target.removeEventListener(name, fn); }
|
||||
|
||||
/**
|
||||
* Dispatches syncronous 'message'
|
||||
* event on a Window.
|
||||
*
|
||||
* We use this because standard
|
||||
* window.postMessage() gets blocked
|
||||
* until the main-thread is free.
|
||||
*
|
||||
* @param {Window} win
|
||||
* @param {*} data
|
||||
* @private
|
||||
*/
|
||||
function postMessageSync(win, data, transfer) { try { void win.document; } catch (_) { win.postMessage(data, location.origin, transfer || []); return; }
|
||||
var event = {
|
||||
data: data,
|
||||
source: self
|
||||
};
|
||||
|
||||
if (transfer) event.ports = transfer;
|
||||
|
||||
win.dispatchEvent(new MessageEvent('message', event));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates new `Error` from registery.
|
||||
*
|
||||
* @param {Number} id Error Id
|
||||
* @return {Error}
|
||||
* @private
|
||||
*/
|
||||
function error(id) {
|
||||
return new Error({
|
||||
1: 'target is undefined'
|
||||
}[id]);
|
||||
}
|
||||
Loading…
Reference in a new issue