function TwitterWatcher() {
if (!(this instanceof TwitterWatcher)) {
return new TwitterWatcher();
}
events.EventEmitter.call(this);
}
function Updater(time) {
this.time = time;
this.array = [
{number: 1},
{number: 2}
];
var that;
events.EventEmitter.call(this);
this.init = function()
{
that = this;
console.log("Contructor");
//Start interval
setInterval(that.run,that.time);
};
this.run = function()
{
that.array.forEach(function (item) {
if(item.number === 2)
{
that.emit('Event');
}
});
};
}
constructor(filename: string) {
super();
EventEmitter.call(this);
this.filename = filename;
this.stack = [];
this.paused = false;
}
export var OrderBook = function(productID: string, websocketURI: string, restURI: string, timeProvider: Utils.ITimeProvider) {
var self = this;
EventEmitter.call(self);
self.productID = productID || 'BTC-USD';
self.websocketURI = websocketURI || 'wss://ws-feed.exchange.coinbase.com';
self.restURI = restURI;
self.state = self.STATES.closed;
self.fail_count = 0;
self.timeProvider = timeProvider;
self.connect();
};
module[method] = (...args: any) => {
// create new instance of module at runtime if none exists
if (!lazyModule) {
lazyModule = creator()
if (isEventEmitter) EventEmitter.call(lazyModule as any)
}
// check for properties on the prototype chain that aren't functions
if (typeof (lazyModule as any)[method] !== 'function') {
return (lazyModule as any)[method]
}
return (lazyModule as any)[method](...args)
}
var VirtualSerialPort = function(path, options, callback) {
events.EventEmitter.call(this);
console.log("on virtual port ", path);
this.path = path;
var self = this;
this.writeToComputer = function(data) {
self.emit("data", data);
};
if (options.autoOpen) {
process.nextTick(function() {
self.open(callback);
});
}
};
import { EventEmitter } from 'events'
const bindings = process.atomBinding('app')
const commandLine = process.atomBinding('command_line')
const { app, App } = bindings
// Only one app object permitted.
export default app
const { deprecate, Menu } = electron
let dockMenu: Electron.Menu | null = null
// App is an EventEmitter.
Object.setPrototypeOf(App.prototype, EventEmitter.prototype)
EventEmitter.call(app as any)
Object.assign(app, {
setApplicationMenu (menu: Electron.Menu | null) {
return Menu.setApplicationMenu(menu)
},
getApplicationMenu () {
return Menu.getApplicationMenu()
},
commandLine: {
hasSwitch: (theSwitch: string) => commandLine.hasSwitch(String(theSwitch)),
getSwitchValue: (theSwitch: string) => commandLine.getSwitchValue(String(theSwitch)),
appendSwitch: (theSwitch: string, value?: string) => commandLine.appendSwitch(String(theSwitch), typeof value === 'undefined' ? value : String(value)),
appendArgument: (arg: string) => commandLine.appendArgument(String(arg))
} as Electron.CommandLine,
enableMixedSandbox () {
module.exports = function Sound(filename) {
events.EventEmitter.call(this);
this.filename = filename;
};
constructor() {
super();
util.inherits(XLSX, events.EventEmitter);
events.EventEmitter.call(this);
}
export function Board(port, options) : void {
if (!(this instanceof Board)) {
return new Board(port, options);
}
var delay = 0;
if(options && typeof options.delay === 'number' && options.delay > 0) {
delay = options.delay;
}
var self = this;
var serialPort = new (require("serialport").SerialPort)(port, options);
// Query our interfaces and attach our interface libraries
serialPort.once('open', function() {
var timeoutId = setTimeout(function() {
self.emit('error', 'Timeout awaiting response to QueryInterface');
}, delay + 1000);
self.once('error', function(error) {
clearTimeout(timeoutId);
});
setTimeout(function() {
self.queryInterface(function(interfaces) {
self.emit('ready');
}, timeoutId);
}, delay);
});
// SLIP (http://www.ietf.org/rfc/rfc1055.txt) protocol special character definitions
// Used to find end of frame when using a streaming communications protocol
var EscapeCharacters = {
END : 0xC0,
ESCAPE : 0xDB,
ESCAPED_END : 0xDC,
ESCAPED_ESCAPE : 0xDD
};
var ReadState = {
// Reading the frame sequence # at the start of the frame
FrameStart : 0,
// Reading frame data bytes until an End is received
ReadingFrame : 1,
// End received, processing the frame data
FrameEnded : 2,
// Waiting for the next End character to get a fresh frame state
FrameInvalid : 3
};
var FrameTypes = {
Reset : 0x7A,
Heartbeat : 0x7B,
Response : 0x7C,
Message : 0x7D,
Warning : 0x7E,
Error : 0x7F
};
var ErrorCodes = {
0x00 : 'OutOfSequence',
0x01 : 'UnexpectedEscape',
0x02 : 'CrcMismatch',
0x03 : 'UnexpectedEnd',
0x04 : 'BufferOverflow',
0x05 : 'FrameTooSmall',
0x06 : 'FunctionConflict',
0x07 : 'FunctionNotFound',
0x08 : 'ParameterMismatch',
0x09 : 'StackOverflow',
0x0A : 'StackUnderflow',
0x0B : 'WireNotAvailable'
};
this.FunctionIds = {
pushArray : [ 0x00 ],
queryInterface : [ 0x01 ],
sendResponse : [ 0x02 ],
sendResponseCount : [ 0x03 ],
reset : [ 0x7A ]
};
// Space to compose an outgoing frame of data
var writeArray = [];
var writeArrayIndex = 0;
var writeSequence = 0;
var writeChecksum = 0;
var writeEscaped = function(b) {
switch(b) {
case EscapeCharacters.END:
writeArray[writeArrayIndex++] = EscapeCharacters.ESCAPE;
writeArray[writeArrayIndex++] = EscapeCharacters.ESCAPED_END;
break;
case EscapeCharacters.ESCAPE:
writeArray[writeArrayIndex++] = EscapeCharacters.ESCAPE;
writeArray[writeArrayIndex++] = EscapeCharacters.ESCAPED_ESCAPE;
break;
default:
writeArray[writeArrayIndex++] = b;
break;
}
writeChecksum ^= b;
};
var readArray = [];
var readArrayIndex = 0;
var readState = ReadState.FrameStart;
var readSequence = 0;
var readChecksum = 0;
var escaped = false;
var readUnescaped = function() {
var b = readArray[readArrayIndex++];
if (escaped) {
escaped = false;
switch (b)
{
case EscapeCharacters.ESCAPED_END:
return EscapeCharacters.END;
case EscapeCharacters.ESCAPED_ESCAPE:
return EscapeCharacters.ESCAPE;
default:
self.emit('warning', 'Local: frame corrupt, unexpected escape');
readState = ReadState.FrameInvalid;
return null;
}
}
if (b === EscapeCharacters.ESCAPE) {
escaped = true;
return null;
}
if (b === EscapeCharacters.END) {
switch (readState)
{
case ReadState.FrameInvalid:
readState = ReadState.FrameStart;
break;
case ReadState.ReadingFrame:
readState = ReadState.FrameEnded;
break;
default:
self.emit('warning', 'Local: frame corrupt, unexpected end');
readState = ReadState.FrameInvalid;
break;
}
}
return b;
};
var frameSequence = 0;
// Buffer to hold a frame of data pulled out of the incoming communications stream
var frameBuffer = [];
var frameIndex = 0;
var parseFrame = function(data) {
readArray = data;
readArrayIndex = 0;
while (readArrayIndex < readArray.length)
{
var b = readUnescaped();
// Either escape character or an error, either way ignore this data
if (b === null) {
continue;
}
switch (readState) {
case ReadState.FrameInvalid:
break;
case ReadState.FrameStart:
frameSequence = b;
if (readSequence++ !== frameSequence) {
readSequence = frameSequence + 1;
}
// Start off a new checksum
readChecksum = b;
// Reinitialize the buffer since we send using frameBuffer.length
frameBuffer = [];
// Reset the buffer pointer to beginning
frameIndex = 0;
readState = ReadState.ReadingFrame;
break;
case ReadState.ReadingFrame:
frameBuffer[frameIndex++] = b;
readChecksum ^= b;
break;
case ReadState.FrameEnded:
// zero expected because when CRC of data is XORed with Checksum byte it should equal zero
if (readChecksum !== 0) {
self.emit('warning', 'Local: frame corrupt, crc mismatch', data, readChecksum);
} else {
// Valid frame received, process based on frame type
switch (frameBuffer[0]) {
case FrameTypes.Error:
self.emit('error', 'Remote: ' + frameBuffer[1] + ' : ' + ErrorCodes[frameBuffer[1]]);
break;
case FrameTypes.Warning:
self.emit('warning', 'Remote: ' + frameBuffer[1] + ' : ' + ErrorCodes[frameBuffer[1]]);
break;
case FrameTypes.Message:
var length = frameBuffer[1];
self.emit('message', new Buffer(frameBuffer).toString('utf8', 2, length + 2));
break;
case FrameTypes.Response:
var responseToSequence = frameBuffer[1];
var frameLength = frameBuffer[2];
var responseData = new Buffer(frameBuffer).slice(3, frameLength + 3);
self.emit('response', { sequence: responseToSequence, data: responseData });
break;
case FrameTypes.Heartbeat:
var collectingLoops = frameBuffer[1] + (frameBuffer[2] << 8);
var idleLoops = frameBuffer[3] + (frameBuffer[4] << 8);
self.emit('heartbeat', { collectingLoops: collectingLoops, idleLoops: idleLoops, data: new Buffer(frameBuffer).slice(5, frameBuffer.length - 1) });
break;
// FrameType unknown, use a generic frame received callback
default:
// TODO: consider expressing this as multiple params?
self.emit('frame', { sequence: frameSequence, data: new Buffer(frameBuffer) });
break;
}
}
readState = ReadState.FrameStart;
break;
}
}
};
serialPort.on('data', parseFrame);
serialPort.on('open', function() { self.emit('open'); });
serialPort.on('close', function() { self.emit('close'); });
serialPort.on('end', function() { self.emit('end'); });
serialPort.on('error', function(err) { self.emit('error', err); });
events.EventEmitter.call(this);
this.close = function close(callback) {
self.sendFrame(self.FunctionIds.reset);
serialPort.close(callback);
};
this.sendFrame = function sendFrame() {
var frame = new Buffer(0);
for (var i = 0; i < arguments.length; i++) {
var data = arguments[i];
if (!Buffer.isBuffer(data)) {
if (isNaN(data)) {
data = new Buffer(data);
} else {
// Don't allow a number passed as data to be misinterpreted as a buffer length
data = new Buffer([data]);
}
}
frame = Buffer.concat( [frame, data] );
}
// Artificial 8-bit rollover
if (writeSequence === 256) {
writeSequence = 0;
}
// Reinitialize the writeArray and checksum
writeChecksum = 0;
writeArray = [];
writeArrayIndex = 0;
writeEscaped(writeSequence);
for (var index = 0; index < frame.length; index++) {
writeEscaped(frame[index]);
}
writeEscaped(writeChecksum);
writeArray[writeArrayIndex++] = EscapeCharacters.END;
serialPort.write(writeArray);
return writeSequence++;
};
// Push an 'n' count of 'parameter' data onto the stack where n == the next byte
// in the frame after the pushArray function id, followed by the next n bytes of
// data.
// For example, a frame of [ 1 4 9 8 7 6 ] would mean:
// [ 1 ] pushArray
// [ 4 ] count of parameter data
// [ 9 8 7 6 ] parameter data to be pushed on the stack
this.pushArray = function pushArray(array) {
self.sendFrame(self.FunctionIds.pushArray, array);
};
// Query the interfaces (e.g. function groups) bound on the Arduino
this.queryInterface = function queryInterface(callback, timeoutId) {
var callSequence = self.sendFrame(self.FunctionIds.queryInterface);
function findInterfaceModules(reflectaInterfaces) {
if (reflectaInterfaces.length === 0) {
callback(self.interfaces);
} else {
var reflectaInterface = reflectaInterfaces.pop();
var interfaceModule = 'reflecta_' + reflectaInterface.id;
try {
// Try and find the interface module locally
self[reflectaInterface.id] = require(interfaceModule)(self, reflectaInterface.offset);
self.interfaces[reflectaInterface.id] = self[reflectaInterface.id];
// recurse until list is done
findInterfaceModules(reflectaInterfaces);
}
catch (error) {
self.emit('message', 'QueryInterface: local interface definition not found for ' + reflectaInterface.id);
// If not found locally, search for it in the NPM registry
console.log('searching for ' + reflectaInterface.id);
var npm = require('npm');
npm.load(function(error, npm) {
npm.install(interfaceModule, function(error) {
if (error) {
self.emit('warning', 'QueryInterface: npm registry interface definition not found for ' + reflectaInterface.id + ', ' + error);
} else {
self[reflectaInterface.id] = require(interfaceModule)(self, reflectaInterface.offset);
self.interfaces[reflectaInterface.id] = self[reflectaInterface.id];
}
findInterfaceModules(reflectaInterfaces);
});
});
}
}
}
var queryInterfaceHandler = function queryInterfaceHandler(response) {
if (response.sequence === callSequence) {
// Clear the pending timeout since we've received a response
clearTimeout(timeoutId);
self.removeListener('response', queryInterfaceHandler);
self.interfaces = {};
var interfaceIds = [];
for (var interfaceIndex = 0; interfaceIndex < response.data.length / 6; interfaceIndex++) {
var offset = response.data[interfaceIndex * 6];
var id = response.data.slice(interfaceIndex * 6 + 1, interfaceIndex * 6 + 6).toString();
interfaceIds.push({ id: id, offset: offset });
}
findInterfaceModules(interfaceIds);
}
};
self.on('response', queryInterfaceHandler);
};
// Request a response with n bytes from the stack, where n == the first byte on the stack
this.sendResponseCount = function sendResponseCount(count, callback) {
var callSequence = self.sendFrame( [self.FunctionIds.pushArray, 1, count, self.FunctionIds.sendResponseCount] );
var sendResponseCountHandler = function(response) {
if (response.sequence === callSequence) {
self.removeListener('response', sendResponseCountHandler);
callback(response.data);
}
}
self.on('response', sendResponseCountHandler);
};
// Request a response with 1 byte from the stack
this.sendResponse = function sendResponse(callback) : void {
var callSequence = self.sendFrame(self.FunctionIds.sendResponse);
// TODO: Tighten logic not to assume ours must be the next response
self.once('response', function(response) {
if (response.sequence === callSequence) {
callback(response.data);
}
});
};
}