2174 lines
75 KiB
JavaScript
2174 lines
75 KiB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.jiboCaiUtils = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo_log_1 = require("jibo-log");
|
|
exports.default = new jibo_log_1.Log('CAIUtils');
|
|
|
|
},{"jibo-log":undefined}],2:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* Created on 7/20/16.
|
|
* @author Tom Donahue <tom.donahue@jibo.com>
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var ActionTimelineState;
|
|
(function (ActionTimelineState) {
|
|
ActionTimelineState[ActionTimelineState["DISPATCHING"] = 0] = "DISPATCHING";
|
|
ActionTimelineState[ActionTimelineState["NOT_DISPATCHING"] = 1] = "NOT_DISPATCHING";
|
|
ActionTimelineState[ActionTimelineState["CANCELLED"] = 2] = "CANCELLED";
|
|
ActionTimelineState[ActionTimelineState["FAST_FORWARD"] = 3] = "FAST_FORWARD";
|
|
})(ActionTimelineState = exports.ActionTimelineState || (exports.ActionTimelineState = {}));
|
|
class ActionTimeline {
|
|
constructor() {
|
|
this._state = ActionTimelineState.NOT_DISPATCHING;
|
|
}
|
|
/**
|
|
* Dispatch a timeline of actions
|
|
*
|
|
* @param {TimelineElement[]} timeline
|
|
* @returns {Promise<void>}
|
|
*/
|
|
dispatchTimeline(timeline) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this._state = ActionTimelineState.DISPATCHING;
|
|
let startTime = process.hrtime();
|
|
this._promiseChain = Promise.resolve();
|
|
timeline.forEach(el => {
|
|
this._promiseChain = this._promiseChain
|
|
.then(() => this._dispatchTimeline(el, startTime));
|
|
});
|
|
this._promiseChain = this._promiseChain.then(() => {
|
|
this._state = ActionTimelineState.NOT_DISPATCHING;
|
|
this._timeoutID = null;
|
|
this._next = null;
|
|
});
|
|
return this._promiseChain;
|
|
});
|
|
}
|
|
_dispatchTimeline(el, startTime) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let timeDiff = process.hrtime(startTime);
|
|
let passedTimeMs = timeDiff[0] * 1e3 + timeDiff[1] * 1e-6;
|
|
let timeToWait = Math.max(0, el.timeMs - passedTimeMs);
|
|
return this._wait(timeToWait).then(() => {
|
|
if (this._state !== ActionTimelineState.CANCELLED) {
|
|
el.action();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Waits for timeMs and then resolves the promise
|
|
*
|
|
* @param {number} timeMs Time to wait in ms
|
|
* @returns {Promise<void>}
|
|
*/
|
|
_wait(timeMs) {
|
|
return new Promise(res => {
|
|
this._next = res;
|
|
if (this._state === ActionTimelineState.FAST_FORWARD || this._state === ActionTimelineState.CANCELLED) {
|
|
this._next();
|
|
}
|
|
else {
|
|
this._timeoutID = setTimeout(res, timeMs);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Cancel a timeline of actions (remaining actions will not be dispatched)
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
cancel() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (this._state === ActionTimelineState.DISPATCHING) {
|
|
this._state = ActionTimelineState.CANCELLED;
|
|
if (this._timeoutID) {
|
|
clearTimeout(this._timeoutID);
|
|
this._timeoutID = null;
|
|
this._next();
|
|
}
|
|
return this._promiseChain.then(() => {
|
|
this._state = ActionTimelineState.NOT_DISPATCHING;
|
|
this._timeoutID = null;
|
|
this._next = null;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Fast-forward a timeline (i.e. trigger all remaining actions in sequence immediately)
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
fastForward() {
|
|
if (this._state === ActionTimelineState.DISPATCHING) {
|
|
this._state = ActionTimelineState.FAST_FORWARD;
|
|
if (this._timeoutID) {
|
|
clearTimeout(this._timeoutID);
|
|
this._timeoutID = null;
|
|
this._next();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Get state of ActionTimeline
|
|
*
|
|
* @returns {ActionTimelineState}
|
|
*/
|
|
_getState() {
|
|
return this._state;
|
|
}
|
|
}
|
|
exports.ActionTimeline = ActionTimeline;
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
/**
|
|
* Manage a set of objects with ids and a cache
|
|
* @type {[type]}
|
|
*/
|
|
class CacheManager {
|
|
constructor() {
|
|
this.idToObject = new Map();
|
|
this.objectToId = new Map();
|
|
this.idToCache = new Map();
|
|
this.cache = new Map();
|
|
}
|
|
addObjectToCache(obj, id, cache) {
|
|
if (!this.cache.has(cache)) {
|
|
this.cache.set(cache, new Set());
|
|
}
|
|
this.cache.get(cache).add(obj);
|
|
this.idToObject.set(id, obj);
|
|
this.objectToId.set(obj, id);
|
|
this.idToCache.set(id, cache);
|
|
}
|
|
getById(id) {
|
|
return this.idToObject.get(id);
|
|
}
|
|
removeCache(cache) {
|
|
const cacheSet = this.cache.get(cache);
|
|
if (!cacheSet) {
|
|
return [];
|
|
}
|
|
this.cache.delete(cache);
|
|
const objects = [];
|
|
cacheSet.forEach((obj) => {
|
|
objects.push(obj);
|
|
this.removeByObj(obj);
|
|
});
|
|
return objects;
|
|
}
|
|
/**
|
|
* Removes both the object and the id from cache, but does not
|
|
* delete an entire cache
|
|
* @param {IDType} id
|
|
*/
|
|
removeById(id) {
|
|
const obj = this.idToObject.get(id);
|
|
this.objectToId.delete(obj);
|
|
this.idToObject.delete(id);
|
|
let cacheKey = this.idToCache.get(id);
|
|
this.idToCache.delete(id);
|
|
if (cacheKey !== undefined) {
|
|
let setForCache = this.cache.get(cacheKey);
|
|
setForCache.delete(obj);
|
|
if (setForCache.size === 0) {
|
|
this.cache.delete(cacheKey);
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
/**
|
|
* This removes the object and id from cache, but does not delete
|
|
* an entire cache
|
|
* @param obj
|
|
*/
|
|
removeByObj(obj) {
|
|
const id = this.objectToId.get(obj);
|
|
this.objectToId.delete(obj);
|
|
this.idToObject.delete(id);
|
|
let cacheKey = this.idToCache.get(id);
|
|
this.idToCache.delete(id);
|
|
if (cacheKey !== undefined) {
|
|
let setForCache = this.cache.get(cacheKey);
|
|
if (setForCache !== undefined) {
|
|
setForCache.delete(obj);
|
|
if (setForCache.size === 0) {
|
|
this.cache.delete(cacheKey);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exports.CacheManager = CacheManager;
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class CacheUtils {
|
|
/**
|
|
* Ensures that the global cache exists for jibo.loader.
|
|
* @param {Jibo} jibo The Jibo Runtime instance on which to ensure global cache is initted.
|
|
*/
|
|
static initGlobalCache(jibo) {
|
|
// Set up global cache if it doesn't exist
|
|
jibo.loader.addCache(CacheUtils.GlobalCacheName);
|
|
CacheUtils.initialized = true;
|
|
}
|
|
}
|
|
/**
|
|
* Name of global cache
|
|
* @type {string}
|
|
*/
|
|
CacheUtils.GlobalCacheName = 'global';
|
|
/**
|
|
* If the global cache has been initialized.
|
|
* @type {boolean}
|
|
*/
|
|
CacheUtils.initialized = false;
|
|
exports.CacheUtils = CacheUtils;
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const events = require("events");
|
|
exports.CancelTokenEvents = {
|
|
UNPAUSED: 'UNPAUSED',
|
|
ALL_DONE: 'ALL_DONE',
|
|
CANCEL_STARTED: 'CANCEL_STARTED',
|
|
CANCEL_FINISHED: 'CANCEL_FINISHED',
|
|
};
|
|
/**
|
|
* @description Represests
|
|
* @class CancelToken
|
|
*/
|
|
class CancelToken {
|
|
/**
|
|
* Creates an instance of CancelToken.
|
|
* @param {Promise<T>} wrappedPromise - The promise to wrap
|
|
* @param {CancelHandler} [onCancel] - Handler function for cancel events
|
|
* @memberOf CancelToken
|
|
*/
|
|
constructor(wrappedPromise, onCancel) {
|
|
this._paused = false;
|
|
this._canceled = false;
|
|
this._emitter = new events.EventEmitter();
|
|
this._wrappedPromise = wrappedPromise;
|
|
this._onCancel = onCancel;
|
|
this.promise = new Promise((resolve, reject) => {
|
|
const done = (error, data) => {
|
|
this._emitter.removeAllListeners();
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
else {
|
|
resolve(data);
|
|
}
|
|
};
|
|
wrappedPromise.then((data) => {
|
|
if (this._paused) {
|
|
this._emitter.once(exports.CancelTokenEvents.UNPAUSED, () => done(null, data));
|
|
}
|
|
else if (!this._canceled) {
|
|
done(null, data);
|
|
}
|
|
}).catch(err => {
|
|
if (this._paused) {
|
|
this._emitter.once(exports.CancelTokenEvents.UNPAUSED, () => done(err));
|
|
}
|
|
else if (!this._canceled) {
|
|
done(err);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Returns the promise this token created wrapping the internal promise
|
|
* @returns {Promise<any>} The internal wrapped promise
|
|
* @memberOf CancelToken
|
|
*/
|
|
getTokenPromise() {
|
|
return this.promise;
|
|
}
|
|
/**
|
|
* Returns the internal promise that this cancel token wraps
|
|
* @returns {Promise<any>} The internal wrapped promise
|
|
* @memberOf CancelToken
|
|
*/
|
|
getWrappedPromise() {
|
|
return this._wrappedPromise;
|
|
}
|
|
/**
|
|
* Sets the paused status of this promise session
|
|
* @param {boolean} paused
|
|
* @memberOf PromiseSession
|
|
*/
|
|
setPaused(paused) {
|
|
const oldPaused = this._paused;
|
|
this._paused = paused;
|
|
if (oldPaused && !paused) {
|
|
this._emitter.emit(exports.CancelTokenEvents.UNPAUSED);
|
|
}
|
|
}
|
|
/**
|
|
* Returns the paused status of this promise session
|
|
* @returns {boolean}
|
|
* @memberOf PromiseSession
|
|
*/
|
|
isPaused() {
|
|
return this._paused;
|
|
}
|
|
/**
|
|
* Is this token canceled
|
|
* @returns {boolean}
|
|
* @memberOf CancelToken
|
|
*/
|
|
isCanceled() {
|
|
return this._canceled;
|
|
}
|
|
/**
|
|
* Cancels the current session. Session should not be reused after calling cancel
|
|
* @memberOf PromiseSession
|
|
*/
|
|
cancel() {
|
|
this._canceled = true;
|
|
if (this._onCancel) {
|
|
this._onCancel();
|
|
}
|
|
}
|
|
}
|
|
exports.CancelToken = CancelToken;
|
|
|
|
},{"events":undefined}],6:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const events = require("events");
|
|
const CancelToken_1 = require("./CancelToken");
|
|
/**
|
|
* @description A class that represents a session for a set of promise tokens
|
|
* @class PromiseSession
|
|
*/
|
|
class CancelTokenSession {
|
|
constructor() {
|
|
this._outstanding = new Set();
|
|
this._emitter = new events.EventEmitter();
|
|
this._isCanceling = false;
|
|
}
|
|
/**
|
|
* Returns true / false whether or not the session is in the process of canceling
|
|
* @returns {boolean} true if the session is canceling. false otherwise
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
isCanceling() {
|
|
return this._isCanceling;
|
|
}
|
|
/**
|
|
* Pauses all
|
|
* @param {boolean} paused
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
setPaused(paused) {
|
|
this._outstanding.forEach(token => token.setPaused(paused));
|
|
}
|
|
/**
|
|
* Cancels the current session. Session should not be reused after calling cancel
|
|
* @returns {Promise<any>} resolved when all internal promises have resolved
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
cancel() {
|
|
this._isCanceling = true;
|
|
let wrappedPromises = [];
|
|
this._outstanding.forEach(token => {
|
|
token.cancel();
|
|
wrappedPromises.push(token.getWrappedPromise());
|
|
});
|
|
this._outstanding.clear();
|
|
this._emitter.emit(CancelToken_1.CancelTokenEvents.CANCEL_STARTED);
|
|
const done = () => {
|
|
this._emitter.emit(CancelToken_1.CancelTokenEvents.CANCEL_FINISHED);
|
|
this._isCanceling = false;
|
|
this.clear();
|
|
};
|
|
// We wait for all wrapped promises to resolve
|
|
return Promise.all(wrappedPromises).then(() => {
|
|
done();
|
|
}).catch(e => {
|
|
done();
|
|
throw e;
|
|
});
|
|
}
|
|
/**
|
|
* Number of outstanding promises
|
|
* @returns {number}
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
size() {
|
|
return this._outstanding.size;
|
|
}
|
|
/**
|
|
* Waits for all outstanding promises to complete
|
|
* This refers to the internal promises, not the wrapped promises that were returned
|
|
* This promise is rejected immediately when the session gets canceled
|
|
* @param {boolean} [rejectImmediatelyOnCancel=true] - Whether we should reject immediately when
|
|
* canceled or when the cancel promise is resolved.
|
|
* @returns {Promise<void>}
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
waitForAll(rejectImmediatelyOnCancel = true) {
|
|
if (this._outstanding.size === 0) {
|
|
return Promise.resolve();
|
|
}
|
|
else {
|
|
return new Promise((resolve, reject) => {
|
|
let allDoneHandler = () => done();
|
|
let canceledHandler = () => done(new Error(`Promise session canceled`));
|
|
// When done, either with error or no error, we clean up listeners and resolve/reject
|
|
const done = (error) => {
|
|
this._emitter.removeListener(CancelToken_1.CancelTokenEvents.ALL_DONE, allDoneHandler);
|
|
this._emitter.removeListener(CancelToken_1.CancelTokenEvents.CANCEL_STARTED, canceledHandler);
|
|
this._emitter.removeListener(CancelToken_1.CancelTokenEvents.CANCEL_FINISHED, canceledHandler);
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
else {
|
|
resolve();
|
|
}
|
|
};
|
|
// We wait for either of these events
|
|
this._emitter.once(CancelToken_1.CancelTokenEvents.ALL_DONE, allDoneHandler);
|
|
if (rejectImmediatelyOnCancel) {
|
|
this._emitter.once(CancelToken_1.CancelTokenEvents.CANCEL_STARTED, canceledHandler);
|
|
}
|
|
else {
|
|
this._emitter.once(CancelToken_1.CancelTokenEvents.CANCEL_FINISHED, canceledHandler);
|
|
}
|
|
}).then(() => {
|
|
this.clear();
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Wraps a promise with a token and adds to this session
|
|
* @param {Promise<T>} promise
|
|
* @returns {Promise<T>}
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
wrap(promise) {
|
|
const token = new CancelToken_1.CancelToken(promise);
|
|
return this.addToken(token);
|
|
}
|
|
wrapCallback(callback, noErrorParam = false) {
|
|
let externalCallback;
|
|
const token = new CancelToken_1.CancelToken(new Promise((resolve, reject) => {
|
|
externalCallback = (error, data) => {
|
|
const args = Array.prototype.slice.call(arguments);
|
|
if (noErrorParam) {
|
|
// If we are in a non-standard callback
|
|
resolve(args);
|
|
}
|
|
else {
|
|
// If we are in a standard callback
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
else {
|
|
// Remove first argument in arguments list (since it's a null error)
|
|
args.splice(0, 1);
|
|
resolve(args);
|
|
}
|
|
}
|
|
};
|
|
}));
|
|
token.promise = token.promise
|
|
.then(data => {
|
|
callback(null, ...data);
|
|
}).catch(error => {
|
|
callback(error);
|
|
});
|
|
this.addToken(token);
|
|
return externalCallback;
|
|
}
|
|
/**
|
|
* Adds a cancel token to this session
|
|
* @template T
|
|
* @param {CancelToken} token
|
|
* @memberOf CancelTokenSession
|
|
*/
|
|
addToken(token) {
|
|
if (this._isCanceling) {
|
|
throw new Error(`Can't add new token when session is canceling`);
|
|
}
|
|
this._outstanding.add(token);
|
|
// We remove the token from the list out outstanding promises regardless of outcome
|
|
return token.promise
|
|
.then((data) => {
|
|
this._removeOutstanding(token);
|
|
return data; // Pass data forward to the caller
|
|
})
|
|
.catch(error => {
|
|
this._removeOutstanding(token);
|
|
throw error; // Allows caller code to handle error
|
|
});
|
|
}
|
|
/**
|
|
* Clears the current state of the promise session
|
|
*/
|
|
clear() {
|
|
this._outstanding.clear();
|
|
this._emitter.removeAllListeners();
|
|
this._isCanceling = false;
|
|
}
|
|
_removeOutstanding(token) {
|
|
this._outstanding.delete(token);
|
|
if (this._outstanding.size === 0) {
|
|
this._emitter.emit(CancelToken_1.CancelTokenEvents.ALL_DONE);
|
|
}
|
|
}
|
|
}
|
|
exports.CancelTokenSession = CancelTokenSession;
|
|
|
|
},{"./CancelToken":5,"events":undefined}],7:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class CircularBuffer {
|
|
/**
|
|
* Creates an instance of CircularBuffer.
|
|
* The circular buffer can contain up to 'capacity' elements
|
|
* and will overwrite oldest element upon insertion when at capacity
|
|
* @param {number} capacity - Capacity of this circular buffer
|
|
*
|
|
* @memberof CircularBuffer
|
|
*/
|
|
constructor(capacity) {
|
|
if (capacity < 0) {
|
|
throw new Error(`Capacity must be greater than or equal to 0`);
|
|
}
|
|
this._capacity = capacity;
|
|
this.clear();
|
|
}
|
|
/**
|
|
* Clears the buffer
|
|
* @memberof CircularBuffer
|
|
*/
|
|
clear() {
|
|
this._size = 0;
|
|
this._tail = 0;
|
|
this._data = [];
|
|
}
|
|
/**
|
|
* Returns the current number of elements in buffer, will never exceed capacity
|
|
* @returns {number}
|
|
* @memberof CircularBuffer
|
|
*/
|
|
size() {
|
|
return this._size;
|
|
}
|
|
/**
|
|
* Returns the capacity of this buffer.
|
|
* @returns {number}
|
|
* @memberof CircularBuffer
|
|
*/
|
|
capacity() {
|
|
return this._capacity;
|
|
}
|
|
/**
|
|
* Adds an element to the buffer. If the size of the buffer is at capacity
|
|
* then the element will overwrite the oldest element
|
|
* @param {T} element
|
|
* @memberof CircularBuffer
|
|
*/
|
|
add(element) {
|
|
const index = (this._tail + this._size) % this._capacity;
|
|
this._data[index] = element;
|
|
if (this._size === this._capacity) {
|
|
this._incrementTail();
|
|
}
|
|
else {
|
|
this._size++;
|
|
}
|
|
}
|
|
/**
|
|
* Gets an element from the buffer at an index.
|
|
* index 0 is the first element
|
|
* index (this.size() - 1) is the last element
|
|
* @param {number} index
|
|
* @returns {T}
|
|
* @memberof CircularBuffer
|
|
*/
|
|
get(index) {
|
|
if (index < 0 || index >= this._size) {
|
|
throw Error(`Index needs to be >= 0 and < ${this._size}`);
|
|
}
|
|
const indToUse = (this._tail + index) % this._capacity;
|
|
return this._data[indToUse];
|
|
}
|
|
/**
|
|
* Removes the first (oldest) element in the buffer. Returns the element that was removed
|
|
* @returns {T}
|
|
* @memberof CircularBuffer
|
|
*/
|
|
removeTail() {
|
|
if (this._size === 0) {
|
|
throw Error(`Buffer is empty`);
|
|
}
|
|
const el = this.get(0);
|
|
this._incrementTail();
|
|
this._size--;
|
|
return el;
|
|
}
|
|
/**
|
|
* Removes the last (most recently added) element in the buffer. Returns the element that was removed
|
|
* @returns {T}
|
|
* @memberof CircularBuffer
|
|
*/
|
|
removeHead() {
|
|
if (this._size === 0) {
|
|
throw Error(`Buffer is empty`);
|
|
}
|
|
const el = this.get(this._size - 1);
|
|
this._size--;
|
|
return el;
|
|
}
|
|
/**
|
|
* Returns an array representation of the buffer.
|
|
* Copies all elements in order into an array
|
|
* @returns {T[]}
|
|
* @memberof CircularBuffer
|
|
*/
|
|
toArray() {
|
|
let out = new Array(this._size);
|
|
for (let i = 0; i < this._size; i++) {
|
|
out[i] = this.get(i);
|
|
}
|
|
return out;
|
|
}
|
|
_incrementTail() {
|
|
this._tail = (this._tail + 1) % this._capacity;
|
|
}
|
|
}
|
|
exports.CircularBuffer = CircularBuffer;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
/**
|
|
* A promise wrapper that exposes the resolve and reject methods of a promise
|
|
*/
|
|
class ExtPromiseWrapper {
|
|
constructor() {
|
|
this.promise = new Promise((resolve, reject) => {
|
|
this.resolve = resolve;
|
|
this.reject = reject;
|
|
});
|
|
}
|
|
}
|
|
exports.ExtPromiseWrapper = ExtPromiseWrapper;
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 5/12/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const asyncParallel = require("async-parallel");
|
|
const PromiseUtils_1 = require("./PromiseUtils");
|
|
const TestUtils_1 = require("./TestUtils");
|
|
const PathUtils_1 = require("./PathUtils");
|
|
const log_1 = require("../log");
|
|
const log = log_1.default.createChild('FileUtils');
|
|
const prify = PromiseUtils_1.PromiseUtils.promisify;
|
|
let onRobot = fs.existsSync('/var/jibo/identity.json');
|
|
class FileUtils {
|
|
/**
|
|
* Returns the root path of project
|
|
* @param {NodeModule|string} pathOrModule Path in project or NodeModule
|
|
* @returns {string}
|
|
* @deprecated
|
|
*/
|
|
static getProjectRoot(pathOrModule) {
|
|
log.warn(`'FileUtils.getProjectRoot' is deprecated, please use 'PathUtils.getProjectRoot'`);
|
|
return PathUtils_1.PathUtils.getProjectRoot(pathOrModule);
|
|
}
|
|
/**
|
|
* Returns the main export of a project, same as you would get if you
|
|
* did `let exp = require('project-name');`
|
|
* @param {NodeModule|string} pathOrModule Path in project or NodeModule
|
|
* @returns {any}
|
|
* @deprecated
|
|
*/
|
|
static getProjectMainExport(pathOrModule) {
|
|
log.warn(`'FileUtils.getProjectMainExport' is deprecated, please use 'TestUtils.getProjectMainExport'`);
|
|
return TestUtils_1.TestUtils.getProjectMainExport(pathOrModule);
|
|
}
|
|
/**
|
|
* Read file from disk and return promise
|
|
* fs.readFile doesn't ensure closing file descriptors and can run
|
|
* out of allowed maximum number of open files
|
|
* @param {string} filePath Path to file
|
|
* @param {string} [encoding='utf8'] Encoding of file
|
|
* @param {number} [chunkSize=512] How many bytes to read from file at a time
|
|
* @returns {Promise<string>}
|
|
*/
|
|
static readFile(filePath, encoding = 'utf8', chunkSize = 512) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let fd = yield prify(h => fs.open(filePath, 'r', h));
|
|
let buffer;
|
|
let bufferSize;
|
|
try {
|
|
const stats = yield prify(h => fs.fstat(fd, h));
|
|
bufferSize = stats.size;
|
|
buffer = new Buffer(bufferSize);
|
|
let bytesRead = 0;
|
|
while (bytesRead < bufferSize) {
|
|
let chunkSizeToUse = chunkSize;
|
|
if ((bytesRead + chunkSize) > bufferSize) {
|
|
chunkSizeToUse = (bufferSize - bytesRead);
|
|
}
|
|
yield prify(h => fs.read(fd, buffer, bytesRead, chunkSizeToUse, bytesRead, h));
|
|
bytesRead += chunkSizeToUse;
|
|
}
|
|
}
|
|
catch (error) {
|
|
throw error;
|
|
}
|
|
finally {
|
|
yield prify(h => fs.close(fd, h));
|
|
}
|
|
if (buffer) {
|
|
return buffer.toString(encoding, 0, bufferSize);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Finds all files of a certain extension in directories rooted at a certain
|
|
* base directory
|
|
* @param {String} baseDir The base directory path of the search
|
|
* @param {String} extension The extension of files to find
|
|
*/
|
|
static findAllFilesWithExt(baseDir, extension) {
|
|
let selector = (fileName) => {
|
|
let _extension = extension.toLowerCase();
|
|
let ext = path.extname(fileName.toLowerCase());
|
|
return (ext[0] === '.' && ext.substr(1) === _extension);
|
|
};
|
|
return FileUtils.findAllFiles(baseDir, selector);
|
|
}
|
|
/**
|
|
* Finds all files of a certain extension in directories rooted at a certain
|
|
* base directory
|
|
* @param {String} baseDir The base directory path of the search
|
|
* @param {Function} selector A function which takes a filename and returns boolean
|
|
* @param {number} [maxConcurrent=50] The number of maximum concurrent file system operations
|
|
* @return {Promise<string[]>}
|
|
*/
|
|
static findAllFiles(baseDir, selector, maxConcurrent = 50) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let files = [];
|
|
yield FileUtils._findAllFiles(baseDir, selector, files, maxConcurrent);
|
|
return files;
|
|
});
|
|
}
|
|
static _findAllFiles(baseDir, selector, out, maxConcurrent = 50) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let directories = [];
|
|
const _fileNames = yield prify(h => fs.readdir(baseDir, h));
|
|
// We open a file descriptor for each path
|
|
// Each of these will process one file
|
|
const filePromiseGenerators = _fileNames.map(f => {
|
|
let fullPath = path.resolve(baseDir, f);
|
|
return () => {
|
|
let fd;
|
|
return PromiseUtils_1.PromiseUtils.promisify(h => fs.open(fullPath, 'r', h))
|
|
.then(_fd => {
|
|
fd = _fd;
|
|
// Here we gather stats on the file descriptor
|
|
return prify(h => fs.fstat(fd, h));
|
|
})
|
|
.then(stat => {
|
|
// We determine which files are directories and which
|
|
// ones comply with our selector
|
|
if (stat.isDirectory()) {
|
|
directories.push(fullPath);
|
|
}
|
|
else if (selector(fullPath)) {
|
|
out.push(fullPath);
|
|
}
|
|
// Now we close the file descriptor
|
|
return prify(h => fs.close(fd, h));
|
|
});
|
|
};
|
|
});
|
|
// Here we chunk all the promise generators into max size chunks
|
|
// and process all the chunks in sequence
|
|
yield asyncParallel.invoke(filePromiseGenerators, maxConcurrent);
|
|
// We don't process directories in parallel since each will be
|
|
// opening file desctiptors in parallel
|
|
yield asyncParallel.invoke(directories.map(dir => {
|
|
return () => FileUtils._findAllFiles(dir, selector, out);
|
|
}), 1);
|
|
});
|
|
}
|
|
/**
|
|
* Checks to see if we are on the robot or in simulator
|
|
*/
|
|
static onRobot() {
|
|
return onRobot;
|
|
}
|
|
/**
|
|
* Search backward in path hierarchy.
|
|
*
|
|
* Example1: inputPath: '/root/foo/bar/bloop', name: 'glop.js'
|
|
* could output '/root/foo/glop.js' if it existed there, null otherwise
|
|
*
|
|
* Example2: inputPath: '/root/foo/bar/bloop', name: 'blip.js', nestedDirectories: ['test']
|
|
* could output '/root/test/blip.js' if it existed there, null otherwise
|
|
*
|
|
* @param {string} inputPath Starting point for search
|
|
* @param {string} name Folder or file name to find
|
|
* @param {string[]} [nestedDirectories] optional nested directories to search into at each level
|
|
* @returns {Promise<string|void>} Resolves with path or null if nothing found
|
|
*/
|
|
static searchBackwardInPath(inputPath, name, nestedDirectories) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let pathToUse = path.dirname(inputPath);
|
|
let paths = [];
|
|
FileUtils._gatherBackwardPaths(pathToUse, paths);
|
|
let ind = 0;
|
|
let nested = nestedDirectories || [];
|
|
return new Promise((resolve, reject) => {
|
|
let find = () => {
|
|
FileUtils._searchBackward(paths[ind++], name, nested)
|
|
.then(result => {
|
|
if (result) {
|
|
resolve(result);
|
|
}
|
|
else if (ind < paths.length) {
|
|
find();
|
|
}
|
|
else {
|
|
resolve(null);
|
|
}
|
|
}).catch(reject);
|
|
};
|
|
find();
|
|
});
|
|
});
|
|
}
|
|
static _gatherBackwardPaths(inputPath, collection) {
|
|
collection.push(path.resolve(inputPath));
|
|
let next = path.resolve(path.join(inputPath, '..'));
|
|
if (next === inputPath) {
|
|
return;
|
|
}
|
|
else {
|
|
FileUtils._gatherBackwardPaths(next, collection);
|
|
}
|
|
}
|
|
static _searchBackward(inputPath, name, nestedDirectories) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let paths = [path.join(inputPath, name)];
|
|
nestedDirectories.forEach(dir => paths.push(path.join(inputPath, dir, name)));
|
|
let ind = 0;
|
|
return new Promise(resolve => {
|
|
let find = () => {
|
|
let pathToUse = paths[ind++];
|
|
fs.exists(pathToUse, (exists) => {
|
|
if (exists) {
|
|
resolve(pathToUse);
|
|
}
|
|
else if (ind < paths.length) {
|
|
find();
|
|
}
|
|
else {
|
|
resolve(null);
|
|
}
|
|
});
|
|
};
|
|
find();
|
|
});
|
|
});
|
|
}
|
|
}
|
|
exports.FileUtils = FileUtils;
|
|
|
|
},{"../log":1,"./PathUtils":10,"./PromiseUtils":12,"./TestUtils":17,"async-parallel":undefined,"fs":undefined,"path":undefined}],10:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 9/25/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const findRoot = require('find-root');
|
|
class PathUtils {
|
|
/**
|
|
* Returns the root path of project
|
|
* @param {NodeModule|string} pathOrModule Path in project or NodeModule
|
|
* @returns {string}
|
|
*/
|
|
static getProjectRoot(pathOrModule) {
|
|
if (typeof pathOrModule === 'string') {
|
|
return findRoot(pathOrModule);
|
|
}
|
|
else if (pathOrModule.filename) {
|
|
return findRoot(pathOrModule.filename);
|
|
}
|
|
else {
|
|
throw new Error(`Can't find project root, invalid input: '${pathOrModule}'`);
|
|
}
|
|
}
|
|
}
|
|
exports.PathUtils = PathUtils;
|
|
|
|
},{"find-root":undefined}],11:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 4/4/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var PromiseQueueState;
|
|
(function (PromiseQueueState) {
|
|
PromiseQueueState[PromiseQueueState["PLAYING"] = 0] = "PLAYING";
|
|
PromiseQueueState[PromiseQueueState["NOT_PLAYING"] = 1] = "NOT_PLAYING";
|
|
})(PromiseQueueState = exports.PromiseQueueState || (exports.PromiseQueueState = {}));
|
|
class PromiseQueue {
|
|
constructor() {
|
|
this._queueEmptyPr = Promise.resolve();
|
|
this._state = PromiseQueueState.NOT_PLAYING;
|
|
this._queue = [];
|
|
}
|
|
/**
|
|
* Get the state of the PromiseQueue
|
|
*/
|
|
getState() {
|
|
return this._state;
|
|
}
|
|
/**
|
|
* Add a promise generator
|
|
* @param {PromiseProvider} promiseProvider Promise generator
|
|
*/
|
|
add(promiseProvider) {
|
|
this._queue.push(promiseProvider);
|
|
if (this._state !== PromiseQueueState.PLAYING) {
|
|
this._state = PromiseQueueState.PLAYING;
|
|
this._queueEmptyPr = new Promise((resolve, reject) => {
|
|
this._resolver = resolve;
|
|
this._rejector = reject;
|
|
});
|
|
this._playNext();
|
|
}
|
|
}
|
|
/**
|
|
* Returns a promise that gets resolved either immediately if queue is
|
|
* empty or as soon as the queue empties and/or rejects at first rejection of any
|
|
* promise in the queue
|
|
*
|
|
* @returns {Promise}
|
|
*/
|
|
waitUntilEmpty() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this._queueEmptyPr;
|
|
});
|
|
}
|
|
/**
|
|
* Clears current queue.
|
|
* If there is currently an outstanding promise then it will be unaffected
|
|
* by this method since it is not in the queue.
|
|
* Any promise from `waitUntilFinish` will be resolved when currently outstanding promise resolves;
|
|
*/
|
|
clear() {
|
|
this._queue = [];
|
|
}
|
|
/**
|
|
* Picks out next promise in queue and continues until all are resolved or one was rejected
|
|
* @private
|
|
*/
|
|
_playNext() {
|
|
if (this._queue.length > 0) {
|
|
let next = this._queue.shift();
|
|
next()
|
|
.then(() => this._playNext())
|
|
.catch((e) => {
|
|
this._state = PromiseQueueState.NOT_PLAYING;
|
|
this._queue = [];
|
|
this._rejector(e);
|
|
});
|
|
}
|
|
else {
|
|
this._state = PromiseQueueState.NOT_PLAYING;
|
|
this._resolver();
|
|
}
|
|
}
|
|
}
|
|
exports.PromiseQueue = PromiseQueue;
|
|
|
|
},{}],12:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 5/12/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const log_1 = require("../log");
|
|
const log = log_1.default.createChild('PromiseUtils');
|
|
class PromiseUtils {
|
|
/**
|
|
* Installs a global handler for unhandled rejected promises
|
|
* Makes sure to only install one instance.
|
|
*/
|
|
static catchUnhandledRejection() {
|
|
let gl = global;
|
|
if (!gl._hasInstalledUncaughtHandler) {
|
|
process.on('unhandledRejection', (reason, p) => {
|
|
log.error(`Unhandled Rejection at: Promise '${JSON.stringify(p)}'`);
|
|
if (reason instanceof Error) {
|
|
log.error(` message: ${reason.message}`);
|
|
log.error(` stack: ${reason.stack}`);
|
|
}
|
|
else {
|
|
log.error(reason);
|
|
}
|
|
});
|
|
gl._hasInstalledUncaughtHandler = true;
|
|
}
|
|
}
|
|
/**
|
|
* Returns promise that succeeds when the first input promise succeeds
|
|
* If all input promises fail, then the returned promise fails.
|
|
* @param {Promise<T>[]} promises
|
|
* @returns {Promise<T>}
|
|
*/
|
|
static firstToSucceed(promises) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((res, rej) => {
|
|
let errors = [];
|
|
let errorCount = 0;
|
|
for (let i = 0; i < promises.length; i++) {
|
|
promises[i].then(res).catch(e => {
|
|
errors[i] = e;
|
|
errorCount++;
|
|
if (errorCount === promises.length) {
|
|
rej(errors);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
}
|
|
static promisify(func, firstParamError = true) {
|
|
return new Promise((resolve, reject) => {
|
|
func((error, result) => {
|
|
if (firstParamError) {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
else {
|
|
resolve(result);
|
|
}
|
|
}
|
|
else {
|
|
// In this case it is assumed that the data is in the first argument
|
|
if (result) {
|
|
log.warn(`Data in second argument ignored`);
|
|
}
|
|
resolve(error);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* A method that allows awaiting a promise safely without using try/catch
|
|
* The return signature is an array that can be decontructed on use, and
|
|
* has a similar shape to a standard Node.js callback
|
|
* @param {Promise<T>} func
|
|
* @returns {Promise<[any, T]>}
|
|
*/
|
|
static to(promise) {
|
|
return promise
|
|
.then(data => [null, data])
|
|
.catch(err => [err, null]);
|
|
}
|
|
static promisifyTo(func, firstParamError = true) {
|
|
return PromiseUtils.to(PromiseUtils.promisify(func, firstParamError));
|
|
}
|
|
/**
|
|
* Resolve only if the passed-in promise resolves before the timeout
|
|
* Rejects with 'Timeout' if the timeout occurs before the promise resolves
|
|
* Passes through the rejection from the promise if it rejects before the
|
|
* timeout
|
|
* @param {Promise<T>} promise The promise to race against the timeout
|
|
* @param {number} timeoutMs Milliseconds before the timeout rejects the promise
|
|
* @param {string} [errorMessage] Error message to use on timeout reject
|
|
* @return {Promise<T>} The new promise that rejects on timeout
|
|
*/
|
|
static timeout(promise, timeoutMs, errorMessage) {
|
|
return new Promise((resolve, reject) => {
|
|
const timeoutHandle = setTimeout(() => {
|
|
reject(new Error(errorMessage || `Timeout of ${timeoutMs}ms`));
|
|
}, timeoutMs);
|
|
promise
|
|
.then(data => resolve(data))
|
|
.catch(error => reject(error))
|
|
.then(() => clearTimeout(timeoutHandle));
|
|
});
|
|
}
|
|
}
|
|
exports.PromiseUtils = PromiseUtils;
|
|
|
|
},{"../log":1}],13:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
* Contains Utilities related to random selection of items
|
|
*
|
|
* Created on 7/17/16.
|
|
* @author Sam Spaulding <sam.spaulding@jibo.com>
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class RandomUtils {
|
|
/**
|
|
* Returns a 'data' element from an array of objects with { data: Object, weight: number} fields
|
|
* selected at random with weight proportional to the weight value of the corresponding element
|
|
* normalised by the weights of the other elements
|
|
*
|
|
* @param {WeightedRandomData[]} inputs
|
|
* @returns {Object}
|
|
*/
|
|
static weightedRandomSample(inputs) {
|
|
let result = {};
|
|
let totalWeight = 0;
|
|
for (let element of inputs) {
|
|
totalWeight += element.weight;
|
|
}
|
|
const rand = Math.random() * totalWeight;
|
|
let ongoingWeight = 0;
|
|
for (let i = 0; i < inputs.length; ++i) {
|
|
// do not factor in 0 or negative weight elements
|
|
if (inputs[i].weight > 0) {
|
|
ongoingWeight += inputs[i].weight;
|
|
if (rand < ongoingWeight) {
|
|
result = inputs[i].data;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
exports.RandomUtils = RandomUtils;
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const events = require("events");
|
|
const uuid = require('uuid');
|
|
const log_1 = require("../log");
|
|
class Session {
|
|
constructor(options) {
|
|
this.options = options;
|
|
this.id = uuid.v4();
|
|
this.active = false;
|
|
this.hasBeenStopped = false;
|
|
}
|
|
/**
|
|
* Stops the session activity if possible
|
|
* @returns {(any | Promise<any>)}
|
|
* @memberOf Session
|
|
*/
|
|
stop() {
|
|
if (!this.hasBeenStopped && this.activity) {
|
|
this.hasBeenStopped = true;
|
|
return this.activity.stop();
|
|
}
|
|
}
|
|
/**
|
|
* Updates the session activity if possible
|
|
* @memberOf Session
|
|
*/
|
|
update() {
|
|
if (this.activity && this.activity.update) {
|
|
this.activity.update();
|
|
}
|
|
}
|
|
}
|
|
exports.Session = Session;
|
|
class SessionManager {
|
|
/**
|
|
* Creates an instance of SessionManager.
|
|
* @param {OpenMethod} openMethod - Is called to create a new session
|
|
* @param {() => void} done - Gets called when all sessions have naturally completed (i.e not when the Session is manually closed)
|
|
* @param {JiboLog} [parentLog] optional log implementation which we will create a child of
|
|
* @memberOf SessionManager
|
|
*/
|
|
constructor(openMethod, done, parentLog) {
|
|
this.openMethod = openMethod;
|
|
this.done = done;
|
|
this.isClosing = false;
|
|
this.emitter = new events.EventEmitter();
|
|
if (parentLog) {
|
|
this.log = parentLog.createChild('SessionManager');
|
|
}
|
|
else {
|
|
this.log = log_1.default.createChild('SessionManager');
|
|
}
|
|
}
|
|
/**
|
|
* Should be called when skill is opened
|
|
* @memberOf SessionManager
|
|
*/
|
|
open(options) {
|
|
if (this.current) {
|
|
this.current.active = false;
|
|
}
|
|
this.current = null;
|
|
this.pending = null;
|
|
this.isClosing = false;
|
|
this.emitter.removeAllListeners();
|
|
this.replaceSession(options);
|
|
}
|
|
/**
|
|
* Switches skill session
|
|
* @param {*} options
|
|
* @memberOf SessionManager
|
|
*/
|
|
replaceSession(options) {
|
|
this.isClosing = false;
|
|
const session = new Session(options);
|
|
if (this.current) {
|
|
// If we have a current session, we set this as pending and tell current session to stop
|
|
if (this.pending) {
|
|
this.log.debug('overriding pending');
|
|
}
|
|
else {
|
|
this.log.debug('setting pending');
|
|
}
|
|
this.pending = session;
|
|
this.current.stop();
|
|
}
|
|
else {
|
|
this.log.debug('starting session');
|
|
// We immediately open this session
|
|
this._startSession(session);
|
|
}
|
|
}
|
|
/**
|
|
* Stops current session and waits for it to finish.
|
|
* After any call to this method you have to call `open` again
|
|
* @returns {Promise<any>}
|
|
* @memberOf SessionManager
|
|
*/
|
|
close() {
|
|
this.isClosing = true;
|
|
this.pending = null;
|
|
let pr = Promise.resolve();
|
|
if (this.current) {
|
|
const ret = this.current.stop();
|
|
if (ret instanceof Promise) {
|
|
pr = ret;
|
|
}
|
|
}
|
|
return pr.then(() => this.waitForCurrent());
|
|
}
|
|
/**
|
|
* Waits for the current session to complete, if no session is current then we resolve immediately
|
|
* @returns {Promise<any>}
|
|
* @memberOf SessionManager
|
|
*/
|
|
waitForCurrent() {
|
|
if (this.current) {
|
|
return this.current.activity.promise;
|
|
}
|
|
else {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
/**
|
|
* Waits for all sessions to complete, if no session is current then we resolve immediately
|
|
* @returns {Promise<any>}
|
|
* @memberOf SessionManager
|
|
*/
|
|
waitForAll() {
|
|
if (this.current) {
|
|
return new Promise(resolve => {
|
|
this.emitter.once('done', resolve);
|
|
});
|
|
}
|
|
else {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
_startSession(session) {
|
|
this.current = session;
|
|
session.active = true;
|
|
session.activity = this.openMethod(session.options);
|
|
session.activity.promise = session.activity.promise
|
|
.catch(err => this.log.error(err))
|
|
.then(() => {
|
|
this.log.debug(`Session finished`);
|
|
const isCurrent = (this.current === session);
|
|
// If this session is the current one, then we set it to null
|
|
if (isCurrent) {
|
|
this.current = null;
|
|
}
|
|
session.active = false;
|
|
// If there is a pending session, we open that one
|
|
if (this.pending) {
|
|
this.log.debug(`Starting pending`);
|
|
const next = this.pending;
|
|
this.pending = null;
|
|
this._startSession(next);
|
|
}
|
|
else {
|
|
// If we are not in the process of closing (e.g. from manually closing the session) then we call the done callback
|
|
if (isCurrent && !this.isClosing) {
|
|
this.log.debug(`Calling done`);
|
|
this.done();
|
|
}
|
|
this.emitter.emit('done');
|
|
}
|
|
});
|
|
}
|
|
}
|
|
exports.SessionManager = SessionManager;
|
|
|
|
},{"../log":1,"events":undefined,"uuid":undefined}],15:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 7/11/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const child_process_1 = require("child_process");
|
|
class ProcessResult {
|
|
}
|
|
exports.ProcessResult = ProcessResult;
|
|
class TerminalUtils {
|
|
/**
|
|
* Runs a terminal command
|
|
* @param {string} cmd Command to run
|
|
* @param {string[]} [args] Arguments to command
|
|
* @param {string} [cwd] Working directory to execute command
|
|
* @returns {Promise<T>}
|
|
*/
|
|
static run(cmd, args, cwd) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => {
|
|
let inst = cwd ? child_process_1.spawn(cmd, args, { cwd }) : child_process_1.spawn(cmd, args);
|
|
let res = new ProcessResult();
|
|
inst.stdout.on('data', (data) => {
|
|
res.stdout = new Buffer(data).toString('utf8', 0);
|
|
});
|
|
inst.stderr.on('data', (data) => {
|
|
res.stderr = new Buffer(data).toString('utf8', 0);
|
|
});
|
|
inst.on('error', (err) => {
|
|
res.error = err;
|
|
res.code = err.code;
|
|
reject(res);
|
|
});
|
|
inst.on('close', (code) => {
|
|
res.code = code;
|
|
if (code === 0) {
|
|
resolve(res);
|
|
}
|
|
else {
|
|
reject(res);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
}
|
|
exports.TerminalUtils = TerminalUtils;
|
|
|
|
},{"child_process":undefined}],16:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 9/24/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const FileUtils_1 = require("./FileUtils");
|
|
const events_1 = require("events");
|
|
var Type;
|
|
(function (Type) {
|
|
Type["NUMBER"] = "NUMBER";
|
|
Type["BOOLEAN"] = "BOOLEAN";
|
|
Type["STRING"] = "STRING";
|
|
})(Type = exports.Type || (exports.Type = {}));
|
|
/**
|
|
* Parses a boolean value
|
|
* @param {string|boolean} input
|
|
* @return {boolean}
|
|
*/
|
|
function getBoolean(input) {
|
|
if (typeof input === 'boolean') {
|
|
return input;
|
|
}
|
|
else if (typeof input === 'string') {
|
|
return !!JSON.parse(input.toLowerCase());
|
|
}
|
|
else {
|
|
throw new Error(`Can't parse boolean '${input}'`);
|
|
}
|
|
}
|
|
/**
|
|
* @class TestConfiguration
|
|
*/
|
|
class TestConfiguration extends events_1.EventEmitter {
|
|
constructor(namespace) {
|
|
super();
|
|
this.namespace = namespace;
|
|
this._hasTestData = false;
|
|
}
|
|
/**
|
|
* Initializes test configuration from test file (if it exists)
|
|
* Should be called after all value providers have been provided
|
|
* @param {string} [pathToTestConfig] Path to test config file
|
|
* @return {Promise<boolean>} True if test configuration loaded, false otherwise
|
|
*/
|
|
init(pathToTestConfig) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let data;
|
|
try {
|
|
data = yield FileUtils_1.FileUtils.readFile(pathToTestConfig);
|
|
}
|
|
catch (error) {
|
|
// Skipping file read error (since file might not exist)
|
|
}
|
|
if (data) {
|
|
try {
|
|
data = JSON.parse(data);
|
|
}
|
|
catch (error) {
|
|
throw new Error(`Error parsing test config '${pathToTestConfig}': ${error}`);
|
|
}
|
|
// If the test data object is enabled and has our namespace
|
|
const enabled = getBoolean(data.enabled);
|
|
if (enabled && data[this.namespace]) {
|
|
this._data = data[this.namespace];
|
|
// Verify test values
|
|
// TOFIX check if test names are expected
|
|
this._hasTestData = true;
|
|
return true;
|
|
}
|
|
}
|
|
if (!this._data) {
|
|
this._data = {};
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Returns true if this class has loaded a valid test configuration
|
|
* and that it is enabled
|
|
* @return {boolean}
|
|
*/
|
|
hasEnabledTestConfig() {
|
|
return this._hasTestData;
|
|
}
|
|
/**
|
|
* Returns true if this class has an overriding test configuration
|
|
* @return {boolean}
|
|
*/
|
|
hasOverridingTestConfig() {
|
|
return !!this._testConfig;
|
|
}
|
|
/**
|
|
* Clears the overriding test config
|
|
*/
|
|
clearOverridingTestConfig() {
|
|
this._testConfig = null;
|
|
}
|
|
/**
|
|
* Sets the overriding test config. If null then test config is disabled
|
|
* @param {Object} testConfig Null to disable
|
|
*/
|
|
setOverridingTestConfig(testConfig) {
|
|
this._testConfig = testConfig;
|
|
if (testConfig) {
|
|
// Verify values
|
|
// TOFIX check if test names are expected
|
|
}
|
|
}
|
|
/**
|
|
* Waits for event emitted on this object
|
|
* @param {string} name
|
|
* @return {Promise<void>}
|
|
*/
|
|
waitForEvent(name) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise(resolve => {
|
|
this.once(name, () => resolve());
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* A number value getter
|
|
* @param {string} name
|
|
* @param {function} [provider] A provider of the real value in case it doesn't exist in test config
|
|
* @return {Promise<number|null>}
|
|
*/
|
|
getNumberFromTestConfig(name, provider) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const val = yield this._getFromTestConfig(name, Type.NUMBER);
|
|
if (val !== null) {
|
|
return parseFloat(val);
|
|
}
|
|
else if (provider) {
|
|
return Promise.resolve(provider());
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* A string value getter
|
|
* @param {string} name
|
|
* @param {function} [provider] A provider of the real value in case it doesn't exist in test config
|
|
* @return {Promise<string|null>}
|
|
*/
|
|
getStringFromTestConfig(name, provider) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const val = yield this._getFromTestConfig(name, Type.STRING);
|
|
if (val !== null) {
|
|
return (typeof val === 'string') ? val : ('' + val);
|
|
}
|
|
else if (provider) {
|
|
return Promise.resolve(provider());
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* A boolean value getter
|
|
* @param {string} name
|
|
* @param {function} [provider] A provider of the real value in case it doesn't exist in test config
|
|
* @return {Promise<boolean|null>}
|
|
*/
|
|
getBooleanFromTestConfig(name, provider) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const val = yield this._getFromTestConfig(name, Type.BOOLEAN);
|
|
if (val !== null) {
|
|
return getBoolean(val);
|
|
}
|
|
else if (provider) {
|
|
return Promise.resolve(provider());
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* A generic value getter
|
|
* @param {string} name
|
|
* @param {Type} type
|
|
* @return {Promise<any>}
|
|
* @private
|
|
*/
|
|
_getFromTestConfig(name, type) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!this._data) {
|
|
throw new Error(`Test configuration '${this.namespace}' is not initialized`);
|
|
}
|
|
// TOFIX check if value name is expected and type thereof
|
|
// If we find the data in the overriding test file
|
|
if (this._testConfig && this._testConfig[name] !== undefined) {
|
|
return this._testConfig[name];
|
|
}
|
|
else if (this._data[name] !== undefined) {
|
|
return this._data[name];
|
|
}
|
|
return null;
|
|
});
|
|
}
|
|
}
|
|
exports.TestConfiguration = TestConfiguration;
|
|
|
|
},{"./FileUtils":9,"events":undefined}],17:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* @fileOverview
|
|
*
|
|
* Created on 7/17/16.
|
|
* @author Siggi Orn <siggi@jibo.com>
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const PathUtils_1 = require("./PathUtils");
|
|
const path = require("path");
|
|
class NameSpace {
|
|
constructor(name) {
|
|
this.name = name;
|
|
/**
|
|
* A container for test dates
|
|
* @type {Map<string, Date>}
|
|
*/
|
|
this.dateById = new Map();
|
|
/**
|
|
* A container for test random numbers
|
|
* @type {Map<string, Date>}
|
|
*/
|
|
this.randomById = new Map();
|
|
// lint noop
|
|
}
|
|
/**
|
|
* Clear all installed tests
|
|
*/
|
|
clear() {
|
|
this.dateById.clear();
|
|
this.randomById.clear();
|
|
}
|
|
}
|
|
exports.NameSpace = NameSpace;
|
|
const defaultNamespace = new NameSpace('');
|
|
const nameSpaces = new Map();
|
|
nameSpaces.set('', defaultNamespace);
|
|
nameSpaces.set('default', defaultNamespace);
|
|
/**
|
|
* Whether testing is enabled or not
|
|
* @type {boolean}
|
|
*/
|
|
let enableTest = false;
|
|
/**
|
|
* A function that returns a date
|
|
* @type {Function}
|
|
* @returns {Date}
|
|
*/
|
|
let realDateProvider = () => {
|
|
return new Date();
|
|
};
|
|
/**
|
|
* A function that returns a random number [0,1)
|
|
* @type {Function}
|
|
* @returns {number}
|
|
*/
|
|
let realRandomProvider = () => {
|
|
return Math.random();
|
|
};
|
|
class TestUtils {
|
|
/**
|
|
* Returns the main export of a project, same as you would get if you
|
|
* did `let exp = require('project-name');`
|
|
* @param {NodeModule|string} pathOrModule Path in project or NodeModule
|
|
* @returns {any}
|
|
*/
|
|
static getProjectMainExport(pathOrModule) {
|
|
let root = PathUtils_1.PathUtils.getProjectRoot(pathOrModule);
|
|
let pack = require(path.join(root, 'package.json'));
|
|
return require(path.join(root, pack.main));
|
|
}
|
|
/**
|
|
* Clear all tests in all namespaces
|
|
*/
|
|
static clearAllTests() {
|
|
nameSpaces.forEach(ns => ns.clear());
|
|
}
|
|
/**
|
|
* Clear all tests in namespace
|
|
* @param {string} [namespace=''] name of namespace
|
|
*/
|
|
static clearTests(namespace) {
|
|
let nsName = namespace || '';
|
|
let ns = nameSpaces.get(nsName);
|
|
if (ns) {
|
|
ns.clear();
|
|
}
|
|
}
|
|
/**
|
|
* Turn on/off testing
|
|
* @param {boolean} enable
|
|
*/
|
|
static enableTesting(enable) {
|
|
enableTest = enable;
|
|
}
|
|
/**
|
|
* Returns namespace, if undefined then returns default namespace
|
|
* @param namespace
|
|
* @returns {any}
|
|
*/
|
|
static getNamespace(namespace) {
|
|
if (!namespace) {
|
|
return defaultNamespace;
|
|
}
|
|
else {
|
|
let ns = nameSpaces.get(namespace);
|
|
if (!ns) {
|
|
ns = new NameSpace(namespace);
|
|
nameSpaces.set(namespace, ns);
|
|
}
|
|
return ns;
|
|
}
|
|
}
|
|
/**
|
|
* Provides a test ID for a particular date
|
|
* @param {Date} date
|
|
* @param {string} id
|
|
* @param {string} [namespace='']
|
|
*/
|
|
static setTestDate(date, id, namespace) {
|
|
let ns = TestUtils.getNamespace(namespace);
|
|
ns.dateById.set(id, date);
|
|
}
|
|
/**
|
|
* Returns a Date object. If testing is enabled and an id is
|
|
* provided then the provided date will be returned
|
|
* @param {string} [id] Test id
|
|
* @param {string} [namespace='']
|
|
* @returns {Date}
|
|
*/
|
|
static getDate(id, namespace) {
|
|
if (enableTest && id) {
|
|
let ns = TestUtils.getNamespace(namespace);
|
|
let testDate = ns.dateById.get(id);
|
|
if (testDate) {
|
|
return testDate;
|
|
}
|
|
}
|
|
return realDateProvider();
|
|
}
|
|
/**
|
|
* Provides a test ID for a particular random number
|
|
* @param {number} randomNum
|
|
* @param {string} id
|
|
* @param {string} [namespace='']
|
|
*/
|
|
static setTestRandom(randomNum, id, namespace) {
|
|
let ns = TestUtils.getNamespace(namespace);
|
|
ns.randomById.set(id, randomNum);
|
|
}
|
|
/**
|
|
* Returns a random number. If testing is enabled and an id is
|
|
* provided then the provided random number will be returned
|
|
* @param {string} [id] Test id
|
|
* @param {string} [namespace]
|
|
* @returns {number}
|
|
*/
|
|
static getRandom(id, namespace) {
|
|
if (enableTest && id) {
|
|
let ns = TestUtils.getNamespace(namespace);
|
|
let random = ns.randomById.get(id);
|
|
if (random) {
|
|
return random;
|
|
}
|
|
}
|
|
return realRandomProvider();
|
|
}
|
|
}
|
|
exports.TestUtils = TestUtils;
|
|
|
|
},{"./PathUtils":10,"path":undefined}],18:[function(require,module,exports){
|
|
"use strict";
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const _ = require("lodash/lodash.min");
|
|
let _timeOutFunc = setTimeout;
|
|
class DefaultDateProvider {
|
|
getDate() {
|
|
return new Date();
|
|
}
|
|
}
|
|
exports.DefaultDateProvider = DefaultDateProvider;
|
|
var PartOfDayBasic;
|
|
(function (PartOfDayBasic) {
|
|
PartOfDayBasic["MORNING"] = "MORNING";
|
|
PartOfDayBasic["AFTERNOON"] = "AFTERNOON";
|
|
PartOfDayBasic["EVENING"] = "EVENING";
|
|
PartOfDayBasic["NIGHT"] = "NIGHT";
|
|
})(PartOfDayBasic = exports.PartOfDayBasic || (exports.PartOfDayBasic = {}));
|
|
var PartOfDayDetail;
|
|
(function (PartOfDayDetail) {
|
|
PartOfDayDetail["EARLY"] = "EARLY";
|
|
PartOfDayDetail["MID"] = "MID";
|
|
PartOfDayDetail["LATE"] = "LATE";
|
|
})(PartOfDayDetail = exports.PartOfDayDetail || (exports.PartOfDayDetail = {}));
|
|
// array of {time: {hour: number, minute: number}, pod: PartOfDay}
|
|
// to find current part of day, iterate through the array
|
|
const EARLY_MORNING_MINUTES = 45;
|
|
const EARLY_MORNING_HOURS = 4;
|
|
exports.PartOfDayTimes = [
|
|
{ time: { hour: 0, minute: 0 }, pod: { basic: PartOfDayBasic.NIGHT, detail: PartOfDayDetail.MID } },
|
|
{ time: { hour: 2, minute: 0 }, pod: { basic: PartOfDayBasic.NIGHT, detail: PartOfDayDetail.LATE } },
|
|
{ time: { hour: EARLY_MORNING_HOURS, minute: EARLY_MORNING_MINUTES }, pod: { basic: PartOfDayBasic.MORNING, detail: PartOfDayDetail.EARLY } },
|
|
{ time: { hour: 6, minute: 45 }, pod: { basic: PartOfDayBasic.MORNING, detail: PartOfDayDetail.MID } },
|
|
{ time: { hour: 10, minute: 0 }, pod: { basic: PartOfDayBasic.MORNING, detail: PartOfDayDetail.LATE } },
|
|
{ time: { hour: 12, minute: 0 }, pod: { basic: PartOfDayBasic.AFTERNOON, detail: PartOfDayDetail.EARLY } },
|
|
{ time: { hour: 14, minute: 0 }, pod: { basic: PartOfDayBasic.AFTERNOON, detail: PartOfDayDetail.MID } },
|
|
{ time: { hour: 16, minute: 0 }, pod: { basic: PartOfDayBasic.AFTERNOON, detail: PartOfDayDetail.LATE } },
|
|
{ time: { hour: 18, minute: 0 }, pod: { basic: PartOfDayBasic.EVENING, detail: PartOfDayDetail.EARLY } },
|
|
{ time: { hour: 20, minute: 0 }, pod: { basic: PartOfDayBasic.EVENING, detail: PartOfDayDetail.MID } },
|
|
{ time: { hour: 21, minute: 0 }, pod: { basic: PartOfDayBasic.EVENING, detail: PartOfDayDetail.LATE } },
|
|
{ time: { hour: 22, minute: 0 }, pod: { basic: PartOfDayBasic.NIGHT, detail: PartOfDayDetail.EARLY } },
|
|
];
|
|
class TimeUtils {
|
|
/**
|
|
* Sets the date provider that should be used by TimeUtils
|
|
* @param {DateProvider} dateProvider
|
|
*/
|
|
static setDateProvider(dateProvider) {
|
|
TimeUtils._dateProvider = dateProvider;
|
|
}
|
|
/**
|
|
* Provide the timeout function to use in all time utilities
|
|
* @param {Function.<Function, number>} timeoutFunc
|
|
*/
|
|
static setTimeoutFunction(timeoutFunc) {
|
|
_timeOutFunc = timeoutFunc;
|
|
}
|
|
/**
|
|
* Waits for timeMs and then resolves the promise
|
|
* @param {number} timeMs Time to wait in ms
|
|
* @returns {Promise<void>}
|
|
*/
|
|
static wait(timeMs) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((res) => {
|
|
_timeOutFunc(res, timeMs);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Dispatch a timeline of actions
|
|
* @param {TimelineElement[]} timeline
|
|
* @returns {Promise<void>}
|
|
*/
|
|
static dispatchTimeline(timeline) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let startTime = process.hrtime();
|
|
let promiseChain = Promise.resolve();
|
|
timeline.forEach(el => {
|
|
promiseChain = promiseChain
|
|
.then(() => TimeUtils._dispatchTimeline(el, startTime));
|
|
});
|
|
return promiseChain;
|
|
});
|
|
}
|
|
static _dispatchTimeline(el, startTime) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let timeDiff = process.hrtime(startTime);
|
|
let passedTimeMs = timeDiff[0] * 1e3 + timeDiff[1] * 1e-6;
|
|
let timeToWait = Math.max(0, el.timeMs - passedTimeMs);
|
|
return TimeUtils.wait(timeToWait).then(() => el.action());
|
|
});
|
|
}
|
|
/**
|
|
* returns the current part of day (morning, afternoon, evening, night)
|
|
* @param {Date} [date] Optional date, defaults to using date provider
|
|
* @returns {PartOfDay}
|
|
*/
|
|
static getPartOfDay(date) {
|
|
date = date || TimeUtils._dateProvider.getDate();
|
|
let hours = date.getHours();
|
|
let minutes = date.getMinutes();
|
|
let pod;
|
|
// we iterate through the PoD time boundaries in chronological order
|
|
for (let i = exports.PartOfDayTimes.length - 1; i >= 0; i--) {
|
|
// iterate backwards through the defined parts of day.
|
|
// when we get to one whose start time is ealier than the input time, we've found our match
|
|
pod = exports.PartOfDayTimes[i].pod;
|
|
let podtime = exports.PartOfDayTimes[i].time;
|
|
if ((podtime.hour < hours) ||
|
|
(podtime.hour === hours && podtime.minute <= minutes)) {
|
|
break;
|
|
}
|
|
}
|
|
return _.cloneDeep(pod);
|
|
}
|
|
/**
|
|
* Returns whether it is early in the morning (between 4:30 and 7 am)
|
|
* This method exists for backward compatibility, but PartOfDay now provides this info directly
|
|
* @param {Date} [date] Optional date, defaults to using date provider
|
|
* @returns {boolean}
|
|
*
|
|
*/
|
|
static isEarlyMorning(date) {
|
|
date = date || TimeUtils._dateProvider.getDate();
|
|
let pod = TimeUtils.getPartOfDay(date);
|
|
return (pod.basic === PartOfDayBasic.MORNING && pod.detail === PartOfDayDetail.EARLY);
|
|
}
|
|
/**
|
|
* Converts milliseconds to seconds
|
|
* @param ms {number}
|
|
* @returns {number}
|
|
*/
|
|
static msToSeconds(ms) {
|
|
return ms / (1000);
|
|
}
|
|
/**
|
|
* Converts milliseconds to minutes
|
|
* @param ms {number}
|
|
* @returns {number}
|
|
*/
|
|
static msToMinutes(ms) {
|
|
return ms / (60 * 1000);
|
|
}
|
|
/**
|
|
* Converts milliseconds to hours
|
|
* @param ms {number}
|
|
* @returns {number}
|
|
*/
|
|
static msToHours(ms) {
|
|
return ms / (60 * 60 * 1000);
|
|
}
|
|
/**
|
|
* Converts seconds to milliseconds
|
|
* @param seconds {number}
|
|
* @returns {number}
|
|
*/
|
|
static secondsToMs(seconds) {
|
|
return seconds * 1000;
|
|
}
|
|
/**
|
|
* Converts minutes to milliseconds
|
|
* @param minutes {number}
|
|
* @returns {number}
|
|
*/
|
|
static minutesToMs(minutes) {
|
|
return minutes * 60 * 1000;
|
|
}
|
|
/**
|
|
* Converts hours to milliseconds
|
|
* @param hours {number}
|
|
* @returns {number}
|
|
*/
|
|
static hoursToMs(hours) {
|
|
return hours * 60 * 60 * 1000;
|
|
}
|
|
/**
|
|
* Turns a string date of the format yyyy-mm-dd into a Date object
|
|
* Does not take time into consideration
|
|
* @param {String} date to convert in the form yyyy-mm-dd
|
|
* @returns {Date}
|
|
*/
|
|
static dateFromString(date) {
|
|
let retVal = null;
|
|
try {
|
|
let yyyymmdd = date.split('-');
|
|
// Attempt to enforce date format (and skip time)
|
|
if (yyyymmdd.length !== 3) {
|
|
throw 'Invalid Date Format';
|
|
}
|
|
retVal = new Date(Number(yyyymmdd[0]), Number(yyyymmdd[1]) - 1, Number(yyyymmdd[2]));
|
|
}
|
|
catch (_a) {
|
|
console.error(`TimeUtils: Attempted to make date from malformed string: ${date}. Requires format yyyy-mm-dd. Returning null.`);
|
|
retVal = null;
|
|
}
|
|
return retVal;
|
|
}
|
|
/**
|
|
* Check whether a queried date is within the start and end date.
|
|
* If no end date is provided just check whether the query date is the same as the start date.
|
|
* Does not take time into consideration.
|
|
* @param {Date} startDate of interval
|
|
* @param {Date} queryDate to check
|
|
* @param {Date} endDate of interval
|
|
* @returns {boolean}
|
|
*/
|
|
static dateWithinInterval(startDate, queryDate, endDate) {
|
|
let withinInterval = false;
|
|
if (!endDate) {
|
|
endDate = startDate;
|
|
}
|
|
// Make sure that all 3 dates are time insensitive
|
|
const startDate_rounded = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
|
|
const queryDate_rounded = new Date(queryDate.getFullYear(), queryDate.getMonth(), queryDate.getDate());
|
|
const endDate_rounded = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate());
|
|
if (startDate_rounded.getTime() <= queryDate_rounded.getTime() && queryDate_rounded.getTime() <= endDate_rounded.getTime()) {
|
|
withinInterval = true;
|
|
}
|
|
return withinInterval;
|
|
}
|
|
/**
|
|
* Check whether the two ms times are on the same day. A new day starts at EARLY-MORNING pod (4:45am)
|
|
* @param {number} ms1 of first time
|
|
* @param {number} ms2 of second time
|
|
*/
|
|
static sameDay(ms1, ms2) {
|
|
const date1 = new Date(ms1);
|
|
const date2 = new Date(ms2);
|
|
// Edge case where different days are within 24 hours. Could be in different months.
|
|
let same = true;
|
|
const diff = Math.abs(ms2 - ms1) / this.hoursToMs(1);
|
|
if (diff < 24) {
|
|
// Is the later of the two dates after EARLY MORNING?
|
|
const earlierDate = (date1 <= date2) ? date1 : date2;
|
|
const laterDate = (date1 > date2) ? date1 : date2;
|
|
const earlyMorning = new Date(laterDate.getFullYear(), laterDate.getMonth(), laterDate.getDate(), EARLY_MORNING_HOURS, EARLY_MORNING_MINUTES);
|
|
same = !((earlierDate < earlyMorning) && (earlyMorning < laterDate)); // The dates are not separated by an early morning
|
|
}
|
|
else {
|
|
same = false;
|
|
}
|
|
return same;
|
|
}
|
|
}
|
|
/**
|
|
* A class that can provide dates (defaults to `new Date()`)
|
|
* @type {DateProvider}
|
|
* @private
|
|
*/
|
|
TimeUtils._dateProvider = new DefaultDateProvider();
|
|
exports.TimeUtils = TimeUtils;
|
|
|
|
},{"lodash/lodash.min":undefined}],19:[function(require,module,exports){
|
|
"use strict";
|
|
/**
|
|
* Created by Andrew Stout on 6/28/16, based on prior work by Siggi Orn.
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class Updatable {
|
|
constructor() {
|
|
this.updatables = new Set();
|
|
// lint noop
|
|
}
|
|
/**
|
|
* Should get called from the main update loop.
|
|
* Iterates through all registered updatables and updates them
|
|
*/
|
|
update(elapsed) {
|
|
//for(let callback of this.updatables) {
|
|
this.updatables.forEach((callback) => {
|
|
callback(elapsed); // this should probably be made asynchronous at some point
|
|
});
|
|
}
|
|
/**
|
|
* Add a function to be called on every update of loop.
|
|
* If this function has already been added then this has no effect.
|
|
* @param {function} callback Function to be called at every update.
|
|
* The callback function takes a parameter of the form [seconds, milliseconds]
|
|
* @returns {boolean} false if callback existed in collection and
|
|
* was therefore not added.
|
|
*/
|
|
add(callback) {
|
|
let exists = this.updatables.has(callback);
|
|
this.updatables.add(callback);
|
|
return !exists;
|
|
}
|
|
/**
|
|
* Stop updating a function on every update of loop
|
|
* @param {function} callback Function to be removed from update loop
|
|
* @returns {boolean}
|
|
*/
|
|
remove(callback) {
|
|
return this.updatables.delete(callback);
|
|
}
|
|
}
|
|
exports.Updatable = Updatable;
|
|
|
|
},{}],20:[function(require,module,exports){
|
|
"use strict";
|
|
function __export(m) {
|
|
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__export(require("./ActionTimeline"));
|
|
__export(require("./CacheUtils"));
|
|
__export(require("./CancelToken"));
|
|
__export(require("./CancelTokenSession"));
|
|
__export(require("./ExtPromiseWrapper"));
|
|
__export(require("./FileUtils"));
|
|
__export(require("./PathUtils"));
|
|
__export(require("./PromiseQueue"));
|
|
__export(require("./PromiseUtils"));
|
|
__export(require("./RandomUtils"));
|
|
__export(require("./SessionManager"));
|
|
__export(require("./CancelToken"));
|
|
__export(require("./CancelTokenSession"));
|
|
__export(require("./TerminalUtils"));
|
|
__export(require("./TestConfiguration"));
|
|
__export(require("./CacheManager"));
|
|
__export(require("./TestUtils"));
|
|
__export(require("./TimeUtils"));
|
|
__export(require("./Updatable"));
|
|
__export(require("./CircularBuffer"));
|
|
|
|
},{"./ActionTimeline":2,"./CacheManager":3,"./CacheUtils":4,"./CancelToken":5,"./CancelTokenSession":6,"./CircularBuffer":7,"./ExtPromiseWrapper":8,"./FileUtils":9,"./PathUtils":10,"./PromiseQueue":11,"./PromiseUtils":12,"./RandomUtils":13,"./SessionManager":14,"./TerminalUtils":15,"./TestConfiguration":16,"./TestUtils":17,"./TimeUtils":18,"./Updatable":19}],21:[function(require,module,exports){
|
|
"use strict";
|
|
function __export(m) {
|
|
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__export(require("./main"));
|
|
|
|
},{"./main":20}]},{},[21])(21)
|
|
});
|
|
|
|
//# sourceMappingURL=jibo-cai-utils.js.map
|