@inweb/viewer-visualize
Version:
JavaScript library for rendering CAD and BIM files in a browser using VisualizeJS
1,431 lines (1,399 loc) • 820 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.ODA = global.ODA || {}, global.ODA.Visualize = global.ODA.Visualize || {})));
})(this, (function (exports) { 'use strict';
class CommandsRegistry {
constructor() {
this._commands = new Map;
}
registerCommand(id, handler, description, thisArg) {
this._commands.set(id, {
id: id,
handler: handler,
thisArg: thisArg,
description: description
});
}
registerCommandAlias(id, alias) {
this.registerCommand(alias, ((viewer, ...args) => this.executeCommand(id, viewer, ...args)));
}
getCommand(id) {
return this._commands.get(id);
}
getCommands() {
const map = new Map;
this._commands.forEach(((value, key) => map.set(key, value)));
return map;
}
executeCommand(id, viewer, ...args) {
const command = this._commands.get(id);
if (!command) {
if (viewer) {
const isDraggerCommand = viewer.draggers.includes(id);
if (isDraggerCommand) return viewer.setActiveDragger(id);
}
console.warn(`Command '${id}' not found`);
return undefined;
}
const {handler: handler, thisArg: thisArg} = command;
const result = handler.apply(thisArg, [ viewer, ...args ]);
viewer === null || viewer === undefined ? undefined : viewer.emit({
type: "command",
data: id,
args: args
});
return result;
}
}
const _commandsRegistry = new Map;
function commandsRegistry(viewerType = "") {
let result = _commandsRegistry.get(viewerType);
if (!result) {
result = new CommandsRegistry;
_commandsRegistry.set(viewerType, result);
}
return result;
}
class Dragger {
constructor(viewer) {
this.name = "";
}
dispose() {}
}
class DraggersRegistry {
constructor() {
this._draggers = new Map;
}
registerDragger(name, provider) {
this._draggers.set(name, provider);
}
registerDraggerAlias(name, alias) {
const provider = this.getDragger(name);
if (provider) this.registerDragger(alias, (viewer => provider(viewer)));
}
getDragger(name) {
return this._draggers.get(name);
}
getDraggers() {
const map = new Map;
this._draggers.forEach(((value, key) => map.set(key, value)));
return map;
}
createDragger(name, viewer) {
const provider = this.getDragger(name);
if (!provider) return null;
const dragger = provider(viewer);
dragger.name = name;
return dragger;
}
}
const _draggersRegistry = new Map;
function draggersRegistry(viewerType = "") {
let result = _draggersRegistry.get(viewerType);
if (!result) {
result = new DraggersRegistry;
_draggersRegistry.set(viewerType, result);
}
return result;
}
class Component {
constructor(viewer) {
this.name = "";
}
dispose() {}
}
class Components {
constructor() {
this._components = new Map;
}
registerComponent(name, provider) {
this._components.set(name, provider);
}
registerComponentAlias(name, alias) {
const provider = this.getComponent(name);
if (provider) this.registerComponent(alias, (viewer => provider(viewer)));
}
getComponent(name) {
return this._components.get(name);
}
getComponents() {
const map = new Map;
this._components.forEach(((value, key) => map.set(key, value)));
return map;
}
createComponent(name, viewer) {
const provider = this.getComponent(name);
if (!provider) return null;
const component = provider(viewer);
component.name = name;
return component;
}
}
const _components = new Map;
function componentsRegistry(viewerType = "") {
let result = _components.get(viewerType);
if (!result) {
result = new Components;
_components.set(viewerType, result);
}
return result;
}
function defaultOptions() {
return {
showWCS: true,
cameraAnimation: true,
antialiasing: true,
groundShadow: false,
shadows: false,
cameraAxisXSpeed: 4,
cameraAxisYSpeed: 1,
ambientOcclusion: false,
enableStreamingMode: true,
enablePartialMode: false,
memoryLimit: 3294967296,
cuttingPlaneFillColor: {
red: 255,
green: 152,
blue: 0
},
edgesColor: {
r: 255,
g: 152,
b: 0
},
facesColor: {
r: 255,
g: 152,
b: 0
},
edgesVisibility: true,
edgesOverlap: true,
facesOverlap: false,
facesTransparancy: 200,
enableCustomHighlight: true,
sceneGraph: false,
edgeModel: true,
reverseZoomWheel: false,
enableZoomWheel: true,
enableGestures: true,
geometryType: "vsfx",
rulerUnit: "Default"
};
}
class Options {
constructor(emitter) {
this._emitter = emitter;
this._data = defaultOptions();
this.loadFromStorage();
}
static defaults() {
return defaultOptions();
}
notifierChangeEvent() {
console.warn("Options.notifierChangeEvent() has been deprecated since 25.3 and will be removed in a future release, use Options.change() instead.");
this.change();
}
change() {
if (this._emitter !== undefined) {
this.saveToStorage();
this._emitter.emit({
type: "optionschange",
data: this
});
}
}
saveToStorage() {
if (typeof window !== "undefined") try {
localStorage.setItem("od-client-settings", JSON.stringify(this.data));
} catch (error) {
console.error("Cannot save client settings.", error);
}
}
loadFromStorage() {
if (typeof window !== "undefined") try {
const item = localStorage.getItem("od-client-settings");
if (item) {
const data = JSON.parse(item);
this.data = {
...data
};
}
} catch (error) {
console.error("Cannot load client settings.", error);
}
}
resetToDefaults(fields) {
if (fields !== undefined) {
const defaults = Options.defaults();
const resetData = fields.reduce(((acc, field) => {
acc[field] = defaults[field];
return acc;
}), {});
this.data = {
...this.data,
...resetData
};
} else {
this.data = {
...this.data,
...Options.defaults()
};
}
}
get data() {
return this._data;
}
set data(value) {
const enablePartialMode = value.enableStreamingMode ? value.enablePartialMode : false;
const sceneGraph = enablePartialMode ? false : value.sceneGraph;
this._data = {
...Options.defaults(),
...this._data,
...value,
enablePartialMode: enablePartialMode,
sceneGraph: sceneGraph
};
this.change();
}
get showWCS() {
return this._data.showWCS;
}
set showWCS(value) {
this._data.showWCS = value;
this.change();
}
get cameraAnimation() {
return this._data.cameraAnimation;
}
set cameraAnimation(value) {
this._data.cameraAnimation = value;
this.change();
}
get antialiasing() {
return this._data.antialiasing;
}
set antialiasing(value) {
this._data.antialiasing = value;
this.change();
}
get groundShadow() {
return this._data.groundShadow;
}
set groundShadow(value) {
this._data.groundShadow = value;
this.change();
}
get shadows() {
return this._data.shadows;
}
set shadows(value) {
this._data.shadows = value;
this.change();
}
get cameraAxisXSpeed() {
return this._data.cameraAxisXSpeed;
}
set cameraAxisXSpeed(value) {
this._data.cameraAxisXSpeed = value;
this.change();
}
get cameraAxisYSpeed() {
return this._data.cameraAxisYSpeed;
}
set cameraAxisYSpeed(value) {
this.cameraAxisYSpeed = value;
this.change();
}
get ambientOcclusion() {
return this._data.ambientOcclusion;
}
set ambientOcclusion(value) {
this._data.ambientOcclusion = value;
this.change();
}
get enableStreamingMode() {
return this._data.enableStreamingMode;
}
set enableStreamingMode(value) {
this._data.enableStreamingMode = value;
if (!value) this._data.enablePartialMode = false;
this.change();
}
get enablePartialMode() {
return this._data.enablePartialMode;
}
set enablePartialMode(value) {
this._data.enablePartialMode = value;
if (value) {
this._data.enableStreamingMode = true;
this._data.sceneGraph = false;
}
this.change();
}
get memoryLimit() {
return this._data.memoryLimit;
}
set memoryLimit(value) {
this._data.memoryLimit = value;
this.change();
}
get cuttingPlaneFillColor() {
return this._data.cuttingPlaneFillColor;
}
set cuttingPlaneFillColor(value) {
this._data.cuttingPlaneFillColor = value;
this.change();
}
get edgesColor() {
return this._data.edgesColor;
}
set edgesColor(value) {
this._data.edgesColor = value;
this.change();
}
get facesColor() {
return this._data.facesColor;
}
set facesColor(value) {
this._data.facesColor = value;
this.change();
}
get edgesVisibility() {
return this._data.edgesVisibility;
}
set edgesVisibility(value) {
this._data.edgesVisibility = value;
this.change();
}
get edgesOverlap() {
return this._data.edgesOverlap;
}
set edgesOverlap(value) {
this._data.edgesOverlap = value;
this.change();
}
get facesOverlap() {
return this._data.facesOverlap;
}
set facesOverlap(value) {
this._data.facesOverlap = value;
this.change();
}
get facesTransparancy() {
return this._data.facesTransparancy;
}
set facesTransparancy(value) {
this._data.facesTransparancy = value;
this.change();
}
get enableCustomHighlight() {
return this._data.enableCustomHighlight;
}
set enableCustomHighlight(value) {
this._data.enableCustomHighlight = value;
this.change();
}
get sceneGraph() {
return this._data.sceneGraph;
}
set sceneGraph(value) {
this._data.sceneGraph = value;
if (value) this._data.enablePartialMode = false;
this.change();
}
get edgeModel() {
return Boolean(this._data.edgeModel);
}
set edgeModel(value) {
this._data.edgeModel = Boolean(value);
this.change();
}
get reverseZoomWheel() {
return this._data.reverseZoomWheel;
}
set reverseZoomWheel(value) {
this._data.reverseZoomWheel = !!value;
this.change();
}
get enableZoomWheel() {
return this._data.enableZoomWheel;
}
set enableZoomWheel(value) {
this._data.enableZoomWheel = !!value;
this.change();
}
get enableGestures() {
return this._data.enableGestures;
}
set enableGestures(value) {
this._data.enableGestures = !!value;
this.change();
}
get geometryType() {
return this._data.geometryType;
}
set geometryType(value) {
this._data.geometryType = value;
this.change();
}
get rulerUnit() {
return this._data.rulerUnit;
}
set rulerUnit(value) {
this._data.rulerUnit = value;
this.change();
}
}
const CanvasEvents = [ "click", "contextmenu", "dblclick", "mousedown", "mouseleave", "mousemove", "mouseup", "pointercancel", "pointerdown", "pointerleave", "pointermove", "pointerup", "touchcancel", "touchend", "touchmove", "touchstart", "wheel" ];
const CANVAS_EVENTS = CanvasEvents;
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var lib$1 = {exports: {}};
var _FullInternals = {};
var _CoreInternals = {};
var Global = {};
var hasRequiredGlobal;
function requireGlobal () {
if (hasRequiredGlobal) return Global;
hasRequiredGlobal = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports._registerNode = exports.Konva = exports.glob = undefined;
const PI_OVER_180 = Math.PI / 180;
function detectBrowser() {
return (typeof window !== 'undefined' &&
({}.toString.call(window) === '[object Window]' ||
{}.toString.call(window) === '[object global]'));
}
exports.glob = typeof commonjsGlobal !== 'undefined'
? commonjsGlobal
: typeof window !== 'undefined'
? window
: typeof WorkerGlobalScope !== 'undefined'
? self
: {};
exports.Konva = {
_global: exports.glob,
version: '9.3.18',
isBrowser: detectBrowser(),
isUnminified: /param/.test(function (param) { }.toString()),
dblClickWindow: 400,
getAngle(angle) {
return exports.Konva.angleDeg ? angle * PI_OVER_180 : angle;
},
enableTrace: false,
pointerEventsEnabled: true,
autoDrawEnabled: true,
hitOnDragEnabled: false,
capturePointerEventsEnabled: false,
_mouseListenClick: false,
_touchListenClick: false,
_pointerListenClick: false,
_mouseInDblClickWindow: false,
_touchInDblClickWindow: false,
_pointerInDblClickWindow: false,
_mouseDblClickPointerId: null,
_touchDblClickPointerId: null,
_pointerDblClickPointerId: null,
_fixTextRendering: false,
pixelRatio: (typeof window !== 'undefined' && window.devicePixelRatio) || 1,
dragDistance: 3,
angleDeg: true,
showWarnings: true,
dragButtons: [0, 1],
isDragging() {
return exports.Konva['DD'].isDragging;
},
isTransforming() {
var _a;
return (_a = exports.Konva['Transformer']) === null || _a === undefined ? undefined : _a.isTransforming();
},
isDragReady() {
return !!exports.Konva['DD'].node;
},
releaseCanvasOnDestroy: true,
document: exports.glob.document,
_injectGlobal(Konva) {
exports.glob.Konva = Konva;
},
};
const _registerNode = (NodeClass) => {
exports.Konva[NodeClass.prototype.getClassName()] = NodeClass;
};
exports._registerNode = _registerNode;
exports.Konva._injectGlobal(exports.Konva);
} (Global));
return Global;
}
var Util = {};
var hasRequiredUtil;
function requireUtil () {
if (hasRequiredUtil) return Util;
hasRequiredUtil = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Util = exports.Transform = undefined;
const Global_1 = requireGlobal();
class Transform {
constructor(m = [1, 0, 0, 1, 0, 0]) {
this.dirty = false;
this.m = (m && m.slice()) || [1, 0, 0, 1, 0, 0];
}
reset() {
this.m[0] = 1;
this.m[1] = 0;
this.m[2] = 0;
this.m[3] = 1;
this.m[4] = 0;
this.m[5] = 0;
}
copy() {
return new Transform(this.m);
}
copyInto(tr) {
tr.m[0] = this.m[0];
tr.m[1] = this.m[1];
tr.m[2] = this.m[2];
tr.m[3] = this.m[3];
tr.m[4] = this.m[4];
tr.m[5] = this.m[5];
}
point(point) {
const m = this.m;
return {
x: m[0] * point.x + m[2] * point.y + m[4],
y: m[1] * point.x + m[3] * point.y + m[5],
};
}
translate(x, y) {
this.m[4] += this.m[0] * x + this.m[2] * y;
this.m[5] += this.m[1] * x + this.m[3] * y;
return this;
}
scale(sx, sy) {
this.m[0] *= sx;
this.m[1] *= sx;
this.m[2] *= sy;
this.m[3] *= sy;
return this;
}
rotate(rad) {
const c = Math.cos(rad);
const s = Math.sin(rad);
const m11 = this.m[0] * c + this.m[2] * s;
const m12 = this.m[1] * c + this.m[3] * s;
const m21 = this.m[0] * -s + this.m[2] * c;
const m22 = this.m[1] * -s + this.m[3] * c;
this.m[0] = m11;
this.m[1] = m12;
this.m[2] = m21;
this.m[3] = m22;
return this;
}
getTranslation() {
return {
x: this.m[4],
y: this.m[5],
};
}
skew(sx, sy) {
const m11 = this.m[0] + this.m[2] * sy;
const m12 = this.m[1] + this.m[3] * sy;
const m21 = this.m[2] + this.m[0] * sx;
const m22 = this.m[3] + this.m[1] * sx;
this.m[0] = m11;
this.m[1] = m12;
this.m[2] = m21;
this.m[3] = m22;
return this;
}
multiply(matrix) {
const m11 = this.m[0] * matrix.m[0] + this.m[2] * matrix.m[1];
const m12 = this.m[1] * matrix.m[0] + this.m[3] * matrix.m[1];
const m21 = this.m[0] * matrix.m[2] + this.m[2] * matrix.m[3];
const m22 = this.m[1] * matrix.m[2] + this.m[3] * matrix.m[3];
const dx = this.m[0] * matrix.m[4] + this.m[2] * matrix.m[5] + this.m[4];
const dy = this.m[1] * matrix.m[4] + this.m[3] * matrix.m[5] + this.m[5];
this.m[0] = m11;
this.m[1] = m12;
this.m[2] = m21;
this.m[3] = m22;
this.m[4] = dx;
this.m[5] = dy;
return this;
}
invert() {
const d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
const m0 = this.m[3] * d;
const m1 = -this.m[1] * d;
const m2 = -this.m[2] * d;
const m3 = this.m[0] * d;
const m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
const m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
this.m[0] = m0;
this.m[1] = m1;
this.m[2] = m2;
this.m[3] = m3;
this.m[4] = m4;
this.m[5] = m5;
return this;
}
getMatrix() {
return this.m;
}
decompose() {
const a = this.m[0];
const b = this.m[1];
const c = this.m[2];
const d = this.m[3];
const e = this.m[4];
const f = this.m[5];
const delta = a * d - b * c;
const result = {
x: e,
y: f,
rotation: 0,
scaleX: 0,
scaleY: 0,
skewX: 0,
skewY: 0,
};
if (a != 0 || b != 0) {
const r = Math.sqrt(a * a + b * b);
result.rotation = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);
result.scaleX = r;
result.scaleY = delta / r;
result.skewX = (a * c + b * d) / delta;
result.skewY = 0;
}
else if (c != 0 || d != 0) {
const s = Math.sqrt(c * c + d * d);
result.rotation =
Math.PI / 2 - (d > 0 ? Math.acos(-c / s) : -Math.acos(c / s));
result.scaleX = delta / s;
result.scaleY = s;
result.skewX = 0;
result.skewY = (a * c + b * d) / delta;
}
else ;
result.rotation = exports.Util._getRotation(result.rotation);
return result;
}
}
exports.Transform = Transform;
const OBJECT_ARRAY = '[object Array]', OBJECT_NUMBER = '[object Number]', OBJECT_STRING = '[object String]', OBJECT_BOOLEAN = '[object Boolean]', PI_OVER_DEG180 = Math.PI / 180, DEG180_OVER_PI = 180 / Math.PI, HASH = '#', EMPTY_STRING = '', ZERO = '0', KONVA_WARNING = 'Konva warning: ', KONVA_ERROR = 'Konva error: ', RGB_PAREN = 'rgb(', COLORS = {
aliceblue: [240, 248, 255],
antiquewhite: [250, 235, 215],
aqua: [0, 255, 255],
aquamarine: [127, 255, 212],
azure: [240, 255, 255],
beige: [245, 245, 220],
bisque: [255, 228, 196],
black: [0, 0, 0],
blanchedalmond: [255, 235, 205],
blue: [0, 0, 255],
blueviolet: [138, 43, 226],
brown: [165, 42, 42],
burlywood: [222, 184, 135],
cadetblue: [95, 158, 160],
chartreuse: [127, 255, 0],
chocolate: [210, 105, 30],
coral: [255, 127, 80],
cornflowerblue: [100, 149, 237],
cornsilk: [255, 248, 220],
crimson: [220, 20, 60],
cyan: [0, 255, 255],
darkblue: [0, 0, 139],
darkcyan: [0, 139, 139],
darkgoldenrod: [184, 132, 11],
darkgray: [169, 169, 169],
darkgreen: [0, 100, 0],
darkgrey: [169, 169, 169],
darkkhaki: [189, 183, 107],
darkmagenta: [139, 0, 139],
darkolivegreen: [85, 107, 47],
darkorange: [255, 140, 0],
darkorchid: [153, 50, 204],
darkred: [139, 0, 0],
darksalmon: [233, 150, 122],
darkseagreen: [143, 188, 143],
darkslateblue: [72, 61, 139],
darkslategray: [47, 79, 79],
darkslategrey: [47, 79, 79],
darkturquoise: [0, 206, 209],
darkviolet: [148, 0, 211],
deeppink: [255, 20, 147],
deepskyblue: [0, 191, 255],
dimgray: [105, 105, 105],
dimgrey: [105, 105, 105],
dodgerblue: [30, 144, 255],
firebrick: [178, 34, 34],
floralwhite: [255, 255, 240],
forestgreen: [34, 139, 34],
fuchsia: [255, 0, 255],
gainsboro: [220, 220, 220],
ghostwhite: [248, 248, 255],
gold: [255, 215, 0],
goldenrod: [218, 165, 32],
gray: [128, 128, 128],
green: [0, 128, 0],
greenyellow: [173, 255, 47],
grey: [128, 128, 128],
honeydew: [240, 255, 240],
hotpink: [255, 105, 180],
indianred: [205, 92, 92],
indigo: [75, 0, 130],
ivory: [255, 255, 240],
khaki: [240, 230, 140],
lavender: [230, 230, 250],
lavenderblush: [255, 240, 245],
lawngreen: [124, 252, 0],
lemonchiffon: [255, 250, 205],
lightblue: [173, 216, 230],
lightcoral: [240, 128, 128],
lightcyan: [224, 255, 255],
lightgoldenrodyellow: [250, 250, 210],
lightgray: [211, 211, 211],
lightgreen: [144, 238, 144],
lightgrey: [211, 211, 211],
lightpink: [255, 182, 193],
lightsalmon: [255, 160, 122],
lightseagreen: [32, 178, 170],
lightskyblue: [135, 206, 250],
lightslategray: [119, 136, 153],
lightslategrey: [119, 136, 153],
lightsteelblue: [176, 196, 222],
lightyellow: [255, 255, 224],
lime: [0, 255, 0],
limegreen: [50, 205, 50],
linen: [250, 240, 230],
magenta: [255, 0, 255],
maroon: [128, 0, 0],
mediumaquamarine: [102, 205, 170],
mediumblue: [0, 0, 205],
mediumorchid: [186, 85, 211],
mediumpurple: [147, 112, 219],
mediumseagreen: [60, 179, 113],
mediumslateblue: [123, 104, 238],
mediumspringgreen: [0, 250, 154],
mediumturquoise: [72, 209, 204],
mediumvioletred: [199, 21, 133],
midnightblue: [25, 25, 112],
mintcream: [245, 255, 250],
mistyrose: [255, 228, 225],
moccasin: [255, 228, 181],
navajowhite: [255, 222, 173],
navy: [0, 0, 128],
oldlace: [253, 245, 230],
olive: [128, 128, 0],
olivedrab: [107, 142, 35],
orange: [255, 165, 0],
orangered: [255, 69, 0],
orchid: [218, 112, 214],
palegoldenrod: [238, 232, 170],
palegreen: [152, 251, 152],
paleturquoise: [175, 238, 238],
palevioletred: [219, 112, 147],
papayawhip: [255, 239, 213],
peachpuff: [255, 218, 185],
peru: [205, 133, 63],
pink: [255, 192, 203],
plum: [221, 160, 203],
powderblue: [176, 224, 230],
purple: [128, 0, 128],
rebeccapurple: [102, 51, 153],
red: [255, 0, 0],
rosybrown: [188, 143, 143],
royalblue: [65, 105, 225],
saddlebrown: [139, 69, 19],
salmon: [250, 128, 114],
sandybrown: [244, 164, 96],
seagreen: [46, 139, 87],
seashell: [255, 245, 238],
sienna: [160, 82, 45],
silver: [192, 192, 192],
skyblue: [135, 206, 235],
slateblue: [106, 90, 205],
slategray: [119, 128, 144],
slategrey: [119, 128, 144],
snow: [255, 255, 250],
springgreen: [0, 255, 127],
steelblue: [70, 130, 180],
tan: [210, 180, 140],
teal: [0, 128, 128],
thistle: [216, 191, 216],
transparent: [255, 255, 255, 0],
tomato: [255, 99, 71],
turquoise: [64, 224, 208],
violet: [238, 130, 238],
wheat: [245, 222, 179],
white: [255, 255, 255],
whitesmoke: [245, 245, 245],
yellow: [255, 255, 0],
yellowgreen: [154, 205, 5],
}, RGB_REGEX = /rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)/;
let animQueue = [];
const req = (typeof requestAnimationFrame !== 'undefined' && requestAnimationFrame) ||
function (f) {
setTimeout(f, 60);
};
exports.Util = {
_isElement(obj) {
return !!(obj && obj.nodeType == 1);
},
_isFunction(obj) {
return !!(obj && obj.constructor && obj.call && obj.apply);
},
_isPlainObject(obj) {
return !!obj && obj.constructor === Object;
},
_isArray(obj) {
return Object.prototype.toString.call(obj) === OBJECT_ARRAY;
},
_isNumber(obj) {
return (Object.prototype.toString.call(obj) === OBJECT_NUMBER &&
!isNaN(obj) &&
isFinite(obj));
},
_isString(obj) {
return Object.prototype.toString.call(obj) === OBJECT_STRING;
},
_isBoolean(obj) {
return Object.prototype.toString.call(obj) === OBJECT_BOOLEAN;
},
isObject(val) {
return val instanceof Object;
},
isValidSelector(selector) {
if (typeof selector !== 'string') {
return false;
}
const firstChar = selector[0];
return (firstChar === '#' ||
firstChar === '.' ||
firstChar === firstChar.toUpperCase());
},
_sign(number) {
if (number === 0) {
return 1;
}
if (number > 0) {
return 1;
}
else {
return -1;
}
},
requestAnimFrame(callback) {
animQueue.push(callback);
if (animQueue.length === 1) {
req(function () {
const queue = animQueue;
animQueue = [];
queue.forEach(function (cb) {
cb();
});
});
}
},
createCanvasElement() {
const canvas = document.createElement('canvas');
try {
canvas.style = canvas.style || {};
}
catch (e) { }
return canvas;
},
createImageElement() {
return document.createElement('img');
},
_isInDocument(el) {
while ((el = el.parentNode)) {
if (el == document) {
return true;
}
}
return false;
},
_urlToImage(url, callback) {
const imageObj = exports.Util.createImageElement();
imageObj.onload = function () {
callback(imageObj);
};
imageObj.src = url;
},
_rgbToHex(r, g, b) {
return ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
},
_hexToRgb(hex) {
hex = hex.replace(HASH, EMPTY_STRING);
const bigint = parseInt(hex, 16);
return {
r: (bigint >> 16) & 255,
g: (bigint >> 8) & 255,
b: bigint & 255,
};
},
getRandomColor() {
let randColor = ((Math.random() * 0xffffff) << 0).toString(16);
while (randColor.length < 6) {
randColor = ZERO + randColor;
}
return HASH + randColor;
},
getRGB(color) {
let rgb;
if (color in COLORS) {
rgb = COLORS[color];
return {
r: rgb[0],
g: rgb[1],
b: rgb[2],
};
}
else if (color[0] === HASH) {
return this._hexToRgb(color.substring(1));
}
else if (color.substr(0, 4) === RGB_PAREN) {
rgb = RGB_REGEX.exec(color.replace(/ /g, ''));
return {
r: parseInt(rgb[1], 10),
g: parseInt(rgb[2], 10),
b: parseInt(rgb[3], 10),
};
}
else {
return {
r: 0,
g: 0,
b: 0,
};
}
},
colorToRGBA(str) {
str = str || 'black';
return (exports.Util._namedColorToRBA(str) ||
exports.Util._hex3ColorToRGBA(str) ||
exports.Util._hex4ColorToRGBA(str) ||
exports.Util._hex6ColorToRGBA(str) ||
exports.Util._hex8ColorToRGBA(str) ||
exports.Util._rgbColorToRGBA(str) ||
exports.Util._rgbaColorToRGBA(str) ||
exports.Util._hslColorToRGBA(str));
},
_namedColorToRBA(str) {
const c = COLORS[str.toLowerCase()];
if (!c) {
return null;
}
return {
r: c[0],
g: c[1],
b: c[2],
a: 1,
};
},
_rgbColorToRGBA(str) {
if (str.indexOf('rgb(') === 0) {
str = str.match(/rgb\(([^)]+)\)/)[1];
const parts = str.split(/ *, */).map(Number);
return {
r: parts[0],
g: parts[1],
b: parts[2],
a: 1,
};
}
},
_rgbaColorToRGBA(str) {
if (str.indexOf('rgba(') === 0) {
str = str.match(/rgba\(([^)]+)\)/)[1];
const parts = str.split(/ *, */).map((n, index) => {
if (n.slice(-1) === '%') {
return index === 3 ? parseInt(n) / 100 : (parseInt(n) / 100) * 255;
}
return Number(n);
});
return {
r: parts[0],
g: parts[1],
b: parts[2],
a: parts[3],
};
}
},
_hex8ColorToRGBA(str) {
if (str[0] === '#' && str.length === 9) {
return {
r: parseInt(str.slice(1, 3), 16),
g: parseInt(str.slice(3, 5), 16),
b: parseInt(str.slice(5, 7), 16),
a: parseInt(str.slice(7, 9), 16) / 0xff,
};
}
},
_hex6ColorToRGBA(str) {
if (str[0] === '#' && str.length === 7) {
return {
r: parseInt(str.slice(1, 3), 16),
g: parseInt(str.slice(3, 5), 16),
b: parseInt(str.slice(5, 7), 16),
a: 1,
};
}
},
_hex4ColorToRGBA(str) {
if (str[0] === '#' && str.length === 5) {
return {
r: parseInt(str[1] + str[1], 16),
g: parseInt(str[2] + str[2], 16),
b: parseInt(str[3] + str[3], 16),
a: parseInt(str[4] + str[4], 16) / 0xff,
};
}
},
_hex3ColorToRGBA(str) {
if (str[0] === '#' && str.length === 4) {
return {
r: parseInt(str[1] + str[1], 16),
g: parseInt(str[2] + str[2], 16),
b: parseInt(str[3] + str[3], 16),
a: 1,
};
}
},
_hslColorToRGBA(str) {
if (/hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.test(str)) {
const [_, ...hsl] = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(str);
const h = Number(hsl[0]) / 360;
const s = Number(hsl[1]) / 100;
const l = Number(hsl[2]) / 100;
let t2;
let t3;
let val;
if (s === 0) {
val = l * 255;
return {
r: Math.round(val),
g: Math.round(val),
b: Math.round(val),
a: 1,
};
}
if (l < 0.5) {
t2 = l * (1 + s);
}
else {
t2 = l + s - l * s;
}
const t1 = 2 * l - t2;
const rgb = [0, 0, 0];
for (let i = 0; i < 3; i++) {
t3 = h + (1 / 3) * -(i - 1);
if (t3 < 0) {
t3++;
}
if (t3 > 1) {
t3--;
}
if (6 * t3 < 1) {
val = t1 + (t2 - t1) * 6 * t3;
}
else if (2 * t3 < 1) {
val = t2;
}
else if (3 * t3 < 2) {
val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
}
else {
val = t1;
}
rgb[i] = val * 255;
}
return {
r: Math.round(rgb[0]),
g: Math.round(rgb[1]),
b: Math.round(rgb[2]),
a: 1,
};
}
},
haveIntersection(r1, r2) {
return !(r2.x > r1.x + r1.width ||
r2.x + r2.width < r1.x ||
r2.y > r1.y + r1.height ||
r2.y + r2.height < r1.y);
},
cloneObject(obj) {
const retObj = {};
for (const key in obj) {
if (this._isPlainObject(obj[key])) {
retObj[key] = this.cloneObject(obj[key]);
}
else if (this._isArray(obj[key])) {
retObj[key] = this.cloneArray(obj[key]);
}
else {
retObj[key] = obj[key];
}
}
return retObj;
},
cloneArray(arr) {
return arr.slice(0);
},
degToRad(deg) {
return deg * PI_OVER_DEG180;
},
radToDeg(rad) {
return rad * DEG180_OVER_PI;
},
_degToRad(deg) {
exports.Util.warn('Util._degToRad is removed. Please use public Util.degToRad instead.');
return exports.Util.degToRad(deg);
},
_radToDeg(rad) {
exports.Util.warn('Util._radToDeg is removed. Please use public Util.radToDeg instead.');
return exports.Util.radToDeg(rad);
},
_getRotation(radians) {
return Global_1.Konva.angleDeg ? exports.Util.radToDeg(radians) : radians;
},
_capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
},
throw(str) {
throw new Error(KONVA_ERROR + str);
},
error(str) {
console.error(KONVA_ERROR + str);
},
warn(str) {
if (!Global_1.Konva.showWarnings) {
return;
}
console.warn(KONVA_WARNING + str);
},
each(obj, func) {
for (const key in obj) {
func(key, obj[key]);
}
},
_inRange(val, left, right) {
return left <= val && val < right;
},
_getProjectionToSegment(x1, y1, x2, y2, x3, y3) {
let x, y, dist;
const pd2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
if (pd2 == 0) {
x = x1;
y = y1;
dist = (x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2);
}
else {
const u = ((x3 - x1) * (x2 - x1) + (y3 - y1) * (y2 - y1)) / pd2;
if (u < 0) {
x = x1;
y = y1;
dist = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3);
}
else if (u > 1.0) {
x = x2;
y = y2;
dist = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
}
else {
x = x1 + u * (x2 - x1);
y = y1 + u * (y2 - y1);
dist = (x - x3) * (x - x3) + (y - y3) * (y - y3);
}
}
return [x, y, dist];
},
_getProjectionToLine(pt, line, isClosed) {
const pc = exports.Util.cloneObject(pt);
let dist = Number.MAX_VALUE;
line.forEach(function (p1, i) {
if (!isClosed && i === line.length - 1) {
return;
}
const p2 = line[(i + 1) % line.length];
const proj = exports.Util._getProjectionToSegment(p1.x, p1.y, p2.x, p2.y, pt.x, pt.y);
const px = proj[0], py = proj[1], pdist = proj[2];
if (pdist < dist) {
pc.x = px;
pc.y = py;
dist = pdist;
}
});
return pc;
},
_prepareArrayForTween(startArray, endArray, isClosed) {
const start = [], end = [];
if (startArray.length > endArray.length) {
const temp = endArray;
endArray = startArray;
startArray = temp;
}
for (let n = 0; n < startArray.length; n += 2) {
start.push({
x: startArray[n],
y: startArray[n + 1],
});
}
for (let n = 0; n < endArray.length; n += 2) {
end.push({
x: endArray[n],
y: endArray[n + 1],
});
}
const newStart = [];
end.forEach(function (point) {
const pr = exports.Util._getProjectionToLine(point, start, isClosed);
newStart.push(pr.x);
newStart.push(pr.y);
});
return newStart;
},
_prepareToStringify(obj) {
let desc;
obj.visitedByCircularReferenceRemoval = true;
for (const key in obj) {
if (!(obj.hasOwnProperty(key) && obj[key] && typeof obj[key] == 'object')) {
continue;
}
desc = Object.getOwnPropertyDescriptor(obj, key);
if (obj[key].visitedByCircularReferenceRemoval ||
exports.Util._isElement(obj[key])) {
if (desc.configurable) {
delete obj[key];
}
else {
return null;
}
}
else if (exports.Util._prepareToStringify(obj[key]) === null) {
if (desc.configurable) {
delete obj[key];
}
else {
return null;
}
}
}
delete obj.visitedByCircularReferenceRemoval;
return obj;
},
_assign(target, source) {
for (const key in source) {
target[key] = source[key];
}
return target;
},
_getFirstPointerId(evt) {
if (!evt.touches) {
return evt.pointerId || 999;
}
else {
return evt.changedTouches[0].identifier;
}
},
releaseCanvas(...canvases) {
if (!Global_1.Konva.releaseCanvasOnDestroy)
return;
canvases.forEach((c) => {
c.width = 0;
c.height = 0;
});
},
drawRoundedRectPath(context, width, height, cornerRadius) {
let topLeft = 0;
let topRight = 0;
let bottomLeft = 0;
let bottomRight = 0;
if (typeof cornerRadius === 'number') {
topLeft =
topRight =
bottomLeft =
bottomRight =
Math.min(cornerRadius, width / 2, height / 2);
}
else {
topLeft = Math.min(cornerRadius[0] || 0, width / 2, height / 2);
topRight = Math.min(cornerRadius[1] || 0, width / 2, height / 2);
bottomRight = Math.min(cornerRadius[2] || 0, width / 2, height / 2);
bottomLeft = Math.min(cornerRadius[3] || 0, width / 2, height / 2);
}
context.moveTo(topLeft, 0);
context.lineTo(width - topRight, 0);
context.arc(width - topRight, topRight, topRight, (Math.PI * 3) / 2, 0, false);
context.lineTo(width, height - bottomRight);
context.arc(width - bottomRight, height - bottomRight, bottomRight, 0, Math.PI / 2, false);
context.lineTo(bottomLeft, height);
context.arc(bottomLeft, height - bottomLeft, bottomLeft, Math.PI / 2, Math.PI, false);
context.lineTo(0, topLeft);
context.arc(topLeft, topLeft, topLeft, Math.PI, (Math.PI * 3) / 2, false);
},
};
} (Util));
return Util;
}
var Node = {};
var Factory = {};
var Validators = {};
var hasRequiredValidators;
function requireValidators () {
if (hasRequiredValidators) return Validators;
hasRequiredValidators = 1;
Object.defineProperty(Validators, "__esModule", { value: true });
Validators.RGBComponent = RGBComponent;
Validators.alphaComponent = alphaComponent;
Validators.getNumberValidator = getNumberValidator;
Validators.getNumberOrArrayOfNumbersValidator = getNumberOrArrayOfNumbersValidator;
Validators.getNumberOrAutoValidator = getNumberOrAutoValidator;
Validators.getStringValidator = getStringValidator;
Validators.getStringOrGradientValidator = getStringOrGradientValidator;
Validators.getFunctionValidator = getFunctionValidator;
Validators.getNumberArrayValidator = getNumberArrayValidator;
Validators.getBooleanValidator = getBooleanValidator;
Validators.getComponentValidator = getComponentValidator;
const Global_1 = requireGlobal();
const Util_1 = requireUtil();
function _formatValue(val) {
if (Util_1.Util._isString(val)) {
return '"' + val + '"';
}
if (Object.prototype.toString.call(val) === '[object Number]') {
return val;
}
if (Util_1.Util._isBoolean(val)) {
return val;
}
return Object.prototype.toString.call(val);
}
function RGBComponent(val) {
if (val > 255) {
return 255;
}
else if (val < 0) {
return 0;
}
return Math.round(val);
}
function alphaComponent(val) {
if (val > 1) {
return 1;
}
else if (val < 0.0001) {
return 0.0001;
}
return val;
}
function getNumberValidator() {
if (Global_1.Konva.isUnminified) {
return function (val, attr) {
if (!Util_1.Util._isNumber(val)) {
Util_1.Util.warn(_formatValue(val) +