15759 lines
573 KiB
JavaScript
15759 lines
573 KiB
JavaScript
(function (exports) {
|
|
'use strict';
|
|
|
|
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
|
|
|
function getAugmentedNamespace(n) {
|
|
if (n.__esModule) return n;
|
|
var f = n.default;
|
|
if (typeof f == "function") {
|
|
var a = function a () {
|
|
if (this instanceof a) {
|
|
return Reflect.construct(f, arguments, this.constructor);
|
|
}
|
|
return f.apply(this, arguments);
|
|
};
|
|
a.prototype = f.prototype;
|
|
} else a = {};
|
|
Object.defineProperty(a, '__esModule', {value: true});
|
|
Object.keys(n).forEach(function (k) {
|
|
var d = Object.getOwnPropertyDescriptor(n, k);
|
|
Object.defineProperty(a, k, d.get ? d : {
|
|
enumerable: true,
|
|
get: function () {
|
|
return n[k];
|
|
}
|
|
});
|
|
});
|
|
return a;
|
|
}
|
|
|
|
var main$1 = {};
|
|
|
|
var cjs$3 = {exports: {}};
|
|
|
|
var url$1 = {};
|
|
|
|
var cjs$2 = {};
|
|
|
|
var socket$2 = {};
|
|
|
|
var transports = {};
|
|
|
|
var pollingXhr = {};
|
|
|
|
var polling = {};
|
|
|
|
var transport = {};
|
|
|
|
var cjs$1 = {};
|
|
|
|
var encodePacket_browser = {};
|
|
|
|
var commons = {};
|
|
|
|
Object.defineProperty(commons, "__esModule", { value: true });
|
|
commons.ERROR_PACKET = commons.PACKET_TYPES_REVERSE = commons.PACKET_TYPES = void 0;
|
|
const PACKET_TYPES = Object.create(null); // no Map = no polyfill
|
|
commons.PACKET_TYPES = PACKET_TYPES;
|
|
PACKET_TYPES["open"] = "0";
|
|
PACKET_TYPES["close"] = "1";
|
|
PACKET_TYPES["ping"] = "2";
|
|
PACKET_TYPES["pong"] = "3";
|
|
PACKET_TYPES["message"] = "4";
|
|
PACKET_TYPES["upgrade"] = "5";
|
|
PACKET_TYPES["noop"] = "6";
|
|
const PACKET_TYPES_REVERSE = Object.create(null);
|
|
commons.PACKET_TYPES_REVERSE = PACKET_TYPES_REVERSE;
|
|
Object.keys(PACKET_TYPES).forEach((key) => {
|
|
PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
|
|
});
|
|
const ERROR_PACKET = { type: "error", data: "parser error" };
|
|
commons.ERROR_PACKET = ERROR_PACKET;
|
|
|
|
Object.defineProperty(encodePacket_browser, "__esModule", { value: true });
|
|
encodePacket_browser.encodePacket = void 0;
|
|
encodePacket_browser.encodePacketToBinary = encodePacketToBinary;
|
|
const commons_js_1$1 = commons;
|
|
const withNativeBlob$1 = typeof Blob === "function" ||
|
|
(typeof Blob !== "undefined" &&
|
|
Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
|
|
const withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
|
|
// ArrayBuffer.isView method is not defined in IE10
|
|
const isView$1 = (obj) => {
|
|
return typeof ArrayBuffer.isView === "function"
|
|
? ArrayBuffer.isView(obj)
|
|
: obj && obj.buffer instanceof ArrayBuffer;
|
|
};
|
|
const encodePacket = ({ type, data }, supportsBinary, callback) => {
|
|
if (withNativeBlob$1 && data instanceof Blob) {
|
|
if (supportsBinary) {
|
|
return callback(data);
|
|
}
|
|
else {
|
|
return encodeBlobAsBase64(data, callback);
|
|
}
|
|
}
|
|
else if (withNativeArrayBuffer$2 &&
|
|
(data instanceof ArrayBuffer || isView$1(data))) {
|
|
if (supportsBinary) {
|
|
return callback(data);
|
|
}
|
|
else {
|
|
return encodeBlobAsBase64(new Blob([data]), callback);
|
|
}
|
|
}
|
|
// plain string
|
|
return callback(commons_js_1$1.PACKET_TYPES[type] + (data || ""));
|
|
};
|
|
encodePacket_browser.encodePacket = encodePacket;
|
|
const encodeBlobAsBase64 = (data, callback) => {
|
|
const fileReader = new FileReader();
|
|
fileReader.onload = function () {
|
|
const content = fileReader.result.split(",")[1];
|
|
callback("b" + (content || ""));
|
|
};
|
|
return fileReader.readAsDataURL(data);
|
|
};
|
|
function toArray$1(data) {
|
|
if (data instanceof Uint8Array) {
|
|
return data;
|
|
}
|
|
else if (data instanceof ArrayBuffer) {
|
|
return new Uint8Array(data);
|
|
}
|
|
else {
|
|
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
|
|
}
|
|
}
|
|
let TEXT_ENCODER;
|
|
function encodePacketToBinary(packet, callback) {
|
|
if (withNativeBlob$1 && packet.data instanceof Blob) {
|
|
return packet.data.arrayBuffer().then(toArray$1).then(callback);
|
|
}
|
|
else if (withNativeArrayBuffer$2 &&
|
|
(packet.data instanceof ArrayBuffer || isView$1(packet.data))) {
|
|
return callback(toArray$1(packet.data));
|
|
}
|
|
encodePacket(packet, false, (encoded) => {
|
|
if (!TEXT_ENCODER) {
|
|
TEXT_ENCODER = new TextEncoder();
|
|
}
|
|
callback(TEXT_ENCODER.encode(encoded));
|
|
});
|
|
}
|
|
|
|
var decodePacket_browser = {};
|
|
|
|
var base64Arraybuffer = {};
|
|
|
|
Object.defineProperty(base64Arraybuffer, "__esModule", { value: true });
|
|
base64Arraybuffer.decode = base64Arraybuffer.encode = void 0;
|
|
// imported from https://github.com/socketio/base64-arraybuffer
|
|
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
// Use a lookup table to find the index.
|
|
const lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
|
|
for (let i = 0; i < chars.length; i++) {
|
|
lookup[chars.charCodeAt(i)] = i;
|
|
}
|
|
const encode$1 = (arraybuffer) => {
|
|
let bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';
|
|
for (i = 0; i < len; i += 3) {
|
|
base64 += chars[bytes[i] >> 2];
|
|
base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
|
|
base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
|
|
base64 += chars[bytes[i + 2] & 63];
|
|
}
|
|
if (len % 3 === 2) {
|
|
base64 = base64.substring(0, base64.length - 1) + '=';
|
|
}
|
|
else if (len % 3 === 1) {
|
|
base64 = base64.substring(0, base64.length - 2) + '==';
|
|
}
|
|
return base64;
|
|
};
|
|
base64Arraybuffer.encode = encode$1;
|
|
const decode$1 = (base64) => {
|
|
let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
|
|
if (base64[base64.length - 1] === '=') {
|
|
bufferLength--;
|
|
if (base64[base64.length - 2] === '=') {
|
|
bufferLength--;
|
|
}
|
|
}
|
|
const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
|
|
for (i = 0; i < len; i += 4) {
|
|
encoded1 = lookup[base64.charCodeAt(i)];
|
|
encoded2 = lookup[base64.charCodeAt(i + 1)];
|
|
encoded3 = lookup[base64.charCodeAt(i + 2)];
|
|
encoded4 = lookup[base64.charCodeAt(i + 3)];
|
|
bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
|
|
bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
|
|
bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
|
|
}
|
|
return arraybuffer;
|
|
};
|
|
base64Arraybuffer.decode = decode$1;
|
|
|
|
Object.defineProperty(decodePacket_browser, "__esModule", { value: true });
|
|
decodePacket_browser.decodePacket = void 0;
|
|
const commons_js_1 = commons;
|
|
const base64_arraybuffer_js_1 = base64Arraybuffer;
|
|
const withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
|
|
const decodePacket = (encodedPacket, binaryType) => {
|
|
if (typeof encodedPacket !== "string") {
|
|
return {
|
|
type: "message",
|
|
data: mapBinary(encodedPacket, binaryType),
|
|
};
|
|
}
|
|
const type = encodedPacket.charAt(0);
|
|
if (type === "b") {
|
|
return {
|
|
type: "message",
|
|
data: decodeBase64Packet(encodedPacket.substring(1), binaryType),
|
|
};
|
|
}
|
|
const packetType = commons_js_1.PACKET_TYPES_REVERSE[type];
|
|
if (!packetType) {
|
|
return commons_js_1.ERROR_PACKET;
|
|
}
|
|
return encodedPacket.length > 1
|
|
? {
|
|
type: commons_js_1.PACKET_TYPES_REVERSE[type],
|
|
data: encodedPacket.substring(1),
|
|
}
|
|
: {
|
|
type: commons_js_1.PACKET_TYPES_REVERSE[type],
|
|
};
|
|
};
|
|
decodePacket_browser.decodePacket = decodePacket;
|
|
const decodeBase64Packet = (data, binaryType) => {
|
|
if (withNativeArrayBuffer$1) {
|
|
const decoded = (0, base64_arraybuffer_js_1.decode)(data);
|
|
return mapBinary(decoded, binaryType);
|
|
}
|
|
else {
|
|
return { base64: true, data }; // fallback for old browsers
|
|
}
|
|
};
|
|
const mapBinary = (data, binaryType) => {
|
|
switch (binaryType) {
|
|
case "blob":
|
|
if (data instanceof Blob) {
|
|
// from WebSocket + binaryType "blob"
|
|
return data;
|
|
}
|
|
else {
|
|
// from HTTP long-polling or WebTransport
|
|
return new Blob([data]);
|
|
}
|
|
case "arraybuffer":
|
|
default:
|
|
if (data instanceof ArrayBuffer) {
|
|
// from HTTP long-polling (base64) or WebSocket + binaryType "arraybuffer"
|
|
return data;
|
|
}
|
|
else {
|
|
// from WebTransport (Uint8Array)
|
|
return data.buffer;
|
|
}
|
|
}
|
|
};
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.decodePayload = exports.decodePacket = exports.encodePayload = exports.encodePacket = exports.protocol = void 0;
|
|
exports.createPacketEncoderStream = createPacketEncoderStream;
|
|
exports.createPacketDecoderStream = createPacketDecoderStream;
|
|
const encodePacket_js_1 = encodePacket_browser;
|
|
Object.defineProperty(exports, "encodePacket", { enumerable: true, get: function () { return encodePacket_js_1.encodePacket; } });
|
|
const decodePacket_js_1 = decodePacket_browser;
|
|
Object.defineProperty(exports, "decodePacket", { enumerable: true, get: function () { return decodePacket_js_1.decodePacket; } });
|
|
const commons_js_1 = commons;
|
|
const SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
|
|
const encodePayload = (packets, callback) => {
|
|
// some packets may be added to the array while encoding, so the initial length must be saved
|
|
const length = packets.length;
|
|
const encodedPackets = new Array(length);
|
|
let count = 0;
|
|
packets.forEach((packet, i) => {
|
|
// force base64 encoding for binary packets
|
|
(0, encodePacket_js_1.encodePacket)(packet, false, (encodedPacket) => {
|
|
encodedPackets[i] = encodedPacket;
|
|
if (++count === length) {
|
|
callback(encodedPackets.join(SEPARATOR));
|
|
}
|
|
});
|
|
});
|
|
};
|
|
exports.encodePayload = encodePayload;
|
|
const decodePayload = (encodedPayload, binaryType) => {
|
|
const encodedPackets = encodedPayload.split(SEPARATOR);
|
|
const packets = [];
|
|
for (let i = 0; i < encodedPackets.length; i++) {
|
|
const decodedPacket = (0, decodePacket_js_1.decodePacket)(encodedPackets[i], binaryType);
|
|
packets.push(decodedPacket);
|
|
if (decodedPacket.type === "error") {
|
|
break;
|
|
}
|
|
}
|
|
return packets;
|
|
};
|
|
exports.decodePayload = decodePayload;
|
|
function createPacketEncoderStream() {
|
|
return new TransformStream({
|
|
transform(packet, controller) {
|
|
(0, encodePacket_js_1.encodePacketToBinary)(packet, (encodedPacket) => {
|
|
const payloadLength = encodedPacket.length;
|
|
let header;
|
|
// inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length
|
|
if (payloadLength < 126) {
|
|
header = new Uint8Array(1);
|
|
new DataView(header.buffer).setUint8(0, payloadLength);
|
|
}
|
|
else if (payloadLength < 65536) {
|
|
header = new Uint8Array(3);
|
|
const view = new DataView(header.buffer);
|
|
view.setUint8(0, 126);
|
|
view.setUint16(1, payloadLength);
|
|
}
|
|
else {
|
|
header = new Uint8Array(9);
|
|
const view = new DataView(header.buffer);
|
|
view.setUint8(0, 127);
|
|
view.setBigUint64(1, BigInt(payloadLength));
|
|
}
|
|
// first bit indicates whether the payload is plain text (0) or binary (1)
|
|
if (packet.data && typeof packet.data !== "string") {
|
|
header[0] |= 0x80;
|
|
}
|
|
controller.enqueue(header);
|
|
controller.enqueue(encodedPacket);
|
|
});
|
|
},
|
|
});
|
|
}
|
|
let TEXT_DECODER;
|
|
function totalLength(chunks) {
|
|
return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
|
|
}
|
|
function concatChunks(chunks, size) {
|
|
if (chunks[0].length === size) {
|
|
return chunks.shift();
|
|
}
|
|
const buffer = new Uint8Array(size);
|
|
let j = 0;
|
|
for (let i = 0; i < size; i++) {
|
|
buffer[i] = chunks[0][j++];
|
|
if (j === chunks[0].length) {
|
|
chunks.shift();
|
|
j = 0;
|
|
}
|
|
}
|
|
if (chunks.length && j < chunks[0].length) {
|
|
chunks[0] = chunks[0].slice(j);
|
|
}
|
|
return buffer;
|
|
}
|
|
function createPacketDecoderStream(maxPayload, binaryType) {
|
|
if (!TEXT_DECODER) {
|
|
TEXT_DECODER = new TextDecoder();
|
|
}
|
|
const chunks = [];
|
|
let state = 0 /* State.READ_HEADER */;
|
|
let expectedLength = -1;
|
|
let isBinary = false;
|
|
return new TransformStream({
|
|
transform(chunk, controller) {
|
|
chunks.push(chunk);
|
|
while (true) {
|
|
if (state === 0 /* State.READ_HEADER */) {
|
|
if (totalLength(chunks) < 1) {
|
|
break;
|
|
}
|
|
const header = concatChunks(chunks, 1);
|
|
isBinary = (header[0] & 0x80) === 0x80;
|
|
expectedLength = header[0] & 0x7f;
|
|
if (expectedLength < 126) {
|
|
state = 3 /* State.READ_PAYLOAD */;
|
|
}
|
|
else if (expectedLength === 126) {
|
|
state = 1 /* State.READ_EXTENDED_LENGTH_16 */;
|
|
}
|
|
else {
|
|
state = 2 /* State.READ_EXTENDED_LENGTH_64 */;
|
|
}
|
|
}
|
|
else if (state === 1 /* State.READ_EXTENDED_LENGTH_16 */) {
|
|
if (totalLength(chunks) < 2) {
|
|
break;
|
|
}
|
|
const headerArray = concatChunks(chunks, 2);
|
|
expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
|
|
state = 3 /* State.READ_PAYLOAD */;
|
|
}
|
|
else if (state === 2 /* State.READ_EXTENDED_LENGTH_64 */) {
|
|
if (totalLength(chunks) < 8) {
|
|
break;
|
|
}
|
|
const headerArray = concatChunks(chunks, 8);
|
|
const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
|
|
const n = view.getUint32(0);
|
|
if (n > Math.pow(2, 53 - 32) - 1) {
|
|
// the maximum safe integer in JavaScript is 2^53 - 1
|
|
controller.enqueue(commons_js_1.ERROR_PACKET);
|
|
break;
|
|
}
|
|
expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
|
|
state = 3 /* State.READ_PAYLOAD */;
|
|
}
|
|
else {
|
|
if (totalLength(chunks) < expectedLength) {
|
|
break;
|
|
}
|
|
const data = concatChunks(chunks, expectedLength);
|
|
controller.enqueue((0, decodePacket_js_1.decodePacket)(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
|
|
state = 0 /* State.READ_HEADER */;
|
|
}
|
|
if (expectedLength === 0 || expectedLength > maxPayload) {
|
|
controller.enqueue(commons_js_1.ERROR_PACKET);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
});
|
|
}
|
|
exports.protocol = 4;
|
|
} (cjs$1));
|
|
|
|
/**
|
|
* Initialize a new `Emitter`.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function Emitter(obj) {
|
|
if (obj) return mixin(obj);
|
|
}
|
|
|
|
/**
|
|
* Mixin the emitter properties.
|
|
*
|
|
* @param {Object} obj
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function mixin(obj) {
|
|
for (var key in Emitter.prototype) {
|
|
obj[key] = Emitter.prototype[key];
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Listen on the given `event` with `fn`.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.on =
|
|
Emitter.prototype.addEventListener = function(event, fn){
|
|
this._callbacks = this._callbacks || {};
|
|
(this._callbacks['$' + event] = this._callbacks['$' + event] || [])
|
|
.push(fn);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Adds an `event` listener that will be invoked a single
|
|
* time then automatically removed.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.once = function(event, fn){
|
|
function on() {
|
|
this.off(event, on);
|
|
fn.apply(this, arguments);
|
|
}
|
|
|
|
on.fn = fn;
|
|
this.on(event, on);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove the given callback for `event` or all
|
|
* registered callbacks.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.off =
|
|
Emitter.prototype.removeListener =
|
|
Emitter.prototype.removeAllListeners =
|
|
Emitter.prototype.removeEventListener = function(event, fn){
|
|
this._callbacks = this._callbacks || {};
|
|
|
|
// all
|
|
if (0 == arguments.length) {
|
|
this._callbacks = {};
|
|
return this;
|
|
}
|
|
|
|
// specific event
|
|
var callbacks = this._callbacks['$' + event];
|
|
if (!callbacks) return this;
|
|
|
|
// remove all handlers
|
|
if (1 == arguments.length) {
|
|
delete this._callbacks['$' + event];
|
|
return this;
|
|
}
|
|
|
|
// remove specific handler
|
|
var cb;
|
|
for (var i = 0; i < callbacks.length; i++) {
|
|
cb = callbacks[i];
|
|
if (cb === fn || cb.fn === fn) {
|
|
callbacks.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Remove event specific arrays for event types that no
|
|
// one is subscribed for to avoid memory leak.
|
|
if (callbacks.length === 0) {
|
|
delete this._callbacks['$' + event];
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Emit `event` with the given args.
|
|
*
|
|
* @param {String} event
|
|
* @param {Mixed} ...
|
|
* @return {Emitter}
|
|
*/
|
|
|
|
Emitter.prototype.emit = function(event){
|
|
this._callbacks = this._callbacks || {};
|
|
|
|
var args = new Array(arguments.length - 1)
|
|
, callbacks = this._callbacks['$' + event];
|
|
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
args[i - 1] = arguments[i];
|
|
}
|
|
|
|
if (callbacks) {
|
|
callbacks = callbacks.slice(0);
|
|
for (var i = 0, len = callbacks.length; i < len; ++i) {
|
|
callbacks[i].apply(this, args);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
// alias used for reserved events (protected method)
|
|
Emitter.prototype.emitReserved = Emitter.prototype.emit;
|
|
|
|
/**
|
|
* Return array of callbacks for `event`.
|
|
*
|
|
* @param {String} event
|
|
* @return {Array}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.listeners = function(event){
|
|
this._callbacks = this._callbacks || {};
|
|
return this._callbacks['$' + event] || [];
|
|
};
|
|
|
|
/**
|
|
* Check if this emitter has `event` handlers.
|
|
*
|
|
* @param {String} event
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.hasListeners = function(event){
|
|
return !! this.listeners(event).length;
|
|
};
|
|
|
|
var esm = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
Emitter: Emitter
|
|
});
|
|
|
|
var require$$5 = /*@__PURE__*/getAugmentedNamespace(esm);
|
|
|
|
var util = {};
|
|
|
|
var globals = {};
|
|
|
|
Object.defineProperty(globals, "__esModule", { value: true });
|
|
globals.defaultBinaryType = globals.globalThisShim = globals.nextTick = void 0;
|
|
globals.createCookieJar = createCookieJar;
|
|
globals.nextTick = (() => {
|
|
const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
|
|
if (isPromiseAvailable) {
|
|
return (cb) => Promise.resolve().then(cb);
|
|
}
|
|
else {
|
|
return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
|
|
}
|
|
})();
|
|
globals.globalThisShim = (() => {
|
|
if (typeof self !== "undefined") {
|
|
return self;
|
|
}
|
|
else if (typeof window !== "undefined") {
|
|
return window;
|
|
}
|
|
else {
|
|
return Function("return this")();
|
|
}
|
|
})();
|
|
globals.defaultBinaryType = "arraybuffer";
|
|
function createCookieJar() { }
|
|
|
|
Object.defineProperty(util, "__esModule", { value: true });
|
|
util.pick = pick;
|
|
util.installTimerFunctions = installTimerFunctions;
|
|
util.byteLength = byteLength;
|
|
util.randomString = randomString;
|
|
const globals_node_js_1$4 = globals;
|
|
function pick(obj, ...attr) {
|
|
return attr.reduce((acc, k) => {
|
|
if (obj.hasOwnProperty(k)) {
|
|
acc[k] = obj[k];
|
|
}
|
|
return acc;
|
|
}, {});
|
|
}
|
|
// Keep a reference to the real timeout functions so they can be used when overridden
|
|
const NATIVE_SET_TIMEOUT = globals_node_js_1$4.globalThisShim.setTimeout;
|
|
const NATIVE_CLEAR_TIMEOUT = globals_node_js_1$4.globalThisShim.clearTimeout;
|
|
function installTimerFunctions(obj, opts) {
|
|
if (opts.useNativeTimers) {
|
|
obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globals_node_js_1$4.globalThisShim);
|
|
obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globals_node_js_1$4.globalThisShim);
|
|
}
|
|
else {
|
|
obj.setTimeoutFn = globals_node_js_1$4.globalThisShim.setTimeout.bind(globals_node_js_1$4.globalThisShim);
|
|
obj.clearTimeoutFn = globals_node_js_1$4.globalThisShim.clearTimeout.bind(globals_node_js_1$4.globalThisShim);
|
|
}
|
|
}
|
|
// base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
|
|
const BASE64_OVERHEAD = 1.33;
|
|
// we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
|
|
function byteLength(obj) {
|
|
if (typeof obj === "string") {
|
|
return utf8Length(obj);
|
|
}
|
|
// arraybuffer or blob
|
|
return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
|
|
}
|
|
function utf8Length(str) {
|
|
let c = 0, length = 0;
|
|
for (let i = 0, l = str.length; i < l; i++) {
|
|
c = str.charCodeAt(i);
|
|
if (c < 0x80) {
|
|
length += 1;
|
|
}
|
|
else if (c < 0x800) {
|
|
length += 2;
|
|
}
|
|
else if (c < 0xd800 || c >= 0xe000) {
|
|
length += 3;
|
|
}
|
|
else {
|
|
i++;
|
|
length += 4;
|
|
}
|
|
}
|
|
return length;
|
|
}
|
|
/**
|
|
* Generates a random 8-characters string.
|
|
*/
|
|
function randomString() {
|
|
return (Date.now().toString(36).substring(3) +
|
|
Math.random().toString(36).substring(2, 5));
|
|
}
|
|
|
|
var parseqs = {};
|
|
|
|
// imported from https://github.com/galkn/querystring
|
|
/**
|
|
* Compiles a querystring
|
|
* Returns string representation of the object
|
|
*
|
|
* @param {Object}
|
|
* @api private
|
|
*/
|
|
Object.defineProperty(parseqs, "__esModule", { value: true });
|
|
parseqs.encode = encode;
|
|
parseqs.decode = decode;
|
|
function encode(obj) {
|
|
let str = '';
|
|
for (let i in obj) {
|
|
if (obj.hasOwnProperty(i)) {
|
|
if (str.length)
|
|
str += '&';
|
|
str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
/**
|
|
* Parses a simple querystring into an object
|
|
*
|
|
* @param {String} qs
|
|
* @api private
|
|
*/
|
|
function decode(qs) {
|
|
let qry = {};
|
|
let pairs = qs.split('&');
|
|
for (let i = 0, l = pairs.length; i < l; i++) {
|
|
let pair = pairs[i].split('=');
|
|
qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
|
|
}
|
|
return qry;
|
|
}
|
|
|
|
var browser = {exports: {}};
|
|
|
|
/**
|
|
* Helpers.
|
|
*/
|
|
|
|
var ms;
|
|
var hasRequiredMs;
|
|
|
|
function requireMs () {
|
|
if (hasRequiredMs) return ms;
|
|
hasRequiredMs = 1;
|
|
var s = 1000;
|
|
var m = s * 60;
|
|
var h = m * 60;
|
|
var d = h * 24;
|
|
var w = d * 7;
|
|
var y = d * 365.25;
|
|
|
|
/**
|
|
* Parse or format the given `val`.
|
|
*
|
|
* Options:
|
|
*
|
|
* - `long` verbose formatting [false]
|
|
*
|
|
* @param {String|Number} val
|
|
* @param {Object} [options]
|
|
* @throws {Error} throw an error if val is not a non-empty string or a number
|
|
* @return {String|Number}
|
|
* @api public
|
|
*/
|
|
|
|
ms = function (val, options) {
|
|
options = options || {};
|
|
var type = typeof val;
|
|
if (type === 'string' && val.length > 0) {
|
|
return parse(val);
|
|
} else if (type === 'number' && isFinite(val)) {
|
|
return options.long ? fmtLong(val) : fmtShort(val);
|
|
}
|
|
throw new Error(
|
|
'val is not a non-empty string or a valid number. val=' +
|
|
JSON.stringify(val)
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Parse the given `str` and return milliseconds.
|
|
*
|
|
* @param {String} str
|
|
* @return {Number}
|
|
* @api private
|
|
*/
|
|
|
|
function parse(str) {
|
|
str = String(str);
|
|
if (str.length > 100) {
|
|
return;
|
|
}
|
|
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
|
|
str
|
|
);
|
|
if (!match) {
|
|
return;
|
|
}
|
|
var n = parseFloat(match[1]);
|
|
var type = (match[2] || 'ms').toLowerCase();
|
|
switch (type) {
|
|
case 'years':
|
|
case 'year':
|
|
case 'yrs':
|
|
case 'yr':
|
|
case 'y':
|
|
return n * y;
|
|
case 'weeks':
|
|
case 'week':
|
|
case 'w':
|
|
return n * w;
|
|
case 'days':
|
|
case 'day':
|
|
case 'd':
|
|
return n * d;
|
|
case 'hours':
|
|
case 'hour':
|
|
case 'hrs':
|
|
case 'hr':
|
|
case 'h':
|
|
return n * h;
|
|
case 'minutes':
|
|
case 'minute':
|
|
case 'mins':
|
|
case 'min':
|
|
case 'm':
|
|
return n * m;
|
|
case 'seconds':
|
|
case 'second':
|
|
case 'secs':
|
|
case 'sec':
|
|
case 's':
|
|
return n * s;
|
|
case 'milliseconds':
|
|
case 'millisecond':
|
|
case 'msecs':
|
|
case 'msec':
|
|
case 'ms':
|
|
return n;
|
|
default:
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Short format for `ms`.
|
|
*
|
|
* @param {Number} ms
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
function fmtShort(ms) {
|
|
var msAbs = Math.abs(ms);
|
|
if (msAbs >= d) {
|
|
return Math.round(ms / d) + 'd';
|
|
}
|
|
if (msAbs >= h) {
|
|
return Math.round(ms / h) + 'h';
|
|
}
|
|
if (msAbs >= m) {
|
|
return Math.round(ms / m) + 'm';
|
|
}
|
|
if (msAbs >= s) {
|
|
return Math.round(ms / s) + 's';
|
|
}
|
|
return ms + 'ms';
|
|
}
|
|
|
|
/**
|
|
* Long format for `ms`.
|
|
*
|
|
* @param {Number} ms
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
function fmtLong(ms) {
|
|
var msAbs = Math.abs(ms);
|
|
if (msAbs >= d) {
|
|
return plural(ms, msAbs, d, 'day');
|
|
}
|
|
if (msAbs >= h) {
|
|
return plural(ms, msAbs, h, 'hour');
|
|
}
|
|
if (msAbs >= m) {
|
|
return plural(ms, msAbs, m, 'minute');
|
|
}
|
|
if (msAbs >= s) {
|
|
return plural(ms, msAbs, s, 'second');
|
|
}
|
|
return ms + ' ms';
|
|
}
|
|
|
|
/**
|
|
* Pluralization helper.
|
|
*/
|
|
|
|
function plural(ms, msAbs, n, name) {
|
|
var isPlural = msAbs >= n * 1.5;
|
|
return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
|
|
}
|
|
return ms;
|
|
}
|
|
|
|
/**
|
|
* This is the common logic for both the Node.js and web browser
|
|
* implementations of `debug()`.
|
|
*/
|
|
|
|
function setup(env) {
|
|
createDebug.debug = createDebug;
|
|
createDebug.default = createDebug;
|
|
createDebug.coerce = coerce;
|
|
createDebug.disable = disable;
|
|
createDebug.enable = enable;
|
|
createDebug.enabled = enabled;
|
|
createDebug.humanize = requireMs();
|
|
createDebug.destroy = destroy;
|
|
|
|
Object.keys(env).forEach(key => {
|
|
createDebug[key] = env[key];
|
|
});
|
|
|
|
/**
|
|
* The currently active debug mode names, and names to skip.
|
|
*/
|
|
|
|
createDebug.names = [];
|
|
createDebug.skips = [];
|
|
|
|
/**
|
|
* Map of special "%n" handling functions, for the debug "format" argument.
|
|
*
|
|
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
|
|
*/
|
|
createDebug.formatters = {};
|
|
|
|
/**
|
|
* Selects a color for a debug namespace
|
|
* @param {String} namespace The namespace string for the debug instance to be colored
|
|
* @return {Number|String} An ANSI color code for the given namespace
|
|
* @api private
|
|
*/
|
|
function selectColor(namespace) {
|
|
let hash = 0;
|
|
|
|
for (let i = 0; i < namespace.length; i++) {
|
|
hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
|
|
hash |= 0; // Convert to 32bit integer
|
|
}
|
|
|
|
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
|
|
}
|
|
createDebug.selectColor = selectColor;
|
|
|
|
/**
|
|
* Create a debugger with the given `namespace`.
|
|
*
|
|
* @param {String} namespace
|
|
* @return {Function}
|
|
* @api public
|
|
*/
|
|
function createDebug(namespace) {
|
|
let prevTime;
|
|
let enableOverride = null;
|
|
let namespacesCache;
|
|
let enabledCache;
|
|
|
|
function debug(...args) {
|
|
// Disabled?
|
|
if (!debug.enabled) {
|
|
return;
|
|
}
|
|
|
|
const self = debug;
|
|
|
|
// Set `diff` timestamp
|
|
const curr = Number(new Date());
|
|
const ms = curr - (prevTime || curr);
|
|
self.diff = ms;
|
|
self.prev = prevTime;
|
|
self.curr = curr;
|
|
prevTime = curr;
|
|
|
|
args[0] = createDebug.coerce(args[0]);
|
|
|
|
if (typeof args[0] !== 'string') {
|
|
// Anything else let's inspect with %O
|
|
args.unshift('%O');
|
|
}
|
|
|
|
// Apply any `formatters` transformations
|
|
let index = 0;
|
|
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
|
|
// If we encounter an escaped % then don't increase the array index
|
|
if (match === '%%') {
|
|
return '%';
|
|
}
|
|
index++;
|
|
const formatter = createDebug.formatters[format];
|
|
if (typeof formatter === 'function') {
|
|
const val = args[index];
|
|
match = formatter.call(self, val);
|
|
|
|
// Now we need to remove `args[index]` since it's inlined in the `format`
|
|
args.splice(index, 1);
|
|
index--;
|
|
}
|
|
return match;
|
|
});
|
|
|
|
// Apply env-specific formatting (colors, etc.)
|
|
createDebug.formatArgs.call(self, args);
|
|
|
|
const logFn = self.log || createDebug.log;
|
|
logFn.apply(self, args);
|
|
}
|
|
|
|
debug.namespace = namespace;
|
|
debug.useColors = createDebug.useColors();
|
|
debug.color = createDebug.selectColor(namespace);
|
|
debug.extend = extend;
|
|
debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
|
|
|
|
Object.defineProperty(debug, 'enabled', {
|
|
enumerable: true,
|
|
configurable: false,
|
|
get: () => {
|
|
if (enableOverride !== null) {
|
|
return enableOverride;
|
|
}
|
|
if (namespacesCache !== createDebug.namespaces) {
|
|
namespacesCache = createDebug.namespaces;
|
|
enabledCache = createDebug.enabled(namespace);
|
|
}
|
|
|
|
return enabledCache;
|
|
},
|
|
set: v => {
|
|
enableOverride = v;
|
|
}
|
|
});
|
|
|
|
// Env-specific initialization logic for debug instances
|
|
if (typeof createDebug.init === 'function') {
|
|
createDebug.init(debug);
|
|
}
|
|
|
|
return debug;
|
|
}
|
|
|
|
function extend(namespace, delimiter) {
|
|
const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
|
|
newDebug.log = this.log;
|
|
return newDebug;
|
|
}
|
|
|
|
/**
|
|
* Enables a debug mode by namespaces. This can include modes
|
|
* separated by a colon and wildcards.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api public
|
|
*/
|
|
function enable(namespaces) {
|
|
createDebug.save(namespaces);
|
|
createDebug.namespaces = namespaces;
|
|
|
|
createDebug.names = [];
|
|
createDebug.skips = [];
|
|
|
|
let i;
|
|
const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
|
|
const len = split.length;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (!split[i]) {
|
|
// ignore empty strings
|
|
continue;
|
|
}
|
|
|
|
namespaces = split[i].replace(/\*/g, '.*?');
|
|
|
|
if (namespaces[0] === '-') {
|
|
createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
|
|
} else {
|
|
createDebug.names.push(new RegExp('^' + namespaces + '$'));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disable debug output.
|
|
*
|
|
* @return {String} namespaces
|
|
* @api public
|
|
*/
|
|
function disable() {
|
|
const namespaces = [
|
|
...createDebug.names.map(toNamespace),
|
|
...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
|
|
].join(',');
|
|
createDebug.enable('');
|
|
return namespaces;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given mode name is enabled, false otherwise.
|
|
*
|
|
* @param {String} name
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
function enabled(name) {
|
|
if (name[name.length - 1] === '*') {
|
|
return true;
|
|
}
|
|
|
|
let i;
|
|
let len;
|
|
|
|
for (i = 0, len = createDebug.skips.length; i < len; i++) {
|
|
if (createDebug.skips[i].test(name)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (i = 0, len = createDebug.names.length; i < len; i++) {
|
|
if (createDebug.names[i].test(name)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Convert regexp to namespace
|
|
*
|
|
* @param {RegExp} regxep
|
|
* @return {String} namespace
|
|
* @api private
|
|
*/
|
|
function toNamespace(regexp) {
|
|
return regexp.toString()
|
|
.substring(2, regexp.toString().length - 2)
|
|
.replace(/\.\*\?$/, '*');
|
|
}
|
|
|
|
/**
|
|
* Coerce `val`.
|
|
*
|
|
* @param {Mixed} val
|
|
* @return {Mixed}
|
|
* @api private
|
|
*/
|
|
function coerce(val) {
|
|
if (val instanceof Error) {
|
|
return val.stack || val.message;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* XXX DO NOT USE. This is a temporary stub function.
|
|
* XXX It WILL be removed in the next major release.
|
|
*/
|
|
function destroy() {
|
|
console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
|
|
}
|
|
|
|
createDebug.enable(createDebug.load());
|
|
|
|
return createDebug;
|
|
}
|
|
|
|
var common = setup;
|
|
|
|
/* eslint-env browser */
|
|
browser.exports;
|
|
|
|
(function (module, exports) {
|
|
/**
|
|
* This is the web browser implementation of `debug()`.
|
|
*/
|
|
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
exports.storage = localstorage();
|
|
exports.destroy = (() => {
|
|
let warned = false;
|
|
|
|
return () => {
|
|
if (!warned) {
|
|
warned = true;
|
|
console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
|
|
}
|
|
};
|
|
})();
|
|
|
|
/**
|
|
* Colors.
|
|
*/
|
|
|
|
exports.colors = [
|
|
'#0000CC',
|
|
'#0000FF',
|
|
'#0033CC',
|
|
'#0033FF',
|
|
'#0066CC',
|
|
'#0066FF',
|
|
'#0099CC',
|
|
'#0099FF',
|
|
'#00CC00',
|
|
'#00CC33',
|
|
'#00CC66',
|
|
'#00CC99',
|
|
'#00CCCC',
|
|
'#00CCFF',
|
|
'#3300CC',
|
|
'#3300FF',
|
|
'#3333CC',
|
|
'#3333FF',
|
|
'#3366CC',
|
|
'#3366FF',
|
|
'#3399CC',
|
|
'#3399FF',
|
|
'#33CC00',
|
|
'#33CC33',
|
|
'#33CC66',
|
|
'#33CC99',
|
|
'#33CCCC',
|
|
'#33CCFF',
|
|
'#6600CC',
|
|
'#6600FF',
|
|
'#6633CC',
|
|
'#6633FF',
|
|
'#66CC00',
|
|
'#66CC33',
|
|
'#9900CC',
|
|
'#9900FF',
|
|
'#9933CC',
|
|
'#9933FF',
|
|
'#99CC00',
|
|
'#99CC33',
|
|
'#CC0000',
|
|
'#CC0033',
|
|
'#CC0066',
|
|
'#CC0099',
|
|
'#CC00CC',
|
|
'#CC00FF',
|
|
'#CC3300',
|
|
'#CC3333',
|
|
'#CC3366',
|
|
'#CC3399',
|
|
'#CC33CC',
|
|
'#CC33FF',
|
|
'#CC6600',
|
|
'#CC6633',
|
|
'#CC9900',
|
|
'#CC9933',
|
|
'#CCCC00',
|
|
'#CCCC33',
|
|
'#FF0000',
|
|
'#FF0033',
|
|
'#FF0066',
|
|
'#FF0099',
|
|
'#FF00CC',
|
|
'#FF00FF',
|
|
'#FF3300',
|
|
'#FF3333',
|
|
'#FF3366',
|
|
'#FF3399',
|
|
'#FF33CC',
|
|
'#FF33FF',
|
|
'#FF6600',
|
|
'#FF6633',
|
|
'#FF9900',
|
|
'#FF9933',
|
|
'#FFCC00',
|
|
'#FFCC33'
|
|
];
|
|
|
|
/**
|
|
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
|
|
* and the Firebug extension (any Firefox version) are known
|
|
* to support "%c" CSS customizations.
|
|
*
|
|
* TODO: add a `localStorage` variable to explicitly enable/disable colors
|
|
*/
|
|
|
|
// eslint-disable-next-line complexity
|
|
function useColors() {
|
|
// NB: In an Electron preload script, document will be defined but not fully
|
|
// initialized. Since we know we're in Chrome, we'll just detect this case
|
|
// explicitly
|
|
if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
|
|
return true;
|
|
}
|
|
|
|
// Internet Explorer and Edge do not support colors.
|
|
if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
|
|
return false;
|
|
}
|
|
|
|
let m;
|
|
|
|
// Is webkit? http://stackoverflow.com/a/16459606/376773
|
|
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
|
|
return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
|
|
// Is firebug? http://stackoverflow.com/a/398120/376773
|
|
(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
|
|
// Is firefox >= v31?
|
|
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
|
(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
|
|
// Double check webkit in userAgent just in case we are in a worker
|
|
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
|
|
}
|
|
|
|
/**
|
|
* Colorize log arguments if enabled.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function formatArgs(args) {
|
|
args[0] = (this.useColors ? '%c' : '') +
|
|
this.namespace +
|
|
(this.useColors ? ' %c' : ' ') +
|
|
args[0] +
|
|
(this.useColors ? '%c ' : ' ') +
|
|
'+' + module.exports.humanize(this.diff);
|
|
|
|
if (!this.useColors) {
|
|
return;
|
|
}
|
|
|
|
const c = 'color: ' + this.color;
|
|
args.splice(1, 0, c, 'color: inherit');
|
|
|
|
// The final "%c" is somewhat tricky, because there could be other
|
|
// arguments passed either before or after the %c, so we need to
|
|
// figure out the correct index to insert the CSS into
|
|
let index = 0;
|
|
let lastC = 0;
|
|
args[0].replace(/%[a-zA-Z%]/g, match => {
|
|
if (match === '%%') {
|
|
return;
|
|
}
|
|
index++;
|
|
if (match === '%c') {
|
|
// We only are interested in the *last* %c
|
|
// (the user may have provided their own)
|
|
lastC = index;
|
|
}
|
|
});
|
|
|
|
args.splice(lastC, 0, c);
|
|
}
|
|
|
|
/**
|
|
* Invokes `console.debug()` when available.
|
|
* No-op when `console.debug` is not a "function".
|
|
* If `console.debug` is not available, falls back
|
|
* to `console.log`.
|
|
*
|
|
* @api public
|
|
*/
|
|
exports.log = console.debug || console.log || (() => {});
|
|
|
|
/**
|
|
* Save `namespaces`.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api private
|
|
*/
|
|
function save(namespaces) {
|
|
try {
|
|
if (namespaces) {
|
|
exports.storage.setItem('debug', namespaces);
|
|
} else {
|
|
exports.storage.removeItem('debug');
|
|
}
|
|
} catch (error) {
|
|
// Swallow
|
|
// XXX (@Qix-) should we be logging these?
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load `namespaces`.
|
|
*
|
|
* @return {String} returns the previously persisted debug modes
|
|
* @api private
|
|
*/
|
|
function load() {
|
|
let r;
|
|
try {
|
|
r = exports.storage.getItem('debug');
|
|
} catch (error) {
|
|
// Swallow
|
|
// XXX (@Qix-) should we be logging these?
|
|
}
|
|
|
|
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
|
|
if (!r && typeof process !== 'undefined' && 'env' in process) {
|
|
r = process.env.DEBUG;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* Localstorage attempts to return the localstorage.
|
|
*
|
|
* This is necessary because safari throws
|
|
* when a user disables cookies/localstorage
|
|
* and you attempt to access it.
|
|
*
|
|
* @return {LocalStorage}
|
|
* @api private
|
|
*/
|
|
|
|
function localstorage() {
|
|
try {
|
|
// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
|
|
// The Browser also has localStorage in the global context.
|
|
return localStorage;
|
|
} catch (error) {
|
|
// Swallow
|
|
// XXX (@Qix-) should we be logging these?
|
|
}
|
|
}
|
|
|
|
module.exports = common(exports);
|
|
|
|
const {formatters} = module.exports;
|
|
|
|
/**
|
|
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
|
*/
|
|
|
|
formatters.j = function (v) {
|
|
try {
|
|
return JSON.stringify(v);
|
|
} catch (error) {
|
|
return '[UnexpectedJSONParseError]: ' + error.message;
|
|
}
|
|
};
|
|
} (browser, browser.exports));
|
|
|
|
var browserExports = browser.exports;
|
|
|
|
var __importDefault$8 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(transport, "__esModule", { value: true });
|
|
transport.Transport = transport.TransportError = void 0;
|
|
const engine_io_parser_1$4 = cjs$1;
|
|
const component_emitter_1$4 = require$$5;
|
|
const util_js_1$4 = util;
|
|
const parseqs_js_1$1 = parseqs;
|
|
const debug_1$8 = __importDefault$8(browserExports); // debug()
|
|
const debug$8 = (0, debug_1$8.default)("engine.io-client:transport"); // debug()
|
|
class TransportError extends Error {
|
|
constructor(reason, description, context) {
|
|
super(reason);
|
|
this.description = description;
|
|
this.context = context;
|
|
this.type = "TransportError";
|
|
}
|
|
}
|
|
transport.TransportError = TransportError;
|
|
class Transport extends component_emitter_1$4.Emitter {
|
|
/**
|
|
* Transport abstract constructor.
|
|
*
|
|
* @param {Object} opts - options
|
|
* @protected
|
|
*/
|
|
constructor(opts) {
|
|
super();
|
|
this.writable = false;
|
|
(0, util_js_1$4.installTimerFunctions)(this, opts);
|
|
this.opts = opts;
|
|
this.query = opts.query;
|
|
this.socket = opts.socket;
|
|
this.supportsBinary = !opts.forceBase64;
|
|
}
|
|
/**
|
|
* Emits an error.
|
|
*
|
|
* @param {String} reason
|
|
* @param description
|
|
* @param context - the error context
|
|
* @return {Transport} for chaining
|
|
* @protected
|
|
*/
|
|
onError(reason, description, context) {
|
|
super.emitReserved("error", new TransportError(reason, description, context));
|
|
return this;
|
|
}
|
|
/**
|
|
* Opens the transport.
|
|
*/
|
|
open() {
|
|
this.readyState = "opening";
|
|
this.doOpen();
|
|
return this;
|
|
}
|
|
/**
|
|
* Closes the transport.
|
|
*/
|
|
close() {
|
|
if (this.readyState === "opening" || this.readyState === "open") {
|
|
this.doClose();
|
|
this.onClose();
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Sends multiple packets.
|
|
*
|
|
* @param {Array} packets
|
|
*/
|
|
send(packets) {
|
|
if (this.readyState === "open") {
|
|
this.write(packets);
|
|
}
|
|
else {
|
|
// this might happen if the transport was silently closed in the beforeunload event handler
|
|
debug$8("transport is not open, discarding packets");
|
|
}
|
|
}
|
|
/**
|
|
* Called upon open
|
|
*
|
|
* @protected
|
|
*/
|
|
onOpen() {
|
|
this.readyState = "open";
|
|
this.writable = true;
|
|
super.emitReserved("open");
|
|
}
|
|
/**
|
|
* Called with data.
|
|
*
|
|
* @param {String} data
|
|
* @protected
|
|
*/
|
|
onData(data) {
|
|
const packet = (0, engine_io_parser_1$4.decodePacket)(data, this.socket.binaryType);
|
|
this.onPacket(packet);
|
|
}
|
|
/**
|
|
* Called with a decoded packet.
|
|
*
|
|
* @protected
|
|
*/
|
|
onPacket(packet) {
|
|
super.emitReserved("packet", packet);
|
|
}
|
|
/**
|
|
* Called upon close.
|
|
*
|
|
* @protected
|
|
*/
|
|
onClose(details) {
|
|
this.readyState = "closed";
|
|
super.emitReserved("close", details);
|
|
}
|
|
/**
|
|
* Pauses the transport, in order not to lose packets during an upgrade.
|
|
*
|
|
* @param onPause
|
|
*/
|
|
pause(onPause) { }
|
|
createUri(schema, query = {}) {
|
|
return (schema +
|
|
"://" +
|
|
this._hostname() +
|
|
this._port() +
|
|
this.opts.path +
|
|
this._query(query));
|
|
}
|
|
_hostname() {
|
|
const hostname = this.opts.hostname;
|
|
return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
|
|
}
|
|
_port() {
|
|
if (this.opts.port &&
|
|
((this.opts.secure && Number(this.opts.port !== 443)) ||
|
|
(!this.opts.secure && Number(this.opts.port) !== 80))) {
|
|
return ":" + this.opts.port;
|
|
}
|
|
else {
|
|
return "";
|
|
}
|
|
}
|
|
_query(query) {
|
|
const encodedQuery = (0, parseqs_js_1$1.encode)(query);
|
|
return encodedQuery.length ? "?" + encodedQuery : "";
|
|
}
|
|
}
|
|
transport.Transport = Transport;
|
|
|
|
var __importDefault$7 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(polling, "__esModule", { value: true });
|
|
polling.Polling = void 0;
|
|
const transport_js_1$2 = transport;
|
|
const util_js_1$3 = util;
|
|
const engine_io_parser_1$3 = cjs$1;
|
|
const debug_1$7 = __importDefault$7(browserExports); // debug()
|
|
const debug$7 = (0, debug_1$7.default)("engine.io-client:polling"); // debug()
|
|
class Polling extends transport_js_1$2.Transport {
|
|
constructor() {
|
|
super(...arguments);
|
|
this._polling = false;
|
|
}
|
|
get name() {
|
|
return "polling";
|
|
}
|
|
/**
|
|
* Opens the socket (triggers polling). We write a PING message to determine
|
|
* when the transport is open.
|
|
*
|
|
* @protected
|
|
*/
|
|
doOpen() {
|
|
this._poll();
|
|
}
|
|
/**
|
|
* Pauses polling.
|
|
*
|
|
* @param {Function} onPause - callback upon buffers are flushed and transport is paused
|
|
* @package
|
|
*/
|
|
pause(onPause) {
|
|
this.readyState = "pausing";
|
|
const pause = () => {
|
|
debug$7("paused");
|
|
this.readyState = "paused";
|
|
onPause();
|
|
};
|
|
if (this._polling || !this.writable) {
|
|
let total = 0;
|
|
if (this._polling) {
|
|
debug$7("we are currently polling - waiting to pause");
|
|
total++;
|
|
this.once("pollComplete", function () {
|
|
debug$7("pre-pause polling complete");
|
|
--total || pause();
|
|
});
|
|
}
|
|
if (!this.writable) {
|
|
debug$7("we are currently writing - waiting to pause");
|
|
total++;
|
|
this.once("drain", function () {
|
|
debug$7("pre-pause writing complete");
|
|
--total || pause();
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
pause();
|
|
}
|
|
}
|
|
/**
|
|
* Starts polling cycle.
|
|
*
|
|
* @private
|
|
*/
|
|
_poll() {
|
|
debug$7("polling");
|
|
this._polling = true;
|
|
this.doPoll();
|
|
this.emitReserved("poll");
|
|
}
|
|
/**
|
|
* Overloads onData to detect payloads.
|
|
*
|
|
* @protected
|
|
*/
|
|
onData(data) {
|
|
debug$7("polling got data %s", data);
|
|
const callback = (packet) => {
|
|
// if its the first message we consider the transport open
|
|
if ("opening" === this.readyState && packet.type === "open") {
|
|
this.onOpen();
|
|
}
|
|
// if its a close packet, we close the ongoing requests
|
|
if ("close" === packet.type) {
|
|
this.onClose({ description: "transport closed by the server" });
|
|
return false;
|
|
}
|
|
// otherwise bypass onData and handle the message
|
|
this.onPacket(packet);
|
|
};
|
|
// decode payload
|
|
(0, engine_io_parser_1$3.decodePayload)(data, this.socket.binaryType).forEach(callback);
|
|
// if an event did not trigger closing
|
|
if ("closed" !== this.readyState) {
|
|
// if we got data we're not polling
|
|
this._polling = false;
|
|
this.emitReserved("pollComplete");
|
|
if ("open" === this.readyState) {
|
|
this._poll();
|
|
}
|
|
else {
|
|
debug$7('ignoring poll - transport state "%s"', this.readyState);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* For polling, send a close packet.
|
|
*
|
|
* @protected
|
|
*/
|
|
doClose() {
|
|
const close = () => {
|
|
debug$7("writing close packet");
|
|
this.write([{ type: "close" }]);
|
|
};
|
|
if ("open" === this.readyState) {
|
|
debug$7("transport open - closing");
|
|
close();
|
|
}
|
|
else {
|
|
// in case we're trying to close while
|
|
// handshaking is in progress (GH-164)
|
|
debug$7("transport not open - deferring close");
|
|
this.once("open", close);
|
|
}
|
|
}
|
|
/**
|
|
* Writes a packets payload.
|
|
*
|
|
* @param {Array} packets - data packets
|
|
* @protected
|
|
*/
|
|
write(packets) {
|
|
this.writable = false;
|
|
(0, engine_io_parser_1$3.encodePayload)(packets, (data) => {
|
|
this.doWrite(data, () => {
|
|
this.writable = true;
|
|
this.emitReserved("drain");
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Generates uri for connection.
|
|
*
|
|
* @private
|
|
*/
|
|
uri() {
|
|
const schema = this.opts.secure ? "https" : "http";
|
|
const query = this.query || {};
|
|
// cache busting is forced
|
|
if (false !== this.opts.timestampRequests) {
|
|
query[this.opts.timestampParam] = (0, util_js_1$3.randomString)();
|
|
}
|
|
if (!this.supportsBinary && !query.sid) {
|
|
query.b64 = 1;
|
|
}
|
|
return this.createUri(schema, query);
|
|
}
|
|
}
|
|
polling.Polling = Polling;
|
|
|
|
var hasCors = {};
|
|
|
|
Object.defineProperty(hasCors, "__esModule", { value: true });
|
|
hasCors.hasCORS = void 0;
|
|
// imported from https://github.com/component/has-cors
|
|
let value = false;
|
|
try {
|
|
value = typeof XMLHttpRequest !== 'undefined' &&
|
|
'withCredentials' in new XMLHttpRequest();
|
|
}
|
|
catch (err) {
|
|
// if XMLHttp support is disabled in IE then it will throw
|
|
// when trying to create
|
|
}
|
|
hasCors.hasCORS = value;
|
|
|
|
var __importDefault$6 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(pollingXhr, "__esModule", { value: true });
|
|
pollingXhr.XHR = pollingXhr.Request = pollingXhr.BaseXHR = void 0;
|
|
const polling_js_1$1 = polling;
|
|
const component_emitter_1$3 = require$$5;
|
|
const util_js_1$2 = util;
|
|
const globals_node_js_1$3 = globals;
|
|
const has_cors_js_1 = hasCors;
|
|
const debug_1$6 = __importDefault$6(browserExports); // debug()
|
|
const debug$6 = (0, debug_1$6.default)("engine.io-client:polling"); // debug()
|
|
function empty() { }
|
|
class BaseXHR extends polling_js_1$1.Polling {
|
|
/**
|
|
* XHR Polling constructor.
|
|
*
|
|
* @param {Object} opts
|
|
* @package
|
|
*/
|
|
constructor(opts) {
|
|
super(opts);
|
|
if (typeof location !== "undefined") {
|
|
const isSSL = "https:" === location.protocol;
|
|
let port = location.port;
|
|
// some user agents have empty `location.port`
|
|
if (!port) {
|
|
port = isSSL ? "443" : "80";
|
|
}
|
|
this.xd =
|
|
(typeof location !== "undefined" &&
|
|
opts.hostname !== location.hostname) ||
|
|
port !== opts.port;
|
|
}
|
|
}
|
|
/**
|
|
* Sends data.
|
|
*
|
|
* @param {String} data to send.
|
|
* @param {Function} called upon flush.
|
|
* @private
|
|
*/
|
|
doWrite(data, fn) {
|
|
const req = this.request({
|
|
method: "POST",
|
|
data: data,
|
|
});
|
|
req.on("success", fn);
|
|
req.on("error", (xhrStatus, context) => {
|
|
this.onError("xhr post error", xhrStatus, context);
|
|
});
|
|
}
|
|
/**
|
|
* Starts a poll cycle.
|
|
*
|
|
* @private
|
|
*/
|
|
doPoll() {
|
|
debug$6("xhr poll");
|
|
const req = this.request();
|
|
req.on("data", this.onData.bind(this));
|
|
req.on("error", (xhrStatus, context) => {
|
|
this.onError("xhr poll error", xhrStatus, context);
|
|
});
|
|
this.pollXhr = req;
|
|
}
|
|
}
|
|
pollingXhr.BaseXHR = BaseXHR;
|
|
class Request extends component_emitter_1$3.Emitter {
|
|
/**
|
|
* Request constructor
|
|
*
|
|
* @param {Object} options
|
|
* @package
|
|
*/
|
|
constructor(createRequest, uri, opts) {
|
|
super();
|
|
this.createRequest = createRequest;
|
|
(0, util_js_1$2.installTimerFunctions)(this, opts);
|
|
this._opts = opts;
|
|
this._method = opts.method || "GET";
|
|
this._uri = uri;
|
|
this._data = undefined !== opts.data ? opts.data : null;
|
|
this._create();
|
|
}
|
|
/**
|
|
* Creates the XHR object and sends the request.
|
|
*
|
|
* @private
|
|
*/
|
|
_create() {
|
|
var _a;
|
|
const opts = (0, util_js_1$2.pick)(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
|
|
opts.xdomain = !!this._opts.xd;
|
|
const xhr = (this._xhr = this.createRequest(opts));
|
|
try {
|
|
debug$6("xhr open %s: %s", this._method, this._uri);
|
|
xhr.open(this._method, this._uri, true);
|
|
try {
|
|
if (this._opts.extraHeaders) {
|
|
// @ts-ignore
|
|
xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
|
|
for (let i in this._opts.extraHeaders) {
|
|
if (this._opts.extraHeaders.hasOwnProperty(i)) {
|
|
xhr.setRequestHeader(i, this._opts.extraHeaders[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (e) { }
|
|
if ("POST" === this._method) {
|
|
try {
|
|
xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
|
|
}
|
|
catch (e) { }
|
|
}
|
|
try {
|
|
xhr.setRequestHeader("Accept", "*/*");
|
|
}
|
|
catch (e) { }
|
|
(_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
|
|
// ie6 check
|
|
if ("withCredentials" in xhr) {
|
|
xhr.withCredentials = this._opts.withCredentials;
|
|
}
|
|
if (this._opts.requestTimeout) {
|
|
xhr.timeout = this._opts.requestTimeout;
|
|
}
|
|
xhr.onreadystatechange = () => {
|
|
var _a;
|
|
if (xhr.readyState === 3) {
|
|
(_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(
|
|
// @ts-ignore
|
|
xhr.getResponseHeader("set-cookie"));
|
|
}
|
|
if (4 !== xhr.readyState)
|
|
return;
|
|
if (200 === xhr.status || 1223 === xhr.status) {
|
|
this._onLoad();
|
|
}
|
|
else {
|
|
// make sure the `error` event handler that's user-set
|
|
// does not throw in the same tick and gets caught here
|
|
this.setTimeoutFn(() => {
|
|
this._onError(typeof xhr.status === "number" ? xhr.status : 0);
|
|
}, 0);
|
|
}
|
|
};
|
|
debug$6("xhr data %s", this._data);
|
|
xhr.send(this._data);
|
|
}
|
|
catch (e) {
|
|
// Need to defer since .create() is called directly from the constructor
|
|
// and thus the 'error' event can only be only bound *after* this exception
|
|
// occurs. Therefore, also, we cannot throw here at all.
|
|
this.setTimeoutFn(() => {
|
|
this._onError(e);
|
|
}, 0);
|
|
return;
|
|
}
|
|
if (typeof document !== "undefined") {
|
|
this._index = Request.requestsCount++;
|
|
Request.requests[this._index] = this;
|
|
}
|
|
}
|
|
/**
|
|
* Called upon error.
|
|
*
|
|
* @private
|
|
*/
|
|
_onError(err) {
|
|
this.emitReserved("error", err, this._xhr);
|
|
this._cleanup(true);
|
|
}
|
|
/**
|
|
* Cleans up house.
|
|
*
|
|
* @private
|
|
*/
|
|
_cleanup(fromError) {
|
|
if ("undefined" === typeof this._xhr || null === this._xhr) {
|
|
return;
|
|
}
|
|
this._xhr.onreadystatechange = empty;
|
|
if (fromError) {
|
|
try {
|
|
this._xhr.abort();
|
|
}
|
|
catch (e) { }
|
|
}
|
|
if (typeof document !== "undefined") {
|
|
delete Request.requests[this._index];
|
|
}
|
|
this._xhr = null;
|
|
}
|
|
/**
|
|
* Called upon load.
|
|
*
|
|
* @private
|
|
*/
|
|
_onLoad() {
|
|
const data = this._xhr.responseText;
|
|
if (data !== null) {
|
|
this.emitReserved("data", data);
|
|
this.emitReserved("success");
|
|
this._cleanup();
|
|
}
|
|
}
|
|
/**
|
|
* Aborts the request.
|
|
*
|
|
* @package
|
|
*/
|
|
abort() {
|
|
this._cleanup();
|
|
}
|
|
}
|
|
pollingXhr.Request = Request;
|
|
Request.requestsCount = 0;
|
|
Request.requests = {};
|
|
/**
|
|
* Aborts pending requests when unloading the window. This is needed to prevent
|
|
* memory leaks (e.g. when using IE) and to ensure that no spurious error is
|
|
* emitted.
|
|
*/
|
|
if (typeof document !== "undefined") {
|
|
// @ts-ignore
|
|
if (typeof attachEvent === "function") {
|
|
// @ts-ignore
|
|
attachEvent("onunload", unloadHandler);
|
|
}
|
|
else if (typeof addEventListener === "function") {
|
|
const terminationEvent = "onpagehide" in globals_node_js_1$3.globalThisShim ? "pagehide" : "unload";
|
|
addEventListener(terminationEvent, unloadHandler, false);
|
|
}
|
|
}
|
|
function unloadHandler() {
|
|
for (let i in Request.requests) {
|
|
if (Request.requests.hasOwnProperty(i)) {
|
|
Request.requests[i].abort();
|
|
}
|
|
}
|
|
}
|
|
const hasXHR2 = (function () {
|
|
const xhr = newRequest({
|
|
xdomain: false,
|
|
});
|
|
return xhr && xhr.responseType !== null;
|
|
})();
|
|
/**
|
|
* HTTP long-polling based on the built-in `XMLHttpRequest` object.
|
|
*
|
|
* Usage: browser
|
|
*
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
|
|
*/
|
|
class XHR extends BaseXHR {
|
|
constructor(opts) {
|
|
super(opts);
|
|
const forceBase64 = opts && opts.forceBase64;
|
|
this.supportsBinary = hasXHR2 && !forceBase64;
|
|
}
|
|
request(opts = {}) {
|
|
Object.assign(opts, { xd: this.xd }, this.opts);
|
|
return new Request(newRequest, this.uri(), opts);
|
|
}
|
|
}
|
|
pollingXhr.XHR = XHR;
|
|
function newRequest(opts) {
|
|
const xdomain = opts.xdomain;
|
|
// XMLHttpRequest can be disabled on IE
|
|
try {
|
|
if ("undefined" !== typeof XMLHttpRequest && (!xdomain || has_cors_js_1.hasCORS)) {
|
|
return new XMLHttpRequest();
|
|
}
|
|
}
|
|
catch (e) { }
|
|
if (!xdomain) {
|
|
try {
|
|
return new globals_node_js_1$3.globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
|
|
}
|
|
catch (e) { }
|
|
}
|
|
}
|
|
|
|
var websocket = {};
|
|
|
|
var __importDefault$5 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(websocket, "__esModule", { value: true });
|
|
websocket.WS = websocket.BaseWS = void 0;
|
|
const transport_js_1$1 = transport;
|
|
const util_js_1$1 = util;
|
|
const engine_io_parser_1$2 = cjs$1;
|
|
const globals_node_js_1$2 = globals;
|
|
const debug_1$5 = __importDefault$5(browserExports); // debug()
|
|
const debug$5 = (0, debug_1$5.default)("engine.io-client:websocket"); // debug()
|
|
// detect ReactNative environment
|
|
const isReactNative = typeof navigator !== "undefined" &&
|
|
typeof navigator.product === "string" &&
|
|
navigator.product.toLowerCase() === "reactnative";
|
|
class BaseWS extends transport_js_1$1.Transport {
|
|
get name() {
|
|
return "websocket";
|
|
}
|
|
doOpen() {
|
|
const uri = this.uri();
|
|
const protocols = this.opts.protocols;
|
|
// React Native only supports the 'headers' option, and will print a warning if anything else is passed
|
|
const opts = isReactNative
|
|
? {}
|
|
: (0, util_js_1$1.pick)(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
|
|
if (this.opts.extraHeaders) {
|
|
opts.headers = this.opts.extraHeaders;
|
|
}
|
|
try {
|
|
this.ws = this.createSocket(uri, protocols, opts);
|
|
}
|
|
catch (err) {
|
|
return this.emitReserved("error", err);
|
|
}
|
|
this.ws.binaryType = this.socket.binaryType;
|
|
this.addEventListeners();
|
|
}
|
|
/**
|
|
* Adds event listeners to the socket
|
|
*
|
|
* @private
|
|
*/
|
|
addEventListeners() {
|
|
this.ws.onopen = () => {
|
|
if (this.opts.autoUnref) {
|
|
this.ws._socket.unref();
|
|
}
|
|
this.onOpen();
|
|
};
|
|
this.ws.onclose = (closeEvent) => this.onClose({
|
|
description: "websocket connection closed",
|
|
context: closeEvent,
|
|
});
|
|
this.ws.onmessage = (ev) => this.onData(ev.data);
|
|
this.ws.onerror = (e) => this.onError("websocket error", e);
|
|
}
|
|
write(packets) {
|
|
this.writable = false;
|
|
// encodePacket efficient as it uses WS framing
|
|
// no need for encodePayload
|
|
for (let i = 0; i < packets.length; i++) {
|
|
const packet = packets[i];
|
|
const lastPacket = i === packets.length - 1;
|
|
(0, engine_io_parser_1$2.encodePacket)(packet, this.supportsBinary, (data) => {
|
|
// Sometimes the websocket has already been closed but the browser didn't
|
|
// have a chance of informing us about it yet, in that case send will
|
|
// throw an error
|
|
try {
|
|
this.doWrite(packet, data);
|
|
}
|
|
catch (e) {
|
|
debug$5("websocket closed before onclose event");
|
|
}
|
|
if (lastPacket) {
|
|
// fake drain
|
|
// defer to next tick to allow Socket to clear writeBuffer
|
|
(0, globals_node_js_1$2.nextTick)(() => {
|
|
this.writable = true;
|
|
this.emitReserved("drain");
|
|
}, this.setTimeoutFn);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
doClose() {
|
|
if (typeof this.ws !== "undefined") {
|
|
this.ws.onerror = () => { };
|
|
this.ws.close();
|
|
this.ws = null;
|
|
}
|
|
}
|
|
/**
|
|
* Generates uri for connection.
|
|
*
|
|
* @private
|
|
*/
|
|
uri() {
|
|
const schema = this.opts.secure ? "wss" : "ws";
|
|
const query = this.query || {};
|
|
// append timestamp to URI
|
|
if (this.opts.timestampRequests) {
|
|
query[this.opts.timestampParam] = (0, util_js_1$1.randomString)();
|
|
}
|
|
// communicate binary support capabilities
|
|
if (!this.supportsBinary) {
|
|
query.b64 = 1;
|
|
}
|
|
return this.createUri(schema, query);
|
|
}
|
|
}
|
|
websocket.BaseWS = BaseWS;
|
|
const WebSocketCtor = globals_node_js_1$2.globalThisShim.WebSocket || globals_node_js_1$2.globalThisShim.MozWebSocket;
|
|
/**
|
|
* WebSocket transport based on the built-in `WebSocket` object.
|
|
*
|
|
* Usage: browser, Node.js (since v21), Deno, Bun
|
|
*
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
|
|
* @see https://caniuse.com/mdn-api_websocket
|
|
* @see https://nodejs.org/api/globals.html#websocket
|
|
*/
|
|
class WS extends BaseWS {
|
|
createSocket(uri, protocols, opts) {
|
|
return !isReactNative
|
|
? protocols
|
|
? new WebSocketCtor(uri, protocols)
|
|
: new WebSocketCtor(uri)
|
|
: new WebSocketCtor(uri, protocols, opts);
|
|
}
|
|
doWrite(_packet, data) {
|
|
this.ws.send(data);
|
|
}
|
|
}
|
|
websocket.WS = WS;
|
|
|
|
var webtransport = {};
|
|
|
|
var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(webtransport, "__esModule", { value: true });
|
|
webtransport.WT = void 0;
|
|
const transport_js_1 = transport;
|
|
const globals_node_js_1$1 = globals;
|
|
const engine_io_parser_1$1 = cjs$1;
|
|
const debug_1$4 = __importDefault$4(browserExports); // debug()
|
|
const debug$4 = (0, debug_1$4.default)("engine.io-client:webtransport"); // debug()
|
|
/**
|
|
* WebTransport transport based on the built-in `WebTransport` object.
|
|
*
|
|
* Usage: browser, Node.js (with the `@fails-components/webtransport` package)
|
|
*
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
|
|
* @see https://caniuse.com/webtransport
|
|
*/
|
|
class WT extends transport_js_1.Transport {
|
|
get name() {
|
|
return "webtransport";
|
|
}
|
|
doOpen() {
|
|
try {
|
|
// @ts-ignore
|
|
this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
|
|
}
|
|
catch (err) {
|
|
return this.emitReserved("error", err);
|
|
}
|
|
this._transport.closed
|
|
.then(() => {
|
|
debug$4("transport closed gracefully");
|
|
this.onClose();
|
|
})
|
|
.catch((err) => {
|
|
debug$4("transport closed due to %s", err);
|
|
this.onError("webtransport error", err);
|
|
});
|
|
// note: we could have used async/await, but that would require some additional polyfills
|
|
this._transport.ready.then(() => {
|
|
this._transport.createBidirectionalStream().then((stream) => {
|
|
const decoderStream = (0, engine_io_parser_1$1.createPacketDecoderStream)(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
|
|
const reader = stream.readable.pipeThrough(decoderStream).getReader();
|
|
const encoderStream = (0, engine_io_parser_1$1.createPacketEncoderStream)();
|
|
encoderStream.readable.pipeTo(stream.writable);
|
|
this._writer = encoderStream.writable.getWriter();
|
|
const read = () => {
|
|
reader
|
|
.read()
|
|
.then(({ done, value }) => {
|
|
if (done) {
|
|
debug$4("session is closed");
|
|
return;
|
|
}
|
|
debug$4("received chunk: %o", value);
|
|
this.onPacket(value);
|
|
read();
|
|
})
|
|
.catch((err) => {
|
|
debug$4("an error occurred while reading: %s", err);
|
|
});
|
|
};
|
|
read();
|
|
const packet = { type: "open" };
|
|
if (this.query.sid) {
|
|
packet.data = `{"sid":"${this.query.sid}"}`;
|
|
}
|
|
this._writer.write(packet).then(() => this.onOpen());
|
|
});
|
|
});
|
|
}
|
|
write(packets) {
|
|
this.writable = false;
|
|
for (let i = 0; i < packets.length; i++) {
|
|
const packet = packets[i];
|
|
const lastPacket = i === packets.length - 1;
|
|
this._writer.write(packet).then(() => {
|
|
if (lastPacket) {
|
|
(0, globals_node_js_1$1.nextTick)(() => {
|
|
this.writable = true;
|
|
this.emitReserved("drain");
|
|
}, this.setTimeoutFn);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
doClose() {
|
|
var _a;
|
|
(_a = this._transport) === null || _a === void 0 ? void 0 : _a.close();
|
|
}
|
|
}
|
|
webtransport.WT = WT;
|
|
|
|
Object.defineProperty(transports, "__esModule", { value: true });
|
|
transports.transports = void 0;
|
|
const polling_xhr_node_js_1 = pollingXhr;
|
|
const websocket_node_js_1 = websocket;
|
|
const webtransport_js_1 = webtransport;
|
|
transports.transports = {
|
|
websocket: websocket_node_js_1.WS,
|
|
webtransport: webtransport_js_1.WT,
|
|
polling: polling_xhr_node_js_1.XHR,
|
|
};
|
|
|
|
var parseuri = {};
|
|
|
|
Object.defineProperty(parseuri, "__esModule", { value: true });
|
|
parseuri.parse = parse;
|
|
// imported from https://github.com/galkn/parseuri
|
|
/**
|
|
* Parses a URI
|
|
*
|
|
* Note: we could also have used the built-in URL object, but it isn't supported on all platforms.
|
|
*
|
|
* See:
|
|
* - https://developer.mozilla.org/en-US/docs/Web/API/URL
|
|
* - https://caniuse.com/url
|
|
* - https://www.rfc-editor.org/rfc/rfc3986#appendix-B
|
|
*
|
|
* History of the parse() method:
|
|
* - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c
|
|
* - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3
|
|
* - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242
|
|
*
|
|
* @author Steven Levithan <stevenlevithan.com> (MIT license)
|
|
* @api private
|
|
*/
|
|
const re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
|
|
const parts = [
|
|
'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
|
|
];
|
|
function parse(str) {
|
|
if (str.length > 8000) {
|
|
throw "URI too long";
|
|
}
|
|
const src = str, b = str.indexOf('['), e = str.indexOf(']');
|
|
if (b != -1 && e != -1) {
|
|
str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
|
|
}
|
|
let m = re.exec(str || ''), uri = {}, i = 14;
|
|
while (i--) {
|
|
uri[parts[i]] = m[i] || '';
|
|
}
|
|
if (b != -1 && e != -1) {
|
|
uri.source = src;
|
|
uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
|
|
uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
|
|
uri.ipv6uri = true;
|
|
}
|
|
uri.pathNames = pathNames(uri, uri['path']);
|
|
uri.queryKey = queryKey(uri, uri['query']);
|
|
return uri;
|
|
}
|
|
function pathNames(obj, path) {
|
|
const regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/");
|
|
if (path.slice(0, 1) == '/' || path.length === 0) {
|
|
names.splice(0, 1);
|
|
}
|
|
if (path.slice(-1) == '/') {
|
|
names.splice(names.length - 1, 1);
|
|
}
|
|
return names;
|
|
}
|
|
function queryKey(uri, query) {
|
|
const data = {};
|
|
query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {
|
|
if ($1) {
|
|
data[$1] = $2;
|
|
}
|
|
});
|
|
return data;
|
|
}
|
|
|
|
var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(socket$2, "__esModule", { value: true });
|
|
socket$2.Socket = socket$2.SocketWithUpgrade = socket$2.SocketWithoutUpgrade = void 0;
|
|
const index_js_1 = transports;
|
|
const util_js_1 = util;
|
|
const parseqs_js_1 = parseqs;
|
|
const parseuri_js_1 = parseuri;
|
|
const component_emitter_1$2 = require$$5;
|
|
const engine_io_parser_1 = cjs$1;
|
|
const globals_node_js_1 = globals;
|
|
const debug_1$3 = __importDefault$3(browserExports); // debug()
|
|
const debug$3 = (0, debug_1$3.default)("engine.io-client:socket"); // debug()
|
|
const withEventListeners = typeof addEventListener === "function" &&
|
|
typeof removeEventListener === "function";
|
|
const OFFLINE_EVENT_LISTENERS = [];
|
|
if (withEventListeners) {
|
|
// within a ServiceWorker, any event handler for the 'offline' event must be added on the initial evaluation of the
|
|
// script, so we create one single event listener here which will forward the event to the socket instances
|
|
addEventListener("offline", () => {
|
|
debug$3("closing %d connection(s) because the network was lost", OFFLINE_EVENT_LISTENERS.length);
|
|
OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());
|
|
}, false);
|
|
}
|
|
/**
|
|
* This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
|
|
* with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
|
|
*
|
|
* This class comes without upgrade mechanism, which means that it will keep the first low-level transport that
|
|
* successfully establishes the connection.
|
|
*
|
|
* In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
|
|
*
|
|
* @example
|
|
* import { SocketWithoutUpgrade, WebSocket } from "engine.io-client";
|
|
*
|
|
* const socket = new SocketWithoutUpgrade({
|
|
* transports: [WebSocket]
|
|
* });
|
|
*
|
|
* socket.on("open", () => {
|
|
* socket.send("hello");
|
|
* });
|
|
*
|
|
* @see SocketWithUpgrade
|
|
* @see Socket
|
|
*/
|
|
class SocketWithoutUpgrade extends component_emitter_1$2.Emitter {
|
|
/**
|
|
* Socket constructor.
|
|
*
|
|
* @param {String|Object} uri - uri or options
|
|
* @param {Object} opts - options
|
|
*/
|
|
constructor(uri, opts) {
|
|
super();
|
|
this.binaryType = globals_node_js_1.defaultBinaryType;
|
|
this.writeBuffer = [];
|
|
this._prevBufferLen = 0;
|
|
this._pingInterval = -1;
|
|
this._pingTimeout = -1;
|
|
this._maxPayload = -1;
|
|
/**
|
|
* The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the
|
|
* callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.
|
|
*/
|
|
this._pingTimeoutTime = Infinity;
|
|
if (uri && "object" === typeof uri) {
|
|
opts = uri;
|
|
uri = null;
|
|
}
|
|
if (uri) {
|
|
const parsedUri = (0, parseuri_js_1.parse)(uri);
|
|
opts.hostname = parsedUri.host;
|
|
opts.secure =
|
|
parsedUri.protocol === "https" || parsedUri.protocol === "wss";
|
|
opts.port = parsedUri.port;
|
|
if (parsedUri.query)
|
|
opts.query = parsedUri.query;
|
|
}
|
|
else if (opts.host) {
|
|
opts.hostname = (0, parseuri_js_1.parse)(opts.host).host;
|
|
}
|
|
(0, util_js_1.installTimerFunctions)(this, opts);
|
|
this.secure =
|
|
null != opts.secure
|
|
? opts.secure
|
|
: typeof location !== "undefined" && "https:" === location.protocol;
|
|
if (opts.hostname && !opts.port) {
|
|
// if no port is specified manually, use the protocol default
|
|
opts.port = this.secure ? "443" : "80";
|
|
}
|
|
this.hostname =
|
|
opts.hostname ||
|
|
(typeof location !== "undefined" ? location.hostname : "localhost");
|
|
this.port =
|
|
opts.port ||
|
|
(typeof location !== "undefined" && location.port
|
|
? location.port
|
|
: this.secure
|
|
? "443"
|
|
: "80");
|
|
this.transports = [];
|
|
this._transportsByName = {};
|
|
opts.transports.forEach((t) => {
|
|
const transportName = t.prototype.name;
|
|
this.transports.push(transportName);
|
|
this._transportsByName[transportName] = t;
|
|
});
|
|
this.opts = Object.assign({
|
|
path: "/engine.io",
|
|
agent: false,
|
|
withCredentials: false,
|
|
upgrade: true,
|
|
timestampParam: "t",
|
|
rememberUpgrade: false,
|
|
addTrailingSlash: true,
|
|
rejectUnauthorized: true,
|
|
perMessageDeflate: {
|
|
threshold: 1024,
|
|
},
|
|
transportOptions: {},
|
|
closeOnBeforeunload: false,
|
|
}, opts);
|
|
this.opts.path =
|
|
this.opts.path.replace(/\/$/, "") +
|
|
(this.opts.addTrailingSlash ? "/" : "");
|
|
if (typeof this.opts.query === "string") {
|
|
this.opts.query = (0, parseqs_js_1.decode)(this.opts.query);
|
|
}
|
|
if (withEventListeners) {
|
|
if (this.opts.closeOnBeforeunload) {
|
|
// Firefox closes the connection when the "beforeunload" event is emitted but not Chrome. This event listener
|
|
// ensures every browser behaves the same (no "disconnect" event at the Socket.IO level when the page is
|
|
// closed/reloaded)
|
|
this._beforeunloadEventListener = () => {
|
|
if (this.transport) {
|
|
// silently close the transport
|
|
this.transport.removeAllListeners();
|
|
this.transport.close();
|
|
}
|
|
};
|
|
addEventListener("beforeunload", this._beforeunloadEventListener, false);
|
|
}
|
|
if (this.hostname !== "localhost") {
|
|
debug$3("adding listener for the 'offline' event");
|
|
this._offlineEventListener = () => {
|
|
this._onClose("transport close", {
|
|
description: "network connection lost",
|
|
});
|
|
};
|
|
OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
|
|
}
|
|
}
|
|
if (this.opts.withCredentials) {
|
|
this._cookieJar = (0, globals_node_js_1.createCookieJar)();
|
|
}
|
|
this._open();
|
|
}
|
|
/**
|
|
* Creates transport of the given type.
|
|
*
|
|
* @param {String} name - transport name
|
|
* @return {Transport}
|
|
* @private
|
|
*/
|
|
createTransport(name) {
|
|
debug$3('creating transport "%s"', name);
|
|
const query = Object.assign({}, this.opts.query);
|
|
// append engine.io protocol identifier
|
|
query.EIO = engine_io_parser_1.protocol;
|
|
// transport name
|
|
query.transport = name;
|
|
// session id if we already have one
|
|
if (this.id)
|
|
query.sid = this.id;
|
|
const opts = Object.assign({}, this.opts, {
|
|
query,
|
|
socket: this,
|
|
hostname: this.hostname,
|
|
secure: this.secure,
|
|
port: this.port,
|
|
}, this.opts.transportOptions[name]);
|
|
debug$3("options: %j", opts);
|
|
return new this._transportsByName[name](opts);
|
|
}
|
|
/**
|
|
* Initializes transport to use and starts probe.
|
|
*
|
|
* @private
|
|
*/
|
|
_open() {
|
|
if (this.transports.length === 0) {
|
|
// Emit error on next tick so it can be listened to
|
|
this.setTimeoutFn(() => {
|
|
this.emitReserved("error", "No transports available");
|
|
}, 0);
|
|
return;
|
|
}
|
|
const transportName = this.opts.rememberUpgrade &&
|
|
SocketWithoutUpgrade.priorWebsocketSuccess &&
|
|
this.transports.indexOf("websocket") !== -1
|
|
? "websocket"
|
|
: this.transports[0];
|
|
this.readyState = "opening";
|
|
const transport = this.createTransport(transportName);
|
|
transport.open();
|
|
this.setTransport(transport);
|
|
}
|
|
/**
|
|
* Sets the current transport. Disables the existing one (if any).
|
|
*
|
|
* @private
|
|
*/
|
|
setTransport(transport) {
|
|
debug$3("setting transport %s", transport.name);
|
|
if (this.transport) {
|
|
debug$3("clearing existing transport %s", this.transport.name);
|
|
this.transport.removeAllListeners();
|
|
}
|
|
// set up transport
|
|
this.transport = transport;
|
|
// set up transport listeners
|
|
transport
|
|
.on("drain", this._onDrain.bind(this))
|
|
.on("packet", this._onPacket.bind(this))
|
|
.on("error", this._onError.bind(this))
|
|
.on("close", (reason) => this._onClose("transport close", reason));
|
|
}
|
|
/**
|
|
* Called when connection is deemed open.
|
|
*
|
|
* @private
|
|
*/
|
|
onOpen() {
|
|
debug$3("socket open");
|
|
this.readyState = "open";
|
|
SocketWithoutUpgrade.priorWebsocketSuccess =
|
|
"websocket" === this.transport.name;
|
|
this.emitReserved("open");
|
|
this.flush();
|
|
}
|
|
/**
|
|
* Handles a packet.
|
|
*
|
|
* @private
|
|
*/
|
|
_onPacket(packet) {
|
|
if ("opening" === this.readyState ||
|
|
"open" === this.readyState ||
|
|
"closing" === this.readyState) {
|
|
debug$3('socket receive: type "%s", data "%s"', packet.type, packet.data);
|
|
this.emitReserved("packet", packet);
|
|
// Socket is live - any packet counts
|
|
this.emitReserved("heartbeat");
|
|
switch (packet.type) {
|
|
case "open":
|
|
this.onHandshake(JSON.parse(packet.data));
|
|
break;
|
|
case "ping":
|
|
this._sendPacket("pong");
|
|
this.emitReserved("ping");
|
|
this.emitReserved("pong");
|
|
this._resetPingTimeout();
|
|
break;
|
|
case "error":
|
|
const err = new Error("server error");
|
|
// @ts-ignore
|
|
err.code = packet.data;
|
|
this._onError(err);
|
|
break;
|
|
case "message":
|
|
this.emitReserved("data", packet.data);
|
|
this.emitReserved("message", packet.data);
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
debug$3('packet received with socket readyState "%s"', this.readyState);
|
|
}
|
|
}
|
|
/**
|
|
* Called upon handshake completion.
|
|
*
|
|
* @param {Object} data - handshake obj
|
|
* @private
|
|
*/
|
|
onHandshake(data) {
|
|
this.emitReserved("handshake", data);
|
|
this.id = data.sid;
|
|
this.transport.query.sid = data.sid;
|
|
this._pingInterval = data.pingInterval;
|
|
this._pingTimeout = data.pingTimeout;
|
|
this._maxPayload = data.maxPayload;
|
|
this.onOpen();
|
|
// In case open handler closes socket
|
|
if ("closed" === this.readyState)
|
|
return;
|
|
this._resetPingTimeout();
|
|
}
|
|
/**
|
|
* Sets and resets ping timeout timer based on server pings.
|
|
*
|
|
* @private
|
|
*/
|
|
_resetPingTimeout() {
|
|
this.clearTimeoutFn(this._pingTimeoutTimer);
|
|
const delay = this._pingInterval + this._pingTimeout;
|
|
this._pingTimeoutTime = Date.now() + delay;
|
|
this._pingTimeoutTimer = this.setTimeoutFn(() => {
|
|
this._onClose("ping timeout");
|
|
}, delay);
|
|
if (this.opts.autoUnref) {
|
|
this._pingTimeoutTimer.unref();
|
|
}
|
|
}
|
|
/**
|
|
* Called on `drain` event
|
|
*
|
|
* @private
|
|
*/
|
|
_onDrain() {
|
|
this.writeBuffer.splice(0, this._prevBufferLen);
|
|
// setting prevBufferLen = 0 is very important
|
|
// for example, when upgrading, upgrade packet is sent over,
|
|
// and a nonzero prevBufferLen could cause problems on `drain`
|
|
this._prevBufferLen = 0;
|
|
if (0 === this.writeBuffer.length) {
|
|
this.emitReserved("drain");
|
|
}
|
|
else {
|
|
this.flush();
|
|
}
|
|
}
|
|
/**
|
|
* Flush write buffers.
|
|
*
|
|
* @private
|
|
*/
|
|
flush() {
|
|
if ("closed" !== this.readyState &&
|
|
this.transport.writable &&
|
|
!this.upgrading &&
|
|
this.writeBuffer.length) {
|
|
const packets = this._getWritablePackets();
|
|
debug$3("flushing %d packets in socket", packets.length);
|
|
this.transport.send(packets);
|
|
// keep track of current length of writeBuffer
|
|
// splice writeBuffer and callbackBuffer on `drain`
|
|
this._prevBufferLen = packets.length;
|
|
this.emitReserved("flush");
|
|
}
|
|
}
|
|
/**
|
|
* Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
|
|
* long-polling)
|
|
*
|
|
* @private
|
|
*/
|
|
_getWritablePackets() {
|
|
const shouldCheckPayloadSize = this._maxPayload &&
|
|
this.transport.name === "polling" &&
|
|
this.writeBuffer.length > 1;
|
|
if (!shouldCheckPayloadSize) {
|
|
return this.writeBuffer;
|
|
}
|
|
let payloadSize = 1; // first packet type
|
|
for (let i = 0; i < this.writeBuffer.length; i++) {
|
|
const data = this.writeBuffer[i].data;
|
|
if (data) {
|
|
payloadSize += (0, util_js_1.byteLength)(data);
|
|
}
|
|
if (i > 0 && payloadSize > this._maxPayload) {
|
|
debug$3("only send %d out of %d packets", i, this.writeBuffer.length);
|
|
return this.writeBuffer.slice(0, i);
|
|
}
|
|
payloadSize += 2; // separator + packet type
|
|
}
|
|
debug$3("payload size is %d (max: %d)", payloadSize, this._maxPayload);
|
|
return this.writeBuffer;
|
|
}
|
|
/**
|
|
* Checks whether the heartbeat timer has expired but the socket has not yet been notified.
|
|
*
|
|
* Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
|
|
* `write()` method then the message would not be buffered by the Socket.IO client.
|
|
*
|
|
* @return {boolean}
|
|
* @private
|
|
*/
|
|
/* private */ _hasPingExpired() {
|
|
if (!this._pingTimeoutTime)
|
|
return true;
|
|
const hasExpired = Date.now() > this._pingTimeoutTime;
|
|
if (hasExpired) {
|
|
debug$3("throttled timer detected, scheduling connection close");
|
|
this._pingTimeoutTime = 0;
|
|
(0, globals_node_js_1.nextTick)(() => {
|
|
this._onClose("ping timeout");
|
|
}, this.setTimeoutFn);
|
|
}
|
|
return hasExpired;
|
|
}
|
|
/**
|
|
* Sends a message.
|
|
*
|
|
* @param {String} msg - message.
|
|
* @param {Object} options.
|
|
* @param {Function} fn - callback function.
|
|
* @return {Socket} for chaining.
|
|
*/
|
|
write(msg, options, fn) {
|
|
this._sendPacket("message", msg, options, fn);
|
|
return this;
|
|
}
|
|
/**
|
|
* Sends a message. Alias of {@link Socket#write}.
|
|
*
|
|
* @param {String} msg - message.
|
|
* @param {Object} options.
|
|
* @param {Function} fn - callback function.
|
|
* @return {Socket} for chaining.
|
|
*/
|
|
send(msg, options, fn) {
|
|
this._sendPacket("message", msg, options, fn);
|
|
return this;
|
|
}
|
|
/**
|
|
* Sends a packet.
|
|
*
|
|
* @param {String} type: packet type.
|
|
* @param {String} data.
|
|
* @param {Object} options.
|
|
* @param {Function} fn - callback function.
|
|
* @private
|
|
*/
|
|
_sendPacket(type, data, options, fn) {
|
|
if ("function" === typeof data) {
|
|
fn = data;
|
|
data = undefined;
|
|
}
|
|
if ("function" === typeof options) {
|
|
fn = options;
|
|
options = null;
|
|
}
|
|
if ("closing" === this.readyState || "closed" === this.readyState) {
|
|
return;
|
|
}
|
|
options = options || {};
|
|
options.compress = false !== options.compress;
|
|
const packet = {
|
|
type: type,
|
|
data: data,
|
|
options: options,
|
|
};
|
|
this.emitReserved("packetCreate", packet);
|
|
this.writeBuffer.push(packet);
|
|
if (fn)
|
|
this.once("flush", fn);
|
|
this.flush();
|
|
}
|
|
/**
|
|
* Closes the connection.
|
|
*/
|
|
close() {
|
|
const close = () => {
|
|
this._onClose("forced close");
|
|
debug$3("socket closing - telling transport to close");
|
|
this.transport.close();
|
|
};
|
|
const cleanupAndClose = () => {
|
|
this.off("upgrade", cleanupAndClose);
|
|
this.off("upgradeError", cleanupAndClose);
|
|
close();
|
|
};
|
|
const waitForUpgrade = () => {
|
|
// wait for upgrade to finish since we can't send packets while pausing a transport
|
|
this.once("upgrade", cleanupAndClose);
|
|
this.once("upgradeError", cleanupAndClose);
|
|
};
|
|
if ("opening" === this.readyState || "open" === this.readyState) {
|
|
this.readyState = "closing";
|
|
if (this.writeBuffer.length) {
|
|
this.once("drain", () => {
|
|
if (this.upgrading) {
|
|
waitForUpgrade();
|
|
}
|
|
else {
|
|
close();
|
|
}
|
|
});
|
|
}
|
|
else if (this.upgrading) {
|
|
waitForUpgrade();
|
|
}
|
|
else {
|
|
close();
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Called upon transport error
|
|
*
|
|
* @private
|
|
*/
|
|
_onError(err) {
|
|
debug$3("socket error %j", err);
|
|
SocketWithoutUpgrade.priorWebsocketSuccess = false;
|
|
if (this.opts.tryAllTransports &&
|
|
this.transports.length > 1 &&
|
|
this.readyState === "opening") {
|
|
debug$3("trying next transport");
|
|
this.transports.shift();
|
|
return this._open();
|
|
}
|
|
this.emitReserved("error", err);
|
|
this._onClose("transport error", err);
|
|
}
|
|
/**
|
|
* Called upon transport close.
|
|
*
|
|
* @private
|
|
*/
|
|
_onClose(reason, description) {
|
|
if ("opening" === this.readyState ||
|
|
"open" === this.readyState ||
|
|
"closing" === this.readyState) {
|
|
debug$3('socket close with reason: "%s"', reason);
|
|
// clear timers
|
|
this.clearTimeoutFn(this._pingTimeoutTimer);
|
|
// stop event from firing again for transport
|
|
this.transport.removeAllListeners("close");
|
|
// ensure transport won't stay open
|
|
this.transport.close();
|
|
// ignore further transport communication
|
|
this.transport.removeAllListeners();
|
|
if (withEventListeners) {
|
|
if (this._beforeunloadEventListener) {
|
|
removeEventListener("beforeunload", this._beforeunloadEventListener, false);
|
|
}
|
|
if (this._offlineEventListener) {
|
|
const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);
|
|
if (i !== -1) {
|
|
debug$3("removing listener for the 'offline' event");
|
|
OFFLINE_EVENT_LISTENERS.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
// set ready state
|
|
this.readyState = "closed";
|
|
// clear session id
|
|
this.id = null;
|
|
// emit close event
|
|
this.emitReserved("close", reason, description);
|
|
// clean buffers after, so users can still
|
|
// grab the buffers on `close` event
|
|
this.writeBuffer = [];
|
|
this._prevBufferLen = 0;
|
|
}
|
|
}
|
|
}
|
|
socket$2.SocketWithoutUpgrade = SocketWithoutUpgrade;
|
|
SocketWithoutUpgrade.protocol = engine_io_parser_1.protocol;
|
|
/**
|
|
* This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
|
|
* with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
|
|
*
|
|
* This class comes with an upgrade mechanism, which means that once the connection is established with the first
|
|
* low-level transport, it will try to upgrade to a better transport.
|
|
*
|
|
* In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
|
|
*
|
|
* @example
|
|
* import { SocketWithUpgrade, WebSocket } from "engine.io-client";
|
|
*
|
|
* const socket = new SocketWithUpgrade({
|
|
* transports: [WebSocket]
|
|
* });
|
|
*
|
|
* socket.on("open", () => {
|
|
* socket.send("hello");
|
|
* });
|
|
*
|
|
* @see SocketWithoutUpgrade
|
|
* @see Socket
|
|
*/
|
|
class SocketWithUpgrade extends SocketWithoutUpgrade {
|
|
constructor() {
|
|
super(...arguments);
|
|
this._upgrades = [];
|
|
}
|
|
onOpen() {
|
|
super.onOpen();
|
|
if ("open" === this.readyState && this.opts.upgrade) {
|
|
debug$3("starting upgrade probes");
|
|
for (let i = 0; i < this._upgrades.length; i++) {
|
|
this._probe(this._upgrades[i]);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Probes a transport.
|
|
*
|
|
* @param {String} name - transport name
|
|
* @private
|
|
*/
|
|
_probe(name) {
|
|
debug$3('probing transport "%s"', name);
|
|
let transport = this.createTransport(name);
|
|
let failed = false;
|
|
SocketWithoutUpgrade.priorWebsocketSuccess = false;
|
|
const onTransportOpen = () => {
|
|
if (failed)
|
|
return;
|
|
debug$3('probe transport "%s" opened', name);
|
|
transport.send([{ type: "ping", data: "probe" }]);
|
|
transport.once("packet", (msg) => {
|
|
if (failed)
|
|
return;
|
|
if ("pong" === msg.type && "probe" === msg.data) {
|
|
debug$3('probe transport "%s" pong', name);
|
|
this.upgrading = true;
|
|
this.emitReserved("upgrading", transport);
|
|
if (!transport)
|
|
return;
|
|
SocketWithoutUpgrade.priorWebsocketSuccess =
|
|
"websocket" === transport.name;
|
|
debug$3('pausing current transport "%s"', this.transport.name);
|
|
this.transport.pause(() => {
|
|
if (failed)
|
|
return;
|
|
if ("closed" === this.readyState)
|
|
return;
|
|
debug$3("changing transport and sending upgrade packet");
|
|
cleanup();
|
|
this.setTransport(transport);
|
|
transport.send([{ type: "upgrade" }]);
|
|
this.emitReserved("upgrade", transport);
|
|
transport = null;
|
|
this.upgrading = false;
|
|
this.flush();
|
|
});
|
|
}
|
|
else {
|
|
debug$3('probe transport "%s" failed', name);
|
|
const err = new Error("probe error");
|
|
// @ts-ignore
|
|
err.transport = transport.name;
|
|
this.emitReserved("upgradeError", err);
|
|
}
|
|
});
|
|
};
|
|
function freezeTransport() {
|
|
if (failed)
|
|
return;
|
|
// Any callback called by transport should be ignored since now
|
|
failed = true;
|
|
cleanup();
|
|
transport.close();
|
|
transport = null;
|
|
}
|
|
// Handle any error that happens while probing
|
|
const onerror = (err) => {
|
|
const error = new Error("probe error: " + err);
|
|
// @ts-ignore
|
|
error.transport = transport.name;
|
|
freezeTransport();
|
|
debug$3('probe transport "%s" failed because of error: %s', name, err);
|
|
this.emitReserved("upgradeError", error);
|
|
};
|
|
function onTransportClose() {
|
|
onerror("transport closed");
|
|
}
|
|
// When the socket is closed while we're probing
|
|
function onclose() {
|
|
onerror("socket closed");
|
|
}
|
|
// When the socket is upgraded while we're probing
|
|
function onupgrade(to) {
|
|
if (transport && to.name !== transport.name) {
|
|
debug$3('"%s" works - aborting "%s"', to.name, transport.name);
|
|
freezeTransport();
|
|
}
|
|
}
|
|
// Remove all listeners on the transport and on self
|
|
const cleanup = () => {
|
|
transport.removeListener("open", onTransportOpen);
|
|
transport.removeListener("error", onerror);
|
|
transport.removeListener("close", onTransportClose);
|
|
this.off("close", onclose);
|
|
this.off("upgrading", onupgrade);
|
|
};
|
|
transport.once("open", onTransportOpen);
|
|
transport.once("error", onerror);
|
|
transport.once("close", onTransportClose);
|
|
this.once("close", onclose);
|
|
this.once("upgrading", onupgrade);
|
|
if (this._upgrades.indexOf("webtransport") !== -1 &&
|
|
name !== "webtransport") {
|
|
// favor WebTransport
|
|
this.setTimeoutFn(() => {
|
|
if (!failed) {
|
|
transport.open();
|
|
}
|
|
}, 200);
|
|
}
|
|
else {
|
|
transport.open();
|
|
}
|
|
}
|
|
onHandshake(data) {
|
|
this._upgrades = this._filterUpgrades(data.upgrades);
|
|
super.onHandshake(data);
|
|
}
|
|
/**
|
|
* Filters upgrades, returning only those matching client transports.
|
|
*
|
|
* @param {Array} upgrades - server upgrades
|
|
* @private
|
|
*/
|
|
_filterUpgrades(upgrades) {
|
|
const filteredUpgrades = [];
|
|
for (let i = 0; i < upgrades.length; i++) {
|
|
if (~this.transports.indexOf(upgrades[i]))
|
|
filteredUpgrades.push(upgrades[i]);
|
|
}
|
|
return filteredUpgrades;
|
|
}
|
|
}
|
|
socket$2.SocketWithUpgrade = SocketWithUpgrade;
|
|
/**
|
|
* This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
|
|
* with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
|
|
*
|
|
* This class comes with an upgrade mechanism, which means that once the connection is established with the first
|
|
* low-level transport, it will try to upgrade to a better transport.
|
|
*
|
|
* @example
|
|
* import { Socket } from "engine.io-client";
|
|
*
|
|
* const socket = new Socket();
|
|
*
|
|
* socket.on("open", () => {
|
|
* socket.send("hello");
|
|
* });
|
|
*
|
|
* @see SocketWithoutUpgrade
|
|
* @see SocketWithUpgrade
|
|
*/
|
|
class Socket$1 extends SocketWithUpgrade {
|
|
constructor(uri, opts = {}) {
|
|
const o = typeof uri === "object" ? uri : opts;
|
|
if (!o.transports ||
|
|
(o.transports && typeof o.transports[0] === "string")) {
|
|
o.transports = (o.transports || ["polling", "websocket", "webtransport"])
|
|
.map((transportName) => index_js_1.transports[transportName])
|
|
.filter((t) => !!t);
|
|
}
|
|
super(uri, o);
|
|
}
|
|
}
|
|
socket$2.Socket = Socket$1;
|
|
|
|
var pollingFetch = {};
|
|
|
|
Object.defineProperty(pollingFetch, "__esModule", { value: true });
|
|
pollingFetch.Fetch = void 0;
|
|
const polling_js_1 = polling;
|
|
/**
|
|
* HTTP long-polling based on the built-in `fetch()` method.
|
|
*
|
|
* Usage: browser, Node.js (since v18), Deno, Bun
|
|
*
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/API/fetch
|
|
* @see https://caniuse.com/fetch
|
|
* @see https://nodejs.org/api/globals.html#fetch
|
|
*/
|
|
class Fetch extends polling_js_1.Polling {
|
|
doPoll() {
|
|
this._fetch()
|
|
.then((res) => {
|
|
if (!res.ok) {
|
|
return this.onError("fetch read error", res.status, res);
|
|
}
|
|
res.text().then((data) => this.onData(data));
|
|
})
|
|
.catch((err) => {
|
|
this.onError("fetch read error", err);
|
|
});
|
|
}
|
|
doWrite(data, callback) {
|
|
this._fetch(data)
|
|
.then((res) => {
|
|
if (!res.ok) {
|
|
return this.onError("fetch write error", res.status, res);
|
|
}
|
|
callback();
|
|
})
|
|
.catch((err) => {
|
|
this.onError("fetch write error", err);
|
|
});
|
|
}
|
|
_fetch(data) {
|
|
var _a;
|
|
const isPost = data !== undefined;
|
|
const headers = new Headers(this.opts.extraHeaders);
|
|
if (isPost) {
|
|
headers.set("content-type", "text/plain;charset=UTF-8");
|
|
}
|
|
(_a = this.socket._cookieJar) === null || _a === void 0 ? void 0 : _a.appendCookies(headers);
|
|
return fetch(this.uri(), {
|
|
method: isPost ? "POST" : "GET",
|
|
body: isPost ? data : null,
|
|
headers,
|
|
credentials: this.opts.withCredentials ? "include" : "omit",
|
|
}).then((res) => {
|
|
var _a;
|
|
// @ts-ignore getSetCookie() was added in Node.js v19.7.0
|
|
(_a = this.socket._cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(res.headers.getSetCookie());
|
|
return res;
|
|
});
|
|
}
|
|
}
|
|
pollingFetch.Fetch = Fetch;
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.WebTransport = exports.WebSocket = exports.NodeWebSocket = exports.XHR = exports.NodeXHR = exports.Fetch = exports.nextTick = exports.parse = exports.installTimerFunctions = exports.transports = exports.TransportError = exports.Transport = exports.protocol = exports.SocketWithUpgrade = exports.SocketWithoutUpgrade = exports.Socket = void 0;
|
|
const socket_js_1 = socket$2;
|
|
Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_js_1.Socket; } });
|
|
var socket_js_2 = socket$2;
|
|
Object.defineProperty(exports, "SocketWithoutUpgrade", { enumerable: true, get: function () { return socket_js_2.SocketWithoutUpgrade; } });
|
|
Object.defineProperty(exports, "SocketWithUpgrade", { enumerable: true, get: function () { return socket_js_2.SocketWithUpgrade; } });
|
|
exports.protocol = socket_js_1.Socket.protocol;
|
|
var transport_js_1 = transport;
|
|
Object.defineProperty(exports, "Transport", { enumerable: true, get: function () { return transport_js_1.Transport; } });
|
|
Object.defineProperty(exports, "TransportError", { enumerable: true, get: function () { return transport_js_1.TransportError; } });
|
|
var index_js_1 = transports;
|
|
Object.defineProperty(exports, "transports", { enumerable: true, get: function () { return index_js_1.transports; } });
|
|
var util_js_1 = util;
|
|
Object.defineProperty(exports, "installTimerFunctions", { enumerable: true, get: function () { return util_js_1.installTimerFunctions; } });
|
|
var parseuri_js_1 = parseuri;
|
|
Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parseuri_js_1.parse; } });
|
|
var globals_node_js_1 = globals;
|
|
Object.defineProperty(exports, "nextTick", { enumerable: true, get: function () { return globals_node_js_1.nextTick; } });
|
|
var polling_fetch_js_1 = pollingFetch;
|
|
Object.defineProperty(exports, "Fetch", { enumerable: true, get: function () { return polling_fetch_js_1.Fetch; } });
|
|
var polling_xhr_node_js_1 = pollingXhr;
|
|
Object.defineProperty(exports, "NodeXHR", { enumerable: true, get: function () { return polling_xhr_node_js_1.XHR; } });
|
|
var polling_xhr_js_1 = pollingXhr;
|
|
Object.defineProperty(exports, "XHR", { enumerable: true, get: function () { return polling_xhr_js_1.XHR; } });
|
|
var websocket_node_js_1 = websocket;
|
|
Object.defineProperty(exports, "NodeWebSocket", { enumerable: true, get: function () { return websocket_node_js_1.WS; } });
|
|
var websocket_js_1 = websocket;
|
|
Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function () { return websocket_js_1.WS; } });
|
|
var webtransport_js_1 = webtransport;
|
|
Object.defineProperty(exports, "WebTransport", { enumerable: true, get: function () { return webtransport_js_1.WT; } });
|
|
} (cjs$2));
|
|
|
|
var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(url$1, "__esModule", { value: true });
|
|
url$1.url = url;
|
|
const engine_io_client_1$1 = cjs$2;
|
|
const debug_1$2 = __importDefault$2(browserExports); // debug()
|
|
const debug$2 = (0, debug_1$2.default)("socket.io-client:url"); // debug()
|
|
/**
|
|
* URL parser.
|
|
*
|
|
* @param uri - url
|
|
* @param path - the request path of the connection
|
|
* @param loc - An object meant to mimic window.location.
|
|
* Defaults to window.location.
|
|
* @public
|
|
*/
|
|
function url(uri, path = "", loc) {
|
|
let obj = uri;
|
|
// default to window.location
|
|
loc = loc || (typeof location !== "undefined" && location);
|
|
if (null == uri)
|
|
uri = loc.protocol + "//" + loc.host;
|
|
// relative path support
|
|
if (typeof uri === "string") {
|
|
if ("/" === uri.charAt(0)) {
|
|
if ("/" === uri.charAt(1)) {
|
|
uri = loc.protocol + uri;
|
|
}
|
|
else {
|
|
uri = loc.host + uri;
|
|
}
|
|
}
|
|
if (!/^(https?|wss?):\/\//.test(uri)) {
|
|
debug$2("protocol-less url %s", uri);
|
|
if ("undefined" !== typeof loc) {
|
|
uri = loc.protocol + "//" + uri;
|
|
}
|
|
else {
|
|
uri = "https://" + uri;
|
|
}
|
|
}
|
|
// parse
|
|
debug$2("parse %s", uri);
|
|
obj = (0, engine_io_client_1$1.parse)(uri);
|
|
}
|
|
// make sure we treat `localhost:80` and `localhost` equally
|
|
if (!obj.port) {
|
|
if (/^(http|ws)$/.test(obj.protocol)) {
|
|
obj.port = "80";
|
|
}
|
|
else if (/^(http|ws)s$/.test(obj.protocol)) {
|
|
obj.port = "443";
|
|
}
|
|
}
|
|
obj.path = obj.path || "/";
|
|
const ipv6 = obj.host.indexOf(":") !== -1;
|
|
const host = ipv6 ? "[" + obj.host + "]" : obj.host;
|
|
// define unique id
|
|
obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
|
|
// define href
|
|
obj.href =
|
|
obj.protocol +
|
|
"://" +
|
|
host +
|
|
(loc && loc.port === obj.port ? "" : ":" + obj.port);
|
|
return obj;
|
|
}
|
|
|
|
var manager = {};
|
|
|
|
var socket$1 = {};
|
|
|
|
var cjs = {};
|
|
|
|
var binary = {};
|
|
|
|
var isBinary$1 = {};
|
|
|
|
Object.defineProperty(isBinary$1, "__esModule", { value: true });
|
|
isBinary$1.hasBinary = isBinary$1.isBinary = void 0;
|
|
const withNativeArrayBuffer = typeof ArrayBuffer === "function";
|
|
const isView = (obj) => {
|
|
return typeof ArrayBuffer.isView === "function"
|
|
? ArrayBuffer.isView(obj)
|
|
: obj.buffer instanceof ArrayBuffer;
|
|
};
|
|
const toString = Object.prototype.toString;
|
|
const withNativeBlob = typeof Blob === "function" ||
|
|
(typeof Blob !== "undefined" &&
|
|
toString.call(Blob) === "[object BlobConstructor]");
|
|
const withNativeFile = typeof File === "function" ||
|
|
(typeof File !== "undefined" &&
|
|
toString.call(File) === "[object FileConstructor]");
|
|
/**
|
|
* Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.
|
|
*
|
|
* @private
|
|
*/
|
|
function isBinary(obj) {
|
|
return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||
|
|
(withNativeBlob && obj instanceof Blob) ||
|
|
(withNativeFile && obj instanceof File));
|
|
}
|
|
isBinary$1.isBinary = isBinary;
|
|
function hasBinary(obj, toJSON) {
|
|
if (!obj || typeof obj !== "object") {
|
|
return false;
|
|
}
|
|
if (Array.isArray(obj)) {
|
|
for (let i = 0, l = obj.length; i < l; i++) {
|
|
if (hasBinary(obj[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
if (isBinary(obj)) {
|
|
return true;
|
|
}
|
|
if (obj.toJSON &&
|
|
typeof obj.toJSON === "function" &&
|
|
arguments.length === 1) {
|
|
return hasBinary(obj.toJSON(), true);
|
|
}
|
|
for (const key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
isBinary$1.hasBinary = hasBinary;
|
|
|
|
Object.defineProperty(binary, "__esModule", { value: true });
|
|
binary.reconstructPacket = binary.deconstructPacket = void 0;
|
|
const is_binary_js_1 = isBinary$1;
|
|
/**
|
|
* Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
|
|
*
|
|
* @param {Object} packet - socket.io event packet
|
|
* @return {Object} with deconstructed packet and list of buffers
|
|
* @public
|
|
*/
|
|
function deconstructPacket(packet) {
|
|
const buffers = [];
|
|
const packetData = packet.data;
|
|
const pack = packet;
|
|
pack.data = _deconstructPacket(packetData, buffers);
|
|
pack.attachments = buffers.length; // number of binary 'attachments'
|
|
return { packet: pack, buffers: buffers };
|
|
}
|
|
binary.deconstructPacket = deconstructPacket;
|
|
function _deconstructPacket(data, buffers) {
|
|
if (!data)
|
|
return data;
|
|
if ((0, is_binary_js_1.isBinary)(data)) {
|
|
const placeholder = { _placeholder: true, num: buffers.length };
|
|
buffers.push(data);
|
|
return placeholder;
|
|
}
|
|
else if (Array.isArray(data)) {
|
|
const newData = new Array(data.length);
|
|
for (let i = 0; i < data.length; i++) {
|
|
newData[i] = _deconstructPacket(data[i], buffers);
|
|
}
|
|
return newData;
|
|
}
|
|
else if (typeof data === "object" && !(data instanceof Date)) {
|
|
const newData = {};
|
|
for (const key in data) {
|
|
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
|
newData[key] = _deconstructPacket(data[key], buffers);
|
|
}
|
|
}
|
|
return newData;
|
|
}
|
|
return data;
|
|
}
|
|
/**
|
|
* Reconstructs a binary packet from its placeholder packet and buffers
|
|
*
|
|
* @param {Object} packet - event packet with placeholders
|
|
* @param {Array} buffers - binary buffers to put in placeholder positions
|
|
* @return {Object} reconstructed packet
|
|
* @public
|
|
*/
|
|
function reconstructPacket(packet, buffers) {
|
|
packet.data = _reconstructPacket(packet.data, buffers);
|
|
delete packet.attachments; // no longer useful
|
|
return packet;
|
|
}
|
|
binary.reconstructPacket = reconstructPacket;
|
|
function _reconstructPacket(data, buffers) {
|
|
if (!data)
|
|
return data;
|
|
if (data && data._placeholder === true) {
|
|
const isIndexValid = typeof data.num === "number" &&
|
|
data.num >= 0 &&
|
|
data.num < buffers.length;
|
|
if (isIndexValid) {
|
|
return buffers[data.num]; // appropriate buffer (should be natural order anyway)
|
|
}
|
|
else {
|
|
throw new Error("illegal attachments");
|
|
}
|
|
}
|
|
else if (Array.isArray(data)) {
|
|
for (let i = 0; i < data.length; i++) {
|
|
data[i] = _reconstructPacket(data[i], buffers);
|
|
}
|
|
}
|
|
else if (typeof data === "object") {
|
|
for (const key in data) {
|
|
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
|
data[key] = _reconstructPacket(data[key], buffers);
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Decoder = exports.Encoder = exports.PacketType = exports.protocol = void 0;
|
|
const component_emitter_1 = require$$5;
|
|
const binary_js_1 = binary;
|
|
const is_binary_js_1 = isBinary$1;
|
|
const debug_1 = browserExports; // debug()
|
|
const debug = (0, debug_1.default)("socket.io-parser"); // debug()
|
|
/**
|
|
* These strings must not be used as event names, as they have a special meaning.
|
|
*/
|
|
const RESERVED_EVENTS = [
|
|
"connect",
|
|
"connect_error",
|
|
"disconnect",
|
|
"disconnecting",
|
|
"newListener",
|
|
"removeListener", // used by the Node.js EventEmitter
|
|
];
|
|
/**
|
|
* Protocol version.
|
|
*
|
|
* @public
|
|
*/
|
|
exports.protocol = 5;
|
|
var PacketType;
|
|
(function (PacketType) {
|
|
PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
|
|
PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
|
|
PacketType[PacketType["EVENT"] = 2] = "EVENT";
|
|
PacketType[PacketType["ACK"] = 3] = "ACK";
|
|
PacketType[PacketType["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
|
|
PacketType[PacketType["BINARY_EVENT"] = 5] = "BINARY_EVENT";
|
|
PacketType[PacketType["BINARY_ACK"] = 6] = "BINARY_ACK";
|
|
})(PacketType = exports.PacketType || (exports.PacketType = {}));
|
|
/**
|
|
* A socket.io Encoder instance
|
|
*/
|
|
class Encoder {
|
|
/**
|
|
* Encoder constructor
|
|
*
|
|
* @param {function} replacer - custom replacer to pass down to JSON.parse
|
|
*/
|
|
constructor(replacer) {
|
|
this.replacer = replacer;
|
|
}
|
|
/**
|
|
* Encode a packet as a single string if non-binary, or as a
|
|
* buffer sequence, depending on packet type.
|
|
*
|
|
* @param {Object} obj - packet object
|
|
*/
|
|
encode(obj) {
|
|
debug("encoding packet %j", obj);
|
|
if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
|
|
if ((0, is_binary_js_1.hasBinary)(obj)) {
|
|
return this.encodeAsBinary({
|
|
type: obj.type === PacketType.EVENT
|
|
? PacketType.BINARY_EVENT
|
|
: PacketType.BINARY_ACK,
|
|
nsp: obj.nsp,
|
|
data: obj.data,
|
|
id: obj.id,
|
|
});
|
|
}
|
|
}
|
|
return [this.encodeAsString(obj)];
|
|
}
|
|
/**
|
|
* Encode packet as string.
|
|
*/
|
|
encodeAsString(obj) {
|
|
// first is type
|
|
let str = "" + obj.type;
|
|
// attachments if we have them
|
|
if (obj.type === PacketType.BINARY_EVENT ||
|
|
obj.type === PacketType.BINARY_ACK) {
|
|
str += obj.attachments + "-";
|
|
}
|
|
// if we have a namespace other than `/`
|
|
// we append it followed by a comma `,`
|
|
if (obj.nsp && "/" !== obj.nsp) {
|
|
str += obj.nsp + ",";
|
|
}
|
|
// immediately followed by the id
|
|
if (null != obj.id) {
|
|
str += obj.id;
|
|
}
|
|
// json data
|
|
if (null != obj.data) {
|
|
str += JSON.stringify(obj.data, this.replacer);
|
|
}
|
|
debug("encoded %j as %s", obj, str);
|
|
return str;
|
|
}
|
|
/**
|
|
* Encode packet as 'buffer sequence' by removing blobs, and
|
|
* deconstructing packet into object with placeholders and
|
|
* a list of buffers.
|
|
*/
|
|
encodeAsBinary(obj) {
|
|
const deconstruction = (0, binary_js_1.deconstructPacket)(obj);
|
|
const pack = this.encodeAsString(deconstruction.packet);
|
|
const buffers = deconstruction.buffers;
|
|
buffers.unshift(pack); // add packet info to beginning of data list
|
|
return buffers; // write all the buffers
|
|
}
|
|
}
|
|
exports.Encoder = Encoder;
|
|
// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript
|
|
function isObject(value) {
|
|
return Object.prototype.toString.call(value) === "[object Object]";
|
|
}
|
|
/**
|
|
* A socket.io Decoder instance
|
|
*
|
|
* @return {Object} decoder
|
|
*/
|
|
class Decoder extends component_emitter_1.Emitter {
|
|
/**
|
|
* Decoder constructor
|
|
*
|
|
* @param {function} reviver - custom reviver to pass down to JSON.stringify
|
|
*/
|
|
constructor(reviver) {
|
|
super();
|
|
this.reviver = reviver;
|
|
}
|
|
/**
|
|
* Decodes an encoded packet string into packet JSON.
|
|
*
|
|
* @param {String} obj - encoded packet
|
|
*/
|
|
add(obj) {
|
|
let packet;
|
|
if (typeof obj === "string") {
|
|
if (this.reconstructor) {
|
|
throw new Error("got plaintext data when reconstructing a packet");
|
|
}
|
|
packet = this.decodeString(obj);
|
|
const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
|
|
if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
|
|
packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
|
|
// binary packet's json
|
|
this.reconstructor = new BinaryReconstructor(packet);
|
|
// no attachments, labeled binary but no binary data to follow
|
|
if (packet.attachments === 0) {
|
|
super.emitReserved("decoded", packet);
|
|
}
|
|
}
|
|
else {
|
|
// non-binary full packet
|
|
super.emitReserved("decoded", packet);
|
|
}
|
|
}
|
|
else if ((0, is_binary_js_1.isBinary)(obj) || obj.base64) {
|
|
// raw binary data
|
|
if (!this.reconstructor) {
|
|
throw new Error("got binary data when not reconstructing a packet");
|
|
}
|
|
else {
|
|
packet = this.reconstructor.takeBinaryData(obj);
|
|
if (packet) {
|
|
// received final buffer
|
|
this.reconstructor = null;
|
|
super.emitReserved("decoded", packet);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
throw new Error("Unknown type: " + obj);
|
|
}
|
|
}
|
|
/**
|
|
* Decode a packet String (JSON data)
|
|
*
|
|
* @param {String} str
|
|
* @return {Object} packet
|
|
*/
|
|
decodeString(str) {
|
|
let i = 0;
|
|
// look up type
|
|
const p = {
|
|
type: Number(str.charAt(0)),
|
|
};
|
|
if (PacketType[p.type] === undefined) {
|
|
throw new Error("unknown packet type " + p.type);
|
|
}
|
|
// look up attachments if type binary
|
|
if (p.type === PacketType.BINARY_EVENT ||
|
|
p.type === PacketType.BINARY_ACK) {
|
|
const start = i + 1;
|
|
while (str.charAt(++i) !== "-" && i != str.length) { }
|
|
const buf = str.substring(start, i);
|
|
if (buf != Number(buf) || str.charAt(i) !== "-") {
|
|
throw new Error("Illegal attachments");
|
|
}
|
|
p.attachments = Number(buf);
|
|
}
|
|
// look up namespace (if any)
|
|
if ("/" === str.charAt(i + 1)) {
|
|
const start = i + 1;
|
|
while (++i) {
|
|
const c = str.charAt(i);
|
|
if ("," === c)
|
|
break;
|
|
if (i === str.length)
|
|
break;
|
|
}
|
|
p.nsp = str.substring(start, i);
|
|
}
|
|
else {
|
|
p.nsp = "/";
|
|
}
|
|
// look up id
|
|
const next = str.charAt(i + 1);
|
|
if ("" !== next && Number(next) == next) {
|
|
const start = i + 1;
|
|
while (++i) {
|
|
const c = str.charAt(i);
|
|
if (null == c || Number(c) != c) {
|
|
--i;
|
|
break;
|
|
}
|
|
if (i === str.length)
|
|
break;
|
|
}
|
|
p.id = Number(str.substring(start, i + 1));
|
|
}
|
|
// look up json data
|
|
if (str.charAt(++i)) {
|
|
const payload = this.tryParse(str.substr(i));
|
|
if (Decoder.isPayloadValid(p.type, payload)) {
|
|
p.data = payload;
|
|
}
|
|
else {
|
|
throw new Error("invalid payload");
|
|
}
|
|
}
|
|
debug("decoded %s as %j", str, p);
|
|
return p;
|
|
}
|
|
tryParse(str) {
|
|
try {
|
|
return JSON.parse(str, this.reviver);
|
|
}
|
|
catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
static isPayloadValid(type, payload) {
|
|
switch (type) {
|
|
case PacketType.CONNECT:
|
|
return isObject(payload);
|
|
case PacketType.DISCONNECT:
|
|
return payload === undefined;
|
|
case PacketType.CONNECT_ERROR:
|
|
return typeof payload === "string" || isObject(payload);
|
|
case PacketType.EVENT:
|
|
case PacketType.BINARY_EVENT:
|
|
return (Array.isArray(payload) &&
|
|
(typeof payload[0] === "number" ||
|
|
(typeof payload[0] === "string" &&
|
|
RESERVED_EVENTS.indexOf(payload[0]) === -1)));
|
|
case PacketType.ACK:
|
|
case PacketType.BINARY_ACK:
|
|
return Array.isArray(payload);
|
|
}
|
|
}
|
|
/**
|
|
* Deallocates a parser's resources
|
|
*/
|
|
destroy() {
|
|
if (this.reconstructor) {
|
|
this.reconstructor.finishedReconstruction();
|
|
this.reconstructor = null;
|
|
}
|
|
}
|
|
}
|
|
exports.Decoder = Decoder;
|
|
/**
|
|
* A manager of a binary event's 'buffer sequence'. Should
|
|
* be constructed whenever a packet of type BINARY_EVENT is
|
|
* decoded.
|
|
*
|
|
* @param {Object} packet
|
|
* @return {BinaryReconstructor} initialized reconstructor
|
|
*/
|
|
class BinaryReconstructor {
|
|
constructor(packet) {
|
|
this.packet = packet;
|
|
this.buffers = [];
|
|
this.reconPack = packet;
|
|
}
|
|
/**
|
|
* Method to be called when binary data received from connection
|
|
* after a BINARY_EVENT packet.
|
|
*
|
|
* @param {Buffer | ArrayBuffer} binData - the raw binary data received
|
|
* @return {null | Object} returns null if more binary data is expected or
|
|
* a reconstructed packet object if all buffers have been received.
|
|
*/
|
|
takeBinaryData(binData) {
|
|
this.buffers.push(binData);
|
|
if (this.buffers.length === this.reconPack.attachments) {
|
|
// done with buffer list
|
|
const packet = (0, binary_js_1.reconstructPacket)(this.reconPack, this.buffers);
|
|
this.finishedReconstruction();
|
|
return packet;
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Cleans up binary packet reconstruction variables.
|
|
*/
|
|
finishedReconstruction() {
|
|
this.reconPack = null;
|
|
this.buffers = [];
|
|
}
|
|
}
|
|
} (cjs));
|
|
|
|
var on$1 = {};
|
|
|
|
Object.defineProperty(on$1, "__esModule", { value: true });
|
|
on$1.on = on;
|
|
function on(obj, ev, fn) {
|
|
obj.on(ev, fn);
|
|
return function subDestroy() {
|
|
obj.off(ev, fn);
|
|
};
|
|
}
|
|
|
|
var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(socket$1, "__esModule", { value: true });
|
|
socket$1.Socket = void 0;
|
|
const socket_io_parser_1 = cjs;
|
|
const on_js_1$1 = on$1;
|
|
const component_emitter_1$1 = require$$5;
|
|
const debug_1$1 = __importDefault$1(browserExports); // debug()
|
|
const debug$1 = (0, debug_1$1.default)("socket.io-client:socket"); // debug()
|
|
/**
|
|
* Internal events.
|
|
* These events can't be emitted by the user.
|
|
*/
|
|
const RESERVED_EVENTS = Object.freeze({
|
|
connect: 1,
|
|
connect_error: 1,
|
|
disconnect: 1,
|
|
disconnecting: 1,
|
|
// EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
|
|
newListener: 1,
|
|
removeListener: 1,
|
|
});
|
|
/**
|
|
* A Socket is the fundamental class for interacting with the server.
|
|
*
|
|
* A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.
|
|
*
|
|
* @example
|
|
* const socket = io();
|
|
*
|
|
* socket.on("connect", () => {
|
|
* console.log("connected");
|
|
* });
|
|
*
|
|
* // send an event to the server
|
|
* socket.emit("foo", "bar");
|
|
*
|
|
* socket.on("foobar", () => {
|
|
* // an event was received from the server
|
|
* });
|
|
*
|
|
* // upon disconnection
|
|
* socket.on("disconnect", (reason) => {
|
|
* console.log(`disconnected due to ${reason}`);
|
|
* });
|
|
*/
|
|
class Socket extends component_emitter_1$1.Emitter {
|
|
/**
|
|
* `Socket` constructor.
|
|
*/
|
|
constructor(io, nsp, opts) {
|
|
super();
|
|
/**
|
|
* Whether the socket is currently connected to the server.
|
|
*
|
|
* @example
|
|
* const socket = io();
|
|
*
|
|
* socket.on("connect", () => {
|
|
* console.log(socket.connected); // true
|
|
* });
|
|
*
|
|
* socket.on("disconnect", () => {
|
|
* console.log(socket.connected); // false
|
|
* });
|
|
*/
|
|
this.connected = false;
|
|
/**
|
|
* Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will
|
|
* be transmitted by the server.
|
|
*/
|
|
this.recovered = false;
|
|
/**
|
|
* Buffer for packets received before the CONNECT packet
|
|
*/
|
|
this.receiveBuffer = [];
|
|
/**
|
|
* Buffer for packets that will be sent once the socket is connected
|
|
*/
|
|
this.sendBuffer = [];
|
|
/**
|
|
* The queue of packets to be sent with retry in case of failure.
|
|
*
|
|
* Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.
|
|
* @private
|
|
*/
|
|
this._queue = [];
|
|
/**
|
|
* A sequence to generate the ID of the {@link QueuedPacket}.
|
|
* @private
|
|
*/
|
|
this._queueSeq = 0;
|
|
this.ids = 0;
|
|
/**
|
|
* A map containing acknowledgement handlers.
|
|
*
|
|
* The `withError` attribute is used to differentiate handlers that accept an error as first argument:
|
|
*
|
|
* - `socket.emit("test", (err, value) => { ... })` with `ackTimeout` option
|
|
* - `socket.timeout(5000).emit("test", (err, value) => { ... })`
|
|
* - `const value = await socket.emitWithAck("test")`
|
|
*
|
|
* From those that don't:
|
|
*
|
|
* - `socket.emit("test", (value) => { ... });`
|
|
*
|
|
* In the first case, the handlers will be called with an error when:
|
|
*
|
|
* - the timeout is reached
|
|
* - the socket gets disconnected
|
|
*
|
|
* In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive
|
|
* an acknowledgement from the server.
|
|
*
|
|
* @private
|
|
*/
|
|
this.acks = {};
|
|
this.flags = {};
|
|
this.io = io;
|
|
this.nsp = nsp;
|
|
if (opts && opts.auth) {
|
|
this.auth = opts.auth;
|
|
}
|
|
this._opts = Object.assign({}, opts);
|
|
if (this.io._autoConnect)
|
|
this.open();
|
|
}
|
|
/**
|
|
* Whether the socket is currently disconnected
|
|
*
|
|
* @example
|
|
* const socket = io();
|
|
*
|
|
* socket.on("connect", () => {
|
|
* console.log(socket.disconnected); // false
|
|
* });
|
|
*
|
|
* socket.on("disconnect", () => {
|
|
* console.log(socket.disconnected); // true
|
|
* });
|
|
*/
|
|
get disconnected() {
|
|
return !this.connected;
|
|
}
|
|
/**
|
|
* Subscribe to open, close and packet events
|
|
*
|
|
* @private
|
|
*/
|
|
subEvents() {
|
|
if (this.subs)
|
|
return;
|
|
const io = this.io;
|
|
this.subs = [
|
|
(0, on_js_1$1.on)(io, "open", this.onopen.bind(this)),
|
|
(0, on_js_1$1.on)(io, "packet", this.onpacket.bind(this)),
|
|
(0, on_js_1$1.on)(io, "error", this.onerror.bind(this)),
|
|
(0, on_js_1$1.on)(io, "close", this.onclose.bind(this)),
|
|
];
|
|
}
|
|
/**
|
|
* Whether the Socket will try to reconnect when its Manager connects or reconnects.
|
|
*
|
|
* @example
|
|
* const socket = io();
|
|
*
|
|
* console.log(socket.active); // true
|
|
*
|
|
* socket.on("disconnect", (reason) => {
|
|
* if (reason === "io server disconnect") {
|
|
* // the disconnection was initiated by the server, you need to manually reconnect
|
|
* console.log(socket.active); // false
|
|
* }
|
|
* // else the socket will automatically try to reconnect
|
|
* console.log(socket.active); // true
|
|
* });
|
|
*/
|
|
get active() {
|
|
return !!this.subs;
|
|
}
|
|
/**
|
|
* "Opens" the socket.
|
|
*
|
|
* @example
|
|
* const socket = io({
|
|
* autoConnect: false
|
|
* });
|
|
*
|
|
* socket.connect();
|
|
*/
|
|
connect() {
|
|
if (this.connected)
|
|
return this;
|
|
this.subEvents();
|
|
if (!this.io["_reconnecting"])
|
|
this.io.open(); // ensure open
|
|
if ("open" === this.io._readyState)
|
|
this.onopen();
|
|
return this;
|
|
}
|
|
/**
|
|
* Alias for {@link connect()}.
|
|
*/
|
|
open() {
|
|
return this.connect();
|
|
}
|
|
/**
|
|
* Sends a `message` event.
|
|
*
|
|
* This method mimics the WebSocket.send() method.
|
|
*
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
|
|
*
|
|
* @example
|
|
* socket.send("hello");
|
|
*
|
|
* // this is equivalent to
|
|
* socket.emit("message", "hello");
|
|
*
|
|
* @return self
|
|
*/
|
|
send(...args) {
|
|
args.unshift("message");
|
|
this.emit.apply(this, args);
|
|
return this;
|
|
}
|
|
/**
|
|
* Override `emit`.
|
|
* If the event is in `events`, it's emitted normally.
|
|
*
|
|
* @example
|
|
* socket.emit("hello", "world");
|
|
*
|
|
* // all serializable datastructures are supported (no need to call JSON.stringify)
|
|
* socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
|
|
*
|
|
* // with an acknowledgement from the server
|
|
* socket.emit("hello", "world", (val) => {
|
|
* // ...
|
|
* });
|
|
*
|
|
* @return self
|
|
*/
|
|
emit(ev, ...args) {
|
|
var _a, _b, _c;
|
|
if (RESERVED_EVENTS.hasOwnProperty(ev)) {
|
|
throw new Error('"' + ev.toString() + '" is a reserved event name');
|
|
}
|
|
args.unshift(ev);
|
|
if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
|
|
this._addToQueue(args);
|
|
return this;
|
|
}
|
|
const packet = {
|
|
type: socket_io_parser_1.PacketType.EVENT,
|
|
data: args,
|
|
};
|
|
packet.options = {};
|
|
packet.options.compress = this.flags.compress !== false;
|
|
// event ack callback
|
|
if ("function" === typeof args[args.length - 1]) {
|
|
const id = this.ids++;
|
|
debug$1("emitting packet with ack id %d", id);
|
|
const ack = args.pop();
|
|
this._registerAckCallback(id, ack);
|
|
packet.id = id;
|
|
}
|
|
const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;
|
|
const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());
|
|
const discardPacket = this.flags.volatile && !isTransportWritable;
|
|
if (discardPacket) {
|
|
debug$1("discard packet as the transport is not currently writable");
|
|
}
|
|
else if (isConnected) {
|
|
this.notifyOutgoingListeners(packet);
|
|
this.packet(packet);
|
|
}
|
|
else {
|
|
this.sendBuffer.push(packet);
|
|
}
|
|
this.flags = {};
|
|
return this;
|
|
}
|
|
/**
|
|
* @private
|
|
*/
|
|
_registerAckCallback(id, ack) {
|
|
var _a;
|
|
const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
|
|
if (timeout === undefined) {
|
|
this.acks[id] = ack;
|
|
return;
|
|
}
|
|
// @ts-ignore
|
|
const timer = this.io.setTimeoutFn(() => {
|
|
delete this.acks[id];
|
|
for (let i = 0; i < this.sendBuffer.length; i++) {
|
|
if (this.sendBuffer[i].id === id) {
|
|
debug$1("removing packet with ack id %d from the buffer", id);
|
|
this.sendBuffer.splice(i, 1);
|
|
}
|
|
}
|
|
debug$1("event with ack id %d has timed out after %d ms", id, timeout);
|
|
ack.call(this, new Error("operation has timed out"));
|
|
}, timeout);
|
|
const fn = (...args) => {
|
|
// @ts-ignore
|
|
this.io.clearTimeoutFn(timer);
|
|
ack.apply(this, args);
|
|
};
|
|
fn.withError = true;
|
|
this.acks[id] = fn;
|
|
}
|
|
/**
|
|
* Emits an event and waits for an acknowledgement
|
|
*
|
|
* @example
|
|
* // without timeout
|
|
* const response = await socket.emitWithAck("hello", "world");
|
|
*
|
|
* // with a specific timeout
|
|
* try {
|
|
* const response = await socket.timeout(1000).emitWithAck("hello", "world");
|
|
* } catch (err) {
|
|
* // the server did not acknowledge the event in the given delay
|
|
* }
|
|
*
|
|
* @return a Promise that will be fulfilled when the server acknowledges the event
|
|
*/
|
|
emitWithAck(ev, ...args) {
|
|
return new Promise((resolve, reject) => {
|
|
const fn = (arg1, arg2) => {
|
|
return arg1 ? reject(arg1) : resolve(arg2);
|
|
};
|
|
fn.withError = true;
|
|
args.push(fn);
|
|
this.emit(ev, ...args);
|
|
});
|
|
}
|
|
/**
|
|
* Add the packet to the queue.
|
|
* @param args
|
|
* @private
|
|
*/
|
|
_addToQueue(args) {
|
|
let ack;
|
|
if (typeof args[args.length - 1] === "function") {
|
|
ack = args.pop();
|
|
}
|
|
const packet = {
|
|
id: this._queueSeq++,
|
|
tryCount: 0,
|
|
pending: false,
|
|
args,
|
|
flags: Object.assign({ fromQueue: true }, this.flags),
|
|
};
|
|
args.push((err, ...responseArgs) => {
|
|
if (packet !== this._queue[0]) {
|
|
// the packet has already been acknowledged
|
|
return;
|
|
}
|
|
const hasError = err !== null;
|
|
if (hasError) {
|
|
if (packet.tryCount > this._opts.retries) {
|
|
debug$1("packet [%d] is discarded after %d tries", packet.id, packet.tryCount);
|
|
this._queue.shift();
|
|
if (ack) {
|
|
ack(err);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
debug$1("packet [%d] was successfully sent", packet.id);
|
|
this._queue.shift();
|
|
if (ack) {
|
|
ack(null, ...responseArgs);
|
|
}
|
|
}
|
|
packet.pending = false;
|
|
return this._drainQueue();
|
|
});
|
|
this._queue.push(packet);
|
|
this._drainQueue();
|
|
}
|
|
/**
|
|
* Send the first packet of the queue, and wait for an acknowledgement from the server.
|
|
* @param force - whether to resend a packet that has not been acknowledged yet
|
|
*
|
|
* @private
|
|
*/
|
|
_drainQueue(force = false) {
|
|
debug$1("draining queue");
|
|
if (!this.connected || this._queue.length === 0) {
|
|
return;
|
|
}
|
|
const packet = this._queue[0];
|
|
if (packet.pending && !force) {
|
|
debug$1("packet [%d] has already been sent and is waiting for an ack", packet.id);
|
|
return;
|
|
}
|
|
packet.pending = true;
|
|
packet.tryCount++;
|
|
debug$1("sending packet [%d] (try n°%d)", packet.id, packet.tryCount);
|
|
this.flags = packet.flags;
|
|
this.emit.apply(this, packet.args);
|
|
}
|
|
/**
|
|
* Sends a packet.
|
|
*
|
|
* @param packet
|
|
* @private
|
|
*/
|
|
packet(packet) {
|
|
packet.nsp = this.nsp;
|
|
this.io._packet(packet);
|
|
}
|
|
/**
|
|
* Called upon engine `open`.
|
|
*
|
|
* @private
|
|
*/
|
|
onopen() {
|
|
debug$1("transport is open - connecting");
|
|
if (typeof this.auth == "function") {
|
|
this.auth((data) => {
|
|
this._sendConnectPacket(data);
|
|
});
|
|
}
|
|
else {
|
|
this._sendConnectPacket(this.auth);
|
|
}
|
|
}
|
|
/**
|
|
* Sends a CONNECT packet to initiate the Socket.IO session.
|
|
*
|
|
* @param data
|
|
* @private
|
|
*/
|
|
_sendConnectPacket(data) {
|
|
this.packet({
|
|
type: socket_io_parser_1.PacketType.CONNECT,
|
|
data: this._pid
|
|
? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)
|
|
: data,
|
|
});
|
|
}
|
|
/**
|
|
* Called upon engine or manager `error`.
|
|
*
|
|
* @param err
|
|
* @private
|
|
*/
|
|
onerror(err) {
|
|
if (!this.connected) {
|
|
this.emitReserved("connect_error", err);
|
|
}
|
|
}
|
|
/**
|
|
* Called upon engine `close`.
|
|
*
|
|
* @param reason
|
|
* @param description
|
|
* @private
|
|
*/
|
|
onclose(reason, description) {
|
|
debug$1("close (%s)", reason);
|
|
this.connected = false;
|
|
delete this.id;
|
|
this.emitReserved("disconnect", reason, description);
|
|
this._clearAcks();
|
|
}
|
|
/**
|
|
* Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
|
|
* the server.
|
|
*
|
|
* @private
|
|
*/
|
|
_clearAcks() {
|
|
Object.keys(this.acks).forEach((id) => {
|
|
const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);
|
|
if (!isBuffered) {
|
|
// note: handlers that do not accept an error as first argument are ignored here
|
|
const ack = this.acks[id];
|
|
delete this.acks[id];
|
|
if (ack.withError) {
|
|
ack.call(this, new Error("socket has been disconnected"));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Called with socket packet.
|
|
*
|
|
* @param packet
|
|
* @private
|
|
*/
|
|
onpacket(packet) {
|
|
const sameNamespace = packet.nsp === this.nsp;
|
|
if (!sameNamespace)
|
|
return;
|
|
switch (packet.type) {
|
|
case socket_io_parser_1.PacketType.CONNECT:
|
|
if (packet.data && packet.data.sid) {
|
|
this.onconnect(packet.data.sid, packet.data.pid);
|
|
}
|
|
else {
|
|
this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
|
|
}
|
|
break;
|
|
case socket_io_parser_1.PacketType.EVENT:
|
|
case socket_io_parser_1.PacketType.BINARY_EVENT:
|
|
this.onevent(packet);
|
|
break;
|
|
case socket_io_parser_1.PacketType.ACK:
|
|
case socket_io_parser_1.PacketType.BINARY_ACK:
|
|
this.onack(packet);
|
|
break;
|
|
case socket_io_parser_1.PacketType.DISCONNECT:
|
|
this.ondisconnect();
|
|
break;
|
|
case socket_io_parser_1.PacketType.CONNECT_ERROR:
|
|
this.destroy();
|
|
const err = new Error(packet.data.message);
|
|
// @ts-ignore
|
|
err.data = packet.data.data;
|
|
this.emitReserved("connect_error", err);
|
|
break;
|
|
}
|
|
}
|
|
/**
|
|
* Called upon a server event.
|
|
*
|
|
* @param packet
|
|
* @private
|
|
*/
|
|
onevent(packet) {
|
|
const args = packet.data || [];
|
|
debug$1("emitting event %j", args);
|
|
if (null != packet.id) {
|
|
debug$1("attaching ack callback to event");
|
|
args.push(this.ack(packet.id));
|
|
}
|
|
if (this.connected) {
|
|
this.emitEvent(args);
|
|
}
|
|
else {
|
|
this.receiveBuffer.push(Object.freeze(args));
|
|
}
|
|
}
|
|
emitEvent(args) {
|
|
if (this._anyListeners && this._anyListeners.length) {
|
|
const listeners = this._anyListeners.slice();
|
|
for (const listener of listeners) {
|
|
listener.apply(this, args);
|
|
}
|
|
}
|
|
super.emit.apply(this, args);
|
|
if (this._pid && args.length && typeof args[args.length - 1] === "string") {
|
|
this._lastOffset = args[args.length - 1];
|
|
}
|
|
}
|
|
/**
|
|
* Produces an ack callback to emit with an event.
|
|
*
|
|
* @private
|
|
*/
|
|
ack(id) {
|
|
const self = this;
|
|
let sent = false;
|
|
return function (...args) {
|
|
// prevent double callbacks
|
|
if (sent)
|
|
return;
|
|
sent = true;
|
|
debug$1("sending ack %j", args);
|
|
self.packet({
|
|
type: socket_io_parser_1.PacketType.ACK,
|
|
id: id,
|
|
data: args,
|
|
});
|
|
};
|
|
}
|
|
/**
|
|
* Called upon a server acknowledgement.
|
|
*
|
|
* @param packet
|
|
* @private
|
|
*/
|
|
onack(packet) {
|
|
const ack = this.acks[packet.id];
|
|
if (typeof ack !== "function") {
|
|
debug$1("bad ack %s", packet.id);
|
|
return;
|
|
}
|
|
delete this.acks[packet.id];
|
|
debug$1("calling ack %s with %j", packet.id, packet.data);
|
|
// @ts-ignore FIXME ack is incorrectly inferred as 'never'
|
|
if (ack.withError) {
|
|
packet.data.unshift(null);
|
|
}
|
|
// @ts-ignore
|
|
ack.apply(this, packet.data);
|
|
}
|
|
/**
|
|
* Called upon server connect.
|
|
*
|
|
* @private
|
|
*/
|
|
onconnect(id, pid) {
|
|
debug$1("socket connected with id %s", id);
|
|
this.id = id;
|
|
this.recovered = pid && this._pid === pid;
|
|
this._pid = pid; // defined only if connection state recovery is enabled
|
|
this.connected = true;
|
|
this.emitBuffered();
|
|
this.emitReserved("connect");
|
|
this._drainQueue(true);
|
|
}
|
|
/**
|
|
* Emit buffered events (received and emitted).
|
|
*
|
|
* @private
|
|
*/
|
|
emitBuffered() {
|
|
this.receiveBuffer.forEach((args) => this.emitEvent(args));
|
|
this.receiveBuffer = [];
|
|
this.sendBuffer.forEach((packet) => {
|
|
this.notifyOutgoingListeners(packet);
|
|
this.packet(packet);
|
|
});
|
|
this.sendBuffer = [];
|
|
}
|
|
/**
|
|
* Called upon server disconnect.
|
|
*
|
|
* @private
|
|
*/
|
|
ondisconnect() {
|
|
debug$1("server disconnect (%s)", this.nsp);
|
|
this.destroy();
|
|
this.onclose("io server disconnect");
|
|
}
|
|
/**
|
|
* Called upon forced client/server side disconnections,
|
|
* this method ensures the manager stops tracking us and
|
|
* that reconnections don't get triggered for this.
|
|
*
|
|
* @private
|
|
*/
|
|
destroy() {
|
|
if (this.subs) {
|
|
// clean subscriptions to avoid reconnections
|
|
this.subs.forEach((subDestroy) => subDestroy());
|
|
this.subs = undefined;
|
|
}
|
|
this.io["_destroy"](this);
|
|
}
|
|
/**
|
|
* Disconnects the socket manually. In that case, the socket will not try to reconnect.
|
|
*
|
|
* If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
|
|
*
|
|
* @example
|
|
* const socket = io();
|
|
*
|
|
* socket.on("disconnect", (reason) => {
|
|
* // console.log(reason); prints "io client disconnect"
|
|
* });
|
|
*
|
|
* socket.disconnect();
|
|
*
|
|
* @return self
|
|
*/
|
|
disconnect() {
|
|
if (this.connected) {
|
|
debug$1("performing disconnect (%s)", this.nsp);
|
|
this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });
|
|
}
|
|
// remove socket from pool
|
|
this.destroy();
|
|
if (this.connected) {
|
|
// fire events
|
|
this.onclose("io client disconnect");
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Alias for {@link disconnect()}.
|
|
*
|
|
* @return self
|
|
*/
|
|
close() {
|
|
return this.disconnect();
|
|
}
|
|
/**
|
|
* Sets the compress flag.
|
|
*
|
|
* @example
|
|
* socket.compress(false).emit("hello");
|
|
*
|
|
* @param compress - if `true`, compresses the sending data
|
|
* @return self
|
|
*/
|
|
compress(compress) {
|
|
this.flags.compress = compress;
|
|
return this;
|
|
}
|
|
/**
|
|
* Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
|
|
* ready to send messages.
|
|
*
|
|
* @example
|
|
* socket.volatile.emit("hello"); // the server may or may not receive it
|
|
*
|
|
* @returns self
|
|
*/
|
|
get volatile() {
|
|
this.flags.volatile = true;
|
|
return this;
|
|
}
|
|
/**
|
|
* Sets a modifier for a subsequent event emission that the callback will be called with an error when the
|
|
* given number of milliseconds have elapsed without an acknowledgement from the server:
|
|
*
|
|
* @example
|
|
* socket.timeout(5000).emit("my-event", (err) => {
|
|
* if (err) {
|
|
* // the server did not acknowledge the event in the given delay
|
|
* }
|
|
* });
|
|
*
|
|
* @returns self
|
|
*/
|
|
timeout(timeout) {
|
|
this.flags.timeout = timeout;
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
|
|
* callback.
|
|
*
|
|
* @example
|
|
* socket.onAny((event, ...args) => {
|
|
* console.log(`got ${event}`);
|
|
* });
|
|
*
|
|
* @param listener
|
|
*/
|
|
onAny(listener) {
|
|
this._anyListeners = this._anyListeners || [];
|
|
this._anyListeners.push(listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
|
|
* callback. The listener is added to the beginning of the listeners array.
|
|
*
|
|
* @example
|
|
* socket.prependAny((event, ...args) => {
|
|
* console.log(`got event ${event}`);
|
|
* });
|
|
*
|
|
* @param listener
|
|
*/
|
|
prependAny(listener) {
|
|
this._anyListeners = this._anyListeners || [];
|
|
this._anyListeners.unshift(listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Removes the listener that will be fired when any event is emitted.
|
|
*
|
|
* @example
|
|
* const catchAllListener = (event, ...args) => {
|
|
* console.log(`got event ${event}`);
|
|
* }
|
|
*
|
|
* socket.onAny(catchAllListener);
|
|
*
|
|
* // remove a specific listener
|
|
* socket.offAny(catchAllListener);
|
|
*
|
|
* // or remove all listeners
|
|
* socket.offAny();
|
|
*
|
|
* @param listener
|
|
*/
|
|
offAny(listener) {
|
|
if (!this._anyListeners) {
|
|
return this;
|
|
}
|
|
if (listener) {
|
|
const listeners = this._anyListeners;
|
|
for (let i = 0; i < listeners.length; i++) {
|
|
if (listener === listeners[i]) {
|
|
listeners.splice(i, 1);
|
|
return this;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this._anyListeners = [];
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
|
|
* e.g. to remove listeners.
|
|
*/
|
|
listenersAny() {
|
|
return this._anyListeners || [];
|
|
}
|
|
/**
|
|
* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
|
|
* callback.
|
|
*
|
|
* Note: acknowledgements sent to the server are not included.
|
|
*
|
|
* @example
|
|
* socket.onAnyOutgoing((event, ...args) => {
|
|
* console.log(`sent event ${event}`);
|
|
* });
|
|
*
|
|
* @param listener
|
|
*/
|
|
onAnyOutgoing(listener) {
|
|
this._anyOutgoingListeners = this._anyOutgoingListeners || [];
|
|
this._anyOutgoingListeners.push(listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
|
|
* callback. The listener is added to the beginning of the listeners array.
|
|
*
|
|
* Note: acknowledgements sent to the server are not included.
|
|
*
|
|
* @example
|
|
* socket.prependAnyOutgoing((event, ...args) => {
|
|
* console.log(`sent event ${event}`);
|
|
* });
|
|
*
|
|
* @param listener
|
|
*/
|
|
prependAnyOutgoing(listener) {
|
|
this._anyOutgoingListeners = this._anyOutgoingListeners || [];
|
|
this._anyOutgoingListeners.unshift(listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Removes the listener that will be fired when any event is emitted.
|
|
*
|
|
* @example
|
|
* const catchAllListener = (event, ...args) => {
|
|
* console.log(`sent event ${event}`);
|
|
* }
|
|
*
|
|
* socket.onAnyOutgoing(catchAllListener);
|
|
*
|
|
* // remove a specific listener
|
|
* socket.offAnyOutgoing(catchAllListener);
|
|
*
|
|
* // or remove all listeners
|
|
* socket.offAnyOutgoing();
|
|
*
|
|
* @param [listener] - the catch-all listener (optional)
|
|
*/
|
|
offAnyOutgoing(listener) {
|
|
if (!this._anyOutgoingListeners) {
|
|
return this;
|
|
}
|
|
if (listener) {
|
|
const listeners = this._anyOutgoingListeners;
|
|
for (let i = 0; i < listeners.length; i++) {
|
|
if (listener === listeners[i]) {
|
|
listeners.splice(i, 1);
|
|
return this;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this._anyOutgoingListeners = [];
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
|
|
* e.g. to remove listeners.
|
|
*/
|
|
listenersAnyOutgoing() {
|
|
return this._anyOutgoingListeners || [];
|
|
}
|
|
/**
|
|
* Notify the listeners for each packet sent
|
|
*
|
|
* @param packet
|
|
*
|
|
* @private
|
|
*/
|
|
notifyOutgoingListeners(packet) {
|
|
if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
|
|
const listeners = this._anyOutgoingListeners.slice();
|
|
for (const listener of listeners) {
|
|
listener.apply(this, packet.data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
socket$1.Socket = Socket;
|
|
|
|
var backo2 = {};
|
|
|
|
/**
|
|
* Initialize backoff timer with `opts`.
|
|
*
|
|
* - `min` initial timeout in milliseconds [100]
|
|
* - `max` max timeout [10000]
|
|
* - `jitter` [0]
|
|
* - `factor` [2]
|
|
*
|
|
* @param {Object} opts
|
|
* @api public
|
|
*/
|
|
Object.defineProperty(backo2, "__esModule", { value: true });
|
|
backo2.Backoff = Backoff;
|
|
function Backoff(opts) {
|
|
opts = opts || {};
|
|
this.ms = opts.min || 100;
|
|
this.max = opts.max || 10000;
|
|
this.factor = opts.factor || 2;
|
|
this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
|
|
this.attempts = 0;
|
|
}
|
|
/**
|
|
* Return the backoff duration.
|
|
*
|
|
* @return {Number}
|
|
* @api public
|
|
*/
|
|
Backoff.prototype.duration = function () {
|
|
var ms = this.ms * Math.pow(this.factor, this.attempts++);
|
|
if (this.jitter) {
|
|
var rand = Math.random();
|
|
var deviation = Math.floor(rand * this.jitter * ms);
|
|
ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
|
|
}
|
|
return Math.min(ms, this.max) | 0;
|
|
};
|
|
/**
|
|
* Reset the number of attempts.
|
|
*
|
|
* @api public
|
|
*/
|
|
Backoff.prototype.reset = function () {
|
|
this.attempts = 0;
|
|
};
|
|
/**
|
|
* Set the minimum duration
|
|
*
|
|
* @api public
|
|
*/
|
|
Backoff.prototype.setMin = function (min) {
|
|
this.ms = min;
|
|
};
|
|
/**
|
|
* Set the maximum duration
|
|
*
|
|
* @api public
|
|
*/
|
|
Backoff.prototype.setMax = function (max) {
|
|
this.max = max;
|
|
};
|
|
/**
|
|
* Set the jitter
|
|
*
|
|
* @api public
|
|
*/
|
|
Backoff.prototype.setJitter = function (jitter) {
|
|
this.jitter = jitter;
|
|
};
|
|
|
|
var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(manager, "__esModule", { value: true });
|
|
manager.Manager = void 0;
|
|
const engine_io_client_1 = cjs$2;
|
|
const socket_js_1 = socket$1;
|
|
const parser = __importStar(cjs);
|
|
const on_js_1 = on$1;
|
|
const backo2_js_1 = backo2;
|
|
const component_emitter_1 = require$$5;
|
|
const debug_1 = __importDefault(browserExports); // debug()
|
|
const debug = (0, debug_1.default)("socket.io-client:manager"); // debug()
|
|
class Manager$1 extends component_emitter_1.Emitter {
|
|
constructor(uri, opts) {
|
|
var _a;
|
|
super();
|
|
this.nsps = {};
|
|
this.subs = [];
|
|
if (uri && "object" === typeof uri) {
|
|
opts = uri;
|
|
uri = undefined;
|
|
}
|
|
opts = opts || {};
|
|
opts.path = opts.path || "/socket.io";
|
|
this.opts = opts;
|
|
(0, engine_io_client_1.installTimerFunctions)(this, opts);
|
|
this.reconnection(opts.reconnection !== false);
|
|
this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
|
|
this.reconnectionDelay(opts.reconnectionDelay || 1000);
|
|
this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
|
|
this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);
|
|
this.backoff = new backo2_js_1.Backoff({
|
|
min: this.reconnectionDelay(),
|
|
max: this.reconnectionDelayMax(),
|
|
jitter: this.randomizationFactor(),
|
|
});
|
|
this.timeout(null == opts.timeout ? 20000 : opts.timeout);
|
|
this._readyState = "closed";
|
|
this.uri = uri;
|
|
const _parser = opts.parser || parser;
|
|
this.encoder = new _parser.Encoder();
|
|
this.decoder = new _parser.Decoder();
|
|
this._autoConnect = opts.autoConnect !== false;
|
|
if (this._autoConnect)
|
|
this.open();
|
|
}
|
|
reconnection(v) {
|
|
if (!arguments.length)
|
|
return this._reconnection;
|
|
this._reconnection = !!v;
|
|
if (!v) {
|
|
this.skipReconnect = true;
|
|
}
|
|
return this;
|
|
}
|
|
reconnectionAttempts(v) {
|
|
if (v === undefined)
|
|
return this._reconnectionAttempts;
|
|
this._reconnectionAttempts = v;
|
|
return this;
|
|
}
|
|
reconnectionDelay(v) {
|
|
var _a;
|
|
if (v === undefined)
|
|
return this._reconnectionDelay;
|
|
this._reconnectionDelay = v;
|
|
(_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);
|
|
return this;
|
|
}
|
|
randomizationFactor(v) {
|
|
var _a;
|
|
if (v === undefined)
|
|
return this._randomizationFactor;
|
|
this._randomizationFactor = v;
|
|
(_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);
|
|
return this;
|
|
}
|
|
reconnectionDelayMax(v) {
|
|
var _a;
|
|
if (v === undefined)
|
|
return this._reconnectionDelayMax;
|
|
this._reconnectionDelayMax = v;
|
|
(_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);
|
|
return this;
|
|
}
|
|
timeout(v) {
|
|
if (!arguments.length)
|
|
return this._timeout;
|
|
this._timeout = v;
|
|
return this;
|
|
}
|
|
/**
|
|
* Starts trying to reconnect if reconnection is enabled and we have not
|
|
* started reconnecting yet
|
|
*
|
|
* @private
|
|
*/
|
|
maybeReconnectOnOpen() {
|
|
// Only try to reconnect if it's the first time we're connecting
|
|
if (!this._reconnecting &&
|
|
this._reconnection &&
|
|
this.backoff.attempts === 0) {
|
|
// keeps reconnection from firing twice for the same reconnection loop
|
|
this.reconnect();
|
|
}
|
|
}
|
|
/**
|
|
* Sets the current transport `socket`.
|
|
*
|
|
* @param {Function} fn - optional, callback
|
|
* @return self
|
|
* @public
|
|
*/
|
|
open(fn) {
|
|
debug("readyState %s", this._readyState);
|
|
if (~this._readyState.indexOf("open"))
|
|
return this;
|
|
debug("opening %s", this.uri);
|
|
this.engine = new engine_io_client_1.Socket(this.uri, this.opts);
|
|
const socket = this.engine;
|
|
const self = this;
|
|
this._readyState = "opening";
|
|
this.skipReconnect = false;
|
|
// emit `open`
|
|
const openSubDestroy = (0, on_js_1.on)(socket, "open", function () {
|
|
self.onopen();
|
|
fn && fn();
|
|
});
|
|
const onError = (err) => {
|
|
debug("error");
|
|
this.cleanup();
|
|
this._readyState = "closed";
|
|
this.emitReserved("error", err);
|
|
if (fn) {
|
|
fn(err);
|
|
}
|
|
else {
|
|
// Only do this if there is no fn to handle the error
|
|
this.maybeReconnectOnOpen();
|
|
}
|
|
};
|
|
// emit `error`
|
|
const errorSub = (0, on_js_1.on)(socket, "error", onError);
|
|
if (false !== this._timeout) {
|
|
const timeout = this._timeout;
|
|
debug("connect attempt will timeout after %d", timeout);
|
|
// set timer
|
|
const timer = this.setTimeoutFn(() => {
|
|
debug("connect attempt timed out after %d", timeout);
|
|
openSubDestroy();
|
|
onError(new Error("timeout"));
|
|
socket.close();
|
|
}, timeout);
|
|
if (this.opts.autoUnref) {
|
|
timer.unref();
|
|
}
|
|
this.subs.push(() => {
|
|
this.clearTimeoutFn(timer);
|
|
});
|
|
}
|
|
this.subs.push(openSubDestroy);
|
|
this.subs.push(errorSub);
|
|
return this;
|
|
}
|
|
/**
|
|
* Alias for open()
|
|
*
|
|
* @return self
|
|
* @public
|
|
*/
|
|
connect(fn) {
|
|
return this.open(fn);
|
|
}
|
|
/**
|
|
* Called upon transport open.
|
|
*
|
|
* @private
|
|
*/
|
|
onopen() {
|
|
debug("open");
|
|
// clear old subs
|
|
this.cleanup();
|
|
// mark as open
|
|
this._readyState = "open";
|
|
this.emitReserved("open");
|
|
// add new subs
|
|
const socket = this.engine;
|
|
this.subs.push((0, on_js_1.on)(socket, "ping", this.onping.bind(this)), (0, on_js_1.on)(socket, "data", this.ondata.bind(this)), (0, on_js_1.on)(socket, "error", this.onerror.bind(this)), (0, on_js_1.on)(socket, "close", this.onclose.bind(this)),
|
|
// @ts-ignore
|
|
(0, on_js_1.on)(this.decoder, "decoded", this.ondecoded.bind(this)));
|
|
}
|
|
/**
|
|
* Called upon a ping.
|
|
*
|
|
* @private
|
|
*/
|
|
onping() {
|
|
this.emitReserved("ping");
|
|
}
|
|
/**
|
|
* Called with data.
|
|
*
|
|
* @private
|
|
*/
|
|
ondata(data) {
|
|
try {
|
|
this.decoder.add(data);
|
|
}
|
|
catch (e) {
|
|
this.onclose("parse error", e);
|
|
}
|
|
}
|
|
/**
|
|
* Called when parser fully decodes a packet.
|
|
*
|
|
* @private
|
|
*/
|
|
ondecoded(packet) {
|
|
// the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error"
|
|
(0, engine_io_client_1.nextTick)(() => {
|
|
this.emitReserved("packet", packet);
|
|
}, this.setTimeoutFn);
|
|
}
|
|
/**
|
|
* Called upon socket error.
|
|
*
|
|
* @private
|
|
*/
|
|
onerror(err) {
|
|
debug("error", err);
|
|
this.emitReserved("error", err);
|
|
}
|
|
/**
|
|
* Creates a new socket for the given `nsp`.
|
|
*
|
|
* @return {Socket}
|
|
* @public
|
|
*/
|
|
socket(nsp, opts) {
|
|
let socket = this.nsps[nsp];
|
|
if (!socket) {
|
|
socket = new socket_js_1.Socket(this, nsp, opts);
|
|
this.nsps[nsp] = socket;
|
|
}
|
|
else if (this._autoConnect && !socket.active) {
|
|
socket.connect();
|
|
}
|
|
return socket;
|
|
}
|
|
/**
|
|
* Called upon a socket close.
|
|
*
|
|
* @param socket
|
|
* @private
|
|
*/
|
|
_destroy(socket) {
|
|
const nsps = Object.keys(this.nsps);
|
|
for (const nsp of nsps) {
|
|
const socket = this.nsps[nsp];
|
|
if (socket.active) {
|
|
debug("socket %s is still active, skipping close", nsp);
|
|
return;
|
|
}
|
|
}
|
|
this._close();
|
|
}
|
|
/**
|
|
* Writes a packet.
|
|
*
|
|
* @param packet
|
|
* @private
|
|
*/
|
|
_packet(packet) {
|
|
debug("writing packet %j", packet);
|
|
const encodedPackets = this.encoder.encode(packet);
|
|
for (let i = 0; i < encodedPackets.length; i++) {
|
|
this.engine.write(encodedPackets[i], packet.options);
|
|
}
|
|
}
|
|
/**
|
|
* Clean up transport subscriptions and packet buffer.
|
|
*
|
|
* @private
|
|
*/
|
|
cleanup() {
|
|
debug("cleanup");
|
|
this.subs.forEach((subDestroy) => subDestroy());
|
|
this.subs.length = 0;
|
|
this.decoder.destroy();
|
|
}
|
|
/**
|
|
* Close the current socket.
|
|
*
|
|
* @private
|
|
*/
|
|
_close() {
|
|
debug("disconnect");
|
|
this.skipReconnect = true;
|
|
this._reconnecting = false;
|
|
this.onclose("forced close");
|
|
}
|
|
/**
|
|
* Alias for close()
|
|
*
|
|
* @private
|
|
*/
|
|
disconnect() {
|
|
return this._close();
|
|
}
|
|
/**
|
|
* Called when:
|
|
*
|
|
* - the low-level engine is closed
|
|
* - the parser encountered a badly formatted packet
|
|
* - all sockets are disconnected
|
|
*
|
|
* @private
|
|
*/
|
|
onclose(reason, description) {
|
|
var _a;
|
|
debug("closed due to %s", reason);
|
|
this.cleanup();
|
|
(_a = this.engine) === null || _a === void 0 ? void 0 : _a.close();
|
|
this.backoff.reset();
|
|
this._readyState = "closed";
|
|
this.emitReserved("close", reason, description);
|
|
if (this._reconnection && !this.skipReconnect) {
|
|
this.reconnect();
|
|
}
|
|
}
|
|
/**
|
|
* Attempt a reconnection.
|
|
*
|
|
* @private
|
|
*/
|
|
reconnect() {
|
|
if (this._reconnecting || this.skipReconnect)
|
|
return this;
|
|
const self = this;
|
|
if (this.backoff.attempts >= this._reconnectionAttempts) {
|
|
debug("reconnect failed");
|
|
this.backoff.reset();
|
|
this.emitReserved("reconnect_failed");
|
|
this._reconnecting = false;
|
|
}
|
|
else {
|
|
const delay = this.backoff.duration();
|
|
debug("will wait %dms before reconnect attempt", delay);
|
|
this._reconnecting = true;
|
|
const timer = this.setTimeoutFn(() => {
|
|
if (self.skipReconnect)
|
|
return;
|
|
debug("attempting reconnect");
|
|
this.emitReserved("reconnect_attempt", self.backoff.attempts);
|
|
// check again for the case socket closed in above events
|
|
if (self.skipReconnect)
|
|
return;
|
|
self.open((err) => {
|
|
if (err) {
|
|
debug("reconnect attempt error");
|
|
self._reconnecting = false;
|
|
self.reconnect();
|
|
this.emitReserved("reconnect_error", err);
|
|
}
|
|
else {
|
|
debug("reconnect success");
|
|
self.onreconnect();
|
|
}
|
|
});
|
|
}, delay);
|
|
if (this.opts.autoUnref) {
|
|
timer.unref();
|
|
}
|
|
this.subs.push(() => {
|
|
this.clearTimeoutFn(timer);
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Called upon successful reconnect.
|
|
*
|
|
* @private
|
|
*/
|
|
onreconnect() {
|
|
const attempt = this.backoff.attempts;
|
|
this._reconnecting = false;
|
|
this.backoff.reset();
|
|
this.emitReserved("reconnect", attempt);
|
|
}
|
|
}
|
|
manager.Manager = Manager$1;
|
|
|
|
cjs$3.exports;
|
|
|
|
(function (module, exports) {
|
|
var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.WebTransport = exports.WebSocket = exports.NodeWebSocket = exports.XHR = exports.NodeXHR = exports.Fetch = exports.Socket = exports.Manager = exports.protocol = void 0;
|
|
exports.io = lookup;
|
|
exports.connect = lookup;
|
|
exports.default = lookup;
|
|
const url_js_1 = url$1;
|
|
const manager_js_1 = manager;
|
|
Object.defineProperty(exports, "Manager", { enumerable: true, get: function () { return manager_js_1.Manager; } });
|
|
const socket_js_1 = socket$1;
|
|
Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_js_1.Socket; } });
|
|
const debug_1 = __importDefault(browserExports); // debug()
|
|
const debug = (0, debug_1.default)("socket.io-client"); // debug()
|
|
/**
|
|
* Managers cache.
|
|
*/
|
|
const cache = {};
|
|
function lookup(uri, opts) {
|
|
if (typeof uri === "object") {
|
|
opts = uri;
|
|
uri = undefined;
|
|
}
|
|
opts = opts || {};
|
|
const parsed = (0, url_js_1.url)(uri, opts.path || "/socket.io");
|
|
const source = parsed.source;
|
|
const id = parsed.id;
|
|
const path = parsed.path;
|
|
const sameNamespace = cache[id] && path in cache[id]["nsps"];
|
|
const newConnection = opts.forceNew ||
|
|
opts["force new connection"] ||
|
|
false === opts.multiplex ||
|
|
sameNamespace;
|
|
let io;
|
|
if (newConnection) {
|
|
debug("ignoring socket cache for %s", source);
|
|
io = new manager_js_1.Manager(source, opts);
|
|
}
|
|
else {
|
|
if (!cache[id]) {
|
|
debug("new io instance for %s", source);
|
|
cache[id] = new manager_js_1.Manager(source, opts);
|
|
}
|
|
io = cache[id];
|
|
}
|
|
if (parsed.query && !opts.query) {
|
|
opts.query = parsed.queryKey;
|
|
}
|
|
return io.socket(parsed.path, opts);
|
|
}
|
|
// so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
|
|
// namespace (e.g. `io.connect(...)`), for backward compatibility
|
|
Object.assign(lookup, {
|
|
Manager: manager_js_1.Manager,
|
|
Socket: socket_js_1.Socket,
|
|
io: lookup,
|
|
connect: lookup,
|
|
});
|
|
/**
|
|
* Protocol version.
|
|
*
|
|
* @public
|
|
*/
|
|
var socket_io_parser_1 = cjs;
|
|
Object.defineProperty(exports, "protocol", { enumerable: true, get: function () { return socket_io_parser_1.protocol; } });
|
|
var engine_io_client_1 = cjs$2;
|
|
Object.defineProperty(exports, "Fetch", { enumerable: true, get: function () { return engine_io_client_1.Fetch; } });
|
|
Object.defineProperty(exports, "NodeXHR", { enumerable: true, get: function () { return engine_io_client_1.NodeXHR; } });
|
|
Object.defineProperty(exports, "XHR", { enumerable: true, get: function () { return engine_io_client_1.XHR; } });
|
|
Object.defineProperty(exports, "NodeWebSocket", { enumerable: true, get: function () { return engine_io_client_1.NodeWebSocket; } });
|
|
Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function () { return engine_io_client_1.WebSocket; } });
|
|
Object.defineProperty(exports, "WebTransport", { enumerable: true, get: function () { return engine_io_client_1.WebTransport; } });
|
|
|
|
module.exports = lookup;
|
|
} (cjs$3, cjs$3.exports));
|
|
|
|
var cjsExports = cjs$3.exports;
|
|
|
|
var menuBar = {};
|
|
|
|
var Index = {};
|
|
|
|
var name = "morphux";
|
|
var version = "2025.9.1";
|
|
var description = "Standardized Morphix UX framework.";
|
|
var main = "dist/Index.js";
|
|
var types = "dist/index.d.ts";
|
|
var scripts = {
|
|
build: "sass scss/index.scss style.css && tsc && npm run bundle",
|
|
"watch-ts": "tsc -w",
|
|
"watch-scss": "sass scss/index.scss style.css -w",
|
|
"watch-rollup": "rollup -c --watch",
|
|
bundle: "npm run bundle-ts && npm run bundle-defenitions",
|
|
"bundle-ts": "rollup --config rollup.config.js",
|
|
"bundle-defenitions": "dts-bundle-generator dist/index.d.ts -o bundle.d.ts --no-check"
|
|
};
|
|
var author = "";
|
|
var license = "ISC";
|
|
var dependencies = {
|
|
"@egjs/hammerjs": "^2.0.17",
|
|
"@rollup/plugin-commonjs": "^25.0.7",
|
|
"@rollup/plugin-json": "^6.1.0",
|
|
"@rollup/plugin-node-resolve": "^15.1.0",
|
|
"@types/node": "^20.12.8",
|
|
"material-symbols": "^0.17.4",
|
|
rollup: "^2.79.1",
|
|
"rollup-plugin-terser": "^7.0.2",
|
|
sortablejs: "^1.2.1"
|
|
};
|
|
var devDependencies = {
|
|
"@types/sortablejs": "^1.15.8",
|
|
"dts-bundle-generator": "^9.5.1"
|
|
};
|
|
var require$$0$1 = {
|
|
name: name,
|
|
version: version,
|
|
description: description,
|
|
main: main,
|
|
types: types,
|
|
scripts: scripts,
|
|
author: author,
|
|
license: license,
|
|
dependencies: dependencies,
|
|
devDependencies: devDependencies
|
|
};
|
|
|
|
var Morph_Components = {};
|
|
|
|
var Component_Button = {};
|
|
|
|
var CE = {};
|
|
|
|
Object.defineProperty(CE, "__esModule", { value: true });
|
|
CE.ce = ce;
|
|
function ce(tagName, classList, attributes, innerText, innerHTML, style) {
|
|
var _a;
|
|
var element = document.createElement(tagName);
|
|
if (classList)
|
|
if (typeof classList == 'string')
|
|
element.classList.add(classList);
|
|
else
|
|
(_a = element.classList).add.apply(_a, classList);
|
|
if (attributes)
|
|
for (var key in attributes)
|
|
if (element[key] != undefined)
|
|
element[key] = attributes[key];
|
|
else
|
|
element.setAttribute(key, String(attributes[key]));
|
|
if (innerText)
|
|
element.innerText = innerText;
|
|
if (innerHTML)
|
|
element.innerHTML = innerHTML;
|
|
if (style != undefined)
|
|
for (var key in style)
|
|
element.style[key] = style[key];
|
|
return element;
|
|
}
|
|
|
|
var baseComponent = {};
|
|
|
|
Object.defineProperty(baseComponent, "__esModule", { value: true });
|
|
baseComponent.MUXComponent = void 0;
|
|
var MUXComponent = /** @class */ (function () {
|
|
function MUXComponent() {
|
|
this._events = {};
|
|
}
|
|
MUXComponent.prototype.callEvent = function (event) {
|
|
var _a;
|
|
var args = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
args[_i - 1] = arguments[_i];
|
|
}
|
|
if (this._events[event] != undefined) {
|
|
(_a = this._events)[event].apply(_a, args);
|
|
}
|
|
};
|
|
MUXComponent.prototype.on = function (event, callback) {
|
|
this._events[event] = callback;
|
|
};
|
|
MUXComponent.prototype.destroy = function () {
|
|
this.container.remove();
|
|
};
|
|
return MUXComponent;
|
|
}());
|
|
baseComponent.MUXComponent = MUXComponent;
|
|
|
|
var __extends$9 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Button, "__esModule", { value: true });
|
|
Component_Button.ComponentButton = void 0;
|
|
var CE_1$9 = CE;
|
|
var baseComponent_1$9 = baseComponent;
|
|
var ComponentButton = /** @class */ (function (_super) {
|
|
__extends$9(ComponentButton, _super);
|
|
function ComponentButton(options) {
|
|
var _a, _b;
|
|
var _this = _super.call(this) || this;
|
|
_this.mode = 'normal';
|
|
_this.mode = (_a = options === null || options === void 0 ? void 0 : options.mode) !== null && _a !== void 0 ? _a : 'normal';
|
|
var target = (_b = options === null || options === void 0 ? void 0 : options.target) !== null && _b !== void 0 ? _b : '';
|
|
_this.container = (0, CE_1$9.ce)(typeof target === 'string' ? 'a' : 'div', [
|
|
'mux_button',
|
|
"mux_".concat(_this.mode),
|
|
]);
|
|
if ((options === null || options === void 0 ? void 0 : options.materialIcon) != undefined)
|
|
_this.container.append((0, CE_1$9.ce)('span', 'material-symbols-outlined', null, options.materialIcon));
|
|
_this.container.appendChild((0, CE_1$9.ce)('span', ['mux_text', 'mux_normal'], null, options.content));
|
|
_this.container.onclick = function (e) {
|
|
e.preventDefault();
|
|
if (_this.mode == 'disabled')
|
|
return;
|
|
if (typeof target === 'function')
|
|
target();
|
|
else {
|
|
if ((options === null || options === void 0 ? void 0 : options.openInNewTab) == true)
|
|
window.open(target, '_blank');
|
|
else
|
|
window.location.href = target;
|
|
}
|
|
};
|
|
if (typeof target === 'string')
|
|
_this.container.setAttribute('href', target);
|
|
return _this;
|
|
}
|
|
ComponentButton.prototype.updateContent = function (content) {
|
|
this.container.innerHTML = content;
|
|
};
|
|
ComponentButton.prototype.updateMode = function (mode) {
|
|
this.mode = mode;
|
|
this.container.classList.remove('mux_normal');
|
|
this.container.classList.remove('mux_highlight');
|
|
this.container.classList.remove('mux_secondary');
|
|
this.container.classList.remove('mux_disabled');
|
|
this.container.classList.add("mux_".concat(mode));
|
|
};
|
|
return ComponentButton;
|
|
}(baseComponent_1$9.MUXComponent));
|
|
Component_Button.ComponentButton = ComponentButton;
|
|
|
|
var Component_Cards = {};
|
|
|
|
var TextHighlighter = {};
|
|
|
|
Object.defineProperty(TextHighlighter, "__esModule", { value: true });
|
|
TextHighlighter.generateTextHighlights = generateTextHighlights;
|
|
function generateTextHighlights(originalText, additionalClassnames) {
|
|
var _a;
|
|
if (additionalClassnames === void 0) { additionalClassnames = []; }
|
|
var div = document.createElement('div');
|
|
(_a = div.classList).add.apply(_a, additionalClassnames);
|
|
var remainingStr = originalText;
|
|
var regex = /\<(.*?)\>/;
|
|
while (remainingStr.length) {
|
|
var match = regex.exec(remainingStr);
|
|
if (match) {
|
|
var normalText = remainingStr.substring(0, match.index);
|
|
if (normalText) {
|
|
var normalSpan = document.createElement('span');
|
|
normalSpan.className = 'normal';
|
|
normalSpan.textContent = normalText;
|
|
div.appendChild(normalSpan);
|
|
}
|
|
var highlightSpan = document.createElement('span');
|
|
highlightSpan.className = 'highlight';
|
|
highlightSpan.textContent = match[1];
|
|
div.appendChild(highlightSpan);
|
|
remainingStr = remainingStr.substring(match.index + match[0].length);
|
|
}
|
|
else {
|
|
var normalSpan = document.createElement('span');
|
|
normalSpan.className = 'normal';
|
|
normalSpan.textContent = remainingStr;
|
|
div.appendChild(normalSpan);
|
|
break;
|
|
}
|
|
}
|
|
return div;
|
|
}
|
|
|
|
var Sortable$2 = {exports: {}};
|
|
|
|
/**!
|
|
* Sortable
|
|
* @author RubaXa <trash@rubaxa.org>
|
|
* @license MIT
|
|
*/
|
|
Sortable$2.exports;
|
|
|
|
(function (module) {
|
|
(function (factory) {
|
|
|
|
{
|
|
module.exports = factory();
|
|
}
|
|
})(function () {
|
|
|
|
var dragEl,
|
|
ghostEl,
|
|
cloneEl,
|
|
rootEl,
|
|
nextEl,
|
|
|
|
scrollEl,
|
|
scrollParentEl,
|
|
|
|
lastEl,
|
|
lastCSS,
|
|
|
|
oldIndex,
|
|
newIndex,
|
|
|
|
activeGroup,
|
|
autoScroll = {},
|
|
|
|
tapEvt,
|
|
touchEvt,
|
|
|
|
/** @const */
|
|
RSPACE = /\s+/g,
|
|
|
|
expando = 'Sortable' + (new Date).getTime(),
|
|
|
|
win = window,
|
|
document = win.document,
|
|
parseInt = win.parseInt,
|
|
|
|
supportDraggable = !!('draggable' in document.createElement('div')),
|
|
|
|
_silent = false,
|
|
|
|
abs = Math.abs,
|
|
slice = [].slice,
|
|
|
|
touchDragOverListeners = [],
|
|
|
|
_autoScroll = _throttle(function (/**Event*/evt, /**Object*/options, /**HTMLElement*/rootEl) {
|
|
// Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
|
|
if (rootEl && options.scroll) {
|
|
var el,
|
|
rect,
|
|
sens = options.scrollSensitivity,
|
|
speed = options.scrollSpeed,
|
|
|
|
x = evt.clientX,
|
|
y = evt.clientY,
|
|
|
|
winWidth = window.innerWidth,
|
|
winHeight = window.innerHeight,
|
|
|
|
vx,
|
|
vy
|
|
;
|
|
|
|
// Delect scrollEl
|
|
if (scrollParentEl !== rootEl) {
|
|
scrollEl = options.scroll;
|
|
scrollParentEl = rootEl;
|
|
|
|
if (scrollEl === true) {
|
|
scrollEl = rootEl;
|
|
|
|
do {
|
|
if ((scrollEl.offsetWidth < scrollEl.scrollWidth) ||
|
|
(scrollEl.offsetHeight < scrollEl.scrollHeight)
|
|
) {
|
|
break;
|
|
}
|
|
/* jshint boss:true */
|
|
} while (scrollEl = scrollEl.parentNode);
|
|
}
|
|
}
|
|
|
|
if (scrollEl) {
|
|
el = scrollEl;
|
|
rect = scrollEl.getBoundingClientRect();
|
|
vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
|
|
vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens);
|
|
}
|
|
|
|
|
|
if (!(vx || vy)) {
|
|
vx = (winWidth - x <= sens) - (x <= sens);
|
|
vy = (winHeight - y <= sens) - (y <= sens);
|
|
|
|
/* jshint expr:true */
|
|
(vx || vy) && (el = win);
|
|
}
|
|
|
|
|
|
if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
|
|
autoScroll.el = el;
|
|
autoScroll.vx = vx;
|
|
autoScroll.vy = vy;
|
|
|
|
clearInterval(autoScroll.pid);
|
|
|
|
if (el) {
|
|
autoScroll.pid = setInterval(function () {
|
|
if (el === win) {
|
|
win.scrollTo(win.pageXOffset + vx * speed, win.pageYOffset + vy * speed);
|
|
} else {
|
|
vy && (el.scrollTop += vy * speed);
|
|
vx && (el.scrollLeft += vx * speed);
|
|
}
|
|
}, 24);
|
|
}
|
|
}
|
|
}
|
|
}, 30)
|
|
;
|
|
|
|
|
|
|
|
/**
|
|
* @class Sortable
|
|
* @param {HTMLElement} el
|
|
* @param {Object} [options]
|
|
*/
|
|
function Sortable(el, options) {
|
|
this.el = el; // root element
|
|
this.options = options = _extend({}, options);
|
|
|
|
|
|
// Export instance
|
|
el[expando] = this;
|
|
|
|
|
|
// Default options
|
|
var defaults = {
|
|
group: Math.random(),
|
|
sort: true,
|
|
disabled: false,
|
|
store: null,
|
|
handle: null,
|
|
scroll: true,
|
|
scrollSensitivity: 30,
|
|
scrollSpeed: 10,
|
|
draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
|
|
ghostClass: 'sortable-ghost',
|
|
ignore: 'a, img',
|
|
filter: null,
|
|
animation: 0,
|
|
setData: function (dataTransfer, dragEl) {
|
|
dataTransfer.setData('Text', dragEl.textContent);
|
|
},
|
|
dropBubble: false,
|
|
dragoverBubble: false,
|
|
dataIdAttr: 'data-id',
|
|
delay: 0
|
|
};
|
|
|
|
|
|
// Set default options
|
|
for (var name in defaults) {
|
|
!(name in options) && (options[name] = defaults[name]);
|
|
}
|
|
|
|
|
|
var group = options.group;
|
|
|
|
if (!group || typeof group != 'object') {
|
|
group = options.group = { name: group };
|
|
}
|
|
|
|
|
|
['pull', 'put'].forEach(function (key) {
|
|
if (!(key in group)) {
|
|
group[key] = true;
|
|
}
|
|
});
|
|
|
|
|
|
options.groups = ' ' + group.name + (group.put.join ? ' ' + group.put.join(' ') : '') + ' ';
|
|
|
|
|
|
// Bind all private methods
|
|
for (var fn in this) {
|
|
if (fn.charAt(0) === '_') {
|
|
this[fn] = _bind(this, this[fn]);
|
|
}
|
|
}
|
|
|
|
|
|
// Bind events
|
|
_on(el, 'mousedown', this._onTapStart);
|
|
_on(el, 'touchstart', this._onTapStart);
|
|
|
|
_on(el, 'dragover', this);
|
|
_on(el, 'dragenter', this);
|
|
|
|
touchDragOverListeners.push(this._onDragOver);
|
|
|
|
// Restore sorting
|
|
options.store && this.sort(options.store.get(this));
|
|
}
|
|
|
|
|
|
Sortable.prototype = /** @lends Sortable.prototype */ {
|
|
constructor: Sortable,
|
|
|
|
_onTapStart: function (/** Event|TouchEvent */evt) {
|
|
var _this = this,
|
|
el = this.el,
|
|
options = this.options,
|
|
type = evt.type,
|
|
touch = evt.touches && evt.touches[0],
|
|
target = (touch || evt).target,
|
|
originalTarget = target,
|
|
filter = options.filter;
|
|
|
|
|
|
if (type === 'mousedown' && evt.button !== 0 || options.disabled) {
|
|
return; // only left button or enabled
|
|
}
|
|
|
|
target = _closest(target, options.draggable, el);
|
|
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
// get the index of the dragged element within its parent
|
|
oldIndex = _index(target);
|
|
|
|
// Check filter
|
|
if (typeof filter === 'function') {
|
|
if (filter.call(this, evt, target, this)) {
|
|
_dispatchEvent(_this, originalTarget, 'filter', target, el, oldIndex);
|
|
evt.preventDefault();
|
|
return; // cancel dnd
|
|
}
|
|
}
|
|
else if (filter) {
|
|
filter = filter.split(',').some(function (criteria) {
|
|
criteria = _closest(originalTarget, criteria.trim(), el);
|
|
|
|
if (criteria) {
|
|
_dispatchEvent(_this, criteria, 'filter', target, el, oldIndex);
|
|
return true;
|
|
}
|
|
});
|
|
|
|
if (filter) {
|
|
evt.preventDefault();
|
|
return; // cancel dnd
|
|
}
|
|
}
|
|
|
|
|
|
if (options.handle && !_closest(originalTarget, options.handle, el)) {
|
|
return;
|
|
}
|
|
|
|
|
|
// Prepare `dragstart`
|
|
this._prepareDragStart(evt, touch, target);
|
|
},
|
|
|
|
_prepareDragStart: function (/** Event */evt, /** Touch */touch, /** HTMLElement */target) {
|
|
var _this = this,
|
|
el = _this.el,
|
|
options = _this.options,
|
|
ownerDocument = el.ownerDocument,
|
|
dragStartFn;
|
|
|
|
if (target && !dragEl && (target.parentNode === el)) {
|
|
tapEvt = evt;
|
|
|
|
rootEl = el;
|
|
dragEl = target;
|
|
nextEl = dragEl.nextSibling;
|
|
activeGroup = options.group;
|
|
|
|
dragStartFn = function () {
|
|
// Delayed drag has been triggered
|
|
// we can re-enable the events: touchmove/mousemove
|
|
_this._disableDelayedDrag();
|
|
|
|
// Make the element draggable
|
|
dragEl.draggable = true;
|
|
|
|
// Disable "draggable"
|
|
options.ignore.split(',').forEach(function (criteria) {
|
|
_find(dragEl, criteria.trim(), _disableDraggable);
|
|
});
|
|
|
|
// Bind the events: dragstart/dragend
|
|
_this._triggerDragStart(touch);
|
|
};
|
|
|
|
_on(ownerDocument, 'mouseup', _this._onDrop);
|
|
_on(ownerDocument, 'touchend', _this._onDrop);
|
|
_on(ownerDocument, 'touchcancel', _this._onDrop);
|
|
|
|
if (options.delay) {
|
|
// If the user moves the pointer before the delay has been reached:
|
|
// disable the delayed drag
|
|
_on(ownerDocument, 'mousemove', _this._disableDelayedDrag);
|
|
_on(ownerDocument, 'touchmove', _this._disableDelayedDrag);
|
|
|
|
_this._dragStartTimer = setTimeout(dragStartFn, options.delay);
|
|
} else {
|
|
dragStartFn();
|
|
}
|
|
}
|
|
},
|
|
|
|
_disableDelayedDrag: function () {
|
|
var ownerDocument = this.el.ownerDocument;
|
|
|
|
clearTimeout(this._dragStartTimer);
|
|
|
|
_off(ownerDocument, 'mousemove', this._disableDelayedDrag);
|
|
_off(ownerDocument, 'touchmove', this._disableDelayedDrag);
|
|
},
|
|
|
|
_triggerDragStart: function (/** Touch */touch) {
|
|
if (touch) {
|
|
// Touch device support
|
|
tapEvt = {
|
|
target: dragEl,
|
|
clientX: touch.clientX,
|
|
clientY: touch.clientY
|
|
};
|
|
|
|
this._onDragStart(tapEvt, 'touch');
|
|
}
|
|
else if (!supportDraggable) {
|
|
this._onDragStart(tapEvt, true);
|
|
}
|
|
else {
|
|
_on(dragEl, 'dragend', this);
|
|
_on(rootEl, 'dragstart', this._onDragStart);
|
|
}
|
|
|
|
try {
|
|
if (document.selection) {
|
|
document.selection.empty();
|
|
} else {
|
|
window.getSelection().removeAllRanges();
|
|
}
|
|
} catch (err) {
|
|
}
|
|
},
|
|
|
|
_dragStarted: function () {
|
|
if (rootEl && dragEl) {
|
|
// Apply effect
|
|
_toggleClass(dragEl, this.options.ghostClass, true);
|
|
|
|
Sortable.active = this;
|
|
|
|
// Drag start event
|
|
_dispatchEvent(this, rootEl, 'start', dragEl, rootEl, oldIndex);
|
|
}
|
|
},
|
|
|
|
_emulateDragOver: function () {
|
|
if (touchEvt) {
|
|
_css(ghostEl, 'display', 'none');
|
|
|
|
var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY),
|
|
parent = target,
|
|
groupName = ' ' + this.options.group.name + '',
|
|
i = touchDragOverListeners.length;
|
|
|
|
if (parent) {
|
|
do {
|
|
if (parent[expando] && parent[expando].options.groups.indexOf(groupName) > -1) {
|
|
while (i--) {
|
|
touchDragOverListeners[i]({
|
|
clientX: touchEvt.clientX,
|
|
clientY: touchEvt.clientY,
|
|
target: target,
|
|
rootEl: parent
|
|
});
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
target = parent; // store last element
|
|
}
|
|
/* jshint boss:true */
|
|
while (parent = parent.parentNode);
|
|
}
|
|
|
|
_css(ghostEl, 'display', '');
|
|
}
|
|
},
|
|
|
|
|
|
_onTouchMove: function (/**TouchEvent*/evt) {
|
|
if (tapEvt) {
|
|
var touch = evt.touches ? evt.touches[0] : evt,
|
|
dx = touch.clientX - tapEvt.clientX,
|
|
dy = touch.clientY - tapEvt.clientY,
|
|
translate3d = evt.touches ? 'translate3d(' + dx + 'px,' + dy + 'px,0)' : 'translate(' + dx + 'px,' + dy + 'px)';
|
|
|
|
touchEvt = touch;
|
|
|
|
_css(ghostEl, 'webkitTransform', translate3d);
|
|
_css(ghostEl, 'mozTransform', translate3d);
|
|
_css(ghostEl, 'msTransform', translate3d);
|
|
_css(ghostEl, 'transform', translate3d);
|
|
|
|
evt.preventDefault();
|
|
}
|
|
},
|
|
|
|
|
|
_onDragStart: function (/**Event*/evt, /**boolean*/useFallback) {
|
|
var dataTransfer = evt.dataTransfer,
|
|
options = this.options;
|
|
|
|
this._offUpEvents();
|
|
|
|
if (activeGroup.pull == 'clone') {
|
|
cloneEl = dragEl.cloneNode(true);
|
|
_css(cloneEl, 'display', 'none');
|
|
rootEl.insertBefore(cloneEl, dragEl);
|
|
}
|
|
|
|
if (useFallback) {
|
|
var rect = dragEl.getBoundingClientRect(),
|
|
css = _css(dragEl),
|
|
ghostRect;
|
|
|
|
ghostEl = dragEl.cloneNode(true);
|
|
|
|
_css(ghostEl, 'top', rect.top - parseInt(css.marginTop, 10));
|
|
_css(ghostEl, 'left', rect.left - parseInt(css.marginLeft, 10));
|
|
_css(ghostEl, 'width', rect.width);
|
|
_css(ghostEl, 'height', rect.height);
|
|
_css(ghostEl, 'opacity', '0.8');
|
|
_css(ghostEl, 'position', 'fixed');
|
|
_css(ghostEl, 'zIndex', '100000');
|
|
|
|
rootEl.appendChild(ghostEl);
|
|
|
|
// Fixing dimensions.
|
|
ghostRect = ghostEl.getBoundingClientRect();
|
|
_css(ghostEl, 'width', rect.width * 2 - ghostRect.width);
|
|
_css(ghostEl, 'height', rect.height * 2 - ghostRect.height);
|
|
|
|
if (useFallback === 'touch') {
|
|
// Bind touch events
|
|
_on(document, 'touchmove', this._onTouchMove);
|
|
_on(document, 'touchend', this._onDrop);
|
|
_on(document, 'touchcancel', this._onDrop);
|
|
} else {
|
|
// Old brwoser
|
|
_on(document, 'mousemove', this._onTouchMove);
|
|
_on(document, 'mouseup', this._onDrop);
|
|
}
|
|
|
|
this._loopId = setInterval(this._emulateDragOver, 150);
|
|
}
|
|
else {
|
|
if (dataTransfer) {
|
|
dataTransfer.effectAllowed = 'move';
|
|
options.setData && options.setData.call(this, dataTransfer, dragEl);
|
|
}
|
|
|
|
_on(document, 'drop', this);
|
|
}
|
|
|
|
setTimeout(this._dragStarted, 0);
|
|
},
|
|
|
|
_onDragOver: function (/**Event*/evt) {
|
|
var el = this.el,
|
|
target,
|
|
dragRect,
|
|
revert,
|
|
options = this.options,
|
|
group = options.group,
|
|
groupPut = group.put,
|
|
isOwner = (activeGroup === group),
|
|
canSort = options.sort;
|
|
|
|
if (evt.preventDefault !== void 0) {
|
|
evt.preventDefault();
|
|
!options.dragoverBubble && evt.stopPropagation();
|
|
}
|
|
|
|
if (activeGroup && !options.disabled &&
|
|
(isOwner
|
|
? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
|
|
: activeGroup.pull && groupPut && (
|
|
(activeGroup.name === group.name) || // by Name
|
|
(groupPut.indexOf && ~groupPut.indexOf(activeGroup.name)) // by Array
|
|
)
|
|
) &&
|
|
(evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
|
|
) {
|
|
// Smart auto-scrolling
|
|
_autoScroll(evt, options, this.el);
|
|
|
|
if (_silent) {
|
|
return;
|
|
}
|
|
|
|
target = _closest(evt.target, options.draggable, el);
|
|
dragRect = dragEl.getBoundingClientRect();
|
|
|
|
|
|
if (revert) {
|
|
_cloneHide(true);
|
|
|
|
if (cloneEl || nextEl) {
|
|
rootEl.insertBefore(dragEl, cloneEl || nextEl);
|
|
}
|
|
else if (!canSort) {
|
|
rootEl.appendChild(dragEl);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
if ((el.children.length === 0) || (el.children[0] === ghostEl) ||
|
|
(el === evt.target) && (target = _ghostInBottom(el, evt))
|
|
) {
|
|
if (target) {
|
|
if (target.animated) {
|
|
return;
|
|
}
|
|
targetRect = target.getBoundingClientRect();
|
|
}
|
|
|
|
_cloneHide(isOwner);
|
|
|
|
if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect) !== false) {
|
|
el.appendChild(dragEl);
|
|
this._animate(dragRect, dragEl);
|
|
target && this._animate(targetRect, target);
|
|
}
|
|
}
|
|
else if (target && !target.animated && target !== dragEl && (target.parentNode[expando] !== void 0)) {
|
|
if (lastEl !== target) {
|
|
lastEl = target;
|
|
lastCSS = _css(target);
|
|
}
|
|
|
|
|
|
var targetRect = target.getBoundingClientRect(),
|
|
width = targetRect.right - targetRect.left,
|
|
height = targetRect.bottom - targetRect.top,
|
|
floating = /left|right|inline/.test(lastCSS.cssFloat + lastCSS.display),
|
|
isWide = (target.offsetWidth > dragEl.offsetWidth),
|
|
isLong = (target.offsetHeight > dragEl.offsetHeight),
|
|
halfway = (floating ? (evt.clientX - targetRect.left) / width : (evt.clientY - targetRect.top) / height) > 0.5,
|
|
nextSibling = target.nextElementSibling,
|
|
moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect),
|
|
after
|
|
;
|
|
|
|
if (moveVector !== false) {
|
|
_silent = true;
|
|
setTimeout(_unsilent, 30);
|
|
|
|
_cloneHide(isOwner);
|
|
|
|
if (moveVector === 1 || moveVector === -1) {
|
|
after = (moveVector === 1);
|
|
}
|
|
else if (floating) {
|
|
after = (target.previousElementSibling === dragEl) && !isWide || halfway && isWide;
|
|
} else {
|
|
after = (nextSibling !== dragEl) && !isLong || halfway && isLong;
|
|
}
|
|
|
|
if (after && !nextSibling) {
|
|
el.appendChild(dragEl);
|
|
} else {
|
|
target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
|
|
}
|
|
|
|
this._animate(dragRect, dragEl);
|
|
this._animate(targetRect, target);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
_animate: function (prevRect, target) {
|
|
var ms = this.options.animation;
|
|
|
|
if (ms) {
|
|
var currentRect = target.getBoundingClientRect();
|
|
|
|
_css(target, 'transition', 'none');
|
|
_css(target, 'transform', 'translate3d('
|
|
+ (prevRect.left - currentRect.left) + 'px,'
|
|
+ (prevRect.top - currentRect.top) + 'px,0)'
|
|
);
|
|
|
|
target.offsetWidth; // repaint
|
|
|
|
_css(target, 'transition', 'all ' + ms + 'ms');
|
|
_css(target, 'transform', 'translate3d(0,0,0)');
|
|
|
|
clearTimeout(target.animated);
|
|
target.animated = setTimeout(function () {
|
|
_css(target, 'transition', '');
|
|
_css(target, 'transform', '');
|
|
target.animated = false;
|
|
}, ms);
|
|
}
|
|
},
|
|
|
|
_offUpEvents: function () {
|
|
var ownerDocument = this.el.ownerDocument;
|
|
|
|
_off(document, 'touchmove', this._onTouchMove);
|
|
_off(ownerDocument, 'mouseup', this._onDrop);
|
|
_off(ownerDocument, 'touchend', this._onDrop);
|
|
_off(ownerDocument, 'touchcancel', this._onDrop);
|
|
},
|
|
|
|
_onDrop: function (/**Event*/evt) {
|
|
var el = this.el,
|
|
options = this.options;
|
|
|
|
clearInterval(this._loopId);
|
|
clearInterval(autoScroll.pid);
|
|
clearTimeout(this._dragStartTimer);
|
|
|
|
// Unbind events
|
|
_off(document, 'drop', this);
|
|
_off(document, 'mousemove', this._onTouchMove);
|
|
_off(el, 'dragstart', this._onDragStart);
|
|
|
|
this._offUpEvents();
|
|
|
|
if (evt) {
|
|
evt.preventDefault();
|
|
!options.dropBubble && evt.stopPropagation();
|
|
|
|
ghostEl && ghostEl.parentNode.removeChild(ghostEl);
|
|
|
|
if (dragEl) {
|
|
_off(dragEl, 'dragend', this);
|
|
|
|
_disableDraggable(dragEl);
|
|
_toggleClass(dragEl, this.options.ghostClass, false);
|
|
|
|
if (rootEl !== dragEl.parentNode) {
|
|
newIndex = _index(dragEl);
|
|
|
|
// drag from one list and drop into another
|
|
_dispatchEvent(null, dragEl.parentNode, 'sort', dragEl, rootEl, oldIndex, newIndex);
|
|
_dispatchEvent(this, rootEl, 'sort', dragEl, rootEl, oldIndex, newIndex);
|
|
|
|
// Add event
|
|
_dispatchEvent(null, dragEl.parentNode, 'add', dragEl, rootEl, oldIndex, newIndex);
|
|
|
|
// Remove event
|
|
_dispatchEvent(this, rootEl, 'remove', dragEl, rootEl, oldIndex, newIndex);
|
|
}
|
|
else {
|
|
// Remove clone
|
|
cloneEl && cloneEl.parentNode.removeChild(cloneEl);
|
|
|
|
if (dragEl.nextSibling !== nextEl) {
|
|
// Get the index of the dragged element within its parent
|
|
newIndex = _index(dragEl);
|
|
|
|
// drag & drop within the same list
|
|
_dispatchEvent(this, rootEl, 'update', dragEl, rootEl, oldIndex, newIndex);
|
|
_dispatchEvent(this, rootEl, 'sort', dragEl, rootEl, oldIndex, newIndex);
|
|
}
|
|
}
|
|
|
|
if (Sortable.active) {
|
|
// Drag end event
|
|
_dispatchEvent(this, rootEl, 'end', dragEl, rootEl, oldIndex, newIndex);
|
|
|
|
// Save sorting
|
|
this.save();
|
|
}
|
|
}
|
|
|
|
// Nulling
|
|
rootEl =
|
|
dragEl =
|
|
ghostEl =
|
|
nextEl =
|
|
cloneEl =
|
|
|
|
scrollEl =
|
|
scrollParentEl =
|
|
|
|
tapEvt =
|
|
touchEvt =
|
|
|
|
lastEl =
|
|
lastCSS =
|
|
|
|
activeGroup =
|
|
Sortable.active = null;
|
|
}
|
|
},
|
|
|
|
|
|
handleEvent: function (/**Event*/evt) {
|
|
var type = evt.type;
|
|
|
|
if (type === 'dragover' || type === 'dragenter') {
|
|
if (dragEl) {
|
|
this._onDragOver(evt);
|
|
_globalDragOver(evt);
|
|
}
|
|
}
|
|
else if (type === 'drop' || type === 'dragend') {
|
|
this._onDrop(evt);
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Serializes the item into an array of string.
|
|
* @returns {String[]}
|
|
*/
|
|
toArray: function () {
|
|
var order = [],
|
|
el,
|
|
children = this.el.children,
|
|
i = 0,
|
|
n = children.length,
|
|
options = this.options;
|
|
|
|
for (; i < n; i++) {
|
|
el = children[i];
|
|
if (_closest(el, options.draggable, this.el)) {
|
|
order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
|
|
}
|
|
}
|
|
|
|
return order;
|
|
},
|
|
|
|
|
|
/**
|
|
* Sorts the elements according to the array.
|
|
* @param {String[]} order order of the items
|
|
*/
|
|
sort: function (order) {
|
|
var items = {}, rootEl = this.el;
|
|
|
|
this.toArray().forEach(function (id, i) {
|
|
var el = rootEl.children[i];
|
|
|
|
if (_closest(el, this.options.draggable, rootEl)) {
|
|
items[id] = el;
|
|
}
|
|
}, this);
|
|
|
|
order.forEach(function (id) {
|
|
if (items[id]) {
|
|
rootEl.removeChild(items[id]);
|
|
rootEl.appendChild(items[id]);
|
|
}
|
|
});
|
|
},
|
|
|
|
|
|
/**
|
|
* Save the current sorting
|
|
*/
|
|
save: function () {
|
|
var store = this.options.store;
|
|
store && store.set(this);
|
|
},
|
|
|
|
|
|
/**
|
|
* For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
|
|
* @param {HTMLElement} el
|
|
* @param {String} [selector] default: `options.draggable`
|
|
* @returns {HTMLElement|null}
|
|
*/
|
|
closest: function (el, selector) {
|
|
return _closest(el, selector || this.options.draggable, this.el);
|
|
},
|
|
|
|
|
|
/**
|
|
* Set/get option
|
|
* @param {string} name
|
|
* @param {*} [value]
|
|
* @returns {*}
|
|
*/
|
|
option: function (name, value) {
|
|
var options = this.options;
|
|
|
|
if (value === void 0) {
|
|
return options[name];
|
|
} else {
|
|
options[name] = value;
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Destroy
|
|
*/
|
|
destroy: function () {
|
|
var el = this.el;
|
|
|
|
el[expando] = null;
|
|
|
|
_off(el, 'mousedown', this._onTapStart);
|
|
_off(el, 'touchstart', this._onTapStart);
|
|
|
|
_off(el, 'dragover', this);
|
|
_off(el, 'dragenter', this);
|
|
|
|
// Remove draggable attributes
|
|
Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
|
|
el.removeAttribute('draggable');
|
|
});
|
|
|
|
touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);
|
|
|
|
this._onDrop();
|
|
|
|
this.el = el = null;
|
|
}
|
|
};
|
|
|
|
|
|
function _cloneHide(state) {
|
|
if (cloneEl && (cloneEl.state !== state)) {
|
|
_css(cloneEl, 'display', state ? 'none' : '');
|
|
!state && cloneEl.state && rootEl.insertBefore(cloneEl, dragEl);
|
|
cloneEl.state = state;
|
|
}
|
|
}
|
|
|
|
|
|
function _bind(ctx, fn) {
|
|
var args = slice.call(arguments, 2);
|
|
return fn.bind ? fn.bind.apply(fn, [ctx].concat(args)) : function () {
|
|
return fn.apply(ctx, args.concat(slice.call(arguments)));
|
|
};
|
|
}
|
|
|
|
|
|
function _closest(/**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx) {
|
|
if (el) {
|
|
ctx = ctx || document;
|
|
selector = selector.split('.');
|
|
|
|
var tag = selector.shift().toUpperCase(),
|
|
re = new RegExp('\\s(' + selector.join('|') + ')(?=\\s)', 'g');
|
|
|
|
do {
|
|
if (
|
|
(tag === '>*' && el.parentNode === ctx) || (
|
|
(tag === '' || el.nodeName.toUpperCase() == tag) &&
|
|
(!selector.length || ((' ' + el.className + ' ').match(re) || []).length == selector.length)
|
|
)
|
|
) {
|
|
return el;
|
|
}
|
|
}
|
|
while (el !== ctx && (el = el.parentNode));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
function _globalDragOver(/**Event*/evt) {
|
|
evt.dataTransfer.dropEffect = 'move';
|
|
evt.preventDefault();
|
|
}
|
|
|
|
|
|
function _on(el, event, fn) {
|
|
el.addEventListener(event, fn, false);
|
|
}
|
|
|
|
|
|
function _off(el, event, fn) {
|
|
el.removeEventListener(event, fn, false);
|
|
}
|
|
|
|
|
|
function _toggleClass(el, name, state) {
|
|
if (el) {
|
|
if (el.classList) {
|
|
el.classList[state ? 'add' : 'remove'](name);
|
|
}
|
|
else {
|
|
var className = (' ' + el.className + ' ').replace(RSPACE, ' ').replace(' ' + name + ' ', ' ');
|
|
el.className = (className + (state ? ' ' + name : '')).replace(RSPACE, ' ');
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function _css(el, prop, val) {
|
|
var style = el && el.style;
|
|
|
|
if (style) {
|
|
if (val === void 0) {
|
|
if (document.defaultView && document.defaultView.getComputedStyle) {
|
|
val = document.defaultView.getComputedStyle(el, '');
|
|
}
|
|
else if (el.currentStyle) {
|
|
val = el.currentStyle;
|
|
}
|
|
|
|
return prop === void 0 ? val : val[prop];
|
|
}
|
|
else {
|
|
if (!(prop in style)) {
|
|
prop = '-webkit-' + prop;
|
|
}
|
|
|
|
style[prop] = val + (typeof val === 'string' ? '' : 'px');
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function _find(ctx, tagName, iterator) {
|
|
if (ctx) {
|
|
var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;
|
|
|
|
if (iterator) {
|
|
for (; i < n; i++) {
|
|
iterator(list[i], i);
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
|
|
|
|
function _dispatchEvent(sortable, rootEl, name, targetEl, fromEl, startIndex, newIndex) {
|
|
var evt = document.createEvent('Event'),
|
|
options = (sortable || rootEl[expando]).options,
|
|
onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
|
|
|
|
evt.initEvent(name, true, true);
|
|
|
|
evt.to = rootEl;
|
|
evt.from = fromEl || rootEl;
|
|
evt.item = targetEl || rootEl;
|
|
evt.clone = cloneEl;
|
|
|
|
evt.oldIndex = startIndex;
|
|
evt.newIndex = newIndex;
|
|
|
|
rootEl.dispatchEvent(evt);
|
|
|
|
if (options[onName]) {
|
|
options[onName].call(sortable, evt);
|
|
}
|
|
}
|
|
|
|
|
|
function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect) {
|
|
var evt,
|
|
sortable = fromEl[expando],
|
|
onMoveFn = sortable.options.onMove,
|
|
retVal;
|
|
|
|
if (onMoveFn) {
|
|
evt = document.createEvent('Event');
|
|
evt.initEvent('move', true, true);
|
|
|
|
evt.to = toEl;
|
|
evt.from = fromEl;
|
|
evt.dragged = dragEl;
|
|
evt.draggedRect = dragRect;
|
|
evt.related = targetEl || toEl;
|
|
evt.relatedRect = targetRect || toEl.getBoundingClientRect();
|
|
|
|
retVal = onMoveFn.call(sortable, evt);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
function _disableDraggable(el) {
|
|
el.draggable = false;
|
|
}
|
|
|
|
|
|
function _unsilent() {
|
|
_silent = false;
|
|
}
|
|
|
|
|
|
/** @returns {HTMLElement|false} */
|
|
function _ghostInBottom(el, evt) {
|
|
var lastEl = el.lastElementChild,
|
|
rect = lastEl.getBoundingClientRect();
|
|
|
|
return (evt.clientY - (rect.top + rect.height) > 5) && lastEl; // min delta
|
|
}
|
|
|
|
|
|
/**
|
|
* Generate id
|
|
* @param {HTMLElement} el
|
|
* @returns {String}
|
|
* @private
|
|
*/
|
|
function _generateId(el) {
|
|
var str = el.tagName + el.className + el.src + el.href + el.textContent,
|
|
i = str.length,
|
|
sum = 0;
|
|
|
|
while (i--) {
|
|
sum += str.charCodeAt(i);
|
|
}
|
|
|
|
return sum.toString(36);
|
|
}
|
|
|
|
/**
|
|
* Returns the index of an element within its parent
|
|
* @param el
|
|
* @returns {number}
|
|
* @private
|
|
*/
|
|
function _index(/**HTMLElement*/el) {
|
|
var index = 0;
|
|
while (el && (el = el.previousElementSibling)) {
|
|
if (el.nodeName.toUpperCase() !== 'TEMPLATE') {
|
|
index++;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
function _throttle(callback, ms) {
|
|
var args, _this;
|
|
|
|
return function () {
|
|
if (args === void 0) {
|
|
args = arguments;
|
|
_this = this;
|
|
|
|
setTimeout(function () {
|
|
if (args.length === 1) {
|
|
callback.call(_this, args[0]);
|
|
} else {
|
|
callback.apply(_this, args);
|
|
}
|
|
|
|
args = void 0;
|
|
}, ms);
|
|
}
|
|
};
|
|
}
|
|
|
|
function _extend(dst, src) {
|
|
if (dst && src) {
|
|
for (var key in src) {
|
|
if (src.hasOwnProperty(key)) {
|
|
dst[key] = src[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return dst;
|
|
}
|
|
|
|
|
|
// Export utils
|
|
Sortable.utils = {
|
|
on: _on,
|
|
off: _off,
|
|
css: _css,
|
|
find: _find,
|
|
bind: _bind,
|
|
is: function (el, selector) {
|
|
return !!_closest(el, selector, el);
|
|
},
|
|
extend: _extend,
|
|
throttle: _throttle,
|
|
closest: _closest,
|
|
toggleClass: _toggleClass,
|
|
index: _index
|
|
};
|
|
|
|
|
|
Sortable.version = '1.2.1';
|
|
|
|
|
|
/**
|
|
* Create sortable instance
|
|
* @param {HTMLElement} el
|
|
* @param {Object} [options]
|
|
*/
|
|
Sortable.create = function (el, options) {
|
|
return new Sortable(el, options);
|
|
};
|
|
|
|
// Export
|
|
return Sortable;
|
|
});
|
|
} (Sortable$2));
|
|
|
|
var SortableExports = Sortable$2.exports;
|
|
|
|
var __extends$8 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Cards, "__esModule", { value: true });
|
|
Component_Cards.ComponentCards = void 0;
|
|
var CE_1$8 = CE;
|
|
var TextHighlighter_1 = TextHighlighter;
|
|
var baseComponent_1$8 = baseComponent;
|
|
var Sortable$1 = SortableExports;
|
|
var ComponentCards = /** @class */ (function (_super) {
|
|
__extends$8(ComponentCards, _super);
|
|
function ComponentCards(options) {
|
|
var _a, _b;
|
|
var _this = _super.call(this) || this;
|
|
_this.entries = {};
|
|
_this.container = (0, CE_1$8.ce)('div', 'mux_cards');
|
|
if (options.onePerRow === true)
|
|
_this.container.classList.add('mux_cards-oneperrow');
|
|
if (options.dragable !== false)
|
|
_this.sortable = new Sortable$1(_this.container, {
|
|
ghostClass: 'mux_cards-item-dragging',
|
|
onStart: function () {
|
|
_this.container.classList.add('mux_cards-dragging');
|
|
},
|
|
onEnd: function (evt) {
|
|
_this.container.classList.remove('mux_cards-dragging');
|
|
_this.callEvent('orderUpdated', _this.getOrder());
|
|
},
|
|
});
|
|
_this.highlightText = (_a = options === null || options === void 0 ? void 0 : options.highlightText) !== null && _a !== void 0 ? _a : false;
|
|
_this.setItems((_b = options === null || options === void 0 ? void 0 : options.items) !== null && _b !== void 0 ? _b : []);
|
|
return _this;
|
|
}
|
|
ComponentCards.prototype.setItems = function (items) {
|
|
var _this = this;
|
|
this.container.innerHTML = '';
|
|
this.entries = {};
|
|
items.forEach(function (item) { return _this.addItem(item); });
|
|
};
|
|
ComponentCards.prototype.addItem = function (item) {
|
|
var _this = this;
|
|
var _a, _b;
|
|
var element = (0, CE_1$8.ce)(item.href != undefined ? 'a' : 'div', 'mux_cards-item', {
|
|
uid: item.uniqueIdentifier,
|
|
});
|
|
if (item.href != undefined)
|
|
element.href = item.href;
|
|
if (item.click != undefined)
|
|
element.onclick = function () { return item.click(); };
|
|
if (item.tooltip != undefined)
|
|
element.title = item.title;
|
|
if (item.enabled == false)
|
|
element.classList.add('mux_cards-item-disabled');
|
|
if (item.uniqueIdentifier != undefined)
|
|
this.entries[item.uniqueIdentifier] = element;
|
|
if (item.thumbnail != null) {
|
|
var thumbnailType = (_a = item.thumbnailType) !== null && _a !== void 0 ? _a : 'image';
|
|
if (thumbnailType == 'image') {
|
|
element.appendChild((0, CE_1$8.ce)('img', 'mux_cards-item-thumbnail', {
|
|
src: item.thumbnail,
|
|
}));
|
|
}
|
|
else if (thumbnailType == 'frame') {
|
|
var ratio = (_b = item.thumbnailWidthRatio) !== null && _b !== void 0 ? _b : 1;
|
|
var frame = (0, CE_1$8.ce)('iframe', 'mux_cards-item-thumbnail', {
|
|
scrolling: 'no',
|
|
src: item.thumbnail,
|
|
});
|
|
element.appendChild(frame);
|
|
var scaleClock = setInterval(function () {
|
|
if (element == null ||
|
|
element.parentElement == null ||
|
|
frame == null)
|
|
return clearInterval(scaleClock);
|
|
frame.style.width = "".concat(frame.clientHeight * ratio, "px");
|
|
}, 100);
|
|
}
|
|
}
|
|
var info = (0, CE_1$8.ce)('div', 'mux_cards-item-info');
|
|
info.appendChild(this.highlightText
|
|
? (0, TextHighlighter_1.generateTextHighlights)(item.title, [
|
|
'mux_header',
|
|
'mux_small',
|
|
])
|
|
: (0, CE_1$8.ce)('div', ['mux_header', 'mux_small'], null, item.title));
|
|
if (item.sublines != undefined && item.sublines.length > 0)
|
|
item.sublines.forEach(function (subline) {
|
|
if (subline != null)
|
|
info.appendChild(_this.highlightText
|
|
? (0, TextHighlighter_1.generateTextHighlights)(subline, [
|
|
'mux_text',
|
|
'mux_small',
|
|
])
|
|
: (0, CE_1$8.ce)('div', ['mux_text', 'mux_small'], null, subline));
|
|
});
|
|
element.appendChild(info);
|
|
if (item.actions != undefined && item.actions.length > 0) {
|
|
var buttons = (0, CE_1$8.ce)('div', 'mux_cards-item-buttons');
|
|
item.actions.forEach(function (action) {
|
|
var buttonelem = (0, CE_1$8.ce)(action.href != undefined ? 'a' : 'div', 'mux_cards-item-button');
|
|
if (action.href != undefined)
|
|
buttonelem.href = action.href;
|
|
if (action.click != undefined)
|
|
buttonelem.onclick = function (e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
e.stopImmediatePropagation();
|
|
action.click();
|
|
};
|
|
if (action.tooltip != undefined)
|
|
buttonelem.title = action.tooltip;
|
|
buttonelem.appendChild((0, CE_1$8.ce)('span', 'material-symbols-outlined', null, action.materialIcon));
|
|
buttons.appendChild(buttonelem);
|
|
});
|
|
element.appendChild(buttons);
|
|
}
|
|
this.container.appendChild(element);
|
|
};
|
|
ComponentCards.prototype.removeItem = function (uniqueIdentifier) {
|
|
if (this.entries[uniqueIdentifier] != undefined) {
|
|
this.entries[uniqueIdentifier].parentElement.removeChild(this.entries[uniqueIdentifier]);
|
|
delete this.entries[uniqueIdentifier];
|
|
}
|
|
};
|
|
ComponentCards.prototype.hasItem = function (uniqueIdentifier) {
|
|
return this.entries[uniqueIdentifier] != undefined;
|
|
};
|
|
ComponentCards.prototype.clear = function () {
|
|
this.container.innerHTML = '';
|
|
this.entries = {};
|
|
};
|
|
ComponentCards.prototype.updateItemTitle = function (uniqueIdentifier, newTitle) {
|
|
if (this.entries[uniqueIdentifier] == undefined)
|
|
return;
|
|
var existingHeader = this.entries[uniqueIdentifier].querySelector('.mux_header');
|
|
var container = existingHeader.parentElement;
|
|
container.insertBefore(this.highlightText
|
|
? (0, TextHighlighter_1.generateTextHighlights)(newTitle, ['mux_header', 'mux_small'])
|
|
: (0, CE_1$8.ce)('div', ['mux_header', 'mux_small'], null, newTitle), existingHeader);
|
|
container.removeChild(existingHeader);
|
|
};
|
|
ComponentCards.prototype.updateSublines = function (uniqueIdentifier, newSublines) {
|
|
var _this = this;
|
|
if (this.entries[uniqueIdentifier] == undefined)
|
|
return;
|
|
var info = this.entries[uniqueIdentifier].querySelector('.mux_cards-item-info');
|
|
info.querySelectorAll('.mux_text.mux_small').forEach(function (existingSubline) {
|
|
return existingSubline.parentElement.removeChild(existingSubline);
|
|
});
|
|
if (newSublines != undefined && newSublines.length > 0)
|
|
newSublines.forEach(function (subline) {
|
|
info.appendChild(_this.highlightText
|
|
? (0, TextHighlighter_1.generateTextHighlights)(subline, [
|
|
'mux_text',
|
|
'mux_small',
|
|
])
|
|
: (0, CE_1$8.ce)('div', ['mux_text', 'mux_small'], null, subline));
|
|
});
|
|
};
|
|
ComponentCards.prototype.updateThumbnail = function (uniqueIdentifier, thumbnailSrc) {
|
|
if (this.entries[uniqueIdentifier] == undefined)
|
|
return;
|
|
var thumbnail = this.entries[uniqueIdentifier].querySelector('.mux_cards-item-thumbnail');
|
|
thumbnail.src = thumbnailSrc;
|
|
};
|
|
ComponentCards.prototype.getOrder = function () {
|
|
var order = [];
|
|
this.container
|
|
.querySelectorAll('.mux_cards-item')
|
|
.forEach(function (item) { return order.push(item.getAttribute('uid')); });
|
|
return order;
|
|
};
|
|
return ComponentCards;
|
|
}(baseComponent_1$8.MUXComponent));
|
|
Component_Cards.ComponentCards = ComponentCards;
|
|
|
|
var Component_ContextMenu = {};
|
|
|
|
var Morph_Keys = {};
|
|
|
|
var KeyBinderBase$1 = {};
|
|
|
|
var KeyBinderOverwrite$1 = {};
|
|
|
|
var __spreadArray$1 = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
Object.defineProperty(KeyBinderOverwrite$1, "__esModule", { value: true });
|
|
KeyBinderOverwrite$1.KeyBinderOverwrite = void 0;
|
|
var KeyBinderOverwrite = /** @class */ (function () {
|
|
function KeyBinderOverwrite(id, KeyBinder) {
|
|
this.binds = {};
|
|
this.id = id;
|
|
this._KeyBinder = KeyBinder;
|
|
}
|
|
KeyBinderOverwrite.prototype.log = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
if (window.location.search.includes('debug'))
|
|
console.log.apply(console, __spreadArray$1(['[KeyBinder]'], args, false));
|
|
};
|
|
KeyBinderOverwrite.prototype.close = function () {
|
|
this._KeyBinder.closeOverwrite(this.id);
|
|
};
|
|
KeyBinderOverwrite.prototype.bind = function (key, callback, settings) {
|
|
if (settings == undefined)
|
|
settings = {};
|
|
var query = this._KeyBinder.createKeyQuery(key, settings.controlKey, settings.shiftKey, settings.altKey);
|
|
if (this.binds[query] != undefined)
|
|
return this.log("Unable to bind key query '".concat(query, "' in overwrite because it already has a bind"));
|
|
if ((settings === null || settings === void 0 ? void 0 : settings.disableInElementsWithTags) != undefined)
|
|
settings.disableInElementsWithTags =
|
|
settings.disableInElementsWithTags.map(function (tagname) {
|
|
return tagname.toUpperCase();
|
|
});
|
|
this.binds[query] = { callback: callback, settings: settings };
|
|
};
|
|
return KeyBinderOverwrite;
|
|
}());
|
|
KeyBinderOverwrite$1.KeyBinderOverwrite = KeyBinderOverwrite;
|
|
|
|
var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
Object.defineProperty(KeyBinderBase$1, "__esModule", { value: true });
|
|
KeyBinderBase$1.KeyBinderBase = void 0;
|
|
var KeyBinderOverwrite_1 = KeyBinderOverwrite$1;
|
|
var KeyBinderBase = /** @class */ (function () {
|
|
function KeyBinderBase() {
|
|
this.binds = {};
|
|
this.overwrites = [];
|
|
this.log('Preparing KeyBinder');
|
|
this.registerListeners();
|
|
}
|
|
KeyBinderBase.prototype.log = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
if (window.location.search.includes('debug'))
|
|
console.log.apply(console, __spreadArray(['[KeyBinder]'], args, false));
|
|
};
|
|
KeyBinderBase.prototype.multiBind = function (keys, callback, settings) {
|
|
for (var i = 0; i < keys.length; i++)
|
|
this.bind(keys[i], callback, settings);
|
|
};
|
|
KeyBinderBase.prototype.bind = function (key, callback, settings) {
|
|
if (settings == undefined)
|
|
settings = {};
|
|
var query = this.createKeyQuery(key, settings.controlKey, settings.shiftKey, settings.altKey);
|
|
if (this.binds[query] != undefined)
|
|
return this.log("Unable to bind key query '".concat(query, "' because it already has a bind"));
|
|
if ((settings === null || settings === void 0 ? void 0 : settings.disableInElementsWithTags) != undefined)
|
|
settings.disableInElementsWithTags =
|
|
settings.disableInElementsWithTags.map(function (tagname) {
|
|
return tagname.toUpperCase();
|
|
});
|
|
this.binds[query] = { callback: callback, settings: settings };
|
|
};
|
|
KeyBinderBase.prototype.unbind = function (key, settings) {
|
|
if (settings == undefined)
|
|
settings = {};
|
|
var query = this.createKeyQuery(key, settings.controlKey, settings.shiftKey, settings.altKey);
|
|
if (this.binds[query] == undefined)
|
|
return this.log("Unable to unbind key query '".concat(query, "' because it has no bind"));
|
|
};
|
|
KeyBinderBase.prototype.createOverwrite = function () {
|
|
var id = this.generateOverwriteId();
|
|
var overwrite = new KeyBinderOverwrite_1.KeyBinderOverwrite(id, this);
|
|
this.overwrites.push(overwrite);
|
|
this.log("Overwrite with id '".concat(id, "' was created"));
|
|
return overwrite;
|
|
};
|
|
KeyBinderBase.prototype.closeOverwrite = function (id) {
|
|
for (var i = 0; i < this.overwrites.length; i++)
|
|
if (this.overwrites[i].id == id) {
|
|
this.overwrites.splice(i, 1);
|
|
this.log("Overwrite with id '".concat(id, "' was closed"));
|
|
return;
|
|
}
|
|
};
|
|
KeyBinderBase.prototype.createKeyQuery = function (key, ctrlKey, shiftKey, altKey) {
|
|
if (ctrlKey === void 0) { ctrlKey = false; }
|
|
if (shiftKey === void 0) { shiftKey = false; }
|
|
if (altKey === void 0) { altKey = false; }
|
|
var queryParts = [key.toLowerCase()];
|
|
if (ctrlKey)
|
|
queryParts.push('ctrl');
|
|
if (shiftKey)
|
|
queryParts.push('shft');
|
|
if (altKey)
|
|
queryParts.push('alt');
|
|
return queryParts.join(':');
|
|
};
|
|
KeyBinderBase.prototype.getAllBinds = function () {
|
|
return Array.from(new Set(this.overwrites
|
|
.map(function (overwrite) { return Object.keys(overwrite.binds); })
|
|
.concat(Object.keys(this.binds))
|
|
.flat()));
|
|
};
|
|
KeyBinderBase.prototype.generateOverwriteId = function () {
|
|
while (true) {
|
|
var id = (Math.random() + 1).toString(36).substring(7);
|
|
if (!this.overwriteIdExists(id))
|
|
return id;
|
|
}
|
|
};
|
|
KeyBinderBase.prototype.overwriteIdExists = function (id) {
|
|
for (var i = 0; i < this.overwrites.length; i++)
|
|
if (this.overwrites[i].id == id)
|
|
return true;
|
|
return false;
|
|
};
|
|
KeyBinderBase.prototype.registerListeners = function () {
|
|
var _this = this;
|
|
window.addEventListener('keydown', function (e) {
|
|
var _a;
|
|
var query = _this.createKeyQuery(e.key, e.ctrlKey || e.metaKey, e.shiftKey, e.altKey);
|
|
if (window.location.search.includes('keydebug'))
|
|
_this.log("Got keypress: ".concat(query));
|
|
var binds = _this.binds;
|
|
if (_this.overwrites.length > 0) {
|
|
binds = _this.overwrites[_this.overwrites.length - 1].binds;
|
|
}
|
|
if (binds[query] == undefined)
|
|
return;
|
|
var bind = binds[query];
|
|
if (((_a = bind === null || bind === void 0 ? void 0 : bind.settings) === null || _a === void 0 ? void 0 : _a.disableInElementsWithTags) != undefined &&
|
|
bind.settings.disableInElementsWithTags.includes(document.activeElement.tagName))
|
|
return;
|
|
e.preventDefault();
|
|
bind.callback();
|
|
});
|
|
};
|
|
return KeyBinderBase;
|
|
}());
|
|
KeyBinderBase$1.KeyBinderBase = KeyBinderBase;
|
|
|
|
Object.defineProperty(Morph_Keys, "__esModule", { value: true });
|
|
Morph_Keys.MorphKey = void 0;
|
|
var KeyBinderBase_1 = KeyBinderBase$1;
|
|
Morph_Keys.MorphKey = new KeyBinderBase_1.KeyBinderBase();
|
|
|
|
var __extends$7 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_ContextMenu, "__esModule", { value: true });
|
|
Component_ContextMenu.ComponentContextMenu = void 0;
|
|
var Morph_Keys_1 = Morph_Keys;
|
|
var CE_1$7 = CE;
|
|
var baseComponent_1$7 = baseComponent;
|
|
var ComponentContextMenu = /** @class */ (function (_super) {
|
|
__extends$7(ComponentContextMenu, _super);
|
|
function ComponentContextMenu(options) {
|
|
var _a, _b;
|
|
var _this = _super.call(this) || this;
|
|
_this.open = true;
|
|
_this.container = (0, CE_1$7.ce)('div', 'mux_contextmenu');
|
|
var align = (_a = options === null || options === void 0 ? void 0 : options.align) !== null && _a !== void 0 ? _a : 'center';
|
|
if ((options === null || options === void 0 ? void 0 : options.materialIconColor) != undefined)
|
|
_this.container.style.setProperty('--mux-contextmenu-iconcolor', options.materialIconColor);
|
|
_this.setItems((_b = options === null || options === void 0 ? void 0 : options.items) !== null && _b !== void 0 ? _b : [], options === null || options === void 0 ? void 0 : options.selected);
|
|
var parentContainer = document.body;
|
|
parentContainer.appendChild(_this.container);
|
|
_this.container.style.top = "".concat(options.y - parentContainer.getBoundingClientRect().top, "px");
|
|
var left = options.x;
|
|
var maxLeft = document.body.clientWidth - _this.container.clientWidth - 20;
|
|
var minLeft = 10;
|
|
if (align == 'center') {
|
|
left -= _this.container.clientWidth / 2;
|
|
_this.container.style.transformOrigin = 'top center';
|
|
}
|
|
else if (align == 'left') {
|
|
_this.container.style.transformOrigin = 'top left';
|
|
}
|
|
else if (align == 'right') {
|
|
left -= _this.container.clientWidth;
|
|
_this.container.style.transformOrigin = 'top right';
|
|
}
|
|
left = Math.min(left, maxLeft);
|
|
left = Math.max(left, minLeft);
|
|
var maxHeight = document.body.clientHeight - options.y - 20;
|
|
_this.container.style.left = "".concat(left, "px");
|
|
_this.container.style.transitionDuration = '.2s';
|
|
_this.container.style.transform = 'scale(1)';
|
|
_this.container.style.opacity = '1';
|
|
_this.container.style.maxHeight = "".concat(maxHeight, "px");
|
|
if ((options === null || options === void 0 ? void 0 : options.highlightedItem) != undefined &&
|
|
_this.container.querySelector("[uid=\"".concat(options.highlightedItem, "\"]")) != null) {
|
|
var selected = _this.container.querySelector("[uid=\"".concat(options.highlightedItem, "\"]"));
|
|
selected.classList.add('mux_contextmenu-item-selected');
|
|
setTimeout(function () {
|
|
selected.scrollIntoView();
|
|
}, 100);
|
|
}
|
|
if ((options === null || options === void 0 ? void 0 : options.selected) != undefined &&
|
|
_this.container.querySelector("[uid=\"".concat(options.selected, "\"]")) != null) {
|
|
var selected = _this.container.querySelector("[uid=\"".concat(options.selected, "\"]"));
|
|
setTimeout(function () {
|
|
selected.scrollIntoView({
|
|
block: 'center',
|
|
inline: 'center',
|
|
});
|
|
}, 100);
|
|
}
|
|
var delay = function (duration, callback) {
|
|
setTimeout(function () {
|
|
callback();
|
|
}, duration);
|
|
};
|
|
_this.handleClick = function (e) {
|
|
var _a, _b;
|
|
if (e.target == undefined)
|
|
return delay(100, function () { return _this.close('outside'); });
|
|
var target = e.target;
|
|
if (target.classList.length == 0)
|
|
return delay(100, function () { return _this.close('outsideclick'); });
|
|
if (!target.classList[0].startsWith('mux_contextmenu') &&
|
|
!((_b = (_a = target.parentElement) === null || _a === void 0 ? void 0 : _a.classList[0]) === null || _b === void 0 ? void 0 : _b.startsWith('mux_contextmenu')))
|
|
return delay(100, function () { return _this.close('outsideparentclick'); });
|
|
};
|
|
setTimeout(function () {
|
|
window.addEventListener('click', _this.handleClick);
|
|
window.addEventListener('mousedown', _this.handleClick);
|
|
window.addEventListener('touchstart', _this.handleClick);
|
|
}, 100);
|
|
_this.overwrite = Morph_Keys_1.MorphKey.createOverwrite();
|
|
if ((options === null || options === void 0 ? void 0 : options.highlightedItem) == undefined) {
|
|
_this.overwrite.bind('ArrowUp', function () {
|
|
var selected = _this.container.querySelector('.mux_contextmenu-item-selected');
|
|
if (selected == null) {
|
|
var elements = _this.container.querySelectorAll('.mux_contextmenu-item');
|
|
if (elements.length > 0) {
|
|
var first = elements[elements.length - 1];
|
|
first.classList.add('mux_contextmenu-item-selected');
|
|
first.scrollIntoView();
|
|
}
|
|
}
|
|
else {
|
|
var previous = selected.previousElementSibling;
|
|
if (previous != null) {
|
|
selected.classList.remove('mux_contextmenu-item-selected');
|
|
previous.classList.add('mux_contextmenu-item-selected');
|
|
previous.scrollIntoView();
|
|
}
|
|
}
|
|
});
|
|
_this.overwrite.bind('ArrowDown', function () {
|
|
var selected = _this.container.querySelector('.mux_contextmenu-item-selected');
|
|
if (selected == null) {
|
|
var elements = _this.container.querySelectorAll('.mux_contextmenu-item');
|
|
if (elements.length > 0) {
|
|
var first = elements[0];
|
|
first.classList.add('mux_contextmenu-item-selected');
|
|
first.scrollIntoView();
|
|
}
|
|
}
|
|
else {
|
|
var next = selected.nextElementSibling;
|
|
if (next != null) {
|
|
selected.classList.remove('mux_contextmenu-item-selected');
|
|
next.classList.add('mux_contextmenu-item-selected');
|
|
next.scrollIntoView();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
_this.overwrite.bind('Enter', function () {
|
|
var selected = _this.container.querySelector('.mux_contextmenu-item-selected');
|
|
if (selected != null) {
|
|
selected.click();
|
|
}
|
|
});
|
|
_this.overwrite.bind('Escape', function () {
|
|
_this.close('escape');
|
|
});
|
|
return _this;
|
|
}
|
|
ComponentContextMenu.prototype.close = function (origin, byClick) {
|
|
var _this = this;
|
|
if (origin === void 0) { origin = 'integrator?'; }
|
|
if (byClick === void 0) { byClick = false; }
|
|
this.overwrite.close();
|
|
this.open = false;
|
|
this.killSubContexts();
|
|
window.removeEventListener('click', this.handleClick);
|
|
window.removeEventListener('mousedown', this.handleClick);
|
|
window.removeEventListener('touchstart', this.handleClick);
|
|
this.callEvent('close', byClick, origin);
|
|
this.container.style.transform = 'scale(0)';
|
|
this.container.style.opacity = '0';
|
|
setTimeout(function () {
|
|
_this.destroy();
|
|
}, 200);
|
|
};
|
|
ComponentContextMenu.prototype.enable = function (uniqueIdentifier) {
|
|
if (this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"))) {
|
|
var element = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
|
|
element.classList.remove('mux_contextmenu-item-disabled');
|
|
}
|
|
};
|
|
ComponentContextMenu.prototype.disable = function (uniqueIdentifier) {
|
|
if (this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"))) {
|
|
var element = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
|
|
element.classList.add('mux_contextmenu-item-disabled');
|
|
}
|
|
};
|
|
ComponentContextMenu.prototype.isOpen = function () {
|
|
return this.open;
|
|
};
|
|
ComponentContextMenu.prototype.setItems = function (items, selectedId) {
|
|
var _this = this;
|
|
this.container.innerHTML = '';
|
|
items.forEach(function (item) {
|
|
return _this.addItem(item, selectedId != null && selectedId == item.uniqueIdentifier);
|
|
});
|
|
};
|
|
ComponentContextMenu.prototype.addItem = function (item, selected) {
|
|
var _this = this;
|
|
var _a, _b, _c;
|
|
if (selected === void 0) { selected = false; }
|
|
switch (item.type) {
|
|
case 'separator':
|
|
var separator = (0, CE_1$7.ce)('div', 'mux_contextmenu-separator');
|
|
if (item.text != undefined && item.text.trim().length > 0)
|
|
separator.appendChild((0, CE_1$7.ce)('span', null, null, item.text));
|
|
this.container.appendChild(separator);
|
|
break;
|
|
case 'normal':
|
|
var element = (0, CE_1$7.ce)(item.href != undefined ? 'a' : 'div', 'mux_contextmenu-item');
|
|
if (selected)
|
|
element.classList.add('mux_contextmenu-item-selected');
|
|
var itemId = (_a = item.uniqueIdentifier) !== null && _a !== void 0 ? _a : (Math.random() + 1).toString(36).substring(7);
|
|
if (item.href != undefined)
|
|
element.setAttribute('href', item.href);
|
|
if (item.tooltip != undefined)
|
|
element.title = item.tooltip;
|
|
if (item.materialIcon != undefined) {
|
|
var materialIcon = (0, CE_1$7.ce)('span', [
|
|
'mux_contextmenu-item-materialicon',
|
|
'material-symbols-outlined',
|
|
], null, item.materialIcon);
|
|
if (item.materialIconTransform != undefined)
|
|
materialIcon.style.transform =
|
|
item.materialIconTransform;
|
|
element.appendChild(materialIcon);
|
|
}
|
|
else if (item.icon != undefined)
|
|
element.appendChild((0, CE_1$7.ce)('img', 'mux_contextmenu-item-icon', {
|
|
src: item.icon,
|
|
}));
|
|
if (item.uniqueIdentifier != undefined) {
|
|
element.setAttribute('uid', item.uniqueIdentifier);
|
|
}
|
|
if (item.enabled == false)
|
|
element.classList.add('mux_contextmenu-item-disabled');
|
|
var itemContent = (0, CE_1$7.ce)('div', ['mux_text', 'mux_small'], null, (_b = item.text) !== null && _b !== void 0 ? _b : '');
|
|
if (item.customFontSize != undefined)
|
|
itemContent.style.fontSize = "".concat(item.customFontSize, "px");
|
|
element.appendChild(itemContent);
|
|
if (item.children == undefined && item.shortcut != undefined)
|
|
element.appendChild((0, CE_1$7.ce)('div', [
|
|
'mux_contextmenu-shortcut',
|
|
'mux_text',
|
|
'mux_tiny',
|
|
], null, (_c = item.shortcut) !== null && _c !== void 0 ? _c : ''));
|
|
if (item.children != undefined && item.children.length > 0) {
|
|
element.appendChild((0, CE_1$7.ce)('span', [
|
|
'material-symbols-outlined',
|
|
'mux_contextmenu-item-arrow',
|
|
], null, 'keyboard_arrow_right'));
|
|
}
|
|
element.onmousemove = function () {
|
|
if (_this.subContextParent == itemId)
|
|
return;
|
|
_this.killSubContexts();
|
|
if (item.children != undefined &&
|
|
item.children.length > 0) {
|
|
var bounds = element.getBoundingClientRect();
|
|
_this.subContextParent = itemId;
|
|
_this.subContext = new ComponentContextMenu({
|
|
items: item.children,
|
|
x: bounds.x + bounds.width + 1,
|
|
y: bounds.y,
|
|
align: 'left',
|
|
});
|
|
_this.subContext.on('close', function (byClick) {
|
|
if (byClick)
|
|
_this.close('parentkillchildhover', true);
|
|
});
|
|
}
|
|
};
|
|
if (item.click != undefined && item.href == undefined) {
|
|
element.onclick = function () {
|
|
if (item.stayOpenOnClick != true) {
|
|
_this.close('itemclick', true);
|
|
_this.killSubContexts();
|
|
}
|
|
item.click();
|
|
};
|
|
}
|
|
this.container.appendChild(element);
|
|
break;
|
|
}
|
|
};
|
|
ComponentContextMenu.prototype.killSubContexts = function () {
|
|
if (this.subContext != null) {
|
|
this.subContext.close('parentkillchild');
|
|
this.subContext = null;
|
|
}
|
|
this.subContextParent = null;
|
|
};
|
|
return ComponentContextMenu;
|
|
}(baseComponent_1$7.MUXComponent));
|
|
Component_ContextMenu.ComponentContextMenu = ComponentContextMenu;
|
|
|
|
var Component_Dialog = {};
|
|
|
|
var hasRequiredComponent_Dialog;
|
|
|
|
function requireComponent_Dialog () {
|
|
if (hasRequiredComponent_Dialog) return Component_Dialog;
|
|
hasRequiredComponent_Dialog = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Dialog, "__esModule", { value: true });
|
|
Component_Dialog.ComponentDialog = void 0;
|
|
var Index_1 = requireIndex();
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var ComponentDialog = /** @class */ (function (_super) {
|
|
__extends(ComponentDialog, _super);
|
|
function ComponentDialog(options) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h;
|
|
var _this = _super.call(this) || this;
|
|
var width = (_a = options === null || options === void 0 ? void 0 : options.width) !== null && _a !== void 0 ? _a : 'small';
|
|
var height = (_b = options === null || options === void 0 ? void 0 : options.height) !== null && _b !== void 0 ? _b : 'auto';
|
|
_this.container = (0, CE_1.ce)('div', 'mux_dialogcontainer');
|
|
_this.dialog = (0, CE_1.ce)('div', 'mux_dialog');
|
|
_this.dialog.classList.add("mux_w-".concat(width), "mux_h-".concat(height));
|
|
var openDialogs = document.querySelectorAll(".mux_dialog.mux_w-".concat(width, ".mux_h-").concat(height)).length;
|
|
_this.dialog.style.marginLeft = "".concat(openDialogs * 30, "px");
|
|
_this.dialog.style.marginTop = "".concat(openDialogs * 30, "px");
|
|
_this.container.append(_this.dialog);
|
|
var titlebar = (0, CE_1.ce)('div', 'mux_dialog-titlebar');
|
|
titlebar.appendChild((0, CE_1.ce)('div', ['mux_dialog-title', 'mux_header'], null, options.title));
|
|
var titlesettings = (0, CE_1.ce)('div', 'mux_dialog-titlesettings');
|
|
titlebar.appendChild(titlesettings);
|
|
_this.titlebar = titlesettings;
|
|
if ((options === null || options === void 0 ? void 0 : options.closeable) !== false) {
|
|
var close = (0, CE_1.ce)('div', 'mux_dialog-close');
|
|
close.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'close'));
|
|
close.onclick = function () {
|
|
_this.callEvent('close', new CloseEvent(_this));
|
|
};
|
|
titlebar.appendChild(close);
|
|
}
|
|
_this.dialog.appendChild(titlebar);
|
|
_this.content = (0, CE_1.ce)('div', 'mux_dialog-content');
|
|
_this.dialog.appendChild(_this.content);
|
|
var okButtonVisible = (_c = options === null || options === void 0 ? void 0 : options.okButtonVisible) !== null && _c !== void 0 ? _c : true;
|
|
var cancelButtonVisible = (_d = options === null || options === void 0 ? void 0 : options.cancelButtonVisible) !== null && _d !== void 0 ? _d : true;
|
|
if (okButtonVisible || cancelButtonVisible) {
|
|
var actionbar = (0, CE_1.ce)('div', 'mux_dialog-actionbar');
|
|
var buttons = (0, CE_1.ce)('div', 'mux_dialog-buttons');
|
|
if (cancelButtonVisible) {
|
|
var cancelButtonEnabled = (_e = options === null || options === void 0 ? void 0 : options.cancelButtonEnabled) !== null && _e !== void 0 ? _e : true;
|
|
_this.cancelButton = new Index_1.MorphComponent.Button({
|
|
content: (_f = options === null || options === void 0 ? void 0 : options.cancelButtonText) !== null && _f !== void 0 ? _f : 'Cancel',
|
|
mode: cancelButtonEnabled ? 'normal' : 'disabled',
|
|
target: function () {
|
|
_this.callEvent('cancel', new CloseEvent(_this));
|
|
},
|
|
});
|
|
buttons.appendChild(_this.cancelButton.container);
|
|
}
|
|
if (okButtonVisible) {
|
|
var okButtonEnabled = (_g = options === null || options === void 0 ? void 0 : options.okButtonEnabled) !== null && _g !== void 0 ? _g : true;
|
|
_this.okButton = new Index_1.MorphComponent.Button({
|
|
content: (_h = options === null || options === void 0 ? void 0 : options.okButtonText) !== null && _h !== void 0 ? _h : 'OK',
|
|
mode: okButtonEnabled ? 'highlight' : 'disabled',
|
|
target: function () {
|
|
_this.callEvent('ok', new CloseEvent(_this));
|
|
},
|
|
});
|
|
buttons.appendChild(_this.okButton.container);
|
|
}
|
|
actionbar.appendChild(buttons);
|
|
_this.dialog.appendChild(actionbar);
|
|
}
|
|
else
|
|
_this.content.classList.add('mux_dialog-content-nobuttons');
|
|
document.body.appendChild(_this.container);
|
|
setTimeout(function () {
|
|
_this.container.style.opacity = '1';
|
|
_this.dialog.style.opacity = '1';
|
|
_this.dialog.style.transform = 'scale(1)';
|
|
}, 20);
|
|
_this.keyOverwrite = Index_1.MorphKey.createOverwrite();
|
|
_this.keyOverwrite.bind('Escape', function () {
|
|
_this.callEvent('cancel', new CloseEvent(_this));
|
|
});
|
|
_this.keyOverwrite.bind('Enter', function () {
|
|
_this.callEvent('ok', new CloseEvent(_this));
|
|
});
|
|
return _this;
|
|
}
|
|
ComponentDialog.prototype.close = function () {
|
|
var _this = this;
|
|
this.dialog.style.transitionTimingFunction = 'ease-out';
|
|
this.dialog.style.transform = 'scale(0.8)';
|
|
this.dialog.style.opacity = '0';
|
|
this.container.style.opacity = '0';
|
|
this.container.style.pointerEvents = 'none';
|
|
this.keyOverwrite.close();
|
|
setTimeout(function () {
|
|
_this.destroy();
|
|
}, 200);
|
|
};
|
|
ComponentDialog.prototype.setOkButtonMode = function (mode) {
|
|
this.okButton.updateMode(mode);
|
|
};
|
|
ComponentDialog.prototype.setCancelButtonMode = function (mode) {
|
|
this.cancelButton.updateMode(mode);
|
|
};
|
|
return ComponentDialog;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_Dialog.ComponentDialog = ComponentDialog;
|
|
var CloseEvent = /** @class */ (function () {
|
|
function DialogCloseEvent(origin) {
|
|
var _this = this;
|
|
this.origin = origin;
|
|
this.autoCloseInterval = setTimeout(function () {
|
|
_this.close();
|
|
}, 50);
|
|
}
|
|
DialogCloseEvent.prototype.preventClose = function () {
|
|
clearInterval(this.autoCloseInterval);
|
|
};
|
|
DialogCloseEvent.prototype.close = function () {
|
|
clearInterval(this.autoCloseInterval);
|
|
this.origin.close();
|
|
};
|
|
return DialogCloseEvent;
|
|
}());
|
|
|
|
return Component_Dialog;
|
|
}
|
|
|
|
var Component_Group = {};
|
|
|
|
var __extends$6 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Group, "__esModule", { value: true });
|
|
Component_Group.ComponentGroup = void 0;
|
|
var CE_1$6 = CE;
|
|
var baseComponent_1$6 = baseComponent;
|
|
var ComponentGroup = /** @class */ (function (_super) {
|
|
__extends$6(ComponentGroup, _super);
|
|
function ComponentGroup(options) {
|
|
var _a, _b, _c;
|
|
var _this = _super.call(this) || this;
|
|
_this.container = (0, CE_1$6.ce)('div', ['mux_group', 'mux_group-open']);
|
|
var closeable = (_a = options === null || options === void 0 ? void 0 : options.closeable) !== null && _a !== void 0 ? _a : false;
|
|
if ((options === null || options === void 0 ? void 0 : options.open) == false && closeable) {
|
|
_this.container.classList.remove('mux_group-open');
|
|
}
|
|
var header = (0, CE_1$6.ce)('div', 'mux_group-header');
|
|
if ((options === null || options === void 0 ? void 0 : options.materialIcon) != undefined)
|
|
header.appendChild((0, CE_1$6.ce)('span', 'material-symbols-outlined', null, options.materialIcon));
|
|
_this.title = (0, CE_1$6.ce)('div', ['mux_header', 'mux_small'], null, (_b = options === null || options === void 0 ? void 0 : options.title) !== null && _b !== void 0 ? _b : '');
|
|
_this.subTitle = (0, CE_1$6.ce)('div', ['mux_text', 'mux_small'], null, (_c = options === null || options === void 0 ? void 0 : options.subTitle) !== null && _c !== void 0 ? _c : '');
|
|
header.append(_this.title, _this.subTitle);
|
|
if ((options === null || options === void 0 ? void 0 : options.actions) != undefined && options.actions.length > 0) {
|
|
var actions = (0, CE_1$6.ce)('div', 'mux_group-actions');
|
|
options.actions.forEach(function (action) {
|
|
var element = (0, CE_1$6.ce)('div', 'mux_group-iconbutton');
|
|
element.appendChild((0, CE_1$6.ce)('span', 'material-symbols-outlined', null, action.materialIcon));
|
|
element.onclick = function (e) {
|
|
e.stopPropagation();
|
|
action.click();
|
|
};
|
|
actions.appendChild(element);
|
|
});
|
|
header.appendChild(actions);
|
|
}
|
|
if (closeable) {
|
|
var foldIcon = (0, CE_1$6.ce)('span', ['material-symbols-outlined', 'mux_group-fold'], null, 'keyboard_arrow_right');
|
|
header.appendChild(foldIcon);
|
|
header.onclick = function () {
|
|
if (_this.container.classList.contains('mux_group-open'))
|
|
_this.container.classList.remove('mux_group-open');
|
|
else
|
|
_this.container.classList.add('mux_group-open');
|
|
_this.callEvent('openState', _this.container.classList.contains('mux_group-open'));
|
|
};
|
|
}
|
|
_this.container.appendChild(header);
|
|
_this.content = (0, CE_1$6.ce)('div', 'mux_group-content');
|
|
var contentwrapper = (0, CE_1$6.ce)('div', 'mux_group-contentwrapper');
|
|
contentwrapper.appendChild(_this.content);
|
|
_this.container.appendChild(contentwrapper);
|
|
return _this;
|
|
}
|
|
ComponentGroup.prototype.setTitle = function (title) {
|
|
this.title.innerText = title !== null && title !== void 0 ? title : '';
|
|
};
|
|
ComponentGroup.prototype.setSubTitle = function (subTitle) {
|
|
this.subTitle.innerText = subTitle !== null && subTitle !== void 0 ? subTitle : '';
|
|
};
|
|
return ComponentGroup;
|
|
}(baseComponent_1$6.MUXComponent));
|
|
Component_Group.ComponentGroup = ComponentGroup;
|
|
|
|
var Component_Header = {};
|
|
|
|
var __extends$5 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Header, "__esModule", { value: true });
|
|
Component_Header.ComponentHeader = void 0;
|
|
var CE_1$5 = CE;
|
|
var baseComponent_1$5 = baseComponent;
|
|
var ComponentHeader = /** @class */ (function (_super) {
|
|
__extends$5(ComponentHeader, _super);
|
|
function ComponentHeader(options) {
|
|
var _a;
|
|
var _this = _super.call(this) || this;
|
|
var size = (_a = options === null || options === void 0 ? void 0 : options.size) !== null && _a !== void 0 ? _a : 'normal';
|
|
_this.container = (0, CE_1$5.ce)('div', ['mux_header', "mux_".concat(size)], null, options === null || options === void 0 ? void 0 : options.content);
|
|
return _this;
|
|
}
|
|
ComponentHeader.prototype.update = function (content) {
|
|
this.container.innerHTML = content;
|
|
};
|
|
return ComponentHeader;
|
|
}(baseComponent_1$5.MUXComponent));
|
|
Component_Header.ComponentHeader = ComponentHeader;
|
|
|
|
var Component_IconGrid = {};
|
|
|
|
var __extends$4 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_IconGrid, "__esModule", { value: true });
|
|
Component_IconGrid.ComponentIconGrid = void 0;
|
|
var CE_1$4 = CE;
|
|
var baseComponent_1$4 = baseComponent;
|
|
var Sortable = SortableExports;
|
|
var ComponentIconGrid = /** @class */ (function (_super) {
|
|
__extends$4(ComponentIconGrid, _super);
|
|
function ComponentIconGrid(options) {
|
|
var _a;
|
|
var _this = _super.call(this) || this;
|
|
_this.container = (0, CE_1$4.ce)('div', 'mux_icongrid');
|
|
if ((options === null || options === void 0 ? void 0 : options.sortable) === true) {
|
|
_this.sortable = new Sortable(_this.container, {
|
|
ghostClass: 'mux_icongrid-item-dragging',
|
|
onStart: function () {
|
|
_this.container.classList.add('mux_icongrid-dragging');
|
|
},
|
|
onEnd: function (evt) {
|
|
_this.container.classList.remove('mux_icongrid-dragging');
|
|
_this.callEvent('orderUpdated', _this.getOrder());
|
|
},
|
|
});
|
|
}
|
|
_this.setItems((_a = options === null || options === void 0 ? void 0 : options.items) !== null && _a !== void 0 ? _a : []);
|
|
return _this;
|
|
}
|
|
ComponentIconGrid.prototype.setItems = function (items) {
|
|
var _this = this;
|
|
this.container.innerHTML = '';
|
|
items.forEach(function (item) { return _this.addItem(item); });
|
|
};
|
|
ComponentIconGrid.prototype.addItem = function (item) {
|
|
var element = (0, CE_1$4.ce)('div', 'mux_icongrid-item');
|
|
if (item.uniqueIdentifier != undefined)
|
|
element.setAttribute('uid', item.uniqueIdentifier);
|
|
if (!item.enabled)
|
|
element.classList.add('mux_icongrid-item-disabled');
|
|
if (item.click != undefined)
|
|
element.onclick = item.click;
|
|
if (item.materialIcon != undefined)
|
|
element.appendChild((0, CE_1$4.ce)('span', ['mux_icongrid-item-icon', 'material-symbols-outline'], null, item.materialIcon));
|
|
else if (item.icon != undefined)
|
|
element.appendChild((0, CE_1$4.ce)('img', 'mux_icongrid-item-icon', { src: item.icon }));
|
|
element.appendChild((0, CE_1$4.ce)('div', ['mux_text', 'mux_small'], null, item.text));
|
|
this.container.appendChild(element);
|
|
};
|
|
ComponentIconGrid.prototype.getOrder = function () {
|
|
return Array.from(this.container.querySelectorAll('.mux_icongrid-item')).map(function (item) { return item.getAttribute('uid'); });
|
|
};
|
|
ComponentIconGrid.prototype.enable = function (uniqueIdentifier) {
|
|
var item = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
|
|
if (item != undefined)
|
|
item.classList.remove('mux_icongrid-item-disabled');
|
|
};
|
|
ComponentIconGrid.prototype.disable = function (uniqueIdentifier) {
|
|
var item = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
|
|
if (item != undefined)
|
|
item.classList.add('mux_icongrid-item-disabled');
|
|
};
|
|
return ComponentIconGrid;
|
|
}(baseComponent_1$4.MUXComponent));
|
|
Component_IconGrid.ComponentIconGrid = ComponentIconGrid;
|
|
|
|
var Component_ImageViewer = {};
|
|
|
|
/*! Hammer.JS - v2.0.17-rc - 2019-12-16
|
|
* http://naver.github.io/egjs
|
|
*
|
|
* Forked By Naver egjs
|
|
* Copyright (c) hammerjs
|
|
* Licensed under the MIT license */
|
|
function _extends() {
|
|
_extends = Object.assign || function (target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
return _extends.apply(this, arguments);
|
|
}
|
|
|
|
function _inheritsLoose(subClass, superClass) {
|
|
subClass.prototype = Object.create(superClass.prototype);
|
|
subClass.prototype.constructor = subClass;
|
|
subClass.__proto__ = superClass;
|
|
}
|
|
|
|
function _assertThisInitialized(self) {
|
|
if (self === void 0) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* extend object.
|
|
* means that properties in dest will be overwritten by the ones in src.
|
|
* @param {Object} target
|
|
* @param {...Object} objects_to_assign
|
|
* @returns {Object} target
|
|
*/
|
|
var assign;
|
|
|
|
if (typeof Object.assign !== 'function') {
|
|
assign = function assign(target) {
|
|
if (target === undefined || target === null) {
|
|
throw new TypeError('Cannot convert undefined or null to object');
|
|
}
|
|
|
|
var output = Object(target);
|
|
|
|
for (var index = 1; index < arguments.length; index++) {
|
|
var source = arguments[index];
|
|
|
|
if (source !== undefined && source !== null) {
|
|
for (var nextKey in source) {
|
|
if (source.hasOwnProperty(nextKey)) {
|
|
output[nextKey] = source[nextKey];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return output;
|
|
};
|
|
} else {
|
|
assign = Object.assign;
|
|
}
|
|
|
|
var assign$1 = assign;
|
|
|
|
var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
|
|
var TEST_ELEMENT = typeof document === "undefined" ? {
|
|
style: {}
|
|
} : document.createElement('div');
|
|
var TYPE_FUNCTION = 'function';
|
|
var round = Math.round,
|
|
abs = Math.abs;
|
|
var now = Date.now;
|
|
|
|
/**
|
|
* @private
|
|
* get the prefixed property
|
|
* @param {Object} obj
|
|
* @param {String} property
|
|
* @returns {String|Undefined} prefixed
|
|
*/
|
|
|
|
function prefixed(obj, property) {
|
|
var prefix;
|
|
var prop;
|
|
var camelProp = property[0].toUpperCase() + property.slice(1);
|
|
var i = 0;
|
|
|
|
while (i < VENDOR_PREFIXES.length) {
|
|
prefix = VENDOR_PREFIXES[i];
|
|
prop = prefix ? prefix + camelProp : property;
|
|
|
|
if (prop in obj) {
|
|
return prop;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/* eslint-disable no-new-func, no-nested-ternary */
|
|
var win;
|
|
|
|
if (typeof window === "undefined") {
|
|
// window is undefined in node.js
|
|
win = {};
|
|
} else {
|
|
win = window;
|
|
}
|
|
|
|
var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
|
|
var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
|
|
function getTouchActionProps() {
|
|
if (!NATIVE_TOUCH_ACTION) {
|
|
return false;
|
|
}
|
|
|
|
var touchMap = {};
|
|
var cssSupports = win.CSS && win.CSS.supports;
|
|
['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function (val) {
|
|
// If css.supports is not supported but there is native touch-action assume it supports
|
|
// all values. This is the case for IE 10 and 11.
|
|
return touchMap[val] = cssSupports ? win.CSS.supports('touch-action', val) : true;
|
|
});
|
|
return touchMap;
|
|
}
|
|
|
|
var TOUCH_ACTION_COMPUTE = 'compute';
|
|
var TOUCH_ACTION_AUTO = 'auto';
|
|
var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
|
|
|
|
var TOUCH_ACTION_NONE = 'none';
|
|
var TOUCH_ACTION_PAN_X = 'pan-x';
|
|
var TOUCH_ACTION_PAN_Y = 'pan-y';
|
|
var TOUCH_ACTION_MAP = getTouchActionProps();
|
|
|
|
var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
|
|
var SUPPORT_TOUCH = 'ontouchstart' in win;
|
|
var SUPPORT_POINTER_EVENTS = prefixed(win, 'PointerEvent') !== undefined;
|
|
var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
|
|
var INPUT_TYPE_TOUCH = 'touch';
|
|
var INPUT_TYPE_PEN = 'pen';
|
|
var INPUT_TYPE_MOUSE = 'mouse';
|
|
var INPUT_TYPE_KINECT = 'kinect';
|
|
var COMPUTE_INTERVAL = 25;
|
|
var INPUT_START = 1;
|
|
var INPUT_MOVE = 2;
|
|
var INPUT_END = 4;
|
|
var INPUT_CANCEL = 8;
|
|
var DIRECTION_NONE = 1;
|
|
var DIRECTION_LEFT = 2;
|
|
var DIRECTION_RIGHT = 4;
|
|
var DIRECTION_UP = 8;
|
|
var DIRECTION_DOWN = 16;
|
|
var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
|
|
var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
|
|
var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
|
|
var PROPS_XY = ['x', 'y'];
|
|
var PROPS_CLIENT_XY = ['clientX', 'clientY'];
|
|
|
|
/**
|
|
* @private
|
|
* walk objects and arrays
|
|
* @param {Object} obj
|
|
* @param {Function} iterator
|
|
* @param {Object} context
|
|
*/
|
|
function each(obj, iterator, context) {
|
|
var i;
|
|
|
|
if (!obj) {
|
|
return;
|
|
}
|
|
|
|
if (obj.forEach) {
|
|
obj.forEach(iterator, context);
|
|
} else if (obj.length !== undefined) {
|
|
i = 0;
|
|
|
|
while (i < obj.length) {
|
|
iterator.call(context, obj[i], i, obj);
|
|
i++;
|
|
}
|
|
} else {
|
|
for (i in obj) {
|
|
obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* let a boolean value also be a function that must return a boolean
|
|
* this first item in args will be used as the context
|
|
* @param {Boolean|Function} val
|
|
* @param {Array} [args]
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
function boolOrFn(val, args) {
|
|
if (typeof val === TYPE_FUNCTION) {
|
|
return val.apply(args ? args[0] || undefined : undefined, args);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* small indexOf wrapper
|
|
* @param {String} str
|
|
* @param {String} find
|
|
* @returns {Boolean} found
|
|
*/
|
|
function inStr(str, find) {
|
|
return str.indexOf(find) > -1;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* when the touchActions are collected they are not a valid value, so we need to clean things up. *
|
|
* @param {String} actions
|
|
* @returns {*}
|
|
*/
|
|
|
|
function cleanTouchActions(actions) {
|
|
// none
|
|
if (inStr(actions, TOUCH_ACTION_NONE)) {
|
|
return TOUCH_ACTION_NONE;
|
|
}
|
|
|
|
var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
|
|
var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); // if both pan-x and pan-y are set (different recognizers
|
|
// for different directions, e.g. horizontal pan but vertical swipe?)
|
|
// we need none (as otherwise with pan-x pan-y combined none of these
|
|
// recognizers will work, since the browser would handle all panning
|
|
|
|
if (hasPanX && hasPanY) {
|
|
return TOUCH_ACTION_NONE;
|
|
} // pan-x OR pan-y
|
|
|
|
|
|
if (hasPanX || hasPanY) {
|
|
return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
|
|
} // manipulation
|
|
|
|
|
|
if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
|
|
return TOUCH_ACTION_MANIPULATION;
|
|
}
|
|
|
|
return TOUCH_ACTION_AUTO;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* Touch Action
|
|
* sets the touchAction property or uses the js alternative
|
|
* @param {Manager} manager
|
|
* @param {String} value
|
|
* @constructor
|
|
*/
|
|
|
|
var TouchAction =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function TouchAction(manager, value) {
|
|
this.manager = manager;
|
|
this.set(value);
|
|
}
|
|
/**
|
|
* @private
|
|
* set the touchAction value on the element or enable the polyfill
|
|
* @param {String} value
|
|
*/
|
|
|
|
|
|
var _proto = TouchAction.prototype;
|
|
|
|
_proto.set = function set(value) {
|
|
// find out the touch-action by the event handlers
|
|
if (value === TOUCH_ACTION_COMPUTE) {
|
|
value = this.compute();
|
|
}
|
|
|
|
if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
|
|
this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
|
|
}
|
|
|
|
this.actions = value.toLowerCase().trim();
|
|
};
|
|
/**
|
|
* @private
|
|
* just re-set the touchAction value
|
|
*/
|
|
|
|
|
|
_proto.update = function update() {
|
|
this.set(this.manager.options.touchAction);
|
|
};
|
|
/**
|
|
* @private
|
|
* compute the value for the touchAction property based on the recognizer's settings
|
|
* @returns {String} value
|
|
*/
|
|
|
|
|
|
_proto.compute = function compute() {
|
|
var actions = [];
|
|
each(this.manager.recognizers, function (recognizer) {
|
|
if (boolOrFn(recognizer.options.enable, [recognizer])) {
|
|
actions = actions.concat(recognizer.getTouchAction());
|
|
}
|
|
});
|
|
return cleanTouchActions(actions.join(' '));
|
|
};
|
|
/**
|
|
* @private
|
|
* this method is called on each input cycle and provides the preventing of the browser behavior
|
|
* @param {Object} input
|
|
*/
|
|
|
|
|
|
_proto.preventDefaults = function preventDefaults(input) {
|
|
var srcEvent = input.srcEvent;
|
|
var direction = input.offsetDirection; // if the touch action did prevented once this session
|
|
|
|
if (this.manager.session.prevented) {
|
|
srcEvent.preventDefault();
|
|
return;
|
|
}
|
|
|
|
var actions = this.actions;
|
|
var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
|
|
var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
|
|
var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
|
|
|
|
if (hasNone) {
|
|
// do not prevent defaults if this is a tap gesture
|
|
var isTapPointer = input.pointers.length === 1;
|
|
var isTapMovement = input.distance < 2;
|
|
var isTapTouchTime = input.deltaTime < 250;
|
|
|
|
if (isTapPointer && isTapMovement && isTapTouchTime) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (hasPanX && hasPanY) {
|
|
// `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
|
|
return;
|
|
}
|
|
|
|
if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) {
|
|
return this.preventSrc(srcEvent);
|
|
}
|
|
};
|
|
/**
|
|
* @private
|
|
* call preventDefault to prevent the browser's default behavior (scrolling in most cases)
|
|
* @param {Object} srcEvent
|
|
*/
|
|
|
|
|
|
_proto.preventSrc = function preventSrc(srcEvent) {
|
|
this.manager.session.prevented = true;
|
|
srcEvent.preventDefault();
|
|
};
|
|
|
|
return TouchAction;
|
|
}();
|
|
|
|
/**
|
|
* @private
|
|
* find if a node is in the given parent
|
|
* @method hasParent
|
|
* @param {HTMLElement} node
|
|
* @param {HTMLElement} parent
|
|
* @return {Boolean} found
|
|
*/
|
|
function hasParent(node, parent) {
|
|
while (node) {
|
|
if (node === parent) {
|
|
return true;
|
|
}
|
|
|
|
node = node.parentNode;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* get the center of all the pointers
|
|
* @param {Array} pointers
|
|
* @return {Object} center contains `x` and `y` properties
|
|
*/
|
|
|
|
function getCenter(pointers) {
|
|
var pointersLength = pointers.length; // no need to loop when only one touch
|
|
|
|
if (pointersLength === 1) {
|
|
return {
|
|
x: round(pointers[0].clientX),
|
|
y: round(pointers[0].clientY)
|
|
};
|
|
}
|
|
|
|
var x = 0;
|
|
var y = 0;
|
|
var i = 0;
|
|
|
|
while (i < pointersLength) {
|
|
x += pointers[i].clientX;
|
|
y += pointers[i].clientY;
|
|
i++;
|
|
}
|
|
|
|
return {
|
|
x: round(x / pointersLength),
|
|
y: round(y / pointersLength)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* create a simple clone from the input used for storage of firstInput and firstMultiple
|
|
* @param {Object} input
|
|
* @returns {Object} clonedInputData
|
|
*/
|
|
|
|
function simpleCloneInputData(input) {
|
|
// make a simple copy of the pointers because we will get a reference if we don't
|
|
// we only need clientXY for the calculations
|
|
var pointers = [];
|
|
var i = 0;
|
|
|
|
while (i < input.pointers.length) {
|
|
pointers[i] = {
|
|
clientX: round(input.pointers[i].clientX),
|
|
clientY: round(input.pointers[i].clientY)
|
|
};
|
|
i++;
|
|
}
|
|
|
|
return {
|
|
timeStamp: now(),
|
|
pointers: pointers,
|
|
center: getCenter(pointers),
|
|
deltaX: input.deltaX,
|
|
deltaY: input.deltaY
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* calculate the absolute distance between two points
|
|
* @param {Object} p1 {x, y}
|
|
* @param {Object} p2 {x, y}
|
|
* @param {Array} [props] containing x and y keys
|
|
* @return {Number} distance
|
|
*/
|
|
|
|
function getDistance(p1, p2, props) {
|
|
if (!props) {
|
|
props = PROPS_XY;
|
|
}
|
|
|
|
var x = p2[props[0]] - p1[props[0]];
|
|
var y = p2[props[1]] - p1[props[1]];
|
|
return Math.sqrt(x * x + y * y);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* calculate the angle between two coordinates
|
|
* @param {Object} p1
|
|
* @param {Object} p2
|
|
* @param {Array} [props] containing x and y keys
|
|
* @return {Number} angle
|
|
*/
|
|
|
|
function getAngle(p1, p2, props) {
|
|
if (!props) {
|
|
props = PROPS_XY;
|
|
}
|
|
|
|
var x = p2[props[0]] - p1[props[0]];
|
|
var y = p2[props[1]] - p1[props[1]];
|
|
return Math.atan2(y, x) * 180 / Math.PI;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* get the direction between two points
|
|
* @param {Number} x
|
|
* @param {Number} y
|
|
* @return {Number} direction
|
|
*/
|
|
|
|
function getDirection(x, y) {
|
|
if (x === y) {
|
|
return DIRECTION_NONE;
|
|
}
|
|
|
|
if (abs(x) >= abs(y)) {
|
|
return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
|
|
}
|
|
|
|
return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
|
|
}
|
|
|
|
function computeDeltaXY(session, input) {
|
|
var center = input.center; // let { offsetDelta:offset = {}, prevDelta = {}, prevInput = {} } = session;
|
|
// jscs throwing error on defalut destructured values and without defaults tests fail
|
|
|
|
var offset = session.offsetDelta || {};
|
|
var prevDelta = session.prevDelta || {};
|
|
var prevInput = session.prevInput || {};
|
|
|
|
if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
|
|
prevDelta = session.prevDelta = {
|
|
x: prevInput.deltaX || 0,
|
|
y: prevInput.deltaY || 0
|
|
};
|
|
offset = session.offsetDelta = {
|
|
x: center.x,
|
|
y: center.y
|
|
};
|
|
}
|
|
|
|
input.deltaX = prevDelta.x + (center.x - offset.x);
|
|
input.deltaY = prevDelta.y + (center.y - offset.y);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* calculate the velocity between two points. unit is in px per ms.
|
|
* @param {Number} deltaTime
|
|
* @param {Number} x
|
|
* @param {Number} y
|
|
* @return {Object} velocity `x` and `y`
|
|
*/
|
|
function getVelocity(deltaTime, x, y) {
|
|
return {
|
|
x: x / deltaTime || 0,
|
|
y: y / deltaTime || 0
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* calculate the scale factor between two pointersets
|
|
* no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
|
|
* @param {Array} start array of pointers
|
|
* @param {Array} end array of pointers
|
|
* @return {Number} scale
|
|
*/
|
|
|
|
function getScale(start, end) {
|
|
return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* calculate the rotation degrees between two pointersets
|
|
* @param {Array} start array of pointers
|
|
* @param {Array} end array of pointers
|
|
* @return {Number} rotation
|
|
*/
|
|
|
|
function getRotation(start, end) {
|
|
return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* velocity is calculated every x ms
|
|
* @param {Object} session
|
|
* @param {Object} input
|
|
*/
|
|
|
|
function computeIntervalInputData(session, input) {
|
|
var last = session.lastInterval || input;
|
|
var deltaTime = input.timeStamp - last.timeStamp;
|
|
var velocity;
|
|
var velocityX;
|
|
var velocityY;
|
|
var direction;
|
|
|
|
if (input.eventType !== INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
|
|
var deltaX = input.deltaX - last.deltaX;
|
|
var deltaY = input.deltaY - last.deltaY;
|
|
var v = getVelocity(deltaTime, deltaX, deltaY);
|
|
velocityX = v.x;
|
|
velocityY = v.y;
|
|
velocity = abs(v.x) > abs(v.y) ? v.x : v.y;
|
|
direction = getDirection(deltaX, deltaY);
|
|
session.lastInterval = input;
|
|
} else {
|
|
// use latest velocity info if it doesn't overtake a minimum period
|
|
velocity = last.velocity;
|
|
velocityX = last.velocityX;
|
|
velocityY = last.velocityY;
|
|
direction = last.direction;
|
|
}
|
|
|
|
input.velocity = velocity;
|
|
input.velocityX = velocityX;
|
|
input.velocityY = velocityY;
|
|
input.direction = direction;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* extend the data with some usable properties like scale, rotate, velocity etc
|
|
* @param {Object} manager
|
|
* @param {Object} input
|
|
*/
|
|
|
|
function computeInputData(manager, input) {
|
|
var session = manager.session;
|
|
var pointers = input.pointers;
|
|
var pointersLength = pointers.length; // store the first input to calculate the distance and direction
|
|
|
|
if (!session.firstInput) {
|
|
session.firstInput = simpleCloneInputData(input);
|
|
} // to compute scale and rotation we need to store the multiple touches
|
|
|
|
|
|
if (pointersLength > 1 && !session.firstMultiple) {
|
|
session.firstMultiple = simpleCloneInputData(input);
|
|
} else if (pointersLength === 1) {
|
|
session.firstMultiple = false;
|
|
}
|
|
|
|
var firstInput = session.firstInput,
|
|
firstMultiple = session.firstMultiple;
|
|
var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
|
|
var center = input.center = getCenter(pointers);
|
|
input.timeStamp = now();
|
|
input.deltaTime = input.timeStamp - firstInput.timeStamp;
|
|
input.angle = getAngle(offsetCenter, center);
|
|
input.distance = getDistance(offsetCenter, center);
|
|
computeDeltaXY(session, input);
|
|
input.offsetDirection = getDirection(input.deltaX, input.deltaY);
|
|
var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
|
|
input.overallVelocityX = overallVelocity.x;
|
|
input.overallVelocityY = overallVelocity.y;
|
|
input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
|
|
input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
|
|
input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
|
|
input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
|
|
computeIntervalInputData(session, input); // find the correct target
|
|
|
|
var target = manager.element;
|
|
var srcEvent = input.srcEvent;
|
|
var srcEventTarget;
|
|
|
|
if (srcEvent.composedPath) {
|
|
srcEventTarget = srcEvent.composedPath()[0];
|
|
} else if (srcEvent.path) {
|
|
srcEventTarget = srcEvent.path[0];
|
|
} else {
|
|
srcEventTarget = srcEvent.target;
|
|
}
|
|
|
|
if (hasParent(srcEventTarget, target)) {
|
|
target = srcEventTarget;
|
|
}
|
|
|
|
input.target = target;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* handle input events
|
|
* @param {Manager} manager
|
|
* @param {String} eventType
|
|
* @param {Object} input
|
|
*/
|
|
|
|
function inputHandler(manager, eventType, input) {
|
|
var pointersLen = input.pointers.length;
|
|
var changedPointersLen = input.changedPointers.length;
|
|
var isFirst = eventType & INPUT_START && pointersLen - changedPointersLen === 0;
|
|
var isFinal = eventType & (INPUT_END | INPUT_CANCEL) && pointersLen - changedPointersLen === 0;
|
|
input.isFirst = !!isFirst;
|
|
input.isFinal = !!isFinal;
|
|
|
|
if (isFirst) {
|
|
manager.session = {};
|
|
} // source event is the normalized value of the domEvents
|
|
// like 'touchstart, mouseup, pointerdown'
|
|
|
|
|
|
input.eventType = eventType; // compute scale, rotation etc
|
|
|
|
computeInputData(manager, input); // emit secret event
|
|
|
|
manager.emit('hammer.input', input);
|
|
manager.recognize(input);
|
|
manager.session.prevInput = input;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* split string on whitespace
|
|
* @param {String} str
|
|
* @returns {Array} words
|
|
*/
|
|
function splitStr(str) {
|
|
return str.trim().split(/\s+/g);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* addEventListener with multiple events at once
|
|
* @param {EventTarget} target
|
|
* @param {String} types
|
|
* @param {Function} handler
|
|
*/
|
|
|
|
function addEventListeners(target, types, handler) {
|
|
each(splitStr(types), function (type) {
|
|
target.addEventListener(type, handler, false);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* removeEventListener with multiple events at once
|
|
* @param {EventTarget} target
|
|
* @param {String} types
|
|
* @param {Function} handler
|
|
*/
|
|
|
|
function removeEventListeners(target, types, handler) {
|
|
each(splitStr(types), function (type) {
|
|
target.removeEventListener(type, handler, false);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* get the window object of an element
|
|
* @param {HTMLElement} element
|
|
* @returns {DocumentView|Window}
|
|
*/
|
|
function getWindowForElement(element) {
|
|
var doc = element.ownerDocument || element;
|
|
return doc.defaultView || doc.parentWindow || window;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* create new input type manager
|
|
* @param {Manager} manager
|
|
* @param {Function} callback
|
|
* @returns {Input}
|
|
* @constructor
|
|
*/
|
|
|
|
var Input =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function Input(manager, callback) {
|
|
var self = this;
|
|
this.manager = manager;
|
|
this.callback = callback;
|
|
this.element = manager.element;
|
|
this.target = manager.options.inputTarget; // smaller wrapper around the handler, for the scope and the enabled state of the manager,
|
|
// so when disabled the input events are completely bypassed.
|
|
|
|
this.domHandler = function (ev) {
|
|
if (boolOrFn(manager.options.enable, [manager])) {
|
|
self.handler(ev);
|
|
}
|
|
};
|
|
|
|
this.init();
|
|
}
|
|
/**
|
|
* @private
|
|
* should handle the inputEvent data and trigger the callback
|
|
* @virtual
|
|
*/
|
|
|
|
|
|
var _proto = Input.prototype;
|
|
|
|
_proto.handler = function handler() {};
|
|
/**
|
|
* @private
|
|
* bind the events
|
|
*/
|
|
|
|
|
|
_proto.init = function init() {
|
|
this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
|
|
this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
|
|
this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
|
|
};
|
|
/**
|
|
* @private
|
|
* unbind the events
|
|
*/
|
|
|
|
|
|
_proto.destroy = function destroy() {
|
|
this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
|
|
this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
|
|
this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
|
|
};
|
|
|
|
return Input;
|
|
}();
|
|
|
|
/**
|
|
* @private
|
|
* find if a array contains the object using indexOf or a simple polyFill
|
|
* @param {Array} src
|
|
* @param {String} find
|
|
* @param {String} [findByKey]
|
|
* @return {Boolean|Number} false when not found, or the index
|
|
*/
|
|
function inArray(src, find, findByKey) {
|
|
if (src.indexOf && !findByKey) {
|
|
return src.indexOf(find);
|
|
} else {
|
|
var i = 0;
|
|
|
|
while (i < src.length) {
|
|
if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) {
|
|
// do not use === here, test fails
|
|
return i;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
var POINTER_INPUT_MAP = {
|
|
pointerdown: INPUT_START,
|
|
pointermove: INPUT_MOVE,
|
|
pointerup: INPUT_END,
|
|
pointercancel: INPUT_CANCEL,
|
|
pointerout: INPUT_CANCEL
|
|
}; // in IE10 the pointer types is defined as an enum
|
|
|
|
var IE10_POINTER_TYPE_ENUM = {
|
|
2: INPUT_TYPE_TOUCH,
|
|
3: INPUT_TYPE_PEN,
|
|
4: INPUT_TYPE_MOUSE,
|
|
5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
|
|
|
|
};
|
|
var POINTER_ELEMENT_EVENTS = 'pointerdown';
|
|
var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel'; // IE10 has prefixed support, and case-sensitive
|
|
|
|
if (win.MSPointerEvent && !win.PointerEvent) {
|
|
POINTER_ELEMENT_EVENTS = 'MSPointerDown';
|
|
POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
|
|
}
|
|
/**
|
|
* @private
|
|
* Pointer events input
|
|
* @constructor
|
|
* @extends Input
|
|
*/
|
|
|
|
|
|
var PointerEventInput =
|
|
/*#__PURE__*/
|
|
function (_Input) {
|
|
_inheritsLoose(PointerEventInput, _Input);
|
|
|
|
function PointerEventInput() {
|
|
var _this;
|
|
|
|
var proto = PointerEventInput.prototype;
|
|
proto.evEl = POINTER_ELEMENT_EVENTS;
|
|
proto.evWin = POINTER_WINDOW_EVENTS;
|
|
_this = _Input.apply(this, arguments) || this;
|
|
_this.store = _this.manager.session.pointerEvents = [];
|
|
return _this;
|
|
}
|
|
/**
|
|
* @private
|
|
* handle mouse events
|
|
* @param {Object} ev
|
|
*/
|
|
|
|
|
|
var _proto = PointerEventInput.prototype;
|
|
|
|
_proto.handler = function handler(ev) {
|
|
var store = this.store;
|
|
var removePointer = false;
|
|
var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
|
|
var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
|
|
var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
|
|
var isTouch = pointerType === INPUT_TYPE_TOUCH; // get index of the event in the store
|
|
|
|
var storeIndex = inArray(store, ev.pointerId, 'pointerId'); // start and mouse must be down
|
|
|
|
if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
|
|
if (storeIndex < 0) {
|
|
store.push(ev);
|
|
storeIndex = store.length - 1;
|
|
}
|
|
} else if (eventType & (INPUT_END | INPUT_CANCEL)) {
|
|
removePointer = true;
|
|
} // it not found, so the pointer hasn't been down (so it's probably a hover)
|
|
|
|
|
|
if (storeIndex < 0) {
|
|
return;
|
|
} // update the event in the store
|
|
|
|
|
|
store[storeIndex] = ev;
|
|
this.callback(this.manager, eventType, {
|
|
pointers: store,
|
|
changedPointers: [ev],
|
|
pointerType: pointerType,
|
|
srcEvent: ev
|
|
});
|
|
|
|
if (removePointer) {
|
|
// remove from the store
|
|
store.splice(storeIndex, 1);
|
|
}
|
|
};
|
|
|
|
return PointerEventInput;
|
|
}(Input);
|
|
|
|
/**
|
|
* @private
|
|
* convert array-like objects to real arrays
|
|
* @param {Object} obj
|
|
* @returns {Array}
|
|
*/
|
|
function toArray(obj) {
|
|
return Array.prototype.slice.call(obj, 0);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* unique array with objects based on a key (like 'id') or just by the array's value
|
|
* @param {Array} src [{id:1},{id:2},{id:1}]
|
|
* @param {String} [key]
|
|
* @param {Boolean} [sort=False]
|
|
* @returns {Array} [{id:1},{id:2}]
|
|
*/
|
|
|
|
function uniqueArray(src, key, sort) {
|
|
var results = [];
|
|
var values = [];
|
|
var i = 0;
|
|
|
|
while (i < src.length) {
|
|
var val = key ? src[i][key] : src[i];
|
|
|
|
if (inArray(values, val) < 0) {
|
|
results.push(src[i]);
|
|
}
|
|
|
|
values[i] = val;
|
|
i++;
|
|
}
|
|
|
|
if (sort) {
|
|
if (!key) {
|
|
results = results.sort();
|
|
} else {
|
|
results = results.sort(function (a, b) {
|
|
return a[key] > b[key];
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
var TOUCH_INPUT_MAP = {
|
|
touchstart: INPUT_START,
|
|
touchmove: INPUT_MOVE,
|
|
touchend: INPUT_END,
|
|
touchcancel: INPUT_CANCEL
|
|
};
|
|
var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
|
|
/**
|
|
* @private
|
|
* Multi-user touch events input
|
|
* @constructor
|
|
* @extends Input
|
|
*/
|
|
|
|
var TouchInput =
|
|
/*#__PURE__*/
|
|
function (_Input) {
|
|
_inheritsLoose(TouchInput, _Input);
|
|
|
|
function TouchInput() {
|
|
var _this;
|
|
|
|
TouchInput.prototype.evTarget = TOUCH_TARGET_EVENTS;
|
|
_this = _Input.apply(this, arguments) || this;
|
|
_this.targetIds = {}; // this.evTarget = TOUCH_TARGET_EVENTS;
|
|
|
|
return _this;
|
|
}
|
|
|
|
var _proto = TouchInput.prototype;
|
|
|
|
_proto.handler = function handler(ev) {
|
|
var type = TOUCH_INPUT_MAP[ev.type];
|
|
var touches = getTouches.call(this, ev, type);
|
|
|
|
if (!touches) {
|
|
return;
|
|
}
|
|
|
|
this.callback(this.manager, type, {
|
|
pointers: touches[0],
|
|
changedPointers: touches[1],
|
|
pointerType: INPUT_TYPE_TOUCH,
|
|
srcEvent: ev
|
|
});
|
|
};
|
|
|
|
return TouchInput;
|
|
}(Input);
|
|
|
|
function getTouches(ev, type) {
|
|
var allTouches = toArray(ev.touches);
|
|
var targetIds = this.targetIds; // when there is only one touch, the process can be simplified
|
|
|
|
if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
|
|
targetIds[allTouches[0].identifier] = true;
|
|
return [allTouches, allTouches];
|
|
}
|
|
|
|
var i;
|
|
var targetTouches;
|
|
var changedTouches = toArray(ev.changedTouches);
|
|
var changedTargetTouches = [];
|
|
var target = this.target; // get target touches from touches
|
|
|
|
targetTouches = allTouches.filter(function (touch) {
|
|
return hasParent(touch.target, target);
|
|
}); // collect touches
|
|
|
|
if (type === INPUT_START) {
|
|
i = 0;
|
|
|
|
while (i < targetTouches.length) {
|
|
targetIds[targetTouches[i].identifier] = true;
|
|
i++;
|
|
}
|
|
} // filter changed touches to only contain touches that exist in the collected target ids
|
|
|
|
|
|
i = 0;
|
|
|
|
while (i < changedTouches.length) {
|
|
if (targetIds[changedTouches[i].identifier]) {
|
|
changedTargetTouches.push(changedTouches[i]);
|
|
} // cleanup removed touches
|
|
|
|
|
|
if (type & (INPUT_END | INPUT_CANCEL)) {
|
|
delete targetIds[changedTouches[i].identifier];
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
if (!changedTargetTouches.length) {
|
|
return;
|
|
}
|
|
|
|
return [// merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
|
|
uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true), changedTargetTouches];
|
|
}
|
|
|
|
var MOUSE_INPUT_MAP = {
|
|
mousedown: INPUT_START,
|
|
mousemove: INPUT_MOVE,
|
|
mouseup: INPUT_END
|
|
};
|
|
var MOUSE_ELEMENT_EVENTS = 'mousedown';
|
|
var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
|
|
/**
|
|
* @private
|
|
* Mouse events input
|
|
* @constructor
|
|
* @extends Input
|
|
*/
|
|
|
|
var MouseInput =
|
|
/*#__PURE__*/
|
|
function (_Input) {
|
|
_inheritsLoose(MouseInput, _Input);
|
|
|
|
function MouseInput() {
|
|
var _this;
|
|
|
|
var proto = MouseInput.prototype;
|
|
proto.evEl = MOUSE_ELEMENT_EVENTS;
|
|
proto.evWin = MOUSE_WINDOW_EVENTS;
|
|
_this = _Input.apply(this, arguments) || this;
|
|
_this.pressed = false; // mousedown state
|
|
|
|
return _this;
|
|
}
|
|
/**
|
|
* @private
|
|
* handle mouse events
|
|
* @param {Object} ev
|
|
*/
|
|
|
|
|
|
var _proto = MouseInput.prototype;
|
|
|
|
_proto.handler = function handler(ev) {
|
|
var eventType = MOUSE_INPUT_MAP[ev.type]; // on start we want to have the left mouse button down
|
|
|
|
if (eventType & INPUT_START && ev.button === 0) {
|
|
this.pressed = true;
|
|
}
|
|
|
|
if (eventType & INPUT_MOVE && ev.which !== 1) {
|
|
eventType = INPUT_END;
|
|
} // mouse must be down
|
|
|
|
|
|
if (!this.pressed) {
|
|
return;
|
|
}
|
|
|
|
if (eventType & INPUT_END) {
|
|
this.pressed = false;
|
|
}
|
|
|
|
this.callback(this.manager, eventType, {
|
|
pointers: [ev],
|
|
changedPointers: [ev],
|
|
pointerType: INPUT_TYPE_MOUSE,
|
|
srcEvent: ev
|
|
});
|
|
};
|
|
|
|
return MouseInput;
|
|
}(Input);
|
|
|
|
/**
|
|
* @private
|
|
* Combined touch and mouse input
|
|
*
|
|
* Touch has a higher priority then mouse, and while touching no mouse events are allowed.
|
|
* This because touch devices also emit mouse events while doing a touch.
|
|
*
|
|
* @constructor
|
|
* @extends Input
|
|
*/
|
|
|
|
var DEDUP_TIMEOUT = 2500;
|
|
var DEDUP_DISTANCE = 25;
|
|
|
|
function setLastTouch(eventData) {
|
|
var _eventData$changedPoi = eventData.changedPointers,
|
|
touch = _eventData$changedPoi[0];
|
|
|
|
if (touch.identifier === this.primaryTouch) {
|
|
var lastTouch = {
|
|
x: touch.clientX,
|
|
y: touch.clientY
|
|
};
|
|
var lts = this.lastTouches;
|
|
this.lastTouches.push(lastTouch);
|
|
|
|
var removeLastTouch = function removeLastTouch() {
|
|
var i = lts.indexOf(lastTouch);
|
|
|
|
if (i > -1) {
|
|
lts.splice(i, 1);
|
|
}
|
|
};
|
|
|
|
setTimeout(removeLastTouch, DEDUP_TIMEOUT);
|
|
}
|
|
}
|
|
|
|
function recordTouches(eventType, eventData) {
|
|
if (eventType & INPUT_START) {
|
|
this.primaryTouch = eventData.changedPointers[0].identifier;
|
|
setLastTouch.call(this, eventData);
|
|
} else if (eventType & (INPUT_END | INPUT_CANCEL)) {
|
|
setLastTouch.call(this, eventData);
|
|
}
|
|
}
|
|
|
|
function isSyntheticEvent(eventData) {
|
|
var x = eventData.srcEvent.clientX;
|
|
var y = eventData.srcEvent.clientY;
|
|
|
|
for (var i = 0; i < this.lastTouches.length; i++) {
|
|
var t = this.lastTouches[i];
|
|
var dx = Math.abs(x - t.x);
|
|
var dy = Math.abs(y - t.y);
|
|
|
|
if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
var TouchMouseInput =
|
|
/*#__PURE__*/
|
|
function () {
|
|
var TouchMouseInput =
|
|
/*#__PURE__*/
|
|
function (_Input) {
|
|
_inheritsLoose(TouchMouseInput, _Input);
|
|
|
|
function TouchMouseInput(_manager, callback) {
|
|
var _this;
|
|
|
|
_this = _Input.call(this, _manager, callback) || this;
|
|
|
|
_this.handler = function (manager, inputEvent, inputData) {
|
|
var isTouch = inputData.pointerType === INPUT_TYPE_TOUCH;
|
|
var isMouse = inputData.pointerType === INPUT_TYPE_MOUSE;
|
|
|
|
if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
|
|
return;
|
|
} // when we're in a touch event, record touches to de-dupe synthetic mouse event
|
|
|
|
|
|
if (isTouch) {
|
|
recordTouches.call(_assertThisInitialized(_assertThisInitialized(_this)), inputEvent, inputData);
|
|
} else if (isMouse && isSyntheticEvent.call(_assertThisInitialized(_assertThisInitialized(_this)), inputData)) {
|
|
return;
|
|
}
|
|
|
|
_this.callback(manager, inputEvent, inputData);
|
|
};
|
|
|
|
_this.touch = new TouchInput(_this.manager, _this.handler);
|
|
_this.mouse = new MouseInput(_this.manager, _this.handler);
|
|
_this.primaryTouch = null;
|
|
_this.lastTouches = [];
|
|
return _this;
|
|
}
|
|
/**
|
|
* @private
|
|
* handle mouse and touch events
|
|
* @param {Hammer} manager
|
|
* @param {String} inputEvent
|
|
* @param {Object} inputData
|
|
*/
|
|
|
|
|
|
var _proto = TouchMouseInput.prototype;
|
|
|
|
/**
|
|
* @private
|
|
* remove the event listeners
|
|
*/
|
|
_proto.destroy = function destroy() {
|
|
this.touch.destroy();
|
|
this.mouse.destroy();
|
|
};
|
|
|
|
return TouchMouseInput;
|
|
}(Input);
|
|
|
|
return TouchMouseInput;
|
|
}();
|
|
|
|
/**
|
|
* @private
|
|
* create new input type manager
|
|
* called by the Manager constructor
|
|
* @param {Hammer} manager
|
|
* @returns {Input}
|
|
*/
|
|
|
|
function createInputInstance(manager) {
|
|
var Type; // let inputClass = manager.options.inputClass;
|
|
|
|
var inputClass = manager.options.inputClass;
|
|
|
|
if (inputClass) {
|
|
Type = inputClass;
|
|
} else if (SUPPORT_POINTER_EVENTS) {
|
|
Type = PointerEventInput;
|
|
} else if (SUPPORT_ONLY_TOUCH) {
|
|
Type = TouchInput;
|
|
} else if (!SUPPORT_TOUCH) {
|
|
Type = MouseInput;
|
|
} else {
|
|
Type = TouchMouseInput;
|
|
}
|
|
|
|
return new Type(manager, inputHandler);
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* if the argument is an array, we want to execute the fn on each entry
|
|
* if it aint an array we don't want to do a thing.
|
|
* this is used by all the methods that accept a single and array argument.
|
|
* @param {*|Array} arg
|
|
* @param {String} fn
|
|
* @param {Object} [context]
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
function invokeArrayArg(arg, fn, context) {
|
|
if (Array.isArray(arg)) {
|
|
each(arg, context[fn], context);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
var STATE_POSSIBLE = 1;
|
|
var STATE_BEGAN = 2;
|
|
var STATE_CHANGED = 4;
|
|
var STATE_ENDED = 8;
|
|
var STATE_RECOGNIZED = STATE_ENDED;
|
|
var STATE_CANCELLED = 16;
|
|
var STATE_FAILED = 32;
|
|
|
|
/**
|
|
* @private
|
|
* get a unique id
|
|
* @returns {number} uniqueId
|
|
*/
|
|
var _uniqueId = 1;
|
|
function uniqueId() {
|
|
return _uniqueId++;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* get a recognizer by name if it is bound to a manager
|
|
* @param {Recognizer|String} otherRecognizer
|
|
* @param {Recognizer} recognizer
|
|
* @returns {Recognizer}
|
|
*/
|
|
function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
|
|
var manager = recognizer.manager;
|
|
|
|
if (manager) {
|
|
return manager.get(otherRecognizer);
|
|
}
|
|
|
|
return otherRecognizer;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* get a usable string, used as event postfix
|
|
* @param {constant} state
|
|
* @returns {String} state
|
|
*/
|
|
|
|
function stateStr(state) {
|
|
if (state & STATE_CANCELLED) {
|
|
return 'cancel';
|
|
} else if (state & STATE_ENDED) {
|
|
return 'end';
|
|
} else if (state & STATE_CHANGED) {
|
|
return 'move';
|
|
} else if (state & STATE_BEGAN) {
|
|
return 'start';
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* Recognizer flow explained; *
|
|
* All recognizers have the initial state of POSSIBLE when a input session starts.
|
|
* The definition of a input session is from the first input until the last input, with all it's movement in it. *
|
|
* Example session for mouse-input: mousedown -> mousemove -> mouseup
|
|
*
|
|
* On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
|
|
* which determines with state it should be.
|
|
*
|
|
* If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
|
|
* POSSIBLE to give it another change on the next cycle.
|
|
*
|
|
* Possible
|
|
* |
|
|
* +-----+---------------+
|
|
* | |
|
|
* +-----+-----+ |
|
|
* | | |
|
|
* Failed Cancelled |
|
|
* +-------+------+
|
|
* | |
|
|
* Recognized Began
|
|
* |
|
|
* Changed
|
|
* |
|
|
* Ended/Recognized
|
|
*/
|
|
|
|
/**
|
|
* @private
|
|
* Recognizer
|
|
* Every recognizer needs to extend from this class.
|
|
* @constructor
|
|
* @param {Object} options
|
|
*/
|
|
|
|
var Recognizer =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function Recognizer(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
this.options = _extends({
|
|
enable: true
|
|
}, options);
|
|
this.id = uniqueId();
|
|
this.manager = null; // default is enable true
|
|
|
|
this.state = STATE_POSSIBLE;
|
|
this.simultaneous = {};
|
|
this.requireFail = [];
|
|
}
|
|
/**
|
|
* @private
|
|
* set options
|
|
* @param {Object} options
|
|
* @return {Recognizer}
|
|
*/
|
|
|
|
|
|
var _proto = Recognizer.prototype;
|
|
|
|
_proto.set = function set(options) {
|
|
assign$1(this.options, options); // also update the touchAction, in case something changed about the directions/enabled state
|
|
|
|
this.manager && this.manager.touchAction.update();
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* recognize simultaneous with an other recognizer.
|
|
* @param {Recognizer} otherRecognizer
|
|
* @returns {Recognizer} this
|
|
*/
|
|
|
|
|
|
_proto.recognizeWith = function recognizeWith(otherRecognizer) {
|
|
if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
|
|
return this;
|
|
}
|
|
|
|
var simultaneous = this.simultaneous;
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
|
|
|
if (!simultaneous[otherRecognizer.id]) {
|
|
simultaneous[otherRecognizer.id] = otherRecognizer;
|
|
otherRecognizer.recognizeWith(this);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* drop the simultaneous link. it doesnt remove the link on the other recognizer.
|
|
* @param {Recognizer} otherRecognizer
|
|
* @returns {Recognizer} this
|
|
*/
|
|
|
|
|
|
_proto.dropRecognizeWith = function dropRecognizeWith(otherRecognizer) {
|
|
if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
|
|
return this;
|
|
}
|
|
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
|
delete this.simultaneous[otherRecognizer.id];
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* recognizer can only run when an other is failing
|
|
* @param {Recognizer} otherRecognizer
|
|
* @returns {Recognizer} this
|
|
*/
|
|
|
|
|
|
_proto.requireFailure = function requireFailure(otherRecognizer) {
|
|
if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
|
|
return this;
|
|
}
|
|
|
|
var requireFail = this.requireFail;
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
|
|
|
if (inArray(requireFail, otherRecognizer) === -1) {
|
|
requireFail.push(otherRecognizer);
|
|
otherRecognizer.requireFailure(this);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* drop the requireFailure link. it does not remove the link on the other recognizer.
|
|
* @param {Recognizer} otherRecognizer
|
|
* @returns {Recognizer} this
|
|
*/
|
|
|
|
|
|
_proto.dropRequireFailure = function dropRequireFailure(otherRecognizer) {
|
|
if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
|
|
return this;
|
|
}
|
|
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
|
var index = inArray(this.requireFail, otherRecognizer);
|
|
|
|
if (index > -1) {
|
|
this.requireFail.splice(index, 1);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* has require failures boolean
|
|
* @returns {boolean}
|
|
*/
|
|
|
|
|
|
_proto.hasRequireFailures = function hasRequireFailures() {
|
|
return this.requireFail.length > 0;
|
|
};
|
|
/**
|
|
* @private
|
|
* if the recognizer can recognize simultaneous with an other recognizer
|
|
* @param {Recognizer} otherRecognizer
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
|
|
_proto.canRecognizeWith = function canRecognizeWith(otherRecognizer) {
|
|
return !!this.simultaneous[otherRecognizer.id];
|
|
};
|
|
/**
|
|
* @private
|
|
* You should use `tryEmit` instead of `emit` directly to check
|
|
* that all the needed recognizers has failed before emitting.
|
|
* @param {Object} input
|
|
*/
|
|
|
|
|
|
_proto.emit = function emit(input) {
|
|
var self = this;
|
|
var state = this.state;
|
|
|
|
function emit(event) {
|
|
self.manager.emit(event, input);
|
|
} // 'panstart' and 'panmove'
|
|
|
|
|
|
if (state < STATE_ENDED) {
|
|
emit(self.options.event + stateStr(state));
|
|
}
|
|
|
|
emit(self.options.event); // simple 'eventName' events
|
|
|
|
if (input.additionalEvent) {
|
|
// additional event(panleft, panright, pinchin, pinchout...)
|
|
emit(input.additionalEvent);
|
|
} // panend and pancancel
|
|
|
|
|
|
if (state >= STATE_ENDED) {
|
|
emit(self.options.event + stateStr(state));
|
|
}
|
|
};
|
|
/**
|
|
* @private
|
|
* Check that all the require failure recognizers has failed,
|
|
* if true, it emits a gesture event,
|
|
* otherwise, setup the state to FAILED.
|
|
* @param {Object} input
|
|
*/
|
|
|
|
|
|
_proto.tryEmit = function tryEmit(input) {
|
|
if (this.canEmit()) {
|
|
return this.emit(input);
|
|
} // it's failing anyway
|
|
|
|
|
|
this.state = STATE_FAILED;
|
|
};
|
|
/**
|
|
* @private
|
|
* can we emit?
|
|
* @returns {boolean}
|
|
*/
|
|
|
|
|
|
_proto.canEmit = function canEmit() {
|
|
var i = 0;
|
|
|
|
while (i < this.requireFail.length) {
|
|
if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
|
|
return false;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
/**
|
|
* @private
|
|
* update the recognizer
|
|
* @param {Object} inputData
|
|
*/
|
|
|
|
|
|
_proto.recognize = function recognize(inputData) {
|
|
// make a new copy of the inputData
|
|
// so we can change the inputData without messing up the other recognizers
|
|
var inputDataClone = assign$1({}, inputData); // is is enabled and allow recognizing?
|
|
|
|
if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
|
|
this.reset();
|
|
this.state = STATE_FAILED;
|
|
return;
|
|
} // reset when we've reached the end
|
|
|
|
|
|
if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
|
|
this.state = STATE_POSSIBLE;
|
|
}
|
|
|
|
this.state = this.process(inputDataClone); // the recognizer has recognized a gesture
|
|
// so trigger an event
|
|
|
|
if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
|
|
this.tryEmit(inputDataClone);
|
|
}
|
|
};
|
|
/**
|
|
* @private
|
|
* return the state of the recognizer
|
|
* the actual recognizing happens in this method
|
|
* @virtual
|
|
* @param {Object} inputData
|
|
* @returns {constant} STATE
|
|
*/
|
|
|
|
/* jshint ignore:start */
|
|
|
|
|
|
_proto.process = function process(inputData) {};
|
|
/* jshint ignore:end */
|
|
|
|
/**
|
|
* @private
|
|
* return the preferred touch-action
|
|
* @virtual
|
|
* @returns {Array}
|
|
*/
|
|
|
|
|
|
_proto.getTouchAction = function getTouchAction() {};
|
|
/**
|
|
* @private
|
|
* called when the gesture isn't allowed to recognize
|
|
* like when another is being recognized or it is disabled
|
|
* @virtual
|
|
*/
|
|
|
|
|
|
_proto.reset = function reset() {};
|
|
|
|
return Recognizer;
|
|
}();
|
|
|
|
/**
|
|
* @private
|
|
* A tap is recognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
|
|
* between the given interval and position. The delay option can be used to recognize multi-taps without firing
|
|
* a single tap.
|
|
*
|
|
* The eventData from the emitted event contains the property `tapCount`, which contains the amount of
|
|
* multi-taps being recognized.
|
|
* @constructor
|
|
* @extends Recognizer
|
|
*/
|
|
|
|
var TapRecognizer =
|
|
/*#__PURE__*/
|
|
function (_Recognizer) {
|
|
_inheritsLoose(TapRecognizer, _Recognizer);
|
|
|
|
function TapRecognizer(options) {
|
|
var _this;
|
|
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
_this = _Recognizer.call(this, _extends({
|
|
event: 'tap',
|
|
pointers: 1,
|
|
taps: 1,
|
|
interval: 300,
|
|
// max time between the multi-tap taps
|
|
time: 250,
|
|
// max time of the pointer to be down (like finger on the screen)
|
|
threshold: 9,
|
|
// a minimal movement is ok, but keep it low
|
|
posThreshold: 10
|
|
}, options)) || this; // previous time and center,
|
|
// used for tap counting
|
|
|
|
_this.pTime = false;
|
|
_this.pCenter = false;
|
|
_this._timer = null;
|
|
_this._input = null;
|
|
_this.count = 0;
|
|
return _this;
|
|
}
|
|
|
|
var _proto = TapRecognizer.prototype;
|
|
|
|
_proto.getTouchAction = function getTouchAction() {
|
|
return [TOUCH_ACTION_MANIPULATION];
|
|
};
|
|
|
|
_proto.process = function process(input) {
|
|
var _this2 = this;
|
|
|
|
var options = this.options;
|
|
var validPointers = input.pointers.length === options.pointers;
|
|
var validMovement = input.distance < options.threshold;
|
|
var validTouchTime = input.deltaTime < options.time;
|
|
this.reset();
|
|
|
|
if (input.eventType & INPUT_START && this.count === 0) {
|
|
return this.failTimeout();
|
|
} // we only allow little movement
|
|
// and we've reached an end event, so a tap is possible
|
|
|
|
|
|
if (validMovement && validTouchTime && validPointers) {
|
|
if (input.eventType !== INPUT_END) {
|
|
return this.failTimeout();
|
|
}
|
|
|
|
var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
|
|
var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
|
|
this.pTime = input.timeStamp;
|
|
this.pCenter = input.center;
|
|
|
|
if (!validMultiTap || !validInterval) {
|
|
this.count = 1;
|
|
} else {
|
|
this.count += 1;
|
|
}
|
|
|
|
this._input = input; // if tap count matches we have recognized it,
|
|
// else it has began recognizing...
|
|
|
|
var tapCount = this.count % options.taps;
|
|
|
|
if (tapCount === 0) {
|
|
// no failing requirements, immediately trigger the tap event
|
|
// or wait as long as the multitap interval to trigger
|
|
if (!this.hasRequireFailures()) {
|
|
return STATE_RECOGNIZED;
|
|
} else {
|
|
this._timer = setTimeout(function () {
|
|
_this2.state = STATE_RECOGNIZED;
|
|
|
|
_this2.tryEmit();
|
|
}, options.interval);
|
|
return STATE_BEGAN;
|
|
}
|
|
}
|
|
}
|
|
|
|
return STATE_FAILED;
|
|
};
|
|
|
|
_proto.failTimeout = function failTimeout() {
|
|
var _this3 = this;
|
|
|
|
this._timer = setTimeout(function () {
|
|
_this3.state = STATE_FAILED;
|
|
}, this.options.interval);
|
|
return STATE_FAILED;
|
|
};
|
|
|
|
_proto.reset = function reset() {
|
|
clearTimeout(this._timer);
|
|
};
|
|
|
|
_proto.emit = function emit() {
|
|
if (this.state === STATE_RECOGNIZED) {
|
|
this._input.tapCount = this.count;
|
|
this.manager.emit(this.options.event, this._input);
|
|
}
|
|
};
|
|
|
|
return TapRecognizer;
|
|
}(Recognizer);
|
|
|
|
/**
|
|
* @private
|
|
* This recognizer is just used as a base for the simple attribute recognizers.
|
|
* @constructor
|
|
* @extends Recognizer
|
|
*/
|
|
|
|
var AttrRecognizer =
|
|
/*#__PURE__*/
|
|
function (_Recognizer) {
|
|
_inheritsLoose(AttrRecognizer, _Recognizer);
|
|
|
|
function AttrRecognizer(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
return _Recognizer.call(this, _extends({
|
|
pointers: 1
|
|
}, options)) || this;
|
|
}
|
|
/**
|
|
* @private
|
|
* Used to check if it the recognizer receives valid input, like input.distance > 10.
|
|
* @memberof AttrRecognizer
|
|
* @param {Object} input
|
|
* @returns {Boolean} recognized
|
|
*/
|
|
|
|
|
|
var _proto = AttrRecognizer.prototype;
|
|
|
|
_proto.attrTest = function attrTest(input) {
|
|
var optionPointers = this.options.pointers;
|
|
return optionPointers === 0 || input.pointers.length === optionPointers;
|
|
};
|
|
/**
|
|
* @private
|
|
* Process the input and return the state for the recognizer
|
|
* @memberof AttrRecognizer
|
|
* @param {Object} input
|
|
* @returns {*} State
|
|
*/
|
|
|
|
|
|
_proto.process = function process(input) {
|
|
var state = this.state;
|
|
var eventType = input.eventType;
|
|
var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
|
|
var isValid = this.attrTest(input); // on cancel input and we've recognized before, return STATE_CANCELLED
|
|
|
|
if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
|
|
return state | STATE_CANCELLED;
|
|
} else if (isRecognized || isValid) {
|
|
if (eventType & INPUT_END) {
|
|
return state | STATE_ENDED;
|
|
} else if (!(state & STATE_BEGAN)) {
|
|
return STATE_BEGAN;
|
|
}
|
|
|
|
return state | STATE_CHANGED;
|
|
}
|
|
|
|
return STATE_FAILED;
|
|
};
|
|
|
|
return AttrRecognizer;
|
|
}(Recognizer);
|
|
|
|
/**
|
|
* @private
|
|
* direction cons to string
|
|
* @param {constant} direction
|
|
* @returns {String}
|
|
*/
|
|
|
|
function directionStr(direction) {
|
|
if (direction === DIRECTION_DOWN) {
|
|
return 'down';
|
|
} else if (direction === DIRECTION_UP) {
|
|
return 'up';
|
|
} else if (direction === DIRECTION_LEFT) {
|
|
return 'left';
|
|
} else if (direction === DIRECTION_RIGHT) {
|
|
return 'right';
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* Pan
|
|
* Recognized when the pointer is down and moved in the allowed direction.
|
|
* @constructor
|
|
* @extends AttrRecognizer
|
|
*/
|
|
|
|
var PanRecognizer =
|
|
/*#__PURE__*/
|
|
function (_AttrRecognizer) {
|
|
_inheritsLoose(PanRecognizer, _AttrRecognizer);
|
|
|
|
function PanRecognizer(options) {
|
|
var _this;
|
|
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
_this = _AttrRecognizer.call(this, _extends({
|
|
event: 'pan',
|
|
threshold: 10,
|
|
pointers: 1,
|
|
direction: DIRECTION_ALL
|
|
}, options)) || this;
|
|
_this.pX = null;
|
|
_this.pY = null;
|
|
return _this;
|
|
}
|
|
|
|
var _proto = PanRecognizer.prototype;
|
|
|
|
_proto.getTouchAction = function getTouchAction() {
|
|
var direction = this.options.direction;
|
|
var actions = [];
|
|
|
|
if (direction & DIRECTION_HORIZONTAL) {
|
|
actions.push(TOUCH_ACTION_PAN_Y);
|
|
}
|
|
|
|
if (direction & DIRECTION_VERTICAL) {
|
|
actions.push(TOUCH_ACTION_PAN_X);
|
|
}
|
|
|
|
return actions;
|
|
};
|
|
|
|
_proto.directionTest = function directionTest(input) {
|
|
var options = this.options;
|
|
var hasMoved = true;
|
|
var distance = input.distance;
|
|
var direction = input.direction;
|
|
var x = input.deltaX;
|
|
var y = input.deltaY; // lock to axis?
|
|
|
|
if (!(direction & options.direction)) {
|
|
if (options.direction & DIRECTION_HORIZONTAL) {
|
|
direction = x === 0 ? DIRECTION_NONE : x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
|
|
hasMoved = x !== this.pX;
|
|
distance = Math.abs(input.deltaX);
|
|
} else {
|
|
direction = y === 0 ? DIRECTION_NONE : y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
|
|
hasMoved = y !== this.pY;
|
|
distance = Math.abs(input.deltaY);
|
|
}
|
|
}
|
|
|
|
input.direction = direction;
|
|
return hasMoved && distance > options.threshold && direction & options.direction;
|
|
};
|
|
|
|
_proto.attrTest = function attrTest(input) {
|
|
return AttrRecognizer.prototype.attrTest.call(this, input) && ( // replace with a super call
|
|
this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
|
|
};
|
|
|
|
_proto.emit = function emit(input) {
|
|
this.pX = input.deltaX;
|
|
this.pY = input.deltaY;
|
|
var direction = directionStr(input.direction);
|
|
|
|
if (direction) {
|
|
input.additionalEvent = this.options.event + direction;
|
|
}
|
|
|
|
_AttrRecognizer.prototype.emit.call(this, input);
|
|
};
|
|
|
|
return PanRecognizer;
|
|
}(AttrRecognizer);
|
|
|
|
/**
|
|
* @private
|
|
* Swipe
|
|
* Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
|
|
* @constructor
|
|
* @extends AttrRecognizer
|
|
*/
|
|
|
|
var SwipeRecognizer =
|
|
/*#__PURE__*/
|
|
function (_AttrRecognizer) {
|
|
_inheritsLoose(SwipeRecognizer, _AttrRecognizer);
|
|
|
|
function SwipeRecognizer(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
return _AttrRecognizer.call(this, _extends({
|
|
event: 'swipe',
|
|
threshold: 10,
|
|
velocity: 0.3,
|
|
direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
|
|
pointers: 1
|
|
}, options)) || this;
|
|
}
|
|
|
|
var _proto = SwipeRecognizer.prototype;
|
|
|
|
_proto.getTouchAction = function getTouchAction() {
|
|
return PanRecognizer.prototype.getTouchAction.call(this);
|
|
};
|
|
|
|
_proto.attrTest = function attrTest(input) {
|
|
var direction = this.options.direction;
|
|
var velocity;
|
|
|
|
if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
|
|
velocity = input.overallVelocity;
|
|
} else if (direction & DIRECTION_HORIZONTAL) {
|
|
velocity = input.overallVelocityX;
|
|
} else if (direction & DIRECTION_VERTICAL) {
|
|
velocity = input.overallVelocityY;
|
|
}
|
|
|
|
return _AttrRecognizer.prototype.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers === this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
|
|
};
|
|
|
|
_proto.emit = function emit(input) {
|
|
var direction = directionStr(input.offsetDirection);
|
|
|
|
if (direction) {
|
|
this.manager.emit(this.options.event + direction, input);
|
|
}
|
|
|
|
this.manager.emit(this.options.event, input);
|
|
};
|
|
|
|
return SwipeRecognizer;
|
|
}(AttrRecognizer);
|
|
|
|
/**
|
|
* @private
|
|
* Pinch
|
|
* Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
|
|
* @constructor
|
|
* @extends AttrRecognizer
|
|
*/
|
|
|
|
var PinchRecognizer =
|
|
/*#__PURE__*/
|
|
function (_AttrRecognizer) {
|
|
_inheritsLoose(PinchRecognizer, _AttrRecognizer);
|
|
|
|
function PinchRecognizer(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
return _AttrRecognizer.call(this, _extends({
|
|
event: 'pinch',
|
|
threshold: 0,
|
|
pointers: 2
|
|
}, options)) || this;
|
|
}
|
|
|
|
var _proto = PinchRecognizer.prototype;
|
|
|
|
_proto.getTouchAction = function getTouchAction() {
|
|
return [TOUCH_ACTION_NONE];
|
|
};
|
|
|
|
_proto.attrTest = function attrTest(input) {
|
|
return _AttrRecognizer.prototype.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
|
|
};
|
|
|
|
_proto.emit = function emit(input) {
|
|
if (input.scale !== 1) {
|
|
var inOut = input.scale < 1 ? 'in' : 'out';
|
|
input.additionalEvent = this.options.event + inOut;
|
|
}
|
|
|
|
_AttrRecognizer.prototype.emit.call(this, input);
|
|
};
|
|
|
|
return PinchRecognizer;
|
|
}(AttrRecognizer);
|
|
|
|
/**
|
|
* @private
|
|
* Rotate
|
|
* Recognized when two or more pointer are moving in a circular motion.
|
|
* @constructor
|
|
* @extends AttrRecognizer
|
|
*/
|
|
|
|
var RotateRecognizer =
|
|
/*#__PURE__*/
|
|
function (_AttrRecognizer) {
|
|
_inheritsLoose(RotateRecognizer, _AttrRecognizer);
|
|
|
|
function RotateRecognizer(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
return _AttrRecognizer.call(this, _extends({
|
|
event: 'rotate',
|
|
threshold: 0,
|
|
pointers: 2
|
|
}, options)) || this;
|
|
}
|
|
|
|
var _proto = RotateRecognizer.prototype;
|
|
|
|
_proto.getTouchAction = function getTouchAction() {
|
|
return [TOUCH_ACTION_NONE];
|
|
};
|
|
|
|
_proto.attrTest = function attrTest(input) {
|
|
return _AttrRecognizer.prototype.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
|
|
};
|
|
|
|
return RotateRecognizer;
|
|
}(AttrRecognizer);
|
|
|
|
/**
|
|
* @private
|
|
* Press
|
|
* Recognized when the pointer is down for x ms without any movement.
|
|
* @constructor
|
|
* @extends Recognizer
|
|
*/
|
|
|
|
var PressRecognizer =
|
|
/*#__PURE__*/
|
|
function (_Recognizer) {
|
|
_inheritsLoose(PressRecognizer, _Recognizer);
|
|
|
|
function PressRecognizer(options) {
|
|
var _this;
|
|
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
_this = _Recognizer.call(this, _extends({
|
|
event: 'press',
|
|
pointers: 1,
|
|
time: 251,
|
|
// minimal time of the pointer to be pressed
|
|
threshold: 9
|
|
}, options)) || this;
|
|
_this._timer = null;
|
|
_this._input = null;
|
|
return _this;
|
|
}
|
|
|
|
var _proto = PressRecognizer.prototype;
|
|
|
|
_proto.getTouchAction = function getTouchAction() {
|
|
return [TOUCH_ACTION_AUTO];
|
|
};
|
|
|
|
_proto.process = function process(input) {
|
|
var _this2 = this;
|
|
|
|
var options = this.options;
|
|
var validPointers = input.pointers.length === options.pointers;
|
|
var validMovement = input.distance < options.threshold;
|
|
var validTime = input.deltaTime > options.time;
|
|
this._input = input; // we only allow little movement
|
|
// and we've reached an end event, so a tap is possible
|
|
|
|
if (!validMovement || !validPointers || input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime) {
|
|
this.reset();
|
|
} else if (input.eventType & INPUT_START) {
|
|
this.reset();
|
|
this._timer = setTimeout(function () {
|
|
_this2.state = STATE_RECOGNIZED;
|
|
|
|
_this2.tryEmit();
|
|
}, options.time);
|
|
} else if (input.eventType & INPUT_END) {
|
|
return STATE_RECOGNIZED;
|
|
}
|
|
|
|
return STATE_FAILED;
|
|
};
|
|
|
|
_proto.reset = function reset() {
|
|
clearTimeout(this._timer);
|
|
};
|
|
|
|
_proto.emit = function emit(input) {
|
|
if (this.state !== STATE_RECOGNIZED) {
|
|
return;
|
|
}
|
|
|
|
if (input && input.eventType & INPUT_END) {
|
|
this.manager.emit(this.options.event + "up", input);
|
|
} else {
|
|
this._input.timeStamp = now();
|
|
this.manager.emit(this.options.event, this._input);
|
|
}
|
|
};
|
|
|
|
return PressRecognizer;
|
|
}(Recognizer);
|
|
|
|
var defaults = {
|
|
/**
|
|
* @private
|
|
* set if DOM events are being triggered.
|
|
* But this is slower and unused by simple implementations, so disabled by default.
|
|
* @type {Boolean}
|
|
* @default false
|
|
*/
|
|
domEvents: false,
|
|
|
|
/**
|
|
* @private
|
|
* The value for the touchAction property/fallback.
|
|
* When set to `compute` it will magically set the correct value based on the added recognizers.
|
|
* @type {String}
|
|
* @default compute
|
|
*/
|
|
touchAction: TOUCH_ACTION_COMPUTE,
|
|
|
|
/**
|
|
* @private
|
|
* @type {Boolean}
|
|
* @default true
|
|
*/
|
|
enable: true,
|
|
|
|
/**
|
|
* @private
|
|
* EXPERIMENTAL FEATURE -- can be removed/changed
|
|
* Change the parent input target element.
|
|
* If Null, then it is being set the to main element.
|
|
* @type {Null|EventTarget}
|
|
* @default null
|
|
*/
|
|
inputTarget: null,
|
|
|
|
/**
|
|
* @private
|
|
* force an input class
|
|
* @type {Null|Function}
|
|
* @default null
|
|
*/
|
|
inputClass: null,
|
|
|
|
/**
|
|
* @private
|
|
* Some CSS properties can be used to improve the working of Hammer.
|
|
* Add them to this method and they will be set when creating a new Manager.
|
|
* @namespace
|
|
*/
|
|
cssProps: {
|
|
/**
|
|
* @private
|
|
* Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
|
|
* @type {String}
|
|
* @default 'none'
|
|
*/
|
|
userSelect: "none",
|
|
|
|
/**
|
|
* @private
|
|
* Disable the Windows Phone grippers when pressing an element.
|
|
* @type {String}
|
|
* @default 'none'
|
|
*/
|
|
touchSelect: "none",
|
|
|
|
/**
|
|
* @private
|
|
* Disables the default callout shown when you touch and hold a touch target.
|
|
* On iOS, when you touch and hold a touch target such as a link, Safari displays
|
|
* a callout containing information about the link. This property allows you to disable that callout.
|
|
* @type {String}
|
|
* @default 'none'
|
|
*/
|
|
touchCallout: "none",
|
|
|
|
/**
|
|
* @private
|
|
* Specifies whether zooming is enabled. Used by IE10>
|
|
* @type {String}
|
|
* @default 'none'
|
|
*/
|
|
contentZooming: "none",
|
|
|
|
/**
|
|
* @private
|
|
* Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
|
|
* @type {String}
|
|
* @default 'none'
|
|
*/
|
|
userDrag: "none",
|
|
|
|
/**
|
|
* @private
|
|
* Overrides the highlight color shown when the user taps a link or a JavaScript
|
|
* clickable element in iOS. This property obeys the alpha value, if specified.
|
|
* @type {String}
|
|
* @default 'rgba(0,0,0,0)'
|
|
*/
|
|
tapHighlightColor: "rgba(0,0,0,0)"
|
|
}
|
|
};
|
|
/**
|
|
* @private
|
|
* Default recognizer setup when calling `Hammer()`
|
|
* When creating a new Manager these will be skipped.
|
|
* This is separated with other defaults because of tree-shaking.
|
|
* @type {Array}
|
|
*/
|
|
|
|
var preset = [[RotateRecognizer, {
|
|
enable: false
|
|
}], [PinchRecognizer, {
|
|
enable: false
|
|
}, ['rotate']], [SwipeRecognizer, {
|
|
direction: DIRECTION_HORIZONTAL
|
|
}], [PanRecognizer, {
|
|
direction: DIRECTION_HORIZONTAL
|
|
}, ['swipe']], [TapRecognizer], [TapRecognizer, {
|
|
event: 'doubletap',
|
|
taps: 2
|
|
}, ['tap']], [PressRecognizer]];
|
|
|
|
var STOP = 1;
|
|
var FORCED_STOP = 2;
|
|
/**
|
|
* @private
|
|
* add/remove the css properties as defined in manager.options.cssProps
|
|
* @param {Manager} manager
|
|
* @param {Boolean} add
|
|
*/
|
|
|
|
function toggleCssProps(manager, add) {
|
|
var element = manager.element;
|
|
|
|
if (!element.style) {
|
|
return;
|
|
}
|
|
|
|
var prop;
|
|
each(manager.options.cssProps, function (value, name) {
|
|
prop = prefixed(element.style, name);
|
|
|
|
if (add) {
|
|
manager.oldCssProps[prop] = element.style[prop];
|
|
element.style[prop] = value;
|
|
} else {
|
|
element.style[prop] = manager.oldCssProps[prop] || "";
|
|
}
|
|
});
|
|
|
|
if (!add) {
|
|
manager.oldCssProps = {};
|
|
}
|
|
}
|
|
/**
|
|
* @private
|
|
* trigger dom event
|
|
* @param {String} event
|
|
* @param {Object} data
|
|
*/
|
|
|
|
|
|
function triggerDomEvent(event, data) {
|
|
var gestureEvent = document.createEvent("Event");
|
|
gestureEvent.initEvent(event, true, true);
|
|
gestureEvent.gesture = data;
|
|
data.target.dispatchEvent(gestureEvent);
|
|
}
|
|
/**
|
|
* @private
|
|
* Manager
|
|
* @param {HTMLElement} element
|
|
* @param {Object} [options]
|
|
* @constructor
|
|
*/
|
|
|
|
|
|
var Manager =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function Manager(element, options) {
|
|
var _this = this;
|
|
|
|
this.options = assign$1({}, defaults, options || {});
|
|
this.options.inputTarget = this.options.inputTarget || element;
|
|
this.handlers = {};
|
|
this.session = {};
|
|
this.recognizers = [];
|
|
this.oldCssProps = {};
|
|
this.element = element;
|
|
this.input = createInputInstance(this);
|
|
this.touchAction = new TouchAction(this, this.options.touchAction);
|
|
toggleCssProps(this, true);
|
|
each(this.options.recognizers, function (item) {
|
|
var recognizer = _this.add(new item[0](item[1]));
|
|
|
|
item[2] && recognizer.recognizeWith(item[2]);
|
|
item[3] && recognizer.requireFailure(item[3]);
|
|
}, this);
|
|
}
|
|
/**
|
|
* @private
|
|
* set options
|
|
* @param {Object} options
|
|
* @returns {Manager}
|
|
*/
|
|
|
|
|
|
var _proto = Manager.prototype;
|
|
|
|
_proto.set = function set(options) {
|
|
assign$1(this.options, options); // Options that need a little more setup
|
|
|
|
if (options.touchAction) {
|
|
this.touchAction.update();
|
|
}
|
|
|
|
if (options.inputTarget) {
|
|
// Clean up existing event listeners and reinitialize
|
|
this.input.destroy();
|
|
this.input.target = options.inputTarget;
|
|
this.input.init();
|
|
}
|
|
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* stop recognizing for this session.
|
|
* This session will be discarded, when a new [input]start event is fired.
|
|
* When forced, the recognizer cycle is stopped immediately.
|
|
* @param {Boolean} [force]
|
|
*/
|
|
|
|
|
|
_proto.stop = function stop(force) {
|
|
this.session.stopped = force ? FORCED_STOP : STOP;
|
|
};
|
|
/**
|
|
* @private
|
|
* run the recognizers!
|
|
* called by the inputHandler function on every movement of the pointers (touches)
|
|
* it walks through all the recognizers and tries to detect the gesture that is being made
|
|
* @param {Object} inputData
|
|
*/
|
|
|
|
|
|
_proto.recognize = function recognize(inputData) {
|
|
var session = this.session;
|
|
|
|
if (session.stopped) {
|
|
return;
|
|
} // run the touch-action polyfill
|
|
|
|
|
|
this.touchAction.preventDefaults(inputData);
|
|
var recognizer;
|
|
var recognizers = this.recognizers; // this holds the recognizer that is being recognized.
|
|
// so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
|
|
// if no recognizer is detecting a thing, it is set to `null`
|
|
|
|
var curRecognizer = session.curRecognizer; // reset when the last recognizer is recognized
|
|
// or when we're in a new session
|
|
|
|
if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) {
|
|
session.curRecognizer = null;
|
|
curRecognizer = null;
|
|
}
|
|
|
|
var i = 0;
|
|
|
|
while (i < recognizers.length) {
|
|
recognizer = recognizers[i]; // find out if we are allowed try to recognize the input for this one.
|
|
// 1. allow if the session is NOT forced stopped (see the .stop() method)
|
|
// 2. allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
|
|
// that is being recognized.
|
|
// 3. allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
|
|
// this can be setup with the `recognizeWith()` method on the recognizer.
|
|
|
|
if (session.stopped !== FORCED_STOP && ( // 1
|
|
!curRecognizer || recognizer === curRecognizer || // 2
|
|
recognizer.canRecognizeWith(curRecognizer))) {
|
|
// 3
|
|
recognizer.recognize(inputData);
|
|
} else {
|
|
recognizer.reset();
|
|
} // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
|
|
// current active recognizer. but only if we don't already have an active recognizer
|
|
|
|
|
|
if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
|
|
session.curRecognizer = recognizer;
|
|
curRecognizer = recognizer;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
};
|
|
/**
|
|
* @private
|
|
* get a recognizer by its event name.
|
|
* @param {Recognizer|String} recognizer
|
|
* @returns {Recognizer|Null}
|
|
*/
|
|
|
|
|
|
_proto.get = function get(recognizer) {
|
|
if (recognizer instanceof Recognizer) {
|
|
return recognizer;
|
|
}
|
|
|
|
var recognizers = this.recognizers;
|
|
|
|
for (var i = 0; i < recognizers.length; i++) {
|
|
if (recognizers[i].options.event === recognizer) {
|
|
return recognizers[i];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
/**
|
|
* @private add a recognizer to the manager
|
|
* existing recognizers with the same event name will be removed
|
|
* @param {Recognizer} recognizer
|
|
* @returns {Recognizer|Manager}
|
|
*/
|
|
|
|
|
|
_proto.add = function add(recognizer) {
|
|
if (invokeArrayArg(recognizer, "add", this)) {
|
|
return this;
|
|
} // remove existing
|
|
|
|
|
|
var existing = this.get(recognizer.options.event);
|
|
|
|
if (existing) {
|
|
this.remove(existing);
|
|
}
|
|
|
|
this.recognizers.push(recognizer);
|
|
recognizer.manager = this;
|
|
this.touchAction.update();
|
|
return recognizer;
|
|
};
|
|
/**
|
|
* @private
|
|
* remove a recognizer by name or instance
|
|
* @param {Recognizer|String} recognizer
|
|
* @returns {Manager}
|
|
*/
|
|
|
|
|
|
_proto.remove = function remove(recognizer) {
|
|
if (invokeArrayArg(recognizer, "remove", this)) {
|
|
return this;
|
|
}
|
|
|
|
var targetRecognizer = this.get(recognizer); // let's make sure this recognizer exists
|
|
|
|
if (recognizer) {
|
|
var recognizers = this.recognizers;
|
|
var index = inArray(recognizers, targetRecognizer);
|
|
|
|
if (index !== -1) {
|
|
recognizers.splice(index, 1);
|
|
this.touchAction.update();
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
/**
|
|
* @private
|
|
* bind event
|
|
* @param {String} events
|
|
* @param {Function} handler
|
|
* @returns {EventEmitter} this
|
|
*/
|
|
|
|
|
|
_proto.on = function on(events, handler) {
|
|
if (events === undefined || handler === undefined) {
|
|
return this;
|
|
}
|
|
|
|
var handlers = this.handlers;
|
|
each(splitStr(events), function (event) {
|
|
handlers[event] = handlers[event] || [];
|
|
handlers[event].push(handler);
|
|
});
|
|
return this;
|
|
};
|
|
/**
|
|
* @private unbind event, leave emit blank to remove all handlers
|
|
* @param {String} events
|
|
* @param {Function} [handler]
|
|
* @returns {EventEmitter} this
|
|
*/
|
|
|
|
|
|
_proto.off = function off(events, handler) {
|
|
if (events === undefined) {
|
|
return this;
|
|
}
|
|
|
|
var handlers = this.handlers;
|
|
each(splitStr(events), function (event) {
|
|
if (!handler) {
|
|
delete handlers[event];
|
|
} else {
|
|
handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
|
|
}
|
|
});
|
|
return this;
|
|
};
|
|
/**
|
|
* @private emit event to the listeners
|
|
* @param {String} event
|
|
* @param {Object} data
|
|
*/
|
|
|
|
|
|
_proto.emit = function emit(event, data) {
|
|
// we also want to trigger dom events
|
|
if (this.options.domEvents) {
|
|
triggerDomEvent(event, data);
|
|
} // no handlers, so skip it all
|
|
|
|
|
|
var handlers = this.handlers[event] && this.handlers[event].slice();
|
|
|
|
if (!handlers || !handlers.length) {
|
|
return;
|
|
}
|
|
|
|
data.type = event;
|
|
|
|
data.preventDefault = function () {
|
|
data.srcEvent.preventDefault();
|
|
};
|
|
|
|
var i = 0;
|
|
|
|
while (i < handlers.length) {
|
|
handlers[i](data);
|
|
i++;
|
|
}
|
|
};
|
|
/**
|
|
* @private
|
|
* destroy the manager and unbinds all events
|
|
* it doesn't unbind dom events, that is the user own responsibility
|
|
*/
|
|
|
|
|
|
_proto.destroy = function destroy() {
|
|
this.element && toggleCssProps(this, false);
|
|
this.handlers = {};
|
|
this.session = {};
|
|
this.input.destroy();
|
|
this.element = null;
|
|
};
|
|
|
|
return Manager;
|
|
}();
|
|
|
|
var SINGLE_TOUCH_INPUT_MAP = {
|
|
touchstart: INPUT_START,
|
|
touchmove: INPUT_MOVE,
|
|
touchend: INPUT_END,
|
|
touchcancel: INPUT_CANCEL
|
|
};
|
|
var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
|
|
var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
|
|
/**
|
|
* @private
|
|
* Touch events input
|
|
* @constructor
|
|
* @extends Input
|
|
*/
|
|
|
|
var SingleTouchInput =
|
|
/*#__PURE__*/
|
|
function (_Input) {
|
|
_inheritsLoose(SingleTouchInput, _Input);
|
|
|
|
function SingleTouchInput() {
|
|
var _this;
|
|
|
|
var proto = SingleTouchInput.prototype;
|
|
proto.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
|
|
proto.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
|
|
_this = _Input.apply(this, arguments) || this;
|
|
_this.started = false;
|
|
return _this;
|
|
}
|
|
|
|
var _proto = SingleTouchInput.prototype;
|
|
|
|
_proto.handler = function handler(ev) {
|
|
var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; // should we handle the touch events?
|
|
|
|
if (type === INPUT_START) {
|
|
this.started = true;
|
|
}
|
|
|
|
if (!this.started) {
|
|
return;
|
|
}
|
|
|
|
var touches = normalizeSingleTouches.call(this, ev, type); // when done, reset the started state
|
|
|
|
if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
|
|
this.started = false;
|
|
}
|
|
|
|
this.callback(this.manager, type, {
|
|
pointers: touches[0],
|
|
changedPointers: touches[1],
|
|
pointerType: INPUT_TYPE_TOUCH,
|
|
srcEvent: ev
|
|
});
|
|
};
|
|
|
|
return SingleTouchInput;
|
|
}(Input);
|
|
|
|
function normalizeSingleTouches(ev, type) {
|
|
var all = toArray(ev.touches);
|
|
var changed = toArray(ev.changedTouches);
|
|
|
|
if (type & (INPUT_END | INPUT_CANCEL)) {
|
|
all = uniqueArray(all.concat(changed), 'identifier', true);
|
|
}
|
|
|
|
return [all, changed];
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* wrap a method with a deprecation warning and stack trace
|
|
* @param {Function} method
|
|
* @param {String} name
|
|
* @param {String} message
|
|
* @returns {Function} A new function wrapping the supplied method.
|
|
*/
|
|
function deprecate(method, name, message) {
|
|
var deprecationMessage = "DEPRECATED METHOD: " + name + "\n" + message + " AT \n";
|
|
return function () {
|
|
var e = new Error('get-stack-trace');
|
|
var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '').replace(/^\s+at\s+/gm, '').replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
|
|
var log = window.console && (window.console.warn || window.console.log);
|
|
|
|
if (log) {
|
|
log.call(window.console, deprecationMessage, stack);
|
|
}
|
|
|
|
return method.apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* extend object.
|
|
* means that properties in dest will be overwritten by the ones in src.
|
|
* @param {Object} dest
|
|
* @param {Object} src
|
|
* @param {Boolean} [merge=false]
|
|
* @returns {Object} dest
|
|
*/
|
|
|
|
var extend = deprecate(function (dest, src, merge) {
|
|
var keys = Object.keys(src);
|
|
var i = 0;
|
|
|
|
while (i < keys.length) {
|
|
if (!merge || merge && dest[keys[i]] === undefined) {
|
|
dest[keys[i]] = src[keys[i]];
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return dest;
|
|
}, 'extend', 'Use `assign`.');
|
|
|
|
/**
|
|
* @private
|
|
* merge the values from src in the dest.
|
|
* means that properties that exist in dest will not be overwritten by src
|
|
* @param {Object} dest
|
|
* @param {Object} src
|
|
* @returns {Object} dest
|
|
*/
|
|
|
|
var merge = deprecate(function (dest, src) {
|
|
return extend(dest, src, true);
|
|
}, 'merge', 'Use `assign`.');
|
|
|
|
/**
|
|
* @private
|
|
* simple class inheritance
|
|
* @param {Function} child
|
|
* @param {Function} base
|
|
* @param {Object} [properties]
|
|
*/
|
|
|
|
function inherit(child, base, properties) {
|
|
var baseP = base.prototype;
|
|
var childP;
|
|
childP = child.prototype = Object.create(baseP);
|
|
childP.constructor = child;
|
|
childP._super = baseP;
|
|
|
|
if (properties) {
|
|
assign$1(childP, properties);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* simple function bind
|
|
* @param {Function} fn
|
|
* @param {Object} context
|
|
* @returns {Function}
|
|
*/
|
|
function bindFn(fn, context) {
|
|
return function boundFn() {
|
|
return fn.apply(context, arguments);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* Simple way to create a manager with a default set of recognizers.
|
|
* @param {HTMLElement} element
|
|
* @param {Object} [options]
|
|
* @constructor
|
|
*/
|
|
|
|
var Hammer =
|
|
/*#__PURE__*/
|
|
function () {
|
|
var Hammer =
|
|
/**
|
|
* @private
|
|
* @const {string}
|
|
*/
|
|
function Hammer(element, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
return new Manager(element, _extends({
|
|
recognizers: preset.concat()
|
|
}, options));
|
|
};
|
|
|
|
Hammer.VERSION = "2.0.17-rc";
|
|
Hammer.DIRECTION_ALL = DIRECTION_ALL;
|
|
Hammer.DIRECTION_DOWN = DIRECTION_DOWN;
|
|
Hammer.DIRECTION_LEFT = DIRECTION_LEFT;
|
|
Hammer.DIRECTION_RIGHT = DIRECTION_RIGHT;
|
|
Hammer.DIRECTION_UP = DIRECTION_UP;
|
|
Hammer.DIRECTION_HORIZONTAL = DIRECTION_HORIZONTAL;
|
|
Hammer.DIRECTION_VERTICAL = DIRECTION_VERTICAL;
|
|
Hammer.DIRECTION_NONE = DIRECTION_NONE;
|
|
Hammer.DIRECTION_DOWN = DIRECTION_DOWN;
|
|
Hammer.INPUT_START = INPUT_START;
|
|
Hammer.INPUT_MOVE = INPUT_MOVE;
|
|
Hammer.INPUT_END = INPUT_END;
|
|
Hammer.INPUT_CANCEL = INPUT_CANCEL;
|
|
Hammer.STATE_POSSIBLE = STATE_POSSIBLE;
|
|
Hammer.STATE_BEGAN = STATE_BEGAN;
|
|
Hammer.STATE_CHANGED = STATE_CHANGED;
|
|
Hammer.STATE_ENDED = STATE_ENDED;
|
|
Hammer.STATE_RECOGNIZED = STATE_RECOGNIZED;
|
|
Hammer.STATE_CANCELLED = STATE_CANCELLED;
|
|
Hammer.STATE_FAILED = STATE_FAILED;
|
|
Hammer.Manager = Manager;
|
|
Hammer.Input = Input;
|
|
Hammer.TouchAction = TouchAction;
|
|
Hammer.TouchInput = TouchInput;
|
|
Hammer.MouseInput = MouseInput;
|
|
Hammer.PointerEventInput = PointerEventInput;
|
|
Hammer.TouchMouseInput = TouchMouseInput;
|
|
Hammer.SingleTouchInput = SingleTouchInput;
|
|
Hammer.Recognizer = Recognizer;
|
|
Hammer.AttrRecognizer = AttrRecognizer;
|
|
Hammer.Tap = TapRecognizer;
|
|
Hammer.Pan = PanRecognizer;
|
|
Hammer.Swipe = SwipeRecognizer;
|
|
Hammer.Pinch = PinchRecognizer;
|
|
Hammer.Rotate = RotateRecognizer;
|
|
Hammer.Press = PressRecognizer;
|
|
Hammer.on = addEventListeners;
|
|
Hammer.off = removeEventListeners;
|
|
Hammer.each = each;
|
|
Hammer.merge = merge;
|
|
Hammer.extend = extend;
|
|
Hammer.bindFn = bindFn;
|
|
Hammer.assign = assign$1;
|
|
Hammer.inherit = inherit;
|
|
Hammer.bindFn = bindFn;
|
|
Hammer.prefixed = prefixed;
|
|
Hammer.toArray = toArray;
|
|
Hammer.inArray = inArray;
|
|
Hammer.uniqueArray = uniqueArray;
|
|
Hammer.splitStr = splitStr;
|
|
Hammer.boolOrFn = boolOrFn;
|
|
Hammer.hasParent = hasParent;
|
|
Hammer.addEventListeners = addEventListeners;
|
|
Hammer.removeEventListeners = removeEventListeners;
|
|
Hammer.defaults = assign$1({}, defaults, {
|
|
preset: preset
|
|
});
|
|
return Hammer;
|
|
}();
|
|
|
|
// style loader but by script tag, not by the loader.
|
|
|
|
var defaults$1 = Hammer.defaults;
|
|
|
|
var hammer_esm = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
'default': Hammer,
|
|
INPUT_START: INPUT_START,
|
|
INPUT_MOVE: INPUT_MOVE,
|
|
INPUT_END: INPUT_END,
|
|
INPUT_CANCEL: INPUT_CANCEL,
|
|
STATE_POSSIBLE: STATE_POSSIBLE,
|
|
STATE_BEGAN: STATE_BEGAN,
|
|
STATE_CHANGED: STATE_CHANGED,
|
|
STATE_ENDED: STATE_ENDED,
|
|
STATE_RECOGNIZED: STATE_RECOGNIZED,
|
|
STATE_CANCELLED: STATE_CANCELLED,
|
|
STATE_FAILED: STATE_FAILED,
|
|
DIRECTION_NONE: DIRECTION_NONE,
|
|
DIRECTION_LEFT: DIRECTION_LEFT,
|
|
DIRECTION_RIGHT: DIRECTION_RIGHT,
|
|
DIRECTION_UP: DIRECTION_UP,
|
|
DIRECTION_DOWN: DIRECTION_DOWN,
|
|
DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
|
|
DIRECTION_VERTICAL: DIRECTION_VERTICAL,
|
|
DIRECTION_ALL: DIRECTION_ALL,
|
|
Manager: Manager,
|
|
Input: Input,
|
|
TouchAction: TouchAction,
|
|
TouchInput: TouchInput,
|
|
MouseInput: MouseInput,
|
|
PointerEventInput: PointerEventInput,
|
|
TouchMouseInput: TouchMouseInput,
|
|
SingleTouchInput: SingleTouchInput,
|
|
Recognizer: Recognizer,
|
|
AttrRecognizer: AttrRecognizer,
|
|
Tap: TapRecognizer,
|
|
Pan: PanRecognizer,
|
|
Swipe: SwipeRecognizer,
|
|
Pinch: PinchRecognizer,
|
|
Rotate: RotateRecognizer,
|
|
Press: PressRecognizer,
|
|
on: addEventListeners,
|
|
off: removeEventListeners,
|
|
each: each,
|
|
merge: merge,
|
|
extend: extend,
|
|
assign: assign$1,
|
|
inherit: inherit,
|
|
bindFn: bindFn,
|
|
prefixed: prefixed,
|
|
toArray: toArray,
|
|
inArray: inArray,
|
|
uniqueArray: uniqueArray,
|
|
splitStr: splitStr,
|
|
boolOrFn: boolOrFn,
|
|
hasParent: hasParent,
|
|
addEventListeners: addEventListeners,
|
|
removeEventListeners: removeEventListeners,
|
|
defaults: defaults$1
|
|
});
|
|
|
|
var require$$0 = /*@__PURE__*/getAugmentedNamespace(hammer_esm);
|
|
|
|
var Utils = {};
|
|
|
|
Object.defineProperty(Utils, "__esModule", { value: true });
|
|
Utils.blackPixel = void 0;
|
|
Utils.isMobile = isMobile;
|
|
Utils.delay = delay;
|
|
function isMobile() {
|
|
return /Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop/i.test(navigator.userAgent);
|
|
}
|
|
Utils.blackPixel = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
|
|
function delay(duration) {
|
|
return new Promise(function (resolve) { return setTimeout(resolve, duration); });
|
|
}
|
|
|
|
var hasRequiredComponent_ImageViewer;
|
|
|
|
function requireComponent_ImageViewer () {
|
|
if (hasRequiredComponent_ImageViewer) return Component_ImageViewer;
|
|
hasRequiredComponent_ImageViewer = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(Component_ImageViewer, "__esModule", { value: true });
|
|
Component_ImageViewer.ComponentImageViewer = void 0;
|
|
var hammerjs_1 = require$$0;
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var Utils_1 = Utils;
|
|
var Morph_Components_1 = requireMorph_Components();
|
|
var ComponentImageViewer = /** @class */ (function (_super) {
|
|
__extends(ComponentImageViewer, _super);
|
|
function ComponentImageViewer(options) {
|
|
var _a, _b, _c, _d, _e;
|
|
var _this = _super.call(this) || this;
|
|
_this._rawScale = 1;
|
|
_this._relativeScale = 1;
|
|
_this._relativeScaleBase = 1;
|
|
_this._left = 0;
|
|
_this._top = 0;
|
|
_this._firstLoad = true;
|
|
_this._dragging = false;
|
|
_this._dragStart = { originX: 0, originY: 0, startX: 0, startY: 0 };
|
|
window.viewer = _this;
|
|
_this.background = (_a = options === null || options === void 0 ? void 0 : options.background) !== null && _a !== void 0 ? _a : true;
|
|
_this.container = (0, CE_1.ce)('div', 'mux_imageviewer');
|
|
if (options.background != false)
|
|
_this.container.style.background = 'var(--mux-panel-sub-color)';
|
|
_this._wrapper = (0, CE_1.ce)('div', 'mux_imageviewer-wrapper');
|
|
_this._image = (0, CE_1.ce)('img', 'mux_imageviewer-image');
|
|
_this._image.style.display = 'none';
|
|
_this._image.addEventListener('load', function () { return __awaiter(_this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
this._stopLoader();
|
|
return [4 /*yield*/, (0, Utils_1.delay)(10)];
|
|
case 1:
|
|
_a.sent();
|
|
this._image.style.display = 'block';
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
_this._unsupported = (0, CE_1.ce)('div', 'mux_imageviewer-unsupported');
|
|
_this._unsupportedIcon = (0, CE_1.ce)('span', [
|
|
'material-symbols-outlined',
|
|
'mux_imageviewer-unsupported-icon',
|
|
]);
|
|
_this._unsupportedText = (0, CE_1.ce)('div', 'mux_text');
|
|
_this._unsupportedButton = new Morph_Components_1.MorphComponent.Button({
|
|
mode: 'normal',
|
|
content: 'Open externally',
|
|
materialIcon: 'open_in_new',
|
|
target: function () {
|
|
window.open(_this._unsupportedTarget, '_blank');
|
|
},
|
|
}).container;
|
|
_this._unsupported.append(_this._unsupportedIcon, _this._unsupportedText, _this._unsupportedButton);
|
|
_this._wrapper.appendChild(_this._unsupported);
|
|
_this._wrapper.appendChild(_this._image);
|
|
_this._loader = (0, CE_1.ce)('div', 'mux_imageviewer-loader');
|
|
_this._loader.append((0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'), (0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'), (0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'), (0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'));
|
|
_this._wrapper.appendChild(_this._loader);
|
|
var controlscontainer = (0, CE_1.ce)('div', 'mux_imageviewer-controlscontainer');
|
|
var controls = (0, CE_1.ce)('div', 'mux_imageviewer-controls');
|
|
controlscontainer.appendChild(controls);
|
|
if ((options === null || options === void 0 ? void 0 : options.controls) != false) {
|
|
var srcCount = (_c = (_b = options === null || options === void 0 ? void 0 : options.src) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
|
|
if (srcCount > 1) {
|
|
_this._thumbnails = (0, CE_1.ce)('div', [
|
|
'mux_imageviewer-control',
|
|
'mux_active',
|
|
]);
|
|
_this._thumbnails.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'photo_library'));
|
|
_this._thumbnails.appendChild((0, CE_1.ce)('span', [
|
|
'mux_imageviewer-control-badge',
|
|
'mux_text',
|
|
'mux_tiny',
|
|
], null, String(srcCount)));
|
|
controls.appendChild(_this._thumbnails);
|
|
}
|
|
_this._zoomIn = (0, CE_1.ce)('div', 'mux_imageviewer-control');
|
|
_this._zoomIn.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'zoom_in'));
|
|
_this._zoomOut = (0, CE_1.ce)('div', 'mux_imageviewer-control');
|
|
_this._zoomOut.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'zoom_out'));
|
|
_this._fit = (0, CE_1.ce)('div', 'mux_imageviewer-control');
|
|
_this._fit.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'fit_screen'));
|
|
_this._highRes = (0, CE_1.ce)('div', 'mux_imageviewer-control');
|
|
_this._highRes.style.display = 'none';
|
|
_this._highRes.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'high_res'));
|
|
controls.append(_this._zoomIn, _this._zoomOut, _this._fit, _this._highRes);
|
|
}
|
|
if ((options === null || options === void 0 ? void 0 : options.downloadable) == true) {
|
|
var download = (0, CE_1.ce)('div', 'mux_imageviewer-control');
|
|
download.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'download'));
|
|
download.addEventListener('click', function () {
|
|
var a = document.createElement('a');
|
|
a.href = _this._image.src;
|
|
a.download = 'image';
|
|
a.click();
|
|
});
|
|
controls.appendChild(download);
|
|
}
|
|
if (controls.childNodes.length > 0)
|
|
_this._wrapper.appendChild(controlscontainer);
|
|
_this.container.appendChild(_this._wrapper);
|
|
if ((options === null || options === void 0 ? void 0 : options.src) instanceof Array) {
|
|
var sources = options.src;
|
|
if (sources.length == 0)
|
|
return _this;
|
|
if (sources.length == 1) {
|
|
_this.setImage(sources[0]);
|
|
}
|
|
else {
|
|
_this._sources = sources;
|
|
_this._drawThumbnails(sources, (_d = options === null || options === void 0 ? void 0 : options.thumbnailsOpen) !== null && _d !== void 0 ? _d : ((0, Utils_1.isMobile)() ? false : true));
|
|
_this._drawNavigationControls();
|
|
_this._imageCount = sources.length;
|
|
var startIndex = (_e = options === null || options === void 0 ? void 0 : options.startSrc) !== null && _e !== void 0 ? _e : 0;
|
|
_this.setImage(sources[startIndex], startIndex);
|
|
}
|
|
}
|
|
else {
|
|
var source = options.src;
|
|
_this.setImage(source);
|
|
}
|
|
_this.registerListeners();
|
|
return _this;
|
|
}
|
|
ComponentImageViewer.prototype.setImage = function (source, index) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var extention;
|
|
var _this = this;
|
|
var _a, _b, _c;
|
|
return __generator(this, function (_d) {
|
|
switch (_d.label) {
|
|
case 0:
|
|
this._startLoader();
|
|
return [4 /*yield*/, (0, Utils_1.delay)(10)];
|
|
case 1:
|
|
_d.sent();
|
|
this._updateUI(index);
|
|
if (source.normal.split('/').pop().split('.').length > 1) {
|
|
extention = (_b = (_a = source.normal.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
|
|
if (!['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(extention)) {
|
|
this._unsupportedTarget = (_c = source.full) !== null && _c !== void 0 ? _c : source.normal;
|
|
if (['mp4', 'webm'].includes(extention)) {
|
|
return [2 /*return*/, this._showUnsupported('play_arrow', "Videos are not supported yet. Please open the file in a new tab.")];
|
|
}
|
|
return [2 /*return*/, this._showUnsupported('error_outline', "File extention ".concat(extention, " is not supported!"))];
|
|
}
|
|
}
|
|
else
|
|
this._image.onerror = function () {
|
|
_this._showUnsupported('error_outline', "File extention ".concat(extention, " is not supported!"));
|
|
};
|
|
this._image.src = source.normal;
|
|
if (source.full != undefined) {
|
|
this._fullSrc = source.full;
|
|
this._highRes.style.display = 'flex';
|
|
}
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
ComponentImageViewer.prototype.next = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var current, next;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
current = this.container.querySelector('.mux_imageviewer-gallery-thumb.active');
|
|
if (current == null)
|
|
return [2 /*return*/];
|
|
next = current.nextElementSibling;
|
|
if (next == null)
|
|
return [2 /*return*/];
|
|
this._startLoader();
|
|
return [4 /*yield*/, (0, Utils_1.delay)(10)];
|
|
case 1:
|
|
_a.sent();
|
|
next.click();
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
ComponentImageViewer.prototype.previous = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var current, prev;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
current = this.container.querySelector('.mux_imageviewer-gallery-thumb.active');
|
|
if (current == null)
|
|
return [2 /*return*/];
|
|
prev = current.previousElementSibling;
|
|
if (prev == null)
|
|
return [2 /*return*/];
|
|
this._startLoader();
|
|
return [4 /*yield*/, (0, Utils_1.delay)(10)];
|
|
case 1:
|
|
_a.sent();
|
|
prev.click();
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
ComponentImageViewer.prototype._updateUI = function (index) {
|
|
if (index != undefined) {
|
|
this.callEvent('imageIndexChanged', index);
|
|
var previousThumb = this.container.querySelector('.mux_imageviewer-gallery-thumb.active');
|
|
if (previousThumb != null)
|
|
previousThumb.classList.remove('active');
|
|
var thumb = this.container.querySelector(".mux_imageviewer-gallery-thumb[index=\"".concat(index, "\"]"));
|
|
if (thumb != null) {
|
|
thumb.classList.add('active');
|
|
thumb.scrollIntoView({
|
|
behavior: 'smooth',
|
|
inline: 'center',
|
|
});
|
|
if (this._firstLoad) {
|
|
this._firstLoad = false;
|
|
setTimeout(function () {
|
|
thumb.scrollIntoView({
|
|
behavior: 'smooth',
|
|
inline: 'center',
|
|
});
|
|
}, 500);
|
|
}
|
|
}
|
|
}
|
|
if (this._prev != undefined)
|
|
if (index == 0)
|
|
this._prev.classList.add('disabled');
|
|
else
|
|
this._prev.classList.remove('disabled');
|
|
if (this._next != undefined)
|
|
if (index == this._imageCount - 1)
|
|
this._next.classList.add('disabled');
|
|
else
|
|
this._next.classList.remove('disabled');
|
|
};
|
|
ComponentImageViewer.prototype._showUnsupported = function (icon, text) {
|
|
this._unsupportedIcon.innerText = icon;
|
|
this._unsupportedText.innerText = text;
|
|
this._stopLoader();
|
|
this._unsupported.style.display = 'flex';
|
|
};
|
|
ComponentImageViewer.prototype._startLoader = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
this._loader.style.display = 'flex';
|
|
this._unsupported.style.display = 'none';
|
|
this._image.style.display = 'none';
|
|
return [4 /*yield*/, (0, Utils_1.delay)(10)];
|
|
case 1:
|
|
_a.sent();
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
ComponentImageViewer.prototype._stopLoader = function () {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
this._loader.style.display = 'none';
|
|
this._restartScaling();
|
|
return [2 /*return*/];
|
|
});
|
|
});
|
|
};
|
|
ComponentImageViewer.prototype._handleStart = function (originX, originY) {
|
|
this._dragging = true;
|
|
this._dragStart = {
|
|
originX: originX,
|
|
originY: originY,
|
|
startX: this._image.offsetLeft,
|
|
startY: this._image.offsetTop,
|
|
};
|
|
};
|
|
ComponentImageViewer.prototype._handleMove = function (x, y) {
|
|
var newX = this._validateX(this._dragStart.startX + x - this._dragStart.originX);
|
|
var newY = this._validateY(this._dragStart.startY + y - this._dragStart.originY);
|
|
this._left = newX;
|
|
this._top = newY;
|
|
this._image.style.left = "".concat(newX, "px");
|
|
this._image.style.top = "".concat(newY, "px");
|
|
};
|
|
ComponentImageViewer.prototype.registerListeners = function () {
|
|
var _this = this;
|
|
//Start
|
|
this.container.addEventListener('mousedown', function (e) {
|
|
_this._handleStart(e.clientX, e.clientY);
|
|
});
|
|
this.container.addEventListener('touchstart', function (e) {
|
|
_this._handleStart(e.touches[0].clientX, e.touches[0].clientY);
|
|
});
|
|
//Move
|
|
this.container.addEventListener('mousemove', function (e) {
|
|
if (!_this._dragging)
|
|
return;
|
|
if (e.buttons != 1) {
|
|
_this._dragging = false;
|
|
return;
|
|
}
|
|
_this._handleMove(e.clientX, e.clientY);
|
|
});
|
|
this.container.addEventListener('touchmove', function (e) {
|
|
if (!_this._dragging)
|
|
return;
|
|
_this._handleMove(e.touches[0].clientX, e.touches[0].clientY);
|
|
});
|
|
//End
|
|
this.container.addEventListener('mouseup', function (e) {
|
|
_this._dragging = false;
|
|
});
|
|
this.container.addEventListener('touchend', function (e) {
|
|
_this._dragging = false;
|
|
});
|
|
//Zoom
|
|
this.container.addEventListener('wheel', function (e) {
|
|
e.preventDefault();
|
|
_this._setScale(_this._relativeScale + e.deltaY * -0.003);
|
|
});
|
|
var mc = new hammerjs_1.default(this._wrapper);
|
|
mc.add(new hammerjs_1.default.Pinch());
|
|
var beforeScale = this._relativeScale;
|
|
mc.on('pinchstart', function (e) {
|
|
beforeScale = _this._relativeScale;
|
|
});
|
|
mc.on('pinch', function (e) {
|
|
_this._setScale(beforeScale * e.scale);
|
|
});
|
|
//Controls
|
|
if (this._thumbnails != undefined)
|
|
this._thumbnails.addEventListener('click', function () {
|
|
if (_this.container.classList.contains('mux_imageviewer-galleryopen')) {
|
|
_this.container.classList.remove('mux_imageviewer-galleryopen');
|
|
_this._thumbnails.classList.remove('mux_active');
|
|
_this.callEvent('thumbnailsOpen', false);
|
|
}
|
|
else {
|
|
_this.container.classList.add('mux_imageviewer-galleryopen');
|
|
_this._thumbnails.classList.add('mux_active');
|
|
_this.callEvent('thumbnailsOpen', true);
|
|
}
|
|
});
|
|
if (this._zoomIn != undefined)
|
|
this._zoomIn.addEventListener('click', function () { return _this.zoomIn(); });
|
|
if (this._zoomOut != undefined)
|
|
this._zoomOut.addEventListener('click', function () { return _this.zoomOut(); });
|
|
if (this._fit != undefined)
|
|
this._fit.addEventListener('click', function () { return _this.fitToContainer(); });
|
|
if (this._highRes != undefined)
|
|
this._highRes.addEventListener('click', function () { return __awaiter(_this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
this._startLoader();
|
|
this._image.style.display = 'none';
|
|
return [4 /*yield*/, (0, Utils_1.delay)(10)];
|
|
case 1:
|
|
_a.sent();
|
|
this._image.src = this._fullSrc;
|
|
this._highRes.style.display = 'none';
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
};
|
|
ComponentImageViewer.prototype._drawNavigationControls = function () {
|
|
var _this = this;
|
|
this._next = (0, CE_1.ce)('div', [
|
|
'mux_imageviewer-navigation',
|
|
'mux_imageviewer-navigation-right',
|
|
]);
|
|
this._next.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'navigate_next'));
|
|
this._next.addEventListener('click', function () {
|
|
if (_this._next.classList.contains('disabled'))
|
|
return;
|
|
_this.next();
|
|
});
|
|
this._wrapper.appendChild(this._next);
|
|
this._prev = (0, CE_1.ce)('div', [
|
|
'mux_imageviewer-navigation',
|
|
'mux_imageviewer-navigation-left',
|
|
]);
|
|
this._prev.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'navigate_before'));
|
|
this._prev.addEventListener('click', function () {
|
|
if (_this._prev.classList.contains('disabled'))
|
|
return;
|
|
_this.previous();
|
|
});
|
|
this._wrapper.appendChild(this._prev);
|
|
};
|
|
ComponentImageViewer.prototype._drawThumbnails = function (sources, openThumbnails) {
|
|
var _this = this;
|
|
var gallery = (0, CE_1.ce)('div', 'mux_imageviewer-gallery');
|
|
if (this.background != false)
|
|
gallery.style.background = 'var(--mux-panel-color)';
|
|
sources.forEach(function (source, index) {
|
|
var _a;
|
|
var thumb = (0, CE_1.ce)('img', 'mux_imageviewer-gallery-thumb', {
|
|
index: index,
|
|
src: (_a = source.thumbnail) !== null && _a !== void 0 ? _a : source.normal,
|
|
});
|
|
thumb.addEventListener('click', function () {
|
|
_this.setImage(source, index);
|
|
});
|
|
gallery.appendChild(thumb);
|
|
});
|
|
this.container.appendChild(gallery);
|
|
if (openThumbnails)
|
|
this.container.classList.add('mux_imageviewer-galleryopen');
|
|
this.fitToContainer();
|
|
};
|
|
ComponentImageViewer.prototype._validateX = function (x) {
|
|
var bounds = this._image.getBoundingClientRect();
|
|
var minInlay = this._wrapper.clientWidth - 10;
|
|
if (bounds.width < this._wrapper.clientWidth) {
|
|
x = (this._wrapper.clientWidth - bounds.width) / 2;
|
|
}
|
|
else {
|
|
x = Math.max(x, (bounds.width - minInlay) * -1);
|
|
x = Math.min(x, this._wrapper.clientWidth - minInlay);
|
|
}
|
|
return x;
|
|
};
|
|
ComponentImageViewer.prototype._validateY = function (y) {
|
|
var bounds = this._image.getBoundingClientRect();
|
|
var minInlay = this._wrapper.clientHeight - 10;
|
|
if (bounds.height < this._wrapper.clientHeight) {
|
|
y = (this._wrapper.clientHeight - bounds.height) / 2;
|
|
}
|
|
else {
|
|
y = Math.max(y, (bounds.height - minInlay) * -1);
|
|
y = Math.min(y, this._wrapper.clientHeight - minInlay);
|
|
}
|
|
return y;
|
|
};
|
|
ComponentImageViewer.prototype._restartScaling = function () {
|
|
var _this = this;
|
|
this._calculateRelativeScale(function () {
|
|
_this.fitToContainer();
|
|
_this._startScaleClock();
|
|
});
|
|
clearTimeout(this._restartScalingRepeat);
|
|
this._restartScalingRepeat = setTimeout(function () {
|
|
_this._calculateRelativeScale(function () {
|
|
_this.fitToContainer();
|
|
_this._startScaleClock();
|
|
});
|
|
}, 1000);
|
|
};
|
|
ComponentImageViewer.prototype._calculateRelativeScale = function (readyCallback) {
|
|
var _this = this;
|
|
var bounds = this._image.getBoundingClientRect();
|
|
clearTimeout(this._fitToContainerRetry);
|
|
if (bounds.width == 0 ||
|
|
bounds.height == 0 ||
|
|
this._image.width == 0 ||
|
|
this._image.height == 0)
|
|
return (this._fitToContainerRetry = setTimeout(function () { return _this._calculateRelativeScale(readyCallback); }, 100));
|
|
var maxWidth = this._wrapper.clientWidth - 20;
|
|
var maxHeight = this._wrapper.clientHeight - 20;
|
|
this._relativeScaleBase = Math.min(maxWidth / this._image.width, maxHeight / this._image.height);
|
|
this._setScale(this._relativeScale);
|
|
if (typeof readyCallback == 'function')
|
|
readyCallback();
|
|
};
|
|
ComponentImageViewer.prototype._setScale = function (factor) {
|
|
this._relativeScale = Math.min(Math.max(factor, 1), 10);
|
|
this._setRawScale(this._relativeScaleBase * factor);
|
|
};
|
|
ComponentImageViewer.prototype._setRawScale = function (scale) {
|
|
var bounds = this._image.getBoundingClientRect();
|
|
this._rawScale = Math.max(scale, this._relativeScaleBase);
|
|
var widthDiff = bounds.width - this._rawScale * this._image.clientWidth;
|
|
var heightDiff = bounds.height - this._rawScale * this._image.clientHeight;
|
|
this._image.style.transform = "scale(".concat(this._rawScale, ")");
|
|
this._left = this._validateX(this._left + widthDiff / 2);
|
|
this._image.style.left = "".concat(this._left, "px");
|
|
this._top = this._validateY(this._top + heightDiff / 2);
|
|
this._image.style.top = "".concat(this._top, "px");
|
|
};
|
|
ComponentImageViewer.prototype._startScaleClock = function () {
|
|
var _this = this;
|
|
if (this._startScaleClockInt != undefined)
|
|
return;
|
|
var lastWidth = this._wrapper.clientWidth;
|
|
var lastHeight = this._wrapper.clientHeight;
|
|
clearInterval(this._startScaleClockInt);
|
|
this._startScaleClockInt = setInterval(function () {
|
|
if (_this.container.parentElement == null)
|
|
return clearInterval(_this._startScaleClockInt);
|
|
if (lastWidth != _this._wrapper.clientWidth ||
|
|
lastHeight != _this._wrapper.clientHeight) {
|
|
lastWidth = _this._wrapper.clientWidth;
|
|
lastHeight = _this._wrapper.clientHeight;
|
|
_this._calculateRelativeScale();
|
|
}
|
|
}, 100);
|
|
};
|
|
ComponentImageViewer.prototype.setImageIndex = function (index) {
|
|
if (this._sources == undefined)
|
|
return;
|
|
if (this._sources[index] == undefined)
|
|
return;
|
|
this.setImage(this._sources[index], index);
|
|
};
|
|
ComponentImageViewer.prototype.fitToContainer = function () {
|
|
this._setScale(1);
|
|
this._left = this._validateX((this._wrapper.clientWidth - this._image.width * this._rawScale) / 2);
|
|
this._top = this._validateY((this._wrapper.clientHeight - this._image.height * this._rawScale) /
|
|
2);
|
|
this._image.style.left = "".concat(this._left, "px");
|
|
this._image.style.top = "".concat(this._top, "px");
|
|
this._image.style.opacity = '1';
|
|
};
|
|
ComponentImageViewer.prototype.zoomIn = function () {
|
|
this._setScale(this._relativeScale + 0.3);
|
|
};
|
|
ComponentImageViewer.prototype.zoomOut = function () {
|
|
this._setScale(this._relativeScale - 0.3);
|
|
};
|
|
return ComponentImageViewer;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_ImageViewer.ComponentImageViewer = ComponentImageViewer;
|
|
|
|
return Component_ImageViewer;
|
|
}
|
|
|
|
var Component_Input = {};
|
|
|
|
var __extends$3 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Input, "__esModule", { value: true });
|
|
Component_Input.ComponentInput = void 0;
|
|
var CE_1$3 = CE;
|
|
var baseComponent_1$3 = baseComponent;
|
|
var ComponentInput = /** @class */ (function (_super) {
|
|
__extends$3(ComponentInput, _super);
|
|
function ComponentInput(options) {
|
|
var _a;
|
|
var _this = _super.call(this) || this;
|
|
_this.container = (0, CE_1$3.ce)('input', 'mux_input', {
|
|
type: options.type,
|
|
});
|
|
var border = (_a = options.border) !== null && _a !== void 0 ? _a : 'hover';
|
|
if (border == 'always')
|
|
_this.container.classList.add('mux_input-alwaysborder');
|
|
else if (border == 'never')
|
|
_this.container.classList.add('mux_input-noborder');
|
|
if ((options === null || options === void 0 ? void 0 : options.min) != undefined)
|
|
_this.container.min = String(options.min);
|
|
if ((options === null || options === void 0 ? void 0 : options.max) != undefined)
|
|
_this.container.max = String(options.max);
|
|
if ((options === null || options === void 0 ? void 0 : options.step) != undefined)
|
|
_this.container.step = String(options.step);
|
|
if ((options === null || options === void 0 ? void 0 : options.maxLength) != undefined)
|
|
_this.container.maxLength = options.maxLength;
|
|
if ((options === null || options === void 0 ? void 0 : options.readOnly) != undefined)
|
|
_this.container.readOnly = options.readOnly;
|
|
if ((options === null || options === void 0 ? void 0 : options.placeholder) != undefined)
|
|
_this.container.placeholder = options.placeholder;
|
|
if ((options === null || options === void 0 ? void 0 : options.value) != undefined)
|
|
_this.container.value = options.value;
|
|
if ((options === null || options === void 0 ? void 0 : options.valueAsNumber) != undefined)
|
|
_this.container.valueAsNumber = options.valueAsNumber;
|
|
if (options.enabled == false)
|
|
_this.container.setAttribute('disabled', '');
|
|
_this.container.oninput = function () {
|
|
return _this.callEvent('input', _this.container.value);
|
|
};
|
|
_this.container.onfocus = function () { return _this.callEvent('focus'); };
|
|
_this.container.onblur = function () { return _this.callEvent('blur'); };
|
|
return _this;
|
|
}
|
|
ComponentInput.prototype.getValue = function () {
|
|
return this.container.value;
|
|
};
|
|
ComponentInput.prototype.getValueAsNumber = function () {
|
|
return this.container.valueAsNumber;
|
|
};
|
|
ComponentInput.prototype.setValue = function (value) {
|
|
this.container.value = value;
|
|
};
|
|
ComponentInput.prototype.setValueAsNumber = function (value) {
|
|
this.container.valueAsNumber = value;
|
|
};
|
|
return ComponentInput;
|
|
}(baseComponent_1$3.MUXComponent));
|
|
Component_Input.ComponentInput = ComponentInput;
|
|
|
|
var Component_List = {};
|
|
|
|
var hasRequiredComponent_List;
|
|
|
|
function requireComponent_List () {
|
|
if (hasRequiredComponent_List) return Component_List;
|
|
hasRequiredComponent_List = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_List, "__esModule", { value: true });
|
|
Component_List.ComponentList = void 0;
|
|
var Index_1 = requireIndex();
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var Sortable = SortableExports;
|
|
var ComponentList = /** @class */ (function (_super) {
|
|
__extends(ComponentList, _super);
|
|
function ComponentList(options) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j;
|
|
var _this = _super.call(this) || this;
|
|
_this.openGroups = [];
|
|
_this.groupComponents = new Map();
|
|
_this.options = options;
|
|
_this.dragable = (_a = options === null || options === void 0 ? void 0 : options.dragable) !== null && _a !== void 0 ? _a : false;
|
|
_this.hover = (_b = options === null || options === void 0 ? void 0 : options.hover) !== null && _b !== void 0 ? _b : false;
|
|
_this.grouped = (_c = options === null || options === void 0 ? void 0 : options.grouped) !== null && _c !== void 0 ? _c : false;
|
|
_this.groupsCloseable = (_d = options === null || options === void 0 ? void 0 : options.groupsCloseable) !== null && _d !== void 0 ? _d : false;
|
|
_this.sortGroupsAlphabetically =
|
|
(_e = options === null || options === void 0 ? void 0 : options.sortGroupsAlphabetically) !== null && _e !== void 0 ? _e : false;
|
|
_this.openGroups = (_f = options === null || options === void 0 ? void 0 : options.groupsOpen) !== null && _f !== void 0 ? _f : [];
|
|
_this.allowSingleItemGroups = (_g = options === null || options === void 0 ? void 0 : options.allowSingleItemGroups) !== null && _g !== void 0 ? _g : false;
|
|
_this.highlighted = (_h = options === null || options === void 0 ? void 0 : options.highlightedItem) !== null && _h !== void 0 ? _h : null;
|
|
if (_this.dragable == true && _this.grouped == true)
|
|
throw new Error("Unable to use 'grouped' for list component when 'canReorderByDrag' is also enabled. ");
|
|
_this.container = (0, CE_1.ce)('div', 'mux_list');
|
|
_this.updateItems((_j = options === null || options === void 0 ? void 0 : options.items) !== null && _j !== void 0 ? _j : []);
|
|
if (_this.dragable == true) {
|
|
_this.sortable = new Sortable(_this.container, {
|
|
ghostClass: 'mux_list-item-dragging',
|
|
onStart: function () {
|
|
_this.container.classList.add('mux_list-dragging');
|
|
},
|
|
onEnd: function (evt) {
|
|
_this.container.classList.remove('mux_list-dragging');
|
|
_this.callEvent('orderUpdated', _this.getCurrentOrder());
|
|
},
|
|
});
|
|
}
|
|
return _this;
|
|
}
|
|
ComponentList.prototype.updateItems = function (items) {
|
|
var _this = this;
|
|
var _a;
|
|
this.container.innerHTML = '';
|
|
this.groupComponents.clear();
|
|
if (items == undefined || items.length == 0)
|
|
return;
|
|
if (this.grouped) {
|
|
var groups = [];
|
|
for (var i = 0; i < items.length; i++) {
|
|
var group = (_a = items[i].group) !== null && _a !== void 0 ? _a : 'Ungrouped';
|
|
if (!groups.includes(group)) {
|
|
groups.push(group);
|
|
}
|
|
}
|
|
if (this.sortGroupsAlphabetically == true)
|
|
groups.sort();
|
|
for (var i = 0; i < groups.length; i++) {
|
|
this.ensureGroup(groups[i]);
|
|
}
|
|
}
|
|
items.forEach(function (item) { return _this.addItem(item); });
|
|
this.groupComponents.forEach(function (_a, group) {
|
|
var container = _a.container, content = _a.content;
|
|
if (content.children.length == 0) {
|
|
container.parentElement.removeChild(container);
|
|
_this.groupComponents.delete(group);
|
|
}
|
|
else {
|
|
if (content.children.length == 1 &&
|
|
_this.allowSingleItemGroups == false) {
|
|
container.classList.add('mux_group-singular');
|
|
}
|
|
else
|
|
container.classList.remove('mux_group-singular');
|
|
}
|
|
});
|
|
};
|
|
ComponentList.prototype.getCurrentOrder = function () {
|
|
return Array.from(this.container.querySelectorAll('.mux_list-item')).map(function (item) {
|
|
return item.getAttribute('uid');
|
|
});
|
|
};
|
|
ComponentList.prototype.removeItem = function (uniqueIdentifier) {
|
|
var match = this.container.querySelector(".mux_list-item[uid=\"".concat(uniqueIdentifier, "\"]"));
|
|
if (match != null)
|
|
match.remove();
|
|
this.callEvent('orderUpdated', this.getCurrentOrder());
|
|
};
|
|
ComponentList.prototype.addItem = function (item) {
|
|
var _this = this;
|
|
var _a, _b;
|
|
var element = (0, CE_1.ce)('div', 'mux_list-item', {
|
|
uid: item.uniqueIdentifier,
|
|
});
|
|
if (this.hover)
|
|
element.classList.add('mux_list-item-hover');
|
|
// if (showSeperator) element.classList.add('mux_list-item-separator');
|
|
if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.overwriteCursor) != null)
|
|
element.style.cursor = this.options.overwriteCursor;
|
|
if (this.highlighted != null &&
|
|
this.highlighted == item.uniqueIdentifier)
|
|
element.classList.add('mux_list-item-selected');
|
|
if (item.tooltip != undefined)
|
|
element.title = item.tooltip;
|
|
if (item.enabled == false)
|
|
element.classList.add('mux_list-item-disabled');
|
|
var content = (0, CE_1.ce)('div', 'mux_list-item-content');
|
|
element.appendChild(content);
|
|
element.onclick = function (e) {
|
|
var _a;
|
|
if (((_a = _this.options) === null || _a === void 0 ? void 0 : _a.highlightOnClick) == true)
|
|
_this.highlight(item.uniqueIdentifier);
|
|
if (item.click != undefined)
|
|
item.click();
|
|
};
|
|
if (item.materialIcon != undefined) {
|
|
var mi = (0, CE_1.ce)('span', ['mux_list-item-icon', 'material-symbols-outlined'], null, item.materialIcon);
|
|
content.appendChild(mi);
|
|
if (item.materialIconColor != undefined)
|
|
mi.style.color = item.materialIconColor;
|
|
}
|
|
else if (item.icon != undefined)
|
|
content.appendChild((0, CE_1.ce)('img', 'mux_list-item-icon', { src: item.icon }));
|
|
var text = (0, CE_1.ce)('div', 'mux_list-item-text');
|
|
if (item.text != undefined)
|
|
text.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_normal'], null, item.text));
|
|
if (item.subText != undefined)
|
|
text.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_small'], null, item.subText));
|
|
content.appendChild(text);
|
|
if (item.actions != undefined && item.actions.length > 0) {
|
|
var actions = (0, CE_1.ce)('div', 'mux_list-item-actions');
|
|
var _loop_1 = function (i) {
|
|
action = (0, CE_1.ce)('div', 'mux_list-item-action');
|
|
if (item.actions[i].tooltip != undefined)
|
|
action.title = item.actions[i].tooltip;
|
|
if (item.actions[i].materialIcon != undefined)
|
|
action.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, item.actions[i].materialIcon));
|
|
else if (item.actions[i].icon != undefined)
|
|
action.appendChild((0, CE_1.ce)('img', null, { src: item.actions[i].icon }));
|
|
action.onclick = function (e) {
|
|
e.stopPropagation();
|
|
e.stopImmediatePropagation();
|
|
item.actions[i].click();
|
|
};
|
|
actions.appendChild(action);
|
|
};
|
|
var action;
|
|
for (var i = 0; i < item.actions.length; i++) {
|
|
_loop_1(i);
|
|
}
|
|
content.appendChild(actions);
|
|
}
|
|
if (this.grouped == true) {
|
|
var group = (_b = item.group) !== null && _b !== void 0 ? _b : 'Ungrouped';
|
|
var content = this.ensureGroup(group).content;
|
|
content.appendChild(element);
|
|
}
|
|
else
|
|
this.container.appendChild(element);
|
|
this.size = this.container.querySelectorAll('.mux_list-item').length;
|
|
};
|
|
ComponentList.prototype.highlight = function (uniqueIdentifier) {
|
|
this.highlighted = uniqueIdentifier;
|
|
this.container
|
|
.querySelectorAll('.mux_list-item')
|
|
.forEach(function (item) {
|
|
var uid = item.getAttribute('uid');
|
|
if (uid == uniqueIdentifier) {
|
|
item.classList.add('mux_list-item-selected');
|
|
item.scrollIntoView({
|
|
behavior: 'smooth',
|
|
block: 'center',
|
|
});
|
|
}
|
|
else
|
|
item.classList.remove('mux_list-item-selected');
|
|
});
|
|
};
|
|
ComponentList.prototype.ensureGroup = function (group) {
|
|
var _this = this;
|
|
if (this.groupComponents.has(group))
|
|
return this.groupComponents.get(group);
|
|
var groupComponent = new Index_1.MorphComponent.Group({
|
|
title: group,
|
|
open: this.openGroups.includes(group) ||
|
|
this.openGroups.includes('*') ||
|
|
this.groupsCloseable == false,
|
|
closeable: this.groupsCloseable,
|
|
});
|
|
groupComponent.on('openState', function (state) {
|
|
if (state) {
|
|
if (!_this.openGroups.includes(group))
|
|
_this.openGroups.push(group);
|
|
}
|
|
else {
|
|
if (_this.openGroups.includes(group))
|
|
_this.openGroups.splice(_this.openGroups.indexOf(group), 1);
|
|
}
|
|
_this.callEvent('openGroupsUpdated', _this.openGroups);
|
|
});
|
|
this.container.appendChild(groupComponent.container);
|
|
this.groupComponents.set(group, groupComponent);
|
|
return this.groupComponents.get(group);
|
|
};
|
|
return ComponentList;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_List.ComponentList = ComponentList;
|
|
|
|
return Component_List;
|
|
}
|
|
|
|
var Component_MenuBar = {};
|
|
|
|
var hasRequiredComponent_MenuBar;
|
|
|
|
function requireComponent_MenuBar () {
|
|
if (hasRequiredComponent_MenuBar) return Component_MenuBar;
|
|
hasRequiredComponent_MenuBar = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_MenuBar, "__esModule", { value: true });
|
|
Component_MenuBar.ComponentMenuBar = void 0;
|
|
var Index_1 = requireIndex();
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var ComponentMenuBar = /** @class */ (function (_super) {
|
|
__extends(ComponentMenuBar, _super);
|
|
function ComponentMenuBar(options) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
|
|
var _this = _super.call(this) || this;
|
|
_this.enabledStates = {};
|
|
_this._leftItems = [];
|
|
_this._rightItems = [];
|
|
_this.mobileIgnoreItems = [];
|
|
_this._leftItems = (_a = options.left) !== null && _a !== void 0 ? _a : [];
|
|
_this._rightItems = (_b = options.right) !== null && _b !== void 0 ? _b : [];
|
|
_this.contextMaterialIconColor =
|
|
(_c = options.contextMaterialIconColor) !== null && _c !== void 0 ? _c : 'var(--mux-primary-color)';
|
|
_this.contextMenuAlign = (_d = options.contextMenuAlign) !== null && _d !== void 0 ? _d : 'below';
|
|
_this.contextAlignSide = {
|
|
below: 'center',
|
|
left: 'right',
|
|
right: 'left',
|
|
}[_this.contextMenuAlign];
|
|
_this.container = (0, CE_1.ce)('div', 'mux_menubar');
|
|
_this.size = (_e = options.size) !== null && _e !== void 0 ? _e : 'normal';
|
|
_this.container.classList.add("mux_menubar-".concat(_this.size));
|
|
_this.direction = (_f = options === null || options === void 0 ? void 0 : options.direction) !== null && _f !== void 0 ? _f : 'horizontal';
|
|
_this.container.classList.add("mux_menubar-direction-".concat(_this.direction));
|
|
_this.leftContainer = (0, CE_1.ce)('div', ['mux_menubar-locater', 'mux_left']);
|
|
_this.rightContainer = (0, CE_1.ce)('div', ['mux_menubar-locater', 'mux_right']);
|
|
_this.mobileContainer = (0, CE_1.ce)('div', 'mux_menubar-mobile');
|
|
var mobileRightItems = (0, CE_1.ce)('div', [
|
|
'mux_menubar-mobile-items',
|
|
'mux_right',
|
|
]);
|
|
((_h = (_g = options === null || options === void 0 ? void 0 : options.mobile) === null || _g === void 0 ? void 0 : _g.right) !== null && _h !== void 0 ? _h : []).forEach(function (item) {
|
|
return _this.addItem(item, mobileRightItems);
|
|
});
|
|
var mobileLeftItems = (0, CE_1.ce)('div', [
|
|
'mux_menubar-mobile-items',
|
|
'mux_left',
|
|
]);
|
|
((_k = (_j = options === null || options === void 0 ? void 0 : options.mobile) === null || _j === void 0 ? void 0 : _j.left) !== null && _k !== void 0 ? _k : []).forEach(function (item) {
|
|
return _this.addItem(item, mobileLeftItems);
|
|
});
|
|
if (((_l = options === null || options === void 0 ? void 0 : options.mobile) === null || _l === void 0 ? void 0 : _l.logo) != undefined) {
|
|
mobileLeftItems.style.left = '50px';
|
|
var logo = (0, CE_1.ce)('a', 'mux_menubar-mobile-logo', {
|
|
href: options.mobile.logo.href,
|
|
});
|
|
logo.appendChild((0, CE_1.ce)('img', null, { src: options.mobile.logo.src }));
|
|
_this.mobileContainer.appendChild(logo);
|
|
}
|
|
_this.mobileIgnoreItems = (_o = (_m = options === null || options === void 0 ? void 0 : options.mobile) === null || _m === void 0 ? void 0 : _m.ignoreItems) !== null && _o !== void 0 ? _o : [];
|
|
_this.addItem({
|
|
type: 'icon',
|
|
materialIcon: 'menu',
|
|
click: function () {
|
|
_this.openMobileMenu();
|
|
// this.rightContainer.classList.toggle('mux_menubar-visible');
|
|
},
|
|
}, mobileRightItems);
|
|
_this.mobileContainer.append(mobileLeftItems, mobileRightItems);
|
|
_this.container.append(_this.leftContainer, _this.rightContainer, _this.mobileContainer);
|
|
if ((options === null || options === void 0 ? void 0 : options.left) != undefined)
|
|
options.left.forEach(function (item) {
|
|
return _this.addItem(item, _this.leftContainer);
|
|
});
|
|
if ((options === null || options === void 0 ? void 0 : options.right) != undefined)
|
|
options.right.forEach(function (item) {
|
|
return _this.addItem(item, _this.rightContainer);
|
|
});
|
|
if (_this.direction == 'horizontal') {
|
|
_this.calculateSizing();
|
|
window.addEventListener('resize', function () {
|
|
_this.calculateSizing();
|
|
});
|
|
var c = 0;
|
|
_this.sizeClock = setInterval(function () {
|
|
if (c++ > 200)
|
|
clearInterval(_this.sizeClock);
|
|
if (_this.container.parentElement != null) {
|
|
clearInterval(_this.sizeClock);
|
|
_this.calculateSizing();
|
|
}
|
|
}, 10);
|
|
}
|
|
else {
|
|
_this.leftContainer.classList.add('mux_menubar-visible');
|
|
_this.rightContainer.classList.add('mux_menubar-visible');
|
|
}
|
|
return _this;
|
|
}
|
|
ComponentMenuBar.prototype.calculateSizing = function () {
|
|
var menuSize = this.leftContainer.clientWidth + this.rightContainer.clientWidth;
|
|
var containerWidth = this.container.clientWidth;
|
|
if (menuSize != 0 && containerWidth != 0)
|
|
clearInterval(this.sizeClock);
|
|
if (menuSize > containerWidth) {
|
|
this.leftContainer.classList.remove('mux_menubar-visible');
|
|
this.rightContainer.classList.remove('mux_menubar-visible');
|
|
this.mobileContainer.classList.add('mux_menubar-visible');
|
|
}
|
|
else {
|
|
this.leftContainer.classList.add('mux_menubar-visible');
|
|
this.rightContainer.classList.add('mux_menubar-visible');
|
|
this.mobileContainer.classList.remove('mux_menubar-visible');
|
|
}
|
|
};
|
|
ComponentMenuBar.prototype.addItem = function (item, target) {
|
|
var _this = this;
|
|
if (item.type != 'image') {
|
|
var element = (0, CE_1.ce)(item.href != undefined ? 'a' : 'div', 'mux_menubar-item');
|
|
if (item.uniqueIdentifier != undefined)
|
|
element.setAttribute('uid', item.uniqueIdentifier);
|
|
if (item.enabled != undefined && item.enabled == false)
|
|
element.classList.add('mux_menubar-item-disabled');
|
|
if (item.href != undefined)
|
|
element.setAttribute('href', item.href);
|
|
if (item.tooltip != undefined)
|
|
element.title = item.tooltip;
|
|
if (item.selected == true)
|
|
element.classList.add('mux_menubar-item-selected');
|
|
if (item.materialIcon != undefined) {
|
|
var materialIcon = (0, CE_1.ce)('span', [
|
|
'mux_menubar-item-materialicon',
|
|
'material-symbols-outlined',
|
|
], null, item.materialIcon);
|
|
if (item.materialIconTransform != undefined)
|
|
materialIcon.style.transform = item.materialIconTransform;
|
|
element.appendChild(materialIcon);
|
|
}
|
|
switch (item.type) {
|
|
case 'icon':
|
|
element.classList.add('mux_menubar-item-icon');
|
|
element.onclick = item.click;
|
|
break;
|
|
case 'normal':
|
|
element.classList.add('mux_menubar-item-normal');
|
|
element.appendChild((0, CE_1.ce)('p', ['mux_text', "mux_".concat(this.size)], null, item.text));
|
|
break;
|
|
}
|
|
if (item.children == undefined || item.children.length == 0) {
|
|
if (item.click != undefined && item.href == undefined)
|
|
element.onclick = item.click;
|
|
}
|
|
else {
|
|
// if (item.type == 'normal')
|
|
element.appendChild((0, CE_1.ce)('span', ['material-symbols-outlined', 'mux_menubar-item-arrow'], null, "keyboard_arrow_".concat({ below: 'down', left: 'left', right: 'right' }[this.contextMenuAlign])));
|
|
element.onclick = function () {
|
|
var _a;
|
|
if (element.classList.contains('mux_menubar-item-disabled'))
|
|
return;
|
|
var bounds = element.getBoundingClientRect();
|
|
element.classList.add('mux_menubar-item-selected');
|
|
for (var i = 0; i < item.children.length; i++)
|
|
if (((_a = item.children[i]) === null || _a === void 0 ? void 0 : _a.uniqueIdentifier) != undefined) {
|
|
if (_this.enabledStates[item.children[i].uniqueIdentifier] != undefined)
|
|
item.children[i].enabled =
|
|
_this.enabledStates[item.children[i].uniqueIdentifier];
|
|
}
|
|
var x;
|
|
var y;
|
|
if (_this.contextMenuAlign == 'below') {
|
|
x = bounds.x + bounds.width / 2;
|
|
y = bounds.y + bounds.height;
|
|
}
|
|
else if (_this.contextMenuAlign == 'left') {
|
|
x = bounds.x;
|
|
y = bounds.y;
|
|
}
|
|
else if (_this.contextMenuAlign == 'right') {
|
|
x = bounds.x + bounds.width;
|
|
y = bounds.y;
|
|
}
|
|
_this.dropdown = new Index_1.MorphComponent.ContextMenu({
|
|
x: x,
|
|
y: y,
|
|
align: _this.contextAlignSide,
|
|
items: item.children,
|
|
materialIconColor: _this.contextMaterialIconColor,
|
|
});
|
|
_this.dropdown.on('close', function () {
|
|
element.classList.remove('mux_menubar-item-selected');
|
|
});
|
|
};
|
|
}
|
|
target.appendChild(element);
|
|
}
|
|
else {
|
|
var icon = (0, CE_1.ce)(item.href != undefined ? 'a' : 'div', 'mux_menubar-image');
|
|
if (item.href != undefined)
|
|
icon.href = item.href;
|
|
icon.appendChild((0, CE_1.ce)('img', null, { src: item.url }));
|
|
target.appendChild(icon);
|
|
}
|
|
};
|
|
ComponentMenuBar.prototype.setSelected = function (uniqueIdentifier) {
|
|
this.selected = uniqueIdentifier;
|
|
this.container
|
|
.querySelectorAll('.mux_menubar-item')
|
|
.forEach(function (item) {
|
|
if (item.getAttribute('uid') == uniqueIdentifier)
|
|
item.classList.add('mux_menubar-item-selected');
|
|
else
|
|
item.classList.remove('mux_menubar-item-selected');
|
|
});
|
|
if (this.mobileMenu != null)
|
|
this.mobileMenu.setSelected(uniqueIdentifier);
|
|
};
|
|
ComponentMenuBar.prototype.setEnabled = function (uniqueIdentifier, enabled) {
|
|
var item = this.container.querySelector(".mux_menubar-item[uid=\"".concat(uniqueIdentifier, "\"]"));
|
|
if (item == null)
|
|
return;
|
|
if (enabled)
|
|
item.classList.remove('mux_menubar-item-disabled');
|
|
else
|
|
item.classList.add('mux_menubar-item-disabled');
|
|
};
|
|
ComponentMenuBar.prototype.openMobileMenu = function () {
|
|
var _this = this;
|
|
var container = (0, CE_1.ce)('div', 'mux_mobilemenu');
|
|
var inner = (0, CE_1.ce)('div', 'mux_mobilemenu-inner');
|
|
this.mobileMenu = new ComponentMenuBar({
|
|
direction: 'vertical',
|
|
left: this._leftItems.filter(function (item) {
|
|
if (item.uniqueIdentifier == undefined)
|
|
return true;
|
|
return !_this.mobileIgnoreItems.includes(item.uniqueIdentifier);
|
|
}),
|
|
right: this._rightItems.filter(function (item) {
|
|
if (item.uniqueIdentifier == undefined)
|
|
return true;
|
|
return !_this.mobileIgnoreItems.includes(item.uniqueIdentifier);
|
|
}),
|
|
});
|
|
this.mobileMenu.setSelected(this.selected);
|
|
inner.appendChild(this.mobileMenu.container);
|
|
container.appendChild(inner);
|
|
document.body.appendChild(container);
|
|
container.animate({ opacity: '1' }, { duration: 200 }).onfinish =
|
|
function () {
|
|
container.style.opacity = '1';
|
|
};
|
|
inner.animate({ transform: 'translateX(0%)' }, { duration: 200, easing: 'ease-out' }).onfinish = function () {
|
|
inner.style.transform = 'translateX(0%)';
|
|
};
|
|
container.onclick = function () {
|
|
container.animate({ opacity: '0' }, { duration: 200 }).onfinish =
|
|
function () {
|
|
container.style.opacity = '0';
|
|
};
|
|
inner.animate({ transform: 'translateX(100%)' }, { duration: 200, easing: 'ease-in' }).onfinish = function () {
|
|
inner.style.transform = 'translateX(100%)';
|
|
_this.mobileMenu = null;
|
|
container.remove();
|
|
};
|
|
};
|
|
inner.onclick = function (e) {
|
|
e.stopPropagation();
|
|
};
|
|
};
|
|
return ComponentMenuBar;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_MenuBar.ComponentMenuBar = ComponentMenuBar;
|
|
|
|
return Component_MenuBar;
|
|
}
|
|
|
|
var Component_PaletteCheckbox = {};
|
|
|
|
var hasRequiredComponent_PaletteCheckbox;
|
|
|
|
function requireComponent_PaletteCheckbox () {
|
|
if (hasRequiredComponent_PaletteCheckbox) return Component_PaletteCheckbox;
|
|
hasRequiredComponent_PaletteCheckbox = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_PaletteCheckbox, "__esModule", { value: true });
|
|
Component_PaletteCheckbox.ComponentPaletteCheckbox = void 0;
|
|
var Index_1 = requireIndex();
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var ComponentPaletteCheckbox = /** @class */ (function (_super) {
|
|
__extends(ComponentPaletteCheckbox, _super);
|
|
function ComponentPaletteCheckbox(options) {
|
|
var _a;
|
|
var _this = _super.call(this) || this;
|
|
_this.defaultView = 'recent_and_rest';
|
|
_this.lastChecked = [];
|
|
_this.recents = [];
|
|
_this.pid = options === null || options === void 0 ? void 0 : options.paletteUniqueIdentifier;
|
|
// if (pid != undefined && pid.length > 0)
|
|
// lastChecked = Validator.array(
|
|
// FieldStorage.getChannelValue('palette_checkbox', pid),
|
|
// []
|
|
// );
|
|
_this.container = (0, CE_1.ce)('div', ['mux_palette', 'mux_palette-checkboxes']);
|
|
_this.container.onclick = function () { return _this.close(); };
|
|
_this.inner = (0, CE_1.ce)('div', 'mux_palette-inner');
|
|
_this.inner.onclick = function (e) { return e.stopPropagation(); };
|
|
_this.results = (0, CE_1.ce)('div', ['mux_palette-results']);
|
|
_this.inner.appendChild(_this.results);
|
|
_this.container.appendChild(_this.inner);
|
|
if ((options === null || options === void 0 ? void 0 : options.title) != undefined && options.title.trim().length > 0) {
|
|
_this.showResultLabel(options.title);
|
|
}
|
|
((_a = options === null || options === void 0 ? void 0 : options.items) !== null && _a !== void 0 ? _a : []).forEach(function (item, i) {
|
|
return _this.renderSearchResult(item, i);
|
|
});
|
|
document.body.appendChild(_this.container);
|
|
setTimeout(function () {
|
|
_this.container.style.opacity = '1';
|
|
_this.inner.style.opacity = '1';
|
|
_this.inner.style.transform = 'scale(1)';
|
|
}, 20);
|
|
_this.registerKeyListener();
|
|
return _this;
|
|
}
|
|
ComponentPaletteCheckbox.prototype.close = function () {
|
|
var _this = this;
|
|
this.overwrite.close();
|
|
this.container.style.pointerEvents = 'none';
|
|
this.container.style.opacity = '0';
|
|
this.inner.style.opacity = '0';
|
|
this.inner.style.transform = 'scale(0.8)';
|
|
setTimeout(function () { return _this.destroy(); }, 400);
|
|
this.callEvent('close');
|
|
};
|
|
ComponentPaletteCheckbox.prototype.getChecked = function () {
|
|
var selected = Array.from(this.results.querySelectorAll('.mux_palette-results-item-checked')).map(function (item) {
|
|
return item.getAttribute('uid');
|
|
});
|
|
this.lastChecked = selected;
|
|
// FieldStorage.setChannelValue('palette_checkbox', this.pid, selected);
|
|
return selected;
|
|
};
|
|
ComponentPaletteCheckbox.prototype.renderSearchResult = function (result, index) {
|
|
var _this = this;
|
|
if (result.uniqueIdentifier == undefined)
|
|
throw new Error("Missing property 'uniqueIdentifier' inside one or more items of component 'PaletteCheckbox'");
|
|
var item = (0, CE_1.ce)('div', 'mux_palette-results-item', {
|
|
uid: result.uniqueIdentifier,
|
|
});
|
|
if (this.lastChecked.length == 0 && result.defaultValue == true)
|
|
item.classList.add('mux_palette-results-item-checked');
|
|
if (this.lastChecked.includes(result.uniqueIdentifier))
|
|
item.classList.add('mux_palette-results-item-checked');
|
|
if (index == 0)
|
|
item.classList.add('mux_palette-results-item-selected');
|
|
item.addEventListener('click', function () {
|
|
if (item.classList.contains('mux_palette-results-item-checked'))
|
|
item.classList.remove('mux_palette-results-item-checked');
|
|
else
|
|
item.classList.add('mux_palette-results-item-checked');
|
|
_this.getChecked();
|
|
});
|
|
var checkbox = (0, CE_1.ce)('div', 'mux_palette-results-item-checkbox');
|
|
checkbox.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'done'));
|
|
item.appendChild(checkbox);
|
|
if (result.materialIcon != undefined) {
|
|
var icon = (0, CE_1.ce)('div', 'material-symbols-outlined', null, result.materialIcon);
|
|
if (result.materialIconTransform != undefined)
|
|
icon.style.transform = result.materialIconTransform;
|
|
item.appendChild(icon);
|
|
}
|
|
else if (result.iconSrc != undefined)
|
|
item.appendChild((0, CE_1.ce)('img', 'mux_palette-results-item-icon', {
|
|
src: result.iconSrc,
|
|
}));
|
|
var text = (0, CE_1.ce)('div', [
|
|
'mux_palette-results-item-text',
|
|
'mux_text',
|
|
'mux_small',
|
|
]);
|
|
if (result.prefix != undefined)
|
|
text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.prefix.trim()));
|
|
text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-main', null, result.name.trim()));
|
|
if (result.suffix != undefined)
|
|
text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.suffix.trim()));
|
|
item.appendChild(text);
|
|
item.appendChild((0, CE_1.ce)('div', [
|
|
'mux_palette-results-item-selectedtext',
|
|
'mux_text',
|
|
'mux_tiny',
|
|
], null, '<space> to toggle'));
|
|
this.results.appendChild(item);
|
|
return item;
|
|
};
|
|
ComponentPaletteCheckbox.prototype.registerKeyListener = function () {
|
|
var _this = this;
|
|
this.overwrite = Index_1.MorphKey.createOverwrite();
|
|
this.overwrite.bind('Escape', function () { return _this.close(); });
|
|
this.overwrite.bind('Enter', function () {
|
|
var checked = _this.getChecked();
|
|
_this.callEvent('selected', checked);
|
|
_this.close();
|
|
});
|
|
this.overwrite.bind(' ', function () {
|
|
var selected = _this.getSelectedResult();
|
|
if (selected != null)
|
|
selected.click();
|
|
});
|
|
this.overwrite.bind('ArrowUp', function () {
|
|
var selected = _this.getSelectedResult();
|
|
if (selected != null &&
|
|
selected.previousElementSibling != null &&
|
|
selected.previousElementSibling.classList.contains('mux_palette-results-item')) {
|
|
selected.classList.remove('mux_palette-results-item-selected');
|
|
selected.previousElementSibling.classList.add('mux_palette-results-item-selected');
|
|
setTimeout(function () {
|
|
if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
|
|
selected.previousElementSibling.scrollIntoView({
|
|
behavior: 'auto',
|
|
block: 'center',
|
|
inline: 'center',
|
|
});
|
|
}, 50);
|
|
}
|
|
});
|
|
this.overwrite.bind('ArrowDown', function () {
|
|
var selected = _this.getSelectedResult();
|
|
if (selected != null &&
|
|
selected.nextElementSibling != null &&
|
|
selected.nextElementSibling.classList.contains('mux_palette-results-item')) {
|
|
selected.classList.remove('mux_palette-results-item-selected');
|
|
selected.nextElementSibling.classList.add('mux_palette-results-item-selected');
|
|
setTimeout(function () {
|
|
if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
|
|
selected.previousElementSibling.scrollIntoView({
|
|
behavior: 'auto',
|
|
block: 'center',
|
|
inline: 'center',
|
|
});
|
|
}, 50);
|
|
}
|
|
});
|
|
};
|
|
ComponentPaletteCheckbox.prototype.showResultLabel = function (text, materialIcon) {
|
|
var label = (0, CE_1.ce)('div', 'mux_palette-results-header');
|
|
if (materialIcon != undefined)
|
|
label.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, materialIcon));
|
|
label.appendChild((0, CE_1.ce)('span', null, null, text));
|
|
this.results.appendChild(label);
|
|
};
|
|
ComponentPaletteCheckbox.prototype.getSelectedResult = function () {
|
|
if (this.results == null)
|
|
return null;
|
|
return this.results.querySelector('.mux_palette-results-item-selected');
|
|
};
|
|
return ComponentPaletteCheckbox;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_PaletteCheckbox.ComponentPaletteCheckbox = ComponentPaletteCheckbox;
|
|
|
|
return Component_PaletteCheckbox;
|
|
}
|
|
|
|
var Component_PaletteSearch = {};
|
|
|
|
var hasRequiredComponent_PaletteSearch;
|
|
|
|
function requireComponent_PaletteSearch () {
|
|
if (hasRequiredComponent_PaletteSearch) return Component_PaletteSearch;
|
|
hasRequiredComponent_PaletteSearch = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
Object.defineProperty(Component_PaletteSearch, "__esModule", { value: true });
|
|
Component_PaletteSearch.ComponentPaletteSearch = void 0;
|
|
var Index_1 = requireIndex();
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var ComponentPaletteSearch = /** @class */ (function (_super) {
|
|
__extends(ComponentPaletteSearch, _super);
|
|
function ComponentPaletteSearch(options) {
|
|
var _a, _b, _c;
|
|
var _this = _super.call(this) || this;
|
|
_this.defaultView = 'recent_and_rest';
|
|
_this.recents = [];
|
|
_this.pid = options === null || options === void 0 ? void 0 : options.paletteUniqueIdentifier;
|
|
_this.defaultView = (_a = options === null || options === void 0 ? void 0 : options.defaultView) !== null && _a !== void 0 ? _a : 'recent_and_rest';
|
|
if ((_this.defaultView == 'recent' ||
|
|
_this.defaultView == 'recent_and_rest') &&
|
|
(_this.pid == undefined || _this.pid.trim().length == 0))
|
|
throw new Error("Property 'paletteUniqueIdentifier' is required in component 'PaletteSearch' to use recents.");
|
|
// if (pid != undefined && pid.length > 0)
|
|
// recents = Validator.array(
|
|
// FieldStorage.getChannelValue('palette_search', pid),
|
|
// []
|
|
// );
|
|
_this.container = (0, CE_1.ce)('div', 'mux_palette');
|
|
_this.container.onclick = function () { return _this.close(); };
|
|
_this.inner = (0, CE_1.ce)('div', 'mux_palette-inner');
|
|
_this.inner.onclick = function (e) { return e.stopPropagation(); };
|
|
var input = (0, CE_1.ce)('input', 'mux_palette-input', {
|
|
type: 'text',
|
|
placeholder: (_b = options === null || options === void 0 ? void 0 : options.placeholder) !== null && _b !== void 0 ? _b : 'Starting typing to search...',
|
|
});
|
|
input.oninput = function () { return _this.handleInputUpdate(input.value); };
|
|
_this.inner.appendChild(input);
|
|
_this.results = (0, CE_1.ce)('div', ['mux_palette-results']);
|
|
_this.inner.appendChild(_this.results);
|
|
_this.container.appendChild(_this.inner);
|
|
document.body.appendChild(_this.container);
|
|
_this.items = (_c = options === null || options === void 0 ? void 0 : options.items) !== null && _c !== void 0 ? _c : [];
|
|
_this.registerKeyListener();
|
|
_this.showDefaultView();
|
|
setTimeout(function () {
|
|
_this.container.style.opacity = '1';
|
|
_this.inner.style.opacity = '1';
|
|
_this.inner.style.transform = 'scale(1)';
|
|
input.focus();
|
|
}, 20);
|
|
return _this;
|
|
}
|
|
ComponentPaletteSearch.prototype.close = function () {
|
|
var _this = this;
|
|
this.overwrite.close();
|
|
this.container.style.pointerEvents = 'none';
|
|
this.container.style.opacity = '0';
|
|
this.inner.style.opacity = '0';
|
|
this.inner.style.transform = 'scale(0.8)';
|
|
setTimeout(function () { return _this.destroy(); }, 400);
|
|
this.callEvent('close');
|
|
};
|
|
ComponentPaletteSearch.prototype.registerKeyListener = function () {
|
|
var _this = this;
|
|
this.overwrite = Index_1.MorphKey.createOverwrite();
|
|
this.overwrite.bind('Escape', function () { return _this.close(); });
|
|
this.overwrite.bind('Enter', function () {
|
|
var selected = _this.getSelectedResult();
|
|
if (selected != null)
|
|
selected.click();
|
|
});
|
|
this.overwrite.bind('ArrowUp', function () {
|
|
var selected = _this.getSelectedResult();
|
|
if (selected != null &&
|
|
selected.previousElementSibling != null &&
|
|
selected.previousElementSibling.classList.contains('mux_palette-results-item')) {
|
|
selected.classList.remove('mux_palette-results-item-selected');
|
|
selected.previousElementSibling.classList.add('mux_palette-results-item-selected');
|
|
setTimeout(function () {
|
|
if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
|
|
selected.previousElementSibling.scrollIntoView({
|
|
behavior: 'auto',
|
|
block: 'center',
|
|
inline: 'center',
|
|
});
|
|
}, 50);
|
|
}
|
|
});
|
|
this.overwrite.bind('ArrowDown', function () {
|
|
var selected = _this.getSelectedResult();
|
|
if (selected != null &&
|
|
selected.nextElementSibling != null &&
|
|
selected.nextElementSibling.classList.contains('mux_palette-results-item')) {
|
|
selected.classList.remove('mux_palette-results-item-selected');
|
|
selected.nextElementSibling.classList.add('mux_palette-results-item-selected');
|
|
setTimeout(function () {
|
|
if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
|
|
selected.previousElementSibling.scrollIntoView({
|
|
behavior: 'auto',
|
|
block: 'center',
|
|
inline: 'center',
|
|
});
|
|
}, 50);
|
|
}
|
|
});
|
|
};
|
|
ComponentPaletteSearch.prototype.search = function (query) {
|
|
var tagwords = this.getTags(query);
|
|
var results = [];
|
|
for (var i = 0; i < this.items.length; i++) {
|
|
var item = this.items[i];
|
|
var score = this.getScore(tagwords, item.tags != undefined ? item.tags : this.getTags(item.name)) *
|
|
(item.scoreWeight != undefined && !isNaN(item.scoreWeight)
|
|
? item.scoreWeight
|
|
: 1);
|
|
if (score > 0)
|
|
results.push(__assign({ score: score }, item));
|
|
}
|
|
return results;
|
|
};
|
|
ComponentPaletteSearch.prototype.addToRecents = function (recentId) {
|
|
var newRecents = [];
|
|
__spreadArray([recentId], this.recents, true).forEach(function (id) {
|
|
if (!newRecents.includes(id))
|
|
newRecents.push(id);
|
|
});
|
|
if (newRecents.length > 5)
|
|
newRecents.splice(5, newRecents.length - 5);
|
|
this.recents = newRecents;
|
|
// FieldStorage.setChannelValue('palette_search', pid, this.recents);
|
|
};
|
|
ComponentPaletteSearch.prototype.renderSearchResult = function (result, index) {
|
|
var _this = this;
|
|
var item = (0, CE_1.ce)(result.href != undefined ? 'a' : 'div', 'mux_palette-results-item');
|
|
if (result.href != undefined)
|
|
item.href = result.href;
|
|
else if (result.click != undefined)
|
|
item.addEventListener('click', function () {
|
|
result.click();
|
|
_this.close();
|
|
});
|
|
if (this.pid != undefined &&
|
|
this.pid.length > 0 &&
|
|
(result.uniqueIdentifier != undefined || result.href != undefined)) {
|
|
item.addEventListener('click', function () {
|
|
var _a;
|
|
return _this.addToRecents((_a = result.uniqueIdentifier) !== null && _a !== void 0 ? _a : "address:".concat(result.href));
|
|
});
|
|
}
|
|
if (index == 0)
|
|
item.classList.add('mux_palette-results-item-selected');
|
|
if (result.materialIcon != undefined) {
|
|
var icon = (0, CE_1.ce)('span', 'material-symbols-outlined', null, result.materialIcon);
|
|
if (result.materialIconTransform != undefined)
|
|
icon.style.transform = result.materialIconTransform;
|
|
item.appendChild(icon);
|
|
}
|
|
else if (result.iconSrc != undefined)
|
|
item.appendChild((0, CE_1.ce)('img', 'mux_palette-results-item-icon', {
|
|
src: result.iconSrc,
|
|
}));
|
|
var text = (0, CE_1.ce)('div', [
|
|
'mux_palette-results-item-text',
|
|
'mux_text',
|
|
'mux_small',
|
|
]);
|
|
if (result.prefix != undefined)
|
|
text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.prefix.trim()));
|
|
text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-main', null, result.name.trim()));
|
|
if (result.suffix != undefined)
|
|
text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.suffix.trim()));
|
|
item.appendChild(text);
|
|
// if (result.selectedText != undefined) {
|
|
// item.appendChild(
|
|
// ce(
|
|
// 'div',
|
|
// ['mux_palette-results-item-selectedtext', 'mux_text', 'mux_tiny'],
|
|
// null,
|
|
// result.selectedText
|
|
// )
|
|
// );
|
|
// }
|
|
this.results.appendChild(item);
|
|
return item;
|
|
};
|
|
ComponentPaletteSearch.prototype.showDefaultView = function () {
|
|
var _this = this;
|
|
this.results.innerHTML = '';
|
|
switch (this.defaultView) {
|
|
case 'all':
|
|
this.items.forEach(function (item, i) {
|
|
return _this.renderSearchResult(item, i);
|
|
});
|
|
break;
|
|
case 'none':
|
|
return;
|
|
case 'recent_and_rest':
|
|
var recentItems = this.getRecentItems();
|
|
if (recentItems.length > 0)
|
|
this.showResultLabel('Recent actions', 'schedule');
|
|
recentItems.forEach(function (item, i) {
|
|
return _this.renderSearchResult(item, i);
|
|
});
|
|
var otherItems = this.items.filter(function (item) {
|
|
var _a;
|
|
if (item.uniqueIdentifier == undefined && item.href == null)
|
|
return true;
|
|
return !_this.recents.includes((_a = item.uniqueIdentifier) !== null && _a !== void 0 ? _a : "address:".concat(item.href));
|
|
});
|
|
if (otherItems.length > 0) {
|
|
otherItems.forEach(function (item, i) {
|
|
var itemElement = _this.renderSearchResult(item, i + recentItems.length);
|
|
if (i == 0 && recentItems.length > 0)
|
|
itemElement.classList.add('mux_palette-results-item-separator');
|
|
});
|
|
}
|
|
break;
|
|
case 'recent':
|
|
default:
|
|
this.showResultLabel('Recent actions', 'schedule');
|
|
this.getRecentItems().forEach(function (item, i) {
|
|
return _this.renderSearchResult(item, i);
|
|
});
|
|
break;
|
|
}
|
|
};
|
|
ComponentPaletteSearch.prototype.getRecentItems = function () {
|
|
if (this.recents == undefined || this.recents.length == 0)
|
|
return [];
|
|
var addressMap = new Map();
|
|
var uidMap = new Map();
|
|
this.items.forEach(function (item) {
|
|
if (item.uniqueIdentifier != undefined &&
|
|
item.uniqueIdentifier.trim().length > 0)
|
|
uidMap.set(item.uniqueIdentifier.trim(), item);
|
|
if (item.href != undefined && item.href.trim().length > 0)
|
|
addressMap.set(item.href.trim(), item);
|
|
});
|
|
var recentItems = [];
|
|
this.recents.forEach(function (recentId) {
|
|
if (recentId.startsWith('address:')) {
|
|
if (addressMap.has(recentId.replace('address:', '')))
|
|
recentItems.push(addressMap.get(recentId.replace('address:', '')));
|
|
}
|
|
else {
|
|
if (uidMap.has(recentId))
|
|
recentItems.push(uidMap.get(recentId));
|
|
}
|
|
});
|
|
return recentItems;
|
|
};
|
|
ComponentPaletteSearch.prototype.handleInputUpdate = function (value) {
|
|
var _this = this;
|
|
if (value.trim().length < 1)
|
|
return this.showDefaultView();
|
|
this.results.innerHTML = '';
|
|
var searchresults = this.search(value.trim());
|
|
if (searchresults.length == 0)
|
|
return this.showResultLabel('No results based on your search query.', 'warning');
|
|
searchresults
|
|
.sort(function (a, b) {
|
|
return b.score - a.score;
|
|
})
|
|
.forEach(function (result, index) { return _this.renderSearchResult(result, index); });
|
|
};
|
|
ComponentPaletteSearch.prototype.showResultLabel = function (text, materialIcon) {
|
|
var label = (0, CE_1.ce)('div', 'mux_palette-results-label');
|
|
if (materialIcon != undefined)
|
|
label.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, materialIcon));
|
|
label.appendChild((0, CE_1.ce)('span', null, null, text));
|
|
this.results.appendChild(label);
|
|
};
|
|
ComponentPaletteSearch.prototype.getSelectedResult = function () {
|
|
if (this.results == null)
|
|
return null;
|
|
return this.results.querySelector('.mux_palette-results-item-selected');
|
|
};
|
|
ComponentPaletteSearch.prototype.getScore = function (queryWords, tagWords) {
|
|
var score = 0;
|
|
var _loop_1 = function (i) {
|
|
tagWords.forEach(function (tagWord) {
|
|
if (tagWord.includes(queryWords[i])) {
|
|
score += tagWord.startsWith(queryWords[i]) ? 2 : 1;
|
|
}
|
|
});
|
|
};
|
|
for (var i = 0; i < queryWords.length; i++) {
|
|
_loop_1(i);
|
|
}
|
|
return score;
|
|
};
|
|
ComponentPaletteSearch.prototype.getTags = function (query) {
|
|
var tags = [];
|
|
query
|
|
.toLowerCase()
|
|
.split(' ')
|
|
.map(function (word) {
|
|
return word.trim();
|
|
})
|
|
.filter(function (word) {
|
|
return word.length > 0;
|
|
})
|
|
.forEach(function (tag) {
|
|
if (!tags.includes(tag))
|
|
tags.push(tag);
|
|
});
|
|
return tags;
|
|
};
|
|
return ComponentPaletteSearch;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_PaletteSearch.ComponentPaletteSearch = ComponentPaletteSearch;
|
|
|
|
return Component_PaletteSearch;
|
|
}
|
|
|
|
var Component_Resizer = {};
|
|
|
|
var __extends$2 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Resizer, "__esModule", { value: true });
|
|
Component_Resizer.ComponentResizer = void 0;
|
|
var CE_1$2 = CE;
|
|
var baseComponent_1$2 = baseComponent;
|
|
var ComponentResizer = /** @class */ (function (_super) {
|
|
__extends$2(ComponentResizer, _super);
|
|
function ComponentResizer(options) {
|
|
var _a, _b, _c;
|
|
var _this = _super.call(this) || this;
|
|
_this.startPoint = null;
|
|
_this.startSize = null;
|
|
_this.preMove = true;
|
|
_this.moveEvent = function (e) {
|
|
_this.handleMove(e);
|
|
};
|
|
_this.touchEndEvent = function (e) {
|
|
_this.stopResize();
|
|
};
|
|
_this.direction = (_a = options === null || options === void 0 ? void 0 : options.direction) !== null && _a !== void 0 ? _a : 'right';
|
|
_this.closeable = (_b = options === null || options === void 0 ? void 0 : options.closeable) !== null && _b !== void 0 ? _b : false;
|
|
_this.min = options === null || options === void 0 ? void 0 : options.min;
|
|
_this.max = options === null || options === void 0 ? void 0 : options.max;
|
|
_this.relative = (_c = options === null || options === void 0 ? void 0 : options.relative) !== null && _c !== void 0 ? _c : false;
|
|
_this.container = (0, CE_1$2.ce)('div', 'mux_resizer');
|
|
var area = (0, CE_1$2.ce)('div', 'mux_resizer-area');
|
|
var grab = (0, CE_1$2.ce)('div', 'mux_resizer-grab');
|
|
var grabHandle = (0, CE_1$2.ce)('span', ['material-symbols-outlined', 'mux_resizer-grab-handle'], null, 'drag_handle');
|
|
if (options.direction == 'left' || options.direction == 'right')
|
|
grabHandle.style.transform = 'rotate(90deg)';
|
|
grab.appendChild(grabHandle);
|
|
var grabOpen = (0, CE_1$2.ce)('span', ['material-symbols-outlined', 'mux_resizer-grab-open'], null, {
|
|
left: 'arrow_left',
|
|
right: 'arrow_right',
|
|
up: 'arrow_drop_up',
|
|
down: 'arrow_drop_down',
|
|
}[_this.direction]);
|
|
grab.appendChild(grabOpen);
|
|
area.appendChild(grab);
|
|
if ((options === null || options === void 0 ? void 0 : options.existingContainer) != undefined) {
|
|
if (!options.existingContainer.classList.contains('mux_resizer'))
|
|
throw new Error('Container of registered resizer does not contain mux_resizer classname');
|
|
_this.container = options.existingContainer;
|
|
if (_this.container.querySelector('.mux_resizer-area') != null) {
|
|
var existingArea = _this.container.querySelector('.mux_resizer-area');
|
|
_this.container.removeChild(existingArea);
|
|
}
|
|
}
|
|
_this.container.appendChild(area);
|
|
_this.container.classList.add("mux_resizer-direction-".concat(_this.direction));
|
|
_this.currentSize =
|
|
_this.direction == 'left' || _this.direction == 'right'
|
|
? _this.container.clientWidth
|
|
: _this.container.clientHeight;
|
|
area.addEventListener('mousedown', function (e) { return _this.startResize(e); });
|
|
area.addEventListener('touchstart', function (e) { return _this.startResize(e); });
|
|
grab.addEventListener('mousedown', function (e) { return _this.startResize(e); });
|
|
area.addEventListener('touchstart', function (e) { return _this.startResize(e); });
|
|
grab.addEventListener('click', function () {
|
|
if (!_this.container.classList.contains('mux_resizer-closed'))
|
|
return;
|
|
var size = typeof _this.min === 'function' ? _this.min() : _this.min;
|
|
if (_this.direction == 'left' || _this.direction == 'right')
|
|
_this.container.style.width = _this.toSize(size);
|
|
else if (_this.direction == 'up' || _this.direction == 'down')
|
|
_this.container.style.height = _this.toSize(size);
|
|
_this.currentSize = size;
|
|
_this.callEvent('resized', size);
|
|
_this.container.classList.remove('mux_resizer-closed');
|
|
});
|
|
if (!_this.relative)
|
|
window.addEventListener('resize', function () {
|
|
_this.setSize(_this.currentSize);
|
|
});
|
|
return _this;
|
|
}
|
|
ComponentResizer.prototype.toSize = function (value) {
|
|
if (!this.relative)
|
|
return "".concat(value, "px");
|
|
var parentSize = this.direction == 'left' || this.direction == 'right'
|
|
? this.container.parentElement.clientWidth
|
|
: this.container.parentElement.clientHeight;
|
|
var percent = (value / parentSize) * 100;
|
|
return "".concat(percent, "%");
|
|
};
|
|
ComponentResizer.prototype.setSize = function (size) {
|
|
var value = this.parseNewValue(size);
|
|
if (this.direction == 'left' || this.direction == 'right')
|
|
this.container.style.width = this.toSize(value);
|
|
else if (this.direction == 'up' || this.direction == 'down')
|
|
this.container.style.height = this.toSize(value);
|
|
this.currentSize = value;
|
|
this.callEvent('resized', value);
|
|
};
|
|
ComponentResizer.prototype.getSize = function () {
|
|
return this.currentSize;
|
|
};
|
|
ComponentResizer.prototype.parseNewValue = function (value) {
|
|
var _min = typeof this.min === 'function' ? this.min() : this.min;
|
|
var _max = typeof this.max === 'function' ? this.max() : this.max;
|
|
value >= _min
|
|
? this.container.classList.remove('mux_resizer-block')
|
|
: this.container.classList.add('mux_resizer-block');
|
|
if (_min >= 0) {
|
|
if (this.closeable == true && value < _min * 0.5) {
|
|
this.container.classList.add('mux_resizer-closed');
|
|
this.callEvent('resized', 0);
|
|
return 0;
|
|
}
|
|
else
|
|
value = Math.max(_min, value);
|
|
}
|
|
if (_max > 0)
|
|
value = Math.min(_max, value);
|
|
this.container.classList.remove('mux_resizer-closed');
|
|
return value;
|
|
};
|
|
ComponentResizer.prototype.startResize = function (e) {
|
|
var _a = this.pageCoords(e), x = _a.x, y = _a.y;
|
|
var bounds = this.container.getBoundingClientRect();
|
|
if (this.direction == 'left' || this.direction == 'right') {
|
|
this.startPoint = x;
|
|
this.startSize = bounds.width;
|
|
}
|
|
else if (this.direction == 'up' || this.direction == 'down') {
|
|
this.startPoint = y;
|
|
this.startSize = bounds.height;
|
|
}
|
|
window.addEventListener('mousemove', this.moveEvent);
|
|
window.addEventListener('touchmove', this.moveEvent);
|
|
window.addEventListener('touchend', this.touchEndEvent);
|
|
};
|
|
ComponentResizer.prototype.stopResize = function () {
|
|
this.startPoint = null;
|
|
this.startSize = null;
|
|
this.preMove = true;
|
|
this.container.classList.remove('mux_resizer-moving');
|
|
window.removeEventListener('mousemove', this.moveEvent);
|
|
window.removeEventListener('touchmove', this.moveEvent);
|
|
window.removeEventListener('touchend', this.touchEndEvent);
|
|
};
|
|
ComponentResizer.prototype.handleMove = function (e) {
|
|
var _a, _b, _c;
|
|
if (((_a = e === null || e === void 0 ? void 0 : e.buttons) !== null && _a !== void 0 ? _a : 1) != 1 ||
|
|
((_c = (_b = e === null || e === void 0 ? void 0 : e.touches) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 1) == 0 ||
|
|
this.startPoint == null ||
|
|
this.startSize == null) {
|
|
this.stopResize();
|
|
return;
|
|
}
|
|
var _d = this.pageCoords(e), x = _d.x, y = _d.y;
|
|
if (this.preMove) {
|
|
var startSpan = Math.abs(this.startPoint -
|
|
(this.direction == 'left' || this.direction == 'right'
|
|
? x
|
|
: y));
|
|
if (startSpan >= 10) {
|
|
this.preMove = false;
|
|
this.container.classList.add('mux_resizer-moving');
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
var value = null;
|
|
if (this.direction == 'left' || this.direction == 'right') {
|
|
value = this.parseNewValue(this.startSize +
|
|
(this.direction == 'left'
|
|
? this.startPoint - x
|
|
: x - this.startPoint));
|
|
this.container.style.width = this.toSize(value);
|
|
}
|
|
else if (this.direction == 'up' || this.direction == 'down') {
|
|
value = this.parseNewValue(this.startSize +
|
|
(this.direction == 'up'
|
|
? this.startPoint - y
|
|
: y - this.startPoint));
|
|
this.container.style.height = this.toSize(value);
|
|
}
|
|
this.currentSize = value;
|
|
this.callEvent('resized', value);
|
|
};
|
|
ComponentResizer.prototype.pageCoords = function (e) {
|
|
var _a, _b, _c, _d;
|
|
return {
|
|
x: (_a = e.pageX) !== null && _a !== void 0 ? _a : (_b = e.touches[0]) === null || _b === void 0 ? void 0 : _b.pageX,
|
|
y: (_c = e.pageY) !== null && _c !== void 0 ? _c : (_d = e.touches[0]) === null || _d === void 0 ? void 0 : _d.pageY,
|
|
};
|
|
};
|
|
return ComponentResizer;
|
|
}(baseComponent_1$2.MUXComponent));
|
|
Component_Resizer.ComponentResizer = ComponentResizer;
|
|
|
|
var Component_Row = {};
|
|
|
|
var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Row, "__esModule", { value: true });
|
|
Component_Row.ComponentRow = void 0;
|
|
var CE_1$1 = CE;
|
|
var baseComponent_1$1 = baseComponent;
|
|
var ComponentRow = /** @class */ (function (_super) {
|
|
__extends$1(ComponentRow, _super);
|
|
function ComponentRow(options) {
|
|
var _this = _super.call(this) || this;
|
|
_this.container = (0, CE_1$1.ce)('div', 'mux_row');
|
|
if ((options === null || options === void 0 ? void 0 : options.spreadEven) == true)
|
|
_this.container.classList.add('mux_spread');
|
|
if ((options === null || options === void 0 ? void 0 : options.indent) == true)
|
|
_this.container.classList.add('mux_indent');
|
|
if ((options === null || options === void 0 ? void 0 : options.disabled) == true)
|
|
_this.container.classList.add('mux_disabled');
|
|
if ((options === null || options === void 0 ? void 0 : options.tooltip) != undefined)
|
|
_this.container.title = options.tooltip;
|
|
_this.content = (0, CE_1$1.ce)('div', 'mux_row-content');
|
|
var label = (0, CE_1$1.ce)('div', ['mux_row-label', 'mux_text'], null, options.label);
|
|
if ((options === null || options === void 0 ? void 0 : options.layout) != undefined && options.layout == 'valueFirst') {
|
|
_this.container.appendChild(_this.content);
|
|
_this.container.appendChild(label);
|
|
}
|
|
else {
|
|
_this.container.appendChild(label);
|
|
_this.container.appendChild(_this.content);
|
|
}
|
|
if (options.content != undefined)
|
|
_this.content.appendChild(options.content);
|
|
return _this;
|
|
}
|
|
ComponentRow.prototype.setEnabled = function (state) {
|
|
if (state)
|
|
this.container.classList.remove('mux_disabled');
|
|
else
|
|
this.container.classList.add('mux_disabled');
|
|
};
|
|
ComponentRow.prototype.setTooltip = function (tooltip) {
|
|
if (tooltip == null)
|
|
this.container.removeAttribute('title');
|
|
else
|
|
this.container.title = tooltip;
|
|
};
|
|
return ComponentRow;
|
|
}(baseComponent_1$1.MUXComponent));
|
|
Component_Row.ComponentRow = ComponentRow;
|
|
|
|
var Component_Select = {};
|
|
|
|
var hasRequiredComponent_Select;
|
|
|
|
function requireComponent_Select () {
|
|
if (hasRequiredComponent_Select) return Component_Select;
|
|
hasRequiredComponent_Select = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Select, "__esModule", { value: true });
|
|
Component_Select.ComponentSelect = void 0;
|
|
var Index_1 = requireIndex();
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var ComponentSelect = /** @class */ (function (_super) {
|
|
__extends(ComponentSelect, _super);
|
|
function ComponentSelect(options) {
|
|
var _a, _b, _c;
|
|
var _this = _super.call(this) || this;
|
|
_this.show = 'name';
|
|
_this.show = (_a = options.show) !== null && _a !== void 0 ? _a : 'name';
|
|
_this.container = (0, CE_1.ce)('div', 'mux_select');
|
|
var border = (_b = options.border) !== null && _b !== void 0 ? _b : 'hover';
|
|
if (border == 'always')
|
|
_this.container.classList.add('mux_select-alwaysborder');
|
|
else if (border == 'never')
|
|
_this.container.classList.add('mux_select-noborder');
|
|
_this.input = new Index_1.MorphComponent.Input({
|
|
type: 'text',
|
|
border: 'never',
|
|
});
|
|
_this.input.container.onkeydown = function (e) {
|
|
e.preventDefault();
|
|
};
|
|
_this.container.appendChild(_this.input.container);
|
|
_this.content = (0, CE_1.ce)('div', 'mux_select-content');
|
|
_this.container.appendChild(_this.content);
|
|
_this.container.appendChild((0, CE_1.ce)('span', ['material-symbols-outlined', 'mux_select-arrow'], null, 'keyboard_arrow_down'));
|
|
_this.input.container.onfocus = function () {
|
|
_this.input.container.blur();
|
|
_this.toggleContext();
|
|
};
|
|
_this.input.container.onblur = function () {
|
|
_this.context.close('selectblur');
|
|
};
|
|
_this.container.onclick = function () { return _this.toggleContext(); };
|
|
_this.items = (_c = options === null || options === void 0 ? void 0 : options.items) !== null && _c !== void 0 ? _c : [];
|
|
_this.select(options.selectedId, false);
|
|
return _this;
|
|
}
|
|
ComponentSelect.prototype.setItems = function (items) {
|
|
this.items = items;
|
|
};
|
|
ComponentSelect.prototype.select = function (id, dispatchEvent) {
|
|
var _a;
|
|
if (dispatchEvent === void 0) { dispatchEvent = true; }
|
|
var item = this.items.find(function (i) {
|
|
if (i.type == 'separator')
|
|
return false;
|
|
return i.id == id;
|
|
});
|
|
this.selectedId = id;
|
|
this.content.innerHTML = '';
|
|
if (item == null) {
|
|
this.content.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_small', 'mux_select-none'], null, 'None selected'));
|
|
return;
|
|
}
|
|
if (item.materialIcon != undefined) {
|
|
var materialIcon = (0, CE_1.ce)('span', 'material-symbols-outlined', null, item.materialIcon);
|
|
if (item.materialIconTransform != undefined)
|
|
materialIcon.style.transform = item.materialIconTransform;
|
|
this.content.appendChild(materialIcon);
|
|
}
|
|
else if (item.icon != undefined) {
|
|
this.content.appendChild((0, CE_1.ce)('img', 'mux_select-content-icon', { src: item.icon }));
|
|
}
|
|
this.content.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_small'], null, (_a = item.text) !== null && _a !== void 0 ? _a : item.id));
|
|
if (dispatchEvent)
|
|
this.callEvent('input', id);
|
|
};
|
|
ComponentSelect.prototype.setSelected = function (id) {
|
|
this.select(id, false);
|
|
};
|
|
ComponentSelect.prototype.getSelected = function () {
|
|
return this.selectedId;
|
|
};
|
|
ComponentSelect.prototype.toggleContext = function () {
|
|
var _this = this;
|
|
if (this.context != null) {
|
|
return this.context.close('selecttoggle');
|
|
}
|
|
var bounds = this.container.getBoundingClientRect();
|
|
this.context = new Index_1.MorphComponent.ContextMenu({
|
|
x: bounds.x + bounds.width / 2,
|
|
y: bounds.y + bounds.height,
|
|
align: 'center',
|
|
selected: this.selectedId,
|
|
items: this.items.map(function (item) {
|
|
var _a, _b;
|
|
if (item.type == 'separator') {
|
|
return { type: 'separator' };
|
|
}
|
|
return {
|
|
type: (_a = item.type) !== null && _a !== void 0 ? _a : 'normal',
|
|
uniqueIdentifier: item.id,
|
|
text: (_b = item.text) !== null && _b !== void 0 ? _b : item.id,
|
|
materialIcon: item.materialIcon,
|
|
materialIconTransform: item.materialIconTransform,
|
|
icon: item.icon,
|
|
click: function () {
|
|
_this.select(item.id, true);
|
|
},
|
|
};
|
|
}),
|
|
});
|
|
this.container.classList.add('mux_select-open');
|
|
this.context.on('close', function () {
|
|
_this.container.classList.remove('mux_select-open');
|
|
_this.context = null;
|
|
});
|
|
};
|
|
return ComponentSelect;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_Select.ComponentSelect = ComponentSelect;
|
|
|
|
return Component_Select;
|
|
}
|
|
|
|
var Component_Table = {};
|
|
|
|
var Component_Table_Button = {};
|
|
|
|
var Component_Table__base = {};
|
|
|
|
Object.defineProperty(Component_Table__base, "__esModule", { value: true });
|
|
Component_Table__base.ComponentTable_Base = void 0;
|
|
var ComponentTable_Base = /** @class */ (function () {
|
|
function ComponentTable_Base() {
|
|
}
|
|
ComponentTable_Base.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
return null;
|
|
};
|
|
return ComponentTable_Base;
|
|
}());
|
|
Component_Table__base.ComponentTable_Base = ComponentTable_Base;
|
|
|
|
var hasRequiredComponent_Table_Button;
|
|
|
|
function requireComponent_Table_Button () {
|
|
if (hasRequiredComponent_Table_Button) return Component_Table_Button;
|
|
hasRequiredComponent_Table_Button = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table_Button, "__esModule", { value: true });
|
|
Component_Table_Button.ComponentTable_Button = void 0;
|
|
var Index_1 = requireIndex();
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_Button = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_Button, _super);
|
|
function ComponentTable_Button() {
|
|
return _super.call(this) || this;
|
|
}
|
|
ComponentTable_Button.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var container = (0, Index_1.ce)('div', ['mux_table-button']);
|
|
var btn = (0, Index_1.ce)('div', [
|
|
'mux_table-button-btn',
|
|
'mux_text',
|
|
'mux_small',
|
|
"mux_table-button-btn-".concat(encodeURI(cell.text)),
|
|
], { title: cell.tooltip }, cell.text);
|
|
btn.onclick = function (e) {
|
|
e.stopPropagation();
|
|
component.callEvent('buttonClick', rowId, column.uniqueIdentifier);
|
|
};
|
|
container.appendChild(btn);
|
|
return container;
|
|
};
|
|
return ComponentTable_Button;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_Button.ComponentTable_Button = ComponentTable_Button;
|
|
|
|
return Component_Table_Button;
|
|
}
|
|
|
|
var Component_Table_Duration = {};
|
|
|
|
var Component_Table_Text = {};
|
|
|
|
var hasRequiredComponent_Table_Text;
|
|
|
|
function requireComponent_Table_Text () {
|
|
if (hasRequiredComponent_Table_Text) return Component_Table_Text;
|
|
hasRequiredComponent_Table_Text = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table_Text, "__esModule", { value: true });
|
|
Component_Table_Text.ComponentTable_Text = void 0;
|
|
var Index_1 = requireIndex();
|
|
var TextHighlighter_1 = TextHighlighter;
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_Text = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_Text, _super);
|
|
function ComponentTable_Text(allowHighlighting) {
|
|
var _this = _super.call(this) || this;
|
|
_this.allowHighlighting = allowHighlighting;
|
|
return _this;
|
|
}
|
|
ComponentTable_Text.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
if (asNumber === void 0) { asNumber = false; }
|
|
var wrapper = (0, Index_1.ce)('div', 'mux_table-wrapper');
|
|
var container = (0, Index_1.ce)('div', 'mux_table-text', {
|
|
title: (_a = cell === null || cell === void 0 ? void 0 : cell.tooltip) !== null && _a !== void 0 ? _a : '',
|
|
});
|
|
var text = this.allowHighlighting
|
|
? (0, TextHighlighter_1.generateTextHighlights)(String(cell.value).trim())
|
|
: (0, Index_1.ce)('div', ['mux_text', 'mux_small'], null, "".concat((_b = cell.prefix) !== null && _b !== void 0 ? _b : '', " ").concat(cell.value).trim());
|
|
text.prepend((0, Index_1.ce)('span', null, null, cell.prefix));
|
|
text.style.justifyContent = {
|
|
left: 'flex-Start',
|
|
right: 'flex-end',
|
|
center: 'center',
|
|
}[(_c = cell.align) !== null && _c !== void 0 ? _c : 'left'];
|
|
var editonly = column.editonly;
|
|
container.appendChild(text);
|
|
if (column.editable) {
|
|
var inputContainer = (0, Index_1.ce)('div', 'mux_table-edit-input');
|
|
var inputPrefix = (0, Index_1.ce)('div', ['mux_text', 'mux_small', 'mux_table-edit-input-prefix'], null, (_d = cell.prefix) !== null && _d !== void 0 ? _d : '');
|
|
var input = new Index_1.MorphComponent.Input({
|
|
type: 'text',
|
|
value: String((_e = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _e !== void 0 ? _e : '').trim(),
|
|
border: 'always',
|
|
});
|
|
if (editonly)
|
|
input.on('input', function () {
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, !asNumber
|
|
? input.container.value
|
|
: parseFloat(input.container.value));
|
|
});
|
|
input.container.style.textAlign = (_f = cell.align) !== null && _f !== void 0 ? _f : 'left';
|
|
inputContainer.appendChild(inputPrefix);
|
|
inputContainer.appendChild(input.container);
|
|
container.appendChild(inputContainer);
|
|
container.style.cursor = 'pointer';
|
|
var hasFirst = false;
|
|
var clickTimeout;
|
|
container.onclick = function () {
|
|
clearTimeout(clickTimeout);
|
|
if (hasFirst == false) {
|
|
hasFirst = true;
|
|
clickTimeout = setTimeout(function () {
|
|
hasFirst = false;
|
|
}, 1000);
|
|
}
|
|
else {
|
|
openEdit();
|
|
hasFirst = false;
|
|
}
|
|
};
|
|
var openEdit = function () {
|
|
text.style.display = 'none';
|
|
inputContainer.style.display = 'flex';
|
|
input.container.focus();
|
|
input.container.setSelectionRange(input.container.value.length, input.container.value.length);
|
|
var initValue = input.container.value;
|
|
var close = function () {
|
|
if (editonly)
|
|
return;
|
|
window.removeEventListener('click', onclick);
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, !asNumber
|
|
? input.container.value
|
|
: parseFloat(input.container.value));
|
|
text.innerText = input.container.value;
|
|
text.style.display = 'flex';
|
|
inputContainer.style.display = 'none';
|
|
};
|
|
input.container.onkeydown = function (e) {
|
|
if (editonly)
|
|
return;
|
|
if (e.key == 'Enter')
|
|
close();
|
|
else if (e.key == 'Escape') {
|
|
input.container.value = initValue;
|
|
text.innerText = input.container.value;
|
|
close();
|
|
}
|
|
};
|
|
if (!editonly) {
|
|
var onclick = function (e) {
|
|
if (e.target == undefined ||
|
|
e.target != input.container)
|
|
close();
|
|
};
|
|
setTimeout(function () { return window.addEventListener('click', onclick); }, 100);
|
|
}
|
|
};
|
|
if (editonly)
|
|
openEdit();
|
|
}
|
|
wrapper.appendChild(container);
|
|
if (cell.subText != undefined) {
|
|
wrapper.appendChild((0, Index_1.ce)('div', ['mux_text', 'mux_tiny', 'mux_table-subtext'], null, cell.subText.trim()));
|
|
}
|
|
return wrapper;
|
|
};
|
|
return ComponentTable_Text;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_Text.ComponentTable_Text = ComponentTable_Text;
|
|
|
|
return Component_Table_Text;
|
|
}
|
|
|
|
var hasRequiredComponent_Table_Duration;
|
|
|
|
function requireComponent_Table_Duration () {
|
|
if (hasRequiredComponent_Table_Duration) return Component_Table_Duration;
|
|
hasRequiredComponent_Table_Duration = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table_Duration, "__esModule", { value: true });
|
|
Component_Table_Duration.ComponentTable_Duration = void 0;
|
|
var Component_Table_Text_1 = requireComponent_Table_Text();
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_Duration = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_Duration, _super);
|
|
function ComponentTable_Duration() {
|
|
var _this = _super.call(this) || this;
|
|
_this._text = new Component_Table_Text_1.ComponentTable_Text(false);
|
|
return _this;
|
|
}
|
|
ComponentTable_Duration.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var element = this._text.createElement(cell, rowId, column, component, true);
|
|
var elementText = element.querySelector('.mux_text');
|
|
if (elementText != null)
|
|
elementText.style.justifyContent = 'center';
|
|
element.classList.add('mux_table-duration');
|
|
var input = element.querySelector('input');
|
|
var regex = /^[0-9.]+$/;
|
|
element.addEventListener('input', function () {
|
|
var currentValue = input.value;
|
|
if (!regex.test(currentValue)) {
|
|
input.value = currentValue.slice(0, -1);
|
|
}
|
|
});
|
|
return element;
|
|
};
|
|
return ComponentTable_Duration;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_Duration.ComponentTable_Duration = ComponentTable_Duration;
|
|
|
|
return Component_Table_Duration;
|
|
}
|
|
|
|
var Component_Table_Icons = {};
|
|
|
|
var hasRequiredComponent_Table_Icons;
|
|
|
|
function requireComponent_Table_Icons () {
|
|
if (hasRequiredComponent_Table_Icons) return Component_Table_Icons;
|
|
hasRequiredComponent_Table_Icons = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table_Icons, "__esModule", { value: true });
|
|
Component_Table_Icons.ComponentTable_Icons = void 0;
|
|
var Index_1 = requireIndex();
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_Icons = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_Icons, _super);
|
|
function ComponentTable_Icons() {
|
|
return _super.call(this) || this;
|
|
}
|
|
ComponentTable_Icons.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var _a;
|
|
var container = (0, Index_1.ce)('div', ['mux_table-icons']);
|
|
((_a = cell === null || cell === void 0 ? void 0 : cell.items) !== null && _a !== void 0 ? _a : []).forEach(function (item) {
|
|
var itemElement = (0, Index_1.ce)('div', 'mux_table-icon');
|
|
itemElement.appendChild((0, Index_1.ce)('span', 'material-symbols-outlined', null, item.materialIcon));
|
|
if (item.color != undefined)
|
|
itemElement.style.color = item.color;
|
|
itemElement.onclick = function (e) {
|
|
e.stopPropagation();
|
|
item.click();
|
|
};
|
|
container.appendChild(itemElement);
|
|
});
|
|
return container;
|
|
};
|
|
return ComponentTable_Icons;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_Icons.ComponentTable_Icons = ComponentTable_Icons;
|
|
|
|
return Component_Table_Icons;
|
|
}
|
|
|
|
var Component_Table_MaterialSymbol = {};
|
|
|
|
var hasRequiredComponent_Table_MaterialSymbol;
|
|
|
|
function requireComponent_Table_MaterialSymbol () {
|
|
if (hasRequiredComponent_Table_MaterialSymbol) return Component_Table_MaterialSymbol;
|
|
hasRequiredComponent_Table_MaterialSymbol = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table_MaterialSymbol, "__esModule", { value: true });
|
|
Component_Table_MaterialSymbol.ComponentTable_MaterialSymbol = void 0;
|
|
var Index_1 = requireIndex();
|
|
var TextHighlighter_1 = TextHighlighter;
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_MaterialSymbol = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_MaterialSymbol, _super);
|
|
function ComponentTable_MaterialSymbol() {
|
|
return _super.call(this) || this;
|
|
}
|
|
ComponentTable_MaterialSymbol.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var _a, _b, _c, _d;
|
|
if (asNumber === void 0) { asNumber = false; }
|
|
var wrapper = (0, Index_1.ce)('div', 'mux_table-wrapper');
|
|
var container = (0, Index_1.ce)('div', 'mux_table-text', {
|
|
title: (_a = cell === null || cell === void 0 ? void 0 : cell.tooltip) !== null && _a !== void 0 ? _a : '',
|
|
});
|
|
var text = this.allowHighlighting
|
|
? (0, TextHighlighter_1.generateTextHighlights)(String(cell.materialIcon).trim())
|
|
: (0, Index_1.ce)('span', ['material-symbols-outlined', 'g_text'], null, cell.materialIcon);
|
|
text.style.justifyContent = {
|
|
left: 'flex-Start',
|
|
right: 'flex-end',
|
|
center: 'center',
|
|
}[(_b = cell.align) !== null && _b !== void 0 ? _b : 'left'];
|
|
container.appendChild(text);
|
|
if (column.editable) {
|
|
var inputContainer = (0, Index_1.ce)('div', 'mux_table-edit-input');
|
|
var input = (0, Index_1.ce)('input', null, {
|
|
type: 'text',
|
|
value: String((_c = cell === null || cell === void 0 ? void 0 : cell.materialIcon) !== null && _c !== void 0 ? _c : '').trim(),
|
|
});
|
|
input.style.textAlign = (_d = cell.align) !== null && _d !== void 0 ? _d : 'left';
|
|
inputContainer.appendChild(input);
|
|
container.appendChild(inputContainer);
|
|
container.style.cursor = 'pointer';
|
|
var hasFirst = false;
|
|
var clickTimeout;
|
|
container.onclick = function () {
|
|
clearTimeout(clickTimeout);
|
|
if (hasFirst == false) {
|
|
hasFirst = true;
|
|
clickTimeout = setTimeout(function () {
|
|
hasFirst = false;
|
|
}, 1000);
|
|
}
|
|
else {
|
|
openEdit();
|
|
hasFirst = false;
|
|
}
|
|
};
|
|
var openEdit = function () {
|
|
text.style.display = 'none';
|
|
inputContainer.style.display = 'flex';
|
|
input.focus();
|
|
input.setSelectionRange(input.value.length, input.value.length);
|
|
var initValue = input.value;
|
|
var close = function () {
|
|
window.removeEventListener('click', onclick);
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, !asNumber ? input.value : parseFloat(input.value));
|
|
text.innerText = input.value;
|
|
text.style.display = 'flex';
|
|
inputContainer.style.display = 'none';
|
|
};
|
|
input.onkeydown = function (e) {
|
|
if (e.key == 'Enter')
|
|
close();
|
|
else if (e.key == 'Escape') {
|
|
input.value = initValue;
|
|
text.innerText = input.value;
|
|
close();
|
|
}
|
|
};
|
|
var onclick = function (e) {
|
|
if (e.target == undefined || e.target != input)
|
|
close();
|
|
};
|
|
setTimeout(function () { return window.addEventListener('click', onclick); }, 100);
|
|
};
|
|
}
|
|
wrapper.appendChild(container);
|
|
// if (cell.materialIcon != undefined) {
|
|
// wrapper.appendChild(
|
|
// ce(
|
|
// 'div',
|
|
// ['mux_text', 'mux_tiny', 'mux_table-subtext'],
|
|
// null,
|
|
// cell.subMaterialSymbol.trim()
|
|
// )
|
|
// );
|
|
// }
|
|
return wrapper;
|
|
};
|
|
return ComponentTable_MaterialSymbol;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_MaterialSymbol.ComponentTable_MaterialSymbol = ComponentTable_MaterialSymbol;
|
|
|
|
return Component_Table_MaterialSymbol;
|
|
}
|
|
|
|
var Component_Table_Number = {};
|
|
|
|
var hasRequiredComponent_Table_Number;
|
|
|
|
function requireComponent_Table_Number () {
|
|
if (hasRequiredComponent_Table_Number) return Component_Table_Number;
|
|
hasRequiredComponent_Table_Number = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table_Number, "__esModule", { value: true });
|
|
Component_Table_Number.ComponentTable_Number = void 0;
|
|
var Component_Table_Text_1 = requireComponent_Table_Text();
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_Number = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_Number, _super);
|
|
function ComponentTable_Number() {
|
|
var _this = _super.call(this) || this;
|
|
_this._text = new Component_Table_Text_1.ComponentTable_Text(false);
|
|
return _this;
|
|
}
|
|
ComponentTable_Number.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var element = this._text.createElement(cell, rowId, column, component);
|
|
element.classList.add('mux_table-number');
|
|
var input = element.querySelector('input');
|
|
var regex = /^[0-9.]+$/;
|
|
element.addEventListener('input', function () {
|
|
var currentValue = input.value;
|
|
if (!regex.test(currentValue)) {
|
|
input.value = currentValue.slice(0, -1);
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, input.value);
|
|
}
|
|
});
|
|
return element;
|
|
};
|
|
return ComponentTable_Number;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_Number.ComponentTable_Number = ComponentTable_Number;
|
|
|
|
return Component_Table_Number;
|
|
}
|
|
|
|
var Component_Table_Select = {};
|
|
|
|
var hasRequiredComponent_Table_Select;
|
|
|
|
function requireComponent_Table_Select () {
|
|
if (hasRequiredComponent_Table_Select) return Component_Table_Select;
|
|
hasRequiredComponent_Table_Select = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
Object.defineProperty(Component_Table_Select, "__esModule", { value: true });
|
|
Component_Table_Select.ComponentTable_Select = void 0;
|
|
var Index_1 = requireIndex();
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_Select = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_Select, _super);
|
|
function ComponentTable_Select() {
|
|
return _super.call(this) || this;
|
|
}
|
|
ComponentTable_Select.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var container = (0, Index_1.ce)('div', 'mux_table-select', { title: cell.tooltip });
|
|
var options = {};
|
|
for (var i = 0; i < column.options.length; i++)
|
|
options[column.options[i].uniqueIdentifier] = column.options[i];
|
|
var setSelected = function (uniqueIdentifier) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
var selected = (options === null || options === void 0 ? void 0 : options[uniqueIdentifier]) != undefined
|
|
? uniqueIdentifier
|
|
: column.options[0].uniqueIdentifier;
|
|
var selectedTransform = (_a = options === null || options === void 0 ? void 0 : options[selected].materialIconTransform) !== null && _a !== void 0 ? _a : 'unset';
|
|
var option = options === null || options === void 0 ? void 0 : options[selected];
|
|
textSpan.innerText = (_b = option === null || option === void 0 ? void 0 : option.text) !== null && _b !== void 0 ? _b : '';
|
|
iconSpan.innerText = (_d = (_c = options === null || options === void 0 ? void 0 : options[selected]) === null || _c === void 0 ? void 0 : _c.materialIcon) !== null && _d !== void 0 ? _d : '';
|
|
iconSpan.style.transform = selectedTransform !== null && selectedTransform !== void 0 ? selectedTransform : '';
|
|
container.title = "".concat((_f = (_e = options === null || options === void 0 ? void 0 : options[selected]) === null || _e === void 0 ? void 0 : _e.text) !== null && _f !== void 0 ? _f : '', " | Click to change");
|
|
};
|
|
var iconSpan = (0, Index_1.ce)('span', 'material-symbols-outlined', null);
|
|
var textSpan = (0, Index_1.ce)('span', ['mux_text', 'mux_small'], null);
|
|
var arrow = (0, Index_1.ce)('span', ['mux_table-select-arrow', 'material-symbols-outlined'], null, 'keyboard_arrow_down');
|
|
container.append(iconSpan, textSpan);
|
|
container.appendChild(arrow);
|
|
setSelected(cell.value);
|
|
container.onclick = function () {
|
|
var bounds = container.getBoundingClientRect();
|
|
var items = column.options.map(function (item) {
|
|
return __assign({ click: function () {
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, item.uniqueIdentifier);
|
|
setSelected(item.uniqueIdentifier);
|
|
} }, item);
|
|
});
|
|
new Index_1.MorphComponent.ContextMenu({
|
|
x: bounds.x + bounds.width / 2,
|
|
y: bounds.y + bounds.height,
|
|
items: items,
|
|
});
|
|
};
|
|
return container;
|
|
};
|
|
return ComponentTable_Select;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_Select.ComponentTable_Select = ComponentTable_Select;
|
|
|
|
return Component_Table_Select;
|
|
}
|
|
|
|
var Component_Table_TextSuggestions = {};
|
|
|
|
var hasRequiredComponent_Table_TextSuggestions;
|
|
|
|
function requireComponent_Table_TextSuggestions () {
|
|
if (hasRequiredComponent_Table_TextSuggestions) return Component_Table_TextSuggestions;
|
|
hasRequiredComponent_Table_TextSuggestions = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(Component_Table_TextSuggestions, "__esModule", { value: true });
|
|
Component_Table_TextSuggestions.ComponentTable_TextSuggestions = void 0;
|
|
var Index_1 = requireIndex();
|
|
var Component_ContextMenu_1 = Component_ContextMenu;
|
|
var Component_Table__base_1 = Component_Table__base;
|
|
var ComponentTable_TextSuggestions = /** @class */ (function (_super) {
|
|
__extends(ComponentTable_TextSuggestions, _super);
|
|
function ComponentTable_TextSuggestions() {
|
|
return _super.call(this) || this;
|
|
}
|
|
ComponentTable_TextSuggestions.prototype.createElement = function (cell, rowId, column, component, asNumber) {
|
|
var _a, _b, _c, _d;
|
|
var wrapper = (0, Index_1.ce)('div', 'mux_table-wrapper');
|
|
var container = (0, Index_1.ce)('div', 'mux_table-textsuggestions');
|
|
var optionTitles = {};
|
|
var optionIds = column.options.map(function (option) {
|
|
optionTitles[option.uniqueIdentifier] = option.text;
|
|
return option.uniqueIdentifier;
|
|
});
|
|
var input = new Index_1.MorphComponent.Input({
|
|
type: 'text',
|
|
value: (_b = optionTitles[String((_a = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _a !== void 0 ? _a : '').trim()]) !== null && _b !== void 0 ? _b : String((_c = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _c !== void 0 ? _c : '').trim(),
|
|
border: 'always',
|
|
});
|
|
input.container.setAttribute('valueId', String((_d = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _d !== void 0 ? _d : '').trim());
|
|
var arrow = (0, Index_1.ce)('span', 'material-symbols-outlined', null, 'arrow_drop_down');
|
|
arrow.onclick = function () {
|
|
input.container.focus();
|
|
showContext();
|
|
};
|
|
input.container.addEventListener('focus', function () {
|
|
var _a;
|
|
input.setValue((_a = input.container.getAttribute('valueId')) !== null && _a !== void 0 ? _a : '');
|
|
});
|
|
input.on('blur', function () {
|
|
var optionTitle = optionTitles[input.container.getAttribute('valueId')];
|
|
if (optionTitle == null) {
|
|
if (input.getValue().length > 0)
|
|
component.callEvent('textSuggestionFailed', rowId, column.uniqueIdentifier);
|
|
input.setValue('');
|
|
input.container.removeAttribute('valueId');
|
|
}
|
|
else {
|
|
input.setValue(optionTitle);
|
|
}
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, input.container.getAttribute('valueId'));
|
|
setTimeout(function () {
|
|
context === null || context === void 0 ? void 0 : context.destroy();
|
|
}, 250);
|
|
});
|
|
input.container.addEventListener('keydown', function (e) {
|
|
if (e.key != ' ' || !e.ctrlKey)
|
|
return;
|
|
e.preventDefault();
|
|
showContext();
|
|
});
|
|
input.on('input', function () { return showContext(); });
|
|
var context;
|
|
var showContextTimeout;
|
|
function showContext() {
|
|
return __awaiter(this, arguments, void 0, function (instant) {
|
|
if (instant === void 0) { instant = false; }
|
|
return __generator(this, function (_a) {
|
|
context === null || context === void 0 ? void 0 : context.close('blur');
|
|
if (optionIds.includes(input.getValue())) {
|
|
input.container.setAttribute('valueId', input.getValue());
|
|
return [2 /*return*/];
|
|
}
|
|
input.container.removeAttribute('valueId');
|
|
clearTimeout(showContextTimeout);
|
|
showContextTimeout = setTimeout(function () {
|
|
var _a;
|
|
var firstId;
|
|
var value = ((_a = input.getValue()) !== null && _a !== void 0 ? _a : '').toLowerCase();
|
|
var options = value.length == 0
|
|
? []
|
|
: column.options
|
|
.map(function (option) {
|
|
var _a, _b;
|
|
var text = ((_a = option === null || option === void 0 ? void 0 : option.text) !== null && _a !== void 0 ? _a : '').toLowerCase();
|
|
var id = ((_b = option === null || option === void 0 ? void 0 : option.uniqueIdentifier) !== null && _b !== void 0 ? _b : '').toLowerCase();
|
|
return { text: text, id: id, option: option };
|
|
})
|
|
.filter(function (_a) {
|
|
var text = _a.text, id = _a.id; _a.option;
|
|
return (text.includes(value) ||
|
|
id.includes(value));
|
|
})
|
|
.map(function (_a) {
|
|
var text = _a.text, id = _a.id, option = _a.option;
|
|
var score = 1;
|
|
if (text.startsWith(value) ||
|
|
id.startsWith(value))
|
|
score += 1;
|
|
if (text.includes(value) ||
|
|
id.includes(value))
|
|
score += 1;
|
|
if (text == value || id == value)
|
|
score += 1;
|
|
return { score: score, option: option };
|
|
})
|
|
.sort(function (a, b) { return b.score - a.score; })
|
|
.map(function (_a, index) {
|
|
_a.score; var option = _a.option;
|
|
if (index == 0)
|
|
firstId = option.uniqueIdentifier;
|
|
return __assign(__assign({}, option), { click: function () {
|
|
input.setValue(option.text);
|
|
input.container.setAttribute('valueId', option.uniqueIdentifier);
|
|
component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, input.getValue());
|
|
component.callEvent('textSuggestionCompleted');
|
|
} });
|
|
});
|
|
if (options.length == 0)
|
|
return;
|
|
var bounds = input.container.getBoundingClientRect();
|
|
context = new Component_ContextMenu_1.ComponentContextMenu({
|
|
items: options,
|
|
selected: firstId,
|
|
x: bounds.x + bounds.width / 2,
|
|
y: bounds.y + bounds.height,
|
|
});
|
|
}, instant ? 0 : 200);
|
|
return [2 /*return*/];
|
|
});
|
|
});
|
|
}
|
|
container.appendChild(input.container);
|
|
container.appendChild(arrow);
|
|
wrapper.appendChild(container);
|
|
return wrapper;
|
|
};
|
|
return ComponentTable_TextSuggestions;
|
|
}(Component_Table__base_1.ComponentTable_Base));
|
|
Component_Table_TextSuggestions.ComponentTable_TextSuggestions = ComponentTable_TextSuggestions;
|
|
|
|
return Component_Table_TextSuggestions;
|
|
}
|
|
|
|
var hasRequiredComponent_Table;
|
|
|
|
function requireComponent_Table () {
|
|
if (hasRequiredComponent_Table) return Component_Table;
|
|
hasRequiredComponent_Table = 1;
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Table, "__esModule", { value: true });
|
|
Component_Table.ComponentTable = void 0;
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var Component_Table_Button_1 = requireComponent_Table_Button();
|
|
var Component_Table_Duration_1 = requireComponent_Table_Duration();
|
|
var Component_Table_Icons_1 = requireComponent_Table_Icons();
|
|
var Component_Table_MaterialSymbol_1 = requireComponent_Table_MaterialSymbol();
|
|
var Component_Table_Number_1 = requireComponent_Table_Number();
|
|
var Component_Table_Select_1 = requireComponent_Table_Select();
|
|
var Component_Table_Text_1 = requireComponent_Table_Text();
|
|
var Component_Table_TextSuggestions_1 = requireComponent_Table_TextSuggestions();
|
|
var Sortable = SortableExports;
|
|
var ComponentTable = /** @class */ (function (_super) {
|
|
__extends(ComponentTable, _super);
|
|
function ComponentTable(options) {
|
|
var _a, _b;
|
|
var _this_1 = _super.call(this) || this;
|
|
_this_1.columns = [];
|
|
_this_1.rows = [];
|
|
_this_1.hiddenRows = [];
|
|
_this_1.columnMap = {};
|
|
_this_1.highlight = function (uniqueIdentifier, style, scrollIntoView, deselectOther) {
|
|
var _a, _b, _c;
|
|
if (scrollIntoView === void 0) { scrollIntoView = false; }
|
|
if (deselectOther === void 0) { deselectOther = true; }
|
|
var rows = _this_1.table.querySelectorAll('tr');
|
|
var styles = typeof style == 'string' ? [style] : style;
|
|
for (var i = 0; i < rows.length; i++) {
|
|
if (uniqueIdentifier != null &&
|
|
rows[i].getAttribute('uid') == uniqueIdentifier) {
|
|
(_a = rows[i].classList).remove.apply(_a, ['selected', 'active', 'outline'].map(function (st) {
|
|
return "mux_table-row-".concat(st);
|
|
}));
|
|
if (style != 'none') {
|
|
(_b = rows[i].classList).add.apply(_b, styles.map(function (st) {
|
|
return "mux_table-row-".concat(st);
|
|
}));
|
|
if (scrollIntoView)
|
|
rows[i].scrollIntoView({
|
|
block: 'center',
|
|
behavior: 'smooth',
|
|
});
|
|
}
|
|
}
|
|
else if (deselectOther)
|
|
(_c = rows[i].classList).remove.apply(_c, ['selected', 'active', 'outline'].map(function (st) {
|
|
return "mux_table-row-".concat(st);
|
|
}));
|
|
}
|
|
};
|
|
_this_1.container = (0, CE_1.ce)('div', 'mux_table');
|
|
_this_1.columns = (_a = options === null || options === void 0 ? void 0 : options.columns) !== null && _a !== void 0 ? _a : [];
|
|
_this_1.table = (0, CE_1.ce)('table');
|
|
var headerRow = (0, CE_1.ce)('tr');
|
|
_this_1.columns.forEach(function (column) {
|
|
var cell = (0, CE_1.ce)('th', null, { uid: column.uniqueIdentifier });
|
|
_this_1.columnMap[column.uniqueIdentifier] = column;
|
|
if (column.width != undefined)
|
|
cell.style.width = column.width;
|
|
if (column.noLeftBorder == true)
|
|
cell.classList.add('mux_table-noborder');
|
|
if (column.title != undefined) {
|
|
var title = (0, CE_1.ce)('div', ['mux_table-text', 'mux_header', 'mux_small'], null, column.title);
|
|
cell.appendChild(title);
|
|
if (column.headerAlign != undefined)
|
|
title.style.textAlign = column.headerAlign;
|
|
}
|
|
headerRow.appendChild(cell);
|
|
});
|
|
_this_1.table.appendChild(headerRow);
|
|
_this_1.container.appendChild(_this_1.table);
|
|
var _this = _this_1;
|
|
var sortable = new Sortable(_this_1.table, {
|
|
filter: ((_b = options === null || options === void 0 ? void 0 : options.dragableIgnore) !== null && _b !== void 0 ? _b : []).join(', '),
|
|
preventOnFilter: false,
|
|
handle: options === null || options === void 0 ? void 0 : options.dragableHandle,
|
|
ghostClass: 'mux_table-row-dragging',
|
|
onStart: function () {
|
|
_this.table.classList.add('mux_table-dragging');
|
|
_this.callEvent('dragStart');
|
|
},
|
|
onEnd: function (evt) {
|
|
_this.callEvent('dragEnd');
|
|
_this.table.classList.remove('mux_table-dragging');
|
|
_this.callEvent('orderUpdated', _this.getOrder());
|
|
_this.updateRowBackgrounds();
|
|
},
|
|
});
|
|
if (options.dragable != true) {
|
|
sortable.option('disabled', true);
|
|
}
|
|
if (options.rows != undefined) {
|
|
options.rows.forEach(function (row) { return _this_1.addRow(row, true); });
|
|
_this_1.updateRowBackgrounds();
|
|
}
|
|
return _this_1;
|
|
}
|
|
ComponentTable.prototype.getOrder = function () {
|
|
var order = [];
|
|
var rows = this.table.querySelectorAll('tr');
|
|
for (var i = 1; i < rows.length; i++)
|
|
order.push(rows[i].getAttribute('uid'));
|
|
return order;
|
|
};
|
|
ComponentTable.prototype.clear = function () {
|
|
this.rows = [];
|
|
var rows = this.table.querySelectorAll('tr');
|
|
if (rows.length > 1)
|
|
for (var i = 1; i < rows.length; i++)
|
|
rows[i].parentElement.removeChild(rows[i]);
|
|
};
|
|
ComponentTable.prototype.addRows = function (rows) {
|
|
var _this_1 = this;
|
|
rows.forEach(function (row) { return _this_1.addRow(row, true); });
|
|
this.updateRowBackgrounds();
|
|
};
|
|
ComponentTable.prototype.addRow = function (row, silent) {
|
|
if (silent === void 0) { silent = false; }
|
|
return this._createRow(row, null, silent);
|
|
};
|
|
ComponentTable.prototype.insertRow = function (index, row, silent) {
|
|
if (silent === void 0) { silent = false; }
|
|
if (index < 0 || index > this.rows.length)
|
|
return;
|
|
return this._createRow(row, index + 1, silent);
|
|
};
|
|
ComponentTable.prototype._createRow = function (row, insertIndex, silent) {
|
|
var _this_1 = this;
|
|
this.rows.push(row.uniqueIdentifier);
|
|
var rowElement = (0, CE_1.ce)('tr', 'mux_table-row', {
|
|
uid: row.uniqueIdentifier,
|
|
});
|
|
if (!this.hiddenRows.includes(row.uniqueIdentifier))
|
|
rowElement.classList.add('mux_table-row-visible');
|
|
rowElement.onclick = function (e) {
|
|
_this_1.callEvent('click', row.uniqueIdentifier, e);
|
|
};
|
|
if (row.child)
|
|
rowElement.classList.add('mux_table-row-child');
|
|
if (row.highlight != undefined)
|
|
rowElement.classList.add("mux_table-row-".concat(row.highlight));
|
|
this.columns.forEach(function (columnSettings) {
|
|
var cellElement = (0, CE_1.ce)('td', null, {
|
|
uid: columnSettings.uniqueIdentifier,
|
|
});
|
|
if (columnSettings.width != undefined)
|
|
cellElement.style.width = columnSettings.width;
|
|
var handler = columnTypes[columnSettings.type];
|
|
var cell = row.cells[columnSettings.uniqueIdentifier];
|
|
if (cell == undefined)
|
|
return;
|
|
cellElement.appendChild(handler.createElement(cell, row.uniqueIdentifier, columnSettings, _this_1));
|
|
rowElement.appendChild(cellElement);
|
|
});
|
|
if (insertIndex != null) {
|
|
var rows = this.table.querySelectorAll('tr');
|
|
if (insertIndex >= rows.length)
|
|
this.table.appendChild(rowElement);
|
|
else
|
|
this.table.insertBefore(rowElement, rows[insertIndex]);
|
|
}
|
|
else
|
|
this.table.appendChild(rowElement);
|
|
if (!silent)
|
|
this.updateRowBackgrounds();
|
|
};
|
|
ComponentTable.prototype.updateCell = function (rowId, columnId, value) {
|
|
var row = this.table.querySelector("tr[uid=\"".concat(rowId, "\"]"));
|
|
if (row == null)
|
|
return;
|
|
var cell = row.querySelector("td[uid=\"".concat(columnId, "\""));
|
|
if (cell == null)
|
|
return;
|
|
var columnSettings = this.columnMap[columnId];
|
|
var handler = columnTypes[columnSettings.type];
|
|
cell.innerHTML = '';
|
|
cell.appendChild(handler.createElement(value, rowId, columnSettings, this));
|
|
};
|
|
ComponentTable.prototype.setDragable = function (dragable) {
|
|
this.Sortable.option('disabled', !dragable);
|
|
};
|
|
ComponentTable.prototype.updateRowBackgrounds = function () {
|
|
var rows = this.table.querySelectorAll('.mux_table-row-visible');
|
|
var counter = 0;
|
|
var insideChild = false;
|
|
for (var i = 0; i < rows.length; i++) {
|
|
var isChild = rows[i].classList.contains('mux_table-row-child');
|
|
if (insideChild != isChild) {
|
|
insideChild = isChild;
|
|
counter = 0;
|
|
}
|
|
var odd = (counter + 1) % 2 == 0;
|
|
counter++;
|
|
if (odd)
|
|
rows[i].classList.add('mux_table-row-odd');
|
|
else
|
|
rows[i].classList.remove('mux_table-row-odd');
|
|
}
|
|
};
|
|
ComponentTable.extendTypes = function (type, handler) {
|
|
columnTypes[type] = handler;
|
|
};
|
|
return ComponentTable;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_Table.ComponentTable = ComponentTable;
|
|
var columnTypes = {
|
|
text: new Component_Table_Text_1.ComponentTable_Text(true),
|
|
textsuggestions: new Component_Table_TextSuggestions_1.ComponentTable_TextSuggestions(),
|
|
number: new Component_Table_Number_1.ComponentTable_Number(),
|
|
button: new Component_Table_Button_1.ComponentTable_Button(),
|
|
duration: new Component_Table_Duration_1.ComponentTable_Duration(),
|
|
icons: new Component_Table_Icons_1.ComponentTable_Icons(),
|
|
select: new Component_Table_Select_1.ComponentTable_Select(),
|
|
materialSymbol: new Component_Table_MaterialSymbol_1.ComponentTable_MaterialSymbol(),
|
|
};
|
|
|
|
return Component_Table;
|
|
}
|
|
|
|
var Component_Text = {};
|
|
|
|
var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(Component_Text, "__esModule", { value: true });
|
|
Component_Text.ComponentText = void 0;
|
|
var CE_1 = CE;
|
|
var baseComponent_1 = baseComponent;
|
|
var ComponentText = /** @class */ (function (_super) {
|
|
__extends(ComponentText, _super);
|
|
function ComponentText(options) {
|
|
var _a;
|
|
var _this = _super.call(this) || this;
|
|
var size = (_a = options === null || options === void 0 ? void 0 : options.size) !== null && _a !== void 0 ? _a : 'normal';
|
|
_this.container = (0, CE_1.ce)('div', ['mux_text', "mux_".concat(size)], null, options === null || options === void 0 ? void 0 : options.content);
|
|
return _this;
|
|
}
|
|
ComponentText.prototype.update = function (content) {
|
|
this.container.innerHTML = content;
|
|
};
|
|
return ComponentText;
|
|
}(baseComponent_1.MUXComponent));
|
|
Component_Text.ComponentText = ComponentText;
|
|
|
|
var hasRequiredMorph_Components;
|
|
|
|
function requireMorph_Components () {
|
|
if (hasRequiredMorph_Components) return Morph_Components;
|
|
hasRequiredMorph_Components = 1;
|
|
Object.defineProperty(Morph_Components, "__esModule", { value: true });
|
|
Morph_Components.MorphComponent = void 0;
|
|
var Component_Button_1 = Component_Button;
|
|
var Component_Cards_1 = Component_Cards;
|
|
var Component_ContextMenu_1 = Component_ContextMenu;
|
|
var Component_Dialog_1 = requireComponent_Dialog();
|
|
var Component_Group_1 = Component_Group;
|
|
var Component_Header_1 = Component_Header;
|
|
var Component_IconGrid_1 = Component_IconGrid;
|
|
var Component_ImageViewer_1 = requireComponent_ImageViewer();
|
|
var Component_Input_1 = Component_Input;
|
|
var Component_List_1 = requireComponent_List();
|
|
var Component_MenuBar_1 = requireComponent_MenuBar();
|
|
var Component_PaletteCheckbox_1 = requireComponent_PaletteCheckbox();
|
|
var Component_PaletteSearch_1 = requireComponent_PaletteSearch();
|
|
var Component_Resizer_1 = Component_Resizer;
|
|
var Component_Row_1 = Component_Row;
|
|
var Component_Select_1 = requireComponent_Select();
|
|
var Component_Table_1 = requireComponent_Table();
|
|
var Component_Text_1 = Component_Text;
|
|
Morph_Components.MorphComponent = {
|
|
Header: Component_Header_1.ComponentHeader,
|
|
Text: Component_Text_1.ComponentText,
|
|
Button: Component_Button_1.ComponentButton,
|
|
Input: Component_Input_1.ComponentInput,
|
|
Select: Component_Select_1.ComponentSelect,
|
|
Group: Component_Group_1.ComponentGroup,
|
|
List: Component_List_1.ComponentList,
|
|
Cards: Component_Cards_1.ComponentCards,
|
|
IconGrid: Component_IconGrid_1.ComponentIconGrid,
|
|
Table: Component_Table_1.ComponentTable,
|
|
Row: Component_Row_1.ComponentRow,
|
|
Dialog: Component_Dialog_1.ComponentDialog,
|
|
PaletteSearch: Component_PaletteSearch_1.ComponentPaletteSearch,
|
|
PaletteCheckbox: Component_PaletteCheckbox_1.ComponentPaletteCheckbox,
|
|
ImageViewer: Component_ImageViewer_1.ComponentImageViewer,
|
|
MenuBar: Component_MenuBar_1.ComponentMenuBar,
|
|
ContextMenu: Component_ContextMenu_1.ComponentContextMenu,
|
|
Resizer: Component_Resizer_1.ComponentResizer,
|
|
extend: function (name, component) {
|
|
this[name] = component;
|
|
},
|
|
};
|
|
|
|
return Morph_Components;
|
|
}
|
|
|
|
var Morph_Features = {};
|
|
|
|
var Feature_Alert = {};
|
|
|
|
var hasRequiredFeature_Alert;
|
|
|
|
function requireFeature_Alert () {
|
|
if (hasRequiredFeature_Alert) return Feature_Alert;
|
|
hasRequiredFeature_Alert = 1;
|
|
Object.defineProperty(Feature_Alert, "__esModule", { value: true });
|
|
Feature_Alert.FeatureAlert = FeatureAlert;
|
|
var Index_1 = requireIndex();
|
|
function FeatureAlert(options, callback) {
|
|
return new Promise(function (resolve) {
|
|
var _a;
|
|
var dialog = new Index_1.MorphComponent.Dialog({
|
|
title: (_a = options === null || options === void 0 ? void 0 : options.title) !== null && _a !== void 0 ? _a : 'Alert',
|
|
width: 'small',
|
|
height: 'auto',
|
|
cancelButtonVisible: false,
|
|
});
|
|
dialog.content.appendChild((0, Index_1.ce)('div', 'mux_text', null, options.message));
|
|
var res = function () {
|
|
if (typeof callback == 'function')
|
|
callback();
|
|
resolve();
|
|
};
|
|
dialog.on('close', function () { return res(); });
|
|
dialog.on('ok', function () { return res(); });
|
|
});
|
|
}
|
|
|
|
return Feature_Alert;
|
|
}
|
|
|
|
var Feature_Confirm = {};
|
|
|
|
var hasRequiredFeature_Confirm;
|
|
|
|
function requireFeature_Confirm () {
|
|
if (hasRequiredFeature_Confirm) return Feature_Confirm;
|
|
hasRequiredFeature_Confirm = 1;
|
|
Object.defineProperty(Feature_Confirm, "__esModule", { value: true });
|
|
Feature_Confirm.FeatureConfirm = FeatureConfirm;
|
|
var Index_1 = requireIndex();
|
|
function FeatureConfirm(options, callback) {
|
|
return new Promise(function (resolve) {
|
|
var _a;
|
|
var dialog = new Index_1.MorphComponent.Dialog({
|
|
title: (_a = options === null || options === void 0 ? void 0 : options.title) !== null && _a !== void 0 ? _a : 'Confirm',
|
|
width: 'small',
|
|
height: 'auto',
|
|
});
|
|
dialog.content.appendChild((0, Index_1.ce)('div', 'mux_text', null, options.message));
|
|
var res = function (state) {
|
|
if (typeof callback == 'function')
|
|
callback(state);
|
|
resolve(state);
|
|
};
|
|
dialog.on('close', function () { return res(null); });
|
|
dialog.on('cancel', function () { return res(false); });
|
|
dialog.on('ok', function () { return res(true); });
|
|
});
|
|
}
|
|
|
|
return Feature_Confirm;
|
|
}
|
|
|
|
var Feature_Loader = {};
|
|
|
|
var hasRequiredFeature_Loader;
|
|
|
|
function requireFeature_Loader () {
|
|
if (hasRequiredFeature_Loader) return Feature_Loader;
|
|
hasRequiredFeature_Loader = 1;
|
|
Object.defineProperty(Feature_Loader, "__esModule", { value: true });
|
|
Feature_Loader.FeatureLoader = FeatureLoader;
|
|
var Index_1 = requireIndex();
|
|
function FeatureLoader(options) {
|
|
var _a, _b;
|
|
var active = (_a = options === null || options === void 0 ? void 0 : options.active) !== null && _a !== void 0 ? _a : false;
|
|
var message = (_b = options === null || options === void 0 ? void 0 : options.message) !== null && _b !== void 0 ? _b : '';
|
|
var progress = options === null || options === void 0 ? void 0 : options.progress;
|
|
if (active == true)
|
|
showLoader(message, progress);
|
|
else
|
|
removeExisting();
|
|
}
|
|
function showLoader(message, progress) {
|
|
var loader = document.querySelector('.mux_loader');
|
|
if (loader == null) {
|
|
loader = (0, Index_1.ce)('div', 'mux_loader');
|
|
loader.appendChild((0, Index_1.ce)('span', 'material-symbols-outlined', null, 'circle'));
|
|
document.body.appendChild(loader);
|
|
}
|
|
var existingProgress = loader.querySelector('.mux_loader-progress');
|
|
if (progress == null) {
|
|
if (existingProgress != null)
|
|
existingProgress.remove();
|
|
}
|
|
else {
|
|
if (existingProgress != null) {
|
|
existingProgress.style.setProperty('--progress', "".concat(progress, "%"));
|
|
existingProgress.querySelector('.mux_loader-progress-label').innerText = "".concat(Math.round(progress), "%");
|
|
}
|
|
else {
|
|
var progressBar = (0, Index_1.ce)('div', 'mux_loader-progress');
|
|
progressBar.style.setProperty('--progress', "".concat(progress, "%"));
|
|
var value = (0, Index_1.ce)('div', 'mux_loader-progress-value');
|
|
value.appendChild((0, Index_1.ce)('div', 'mux_loader-progress-label', null, "".concat(Math.round(progress), "%")));
|
|
progressBar.appendChild(value);
|
|
loader.appendChild(progressBar);
|
|
}
|
|
}
|
|
var existingText = loader.querySelector('.mux_loader-message');
|
|
if (message.trim().length == 0) {
|
|
if (existingText != null)
|
|
existingText.remove();
|
|
}
|
|
else {
|
|
if (existingText != null)
|
|
existingText.innerText = message;
|
|
else {
|
|
if (loader.querySelector('.mux_loader-progress') != null)
|
|
loader.insertBefore((0, Index_1.ce)('div', ['mux_text', 'mux_loader-message'], null, message), loader.querySelector('.mux_loader-progress'));
|
|
else
|
|
loader.appendChild((0, Index_1.ce)('div', ['mux_text', 'mux_loader-message'], null, message));
|
|
}
|
|
}
|
|
}
|
|
function removeExisting() {
|
|
var existing = document.querySelector('.mux_loader');
|
|
if (existing != null)
|
|
existing.remove();
|
|
}
|
|
|
|
return Feature_Loader;
|
|
}
|
|
|
|
var Feature_Notification = {};
|
|
|
|
var hasRequiredFeature_Notification;
|
|
|
|
function requireFeature_Notification () {
|
|
if (hasRequiredFeature_Notification) return Feature_Notification;
|
|
hasRequiredFeature_Notification = 1;
|
|
Object.defineProperty(Feature_Notification, "__esModule", { value: true });
|
|
Feature_Notification.FeatureNotification = FeatureNotification;
|
|
var Index_1 = requireIndex();
|
|
var NotificationHandler = new (/** @class */ (function () {
|
|
function class_1() {
|
|
var _this = this;
|
|
window.addEventListener('DOMContentLoaded', function () { return _this.prepare(); });
|
|
}
|
|
class_1.prototype.prepare = function () {
|
|
this.container = (0, Index_1.ce)('div', 'mux_notifications');
|
|
document.body.appendChild(this.container);
|
|
};
|
|
class_1.prototype.append = function (notification) {
|
|
var _a, _b, _c;
|
|
var element = (0, Index_1.ce)('div', 'mux_notification');
|
|
element.classList.add('mux_notification-' + notification.level);
|
|
var icon = (0, Index_1.ce)('span', ['material-symbols-outlined', 'mux_notification-icon'], null, {
|
|
info: 'exclamation',
|
|
warning: 'exclamation',
|
|
error: 'close',
|
|
success: 'check',
|
|
}[(_a = notification.level) !== null && _a !== void 0 ? _a : 'info']);
|
|
if (notification.level == 'info')
|
|
icon.style.transform = 'rotate(180deg)';
|
|
element.appendChild(icon);
|
|
element.appendChild((0, Index_1.ce)('div', 'mux_text', null, notification.message));
|
|
if ((notification === null || notification === void 0 ? void 0 : notification.action) != null) {
|
|
var action = (0, Index_1.ce)('span', ['material-symbols-outlined', 'mux_notification-action'], null, notification.action.materialIcon);
|
|
action.onclick = function () {
|
|
notification.action.click();
|
|
clearTimeout(hideTimeout);
|
|
closeNotification();
|
|
};
|
|
element.appendChild(action);
|
|
}
|
|
if ((_b = notification === null || notification === void 0 ? void 0 : notification.closeable) !== null && _b !== void 0 ? _b : true) {
|
|
element.onclick = function () {
|
|
closeNotification();
|
|
};
|
|
}
|
|
this.container.prepend(element);
|
|
var openNotification = function () {
|
|
element.style.opacity = '1';
|
|
element.style.transform = 'translateX(0px)';
|
|
};
|
|
var closeNotification = function () {
|
|
clearTimeout(hideTimeout);
|
|
element.style.marginTop = "-".concat(element.clientHeight + 6, "px");
|
|
element.style.opacity = '0';
|
|
element.style.transform = 'translateX(100%)';
|
|
element.style.pointerEvents = 'none';
|
|
element.ontransitionend = function () { return element.remove(); };
|
|
};
|
|
setTimeout(function () { return openNotification(); }, 100);
|
|
var hideTimeout = setTimeout(function () { return closeNotification(); }, ((_c = notification === null || notification === void 0 ? void 0 : notification.seconds) !== null && _c !== void 0 ? _c : 10) * 1000);
|
|
return new NotificationInstance(closeNotification);
|
|
};
|
|
return class_1;
|
|
}()))();
|
|
var NotificationInstance = /** @class */ (function () {
|
|
function NotificationInstance(close) {
|
|
this._close = close;
|
|
}
|
|
NotificationInstance.prototype.close = function () {
|
|
this._close();
|
|
};
|
|
return NotificationInstance;
|
|
}());
|
|
function FeatureNotification(notification) {
|
|
var _a;
|
|
if (((_a = notification === null || notification === void 0 ? void 0 : notification.message) !== null && _a !== void 0 ? _a : '').trim().length == 0)
|
|
return;
|
|
return NotificationHandler.append(notification);
|
|
}
|
|
|
|
return Feature_Notification;
|
|
}
|
|
|
|
var Feature_Prompt = {};
|
|
|
|
var hasRequiredFeature_Prompt;
|
|
|
|
function requireFeature_Prompt () {
|
|
if (hasRequiredFeature_Prompt) return Feature_Prompt;
|
|
hasRequiredFeature_Prompt = 1;
|
|
Object.defineProperty(Feature_Prompt, "__esModule", { value: true });
|
|
Feature_Prompt.FeaturePrompt = FeaturePrompt;
|
|
var Index_1 = requireIndex();
|
|
function FeaturePrompt(options, callback) {
|
|
return new Promise(function (resolve) {
|
|
var _a, _b, _c, _d;
|
|
var dialog = new Index_1.MorphComponent.Dialog({
|
|
title: (_a = options === null || options === void 0 ? void 0 : options.title) !== null && _a !== void 0 ? _a : 'Prompt',
|
|
width: 'small',
|
|
height: 'auto',
|
|
});
|
|
dialog.content.appendChild((0, Index_1.ce)('div', 'mux_text', null, options.message));
|
|
var input = new Index_1.MorphComponent.Input({
|
|
type: (_b = options.type) !== null && _b !== void 0 ? _b : 'text',
|
|
value: (_c = options.default) !== null && _c !== void 0 ? _c : '',
|
|
placeholder: (_d = options.placeholder) !== null && _d !== void 0 ? _d : '',
|
|
border: 'always',
|
|
});
|
|
input.container.style.margin = 'var(--mux-edge-offset-tiny) 0px';
|
|
input.container.onfocus = function () {
|
|
errorMessage.style.height = '0px';
|
|
};
|
|
dialog.content.appendChild(input.container);
|
|
var errorMessage = (0, Index_1.ce)('div', ['mux_text', 'mux_small'], null, 'Value can not be empty!');
|
|
errorMessage.style.height = '0px';
|
|
errorMessage.style.transitionDuration =
|
|
'var(--mux-transition-animation)';
|
|
errorMessage.style.overflow = 'hidden';
|
|
errorMessage.style.color = 'var(--mux-color-red)';
|
|
dialog.content.appendChild(errorMessage);
|
|
var res = function (value) {
|
|
if (typeof callback == 'function')
|
|
callback(value);
|
|
resolve(value);
|
|
};
|
|
dialog.on('close', function () { return res(null); });
|
|
dialog.on('cancel', function () { return res(null); });
|
|
dialog.on('ok', function (closeEvent) {
|
|
if (!options.canBeEmpty && input.getValue().trim() == '') {
|
|
errorMessage.style.height = '14px';
|
|
return closeEvent.preventClose();
|
|
}
|
|
res(input.getValue());
|
|
});
|
|
input.container.focus();
|
|
});
|
|
}
|
|
|
|
return Feature_Prompt;
|
|
}
|
|
|
|
var hasRequiredMorph_Features;
|
|
|
|
function requireMorph_Features () {
|
|
if (hasRequiredMorph_Features) return Morph_Features;
|
|
hasRequiredMorph_Features = 1;
|
|
Object.defineProperty(Morph_Features, "__esModule", { value: true });
|
|
Morph_Features.MorphFeature = void 0;
|
|
var Feature_Alert_1 = requireFeature_Alert();
|
|
var Feature_Confirm_1 = requireFeature_Confirm();
|
|
var Feature_Loader_1 = requireFeature_Loader();
|
|
var Feature_Notification_1 = requireFeature_Notification();
|
|
var Feature_Prompt_1 = requireFeature_Prompt();
|
|
Morph_Features.MorphFeature = {
|
|
Confirm: Feature_Confirm_1.FeatureConfirm,
|
|
Alert: Feature_Alert_1.FeatureAlert,
|
|
Prompt: Feature_Prompt_1.FeaturePrompt,
|
|
Notification: Feature_Notification_1.FeatureNotification,
|
|
Loader: Feature_Loader_1.FeatureLoader,
|
|
extend: function (name, component) {
|
|
this[name] = component;
|
|
},
|
|
};
|
|
|
|
return Morph_Features;
|
|
}
|
|
|
|
var Morph_Utils = {};
|
|
|
|
var clone$1 = {};
|
|
|
|
Object.defineProperty(clone$1, "__esModule", { value: true });
|
|
clone$1.clone = clone;
|
|
function clone(object) {
|
|
if (typeof object !== 'object')
|
|
return object;
|
|
return JSON.parse(JSON.stringify(object !== null && object !== void 0 ? object : {}));
|
|
}
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ce = exports.clone = void 0;
|
|
var clone_1 = clone$1;
|
|
Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return clone_1.clone; } });
|
|
var CE_1 = CE;
|
|
Object.defineProperty(exports, "ce", { enumerable: true, get: function () { return CE_1.ce; } });
|
|
|
|
} (Morph_Utils));
|
|
|
|
var hasRequiredIndex;
|
|
|
|
function requireIndex () {
|
|
if (hasRequiredIndex) return Index;
|
|
hasRequiredIndex = 1;
|
|
(function (exports) {
|
|
var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.MUXComponent = void 0;
|
|
var version = require$$0$1.version;
|
|
if (window._MorphUXInitialized === undefined) {
|
|
console.log('MorphUX Loaded');
|
|
console.log("Version ".concat(version));
|
|
window._MorphUXInitialized = true;
|
|
}
|
|
__exportStar(requireMorph_Components(), exports);
|
|
__exportStar(requireMorph_Features(), exports);
|
|
__exportStar(Morph_Keys, exports);
|
|
__exportStar(Morph_Utils, exports);
|
|
var baseComponent_1 = baseComponent;
|
|
Object.defineProperty(exports, "MUXComponent", { enumerable: true, get: function () { return baseComponent_1.MUXComponent; } });
|
|
|
|
} (Index));
|
|
return Index;
|
|
}
|
|
|
|
var __awaiter$4 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator$4 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(menuBar, "__esModule", { value: true });
|
|
menuBar.MenuBar = void 0;
|
|
var morphux_1$5 = requireIndex();
|
|
var Component_MenuBar_1 = requireComponent_MenuBar();
|
|
var MenuBar = /** @class */ (function () {
|
|
function MenuBar(main) {
|
|
var _this = this;
|
|
this.container = document.querySelector('.ntsh_menubar');
|
|
this._Main = main;
|
|
this.build();
|
|
setTimeout(function () {
|
|
if ((localStorage === null || localStorage === void 0 ? void 0 : localStorage.getItem('serviceMode')) === 'true')
|
|
_this.toggleServiceMode(true, true);
|
|
}, 10);
|
|
}
|
|
MenuBar.prototype.build = function () {
|
|
var _this = this;
|
|
this.menubar = new Component_MenuBar_1.ComponentMenuBar({
|
|
left: [
|
|
{
|
|
type: 'image',
|
|
url: '/img/morphix_logo_white.png',
|
|
},
|
|
{
|
|
type: 'normal',
|
|
text: 'Dashboard',
|
|
materialIcon: 'dashboard',
|
|
uniqueIdentifier: 'dashboard',
|
|
selected: true,
|
|
click: function () { return _this._Main.TabController.showTab('dashboard'); },
|
|
},
|
|
{
|
|
type: 'normal',
|
|
text: 'Calibration',
|
|
uniqueIdentifier: 'calibration',
|
|
materialIcon: 'crop_free',
|
|
click: function () {
|
|
return _this._Main.TabController.showTab('calibration');
|
|
},
|
|
},
|
|
{
|
|
type: 'normal',
|
|
text: 'Unity Logs',
|
|
uniqueIdentifier: 'unitylogs',
|
|
materialIcon: 'deployed_code',
|
|
click: function () { return _this._Main.TabController.showTab('unitylogs'); },
|
|
},
|
|
{
|
|
type: 'normal',
|
|
text: 'Camera Logs',
|
|
uniqueIdentifier: 'cameralogs',
|
|
materialIcon: 'photo_camera',
|
|
click: function () { return _this._Main.TabController.showTab('cameralogs'); },
|
|
},
|
|
],
|
|
right: [
|
|
{
|
|
type: 'normal',
|
|
text: document.body.classList.contains('ntsh_service')
|
|
? 'Exit Service'
|
|
: 'Service Mode',
|
|
uniqueIdentifier: 'serviceMode',
|
|
materialIcon: document.body.classList.contains('ntsh_service')
|
|
? 'logout'
|
|
: 'engineering',
|
|
click: function () { return __awaiter$4(_this, void 0, void 0, function () {
|
|
var mobileMenu;
|
|
return __generator$4(this, function (_a) {
|
|
mobileMenu = document.querySelector('.mux_mobilemenu');
|
|
mobileMenu === null || mobileMenu === void 0 ? void 0 : mobileMenu.click();
|
|
this.toggleServiceMode();
|
|
return [2 /*return*/];
|
|
});
|
|
}); },
|
|
},
|
|
],
|
|
});
|
|
this.container.innerHTML = '';
|
|
this.container.appendChild(this.menubar.container);
|
|
};
|
|
MenuBar.prototype.toggleServiceMode = function (mode, skipPin) {
|
|
return __awaiter$4(this, void 0, void 0, function () {
|
|
var newMode, servicePin;
|
|
return __generator$4(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
newMode = mode !== null && mode !== void 0 ? mode : !document.body.classList.contains('ntsh_service');
|
|
if (!newMode) return [3 /*break*/, 3];
|
|
if (!(skipPin !== true)) return [3 /*break*/, 2];
|
|
return [4 /*yield*/, morphux_1$5.MorphFeature.Prompt({
|
|
title: 'Service Mode',
|
|
message: 'Enter the service PIN:',
|
|
type: 'number',
|
|
canBeEmpty: false,
|
|
placeholder: '****',
|
|
})];
|
|
case 1:
|
|
servicePin = _a.sent();
|
|
if (servicePin !== '4252') {
|
|
morphux_1$5.MorphFeature.Alert({
|
|
title: 'Error',
|
|
message: 'Incorrect PIN provided.',
|
|
});
|
|
return [2 /*return*/, false];
|
|
}
|
|
_a.label = 2;
|
|
case 2:
|
|
document.body.classList.add('ntsh_service');
|
|
localStorage.setItem('serviceMode', 'true');
|
|
morphux_1$5.MorphFeature.Notification({
|
|
level: 'success',
|
|
message: 'Service mode activated.',
|
|
});
|
|
return [3 /*break*/, 4];
|
|
case 3:
|
|
document.body.classList.remove('ntsh_service');
|
|
this._Main.TabController.showTab('dashboard');
|
|
localStorage.setItem('serviceMode', 'false');
|
|
morphux_1$5.MorphFeature.Notification({
|
|
level: 'success',
|
|
message: 'Service mode deactivated.',
|
|
});
|
|
_a.label = 4;
|
|
case 4:
|
|
this.build();
|
|
return [2 /*return*/, true];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return MenuBar;
|
|
}());
|
|
menuBar.MenuBar = MenuBar;
|
|
|
|
var tabController = {};
|
|
|
|
var __awaiter$3 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator$3 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(tabController, "__esModule", { value: true });
|
|
tabController.TabController = void 0;
|
|
var morphux_1$4 = requireIndex();
|
|
var TabController = /** @class */ (function () {
|
|
function TabController(main) {
|
|
this.container = document.querySelector('.ntsh_tabs');
|
|
this.tabListeners = new Map();
|
|
this._Main = main;
|
|
this.registerNavigationListener();
|
|
}
|
|
TabController.prototype.registerListener = function (tabId, callback) {
|
|
if (this.tabListeners.has(tabId))
|
|
throw new Error("Listener for tab id ".concat(tabId, " has already been registered!"));
|
|
this.tabListeners.set(tabId, callback);
|
|
callback(this.currentTabId == tabId);
|
|
};
|
|
TabController.prototype.showTab = function (tabId) {
|
|
return __awaiter$3(this, void 0, void 0, function () {
|
|
var confirmed, succeed, tabName;
|
|
return __generator$3(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
if (this.currentTabId == tabId)
|
|
return [2 /*return*/];
|
|
if (!(tabId !== 'dashboard' &&
|
|
!document.body.classList.contains('ntsh_service'))) return [3 /*break*/, 3];
|
|
return [4 /*yield*/, morphux_1$4.MorphFeature.Confirm({
|
|
title: 'Service Mode Required',
|
|
message: "You need to be in service mode to access tab ".concat(tabId, ", switch to Service Mode now?"),
|
|
})];
|
|
case 1:
|
|
confirmed = _a.sent();
|
|
if (!confirmed)
|
|
return [2 /*return*/, this.showTab('dashboard')];
|
|
return [4 /*yield*/, this._Main.MenuBar.toggleServiceMode(true)];
|
|
case 2:
|
|
succeed = _a.sent();
|
|
if (!succeed)
|
|
return [2 /*return*/, this.showTab('dashboard')];
|
|
_a.label = 3;
|
|
case 3:
|
|
this._Main.MenuBar.menubar.setSelected(tabId);
|
|
if (this.tabListeners.has(this.currentTabId))
|
|
this.tabListeners.get(this.currentTabId)(false);
|
|
if (this.tabListeners.has(tabId))
|
|
this.tabListeners.get(tabId)(true);
|
|
this.currentTabId = tabId;
|
|
this.container
|
|
.querySelectorAll('.ntsh_tab')
|
|
.forEach(function (tab) { return tab.classList.remove('ntsh_tab-visible'); });
|
|
this.container
|
|
.querySelector(".ntsh_tab[tabid=\"".concat(tabId, "\"]"))
|
|
.classList.add('ntsh_tab-visible');
|
|
window.history.pushState({ tab: tabId }, '', "/".concat(tabId).concat(window.location.search));
|
|
tabName = {
|
|
dashboard: 'Dashboard',
|
|
calibration: 'Calibration',
|
|
cameralogs: 'Camera Logs',
|
|
unitylogs: 'Unity Logs',
|
|
}[tabId];
|
|
document.title = "NTSH Control - ".concat(tabName);
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
TabController.prototype.registerNavigationListener = function () {
|
|
var _this = this;
|
|
window.addEventListener('popstate', function (event) {
|
|
var state = event.state;
|
|
if (state && state.tab)
|
|
_this.showTab(state.tab);
|
|
});
|
|
var startTab = window.location.pathname
|
|
.replace('/', '')
|
|
.split('/')
|
|
.shift();
|
|
this.showTab(startTab.length > 0 ? startTab : 'dashboard');
|
|
};
|
|
return TabController;
|
|
}());
|
|
tabController.TabController = TabController;
|
|
|
|
var dashboard_camerarunner = {};
|
|
|
|
var utils = {};
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.createProgress = exports.setProgressState = exports.setStatusState = exports.lerp = void 0;
|
|
exports.capitalizeFirstLetter = capitalizeFirstLetter;
|
|
exports.formatUptime = formatUptime;
|
|
exports.delay = delay;
|
|
var morphux_1 = requireIndex();
|
|
/**
|
|
* A linear interpolation helper function.
|
|
* @param a The start value.
|
|
* @param b The end value.
|
|
* @param t The interpolation factor (0 to 1).
|
|
* @returns The interpolated value.
|
|
*/
|
|
var lerp = function (a, b, t) {
|
|
return a + (b - a) * t;
|
|
};
|
|
exports.lerp = lerp;
|
|
var setStatusState = function (statusElement, state) {
|
|
statusElement.classList.remove('ntsh_status-green', 'ntsh_status-yellow', 'ntsh_status-red', 'ntsh_status-gray');
|
|
statusElement.classList.add("ntsh_status-".concat(state));
|
|
};
|
|
exports.setStatusState = setStatusState;
|
|
var setProgressState = function (progressElement, percentage) {
|
|
var value = progressElement.querySelector('.ntsh_progress-value');
|
|
value.style.width = "".concat(percentage * 100, "%");
|
|
var label = progressElement.querySelector('.ntsh_progress-label');
|
|
label.innerText = "".concat(Math.round(percentage * 100), "%");
|
|
};
|
|
exports.setProgressState = setProgressState;
|
|
var createProgress = function (value) {
|
|
var progress = (0, morphux_1.ce)('div', 'ntsh_progress');
|
|
progress.appendChild((0, morphux_1.ce)('div', 'ntsh_progress-value'));
|
|
progress.appendChild((0, morphux_1.ce)('div', 'ntsh_progress-label'));
|
|
(0, exports.setProgressState)(progress, value);
|
|
return progress;
|
|
};
|
|
exports.createProgress = createProgress;
|
|
function capitalizeFirstLetter(string) {
|
|
return string.charAt(0).toUpperCase() + string.slice(1);
|
|
}
|
|
function formatUptime(seconds) {
|
|
if (seconds < 0)
|
|
return '';
|
|
var days = Math.floor(seconds / 86400);
|
|
seconds %= 86400;
|
|
var hours = Math.floor(seconds / 3600);
|
|
seconds %= 3600;
|
|
var minutes = Math.floor(seconds / 60);
|
|
seconds = Math.floor(seconds % 60);
|
|
var parts = [];
|
|
if (days > 0)
|
|
parts.push("".concat(days, "d"));
|
|
parts.push("".concat(hours.toString().padStart(2, '0'), ":").concat(minutes
|
|
.toString()
|
|
.padStart(2, '0'), ":").concat(seconds.toString().padStart(2, '0')));
|
|
return parts.join(' ');
|
|
}
|
|
function delay(duration) {
|
|
return new Promise(function (resolve) { return setTimeout(resolve, duration); });
|
|
}
|
|
|
|
} (utils));
|
|
|
|
var __awaiter$2 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator$2 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(dashboard_camerarunner, "__esModule", { value: true });
|
|
dashboard_camerarunner.DashboardCameraRunner = void 0;
|
|
var morphux_1$3 = requireIndex();
|
|
var utils_1$1 = utils;
|
|
var DashboardCameraRunner = /** @class */ (function () {
|
|
function DashboardCameraRunner(Main) {
|
|
this.container = document.querySelector('.ntsh_dashboard-camerarunner');
|
|
this.connectionStatus = this.container.querySelector('.ntsh_dashboard-camerarunner-connectionstatus');
|
|
this.connectionInfo = this.container.querySelector('.ntsh_dashboard-camerarunner-connectioninfo');
|
|
this.rebootButton = this.container.querySelector('.ntsh_dashboard-camerarunner-reboot');
|
|
this.processStatus = this.container.querySelector('.ntsh_dashboard-camerarunner-processstatus');
|
|
this.processInfo = this.container.querySelector('.ntsh_dashboard-camerarunner-processinfo');
|
|
this.restartButton = this.container.querySelector('.ntsh_dashboard-camerarunner-restart');
|
|
this.uptimeInfo = this.container.querySelector('.ntsh_dashboard-camerarunner-uptime');
|
|
this.errorContainer = this.container.querySelector('.ntsh_dashboard-camerarunner-error');
|
|
this.errorText = this.container.querySelector('.ntsh_dashboard-camerarunner-errortext');
|
|
this._Main = Main;
|
|
this.registerListeners();
|
|
}
|
|
DashboardCameraRunner.prototype.updateState = function (state) {
|
|
var _a, _b, _c, _d, _e;
|
|
// ----------- Connection -----------
|
|
(0, utils_1$1.setStatusState)(this.connectionStatus, {
|
|
CONNECTING: 'yellow',
|
|
CONNECTED: 'green',
|
|
DISCONNECTED: 'red',
|
|
FAILED: 'red',
|
|
}[state.state]);
|
|
this.connectionInfo.innerText = (_a = state.message) !== null && _a !== void 0 ? _a : '';
|
|
// ----------- Process -----------
|
|
if (state.state != 'CONNECTED') {
|
|
state.processStatus.state = 'STOPPED';
|
|
state.processStatus.message = 'Not connected';
|
|
state.processStatus.startTime = -1;
|
|
this.restartButton.style.display = 'none';
|
|
this.rebootButton.style.display = 'none';
|
|
}
|
|
else {
|
|
this.rebootButton.style.display = 'flex';
|
|
if (state.processStatus.state == 'RUNNING')
|
|
this.restartButton.style.display = 'flex';
|
|
else
|
|
this.restartButton.style.display = 'none';
|
|
}
|
|
(0, utils_1$1.setStatusState)(this.processStatus, {
|
|
RUNNING: 'green',
|
|
STOPPED: 'gray',
|
|
STARTING: 'yellow',
|
|
PROBLEM: 'red',
|
|
}[state.processStatus.state]);
|
|
this.processInfo.innerText = (_b = state.processStatus.message) !== null && _b !== void 0 ? _b : '';
|
|
// ----------- Uptime -----------
|
|
var uptimeSeconds = state.processStatus.startTime == -1
|
|
? -1
|
|
: (Date.now() - state.processStatus.startTime) / 1000;
|
|
this.uptimeInfo.innerText = (0, utils_1$1.formatUptime)(uptimeSeconds);
|
|
// ----------- Error -----------
|
|
var errors = [];
|
|
if (((_c = state === null || state === void 0 ? void 0 : state.error) !== null && _c !== void 0 ? _c : '').trim().length > 0)
|
|
errors.push(state.error);
|
|
if (((_e = (_d = state === null || state === void 0 ? void 0 : state.processStatus) === null || _d === void 0 ? void 0 : _d.error) !== null && _e !== void 0 ? _e : '').trim().length > 0)
|
|
errors.push(state.processStatus.error);
|
|
if (errors.length > 0) {
|
|
this.errorText.innerText = errors.join('\n');
|
|
this.errorContainer.style.display = 'block';
|
|
}
|
|
else {
|
|
this.errorContainer.style.display = 'none';
|
|
this.errorText.innerText = '';
|
|
}
|
|
this._Main.Logs.setCameraLogs(state.processStatus.output.current);
|
|
};
|
|
DashboardCameraRunner.prototype.registerListeners = function () {
|
|
var _this = this;
|
|
this._Main.socket.on('cameraRunnerState', function (state) {
|
|
_this.updateState(state);
|
|
});
|
|
this.restartButton.addEventListener('click', function () { return __awaiter$2(_this, void 0, void 0, function () {
|
|
return __generator$2(this, function (_a) {
|
|
this.executeCommand('restart', 'Are you sure you want to restart the Camera Runner process?');
|
|
return [2 /*return*/];
|
|
});
|
|
}); });
|
|
this.rebootButton.addEventListener('click', function () { return __awaiter$2(_this, void 0, void 0, function () {
|
|
return __generator$2(this, function (_a) {
|
|
this.executeCommand('reboot', 'Are you sure you want to reboot the Camera Runner machine?');
|
|
return [2 /*return*/];
|
|
});
|
|
}); });
|
|
};
|
|
DashboardCameraRunner.prototype.executeCommand = function (command, message) {
|
|
return __awaiter$2(this, void 0, void 0, function () {
|
|
var confirmed;
|
|
return __generator$2(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0: return [4 /*yield*/, morphux_1$3.MorphFeature.Confirm({
|
|
title: 'Are you sure?',
|
|
message: message,
|
|
})];
|
|
case 1:
|
|
confirmed = _a.sent();
|
|
if (!confirmed)
|
|
return [2 /*return*/];
|
|
morphux_1$3.MorphFeature.Loader({
|
|
active: true,
|
|
message: "Requesting Camera Runner ".concat(command, "..."),
|
|
});
|
|
this._Main.socket.emit('cameraRunner', command, function (response) {
|
|
morphux_1$3.MorphFeature.Loader({ active: false });
|
|
if (!response.succeed)
|
|
return morphux_1$3.MorphFeature.Alert({
|
|
title: 'Error',
|
|
message: response.message,
|
|
});
|
|
morphux_1$3.MorphFeature.Notification({
|
|
level: 'success',
|
|
message: "Camera Runner is ".concat(command, "ing..."),
|
|
});
|
|
});
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return DashboardCameraRunner;
|
|
}());
|
|
dashboard_camerarunner.DashboardCameraRunner = DashboardCameraRunner;
|
|
|
|
var logsHandler = {};
|
|
|
|
var __makeTemplateObject = (undefined && undefined.__makeTemplateObject) || function (cooked, raw) {
|
|
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
|
return cooked;
|
|
};
|
|
var PacketKind;
|
|
(function (PacketKind) {
|
|
PacketKind[PacketKind["EOS"] = 0] = "EOS";
|
|
PacketKind[PacketKind["Text"] = 1] = "Text";
|
|
PacketKind[PacketKind["Incomplete"] = 2] = "Incomplete";
|
|
PacketKind[PacketKind["ESC"] = 3] = "ESC";
|
|
PacketKind[PacketKind["Unknown"] = 4] = "Unknown";
|
|
PacketKind[PacketKind["SGR"] = 5] = "SGR";
|
|
PacketKind[PacketKind["OSCURL"] = 6] = "OSCURL";
|
|
})(PacketKind || (PacketKind = {}));
|
|
class AnsiUp {
|
|
constructor() {
|
|
this.VERSION = "6.0.6";
|
|
this.setup_palettes();
|
|
this._use_classes = false;
|
|
this.bold = false;
|
|
this.faint = false;
|
|
this.italic = false;
|
|
this.underline = false;
|
|
this.fg = this.bg = null;
|
|
this._buffer = '';
|
|
this._url_allowlist = { 'http': 1, 'https': 1 };
|
|
this._escape_html = true;
|
|
this.boldStyle = 'font-weight:bold';
|
|
this.faintStyle = 'opacity:0.7';
|
|
this.italicStyle = 'font-style:italic';
|
|
this.underlineStyle = 'text-decoration:underline';
|
|
}
|
|
set use_classes(arg) {
|
|
this._use_classes = arg;
|
|
}
|
|
get use_classes() {
|
|
return this._use_classes;
|
|
}
|
|
set url_allowlist(arg) {
|
|
this._url_allowlist = arg;
|
|
}
|
|
get url_allowlist() {
|
|
return this._url_allowlist;
|
|
}
|
|
set escape_html(arg) {
|
|
this._escape_html = arg;
|
|
}
|
|
get escape_html() {
|
|
return this._escape_html;
|
|
}
|
|
set boldStyle(arg) { this._boldStyle = arg; }
|
|
get boldStyle() { return this._boldStyle; }
|
|
set faintStyle(arg) { this._faintStyle = arg; }
|
|
get faintStyle() { return this._faintStyle; }
|
|
set italicStyle(arg) { this._italicStyle = arg; }
|
|
get italicStyle() { return this._italicStyle; }
|
|
set underlineStyle(arg) { this._underlineStyle = arg; }
|
|
get underlineStyle() { return this._underlineStyle; }
|
|
setup_palettes() {
|
|
this.ansi_colors =
|
|
[
|
|
[
|
|
{ rgb: [0, 0, 0], class_name: "ansi-black" },
|
|
{ rgb: [187, 0, 0], class_name: "ansi-red" },
|
|
{ rgb: [0, 187, 0], class_name: "ansi-green" },
|
|
{ rgb: [187, 187, 0], class_name: "ansi-yellow" },
|
|
{ rgb: [0, 0, 187], class_name: "ansi-blue" },
|
|
{ rgb: [187, 0, 187], class_name: "ansi-magenta" },
|
|
{ rgb: [0, 187, 187], class_name: "ansi-cyan" },
|
|
{ rgb: [255, 255, 255], class_name: "ansi-white" }
|
|
],
|
|
[
|
|
{ rgb: [85, 85, 85], class_name: "ansi-bright-black" },
|
|
{ rgb: [255, 85, 85], class_name: "ansi-bright-red" },
|
|
{ rgb: [0, 255, 0], class_name: "ansi-bright-green" },
|
|
{ rgb: [255, 255, 85], class_name: "ansi-bright-yellow" },
|
|
{ rgb: [85, 85, 255], class_name: "ansi-bright-blue" },
|
|
{ rgb: [255, 85, 255], class_name: "ansi-bright-magenta" },
|
|
{ rgb: [85, 255, 255], class_name: "ansi-bright-cyan" },
|
|
{ rgb: [255, 255, 255], class_name: "ansi-bright-white" }
|
|
]
|
|
];
|
|
this.palette_256 = [];
|
|
this.ansi_colors.forEach(palette => {
|
|
palette.forEach(rec => {
|
|
this.palette_256.push(rec);
|
|
});
|
|
});
|
|
let levels = [0, 95, 135, 175, 215, 255];
|
|
for (let r = 0; r < 6; ++r) {
|
|
for (let g = 0; g < 6; ++g) {
|
|
for (let b = 0; b < 6; ++b) {
|
|
let col = { rgb: [levels[r], levels[g], levels[b]], class_name: 'truecolor' };
|
|
this.palette_256.push(col);
|
|
}
|
|
}
|
|
}
|
|
let grey_level = 8;
|
|
for (let i = 0; i < 24; ++i, grey_level += 10) {
|
|
let gry = { rgb: [grey_level, grey_level, grey_level], class_name: 'truecolor' };
|
|
this.palette_256.push(gry);
|
|
}
|
|
}
|
|
escape_txt_for_html(txt) {
|
|
if (!this._escape_html)
|
|
return txt;
|
|
return txt.replace(/[&<>"']/gm, (str) => {
|
|
if (str === "&")
|
|
return "&";
|
|
if (str === "<")
|
|
return "<";
|
|
if (str === ">")
|
|
return ">";
|
|
if (str === "\"")
|
|
return """;
|
|
if (str === "'")
|
|
return "'";
|
|
});
|
|
}
|
|
append_buffer(txt) {
|
|
var str = this._buffer + txt;
|
|
this._buffer = str;
|
|
}
|
|
get_next_packet() {
|
|
var pkt = {
|
|
kind: PacketKind.EOS,
|
|
text: '',
|
|
url: ''
|
|
};
|
|
var len = this._buffer.length;
|
|
if (len == 0)
|
|
return pkt;
|
|
var pos = this._buffer.indexOf("\x1B");
|
|
if (pos == -1) {
|
|
pkt.kind = PacketKind.Text;
|
|
pkt.text = this._buffer;
|
|
this._buffer = '';
|
|
return pkt;
|
|
}
|
|
if (pos > 0) {
|
|
pkt.kind = PacketKind.Text;
|
|
pkt.text = this._buffer.slice(0, pos);
|
|
this._buffer = this._buffer.slice(pos);
|
|
return pkt;
|
|
}
|
|
if (pos == 0) {
|
|
if (len < 3) {
|
|
pkt.kind = PacketKind.Incomplete;
|
|
return pkt;
|
|
}
|
|
var next_char = this._buffer.charAt(1);
|
|
if ((next_char != '[') && (next_char != ']') && (next_char != '(')) {
|
|
pkt.kind = PacketKind.ESC;
|
|
pkt.text = this._buffer.slice(0, 1);
|
|
this._buffer = this._buffer.slice(1);
|
|
return pkt;
|
|
}
|
|
if (next_char == '[') {
|
|
if (!this._csi_regex) {
|
|
this._csi_regex = rgx(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n ^ # beginning of line\n #\n # First attempt\n (?: # legal sequence\n \u001B[ # CSI\n ([<-?]?) # private-mode char\n ([d;]*) # any digits or semicolons\n ([ -/]? # an intermediate modifier\n [@-~]) # the command\n )\n | # alternate (second attempt)\n (?: # illegal sequence\n \u001B[ # CSI\n [ -~]* # anything legal\n ([\0-\u001F:]) # anything illegal\n )\n "], ["\n ^ # beginning of line\n #\n # First attempt\n (?: # legal sequence\n \\x1b\\[ # CSI\n ([\\x3c-\\x3f]?) # private-mode char\n ([\\d;]*) # any digits or semicolons\n ([\\x20-\\x2f]? # an intermediate modifier\n [\\x40-\\x7e]) # the command\n )\n | # alternate (second attempt)\n (?: # illegal sequence\n \\x1b\\[ # CSI\n [\\x20-\\x7e]* # anything legal\n ([\\x00-\\x1f:]) # anything illegal\n )\n "])));
|
|
}
|
|
let match = this._buffer.match(this._csi_regex);
|
|
if (match === null) {
|
|
pkt.kind = PacketKind.Incomplete;
|
|
return pkt;
|
|
}
|
|
if (match[4]) {
|
|
pkt.kind = PacketKind.ESC;
|
|
pkt.text = this._buffer.slice(0, 1);
|
|
this._buffer = this._buffer.slice(1);
|
|
return pkt;
|
|
}
|
|
if ((match[1] != '') || (match[3] != 'm'))
|
|
pkt.kind = PacketKind.Unknown;
|
|
else
|
|
pkt.kind = PacketKind.SGR;
|
|
pkt.text = match[2];
|
|
var rpos = match[0].length;
|
|
this._buffer = this._buffer.slice(rpos);
|
|
return pkt;
|
|
}
|
|
else if (next_char == ']') {
|
|
if (len < 4) {
|
|
pkt.kind = PacketKind.Incomplete;
|
|
return pkt;
|
|
}
|
|
if ((this._buffer.charAt(2) != '8')
|
|
|| (this._buffer.charAt(3) != ';')) {
|
|
pkt.kind = PacketKind.ESC;
|
|
pkt.text = this._buffer.slice(0, 1);
|
|
this._buffer = this._buffer.slice(1);
|
|
return pkt;
|
|
}
|
|
if (!this._osc_st) {
|
|
this._osc_st = rgxG(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n (?: # legal sequence\n (\u001B\\) # ESC | # alternate\n (\u0007) # BEL (what xterm did)\n )\n | # alternate (second attempt)\n ( # illegal sequence\n [\0-\u0006] # anything illegal\n | # alternate\n [\b-\u001A] # anything illegal\n | # alternate\n [\u001C-\u001F] # anything illegal\n )\n "], ["\n (?: # legal sequence\n (\\x1b\\\\) # ESC \\\n | # alternate\n (\\x07) # BEL (what xterm did)\n )\n | # alternate (second attempt)\n ( # illegal sequence\n [\\x00-\\x06] # anything illegal\n | # alternate\n [\\x08-\\x1a] # anything illegal\n | # alternate\n [\\x1c-\\x1f] # anything illegal\n )\n "])));
|
|
}
|
|
this._osc_st.lastIndex = 0;
|
|
{
|
|
let match = this._osc_st.exec(this._buffer);
|
|
if (match === null) {
|
|
pkt.kind = PacketKind.Incomplete;
|
|
return pkt;
|
|
}
|
|
if (match[3]) {
|
|
pkt.kind = PacketKind.ESC;
|
|
pkt.text = this._buffer.slice(0, 1);
|
|
this._buffer = this._buffer.slice(1);
|
|
return pkt;
|
|
}
|
|
}
|
|
{
|
|
let match = this._osc_st.exec(this._buffer);
|
|
if (match === null) {
|
|
pkt.kind = PacketKind.Incomplete;
|
|
return pkt;
|
|
}
|
|
if (match[3]) {
|
|
pkt.kind = PacketKind.ESC;
|
|
pkt.text = this._buffer.slice(0, 1);
|
|
this._buffer = this._buffer.slice(1);
|
|
return pkt;
|
|
}
|
|
}
|
|
if (!this._osc_regex) {
|
|
this._osc_regex = rgx(templateObject_3 || (templateObject_3 = __makeTemplateObject(["\n ^ # beginning of line\n #\n \u001B]8; # OSC Hyperlink\n [ -:<-~]* # params (excluding ;)\n ; # end of params\n ([!-~]{0,512}) # URL capture\n (?: # ST\n (?:\u001B\\) # ESC | # alternate\n (?:\u0007) # BEL (what xterm did)\n )\n ([ -~]+) # TEXT capture\n \u001B]8;; # OSC Hyperlink End\n (?: # ST\n (?:\u001B\\) # ESC | # alternate\n (?:\u0007) # BEL (what xterm did)\n )\n "], ["\n ^ # beginning of line\n #\n \\x1b\\]8; # OSC Hyperlink\n [\\x20-\\x3a\\x3c-\\x7e]* # params (excluding ;)\n ; # end of params\n ([\\x21-\\x7e]{0,512}) # URL capture\n (?: # ST\n (?:\\x1b\\\\) # ESC \\\n | # alternate\n (?:\\x07) # BEL (what xterm did)\n )\n ([\\x20-\\x7e]+) # TEXT capture\n \\x1b\\]8;; # OSC Hyperlink End\n (?: # ST\n (?:\\x1b\\\\) # ESC \\\n | # alternate\n (?:\\x07) # BEL (what xterm did)\n )\n "])));
|
|
}
|
|
let match = this._buffer.match(this._osc_regex);
|
|
if (match === null) {
|
|
pkt.kind = PacketKind.ESC;
|
|
pkt.text = this._buffer.slice(0, 1);
|
|
this._buffer = this._buffer.slice(1);
|
|
return pkt;
|
|
}
|
|
pkt.kind = PacketKind.OSCURL;
|
|
pkt.url = match[1];
|
|
pkt.text = match[2];
|
|
var rpos = match[0].length;
|
|
this._buffer = this._buffer.slice(rpos);
|
|
return pkt;
|
|
}
|
|
else if (next_char == '(') {
|
|
pkt.kind = PacketKind.Unknown;
|
|
this._buffer = this._buffer.slice(3);
|
|
return pkt;
|
|
}
|
|
}
|
|
}
|
|
ansi_to_html(txt) {
|
|
this.append_buffer(txt);
|
|
var blocks = [];
|
|
while (true) {
|
|
var packet = this.get_next_packet();
|
|
if ((packet.kind == PacketKind.EOS)
|
|
|| (packet.kind == PacketKind.Incomplete))
|
|
break;
|
|
if ((packet.kind == PacketKind.ESC)
|
|
|| (packet.kind == PacketKind.Unknown))
|
|
continue;
|
|
if (packet.kind == PacketKind.Text)
|
|
blocks.push(this.transform_to_html(this.with_state(packet)));
|
|
else if (packet.kind == PacketKind.SGR)
|
|
this.process_ansi(packet);
|
|
else if (packet.kind == PacketKind.OSCURL)
|
|
blocks.push(this.process_hyperlink(packet));
|
|
}
|
|
return blocks.join("");
|
|
}
|
|
with_state(pkt) {
|
|
return { bold: this.bold, faint: this.faint, italic: this.italic, underline: this.underline, fg: this.fg, bg: this.bg, text: pkt.text };
|
|
}
|
|
process_ansi(pkt) {
|
|
let sgr_cmds = pkt.text.split(';');
|
|
while (sgr_cmds.length > 0) {
|
|
let sgr_cmd_str = sgr_cmds.shift();
|
|
let num = parseInt(sgr_cmd_str, 10);
|
|
if (isNaN(num) || num === 0) {
|
|
this.fg = null;
|
|
this.bg = null;
|
|
this.bold = false;
|
|
this.faint = false;
|
|
this.italic = false;
|
|
this.underline = false;
|
|
}
|
|
else if (num === 1) {
|
|
this.bold = true;
|
|
}
|
|
else if (num === 2) {
|
|
this.faint = true;
|
|
}
|
|
else if (num === 3) {
|
|
this.italic = true;
|
|
}
|
|
else if (num === 4) {
|
|
this.underline = true;
|
|
}
|
|
else if (num === 21) {
|
|
this.bold = false;
|
|
}
|
|
else if (num === 22) {
|
|
this.faint = false;
|
|
this.bold = false;
|
|
}
|
|
else if (num === 23) {
|
|
this.italic = false;
|
|
}
|
|
else if (num === 24) {
|
|
this.underline = false;
|
|
}
|
|
else if (num === 39) {
|
|
this.fg = null;
|
|
}
|
|
else if (num === 49) {
|
|
this.bg = null;
|
|
}
|
|
else if ((num >= 30) && (num < 38)) {
|
|
this.fg = this.ansi_colors[0][(num - 30)];
|
|
}
|
|
else if ((num >= 40) && (num < 48)) {
|
|
this.bg = this.ansi_colors[0][(num - 40)];
|
|
}
|
|
else if ((num >= 90) && (num < 98)) {
|
|
this.fg = this.ansi_colors[1][(num - 90)];
|
|
}
|
|
else if ((num >= 100) && (num < 108)) {
|
|
this.bg = this.ansi_colors[1][(num - 100)];
|
|
}
|
|
else if (num === 38 || num === 48) {
|
|
if (sgr_cmds.length > 0) {
|
|
let is_foreground = (num === 38);
|
|
let mode_cmd = sgr_cmds.shift();
|
|
if (mode_cmd === '5' && sgr_cmds.length > 0) {
|
|
let palette_index = parseInt(sgr_cmds.shift(), 10);
|
|
if (palette_index >= 0 && palette_index <= 255) {
|
|
if (is_foreground)
|
|
this.fg = this.palette_256[palette_index];
|
|
else
|
|
this.bg = this.palette_256[palette_index];
|
|
}
|
|
}
|
|
if (mode_cmd === '2' && sgr_cmds.length > 2) {
|
|
let r = parseInt(sgr_cmds.shift(), 10);
|
|
let g = parseInt(sgr_cmds.shift(), 10);
|
|
let b = parseInt(sgr_cmds.shift(), 10);
|
|
if ((r >= 0 && r <= 255) && (g >= 0 && g <= 255) && (b >= 0 && b <= 255)) {
|
|
let c = { rgb: [r, g, b], class_name: 'truecolor' };
|
|
if (is_foreground)
|
|
this.fg = c;
|
|
else
|
|
this.bg = c;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
transform_to_html(fragment) {
|
|
let txt = fragment.text;
|
|
if (txt.length === 0)
|
|
return txt;
|
|
txt = this.escape_txt_for_html(txt);
|
|
if (!fragment.bold && !fragment.italic && !fragment.faint && !fragment.underline && fragment.fg === null && fragment.bg === null)
|
|
return txt;
|
|
let styles = [];
|
|
let classes = [];
|
|
let fg = fragment.fg;
|
|
let bg = fragment.bg;
|
|
if (fragment.bold)
|
|
styles.push(this._boldStyle);
|
|
if (fragment.faint)
|
|
styles.push(this._faintStyle);
|
|
if (fragment.italic)
|
|
styles.push(this._italicStyle);
|
|
if (fragment.underline)
|
|
styles.push(this._underlineStyle);
|
|
if (!this._use_classes) {
|
|
if (fg)
|
|
styles.push(`color:rgb(${fg.rgb.join(',')})`);
|
|
if (bg)
|
|
styles.push(`background-color:rgb(${bg.rgb})`);
|
|
}
|
|
else {
|
|
if (fg) {
|
|
if (fg.class_name !== 'truecolor') {
|
|
classes.push(`${fg.class_name}-fg`);
|
|
}
|
|
else {
|
|
styles.push(`color:rgb(${fg.rgb.join(',')})`);
|
|
}
|
|
}
|
|
if (bg) {
|
|
if (bg.class_name !== 'truecolor') {
|
|
classes.push(`${bg.class_name}-bg`);
|
|
}
|
|
else {
|
|
styles.push(`background-color:rgb(${bg.rgb.join(',')})`);
|
|
}
|
|
}
|
|
}
|
|
let class_string = '';
|
|
let style_string = '';
|
|
if (classes.length)
|
|
class_string = ` class="${classes.join(' ')}"`;
|
|
if (styles.length)
|
|
style_string = ` style="${styles.join(';')}"`;
|
|
return `<span${style_string}${class_string}>${txt}</span>`;
|
|
}
|
|
;
|
|
process_hyperlink(pkt) {
|
|
let parts = pkt.url.split(':');
|
|
if (parts.length < 1)
|
|
return '';
|
|
if (!this._url_allowlist[parts[0]])
|
|
return '';
|
|
let result = `<a href="${this.escape_txt_for_html(pkt.url)}">${this.escape_txt_for_html(pkt.text)}</a>`;
|
|
return result;
|
|
}
|
|
}
|
|
function rgx(tmplObj, ...subst) {
|
|
let regexText = tmplObj.raw[0];
|
|
let wsrgx = /^\s+|\s+\n|\s*#[\s\S]*?\n|\n/gm;
|
|
let txt2 = regexText.replace(wsrgx, '');
|
|
return new RegExp(txt2);
|
|
}
|
|
function rgxG(tmplObj, ...subst) {
|
|
let regexText = tmplObj.raw[0];
|
|
let wsrgx = /^\s+|\s+\n|\s*#[\s\S]*?\n|\n/gm;
|
|
let txt2 = regexText.replace(wsrgx, '');
|
|
return new RegExp(txt2, 'g');
|
|
}
|
|
var templateObject_1, templateObject_2, templateObject_3;
|
|
|
|
var ansi_up = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
AnsiUp: AnsiUp
|
|
});
|
|
|
|
var require$$1 = /*@__PURE__*/getAugmentedNamespace(ansi_up);
|
|
|
|
var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator$1 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(logsHandler, "__esModule", { value: true });
|
|
logsHandler.LogsHandler = void 0;
|
|
var morphux_1$2 = requireIndex();
|
|
var ansi_up_1 = require$$1;
|
|
var LogsHandler = /** @class */ (function () {
|
|
function LogsHandler(Main) {
|
|
this.ansiUp = new ansi_up_1.AnsiUp();
|
|
this.cameraLogsContainer = document.querySelector('.ntsh_tab[tabid="cameralogs"] .ntsh_logs');
|
|
this.unityLogsContainer = document.querySelector('.ntsh_tab[tabid="unitylogs"] .ntsh_logs');
|
|
this.firstTime = new Set();
|
|
this._Main = Main;
|
|
this.registerListeners();
|
|
}
|
|
LogsHandler.prototype.setCameraLogs = function (logs) {
|
|
this.applyLogs(this.cameraLogsContainer, logs);
|
|
};
|
|
LogsHandler.prototype.setUnityLogs = function (logs) {
|
|
this.applyLogs(this.unityLogsContainer, logs);
|
|
};
|
|
LogsHandler.prototype.applyLogs = function (container, logs) {
|
|
return __awaiter$1(this, void 0, void 0, function () {
|
|
var logCount, isAtBottom;
|
|
var _this = this;
|
|
return __generator$1(this, function (_a) {
|
|
logCount = container.querySelectorAll('.ntsh_log.ntsh_log-normal').length;
|
|
if (logCount === logs.length)
|
|
return [2 /*return*/];
|
|
if (logCount > logs.length)
|
|
logCount = 0;
|
|
isAtBottom = !this.firstTime.has(container) ||
|
|
container.scrollTop + container.clientHeight >=
|
|
container.scrollHeight;
|
|
container.innerHTML = '';
|
|
logs.forEach(function (log, i) {
|
|
var element = (0, morphux_1$2.ce)('div', ['ntsh_log', 'ntsh_log-normal'], null, null, _this.ansiUp.ansi_to_html(log));
|
|
if (_this.firstTime.has(container) && i > logCount - 1) {
|
|
element.style.display = 'none';
|
|
var spawnDelay = (i - logCount) * 10;
|
|
setTimeout(function () {
|
|
element.style.display = 'block';
|
|
if (isAtBottom)
|
|
container.scrollTop = container.scrollHeight;
|
|
}, spawnDelay);
|
|
}
|
|
container.appendChild(element);
|
|
if (isAtBottom)
|
|
container.scrollTop = container.scrollHeight;
|
|
});
|
|
if (!this.firstTime.has(container)) {
|
|
container.scrollTop = container.scrollHeight;
|
|
this.firstTime.add(container);
|
|
}
|
|
return [2 /*return*/];
|
|
});
|
|
});
|
|
};
|
|
LogsHandler.prototype.registerListeners = function () {
|
|
var _this = this;
|
|
this._Main.TabController.registerListener('cameralogs', function (visible) {
|
|
if (!visible)
|
|
return;
|
|
setTimeout(function () {
|
|
_this.cameraLogsContainer.scrollTop =
|
|
_this.cameraLogsContainer.scrollHeight;
|
|
}, 10);
|
|
});
|
|
this._Main.TabController.registerListener('unitylogs', function (visible) {
|
|
if (!visible)
|
|
return;
|
|
setTimeout(function () {
|
|
_this.unityLogsContainer.scrollTop =
|
|
_this.unityLogsContainer.scrollHeight;
|
|
}, 10);
|
|
});
|
|
};
|
|
return LogsHandler;
|
|
}());
|
|
logsHandler.LogsHandler = LogsHandler;
|
|
|
|
var calibration = {};
|
|
|
|
Object.defineProperty(calibration, "__esModule", { value: true });
|
|
calibration.Calibration = void 0;
|
|
var Calibration = /** @class */ (function () {
|
|
function Calibration(Main) {
|
|
this.container = document.querySelector('.ntsh_calibration');
|
|
this.image = this.container.querySelector('img');
|
|
this.fullscreenButton = this.container.querySelector('.ntsh_calibration-fullscreen');
|
|
this._Main = Main;
|
|
this.registerListeners();
|
|
}
|
|
Calibration.prototype.startFetchClock = function () {
|
|
var _this = this;
|
|
this.image.src = "/calibrationImage?t=".concat(Date.now());
|
|
this.fetchClock = setInterval(function () {
|
|
_this.image.src = "/calibrationImage?t=".concat(Date.now());
|
|
}, 1000);
|
|
};
|
|
Calibration.prototype.stopFetchClock = function () {
|
|
clearInterval(this.fetchClock);
|
|
};
|
|
Calibration.prototype.registerListeners = function () {
|
|
var _this = this;
|
|
this._Main.TabController.registerListener('calibration', function (visible) {
|
|
if (visible)
|
|
_this.startFetchClock();
|
|
else
|
|
_this.stopFetchClock();
|
|
});
|
|
this.fullscreenButton.addEventListener('click', function () {
|
|
_this.image.requestFullscreen();
|
|
});
|
|
};
|
|
return Calibration;
|
|
}());
|
|
calibration.Calibration = Calibration;
|
|
|
|
var dashboard_unity = {};
|
|
|
|
var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(dashboard_unity, "__esModule", { value: true });
|
|
dashboard_unity.DashboardUnity = void 0;
|
|
var morphux_1$1 = requireIndex();
|
|
var utils_1 = utils;
|
|
var DashboardUnity = /** @class */ (function () {
|
|
function DashboardUnity(Main) {
|
|
this.container = document.querySelector('.ntsh_dashboard-unity');
|
|
this.processStatus = document.querySelector('.ntsh_dashboard-unity-processstatus');
|
|
this.processInfo = document.querySelector('.ntsh_dashboard-unity-processinfo');
|
|
this.restartButton = document.querySelector('.ntsh_dashboard-unity-restart');
|
|
this.uptimeInfo = document.querySelector('.ntsh_dashboard-unity-uptime');
|
|
this.webSocketStatus = document.querySelector('.ntsh_dashboard-unity-websocketstatus');
|
|
this.webSocketInfo = document.querySelector('.ntsh_dashboard-unity-websocketinfo');
|
|
this.zedStreamStatus = document.querySelector('.ntsh_dashboard-unity-zedstreamstatus');
|
|
this.zedStreamInfo = document.querySelector('.ntsh_dashboard-unity-zedstreaminfo');
|
|
this.zedStreamFps = document.querySelector('.ntsh_dashboard-unity-zedstreamfps');
|
|
this.zedStreamPath = document.querySelector('.ntsh_dashboard-unity-zedstreampath');
|
|
this.timelineWatching = document.querySelector('.ntsh_dashboard-unity-timeline-watching');
|
|
this.timelineStanding = document.querySelector('.ntsh_dashboard-unity-timeline-standing');
|
|
this.timelineProgress = document.querySelector('.ntsh_dashboard-unity-timeline-progress');
|
|
this.parametersTable = document.querySelector('.ntsh_dashboard-unity-parameters');
|
|
this.errorContainer = document.querySelector('.ntsh_dashboard-unity-error');
|
|
this.errorText = document.querySelector('.ntsh_dashboard-unity-errortext');
|
|
this._Main = Main;
|
|
this.registerListeners();
|
|
}
|
|
DashboardUnity.prototype.updateRunnerState = function (state) {
|
|
var _a, _b;
|
|
// ----------- Process -----------
|
|
if (state.state != 'RUNNING') {
|
|
state.startTime = -1;
|
|
this.restartButton.style.display = 'none';
|
|
}
|
|
else {
|
|
this.restartButton.style.display = 'flex';
|
|
}
|
|
(0, utils_1.setStatusState)(this.processStatus, {
|
|
RUNNING: 'green',
|
|
STOPPED: 'red',
|
|
STARTING: 'yellow',
|
|
PROBLEM: 'red',
|
|
}[state.state]);
|
|
this.processInfo.innerText = (_a = state.message) !== null && _a !== void 0 ? _a : '';
|
|
// ----------- Uptime -----------
|
|
var uptimeSeconds = state.startTime == -1 ? -1 : (Date.now() - state.startTime) / 1000;
|
|
this.uptimeInfo.innerText = (0, utils_1.formatUptime)(uptimeSeconds);
|
|
// ----------- Error -----------
|
|
if (((_b = state === null || state === void 0 ? void 0 : state.error) !== null && _b !== void 0 ? _b : '').trim().length > 0)
|
|
this.runnerError = state.error;
|
|
else
|
|
this.runnerError = null;
|
|
this.updateError();
|
|
this._Main.Logs.setUnityLogs(state.output.current);
|
|
};
|
|
DashboardUnity.prototype.updateWebSocketState = function (state) {
|
|
var _a, _b;
|
|
// ----------- WebSocket -----------
|
|
(0, utils_1.setStatusState)(this.webSocketStatus, {
|
|
CONNECTING: 'yellow',
|
|
CONNECTED: 'green',
|
|
DISCONNECTED: 'gray',
|
|
FAILED: 'red',
|
|
}[state.state]);
|
|
this.webSocketInfo.innerText = (_a = state.message) !== null && _a !== void 0 ? _a : '';
|
|
// ----------- ZED Stream -----------
|
|
(0, utils_1.setStatusState)(this.zedStreamStatus, state.parameters.zedReady ? 'green' : 'red');
|
|
this.zedStreamInfo.innerText = state.parameters.zedReady
|
|
? "Connected to ".concat(state.parameters.zedPath)
|
|
: 'Not ready';
|
|
this.zedStreamFps.innerText =
|
|
state.parameters.zedFPS == '-' ? '' : state.parameters.zedFPS;
|
|
// ----------- Timeline -----------
|
|
this.timelineWatching.innerText = state.parameters.timelineWatching
|
|
? 'Yes'
|
|
: 'No';
|
|
this.timelineStanding.innerText = state.parameters.timelineStanding
|
|
? 'Yes'
|
|
: 'No';
|
|
(0, utils_1.setProgressState)(this.timelineProgress, state.parameters.timelineProgress);
|
|
// ----------- Parameters -----------
|
|
this.renderParameterSliders(state.parameters.parameters);
|
|
// ----------- Error -----------
|
|
if (((_b = state === null || state === void 0 ? void 0 : state.error) !== null && _b !== void 0 ? _b : '').trim().length > 0)
|
|
this.webSocketError = state.error;
|
|
else
|
|
this.webSocketError = null;
|
|
this.updateError();
|
|
};
|
|
DashboardUnity.prototype.renderParameterSliders = function (parameters) {
|
|
var _this = this;
|
|
if (parameters.length === 0)
|
|
return;
|
|
var existingSliders = this.parametersTable.querySelectorAll('.ntsh_dashboard-unity-parameter-row');
|
|
if (existingSliders.length !== parameters.length) {
|
|
this.parametersTable.innerHTML = '';
|
|
parameters.forEach(function (param) {
|
|
var row = (0, morphux_1$1.ce)('tr', 'ntsh_dashboard-unity-parameter-row');
|
|
var nameCell = (0, morphux_1$1.ce)('td');
|
|
nameCell.appendChild((0, morphux_1$1.ce)('div', 'mux_text', null, param.sliderName));
|
|
row.appendChild(nameCell);
|
|
var progressCell = (0, morphux_1$1.ce)('td', 'no-service');
|
|
progressCell.appendChild((0, utils_1.createProgress)(param.outputValue));
|
|
row.appendChild(progressCell);
|
|
var sliderCell = (0, morphux_1$1.ce)('td', 'only-service');
|
|
var sliderProgress = (0, utils_1.createProgress)(param.outputValue);
|
|
var sliderValue = sliderProgress.querySelector('.ntsh_progress-value');
|
|
sliderValue.classList.add('mux_resizer');
|
|
sliderCell.appendChild(sliderProgress);
|
|
var resizer = new morphux_1$1.MorphComponent.Resizer({
|
|
existingContainer: sliderValue,
|
|
direction: 'right',
|
|
relative: true,
|
|
min: 0,
|
|
max: function () { return sliderProgress.clientWidth; },
|
|
});
|
|
var lastPercentage = -1;
|
|
resizer.on('resized', function (size) {
|
|
var percentage = Math.round((size / sliderProgress.clientWidth) * 100) /
|
|
100;
|
|
if (percentage === lastPercentage)
|
|
return;
|
|
lastPercentage = percentage;
|
|
_this._Main.socket.emit('unityWebSocket', 'parameterValue', param.sliderIndex, percentage);
|
|
(0, utils_1.setProgressState)(sliderProgress, percentage);
|
|
});
|
|
row.appendChild(sliderCell);
|
|
_this.parametersTable.appendChild(row);
|
|
});
|
|
}
|
|
else {
|
|
existingSliders.forEach(function (row, index) {
|
|
var value = parameters[index].outputValue;
|
|
var progressElement = row.querySelector('.no-service .ntsh_progress');
|
|
(0, utils_1.setProgressState)(progressElement, value);
|
|
var sliderElement = row.querySelector('.only-service .ntsh_progress');
|
|
if (sliderElement.querySelector('.mux_resizer-moving') == null)
|
|
(0, utils_1.setProgressState)(sliderElement, value);
|
|
});
|
|
}
|
|
};
|
|
DashboardUnity.prototype.updateError = function () {
|
|
var errors = [];
|
|
if (this.runnerError != null)
|
|
errors.push(this.runnerError);
|
|
if (this.webSocketError != null)
|
|
errors.push(this.webSocketError);
|
|
if (errors.length > 0) {
|
|
this.errorText.innerText = errors.join('\n');
|
|
this.errorContainer.style.display = 'block';
|
|
}
|
|
else {
|
|
this.errorContainer.style.display = 'none';
|
|
this.errorText.innerText = '';
|
|
}
|
|
};
|
|
DashboardUnity.prototype.registerListeners = function () {
|
|
var _this = this;
|
|
this._Main.socket.on('unityRunnerState', function (state) {
|
|
return _this.updateRunnerState(state);
|
|
});
|
|
this._Main.socket.on('unityWebSocketState', function (state) { return _this.updateWebSocketState(state); });
|
|
this.restartButton.addEventListener('click', function () { return __awaiter(_this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
this.executeCommand('restart', 'Are you sure you want to restart the Unity Runner process?');
|
|
return [2 /*return*/];
|
|
});
|
|
}); });
|
|
};
|
|
DashboardUnity.prototype.executeCommand = function (command, message) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var confirmed;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0: return [4 /*yield*/, morphux_1$1.MorphFeature.Confirm({
|
|
title: 'Are you sure?',
|
|
message: message,
|
|
})];
|
|
case 1:
|
|
confirmed = _a.sent();
|
|
if (!confirmed)
|
|
return [2 /*return*/];
|
|
morphux_1$1.MorphFeature.Loader({
|
|
active: true,
|
|
message: "Requesting Unity Runner ".concat(command, "..."),
|
|
});
|
|
this._Main.socket.emit('unityRunner', command, function (response) {
|
|
morphux_1$1.MorphFeature.Loader({ active: false });
|
|
if (!response.succeed)
|
|
return morphux_1$1.MorphFeature.Alert({
|
|
title: 'Error',
|
|
message: response.message,
|
|
});
|
|
morphux_1$1.MorphFeature.Notification({
|
|
level: 'success',
|
|
message: "Unity Runner is ".concat(command, "ing..."),
|
|
});
|
|
});
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return DashboardUnity;
|
|
}());
|
|
dashboard_unity.DashboardUnity = DashboardUnity;
|
|
|
|
Object.defineProperty(main$1, "__esModule", { value: true });
|
|
exports.Main = main$1.Main = void 0;
|
|
var socket_io_client_1 = cjsExports;
|
|
var menuBar_1 = menuBar;
|
|
var tabController_1 = tabController;
|
|
var morphux_1 = requireIndex();
|
|
var dashboard_camerarunner_1 = dashboard_camerarunner;
|
|
var logsHandler_1 = logsHandler;
|
|
var calibration_1 = calibration;
|
|
var dashboard_unity_1 = dashboard_unity;
|
|
var socket = (0, socket_io_client_1.io)('/');
|
|
var Main = /** @class */ (function () {
|
|
function Main() {
|
|
this.socket = socket;
|
|
this.MenuBar = new menuBar_1.MenuBar(this);
|
|
this.TabController = new tabController_1.TabController(this);
|
|
this.Logs = new logsHandler_1.LogsHandler(this);
|
|
this.Calibration = new calibration_1.Calibration(this);
|
|
this.DashboardCameraRunner = new dashboard_camerarunner_1.DashboardCameraRunner(this);
|
|
this.DashboardUnityRunner = new dashboard_unity_1.DashboardUnity(this);
|
|
if (window.location.search.includes('debug')) {
|
|
window.SN = this;
|
|
console.log('Debug mode enabled');
|
|
}
|
|
}
|
|
return Main;
|
|
}());
|
|
exports.Main = main$1.Main = Main;
|
|
morphux_1.MorphFeature.Loader({ active: true, message: 'Connecting to server...' });
|
|
socket.on('connect', function () {
|
|
console.log('Connected to server');
|
|
morphux_1.MorphFeature.Loader({ active: false });
|
|
});
|
|
new Main();
|
|
|
|
exports["default"] = main$1;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
return exports;
|
|
|
|
})({});
|
|
//# sourceMappingURL=script.js.map
|