diff --git a/release/0.29.2/dist/guides.cjs.js b/release/0.29.2/dist/guides.cjs.js new file mode 100644 index 0000000..f26b8dc --- /dev/null +++ b/release/0.29.2/dist/guides.cjs.js @@ -0,0 +1,533 @@ +/* +Copyright (c) Daybrush +name: @scena/guides +license: MIT +author: Daybrush +repository: git+https://github.com/daybrush/guides.git +version: 0.29.2 +*/ +'use strict'; + +var frameworkUtils = require('framework-utils'); +var React = require('croact'); +var ReactGuides = require('croact-guides'); +var utils = require('@daybrush/utils'); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + +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); +}; + +function __extends(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 = function() { + __assign = Object.assign || function __assign(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); +}; + +function __decorate(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +} + +var PROPERTIES = ReactGuides.PROPERTIES; +var METHODS = ReactGuides.METHODS; +var EVENTS = ReactGuides.EVENTS; + +var InnerGuides = +/*#__PURE__*/ +function (_super) { + __extends(InnerGuides, _super); + + function InnerGuides(props) { + var _this = _super.call(this, props) || this; + + _this.state = {}; + _this.state = _this.props; + return _this; + } + + var __proto = InnerGuides.prototype; + + __proto.render = function () { + return React.createElement(ReactGuides, __assign({ + ref: frameworkUtils.ref(this, "guides") + }, this.state)); + }; + + return InnerGuides; +}(React.Component); + +/* +Copyright (c) 2019 Daybrush +name: @scena/event-emitter +license: MIT +author: Daybrush +repository: git+https://github.com/daybrush/gesture.git +version: 1.0.5 +*/ + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +var __assign$1 = function () { + __assign$1 = Object.assign || function __assign(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$1.apply(this, arguments); +}; +function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + + for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; + + return r; +} + +/** + * Implement EventEmitter on object or component. + */ + +var EventEmitter = +/*#__PURE__*/ +function () { + function EventEmitter() { + this._events = {}; + } + /** + * Add a listener to the registered event. + * @param - Name of the event to be added + * @param - listener function of the event to be added + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Add listener in "a" event + * emitter.on("a", () => { + * }); + * // Add listeners + * emitter.on({ + * a: () => {}, + * b: () => {}, + * }); + */ + + + var __proto = EventEmitter.prototype; + + __proto.on = function (eventName, listener) { + if (utils.isObject(eventName)) { + for (var name in eventName) { + this.on(name, eventName[name]); + } + } else { + this._addEvent(eventName, listener, {}); + } + + return this; + }; + /** + * Remove listeners registered in the event target. + * @param - Name of the event to be removed + * @param - listener function of the event to be removed + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Remove all listeners. + * emitter.off(); + * + * // Remove all listeners in "A" event. + * emitter.off("a"); + * + * + * // Remove "listener" listener in "a" event. + * emitter.off("a", listener); + */ + + + __proto.off = function (eventName, listener) { + if (!eventName) { + this._events = {}; + } else if (utils.isObject(eventName)) { + for (var name in eventName) { + this.off(name); + } + } else if (!listener) { + this._events[eventName] = []; + } else { + var events = this._events[eventName]; + + if (events) { + var index = utils.findIndex(events, function (e) { + return e.listener === listener; + }); + + if (index > -1) { + events.splice(index, 1); + } + } + } + + return this; + }; + /** + * Add a disposable listener and Use promise to the registered event. + * @param - Name of the event to be added + * @param - disposable listener function of the event to be added + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Add a disposable listener in "a" event + * emitter.once("a", () => { + * }); + * + * // Use Promise + * emitter.once("a").then(e => { + * }); + */ + + + __proto.once = function (eventName, listener) { + var _this = this; + + if (listener) { + this._addEvent(eventName, listener, { + once: true + }); + } + + return new Promise(function (resolve) { + _this._addEvent(eventName, resolve, { + once: true + }); + }); + }; + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * + * emitter.emit("a", { + * a: 1, + * }); + */ + + + __proto.emit = function (eventName, param) { + var _this = this; + + if (param === void 0) { + param = {}; + } + + var events = this._events[eventName]; + + if (!eventName || !events) { + return true; + } + + var isStop = false; + param.eventType = eventName; + + param.stop = function () { + isStop = true; + }; + + param.currentTarget = this; + + __spreadArrays(events).forEach(function (info) { + info.listener(param); + + if (info.once) { + _this.off(eventName, info.listener); + } + }); + + return !isStop; + }; + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * + * emitter.emit("a", { + * a: 1, + * }); + */ + + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * // emit + * emitter.trigger("a", { + * a: 1, + * }); + */ + + + __proto.trigger = function (eventName, param) { + if (param === void 0) { + param = {}; + } + + return this.emit(eventName, param); + }; + + __proto._addEvent = function (eventName, listener, options) { + var events = this._events; + events[eventName] = events[eventName] || []; + var listeners = events[eventName]; + listeners.push(__assign$1({ + listener: listener + }, options)); + }; + + return EventEmitter; +}(); + +var Guides = +/*#__PURE__*/ +function (_super) { + __extends(Guides, _super); + /** + * @sort 1 + * @param - guides' container + * @param {$ts:Partial} - guides' options + */ + + + function Guides(container, options) { + if (options === void 0) { + options = {}; + } + + var _this = _super.call(this) || this; + + _this.containerProvider = null; + _this.selfElement = null; + _this._warp = false; + var events = {}; + EVENTS.forEach(function (name) { + events[utils.camelize("on ".concat(name))] = function (e) { + return _this.trigger(name, e); + }; + }); + var selfElement; + + if (options.warpSelf) { + delete options.warpSelf; + _this._warp = true; + selfElement = container; + } else { + selfElement = document.createElement("div"); + container.appendChild(selfElement); + } + + _this.containerProvider = React.renderSelf(React.createElement(InnerGuides, __assign({ + ref: frameworkUtils.ref(_this, "innerGuides") + }, events, options)), selfElement); + return _this; + } + /** + * @param state + * @param callback + */ + + + var __proto = Guides.prototype; + + __proto.setState = function (state, callback) { + this.innerGuides.setState(state, callback); + }; + /** + * @param callback + */ + + + __proto.forceUpdate = function (callback) { + this.innerGuides.forceUpdate(callback); + }; + /** + * destroy guides + */ + + + __proto.destroy = function () { + var _a; + + var selfElement = this.selfElement; + React.renderSelf(null, selfElement, this.containerProvider); + + if (!this._warp) { + (_a = selfElement === null || selfElement === void 0 ? void 0 : selfElement.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(selfElement); + } + + this.selfElement = null; + this.innerGuides = null; + }; + + __proto.getInnerGuides = function () { + return this.innerGuides.guides; + }; + + Guides = __decorate([frameworkUtils.Properties(METHODS, function (prototype, property) { + if (prototype[property]) { + return; + } + + prototype[property] = function () { + var args = []; + + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + + var self = this.getInnerGuides(); + + if (!self || !self[property]) { + return; + } + + return self[property].apply(self, args); + }; + }), frameworkUtils.Properties(PROPERTIES, function (prototype, property) { + Object.defineProperty(prototype, property, { + get: function () { + return this.getInnerGuides().props[property]; + }, + set: function (value) { + var _a; + + this.innerGuides.setState((_a = {}, _a[property] = value, _a)); + }, + enumerable: true, + configurable: true + }); + }) + /** + * @sort 1 + * @extends EventEmitter + */ + ], Guides); + return Guides; +}(EventEmitter); + +var Guides$1 = +/*#__PURE__*/ +function (_super) { + __extends(Guides, _super); + + function Guides() { + return _super !== null && _super.apply(this, arguments) || this; + } + + return Guides; +}(Guides); + + + +var others = { + __proto__: null, + 'default': Guides$1, + PROPERTIES: PROPERTIES, + METHODS: METHODS, + EVENTS: EVENTS +}; + +for (var name in others) { + Guides$1[name] = others[name]; +} + +module.exports = Guides$1; + +exports.EVENTS = EVENTS; +exports.METHODS = METHODS; +exports.PROPERTIES = PROPERTIES; +exports.default = Guides$1; +//# sourceMappingURL=guides.cjs.js.map diff --git a/release/0.29.2/dist/guides.cjs.js.map b/release/0.29.2/dist/guides.cjs.js.map new file mode 100644 index 0000000..e297a7b --- /dev/null +++ b/release/0.29.2/dist/guides.cjs.js.map @@ -0,0 +1 @@ +{"version":3,"file":"guides.cjs.js","sources":["../src/consts.ts","../src/InnerGuides.tsx","../src/GuidesManager.tsx","../src/Guides.tsx","../src/index.cjs.ts"],"sourcesContent":["import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\ndeclare const module: any;\n\nmodule.exports = Guides;\nexport * from \"./index.esm\";\nexport default Guides;\n"],"names":["PROPERTIES","GUIDES_PROPERTIES","METHODS","GUIDES_METHODS","EVENTS","GUIDES_EVENTS","__extends","props","_super","_this","state","React","ReactGuides","ref","container","options","events","forEach","name","camelize","e","trigger","selfElement","warpSelf","_warp","document","createElement","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","setState","forceUpdate","parentElement","removeChild","guides","Guides","Properties","prototype","property","_i","args","self","getInnerGuides","Object","defineProperty","get","set","value","_a","enumerable","configurable","EventEmitter","GuidesManager","others","module","exports"],"mappings":"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"} \ No newline at end of file diff --git a/release/0.29.2/dist/guides.esm.js b/release/0.29.2/dist/guides.esm.js new file mode 100644 index 0000000..37c6799 --- /dev/null +++ b/release/0.29.2/dist/guides.esm.js @@ -0,0 +1,513 @@ +/* +Copyright (c) Daybrush +name: @scena/guides +license: MIT +author: Daybrush +repository: git+https://github.com/daybrush/guides.git +version: 0.29.2 +*/ +import { ref, Properties } from 'framework-utils'; +import { createElement, Component, renderSelf } from 'croact'; +import ReactGuides, { PROPERTIES as PROPERTIES$1, METHODS as METHODS$1, EVENTS as EVENTS$1 } from 'croact-guides'; +import { isObject, findIndex, camelize } from '@daybrush/utils'; + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + +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); +}; + +function __extends(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 = function() { + __assign = Object.assign || function __assign(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); +}; + +function __decorate(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +} + +var PROPERTIES = PROPERTIES$1; +var METHODS = METHODS$1; +var EVENTS = EVENTS$1; + +var InnerGuides = +/*#__PURE__*/ +function (_super) { + __extends(InnerGuides, _super); + + function InnerGuides(props) { + var _this = _super.call(this, props) || this; + + _this.state = {}; + _this.state = _this.props; + return _this; + } + + var __proto = InnerGuides.prototype; + + __proto.render = function () { + return createElement(ReactGuides, __assign({ + ref: ref(this, "guides") + }, this.state)); + }; + + return InnerGuides; +}(Component); + +/* +Copyright (c) 2019 Daybrush +name: @scena/event-emitter +license: MIT +author: Daybrush +repository: git+https://github.com/daybrush/gesture.git +version: 1.0.5 +*/ + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +var __assign$1 = function () { + __assign$1 = Object.assign || function __assign(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$1.apply(this, arguments); +}; +function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + + for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; + + return r; +} + +/** + * Implement EventEmitter on object or component. + */ + +var EventEmitter = +/*#__PURE__*/ +function () { + function EventEmitter() { + this._events = {}; + } + /** + * Add a listener to the registered event. + * @param - Name of the event to be added + * @param - listener function of the event to be added + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Add listener in "a" event + * emitter.on("a", () => { + * }); + * // Add listeners + * emitter.on({ + * a: () => {}, + * b: () => {}, + * }); + */ + + + var __proto = EventEmitter.prototype; + + __proto.on = function (eventName, listener) { + if (isObject(eventName)) { + for (var name in eventName) { + this.on(name, eventName[name]); + } + } else { + this._addEvent(eventName, listener, {}); + } + + return this; + }; + /** + * Remove listeners registered in the event target. + * @param - Name of the event to be removed + * @param - listener function of the event to be removed + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Remove all listeners. + * emitter.off(); + * + * // Remove all listeners in "A" event. + * emitter.off("a"); + * + * + * // Remove "listener" listener in "a" event. + * emitter.off("a", listener); + */ + + + __proto.off = function (eventName, listener) { + if (!eventName) { + this._events = {}; + } else if (isObject(eventName)) { + for (var name in eventName) { + this.off(name); + } + } else if (!listener) { + this._events[eventName] = []; + } else { + var events = this._events[eventName]; + + if (events) { + var index = findIndex(events, function (e) { + return e.listener === listener; + }); + + if (index > -1) { + events.splice(index, 1); + } + } + } + + return this; + }; + /** + * Add a disposable listener and Use promise to the registered event. + * @param - Name of the event to be added + * @param - disposable listener function of the event to be added + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Add a disposable listener in "a" event + * emitter.once("a", () => { + * }); + * + * // Use Promise + * emitter.once("a").then(e => { + * }); + */ + + + __proto.once = function (eventName, listener) { + var _this = this; + + if (listener) { + this._addEvent(eventName, listener, { + once: true + }); + } + + return new Promise(function (resolve) { + _this._addEvent(eventName, resolve, { + once: true + }); + }); + }; + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * + * emitter.emit("a", { + * a: 1, + * }); + */ + + + __proto.emit = function (eventName, param) { + var _this = this; + + if (param === void 0) { + param = {}; + } + + var events = this._events[eventName]; + + if (!eventName || !events) { + return true; + } + + var isStop = false; + param.eventType = eventName; + + param.stop = function () { + isStop = true; + }; + + param.currentTarget = this; + + __spreadArrays(events).forEach(function (info) { + info.listener(param); + + if (info.once) { + _this.off(eventName, info.listener); + } + }); + + return !isStop; + }; + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * + * emitter.emit("a", { + * a: 1, + * }); + */ + + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * // emit + * emitter.trigger("a", { + * a: 1, + * }); + */ + + + __proto.trigger = function (eventName, param) { + if (param === void 0) { + param = {}; + } + + return this.emit(eventName, param); + }; + + __proto._addEvent = function (eventName, listener, options) { + var events = this._events; + events[eventName] = events[eventName] || []; + var listeners = events[eventName]; + listeners.push(__assign$1({ + listener: listener + }, options)); + }; + + return EventEmitter; +}(); + +var Guides = +/*#__PURE__*/ +function (_super) { + __extends(Guides, _super); + /** + * @sort 1 + * @param - guides' container + * @param {$ts:Partial} - guides' options + */ + + + function Guides(container, options) { + if (options === void 0) { + options = {}; + } + + var _this = _super.call(this) || this; + + _this.containerProvider = null; + _this.selfElement = null; + _this._warp = false; + var events = {}; + EVENTS.forEach(function (name) { + events[camelize("on ".concat(name))] = function (e) { + return _this.trigger(name, e); + }; + }); + var selfElement; + + if (options.warpSelf) { + delete options.warpSelf; + _this._warp = true; + selfElement = container; + } else { + selfElement = document.createElement("div"); + container.appendChild(selfElement); + } + + _this.containerProvider = renderSelf(createElement(InnerGuides, __assign({ + ref: ref(_this, "innerGuides") + }, events, options)), selfElement); + return _this; + } + /** + * @param state + * @param callback + */ + + + var __proto = Guides.prototype; + + __proto.setState = function (state, callback) { + this.innerGuides.setState(state, callback); + }; + /** + * @param callback + */ + + + __proto.forceUpdate = function (callback) { + this.innerGuides.forceUpdate(callback); + }; + /** + * destroy guides + */ + + + __proto.destroy = function () { + var _a; + + var selfElement = this.selfElement; + renderSelf(null, selfElement, this.containerProvider); + + if (!this._warp) { + (_a = selfElement === null || selfElement === void 0 ? void 0 : selfElement.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(selfElement); + } + + this.selfElement = null; + this.innerGuides = null; + }; + + __proto.getInnerGuides = function () { + return this.innerGuides.guides; + }; + + Guides = __decorate([Properties(METHODS, function (prototype, property) { + if (prototype[property]) { + return; + } + + prototype[property] = function () { + var args = []; + + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + + var self = this.getInnerGuides(); + + if (!self || !self[property]) { + return; + } + + return self[property].apply(self, args); + }; + }), Properties(PROPERTIES, function (prototype, property) { + Object.defineProperty(prototype, property, { + get: function () { + return this.getInnerGuides().props[property]; + }, + set: function (value) { + var _a; + + this.innerGuides.setState((_a = {}, _a[property] = value, _a)); + }, + enumerable: true, + configurable: true + }); + }) + /** + * @sort 1 + * @extends EventEmitter + */ + ], Guides); + return Guides; +}(EventEmitter); + +var Guides$1 = +/*#__PURE__*/ +function (_super) { + __extends(Guides, _super); + + function Guides() { + return _super !== null && _super.apply(this, arguments) || this; + } + + return Guides; +}(Guides); + +export default Guides$1; +export { EVENTS, METHODS, PROPERTIES }; +//# sourceMappingURL=guides.esm.js.map diff --git a/release/0.29.2/dist/guides.esm.js.map b/release/0.29.2/dist/guides.esm.js.map new file mode 100644 index 0000000..2af70d6 --- /dev/null +++ b/release/0.29.2/dist/guides.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"guides.esm.js","sources":["../src/consts.ts","../src/InnerGuides.tsx","../src/GuidesManager.tsx","../src/Guides.tsx"],"sourcesContent":["import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n"],"names":["PROPERTIES","GUIDES_PROPERTIES","METHODS","GUIDES_METHODS","EVENTS","GUIDES_EVENTS","__extends","props","_super","_this","state","React","ReactGuides","ref","container","options","events","forEach","name","camelize","e","trigger","selfElement","warpSelf","_warp","document","createElement","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","setState","forceUpdate","parentElement","removeChild","guides","Guides","Properties","prototype","property","_i","args","self","getInnerGuides","Object","defineProperty","get","set","value","_a","enumerable","configurable","EventEmitter","GuidesManager"],"mappings":"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"} \ No newline at end of file diff --git a/release/0.29.2/dist/guides.js b/release/0.29.2/dist/guides.js new file mode 100644 index 0000000..7d8252c --- /dev/null +++ b/release/0.29.2/dist/guides.js @@ -0,0 +1,5599 @@ +/* +Copyright (c) Daybrush +name: @scena/guides +license: MIT +author: Daybrush +repository: git+https://github.com/daybrush/guides.git +version: 0.29.2 +*/ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = global || self, global.Guides = factory()); +}(this, (function () { 'use strict'; + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + 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); + }; + + function __extends(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 = function() { + __assign = Object.assign || function __assign(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); + }; + + function __decorate(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + } + + /* + Copyright (c) 2019 Daybrush + name: framework-utils + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/framework-utils.git + version: 1.1.0 + */ + function prefixNames(prefix) { + var classNames = []; + + for (var _i = 1; _i < arguments.length; _i++) { + classNames[_i - 1] = arguments[_i]; + } + + return classNames.map(function (className) { + return className.split(" ").map(function (name) { + return name ? "" + prefix + name : ""; + }).join(" "); + }).join(" "); + } + function prefixCSS(prefix, css) { + return css.replace(/([^}{]*){/gm, function (_, selector) { + return selector.replace(/\.([^{,\s\d.]+)/g, "." + prefix + "$1") + "{"; + }); + } + /* react */ + + function ref(target, name) { + return function (e) { + e && (target[name] = e); + }; + } + function refs(target, name, i) { + return function (e) { + e && (target[name][i] = e); + }; + } + /* Class Decorator */ + + function Properties(properties, action) { + return function (component) { + var prototype = component.prototype; + properties.forEach(function (property) { + action(prototype, property); + }); + }; + } + + /* + Copyright (c) 2018 Daybrush + @name: @daybrush/utils + license: MIT + author: Daybrush + repository: https://github.com/daybrush/utils + @version 1.12.1 + */ + /** + * get string "function" + * @memberof Consts + * @example + import {FUNCTION} from "@daybrush/utils"; + + console.log(FUNCTION); // "function" + */ + var FUNCTION = "function"; + /** + * get string "object" + * @memberof Consts + * @example + import {OBJECT} from "@daybrush/utils"; + + console.log(OBJECT); // "object" + */ + var OBJECT = "object"; + /** + * get string "string" + * @memberof Consts + * @example + import {STRING} from "@daybrush/utils"; + + console.log(STRING); // "string" + */ + var STRING = "string"; + /** + * get string "number" + * @memberof Consts + * @example + import {NUMBER} from "@daybrush/utils"; + + console.log(NUMBER); // "number" + */ + var NUMBER = "number"; + /** + * get string "undefined" + * @memberof Consts + * @example + import {UNDEFINED} from "@daybrush/utils"; + + console.log(UNDEFINED); // "undefined" + */ + var UNDEFINED = "undefined"; + var OPEN_CLOSED_CHARACTERS = [{ + open: "(", + close: ")" + }, { + open: "\"", + close: "\"" + }, { + open: "'", + close: "'" + }, { + open: "\\\"", + close: "\\\"" + }, { + open: "\\'", + close: "\\'" + }]; + var TINY_NUM = 0.0000001; + var DEFAULT_UNIT_PRESETS = { + "cm": function (pos) { + return pos * 96 / 2.54; + }, + "mm": function (pos) { + return pos * 96 / 254; + }, + "in": function (pos) { + return pos * 96; + }, + "pt": function (pos) { + return pos * 96 / 72; + }, + "pc": function (pos) { + return pos * 96 / 6; + }, + "%": function (pos, size) { + return pos * size / 100; + }, + "vw": function (pos, size) { + if (size === void 0) { + size = window.innerWidth; + } + return pos / 100 * size; + }, + "vh": function (pos, size) { + if (size === void 0) { + size = window.innerHeight; + } + return pos / 100 * size; + }, + "vmax": function (pos, size) { + if (size === void 0) { + size = Math.max(window.innerWidth, window.innerHeight); + } + return pos / 100 * size; + }, + "vmin": function (pos, size) { + if (size === void 0) { + size = Math.min(window.innerWidth, window.innerHeight); + } + return pos / 100 * size; + } + }; + + /*! ***************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; + return r; + } + /** + * Check the type that the value is undefined. + * @memberof Utils + * @param {string} value - Value to check the type + * @return {boolean} true if the type is correct, false otherwise + * @example + import {isUndefined} from "@daybrush/utils"; + + console.log(isUndefined(undefined)); // true + console.log(isUndefined("")); // false + console.log(isUndefined(1)); // false + console.log(isUndefined(null)); // false + */ + function isUndefined(value) { + return typeof value === UNDEFINED; + } + /** + * Check the type that the value is object. + * @memberof Utils + * @param {string} value - Value to check the type + * @return {} true if the type is correct, false otherwise + * @example + import {isObject} from "@daybrush/utils"; + + console.log(isObject({})); // true + console.log(isObject(undefined)); // false + console.log(isObject("")); // false + console.log(isObject(null)); // false + */ + function isObject(value) { + return value && typeof value === OBJECT; + } + /** + * Check the type that the value is isArray. + * @memberof Utils + * @param {string} value - Value to check the type + * @return {} true if the type is correct, false otherwise + * @example + import {isArray} from "@daybrush/utils"; + + console.log(isArray([])); // true + console.log(isArray({})); // false + console.log(isArray(undefined)); // false + console.log(isArray(null)); // false + */ + function isArray(value) { + return Array.isArray(value); + } + /** + * Check the type that the value is string. + * @memberof Utils + * @param {string} value - Value to check the type + * @return {} true if the type is correct, false otherwise + * @example + import {isString} from "@daybrush/utils"; + + console.log(isString("1234")); // true + console.log(isString(undefined)); // false + console.log(isString(1)); // false + console.log(isString(null)); // false + */ + function isString(value) { + return typeof value === STRING; + } + function isNumber(value) { + return typeof value === NUMBER; + } + /** + * Check the type that the value is function. + * @memberof Utils + * @param {string} value - Value to check the type + * @return {} true if the type is correct, false otherwise + * @example + import {isFunction} from "@daybrush/utils"; + + console.log(isFunction(function a() {})); // true + console.log(isFunction(() => {})); // true + console.log(isFunction("1234")); // false + console.log(isFunction(1)); // false + console.log(isFunction(null)); // false + */ + function isFunction(value) { + return typeof value === FUNCTION; + } + function isEqualSeparator(character, separator) { + var isCharacterSpace = character === "" || character == " "; + var isSeparatorSpace = separator === "" || separator == " "; + return isSeparatorSpace && isCharacterSpace || character === separator; + } + function findOpen(openCharacter, texts, index, length, openCloseCharacters) { + var isIgnore = findIgnore(openCharacter, texts, index); + if (!isIgnore) { + return findClose(openCharacter, texts, index + 1, length, openCloseCharacters); + } + return index; + } + function findIgnore(character, texts, index) { + if (!character.ignore) { + return null; + } + var otherText = texts.slice(Math.max(index - 3, 0), index + 3).join(""); + return new RegExp(character.ignore).exec(otherText); + } + function findClose(closeCharacter, texts, index, length, openCloseCharacters) { + var _loop_1 = function (i) { + var character = texts[i].trim(); + if (character === closeCharacter.close && !findIgnore(closeCharacter, texts, i)) { + return { + value: i + }; + } + var nextIndex = i; + // re open + var openCharacter = find(openCloseCharacters, function (_a) { + var open = _a.open; + return open === character; + }); + if (openCharacter) { + nextIndex = findOpen(openCharacter, texts, i, length, openCloseCharacters); + } + if (nextIndex === -1) { + return out_i_1 = i, "break"; + } + i = nextIndex; + out_i_1 = i; + }; + var out_i_1; + for (var i = index; i < length; ++i) { + var state_1 = _loop_1(i); + i = out_i_1; + if (typeof state_1 === "object") return state_1.value; + if (state_1 === "break") break; + } + return -1; + } + function splitText(text, splitOptions) { + var _a = isString(splitOptions) ? { + separator: splitOptions + } : splitOptions, + _b = _a.separator, + separator = _b === void 0 ? "," : _b, + isSeparateFirst = _a.isSeparateFirst, + isSeparateOnlyOpenClose = _a.isSeparateOnlyOpenClose, + _c = _a.isSeparateOpenClose, + isSeparateOpenClose = _c === void 0 ? isSeparateOnlyOpenClose : _c, + _d = _a.openCloseCharacters, + openCloseCharacters = _d === void 0 ? OPEN_CLOSED_CHARACTERS : _d; + var openClosedText = openCloseCharacters.map(function (_a) { + var open = _a.open, + close = _a.close; + if (open === close) { + return open; + } + return open + "|" + close; + }).join("|"); + var regexText = "(\\s*" + separator + "\\s*|" + openClosedText + "|\\s+)"; + var regex = new RegExp(regexText, "g"); + var texts = text.split(regex).filter(function (chr) { + return chr && chr !== "undefined"; + }); + var length = texts.length; + var values = []; + var tempValues = []; + function resetTemp() { + if (tempValues.length) { + values.push(tempValues.join("")); + tempValues = []; + return true; + } + return false; + } + var _loop_2 = function (i) { + var character = texts[i].trim(); + var nextIndex = i; + var openCharacter = find(openCloseCharacters, function (_a) { + var open = _a.open; + return open === character; + }); + var closeCharacter = find(openCloseCharacters, function (_a) { + var close = _a.close; + return close === character; + }); + if (openCharacter) { + nextIndex = findOpen(openCharacter, texts, i, length, openCloseCharacters); + if (nextIndex !== -1 && isSeparateOpenClose) { + if (resetTemp() && isSeparateFirst) { + return out_i_2 = i, "break"; + } + values.push(texts.slice(i, nextIndex + 1).join("")); + i = nextIndex; + if (isSeparateFirst) { + return out_i_2 = i, "break"; + } + return out_i_2 = i, "continue"; + } + } else if (closeCharacter && !findIgnore(closeCharacter, texts, i)) { + var nextOpenCloseCharacters = __spreadArrays(openCloseCharacters); + nextOpenCloseCharacters.splice(openCloseCharacters.indexOf(closeCharacter), 1); + return { + value: splitText(text, { + separator: separator, + isSeparateFirst: isSeparateFirst, + isSeparateOnlyOpenClose: isSeparateOnlyOpenClose, + isSeparateOpenClose: isSeparateOpenClose, + openCloseCharacters: nextOpenCloseCharacters + }) + }; + } else if (isEqualSeparator(character, separator) && !isSeparateOnlyOpenClose) { + resetTemp(); + if (isSeparateFirst) { + return out_i_2 = i, "break"; + } + return out_i_2 = i, "continue"; + } + if (nextIndex === -1) { + nextIndex = length - 1; + } + tempValues.push(texts.slice(i, nextIndex + 1).join("")); + i = nextIndex; + out_i_2 = i; + }; + var out_i_2; + for (var i = 0; i < length; ++i) { + var state_2 = _loop_2(i); + i = out_i_2; + if (typeof state_2 === "object") return state_2.value; + if (state_2 === "break") break; + } + if (tempValues.length) { + values.push(tempValues.join("")); + } + return values; + } + /** + * divide text by space. + * @memberof Utils + * @param {string} text - text to divide + * @return {Array} divided texts + * @example + import {spliceSpace} from "@daybrush/utils"; + + console.log(splitSpace("a b c d e f g")); + // ["a", "b", "c", "d", "e", "f", "g"] + console.log(splitSpace("'a,b' c 'd,e' f g")); + // ["'a,b'", "c", "'d,e'", "f", "g"] + */ + function splitSpace(text) { + // divide comma(space) + return splitText(text, ""); + } + /** + * divide text by comma. + * @memberof Utils + * @param {string} text - text to divide + * @return {Array} divided texts + * @example + import {splitComma} from "@daybrush/utils"; + + console.log(splitComma("a,b,c,d,e,f,g")); + // ["a", "b", "c", "d", "e", "f", "g"] + console.log(splitComma("'a,b',c,'d,e',f,g")); + // ["'a,b'", "c", "'d,e'", "f", "g"] + */ + function splitComma(text) { + // divide comma(,) + // "[^"]*"|'[^']*' + return splitText(text, ","); + } + /** + * divide text by bracket "(", ")". + * @memberof Utils + * @param {string} text - text to divide + * @return {object} divided texts + * @example + import {splitBracket} from "@daybrush/utils"; + + console.log(splitBracket("a(1, 2)")); + // {prefix: "a", value: "1, 2", suffix: ""} + console.log(splitBracket("a(1, 2)b")); + // {prefix: "a", value: "1, 2", suffix: "b"} + */ + function splitBracket(text) { + var matches = /([^(]*)\(([\s\S]*)\)([\s\S]*)/g.exec(text); + if (!matches || matches.length < 4) { + return {}; + } else { + return { + prefix: matches[1], + value: matches[2], + suffix: matches[3] + }; + } + } + /** + * divide text by number and unit. + * @memberof Utils + * @param {string} text - text to divide + * @return {} divided texts + * @example + import {splitUnit} from "@daybrush/utils"; + + console.log(splitUnit("10px")); + // {prefix: "", value: 10, unit: "px"} + console.log(splitUnit("-10px")); + // {prefix: "", value: -10, unit: "px"} + console.log(splitUnit("a10%")); + // {prefix: "a", value: 10, unit: "%"} + */ + function splitUnit(text) { + var matches = /^([^\d|e|\-|\+]*)((?:\d|\.|-|e-|e\+)+)(\S*)$/g.exec(text); + if (!matches) { + return { + prefix: "", + unit: "", + value: NaN + }; + } + var prefix = matches[1]; + var value = matches[2]; + var unit = matches[3]; + return { + prefix: prefix, + unit: unit, + value: parseFloat(value) + }; + } + /** + * transform strings to camel-case + * @memberof Utils + * @param {String} text - string + * @return {String} camel-case string + * @example + import {camelize} from "@daybrush/utils"; + + console.log(camelize("transform-origin")); // transformOrigin + console.log(camelize("abcd_efg")); // abcdEfg + console.log(camelize("abcd efg")); // abcdEfg + */ + function camelize(str) { + return str.replace(/[\s-_]+([^\s-_])/g, function (all, letter) { + return letter.toUpperCase(); + }); + } + /** + * transform a camelized string into a lowercased string. + * @memberof Utils + * @param {string} text - a camel-cased string + * @param {string} [separator="-"] - a separator + * @return {string} a lowercased string + * @example + import {decamelize} from "@daybrush/utils"; + + console.log(decamelize("transformOrigin")); // transform-origin + console.log(decamelize("abcdEfg", "_")); // abcd_efg + */ + function decamelize(str, separator) { + if (separator === void 0) { + separator = "-"; + } + return str.replace(/([a-z])([A-Z])/g, function (all, letter, letter2) { + return "" + letter + separator + letter2.toLowerCase(); + }); + } + /** + * Date.now() method + * @memberof CrossBrowser + * @return {number} milliseconds + * @example + import {now} from "@daybrush/utils"; + + console.log(now()); // 12121324241(milliseconds) + */ + function now() { + return Date.now ? Date.now() : new Date().getTime(); + } + /** + * Returns the index of the first element in the array that satisfies the provided testing function. + * @function + * @memberof CrossBrowser + * @param - The array `findIndex` was called upon. + * @param - A function to execute on each value in the array until the function returns true, indicating that the satisfying element was found. + * @param - Returns defaultIndex if not found by the function. + * @example + import { findIndex } from "@daybrush/utils"; + + findIndex([{a: 1}, {a: 2}, {a: 3}, {a: 4}], ({ a }) => a === 2); // 1 + */ + function findIndex(arr, callback, defaultIndex) { + if (defaultIndex === void 0) { + defaultIndex = -1; + } + var length = arr.length; + for (var i = 0; i < length; ++i) { + if (callback(arr[i], i, arr)) { + return i; + } + } + return defaultIndex; + } + /** + * Returns the reverse direction index of the first element in the array that satisfies the provided testing function. + * @function + * @memberof CrossBrowser + * @param - The array `findLastIndex` was called upon. + * @param - A function to execute on each value in the array until the function returns true, indicating that the satisfying element was found. + * @param - Returns defaultIndex if not found by the function. + * @example + import { findLastIndex } from "@daybrush/utils"; + + findLastIndex([{a: 1}, {a: 2}, {a: 3}, {a: 4}], ({ a }) => a === 2); // 1 + */ + function findLastIndex(arr, callback, defaultIndex) { + if (defaultIndex === void 0) { + defaultIndex = -1; + } + var length = arr.length; + for (var i = length - 1; i >= 0; --i) { + if (callback(arr[i], i, arr)) { + return i; + } + } + return defaultIndex; + } + /** + * Returns the value of the reverse direction element in the array that satisfies the provided testing function. + * @function + * @memberof CrossBrowser + * @param - The array `findLast` was called upon. + * @param - A function to execute on each value in the array, + * @param - Returns defalutValue if not found by the function. + * @example + import { find } from "@daybrush/utils"; + + find([{a: 1}, {a: 2}, {a: 3}, {a: 4}], ({ a }) => a === 2); // {a: 2} + */ + function findLast(arr, callback, defalutValue) { + var index = findLastIndex(arr, callback); + return index > -1 ? arr[index] : defalutValue; + } + /** + * Returns the value of the first element in the array that satisfies the provided testing function. + * @function + * @memberof CrossBrowser + * @param - The array `find` was called upon. + * @param - A function to execute on each value in the array, + * @param - Returns defalutValue if not found by the function. + * @example + import { find } from "@daybrush/utils"; + + find([{a: 1}, {a: 2}, {a: 3}, {a: 4}], ({ a }) => a === 2); // {a: 2} + */ + function find(arr, callback, defalutValue) { + var index = findIndex(arr, callback); + return index > -1 ? arr[index] : defalutValue; + } + /** + * @function + * @memberof Utils + */ + function getKeys(obj) { + return Object.keys(obj); + } + /** + * @function + * @memberof Utils + */ + function getValues(obj) { + var keys = getKeys(obj); + return keys.map(function (key) { + return obj[key]; + }); + } + /** + * convert unit size to px size + * @function + * @memberof Utils + */ + function convertUnitSize(pos, size) { + var _a = splitUnit(pos), + value = _a.value, + unit = _a.unit; + if (isObject(size)) { + var sizeFunction = size[unit]; + if (sizeFunction) { + if (isFunction(sizeFunction)) { + return sizeFunction(value); + } else if (DEFAULT_UNIT_PRESETS[unit]) { + return DEFAULT_UNIT_PRESETS[unit](value, sizeFunction); + } + } + } else if (unit === "%") { + return value * size / 100; + } + if (DEFAULT_UNIT_PRESETS[unit]) { + return DEFAULT_UNIT_PRESETS[unit](value); + } + return value; + } + /** + * throttle number depending on the unit. + * @function + * @memberof Utils + */ + function throttle(num, unit) { + if (!unit) { + return num; + } + var reverseUnit = 1 / unit; + return Math.round(num / unit) / reverseUnit; + } + /** + * @function + * @memberof Utils + */ + function flat(arr) { + return arr.reduce(function (prev, cur) { + return prev.concat(cur); + }, []); + } + /** + * Checks if the specified class value exists in the element's class attribute. + * @memberof DOM + * @param element - target + * @param className - the class name to search + * @return {boolean} return false if the class is not found. + * @example + import {hasClass} from "@daybrush/utils"; + + console.log(hasClass(element, "start")); // true or false + */ + function hasClass(element, className) { + if (element.classList) { + return element.classList.contains(className); + } + return !!element.className.match(new RegExp("(\\s|^)" + className + "(\\s|$)")); + } + /** + * Add the specified class value. If these classe already exist in the element's class attribute they are ignored. + * @memberof DOM + * @param element - target + * @param className - the class name to add + * @example + import {addClass} from "@daybrush/utils"; + + addClass(element, "start"); + */ + function addClass(element, className) { + if (element.classList) { + element.classList.add(className); + } else { + element.className += " " + className; + } + } + /** + * Removes the specified class value. + * @memberof DOM + * @param element - target + * @param className - the class name to remove + * @example + import {removeClass} from "@daybrush/utils"; + + removeClass(element, "start"); + */ + function removeClass(element, className) { + if (element.classList) { + element.classList.remove(className); + } else { + var reg = new RegExp("(\\s|^)" + className + "(\\s|$)"); + element.className = element.className.replace(reg, " "); + } + } + /** + * Sets up a function that will be called whenever the specified event is delivered to the target + * @memberof DOM + * @param - event target + * @param - A case-sensitive string representing the event type to listen for. + * @param - The object which receives a notification (an object that implements the Event interface) when an event of the specified type occurs + * @param - An options object that specifies characteristics about the event listener. + * @example + import {addEvent} from "@daybrush/utils"; + + addEvent(el, "click", e => { + console.log(e); + }); + */ + function addEvent(el, type, listener, options) { + el.addEventListener(type, listener, options); + } + /** + * removes from the EventTarget an event listener previously registered with EventTarget.addEventListener() + * @memberof DOM + * @param - event target + * @param - A case-sensitive string representing the event type to listen for. + * @param - The EventListener function of the event handler to remove from the event target. + * @param - An options object that specifies characteristics about the event listener. + * @example + import {addEvent, removeEvent} from "@daybrush/utils"; + const listener = e => { + console.log(e); + }; + addEvent(el, "click", listener); + removeEvent(el, "click", listener); + */ + function removeEvent(el, type, listener, options) { + el.removeEventListener(type, listener, options); + } + function getWindow(el) { + var _a; + return ((_a = el === null || el === void 0 ? void 0 : el.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView) || window; + } + + /* + Copyright (c) 2019-present NAVER Corp. + name: @egjs/list-differ + license: MIT + author: NAVER Corp. + repository: https://github.com/naver/egjs-list-differ + version: 1.0.0 + */ + /* + egjs-list-differ + Copyright (c) 2019-present NAVER Corp. + MIT license + */ + var PolyMap = + /*#__PURE__*/ + function () { + function PolyMap() { + this.keys = []; + this.values = []; + } + + var __proto = PolyMap.prototype; + + __proto.get = function (key) { + return this.values[this.keys.indexOf(key)]; + }; + + __proto.set = function (key, value) { + var keys = this.keys; + var values = this.values; + var prevIndex = keys.indexOf(key); + var index = prevIndex === -1 ? keys.length : prevIndex; + keys[index] = key; + values[index] = value; + }; + + return PolyMap; + }(); + + /* + egjs-list-differ + Copyright (c) 2019-present NAVER Corp. + MIT license + */ + var HashMap = + /*#__PURE__*/ + function () { + function HashMap() { + this.object = {}; + } + + var __proto = HashMap.prototype; + + __proto.get = function (key) { + return this.object[key]; + }; + + __proto.set = function (key, value) { + this.object[key] = value; + }; + + return HashMap; + }(); + + /* + egjs-list-differ + Copyright (c) 2019-present NAVER Corp. + MIT license + */ + var SUPPORT_MAP = typeof Map === "function"; + + /* + egjs-list-differ + Copyright (c) 2019-present NAVER Corp. + MIT license + */ + var Link = + /*#__PURE__*/ + function () { + function Link() {} + + var __proto = Link.prototype; + + __proto.connect = function (prevLink, nextLink) { + this.prev = prevLink; + this.next = nextLink; + prevLink && (prevLink.next = this); + nextLink && (nextLink.prev = this); + }; + + __proto.disconnect = function () { + // In double linked list, diconnect the interconnected relationship. + var prevLink = this.prev; + var nextLink = this.next; + prevLink && (prevLink.next = nextLink); + nextLink && (nextLink.prev = prevLink); + }; + + __proto.getIndex = function () { + var link = this; + var index = -1; + + while (link) { + link = link.prev; + ++index; + } + + return index; + }; + + return Link; + }(); + + /* + egjs-list-differ + Copyright (c) 2019-present NAVER Corp. + MIT license + */ + + function orderChanged(changed, fixed) { + // It is roughly in the order of these examples. + // 4, 6, 0, 2, 1, 3, 5, 7 + var fromLinks = []; // 0, 1, 2, 3, 4, 5, 6, 7 + + var toLinks = []; + changed.forEach(function (_a) { + var from = _a[0], + to = _a[1]; + var link = new Link(); + fromLinks[from] = link; + toLinks[to] = link; + }); // `fromLinks` are connected to each other by double linked list. + + fromLinks.forEach(function (link, i) { + link.connect(fromLinks[i - 1]); + }); + return changed.filter(function (_, i) { + return !fixed[i]; + }).map(function (_a, i) { + var from = _a[0], + to = _a[1]; + + if (from === to) { + return [0, 0]; + } + + var fromLink = fromLinks[from]; + var toLink = toLinks[to - 1]; + var fromIndex = fromLink.getIndex(); // Disconnect the link connected to `fromLink`. + + fromLink.disconnect(); // Connect `fromLink` to the right of `toLink`. + + if (!toLink) { + fromLink.connect(undefined, fromLinks[0]); + } else { + fromLink.connect(toLink, toLink.next); + } + + var toIndex = fromLink.getIndex(); + return [fromIndex, toIndex]; + }); + } + + var Result = + /*#__PURE__*/ + function () { + function Result(prevList, list, added, removed, changed, maintained, changedBeforeAdded, fixed) { + this.prevList = prevList; + this.list = list; + this.added = added; + this.removed = removed; + this.changed = changed; + this.maintained = maintained; + this.changedBeforeAdded = changedBeforeAdded; + this.fixed = fixed; + } + + var __proto = Result.prototype; + Object.defineProperty(__proto, "ordered", { + get: function () { + if (!this.cacheOrdered) { + this.caculateOrdered(); + } + + return this.cacheOrdered; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(__proto, "pureChanged", { + get: function () { + if (!this.cachePureChanged) { + this.caculateOrdered(); + } + + return this.cachePureChanged; + }, + enumerable: true, + configurable: true + }); + + __proto.caculateOrdered = function () { + var ordered = orderChanged(this.changedBeforeAdded, this.fixed); + var changed = this.changed; + var pureChanged = []; + this.cacheOrdered = ordered.filter(function (_a, i) { + var from = _a[0], + to = _a[1]; + var _b = changed[i], + fromBefore = _b[0], + toBefore = _b[1]; + + if (from !== to) { + pureChanged.push([fromBefore, toBefore]); + return true; + } + }); + this.cachePureChanged = pureChanged; + }; + + return Result; + }(); + + /** + * + * @memberof eg.ListDiffer + * @static + * @function + * @param - Previous List 이전 목록 + * @param - List to Update 업데이트 할 목록 + * @param - This callback function returns the key of the item. 아이템의 키를 반환하는 콜백 함수입니다. + * @return - Returns the diff between `prevList` and `list` `prevList`와 `list`의 다른 점을 반환한다. + * @example + * import { diff } from "@egjs/list-differ"; + * // script => eg.ListDiffer.diff + * const result = diff([0, 1, 2, 3, 4, 5], [7, 8, 0, 4, 3, 6, 2, 1], e => e); + * // List before update + * // [1, 2, 3, 4, 5] + * console.log(result.prevList); + * // Updated list + * // [4, 3, 6, 2, 1] + * console.log(result.list); + * // Index array of values added to `list` + * // [0, 1, 5] + * console.log(result.added); + * // Index array of values removed in `prevList` + * // [5] + * console.log(result.removed); + * // An array of index pairs of `prevList` and `list` with different indexes from `prevList` and `list` + * // [[0, 2], [4, 3], [3, 4], [2, 6], [1, 7]] + * console.log(result.changed); + * // The subset of `changed` and an array of index pairs that moved data directly. Indicate an array of absolute index pairs of `ordered`.(Formatted by: Array<[index of prevList, index of list]>) + * // [[4, 3], [3, 4], [2, 6]] + * console.log(result.pureChanged); + * // An array of index pairs to be `ordered` that can synchronize `list` before adding data. (Formatted by: Array<[prevIndex, nextIndex]>) + * // [[4, 1], [4, 2], [4, 3]] + * console.log(result.ordered); + * // An array of index pairs of `prevList` and `list` that have not been added/removed so data is preserved + * // [[0, 2], [4, 3], [3, 4], [2, 6], [1, 7]] + * console.log(result.maintained); + */ + + function diff(prevList, list, findKeyCallback) { + var mapClass = SUPPORT_MAP ? Map : findKeyCallback ? HashMap : PolyMap; + + var callback = findKeyCallback || function (e) { + return e; + }; + + var added = []; + var removed = []; + var maintained = []; + var prevKeys = prevList.map(callback); + var keys = list.map(callback); + var prevKeyMap = new mapClass(); + var keyMap = new mapClass(); + var changedBeforeAdded = []; + var fixed = []; + var removedMap = {}; + var changed = []; + var addedCount = 0; + var removedCount = 0; // Add prevKeys and keys to the hashmap. + + prevKeys.forEach(function (key, prevListIndex) { + prevKeyMap.set(key, prevListIndex); + }); + keys.forEach(function (key, listIndex) { + keyMap.set(key, listIndex); + }); // Compare `prevKeys` and `keys` and add them to `removed` if they are not in `keys`. + + prevKeys.forEach(function (key, prevListIndex) { + var listIndex = keyMap.get(key); // In prevList, but not in list, it is removed. + + if (typeof listIndex === "undefined") { + ++removedCount; + removed.push(prevListIndex); + } else { + removedMap[listIndex] = removedCount; + } + }); // Compare `prevKeys` and `keys` and add them to `added` if they are not in `prevKeys`. + + keys.forEach(function (key, listIndex) { + var prevListIndex = prevKeyMap.get(key); // In list, but not in prevList, it is added. + + if (typeof prevListIndex === "undefined") { + added.push(listIndex); + ++addedCount; + } else { + maintained.push([prevListIndex, listIndex]); + removedCount = removedMap[listIndex] || 0; + changedBeforeAdded.push([prevListIndex - removedCount, listIndex - addedCount]); + fixed.push(listIndex === prevListIndex); + + if (prevListIndex !== listIndex) { + changed.push([prevListIndex, listIndex]); + } + } + }); // Sort by ascending order of 'to(list's index). + + removed.reverse(); + return new Result(prevList, list, added, removed, changed, maintained, changedBeforeAdded, fixed); + } + + /* + Copyright (c) Daybrush + name: croact + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/croact.git + version: 1.0.3 + */ + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + var extendStatics$1 = function(d, b) { + extendStatics$1 = 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$1(d, b); + }; + + function __extends$1(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics$1(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + } + + var __assign$1 = function() { + __assign$1 = Object.assign || function __assign(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$1.apply(this, arguments); + }; + + function __rest(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; + } + + function __spreadArray(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)); + } + + function fillKeys(keys) { + var index = 0; + return keys.map(function (key) { + return key == null ? "$compat".concat(++index) : "".concat(key); + }); + } + function flat$1(arr) { + var arr2 = []; + arr.forEach(function (el) { + arr2 = arr2.concat(isArray(el) ? flat$1(el) : el); + }); + return arr2; + } + function fillProps(props, defaultProps) { + if (!defaultProps) { + return props; + } + for (var name_1 in defaultProps) { + if (isUndefined(props[name_1])) { + props[name_1] = defaultProps[name_1]; + } + } + return props; + } + function isDiff(a, b) { + if (a === b) { + return false; + } + for (var i in a) { + if (!(i in b)) { + return true; + } + } + for (var i in b) { + if (a[i] !== b[i]) { + return true; + } + } + return false; + } + function getAttributes(props) { + var className = props.className, + otherProps = __rest(props, ["className"]); + if (className != null) { + otherProps.class = className; + } + delete otherProps.style; + delete otherProps.children; + return otherProps; + } + function splitProps(props) { + var attributes = {}; + var events = {}; + for (var name_2 in props) { + if (name_2.indexOf("on") === 0) { + events[name_2] = props[name_2]; + } else { + attributes[name_2] = props[name_2]; + } + } + return [attributes, events]; + } + function findContainerNode(provider) { + if (!provider) { + return null; + } + var base = provider.b; + if (base instanceof Node) { + return base; + } + return findContainerNode(provider.c); + } + function removeNode(node) { + var parentNode = node.parentNode; + if (parentNode) { + parentNode.removeChild(node); + } + } + function executeHooks(hooks) { + hooks.forEach(function (hook) { + hook(); + }); + } + function renderFunctionComponent() { + return this.constructor(this.props, this.context); + } + + var hooksIndex = 0; + var Provider = /*#__PURE__*/function () { + function Provider( + /** + * Type + */ + t, + /** + * Depth + */ + d, + /** + * Key + */ + k, + /** + * index + */ + i, + /** + * Container + */ + c, + /** + * Ref + */ + ref, + /** + * Props + */ + ps) { + if (ps === void 0) { + ps = {}; + } + this.t = t; + this.d = d; + this.k = k; + this.i = i; + this.c = c; + this.ref = ref; + this.ps = ps; + this.typ = "prov"; + /** + * providers + */ + this._ps = []; + /** + * Contexts + */ + this._cs = {}; + /** + * Whether to hydrate + */ + this._hyd = null; + /** + * is self render + */ + this._sel = false; + } + var __proto = Provider.prototype; + __proto.s = function () { + return true; + }; + /** + * Update + */ + __proto.u = function (hooks, contexts, nextElement, nextState, isForceUpdate) { + var self = this; + var currentDepth = self.d; + var scheduledContexts = getValues(contexts).filter(function (context) { + return context.$_req; + }); + var scheduledSubs = flat$1(scheduledContexts.map(function (context) { + return context.$_subs; + })); + var isContextUpdate = find(scheduledSubs, function (provider) { + return provider.d === currentDepth; + }); + if (self.b && !isString(nextElement) && !isForceUpdate && !self.s(nextElement.props, nextState) && !isContextUpdate) { + var nextChildSubs = scheduledSubs.reduce(function (childs, sub) { + var depth = sub.d; + if (childs[0]) { + if (childs[0].d === depth) { + childs.push(sub); + } + } else if (depth > currentDepth) { + childs.push(sub); + } + return childs; + }, []); + nextChildSubs.forEach(function (child) { + // provider.container!, + // [provider], + // [provider.original], + // hooks, + // provider._cs, + // { ...self.state, ...self.$_state }, + // isForceUpdate, + renderProviders(child, child._ps, [child.o], hooks, contexts, true); + }); + return false; + } + self.o = nextElement; + self.ss(nextState); + // render + var prevProps = self.ps; + if (!isString(nextElement)) { + self.ps = nextElement.props; + self.ref = nextElement.ref; + } + setCurrentInstance(this); + self.r(hooks, contexts, self.b ? prevProps : {}, nextState); + return true; + }; + __proto.md = function () { + this.rr(); + }; + __proto.ss = function () { + return; + }; + __proto.ud = function () { + this.rr(); + }; + /** + * register refs + */ + __proto.rr = function () { + var self = this; + var ref = self.ref; + var fr = self.fr; + ref && ref(fr ? fr.current : self.b); + }; + return Provider; + }(); + function getCurrentInstance() { + return Object.__CROACT_CURRENT_INSTNACE__; + } + function getHooksIndex() { + return hooksIndex; + } + function setHooksInex(nextHooksIndex) { + hooksIndex = nextHooksIndex; + } + function setCurrentInstance(provider) { + Object.__CROACT_CURRENT_INSTNACE__ = provider; + hooksIndex = 0; + return provider; + } + + var Component = /*#__PURE__*/function () { + function Component(props, context) { + if (props === void 0) { + props = {}; + } + this.props = props; + this.context = context; + this.state = {}; + this.$_timer = 0; + this.$_state = {}; + this.$_subs = []; + this.$_cs = {}; + } + var __proto = Component.prototype; + __proto.render = function () { + return null; + }; + __proto.shouldComponentUpdate = function (props, state) { + return this.props !== props || this.state !== state; + }; + __proto.setState = function (state, callback, isForceUpdate) { + var self = this; + if (!self.$_timer) { + self.$_state = {}; + } + clearTimeout(self.$_timer); + self.$_timer = 0; + self.$_state = __assign$1(__assign$1({}, self.$_state), state); + if (!isForceUpdate) { + self.$_timer = window.setTimeout(function () { + self.$_timer = 0; + self.$_setState(callback, isForceUpdate); + }); + } else { + self.$_setState(callback, isForceUpdate); + } + return; + }; + __proto.forceUpdate = function (callback) { + this.setState({}, callback, true); + }; + __proto.componentDidMount = function () {}; + __proto.componentDidUpdate = function (prevProps, prevState) {}; + __proto.componentWillUnmount = function () {}; + __proto.$_setState = function (callback, isForceUpdate) { + var hooks = []; + var provider = this.$_p; + var isUpdate = renderProviders(provider.c, [provider], [provider.o], hooks, provider._cs, __assign$1(__assign$1({}, this.state), this.$_state), isForceUpdate); + if (isUpdate) { + if (callback) { + hooks.push(callback); + } + executeHooks(hooks); + setCurrentInstance(null); + } + }; + return Component; + }(); + var PureComponent = /*#__PURE__*/function (_super) { + __extends$1(PureComponent, _super); + function PureComponent() { + return _super !== null && _super.apply(this, arguments) || this; + } + var __proto = PureComponent.prototype; + __proto.shouldComponentUpdate = function (props, state) { + return isDiff(this.props, props) || isDiff(this.state, state); + }; + return PureComponent; + }(Component); + + function createRef(defaultValue) { + var refCallback = function (e) { + refCallback.current = e; + }; + refCallback.current = defaultValue; + return refCallback; + } + function forwardRef(func) { + func._fr = true; + return func; + } + + function createComponent(type, props, contextValue, self) { + var _a; + var base; + if ((_a = type === null || type === void 0 ? void 0 : type.prototype) === null || _a === void 0 ? void 0 : _a.render) { + base = new type(props, contextValue); + } else { + base = new Component(props, contextValue); + base.constructor = type; + if (type._fr) { + self.fr = createRef(); + base.render = function () { + return this.constructor(this.props, self.fr); + }; + } else { + base.render = renderFunctionComponent; + } + } + base.$_p = self; + return base; + } + var ComponentProvider = /*#__PURE__*/function (_super) { + __extends$1(ComponentProvider, _super); + function ComponentProvider(type, depth, key, index, container, ref, props) { + if (props === void 0) { + props = {}; + } + var _this = _super.call(this, type, depth, key, index, container, ref, fillProps(props, type.defaultProps)) || this; + _this.typ = "comp"; + /** + * Update shift effects + */ + _this._usefs = []; + /** + * Update effects + */ + _this._uefs = []; + /** + * Destroy effects + */ + _this._defs = []; + return _this; + } + var __proto = ComponentProvider.prototype; + __proto.s = function (nextProps, nextState) { + var base = this.b; + return base.shouldComponentUpdate(fillProps(nextProps, this.t.defaultProps), nextState || base.state) !== false; + }; + __proto.r = function (hooks, contexts, prevProps) { + var _a, _b; + var self = this; + var type = self.t; + self.ps = fillProps(self.ps, self.t.defaultProps); + var props = self.ps; + var isMount = !self.b; + var contextType = type.contextType; + var base = self.b; + var contextValue = contextType === null || contextType === void 0 ? void 0 : contextType.get(self); + self._cs = contexts; + if (isMount) { + base = createComponent(type, props, contextValue, self); + self.b = base; + } else { + base.props = props; + base.context = contextValue; + } + var prevState = base.state; + self._usefs = []; + self._uefs = []; + var template = base.render(); + if (((_b = (_a = template === null || template === void 0 ? void 0 : template.props) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b.length) === 0) { + template.props.children = self.ps.children; + } + var nextContexts = __assign$1(__assign$1({}, contexts), base.$_cs); + renderProviders(self, self._ps, template ? [template] : [], hooks, nextContexts); + if (isMount) { + self._uefs.push(function () { + contextType === null || contextType === void 0 ? void 0 : contextType.register(self); + base.componentDidMount(); + }); + } else { + self._uefs.push(function () { + base.componentDidUpdate(prevProps, prevState); + }); + } + hooks.push(function () { + self._usefs.forEach(function (ef) { + ef(); + }); + if (isMount) { + self.md(); + } else { + self.ud(); + } + self._defs = self._uefs.map(function (ef) { + return ef(); + }); + }); + }; + __proto.ss = function (nextState) { + var base = this.b; + if (!base || !nextState) { + return; + } + base.state = nextState; + }; + __proto.un = function () { + var _a; + var self = this; + self._ps.forEach(function (provider) { + provider.un(); + }); + var type = self.t; + (_a = type.contextType) === null || _a === void 0 ? void 0 : _a.unregister(self); + clearTimeout(self.b.$_timer); + self._defs.forEach(function (def) { + def && def(); + }); + self.b.componentWillUnmount(); + }; + return ComponentProvider; + }(Provider); + + function diffAttributes(attrs1, attrs2, el) { + var _a = diffObject(getAttributes(attrs1), getAttributes(attrs2)), + added = _a.added, + removed = _a.removed, + changed = _a.changed; + for (var name_1 in added) { + el.setAttribute(name_1, added[name_1]); + } + for (var name_2 in changed) { + el.setAttribute(name_2, changed[name_2][1]); + } + for (var name_3 in removed) { + el.removeAttribute(name_3); + } + } + function diffEvents(events1, events2, provier) { + var _a = diffObject(events1, events2), + added = _a.added, + removed = _a.removed; + for (var name_4 in removed) { + provier.e(name_4, true); + } + for (var name_5 in added) { + provier.e(name_5); + } + } + function diffObject(a, b) { + var keys1 = getKeys(a); + var keys2 = getKeys(b); + var result = diff(keys1, keys2, function (key) { + return key; + }); + var added = {}; + var removed = {}; + var changed = {}; + result.added.forEach(function (index) { + var name = keys2[index]; + added[name] = b[name]; + }); + result.removed.forEach(function (index) { + var name = keys1[index]; + removed[name] = a[name]; + }); + result.maintained.forEach(function (_a) { + var index = _a[0]; + var name = keys1[index]; + var values = [a[name], b[name]]; + if (a[name] !== b[name]) { + changed[name] = values; + } + }); + return { + added: added, + removed: removed, + changed: changed + }; + } + function diffStyle(style1, style2, el) { + var style = el.style; + var _a = diffObject(style1, style2), + added = _a.added, + removed = _a.removed, + changed = _a.changed; + for (var beforeName in added) { + var name_6 = decamelize(beforeName, "-"); + style.setProperty(name_6, added[beforeName]); + } + for (var beforeName in changed) { + var name_7 = decamelize(beforeName, "-"); + style.setProperty(name_7, changed[beforeName][1]); + } + for (var beforeName in removed) { + var name_8 = decamelize(beforeName, "-"); + style.removeProperty(name_8); + } + } + function getNativeEventName(name) { + return name.replace(/^on/g, "").toLowerCase(); + } + var ElementProvider = /*#__PURE__*/function (_super) { + __extends$1(ElementProvider, _super); + function ElementProvider() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.typ = "elem"; + /** + * Events + */ + _this._es = {}; + /** + * is svg + */ + _this._svg = false; + return _this; + } + var __proto = ElementProvider.prototype; + __proto.e = function (name, isRemove) { + var self = this; + var events = self._es; + var base = self.b; + var eventName = getNativeEventName(name); + if (isRemove) { + removeEvent(base, eventName, events[name]); + delete events[name]; + } else { + events[name] = function (e) { + var _a, _b; + (_b = (_a = self.ps)[name]) === null || _b === void 0 ? void 0 : _b.call(_a, e); + }; + addEvent(base, eventName, events[name]); + } + }; + __proto.s = function (nextProps) { + return isDiff(this.ps, nextProps); + }; + __proto.r = function (hooks, contextValues, prevProps) { + var _a; + var self = this; + var isMount = !self.b; + var nextProps = self.ps; + if (isMount) { + var isSVG = false; + if (self._svg || self.t === "svg") { + isSVG = true; + } else { + var containerNode = findContainerNode(self.c); + isSVG = containerNode && containerNode.ownerSVGElement; + } + self._svg = isSVG; + var element = (_a = self._hyd) === null || _a === void 0 ? void 0 : _a.splice(0, 1)[0]; + var type = self.t; + if (element) { + self._hyd = [].slice.call(element.children || []); + } else { + if (isSVG) { + element = document.createElementNS("http://www.w3.org/2000/svg", type); + } else { + element = document.createElement(type); + } + } + self.b = element; + } + renderProviders(self, self._ps, nextProps.children, hooks, contextValues); + var base = self.b; + var _b = splitProps(prevProps), + prevAttributes = _b[0], + prevEvents = _b[1]; + var _c = splitProps(nextProps), + nextAttributes = _c[0], + nextEvents = _c[1]; + diffAttributes(prevAttributes, nextAttributes, base); + diffEvents(prevEvents, nextEvents, self); + diffStyle(prevProps.style || {}, nextProps.style || {}, base); + hooks.push(function () { + if (isMount) { + self.md(); + } else { + self.ud(); + } + }); + return true; + }; + __proto.un = function () { + var self = this; + var events = self._es; + var base = self.b; + for (var name_9 in events) { + removeEvent(base, name_9, events[name_9]); + } + self._ps.forEach(function (provider) { + provider.un(); + }); + self._es = {}; + if (!self._sel) { + removeNode(base); + } + }; + return ElementProvider; + }(Provider); + + function findDOMNode(comp) { + if (!comp || comp instanceof Node) { + return comp; + } + var providers = comp.$_p._ps; + if (!providers.length) { + return null; + } + return findDOMNode(providers[0].b); + } + function findNodeProvider(provider) { + if (!provider) { + return; + } + if (provider.b && provider.b instanceof Node) { + return provider; + } + var providers = provider._ps; + if (!providers.length) { + return null; + } + return findNodeProvider(providers[0]); + } + function createElement(type, props) { + var children = []; + for (var _i = 2; _i < arguments.length; _i++) { + children[_i - 2] = arguments[_i]; + } + var _a = props || {}, + key = _a.key, + ref = _a.ref, + otherProps = __rest(_a, ["key", "ref"]); + return { + type: type, + key: key, + ref: ref, + props: __assign$1(__assign$1({}, otherProps), { + children: flat(children).filter(function (child) { + return child != null && child !== false; + }) + }) + }; + } + + var ContainerProvider = /*#__PURE__*/function (_super) { + __extends$1(ContainerProvider, _super); + function ContainerProvider(base, depth) { + if (depth === void 0) { + depth = 0; + } + var _this = _super.call(this, "container", depth, "container", 0, null) || this; + _this.typ = "container"; + _this.b = base; + return _this; + } + var __proto = ContainerProvider.prototype; + __proto.r = function () { + return true; + }; + __proto.un = function () { + return; + }; + return ContainerProvider; + }(Provider); + var TextProvider = /*#__PURE__*/function (_super) { + __extends$1(TextProvider, _super); + function TextProvider() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.typ = "text"; + return _this; + } + var __proto = TextProvider.prototype; + __proto.r = function (hooks) { + var _a; + var self = this; + var isMount = !self.b; + if (isMount) { + var b = (_a = self._hyd) === null || _a === void 0 ? void 0 : _a.splice(0, 1)[0]; + self.b = b || document.createTextNode(self.t.replace("text_", "")); + } + hooks.push(function () { + if (isMount) { + self.md(); + } else { + self.ud(); + } + }); + return true; + }; + __proto.un = function () { + removeNode(this.b); + }; + return TextProvider; + }(Provider); + function diffProviders(containerProvider, providers, children) { + var childrenKeys = children.map(function (p) { + return isString(p) ? null : p.key; + }); + var keys1 = fillKeys(providers.map(function (p) { + return p.k; + })); + var keys2 = fillKeys(childrenKeys); + var result = diff(keys1, keys2, function (key) { + return key; + }); + result.removed.forEach(function (index) { + providers.splice(index, 1)[0].un(); + }); + result.ordered.forEach(function (_a) { + var from = _a[0], + to = _a[1]; + var childrenProvider = providers.splice(from, 1)[0]; + providers.splice(to, 0, childrenProvider); + var el = findDOMNode(childrenProvider.b); + var next = findDOMNode(providers[to + 1] && providers[to + 1].b); + if (el) { + el.parentNode.insertBefore(el, next); + } + }); + result.added.forEach(function (index) { + providers.splice(index, 0, createProvider(children[index], childrenKeys[index], index, containerProvider)); + }); + var changed = result.maintained.filter(function (_a) { + _a[0]; + var to = _a[1]; + var el = children[to]; + var childProvider = providers[to]; + var type = isString(el) ? "text_".concat(el) : el.type; + if (type !== childProvider.t) { + childProvider.un(); + providers.splice(to, 1, createProvider(el, childrenKeys[to], to, containerProvider)); + return true; + } + childProvider.i = to; + return false; + }); + return __spreadArray(__spreadArray([], result.added, true), changed.map(function (_a) { + _a[0]; + var to = _a[1]; + return to; + }), true); + } + + function getNextSibiling(provider, childProvider) { + var childProviders = provider._ps; + var length = childProviders.length; + for (var i = childProvider.i + 1; i < length; ++i) { + var el = findDOMNode(childProviders[i].b); + if (el) { + return el; + } + } + return null; + } + function createProvider(el, key, index, containerProvider) { + var depth = containerProvider.d + 1; + if (isString(el) || isNumber(el)) { + return new TextProvider("text_".concat(el), depth, key, index, containerProvider, null, {}); + } + var type = el.type; + var providerClass = typeof type === "string" ? ElementProvider : ComponentProvider; + return new providerClass(type, depth, key, index, containerProvider, el.ref, el.props); + } + function renderProviders(containerProvider, providers, children, updatedHooks, nextContexts, nextState, isForceUpdate) { + var result = diffProviders(containerProvider, providers, children); + var hyd = containerProvider._hyd; + var updated = providers.filter(function (childProvider, i) { + childProvider._hyd = hyd; + return childProvider.u(updatedHooks, nextContexts, children[i], nextState, isForceUpdate); + }); + if (containerProvider.typ === "container" && containerProvider._sel) { + providers.forEach(function (provider) { + var nodeProvider = findNodeProvider(provider); + if (nodeProvider) { + nodeProvider._sel = true; + } + }); + } + containerProvider._hyd = null; + var containerNode = findContainerNode(containerProvider); + if (containerNode) { + result.reverse().forEach(function (index) { + var childProvider = providers[index]; + var el = findDOMNode(childProvider.b); + if (!el) { + return; + } + if (containerNode !== el && !el.parentNode) { + var nextElement = getNextSibiling(containerProvider, childProvider); + containerNode.insertBefore(el, nextElement); + } + }); + } + return updated.length > 0; + } + function renderProvider(element, container, provider, contexts) { + if (provider === void 0) { + provider = container.__CROACT__; + } + if (contexts === void 0) { + contexts = {}; + } + var isProvider = !!provider; + if (!provider) { + provider = new ContainerProvider(container); + } + var hooks = []; + renderProviders(provider, provider._ps, element ? [element] : [], hooks, contexts, undefined, undefined); + executeHooks(hooks); + setCurrentInstance(null); + if (!isProvider) { + container.__CROACT__ = provider; + } + return provider; + } + function renderSelf(element, self, containerProvider) { + if (!containerProvider && element) { + containerProvider = new ContainerProvider(self.parentElement); + containerProvider._hyd = [self]; + containerProvider._sel = true; + } + renderProvider(element, self, containerProvider); + return containerProvider; + } + + function checkHookInfo(info) { + var inst = getCurrentInstance(); + var hooks = inst._hs || (inst._hs = []); + var index = getHooksIndex(); + var prevHt = hooks[index]; + setHooksInex(index + 1); + if (prevHt) { + if (!isDiff(prevHt.deps, info.deps)) { + prevHt.updated = false; + return prevHt; + } + hooks[index] = info; + } else { + hooks.push(info); + } + info.value = info.func(); + info.updated = true; + return info; + } + function useMemo(defaultFunction, deps) { + var info = checkHookInfo({ + func: defaultFunction, + deps: deps + }); + return info.value; + } + function useRef(defaultValue) { + return useMemo(function () { + return createRef(defaultValue); + }, []); + } + function useEffect(effect, deps, unshift) { + var inst = getCurrentInstance(); + var info = checkHookInfo({ + func: function () { + return effect; + }, + deps: deps + }); + var effects = unshift ? inst._usefs : inst._uefs; + if (info.updated) { + effects.push(function () { + info.effect && info.effect(); + info.effect = effect(); + return info.effect; + }); + } else { + effects.push(function () { + return info.effect; + }); + } + } + function useImperativeHandle(ref, func, deps) { + useEffect(function () { + ref === null || ref === void 0 ? void 0 : ref(func()); + }, deps, true); + } + + /* + Copyright (c) 2019 Daybrush + name: @scena/react-ruler + license: MIT + author: Daybrush + repository: https://github.com/daybrush/ruler/blob/master/packages/react-ruler + version: 0.19.0 + */ + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + + /* global Reflect, Promise */ + var extendStatics$2 = function (d, b) { + extendStatics$2 = 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$2(d, b); + }; + + function __extends$2(d, b) { + if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics$2(d, b); + + function __() { + this.constructor = d; + } + + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + } + + var Ruler = + /*#__PURE__*/ + function (_super) { + __extends$2(Ruler, _super); + + function Ruler() { + var _this = _super !== null && _super.apply(this, arguments) || this; + + _this.state = { + scrollPos: 0 + }; + _this.width = 0; + _this.height = 0; + _this._zoom = 0; + _this._rulerScale = 0; + _this._observer = null; + + _this._checkResize = function () { + _this.resize(); + }; + + return _this; + } + + var __proto = Ruler.prototype; + + __proto.render = function () { + var props = this.props; + this._zoom = props.zoom; + return createElement("canvas", { + ref: ref(this, "canvasElement"), + style: this.props.style + }); + }; + + __proto.componentDidMount = function () { + var props = this.props; + this.state.scrollPos = props.defaultScrollPos || 0; + var canvas = this.canvasElement; + var context = canvas.getContext("2d", { + alpha: true + }); + this.canvasContext = context; + + if (props.useResizeObserver) { + this._observer = new ResizeObserver(this._checkResize); + + this._observer.observe(canvas, { + box: "border-box" + }); + } else { + this.resize(); + } + }; + + __proto.componentDidUpdate = function () { + this.resize(); + }; + + __proto.componentWillUnmount = function () { + var _a; + + this.state.scrollPos = 0; + (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect(); + }; + /** + * Gets the scroll position of the ruler. + */ + + + __proto.getScrollPos = function () { + return this.state.scrollPos; + }; + /** + * @method Ruler#scroll + * @param scrollPos + */ + + + __proto.scroll = function (scrollPos, zoom) { + this.draw({ + scrollPos: scrollPos, + zoom: zoom + }); + }; + /** + * @method Ruler#resize + */ + + + __proto.resize = function (nextZoom) { + var canvas = this.canvasElement; + var _a = this.props, + width = _a.width, + height = _a.height, + scrollPos = _a.scrollPos; + + var rulerScale = this._getRulerScale(); + + this.width = width || canvas.offsetWidth; + this.height = height || canvas.offsetHeight; + canvas.width = this.width * rulerScale; + canvas.height = this.height * rulerScale; + this.draw({ + scrollPos: scrollPos, + zoom: nextZoom + }); + }; + /** + * draw a ruler + * @param options - It is drawn with an external value, not the existing state. + */ + + + __proto.draw = function (options) { + if (options === void 0) { + options = {}; + } + + var props = this.props; + var _a = options.zoom, + nextZoom = _a === void 0 ? this._zoom : _a, + _b = options.scrollPos, + scrollPos = _b === void 0 ? this.state.scrollPos : _b, + _c = options.marks, + marks = _c === void 0 ? props.marks : _c, + _d = options.selectedRanges, + selectedRanges = _d === void 0 ? props.selectedRanges : _d, + _e = options.segment, + segment = _e === void 0 ? props.segment || 10 : _e, + _f = options.unit, + unit = _f === void 0 ? props.unit : _f; + this._zoom = nextZoom; + var _g = props, + type = _g.type, + backgroundColor = _g.backgroundColor, + lineColor = _g.lineColor, + textColor = _g.textColor, + textBackgroundColor = _g.textBackgroundColor, + direction = _g.direction, + _h = _g.negativeRuler, + negativeRuler = _h === void 0 ? true : _h, + textFormat = _g.textFormat, + _j = _g.range, + range = _j === void 0 ? [-Infinity, Infinity] : _j, + rangeBackgroundColor = _g.rangeBackgroundColor, + selectedBackgroundColor = _g.selectedBackgroundColor, + _k = _g.lineWidth, + lineWidth = _k === void 0 ? 1 : _k, + selectedRangesText = _g.selectedRangesText, + _l = _g.selectedRangesTextColor, + selectedRangesTextColor = _l === void 0 ? "#44aaff" : _l, + _m = _g.selectedRangesTextOffset, + selectedRangesTextOffset = _m === void 0 ? [0, 0] : _m, + _o = _g.markColor, + markColor = _o === void 0 ? "#ff5" : _o; + + var rulerScale = this._getRulerScale(); + + var width = this.width; + var height = this.height; + var state = this.state; + state.scrollPos = scrollPos; + var context = this.canvasContext; + var isHorizontal = type === "horizontal"; + var isNegative = negativeRuler !== false; + var font = props.font || "10px sans-serif"; + var textAlign = props.textAlign || "left"; + var textOffset = props.textOffset || [0, 0]; + var containerSize = isHorizontal ? height : width; + var mainLineSize = convertUnitSize("".concat(props.mainLineSize || "100%"), containerSize); + var longLineSize = convertUnitSize("".concat(props.longLineSize || 10), containerSize); + var shortLineSize = convertUnitSize("".concat(props.shortLineSize || 7), containerSize); + var lineOffset = props.lineOffset || [0, 0]; + + if (backgroundColor === "transparent") { + // Clear existing paths & text + context.clearRect(0, 0, width * rulerScale, height * rulerScale); + } else { + // Draw the background + context.rect(0, 0, width * rulerScale, height * rulerScale); + context.fillStyle = backgroundColor; + context.fill(); + } + + context.save(); + context.scale(rulerScale, rulerScale); + context.strokeStyle = lineColor; + context.lineWidth = lineWidth; + context.font = font; + context.fillStyle = textColor; + context.textAlign = textAlign; + + switch (direction) { + case "start": + context.textBaseline = "top"; + break; + + case "center": + context.textBaseline = "middle"; + break; + + case "end": + context.textBaseline = "bottom"; + break; + } + + context.translate(0.5, 0); + context.beginPath(); + var size = isHorizontal ? width : height; + var zoomUnit = nextZoom * unit; + var minRange = Math.floor(scrollPos * nextZoom / zoomUnit); + var maxRange = Math.ceil((scrollPos * nextZoom + size) / zoomUnit); + var length = maxRange - minRange; + var alignOffset = Math.max(["left", "center", "right"].indexOf(textAlign) - 1, -1); + var barSize = isHorizontal ? height : width; + var values = []; + + for (var i = 0; i <= length; ++i) { + var value = (i + minRange) * unit; + var text = "".concat(value); + + if (textFormat) { + text = textFormat(value); + } + + var textSize = context.measureText(text).width; + values.push({ + color: textColor, + offset: textOffset, + backgroundColor: textBackgroundColor, + value: value, + text: text, + textSize: textSize + }); + } // Draw Selected Range Background + + + if (selectedBackgroundColor !== "transparent" && (selectedRanges === null || selectedRanges === void 0 ? void 0 : selectedRanges.length)) { + selectedRanges.forEach(function (selectedRange) { + var rangeStart = Math.max(selectedRange[0], range[0], negativeRuler ? -Infinity : 0); + var rangeEnd = Math.min(selectedRange[1], range[1]); + var rangeX = (rangeStart - scrollPos) * nextZoom; + var rangeWidth = (rangeEnd - rangeStart) * nextZoom; + + if (selectedRangesText) { + selectedRange.forEach(function (value) { + var text = "".concat(value); + + if (textFormat) { + text = textFormat(value); + } + + var textSize = context.measureText(text).width; + var startPos = value * nextZoom; + var endPos = startPos + textSize; + findLast(values, function (_a, index) { + var prevValue = _a.value, + prevTextSize = _a.textSize; + var prevStartPos = prevValue * nextZoom; + var prevEndPos = prevStartPos + prevTextSize; + + if (prevStartPos <= endPos && startPos <= prevEndPos) { + values.splice(index, 1); + } + }); + values.push({ + value: value, + color: selectedRangesTextColor, + offset: selectedRangesTextOffset, + text: text, + textSize: textSize + }); + }); + } + + if (rangeWidth <= 0) { + return; + } + + context.save(); + context.fillStyle = selectedBackgroundColor; + + if (isHorizontal) { + context.fillRect(rangeX, 0, rangeWidth, barSize); + } else { + context.fillRect(0, rangeX, barSize, rangeWidth); + } + + context.restore(); + }); + } // Draw Range Background + + + if (rangeBackgroundColor !== "transparent" && range[0] !== -Infinity && range[1] !== Infinity) { + var rangeStart = (range[0] - scrollPos) * nextZoom; + var rangeEnd = (range[1] - range[0]) * nextZoom; + context.save(); + context.fillStyle = rangeBackgroundColor; + + if (isHorizontal) { + context.fillRect(rangeStart, 0, rangeEnd, barSize); + } else { + context.fillRect(0, rangeStart, barSize, rangeEnd); + } + + context.restore(); + } // Render Segments First + + + for (var i = 0; i <= length; ++i) { + var value = i + minRange; + + if (!isNegative && value < 0) { + continue; + } + + var startValue = value * unit; + var startPos = (startValue - scrollPos) * nextZoom; + + for (var j = 0; j < segment; ++j) { + var pos = startPos + j / segment * zoomUnit; + var value_1 = startValue + j / segment * unit; + + if (pos < 0 || pos >= size || value_1 < range[0] || value_1 > range[1]) { + continue; + } + + var lineSize = j === 0 ? mainLineSize : j % 2 === 0 ? longLineSize : shortLineSize; + var origin = 0; + + switch (direction) { + case "start": + origin = 0; + break; + + case "center": + origin = barSize / 2 - lineSize / 2; + break; + + case "end": + origin = barSize - lineSize; + break; + } + + var _p = isHorizontal ? [pos + lineOffset[0], origin + lineOffset[1]] : [origin + lineOffset[0], pos + lineOffset[1]], + x1 = _p[0], + y1 = _p[1]; + + var _q = isHorizontal ? [x1, y1 + lineSize] : [x1 + lineSize, y1], + x2 = _q[0], + y2 = _q[1]; + + context.moveTo(x1 + lineOffset[0], y1 + lineOffset[1]); + context.lineTo(x2 + lineOffset[0], y2 + lineOffset[1]); + } + } + + context.stroke(); + context.beginPath(); // Render marks + + context.strokeStyle = markColor; + context.lineWidth = 1; + (marks || []).forEach(function (value) { + var pos = (-scrollPos + value) * nextZoom; + + if (pos < 0 || pos >= size || value < range[0] || value > range[1]) { + return; + } + + var _a = isHorizontal ? [pos + lineOffset[0], lineOffset[1]] : [lineOffset[0], pos + lineOffset[1]], + x1 = _a[0], + y1 = _a[1]; + + var _b = isHorizontal ? [x1, y1 + containerSize] : [x1 + containerSize, y1], + x2 = _b[0], + y2 = _b[1]; + + context.moveTo(x1 + lineOffset[0], y1 + lineOffset[1]); + context.lineTo(x2 + lineOffset[0], y2 + lineOffset[1]); + }); + context.stroke(); // Render Labels + + values.forEach(function (_a) { + var value = _a.value, + offset = _a.offset, + backgroundColor = _a.backgroundColor, + color = _a.color, + text = _a.text, + textSize = _a.textSize; + + if (!isNegative && value < 0) { + return; + } + + var startPos = (value - scrollPos) * nextZoom; + + if (startPos < -zoomUnit || startPos >= size + unit * nextZoom || value < range[0] || value > range[1]) { + return; + } + + var origin = 0; + + switch (direction) { + case "start": + origin = 17; + break; + + case "center": + origin = barSize / 2; + break; + + case "end": + origin = barSize - 17; + break; + } + + var _b = isHorizontal ? [startPos + alignOffset * -3, origin] : [origin, startPos + alignOffset * 3], + startX = _b[0], + startY = _b[1]; + + if (backgroundColor) { + var backgroundOffset = 0; + + switch (textAlign) { + case "left": + backgroundOffset = 0; + break; + + case "center": + backgroundOffset = -textSize / 2; + break; + + case "right": + backgroundOffset = -textSize; + break; + } + + context.save(); + context.fillStyle = backgroundColor; + + if (isHorizontal) { + context.fillRect(startX + offset[0] + backgroundOffset, 0, textSize, mainLineSize); + } else { + context.translate(0, startY + offset[1]); + context.rotate(-Math.PI / 2); + context.fillRect(backgroundOffset, 0, textSize, mainLineSize); + } + + context.restore(); + } + + context.save(); + context.fillStyle = color; + + if (isHorizontal) { + context.fillText(text, startX + offset[0], startY + offset[1]); + } else { + context.translate(startX + offset[0], startY + offset[1]); + context.rotate(-Math.PI / 2); + context.fillText(text, 0, 0); + } + + context.restore(); + }); + context.restore(); + }; + + __proto._getRulerScale = function () { + var defaultPixelScale = this.props.defaultPixelScale || 2; + + if (!this._rulerScale) { + var isHighDensity = window.devicePixelRatio > 1; + + if (!isHighDensity && window.matchMedia) { + var mq = window.matchMedia('only screen and (min--moz-device-pixel-ratio: 1.3), only screen and (-o-min-device-pixel-ratio: 2.6/2), only screen and (-webkit-min-device-pixel-ratio: 1.3), only screen and (min-device-pixel-ratio: 1.3), only screen and (min-resolution: 1.3dppx)'); + isHighDensity = mq && mq.matches; + } + + this._rulerScale = isHighDensity ? 3 : defaultPixelScale; + } + + return this._rulerScale; + }; + + Ruler.defaultProps = { + type: "horizontal", + zoom: 1, + width: 0, + height: 0, + unit: 50, + negativeRuler: true, + mainLineSize: "100%", + longLineSize: 10, + shortLineSize: 7, + segment: 10, + direction: "end", + style: { + width: "100%", + height: "100%" + }, + backgroundColor: "#333333", + font: "10px sans-serif", + textColor: "#ffffff", + textBackgroundColor: 'transparent', + lineColor: "#777777", + range: [-Infinity, Infinity], + rangeBackgroundColor: 'transparent', + lineWidth: 1, + selectedBackgroundColor: "#555555", + defaultScrollPos: 0, + markColor: "#f55", + marks: [] + }; + return Ruler; + }(PureComponent); + + var PROPERTIES = ["type", "width", "height", "unit", "zoom", "direction", "textAlign", "font", "segment", "mainLineSize", "longLineSize", "shortLineSize", "lineOffset", "textOffset", "negativeRuler", "range", "scrollPos", "defaultScrollPos", "style", "backgroundColor", "rangeBackgroundColor", "lineColor", "textColor", "textBackgroundColor", "textFormat", "warpSelf", "selectedBackgroundColor", "selectedRanges", "defaultPixelScale", "useResizeObserver", "selectedRangesText", "selectedRangesTextColor", "selectedRangesTextOffset", "marks", "markColor"]; + + /* + Copyright (c) 2019 Daybrush + name: @scena/event-emitter + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/gesture.git + version: 1.0.5 + */ + + /*! ***************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + var __assign$2 = function () { + __assign$2 = Object.assign || function __assign(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$2.apply(this, arguments); + }; + function __spreadArrays$1() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + + for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; + + return r; + } + + /** + * Implement EventEmitter on object or component. + */ + + var EventEmitter = + /*#__PURE__*/ + function () { + function EventEmitter() { + this._events = {}; + } + /** + * Add a listener to the registered event. + * @param - Name of the event to be added + * @param - listener function of the event to be added + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Add listener in "a" event + * emitter.on("a", () => { + * }); + * // Add listeners + * emitter.on({ + * a: () => {}, + * b: () => {}, + * }); + */ + + + var __proto = EventEmitter.prototype; + + __proto.on = function (eventName, listener) { + if (isObject(eventName)) { + for (var name in eventName) { + this.on(name, eventName[name]); + } + } else { + this._addEvent(eventName, listener, {}); + } + + return this; + }; + /** + * Remove listeners registered in the event target. + * @param - Name of the event to be removed + * @param - listener function of the event to be removed + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Remove all listeners. + * emitter.off(); + * + * // Remove all listeners in "A" event. + * emitter.off("a"); + * + * + * // Remove "listener" listener in "a" event. + * emitter.off("a", listener); + */ + + + __proto.off = function (eventName, listener) { + if (!eventName) { + this._events = {}; + } else if (isObject(eventName)) { + for (var name in eventName) { + this.off(name); + } + } else if (!listener) { + this._events[eventName] = []; + } else { + var events = this._events[eventName]; + + if (events) { + var index = findIndex(events, function (e) { + return e.listener === listener; + }); + + if (index > -1) { + events.splice(index, 1); + } + } + } + + return this; + }; + /** + * Add a disposable listener and Use promise to the registered event. + * @param - Name of the event to be added + * @param - disposable listener function of the event to be added + * @example + * import EventEmitter from "@scena/event-emitter"; + * cosnt emitter = new EventEmitter(); + * + * // Add a disposable listener in "a" event + * emitter.once("a", () => { + * }); + * + * // Use Promise + * emitter.once("a").then(e => { + * }); + */ + + + __proto.once = function (eventName, listener) { + var _this = this; + + if (listener) { + this._addEvent(eventName, listener, { + once: true + }); + } + + return new Promise(function (resolve) { + _this._addEvent(eventName, resolve, { + once: true + }); + }); + }; + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * + * emitter.emit("a", { + * a: 1, + * }); + */ + + + __proto.emit = function (eventName, param) { + var _this = this; + + if (param === void 0) { + param = {}; + } + + var events = this._events[eventName]; + + if (!eventName || !events) { + return true; + } + + var isStop = false; + param.eventType = eventName; + + param.stop = function () { + isStop = true; + }; + + param.currentTarget = this; + + __spreadArrays$1(events).forEach(function (info) { + info.listener(param); + + if (info.once) { + _this.off(eventName, info.listener); + } + }); + + return !isStop; + }; + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * + * emitter.emit("a", { + * a: 1, + * }); + */ + + /** + * Fires an event to call listeners. + * @param - Event name + * @param - Event parameter + * @return If false, stop the event. + * @example + * + * import EventEmitter from "@scena/event-emitter"; + * + * + * const emitter = new EventEmitter(); + * + * emitter.on("a", e => { + * }); + * + * // emit + * emitter.trigger("a", { + * a: 1, + * }); + */ + + + __proto.trigger = function (eventName, param) { + if (param === void 0) { + param = {}; + } + + return this.emit(eventName, param); + }; + + __proto._addEvent = function (eventName, listener, options) { + var events = this._events; + events[eventName] = events[eventName] || []; + var listeners = events[eventName]; + listeners.push(__assign$2({ + listener: listener + }, options)); + }; + + return EventEmitter; + }(); + + /* + Copyright (c) 2019 Daybrush + name: @scena/dragscroll + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/dragscroll.git + version: 1.3.0 + */ + + /*! ***************************************************************************** + Copyright (c) Microsoft Corporation. All rights reserved. + Licensed under the Apache License, Version 2.0 (the "License"); you may not use + this file except in compliance with the License. You may obtain a copy of the + License at http://www.apache.org/licenses/LICENSE-2.0 + + THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED + WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, + MERCHANTABLITY OR NON-INFRINGEMENT. + + See the Apache Version 2.0 License for specific language governing permissions + and limitations under the License. + ***************************************************************************** */ + + /* global Reflect, Promise */ + var extendStatics$3 = function (d, b) { + extendStatics$3 = Object.setPrototypeOf || { + __proto__: [] + } instanceof Array && function (d, b) { + d.__proto__ = b; + } || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + }; + + return extendStatics$3(d, b); + }; + + function __extends$3(d, b) { + extendStatics$3(d, b); + + function __() { + this.constructor = d; + } + + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + } + var __assign$3 = function () { + __assign$3 = Object.assign || function __assign(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$3.apply(this, arguments); + }; + + function getDefaultScrollPosition(e) { + var container = e.container; + + if (container === document.body) { + return [container.scrollLeft || document.documentElement.scrollLeft, container.scrollTop || document.documentElement.scrollTop]; + } + + return [container.scrollLeft, container.scrollTop]; + } + + function getContainerElement(container) { + if (!container) { + return null; + } else if (isString(container)) { + return document.querySelector(container); + } + + if (isFunction(container)) { + return container(); + } else if (container instanceof Element) { + return container; + } else if ("current" in container) { + return container.current; + } else if ("value" in container) { + return container.value; + } + } + /** + * @sort 1 + */ + + + var DragScroll = + /*#__PURE__*/ + function (_super) { + __extends$3(DragScroll, _super); + + function DragScroll() { + var _this = _super !== null && _super.apply(this, arguments) || this; + + _this._startRect = null; + _this._startPos = []; + _this._prevTime = 0; + _this._timer = 0; + _this._prevScrollPos = [0, 0]; + _this._isWait = false; + _this._flag = false; + return _this; + } + /** + */ + + + var __proto = DragScroll.prototype; + + __proto.dragStart = function (e, options) { + var container = getContainerElement(options.container); + + if (!container) { + this._flag = false; + return; + } + + var top = 0; + var left = 0; + var width = 0; + var height = 0; + + if (container === document.body) { + width = window.innerWidth; + height = window.innerHeight; + } else { + var rect = container.getBoundingClientRect(); + top = rect.top; + left = rect.left; + width = rect.width; + height = rect.height; + } + + this._flag = true; + this._startPos = [e.clientX, e.clientY]; + this._startRect = { + top: top, + left: left, + width: width, + height: height + }; + this._prevScrollPos = this._getScrollPosition([0, 0], options); + }; + + __proto.drag = function (e, options) { + clearTimeout(this._timer); + + if (!this._flag) { + return; + } + + var clientX = e.clientX, + clientY = e.clientY; + var _a = options.threshold, + threshold = _a === void 0 ? 0 : _a; + + var _b = this, + _startRect = _b._startRect, + _startPos = _b._startPos; + + var direction = [0, 0]; + + if (_startRect.top > clientY - threshold) { + if (_startPos[1] > _startRect.top || clientY < _startPos[1]) { + direction[1] = -1; + } + } else if (_startRect.top + _startRect.height < clientY + threshold) { + if (_startPos[1] < _startRect.top + _startRect.height || clientY > _startPos[1]) { + direction[1] = 1; + } + } + + if (_startRect.left > clientX - threshold) { + if (_startPos[0] > _startRect.left || clientX < _startPos[0]) { + direction[0] = -1; + } + } else if (_startRect.left + _startRect.width < clientX + threshold) { + if (_startPos[0] < _startRect.left + _startRect.width || clientX > _startPos[0]) { + direction[0] = 1; + } + } + + if (!direction[0] && !direction[1]) { + return false; + } + + return this._continueDrag(__assign$3(__assign$3({}, options), { + direction: direction, + inputEvent: e, + isDrag: true + })); + }; + /** + */ + + + __proto.checkScroll = function (options) { + var _this = this; + + if (this._isWait) { + return false; + } + + var _a = options.prevScrollPos, + prevScrollPos = _a === void 0 ? this._prevScrollPos : _a, + direction = options.direction, + _b = options.throttleTime, + throttleTime = _b === void 0 ? 0 : _b, + inputEvent = options.inputEvent, + isDrag = options.isDrag; + + var nextScrollPos = this._getScrollPosition(direction || [0, 0], options); + + var offsetX = nextScrollPos[0] - prevScrollPos[0]; + var offsetY = nextScrollPos[1] - prevScrollPos[1]; + var nextDirection = direction || [offsetX ? Math.abs(offsetX) / offsetX : 0, offsetY ? Math.abs(offsetY) / offsetY : 0]; + this._prevScrollPos = nextScrollPos; + + if (!offsetX && !offsetY) { + return false; + } + /** + * @event DragScroll#move + */ + + + this.trigger("move", { + offsetX: nextDirection[0] ? offsetX : 0, + offsetY: nextDirection[1] ? offsetY : 0, + inputEvent: inputEvent + }); + + if (throttleTime && isDrag) { + clearTimeout(this._timer); + this._timer = window.setTimeout(function () { + _this._continueDrag(options); + }, throttleTime); + } + + return true; + }; + /** + */ + + + __proto.dragEnd = function () { + this._flag = false; + clearTimeout(this._timer); + }; + + __proto._getScrollPosition = function (direction, options) { + var container = options.container, + _a = options.getScrollPosition, + getScrollPosition = _a === void 0 ? getDefaultScrollPosition : _a; + return getScrollPosition({ + container: getContainerElement(container), + direction: direction + }); + }; + + __proto._continueDrag = function (options) { + var _this = this; + + var _a, _b; + + var container = options.container, + direction = options.direction, + throttleTime = options.throttleTime, + useScroll = options.useScroll, + isDrag = options.isDrag, + inputEvent = options.inputEvent; + + if (!this._flag || isDrag && this._isWait) { + return; + } + + var nowTime = now(); + var distTime = Math.max(throttleTime + this._prevTime - nowTime, 0); + + if (distTime > 0) { + clearTimeout(this._timer); + this._timer = window.setTimeout(function () { + _this._continueDrag(options); + }, distTime); + return false; + } + + this._prevTime = nowTime; + + var prevScrollPos = this._getScrollPosition(direction, options); + + this._prevScrollPos = prevScrollPos; + + if (isDrag) { + this._isWait = true; + } + + var param = { + container: getContainerElement(container), + direction: direction, + inputEvent: inputEvent + }; + (_b = (_a = options).requestScroll) === null || _b === void 0 ? void 0 : _b.call(_a, param); + /** + * @event DragScroll#scroll + */ + + this.trigger("scroll", param); + this._isWait = false; + return useScroll || this.checkScroll(__assign$3(__assign$3({}, options), { + prevScrollPos: prevScrollPos, + direction: direction, + inputEvent: inputEvent + })); + }; + + return DragScroll; + }(EventEmitter); + + /* + Copyright (c) 2019 Daybrush + name: gesto + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/gesto.git + version: 1.18.1 + */ + + /*! ***************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + var extendStatics$4 = function(d, b) { + extendStatics$4 = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics$4(d, b); + }; + + function __extends$4(d, b) { + extendStatics$4(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + } + + var __assign$4 = function() { + __assign$4 = Object.assign || function __assign(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$4.apply(this, arguments); + }; + + function getRad(pos1, pos2) { + var distX = pos2[0] - pos1[0]; + var distY = pos2[1] - pos1[1]; + var rad = Math.atan2(distY, distX); + return rad >= 0 ? rad : rad + Math.PI * 2; + } + function getRotatiion(touches) { + return getRad([ + touches[0].clientX, + touches[0].clientY, + ], [ + touches[1].clientX, + touches[1].clientY, + ]) / Math.PI * 180; + } + function isMultiTouch(e) { + return e.touches && e.touches.length >= 2; + } + function getEventClients(e) { + if (!e) { + return []; + } + if (e.touches) { + return getClients(e.touches); + } + else { + return [getClient(e)]; + } + } + function isMouseEvent(e) { + return e && (e.type.indexOf("mouse") > -1 || "button" in e); + } + function getPosition(clients, prevClients, startClients) { + var length = startClients.length; + var _a = getAverageClient(clients, length), clientX = _a.clientX, clientY = _a.clientY, originalClientX = _a.originalClientX, originalClientY = _a.originalClientY; + var _b = getAverageClient(prevClients, length), prevX = _b.clientX, prevY = _b.clientY; + var _c = getAverageClient(startClients, length), startX = _c.clientX, startY = _c.clientY; + var deltaX = clientX - prevX; + var deltaY = clientY - prevY; + var distX = clientX - startX; + var distY = clientY - startY; + return { + clientX: originalClientX, + clientY: originalClientY, + deltaX: deltaX, + deltaY: deltaY, + distX: distX, + distY: distY, + }; + } + function getDist(clients) { + return Math.sqrt(Math.pow(clients[0].clientX - clients[1].clientX, 2) + + Math.pow(clients[0].clientY - clients[1].clientY, 2)); + } + function getClients(touches) { + var length = Math.min(touches.length, 2); + var clients = []; + for (var i = 0; i < length; ++i) { + clients.push(getClient(touches[i])); + } + return clients; + } + function getClient(e) { + return { + clientX: e.clientX, + clientY: e.clientY, + }; + } + function getAverageClient(clients, length) { + if (length === void 0) { length = clients.length; } + var sumClient = { + clientX: 0, + clientY: 0, + originalClientX: 0, + originalClientY: 0, + }; + for (var i = 0; i < length; ++i) { + var client = clients[i]; + sumClient.originalClientX += "originalClientX" in client ? client.originalClientX : client.clientX; + sumClient.originalClientY += "originalClientY" in client ? client.originalClientY : client.clientY; + sumClient.clientX += client.clientX; + sumClient.clientY += client.clientY; + } + if (!length) { + return sumClient; + } + return { + clientX: sumClient.clientX / length, + clientY: sumClient.clientY / length, + originalClientX: sumClient.originalClientX / length, + originalClientY: sumClient.originalClientY / length, + }; + } + + var ClientStore = /*#__PURE__*/ (function () { + function ClientStore(clients) { + this.prevClients = []; + this.startClients = []; + this.movement = 0; + this.length = 0; + this.startClients = clients; + this.prevClients = clients; + this.length = clients.length; + } + ClientStore.prototype.getAngle = function (clients) { + if (clients === void 0) { clients = this.prevClients; } + return getRotatiion(clients); + }; + ClientStore.prototype.getRotation = function (clients) { + if (clients === void 0) { clients = this.prevClients; } + return getRotatiion(clients) - getRotatiion(this.startClients); + }; + ClientStore.prototype.getPosition = function (clients, isAdd) { + if (clients === void 0) { clients = this.prevClients; } + var position = getPosition(clients || this.prevClients, this.prevClients, this.startClients); + var deltaX = position.deltaX, deltaY = position.deltaY; + this.movement += Math.sqrt(deltaX * deltaX + deltaY * deltaY); + this.prevClients = clients; + return position; + }; + ClientStore.prototype.getPositions = function (clients) { + if (clients === void 0) { clients = this.prevClients; } + var prevClients = this.prevClients; + return this.startClients.map(function (startClient, i) { return getPosition([clients[i]], [prevClients[i]], [startClient]); }); + }; + ClientStore.prototype.getMovement = function (clients) { + var movement = this.movement; + if (!clients) { + return movement; + } + var currentClient = getAverageClient(clients, this.length); + var prevClient = getAverageClient(this.prevClients, this.length); + var deltaX = currentClient.clientX - prevClient.clientX; + var deltaY = currentClient.clientY - prevClient.clientY; + return Math.sqrt(deltaX * deltaX + deltaY * deltaY) + movement; + }; + ClientStore.prototype.getDistance = function (clients) { + if (clients === void 0) { clients = this.prevClients; } + return getDist(clients); + }; + ClientStore.prototype.getScale = function (clients) { + if (clients === void 0) { clients = this.prevClients; } + return getDist(clients) / getDist(this.startClients); + }; + ClientStore.prototype.move = function (deltaX, deltaY) { + this.startClients.forEach(function (client) { + client.clientX -= deltaX; + client.clientY -= deltaY; + }); + this.prevClients.forEach(function (client) { + client.clientX -= deltaX; + client.clientY -= deltaY; + }); + }; + return ClientStore; + }()); + + var INPUT_TAGNAMES = ["textarea", "input"]; + /** + * You can set up drag, pinch events in any browser. + */ + var Gesto = /*#__PURE__*/ (function (_super) { + __extends$4(Gesto, _super); + /** + * + */ + function Gesto(targets, options) { + if (options === void 0) { options = {}; } + var _this = _super.call(this) || this; + _this.options = {}; + _this.flag = false; + _this.pinchFlag = false; + _this.data = {}; + _this.isDrag = false; + _this.isPinch = false; + _this.isMouse = false; + _this.isTouch = false; + _this.clientStores = []; + _this.targets = []; + _this.prevTime = 0; + _this.doubleFlag = false; + _this._dragFlag = false; + _this._isTrusted = false; + _this._isMouseEvent = false; + _this._isSecondaryButton = false; + _this._preventMouseEvent = false; + _this._prevInputEvent = null; + _this._isDragAPI = false; + _this._isIdle = true; + _this._window = window; + _this.onDragStart = function (e, isTrusted) { + if (isTrusted === void 0) { isTrusted = true; } + if (!_this.flag && e.cancelable === false) { + return; + } + var isDragAPI = e.type.indexOf("drag") >= -1; + if (_this.flag && isDragAPI) { + return; + } + _this._isDragAPI = true; + var _a = _this.options, container = _a.container, pinchOutside = _a.pinchOutside, preventWheelClick = _a.preventWheelClick, preventRightClick = _a.preventRightClick, preventDefault = _a.preventDefault, checkInput = _a.checkInput, dragFocusedInput = _a.dragFocusedInput, preventClickEventOnDragStart = _a.preventClickEventOnDragStart, preventClickEventOnDrag = _a.preventClickEventOnDrag, preventClickEventByCondition = _a.preventClickEventByCondition; + var isTouch = _this.isTouch; + var isDragStart = !_this.flag; + _this._isSecondaryButton = e.which === 3 || e.button === 2; + if ((preventWheelClick && (e.which === 2 || e.button === 1)) + || (preventRightClick && (e.which === 3 || e.button === 2))) { + _this.stop(); + return false; + } + if (isDragStart) { + var activeElement = _this._window.document.activeElement; + var target = e.target; + if (target) { + var tagName = target.tagName.toLowerCase(); + var hasInput = INPUT_TAGNAMES.indexOf(tagName) > -1; + var hasContentEditable = target.isContentEditable; + if (hasInput || hasContentEditable) { + if (checkInput || (!dragFocusedInput && activeElement === target)) { + // force false or already focused. + return false; + } + // no focus + if (activeElement && (activeElement === target + || (hasContentEditable && activeElement.isContentEditable && activeElement.contains(target)))) { + if (dragFocusedInput) { + target.blur(); + } + else { + return false; + } + } + } + else if ((preventDefault || e.type === "touchstart") && activeElement) { + var activeTagName = activeElement.tagName.toLowerCase(); + if (activeElement.isContentEditable || INPUT_TAGNAMES.indexOf(activeTagName) > -1) { + activeElement.blur(); + } + } + if (preventClickEventOnDragStart || preventClickEventOnDrag || preventClickEventByCondition) { + addEvent(_this._window, "click", _this._onClick, true); + } + } + _this.clientStores = [new ClientStore(getEventClients(e))]; + _this._isIdle = false; + _this.flag = true; + _this.isDrag = false; + _this._isTrusted = isTrusted; + _this._dragFlag = true; + _this._prevInputEvent = e; + _this.data = {}; + _this.doubleFlag = now() - _this.prevTime < 200; + _this._isMouseEvent = isMouseEvent(e); + if (!_this._isMouseEvent && _this._preventMouseEvent) { + _this._preventMouseEvent = false; + } + var result = _this._preventMouseEvent || _this.emit("dragStart", __assign$4(__assign$4({ data: _this.data, datas: _this.data, inputEvent: e, isMouseEvent: _this._isMouseEvent, isSecondaryButton: _this._isSecondaryButton, isTrusted: isTrusted, isDouble: _this.doubleFlag }, _this.getCurrentStore().getPosition()), { preventDefault: function () { + e.preventDefault(); + }, preventDrag: function () { + _this._dragFlag = false; + } })); + if (result === false) { + _this.stop(); + } + if (_this._isMouseEvent && _this.flag && preventDefault) { + e.preventDefault(); + } + } + if (!_this.flag) { + return false; + } + var timer = 0; + if (isDragStart) { + _this._attchDragEvent(); + // wait pinch + if (isTouch && pinchOutside) { + timer = setTimeout(function () { + addEvent(container, "touchstart", _this.onDragStart, { + passive: false + }); + }); + } + } + else if (isTouch && pinchOutside) { + // pinch is occured + removeEvent(container, "touchstart", _this.onDragStart); + } + if (_this.flag && isMultiTouch(e)) { + clearTimeout(timer); + if (isDragStart && (e.touches.length !== e.changedTouches.length)) { + return; + } + if (!_this.pinchFlag) { + _this.onPinchStart(e); + } + } + }; + _this.onDrag = function (e, isScroll) { + if (!_this.flag) { + return; + } + var preventDefault = _this.options.preventDefault; + if (!_this._isMouseEvent && preventDefault) { + e.preventDefault(); + } + _this._prevInputEvent = e; + var clients = getEventClients(e); + var result = _this.moveClients(clients, e, false); + if (_this._dragFlag) { + if (_this.pinchFlag || result.deltaX || result.deltaY) { + var dragResult = _this._preventMouseEvent || _this.emit("drag", __assign$4(__assign$4({}, result), { isScroll: !!isScroll, inputEvent: e })); + if (dragResult === false) { + _this.stop(); + return; + } + } + if (_this.pinchFlag) { + _this.onPinch(e, clients); + } + } + _this.getCurrentStore().getPosition(clients, true); + }; + _this.onDragEnd = function (e) { + if (!_this.flag) { + return; + } + var _a = _this.options, pinchOutside = _a.pinchOutside, container = _a.container, preventClickEventOnDrag = _a.preventClickEventOnDrag, preventClickEventOnDragStart = _a.preventClickEventOnDragStart, preventClickEventByCondition = _a.preventClickEventByCondition; + var isDrag = _this.isDrag; + if (preventClickEventOnDrag || preventClickEventOnDragStart || preventClickEventByCondition) { + requestAnimationFrame(function () { + _this._allowClickEvent(); + }); + } + if (!preventClickEventByCondition && !preventClickEventOnDragStart && preventClickEventOnDrag && !isDrag) { + _this._allowClickEvent(); + } + if (_this.isTouch && pinchOutside) { + removeEvent(container, "touchstart", _this.onDragStart); + } + if (_this.pinchFlag) { + _this.onPinchEnd(e); + } + var clients = (e === null || e === void 0 ? void 0 : e.touches) ? getEventClients(e) : []; + var clientsLength = clients.length; + if (clientsLength === 0 || !_this.options.keepDragging) { + _this.flag = false; + } + else { + _this._addStore(new ClientStore(clients)); + } + var position = _this._getPosition(); + var currentTime = now(); + var isDouble = !isDrag && _this.doubleFlag; + _this._prevInputEvent = null; + _this.prevTime = isDrag || isDouble ? 0 : currentTime; + if (!_this.flag) { + _this._dettachDragEvent(); + _this._preventMouseEvent || _this.emit("dragEnd", __assign$4({ data: _this.data, datas: _this.data, isDouble: isDouble, isDrag: isDrag, isClick: !isDrag, isMouseEvent: _this._isMouseEvent, isSecondaryButton: _this._isSecondaryButton, inputEvent: e, isTrusted: _this._isTrusted }, position)); + _this.clientStores = []; + if (!_this._isMouseEvent) { + _this._preventMouseEvent = true; + requestAnimationFrame(function () { + requestAnimationFrame(function () { + _this._preventMouseEvent = false; + }); + }); + } + _this._isIdle = true; + } + }; + _this.onBlur = function () { + _this.onDragEnd(); + }; + _this._allowClickEvent = function () { + removeEvent(_this._window, "click", _this._onClick, true); + }; + _this._onClick = function (e) { + _this._allowClickEvent(); + _this._preventMouseEvent = false; + var preventClickEventByCondition = _this.options.preventClickEventByCondition; + if (preventClickEventByCondition === null || preventClickEventByCondition === void 0 ? void 0 : preventClickEventByCondition(e)) { + return; + } + e.stopPropagation(); + e.preventDefault(); + }; + _this._onContextMenu = function (e) { + var options = _this.options; + if (!options.preventRightClick) { + e.preventDefault(); + } + else { + _this.onDragEnd(e); + } + }; + _this._passCallback = function () { }; + var elements = [].concat(targets); + var firstTarget = elements[0]; + _this._window = firstTarget && !("document" in firstTarget) ? getWindow(firstTarget) : window; + _this.options = __assign$4({ checkInput: false, container: firstTarget && !("document" in firstTarget) ? getWindow(firstTarget) : firstTarget, preventRightClick: true, preventWheelClick: true, preventClickEventOnDragStart: false, preventClickEventOnDrag: false, preventClickEventByCondition: null, preventDefault: true, checkWindowBlur: false, keepDragging: false, pinchThreshold: 0, events: ["touch", "mouse"] }, options); + var _a = _this.options, container = _a.container, events = _a.events, checkWindowBlur = _a.checkWindowBlur; + _this.isTouch = events.indexOf("touch") > -1; + _this.isMouse = events.indexOf("mouse") > -1; + _this.targets = elements; + if (_this.isMouse) { + elements.forEach(function (el) { + addEvent(el, "mousedown", _this.onDragStart); + addEvent(el, "mousemove", _this._passCallback); + }); + addEvent(container, "contextmenu", _this._onContextMenu); + } + if (checkWindowBlur) { + addEvent(getWindow(), "blur", _this.onBlur); + } + if (_this.isTouch) { + var passive_1 = { + passive: false, + }; + elements.forEach(function (el) { + addEvent(el, "touchstart", _this.onDragStart, passive_1); + addEvent(el, "touchmove", _this._passCallback, passive_1); + }); + } + return _this; + } + /** + * Stop Gesto's drag events. + */ + Gesto.prototype.stop = function () { + this.isDrag = false; + this.data = {}; + this.clientStores = []; + this.pinchFlag = false; + this.doubleFlag = false; + this.prevTime = 0; + this.flag = false; + this._isIdle = true; + this._allowClickEvent(); + this._dettachDragEvent(); + this._isDragAPI = false; + }; + /** + * The total moved distance + */ + Gesto.prototype.getMovement = function (clients) { + return this.getCurrentStore().getMovement(clients) + this.clientStores.slice(1).reduce(function (prev, cur) { + return prev + cur.movement; + }, 0); + }; + /** + * Whether to drag + */ + Gesto.prototype.isDragging = function () { + return this.isDrag; + }; + /** + * Whether the operation of gesto is finished and is in idle state + */ + Gesto.prototype.isIdle = function () { + return this._isIdle; + }; + /** + * Whether to start drag + */ + Gesto.prototype.isFlag = function () { + return this.flag; + }; + /** + * Whether to start pinch + */ + Gesto.prototype.isPinchFlag = function () { + return this.pinchFlag; + }; + /** + * Whether to start double click + */ + Gesto.prototype.isDoubleFlag = function () { + return this.doubleFlag; + }; + /** + * Whether to pinch + */ + Gesto.prototype.isPinching = function () { + return this.isPinch; + }; + /** + * If a scroll event occurs, it is corrected by the scroll distance. + */ + Gesto.prototype.scrollBy = function (deltaX, deltaY, e, isCallDrag) { + if (isCallDrag === void 0) { isCallDrag = true; } + if (!this.flag) { + return; + } + this.clientStores[0].move(deltaX, deltaY); + isCallDrag && this.onDrag(e, true); + }; + /** + * Create a virtual drag event. + */ + Gesto.prototype.move = function (_a, inputEvent) { + var deltaX = _a[0], deltaY = _a[1]; + var store = this.getCurrentStore(); + var nextClients = store.prevClients; + return this.moveClients(nextClients.map(function (_a) { + var clientX = _a.clientX, clientY = _a.clientY; + return { + clientX: clientX + deltaX, + clientY: clientY + deltaY, + originalClientX: clientX, + originalClientY: clientY, + }; + }), inputEvent, true); + }; + /** + * The dragStart event is triggered by an external event. + */ + Gesto.prototype.triggerDragStart = function (e) { + this.onDragStart(e, false); + }; + /** + * Set the event data while dragging. + */ + Gesto.prototype.setEventData = function (data) { + var currentData = this.data; + for (var name_1 in data) { + currentData[name_1] = data[name_1]; + } + return this; + }; + /** + * Set the event data while dragging. + * Use `setEventData` + * @deprecated + */ + Gesto.prototype.setEventDatas = function (data) { + return this.setEventData(data); + }; + /** + * Get the current event state while dragging. + */ + Gesto.prototype.getCurrentEvent = function (inputEvent) { + if (inputEvent === void 0) { inputEvent = this._prevInputEvent; } + return __assign$4(__assign$4({ data: this.data, datas: this.data }, this._getPosition()), { movement: this.getMovement(), isDrag: this.isDrag, isPinch: this.isPinch, isScroll: false, inputEvent: inputEvent }); + }; + /** + * Get & Set the event data while dragging. + */ + Gesto.prototype.getEventData = function () { + return this.data; + }; + /** + * Get & Set the event data while dragging. + * Use getEventData method + * @depreacated + */ + Gesto.prototype.getEventDatas = function () { + return this.data; + }; + /** + * Unset Gesto + */ + Gesto.prototype.unset = function () { + var _this = this; + var targets = this.targets; + var container = this.options.container; + this.off(); + removeEvent(this._window, "blur", this.onBlur); + if (this.isMouse) { + targets.forEach(function (target) { + removeEvent(target, "mousedown", _this.onDragStart); + }); + removeEvent(container, "contextmenu", this._onContextMenu); + } + if (this.isTouch) { + targets.forEach(function (target) { + removeEvent(target, "touchstart", _this.onDragStart); + }); + removeEvent(container, "touchstart", this.onDragStart); + } + this._prevInputEvent = null; + this._allowClickEvent(); + this._dettachDragEvent(); + }; + Gesto.prototype.onPinchStart = function (e) { + var _this = this; + var pinchThreshold = this.options.pinchThreshold; + if (this.isDrag && this.getMovement() > pinchThreshold) { + return; + } + var store = new ClientStore(getEventClients(e)); + this.pinchFlag = true; + this._addStore(store); + var result = this.emit("pinchStart", __assign$4(__assign$4({ data: this.data, datas: this.data, angle: store.getAngle(), touches: this.getCurrentStore().getPositions() }, store.getPosition()), { inputEvent: e, isTrusted: this._isTrusted, preventDefault: function () { + e.preventDefault(); + }, preventDrag: function () { + _this._dragFlag = false; + } })); + if (result === false) { + this.pinchFlag = false; + } + }; + Gesto.prototype.onPinch = function (e, clients) { + if (!this.flag || !this.pinchFlag || clients.length < 2) { + return; + } + var store = this.getCurrentStore(); + this.isPinch = true; + this.emit("pinch", __assign$4(__assign$4({ data: this.data, datas: this.data, movement: this.getMovement(clients), angle: store.getAngle(clients), rotation: store.getRotation(clients), touches: store.getPositions(clients), scale: store.getScale(clients), distance: store.getDistance(clients) }, store.getPosition(clients)), { inputEvent: e, isTrusted: this._isTrusted })); + }; + Gesto.prototype.onPinchEnd = function (e) { + if (!this.pinchFlag) { + return; + } + var isPinch = this.isPinch; + this.isPinch = false; + this.pinchFlag = false; + var store = this.getCurrentStore(); + this.emit("pinchEnd", __assign$4(__assign$4({ data: this.data, datas: this.data, isPinch: isPinch, touches: store.getPositions() }, store.getPosition()), { inputEvent: e })); + }; + Gesto.prototype.getCurrentStore = function () { + return this.clientStores[0]; + }; + Gesto.prototype.moveClients = function (clients, inputEvent, isAdd) { + var position = this._getPosition(clients, isAdd); + var isPrevDrag = this.isDrag; + if (position.deltaX || position.deltaY) { + this.isDrag = true; + } + var isFirstDrag = false; + if (!isPrevDrag && this.isDrag) { + isFirstDrag = true; + } + return __assign$4(__assign$4({ data: this.data, datas: this.data }, position), { movement: this.getMovement(clients), isDrag: this.isDrag, isPinch: this.isPinch, isScroll: false, isMouseEvent: this._isMouseEvent, isSecondaryButton: this._isSecondaryButton, inputEvent: inputEvent, isTrusted: this._isTrusted, isFirstDrag: isFirstDrag }); + }; + Gesto.prototype._addStore = function (store) { + this.clientStores.splice(0, 0, store); + }; + Gesto.prototype._getPosition = function (clients, isAdd) { + var store = this.getCurrentStore(); + var position = store.getPosition(clients, isAdd); + var _a = this.clientStores.slice(1).reduce(function (prev, cur) { + var storePosition = cur.getPosition(); + prev.distX += storePosition.distX; + prev.distY += storePosition.distY; + return prev; + }, position), distX = _a.distX, distY = _a.distY; + return __assign$4(__assign$4({}, position), { distX: distX, distY: distY }); + }; + Gesto.prototype._attchDragEvent = function () { + var container = this.options.container; + var passive = { + passive: false + }; + if (this._isDragAPI) { + addEvent(container, "dragover", this.onDrag); + addEvent(container, "dragend", this.onDragEnd); + } + if (this.isMouse) { + addEvent(container, "mousemove", this.onDrag); + addEvent(container, "mouseup", this.onDragEnd); + } + if (this.isTouch) { + addEvent(container, "touchmove", this.onDrag, passive); + addEvent(container, "touchend", this.onDragEnd, passive); + addEvent(container, "touchcancel", this.onDragEnd, passive); + } + }; + Gesto.prototype._dettachDragEvent = function () { + var container = this.options.container; + if (this._isDragAPI) { + removeEvent(container, "dragover", this.onDrag); + removeEvent(container, "dragend", this.onDragEnd); + } + if (this.isMouse) { + removeEvent(container, "mousemove", this.onDrag); + removeEvent(container, "mouseup", this.onDragEnd); + } + if (this.isTouch) { + removeEvent(container, "touchstart", this.onDragStart); + removeEvent(container, "touchmove", this.onDrag); + removeEvent(container, "touchend", this.onDragEnd); + removeEvent(container, "touchcancel", this.onDragEnd); + } + }; + return Gesto; + }(EventEmitter)); + + /* + Copyright (c) Daybrush + name: css-styled + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/css-styled.git + version: 1.0.7 + */ + + function hash(str) { + var hash = 5381, + i = str.length; + + while(i) { + hash = (hash * 33) ^ str.charCodeAt(--i); + } + + /* JavaScript does bitwise operations (like XOR, above) on 32-bit signed + * integers. Since we want the results to be always positive, convert the + * signed int to an unsigned by doing an unsigned bitshift. */ + return hash >>> 0; + } + + var stringHash = hash; + + function getHash(str) { + return stringHash(str).toString(36); + } + function getShadowRoot(parentElement) { + if (parentElement && parentElement.getRootNode) { + var rootNode = parentElement.getRootNode(); + if (rootNode.nodeType === 11) { + return rootNode; + } + } + return; + } + function replaceStyle(className, css, options) { + if (options.original) { + return css; + } + return css.replace(/([^};{\s}][^};{]*|^\s*){/mg, function (_, selector) { + var trimmedSelector = selector.trim(); + return (trimmedSelector ? splitComma(trimmedSelector) : [""]).map(function (subSelector) { + var trimmedSubSelector = subSelector.trim(); + if (trimmedSubSelector.indexOf("@") === 0) { + return trimmedSubSelector; + } else if (trimmedSubSelector.indexOf(":global") > -1) { + return trimmedSubSelector.replace(/\:global/g, ""); + } else if (trimmedSubSelector.indexOf(":host") > -1) { + return "".concat(trimmedSubSelector.replace(/\:host/g, ".".concat(className))); + } else if (trimmedSubSelector) { + return ".".concat(className, " ").concat(trimmedSubSelector); + } else { + return ".".concat(className); + } + }).join(", ") + " {"; + }); + } + function injectStyle(className, css, options, el, shadowRoot) { + var style = document.createElement("style"); + style.setAttribute("type", "text/css"); + style.setAttribute("data-styled-id", className); + style.setAttribute("data-styled-count", "1"); + if (options.nonce) { + style.setAttribute("nonce", options.nonce); + } + style.innerHTML = replaceStyle(className, css, options); + var ownerDocument = el.ownerDocument || document; + (shadowRoot || ownerDocument.head || ownerDocument.body).appendChild(style); + return style; + } + + /** + * Create an styled object that can be defined and inserted into the css. + * @param - css styles + */ + function styled(css) { + var injectClassName = "rCS" + getHash(css); + return { + className: injectClassName, + inject: function (el, options) { + if (options === void 0) { + options = {}; + } + var shadowRoot = getShadowRoot(el); + var styleElement = (shadowRoot || el.ownerDocument || document).querySelector("style[data-styled-id=\"".concat(injectClassName, "\"]")); + if (!styleElement) { + styleElement = injectStyle(injectClassName, css, options, el, shadowRoot); + } else { + var count = parseFloat(styleElement.getAttribute("data-styled-count")) || 0; + styleElement.setAttribute("data-styled-count", "".concat(count + 1)); + } + return { + destroy: function () { + var _a; + var injectCount = parseFloat(styleElement.getAttribute("data-styled-count")) || 0; + if (injectCount <= 1) { + if (styleElement.remove) { + styleElement.remove(); + } else { + (_a = styleElement.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(styleElement); + } + styleElement = null; + } else { + styleElement.setAttribute("data-styled-count", "".concat(injectCount - 1)); + } + } + }; + } + }; + } + + /* + Copyright (c) 2019 Daybrush + name: react-css-styled + license: MIT + author: Daybrush + repository: https://github.com/daybrush/css-styled/tree/master/packages/react-css-styled + version: 1.1.8 + */ + var __assign$5 = function () { + __assign$5 = Object.assign || function __assign(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$5.apply(this, arguments); + }; + function __rest$1(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; + } + return t; + } + function styled$1(Tag, css) { + var injector = styled(css); + var cssId = injector.className; + return forwardRef(function (props, ref) { + var _a = props.className, + className = _a === void 0 ? "" : _a, + cspNonce = props.cspNonce, + attributes = __rest$1(props, ["className", "cspNonce"]); + var targetRef = useRef(); + useImperativeHandle(ref, function () { + return targetRef.current; + }, []); + useEffect(function () { + var injectResult = injector.inject(targetRef.current, { + nonce: props.cspNonce + }); + return function () { + injectResult.destroy(); + }; + }, []); + return createElement(Tag, __assign$5({ + "ref": targetRef, + "data-styled-id": cssId, + "className": "".concat(className, " ").concat(cssId) + }, attributes)); + }); + } + + /* + Copyright (c) 2020 Daybrush + name: @scena/matrix + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/matrix + version: 1.1.1 + */ + + function add(matrix, inverseMatrix, startIndex, fromIndex, n, k) { + for (var i = 0; i < n; ++i) { + var x = startIndex + i * n; + var fromX = fromIndex + i * n; + matrix[x] += matrix[fromX] * k; + inverseMatrix[x] += inverseMatrix[fromX] * k; + } + } + + function swap(matrix, inverseMatrix, startIndex, fromIndex, n) { + for (var i = 0; i < n; ++i) { + var x = startIndex + i * n; + var fromX = fromIndex + i * n; + var v = matrix[x]; + var iv = inverseMatrix[x]; + matrix[x] = matrix[fromX]; + matrix[fromX] = v; + inverseMatrix[x] = inverseMatrix[fromX]; + inverseMatrix[fromX] = iv; + } + } + + function divide(matrix, inverseMatrix, startIndex, n, k) { + for (var i = 0; i < n; ++i) { + var x = startIndex + i * n; + matrix[x] /= k; + inverseMatrix[x] /= k; + } + } + /** + * @memberof Matrix + */ + + function invert(matrix, n) { + if (n === void 0) { + n = Math.sqrt(matrix.length); + } + + var newMatrix = matrix.slice(); + var inverseMatrix = createIdentityMatrix(n); + + for (var i = 0; i < n; ++i) { + // diagonal + var identityIndex = n * i + i; + + if (!throttle(newMatrix[identityIndex], TINY_NUM)) { + // newMatrix[identityIndex] = 0; + for (var j = i + 1; j < n; ++j) { + if (newMatrix[n * i + j]) { + swap(newMatrix, inverseMatrix, i, j, n); + break; + } + } + } + + if (!throttle(newMatrix[identityIndex], TINY_NUM)) { + // no inverse matrix + return []; + } + + divide(newMatrix, inverseMatrix, i, n, newMatrix[identityIndex]); + + for (var j = 0; j < n; ++j) { + var targetStartIndex = j; + var targetIndex = j + i * n; + var target = newMatrix[targetIndex]; + + if (!throttle(target, TINY_NUM) || i === j) { + continue; + } + + add(newMatrix, inverseMatrix, targetStartIndex, i, n, -target); + } + } + + return inverseMatrix; + } + /** + * @memberof Matrix + */ + + function multiply(matrix, matrix2, n) { + if (n === void 0) { + n = Math.sqrt(matrix.length); + } + + var newMatrix = []; // 1 y: n + // 1 x: m + // 2 x: m + // 2 y: k + // n * m X m * k + + var m = matrix.length / n; + var k = matrix2.length / m; + + if (!m) { + return matrix2; + } else if (!k) { + return matrix; + } + + for (var i = 0; i < n; ++i) { + for (var j = 0; j < k; ++j) { + newMatrix[j * n + i] = 0; + + for (var l = 0; l < m; ++l) { + // m1 x: m(l), y: n(i) + // m2 x: k(j): y: m(l) + // nw x: n(i), y: k(j) + newMatrix[j * n + i] += matrix[l * n + i] * matrix2[j * m + l]; + } + } + } // n * k + + + return newMatrix; + } + /** + * @memberof Matrix + */ + + function calculate(matrix, matrix2, n) { + if (n === void 0) { + n = matrix2.length; + } + + var result = multiply(matrix, matrix2, n); + var k = result[n - 1]; + return result.map(function (v) { + return v / k; + }); + } + /** + * @memberof Matrix + */ + + function rotateX3d(matrix, rad) { + return multiply(matrix, [1, 0, 0, 0, 0, Math.cos(rad), Math.sin(rad), 0, 0, -Math.sin(rad), Math.cos(rad), 0, 0, 0, 0, 1], 4); + } + /** + * @memberof Matrix + */ + + function rotateY3d(matrix, rad) { + return multiply(matrix, [Math.cos(rad), 0, -Math.sin(rad), 0, 0, 1, 0, 0, Math.sin(rad), 0, Math.cos(rad), 0, 0, 0, 0, 1], 4); + } + /** + * @memberof Matrix + */ + + function rotateZ3d(matrix, rad) { + return multiply(matrix, createRotateMatrix(rad, 4)); + } + /** + * @memberof Matrix + */ + + function scale3d(matrix, _a) { + var _b = _a[0], + sx = _b === void 0 ? 1 : _b, + _c = _a[1], + sy = _c === void 0 ? 1 : _c, + _d = _a[2], + sz = _d === void 0 ? 1 : _d; + return multiply(matrix, [sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, sz, 0, 0, 0, 0, 1], 4); + } + /** + * @memberof Matrix + */ + + function translate3d(matrix, _a) { + var _b = _a[0], + tx = _b === void 0 ? 0 : _b, + _c = _a[1], + ty = _c === void 0 ? 0 : _c, + _d = _a[2], + tz = _d === void 0 ? 0 : _d; + return multiply(matrix, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, tx, ty, tz, 1], 4); + } + /** + * @memberof Matrix + */ + + function matrix3d(matrix1, matrix2) { + return multiply(matrix1, matrix2, 4); + } + /** + * @memberof Matrix + */ + + function createRotateMatrix(rad, n) { + var cos = Math.cos(rad); + var sin = Math.sin(rad); + var m = createIdentityMatrix(n); // cos -sin + // sin cos + + m[0] = cos; + m[1] = sin; + m[n] = -sin; + m[n + 1] = cos; + return m; + } + /** + * @memberof Matrix + */ + + function createIdentityMatrix(n) { + var length = n * n; + var matrix = []; + + for (var i = 0; i < length; ++i) { + matrix[i] = i % (n + 1) ? 0 : 1; + } + + return matrix; + } + + /* + Copyright (c) 2019 Daybrush + name: css-to-mat + license: MIT + author: Daybrush + repository: git+https://github.com/daybrush/css-to-mat.git + version: 1.0.3 + */ + + function createMatrix() { + return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; + } + function parseMat(transform) { + return toMat(parse(transform)); + } + function calculateMatrixDist(matrix, pos) { + var res = calculate(matrix, [pos[0], pos[1] || 0, pos[2] || 0, 1], 4); + var w = res[3] || 1; + return [res[0] / w, res[1] / w, res[2] / w]; + } + function getDistElementMatrix(el, container) { + if (container === void 0) { + container = document.body; + } + + var target = el; + var matrix = createMatrix(); + + while (target) { + var transform = getComputedStyle(target).transform; + matrix = matrix3d(parseMat(transform), matrix); + + if (target === container) { + break; + } + + target = target.parentElement; + } + + matrix = invert(matrix, 4); + matrix[12] = 0; + matrix[13] = 0; + matrix[14] = 0; + return matrix; + } + function toMat(matrixInfos) { + var target = createMatrix(); + matrixInfos.forEach(function (info) { + var matrixFunction = info.matrixFunction, + functionValue = info.functionValue; + + if (!matrixFunction) { + return; + } + + target = matrixFunction(target, functionValue); + }); + return target; + } + function parse(transform) { + var transforms = isArray(transform) ? transform : splitSpace(transform); + return transforms.map(function (t) { + var _a = splitBracket(t), + name = _a.prefix, + value = _a.value; + + var matrixFunction = null; + var functionName = name; + var functionValue = ""; + + if (name === "translate" || name === "translateX" || name === "translate3d") { + var _b = splitComma(value).map(function (v) { + return parseFloat(v); + }), + posX = _b[0], + _c = _b[1], + posY = _c === void 0 ? 0 : _c, + _d = _b[2], + posZ = _d === void 0 ? 0 : _d; + + matrixFunction = translate3d; + functionValue = [posX, posY, posZ]; + } else if (name === "translateY") { + var posY = parseFloat(value); + matrixFunction = translate3d; + functionValue = [0, posY, 0]; + } else if (name === "translateZ") { + var posZ = parseFloat(value); + matrixFunction = translate3d; + functionValue = [0, 0, posZ]; + } else if (name === "scale" || name === "scale3d") { + var _e = splitComma(value).map(function (v) { + return parseFloat(v); + }), + sx = _e[0], + _f = _e[1], + sy = _f === void 0 ? sx : _f, + _g = _e[2], + sz = _g === void 0 ? 1 : _g; + + matrixFunction = scale3d; + functionValue = [sx, sy, sz]; + } else if (name === "scaleX") { + var sx = parseFloat(value); + matrixFunction = scale3d; + functionValue = [sx, 1, 1]; + } else if (name === "scaleY") { + var sy = parseFloat(value); + matrixFunction = scale3d; + functionValue = [1, sy, 1]; + } else if (name === "scaleZ") { + var sz = parseFloat(value); + matrixFunction = scale3d; + functionValue = [1, 1, sz]; + } else if (name === "rotate" || name === "rotateZ" || name === "rotateX" || name === "rotateY") { + var _h = splitUnit(value), + unit = _h.unit, + unitValue = _h.value; + + var rad = unit === "rad" ? unitValue : unitValue * Math.PI / 180; + + if (name === "rotate" || name === "rotateZ") { + functionName = "rotateZ"; + matrixFunction = rotateZ3d; + } else if (name === "rotateX") { + matrixFunction = rotateX3d; + } else if (name === "rotateY") { + matrixFunction = rotateY3d; + } + + functionValue = rad; + } else if (name === "matrix3d") { + matrixFunction = matrix3d; + functionValue = splitComma(value).map(function (v) { + return parseFloat(v); + }); + } else if (name === "matrix") { + var m = splitComma(value).map(function (v) { + return parseFloat(v); + }); + matrixFunction = matrix3d; + functionValue = [m[0], m[1], 0, 0, m[2], m[3], 0, 0, 0, 0, 1, 0, m[4], m[5], 0, 1]; + } else { + functionName = ""; + } + + return { + name: name, + functionName: functionName, + value: value, + matrixFunction: matrixFunction, + functionValue: functionValue + }; + }); + } + + /* + Copyright (c) 2019 Daybrush + name: @scena/react-guides + license: MIT + author: Daybrush + repository: https://github.com/daybrush/guides/blob/master/packages/react-guides + version: 0.28.2 + */ + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + + /* global Reflect, Promise */ + + var extendStatics$5 = function (d, b) { + extendStatics$5 = 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$5(d, b); + }; + + function __extends$5(d, b) { + if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics$5(d, b); + + function __() { + this.constructor = d; + } + + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + } + + var __assign$6 = function () { + __assign$6 = Object.assign || function __assign(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$6.apply(this, arguments); + }; + + function __spreadArray$1(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)); + } + + function prefix() { + var classNames = []; + + for (var _i = 0; _i < arguments.length; _i++) { + classNames[_i] = arguments[_i]; + } + + return prefixNames.apply(void 0, __spreadArray$1(["scena-guides-"], classNames, false)); + } + + var ADDER = prefix("guide", "adder"); + var GUIDES = prefix("guides"); + var GUIDE = prefix("guide"); + var DRAGGING = prefix("dragging"); + var DISPLAY_DRAG = prefix("display-drag"); + var GUIDES_CSS = prefixCSS("scena-guides-", "\n{\n position: relative;\n width: 100%;\n height: 100%;\n}\ncanvas {\n position: relative;\n}\n.guide-origin {\n position: absolute;\n width: 1px;\n height: 1px;\n top: 0;\n left: 0;\n opacity: 0;\n}\n.guides {\n position: absolute;\n bottom: 0;\n right: 0;\n will-change: transform;\n z-index: 2000;\n}\n.guide-pos {\n position: absolute;\n font-weight: bold;\n font-size: 12px;\n color: #f33;\n}\n.horizontal .guide-pos {\n bottom: 100%;\n left: 50%;\n transform: translate(-50%);\n}\n.vertical .guide-pos {\n left: calc(100% + 2px);\n top: 50%;\n transform: translateY(-50%);\n}\n.display-drag {\n position: absolute;\n will-change: transform;\n z-index: 2000;\n font-weight: bold;\n font-size: 12px;\n display: none;\n left: 20px;\n top: -20px;\n color: #f33;\n}\n:host.horizontal .guides {\n width: 100%;\n height: 0;\n}\n:host.vertical .guides {\n height: 100%;\n width: 0;\n}\n:host.horizontal canvas {\n cursor: ns-resize;\n}\n:host.vertical canvas {\n cursor: ew-resize;\n}\n.guide {\n position: absolute;\n background: #f33;\n z-index: 2;\n}\n.guide.dragging:before {\n position: absolute;\n content: \"\";\n width: 100%;\n height: 100%;\n top: 50%;\n left: 50%;\n transform: translate(-50%, -50%);\n}\n:host.horizontal .guide {\n width: 100%;\n height: 1px;\n cursor: row-resize;\n}\n:host.vertical .guide {\n width: 1px;\n height: 100%;\n cursor: col-resize;\n}\n.mobile :host.horizontal .guide {\n transform: scale(1, 2);\n}\n.mobile :host.vertical .guide {\n transform: scale(2, 1);\n}\n:host.horizontal .guide:before {\n height: 20px;\n}\n:host.vertical .guide:before {\n width: 20px;\n}\n.adder {\n display: none;\n}\n.adder.dragging {\n display: block;\n}\n"); + + var PROPERTIES$1 = __spreadArray$1(["className", "rulerStyle", 'snapThreshold', "snaps", "displayDragPos", "cspNonce", 'dragPosFormat', "defaultGuides", "showGuides", "scrollOptions", "guideStyle", "guidesOffset", "digit", "defaultGuidesPos", "dragGuideStyle", "displayGuidePos", "guidePosFormat", "guidePosStyle", "lockGuides", "guidesZoom"], PROPERTIES, true); + + var METHODS = ["getGuides", "loadGuides", "scroll", "scrollGuides", "resize", "getElement", "getRulerElement", "forceUpdate", "getRulerScrollPos", "getGuideScrollPos", "zoomTo", "drawRuler"]; + var EVENTS = ["changeGuides", "requestScroll", "dragStart", "drag", "dragEnd", "clickRuler"]; + var GuidesElement = styled$1("div", GUIDES_CSS); + + var Guides = /*#__PURE__*/function (_super) { + __extends$5(Guides, _super); + + function Guides(props) { + var _this = _super.call(this, props) || this; + + _this.state = { + guides: [] + }; + _this.scrollPos = 0; + _this.managerRef = createRef(); + _this.guideElements = []; + _this._isFirstMove = false; + _this._zoom = 1; + _this._guidesZoom = 1; + _this._observer = null; + + _this.onDragStart = function (e) { + var datas = e.datas, + inputEvent = e.inputEvent; + _this._isFirstMove = true; + + _this.movePos(e); + /** + * When the drag starts, the dragStart event is called. + * @memberof Guides + * @event dragStart + * @param {OnDragStart} - Parameters for the dragStart event + */ + + + _this.props.onDragStart(__assign$6(__assign$6({}, e), { + dragElement: datas.target + })); + + if (!_this.gesto.isFlag()) { + return; + } + + inputEvent.stopPropagation(); + inputEvent.preventDefault(); + + _this._startDragScroll(e); + }; + + _this._onDrag = function (e) { + if (_this._isFirstMove) { + _this._isFirstMove = false; + addClass(e.datas.target, DRAGGING); + } + + var nextPos = _this.movePos(e); + /** + * When dragging, the drag event is called. + * @memberof Guides + * @event drag + * @param {OnDrag} - Parameters for the drag event + */ + + + _this.props.onDrag(__assign$6(__assign$6({}, e), { + dragElement: e.datas.target + })); + + if (!_this.gesto.isFlag()) { + _this._endDragScroll(e); + + return; + } + + _this._dragScroll(e); + + return nextPos; + }; + + _this.onDragEnd = function (e) { + var datas = e.datas, + isDouble = e.isDouble, + distX = e.distX, + distY = e.distY; + + var pos = _this.movePos(e); + + var guides = _this.state.guides; + var _a = _this.props, + onChangeGuides = _a.onChangeGuides, + displayDragPos = _a.displayDragPos, + digit = _a.digit, + lockGuides = _a.lockGuides, + guidesOffset = _a.guidesOffset; + var zoom = _this._guidesZoom; + var guidePos = parseFloat((pos / zoom).toFixed(digit || 0)); + var baseScrollPos = _this.scrollPos - (guidesOffset || 0); + + if (displayDragPos) { + _this.displayElement.style.cssText += "display: none;"; + } + + removeClass(datas.target, DRAGGING); + /** + * When the drag finishes, the dragEnd event is called. + * @memberof Guides + * @event dragEnd + * @param {OnDragEnd} - Parameters for the dragEnd event + */ + + _this.props.onDragEnd(__assign$6(__assign$6({}, e), { + dragElement: datas.target + })); + + _this._endDragScroll(e); + + if (datas.fromRuler) { + if (_this._isFirstMove) { + /** + * When click the ruler, the click ruler is called. + * @memberof Guides + * @event clickRuler + * @param {OnClickRuler} - Parameters for the clickRuler event + */ + _this.props.onClickRuler(__assign$6(__assign$6({}, e), { + pos: 0 + })); + } + + if (guidePos >= baseScrollPos && guides.indexOf(guidePos) < 0) { + _this.setState({ + guides: __spreadArray$1(__spreadArray$1([], guides, true), [guidePos], false) + }, function () { + /** + * The `changeGuides` event occurs when the guideline is added / removed / changed. + * @memberof Guides + * @event changeGuides + * @param {OnChangeGuides} - Parameters for the changeGuides event + */ + onChangeGuides({ + guides: _this.state.guides, + distX: distX, + distY: distY, + index: guides.length, + isAdd: true, + isRemove: false, + isChange: false + }); + }); + } + } else { + var index_1 = parseFloat(datas.target.getAttribute("data-index")); + var isRemove_1 = false; + var isChange_1 = false; + guides = __spreadArray$1([], guides, true); + var guideIndex = guides.indexOf(guidePos); + + if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) { + if (lockGuides && (lockGuides === true || lockGuides.indexOf("remove") > -1)) { + return; + } + + guides.splice(index_1, 1); + isRemove_1 = true; + } else if (guideIndex > -1) { + return; + } else { + if (lockGuides && (lockGuides === true || lockGuides.indexOf("change") > -1)) { + return; + } + + guides[index_1] = guidePos; + isChange_1 = true; + } + + _this.setState({ + guides: guides + }, function () { + var nextGuides = _this.state.guides; + onChangeGuides({ + distX: distX, + distY: distY, + guides: nextGuides, + isAdd: false, + index: index_1, + isChange: isChange_1, + isRemove: isRemove_1 + }); + }); + } + }; + + _this._onCheck = function () { + _this.resize(); + }; + + _this.state.guides = props.defaultGuides || []; + _this.scrollPos = props.defaultGuidesPos || 0; + return _this; + } + + var __proto = Guides.prototype; + + __proto.render = function () { + var _a = this.props, + className = _a.className, + type = _a.type, + zoom = _a.zoom, + guidesZoom = _a.guidesZoom, + style = _a.style, + rulerStyle = _a.rulerStyle, + displayDragPos = _a.displayDragPos, + cspNonce = _a.cspNonce, + dragGuideStyle = _a.dragGuideStyle, + _b = _a.guidePosStyle, + guidePosStyle = _b === void 0 ? {} : _b; + var props = this.props; + var translateName = this.getTranslateName(); + var rulerProps = {}; + PROPERTIES.forEach(function (name) { + if (name === "style" || name === "warpSelf" || name === "useResizeObserver") { + return; + } + + rulerProps[name] = props[name]; + }); + this._zoom = zoom; + this._guidesZoom = guidesZoom || zoom; + return createElement(GuidesElement, { + ref: this.managerRef, + cspNonce: cspNonce, + className: "".concat(prefix("manager", type), " ").concat(className), + style: style + }, createElement("div", { + className: prefix("guide-origin"), + ref: ref(this, "originElement") + }), createElement(Ruler, __assign$6({ + ref: ref(this, "ruler"), + style: rulerStyle + }, rulerProps)), createElement("div", { + className: GUIDES, + ref: ref(this, "guidesElement"), + style: { + transform: "".concat(translateName, "(").concat(-this.scrollPos * this._guidesZoom, "px)") + } + }, displayDragPos && createElement("div", { + className: DISPLAY_DRAG, + ref: ref(this, "displayElement"), + style: guidePosStyle || {} + }), createElement("div", { + className: ADDER, + ref: ref(this, "adderElement"), + style: dragGuideStyle + }), this.renderGuides())); + }; + /** + * Draw ruler + */ + + + __proto.drawRuler = function (options) { + this.ruler.draw(options); + }; + + __proto.renderGuides = function () { + var _this = this; + + var props = this.props; + var _a = props, + type = _a.type, + showGuides = _a.showGuides, + guideStyle = _a.guideStyle, + displayGuidePos = _a.displayGuidePos, + _b = _a.guidePosStyle, + guidePosStyle = _b === void 0 ? {} : _b, + guidesOffset = _a.guidesOffset; + var zoom = this._guidesZoom; + var translateName = this.getTranslateName(); + var guides = this.state.guides; + + var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) { + return v; + }; + + this.guideElements = []; + + if (showGuides) { + return guides.map(function (pos, i) { + var guidePos = pos + (guidesOffset || 0); + return createElement("div", { + className: prefix("guide", type), + ref: refs(_this, "guideElements", i), + key: i, + "data-index": i, + "data-pos": pos, + style: __assign$6(__assign$6({}, guideStyle), { + transform: "".concat(translateName, "(").concat(guidePos * zoom, "px) translateZ(0px)") + }) + }, displayGuidePos && createElement("div", { + className: prefix("guide-pos"), + style: guidePosStyle || {} + }, guidePosFormat(pos))); + }); + } + + return; + }; + + __proto.componentDidMount = function () { + var _this = this; + + this.gesto = new Gesto(this.managerRef.current, { + container: document.body + }).on("dragStart", function (e) { + var _a = _this.props, + type = _a.type, + lockGuides = _a.lockGuides; + var zoom = _this._guidesZoom; + + if (lockGuides === true) { + e.stop(); + return; + } + + var inputEvent = e.inputEvent; + var target = inputEvent.target; + var datas = e.datas; + var canvasElement = _this.ruler.canvasElement; + var guidesElement = _this.guidesElement; + var isHorizontal = type === "horizontal"; + + var originRect = _this.originElement.getBoundingClientRect(); + + var matrix = getDistElementMatrix(_this.managerRef.current); + var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]); + offsetPos[0] -= guidesElement.offsetLeft; + offsetPos[1] -= guidesElement.offsetTop; + offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom; + datas.offsetPos = offsetPos; + datas.matrix = matrix; + var isLockAdd = lockGuides && lockGuides.indexOf("add") > -1; + var isLockRemove = lockGuides && lockGuides.indexOf("remove") > -1; + var isLockChange = lockGuides && lockGuides.indexOf("change") > -1; + + if (target === canvasElement) { + if (isLockAdd) { + e.stop(); + return; + } + + datas.fromRuler = true; + datas.target = _this.adderElement; // add + } else if (hasClass(target, GUIDE)) { + if (isLockRemove && isLockChange) { + e.stop(); + return; + } + + datas.target = target; // change + } else { + e.stop(); + return false; + } + + _this.onDragStart(e); + }).on("drag", this._onDrag).on("dragEnd", this.onDragEnd); + + if (this.props.useResizeObserver) { + this._observer = new ResizeObserver(this._onCheck); + + this._observer.observe(this.guidesElement, { + box: "border-box" + }); + + this._observer.observe(this.getRulerElement(), { + box: "border-box" + }); + } else { + this._onCheck(); + } + }; + + __proto.componentWillUnmount = function () { + var _a; + + this.gesto.unset(); + (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect(); + }; + + __proto.componentDidUpdate = function (prevProps) { + var nextGuides = this.props.defaultGuides; + + if (prevProps.defaultGuides !== nextGuides) { + // to dynamically update guides from code rather than dragging guidelines + this.setState({ + guides: nextGuides || [] + }); + } + }; + /** + * Load the current guidelines. + * @memberof Guides + * @instance + */ + + + __proto.loadGuides = function (guides) { + this.setState({ + guides: guides + }); + }; + /** + * Get current guidelines. + * @memberof Guides + * @instance + */ + + + __proto.getGuides = function () { + return this.state.guides; + }; + /** + * Scroll the positions of the guidelines opposite the ruler. + * @memberof Guides + * @instance + */ + + + __proto.scrollGuides = function (pos, nextZoom) { + if (nextZoom === void 0) { + nextZoom = this._guidesZoom; + } + + this._setZoom({ + guidesZoom: nextZoom + }); + + var translateName = this.getTranslateName(); + var guidesElement = this.guidesElement; + this.scrollPos = pos; + guidesElement.style.transform = "".concat(translateName, "(").concat(-pos * nextZoom, "px)"); + var guides = this.state.guides; + var guidesOffset = this.props.guidesOffset || 0; + this.guideElements.forEach(function (el, i) { + if (!el) { + return; + } + + var guidePos = guides[i] + (guidesOffset || 0); + el.style.transform = "".concat(translateName, "(").concat(guidePos * nextZoom, "px) translateZ(0px)"); + el.style.display = -pos + guidePos < 0 ? "none" : "block"; + }); + }; + /** + * Set to the next zoom. + * @memberof Guides + * @since 0.22.0 + * @param nextZoom - next zoom + */ + + + __proto.zoomTo = function (nextZoom, nextGuidesZoom) { + if (nextGuidesZoom === void 0) { + nextGuidesZoom = nextZoom; + } + + this.scroll(this.getRulerScrollPos(), nextZoom); + this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom); + }; + /** + * Get Guides DOM Element + * @memberof Guides + * @instance + */ + + + __proto.getElement = function () { + return this.managerRef.current; + }; + /** + * Get Ruler DOM Element + * @memberof Guides + * @instance + */ + + + __proto.getRulerElement = function () { + return this.ruler.canvasElement; + }; + /** + * Scroll position of guides (horizontal: y, vertical: x) + */ + + + __proto.getGuideScrollPos = function () { + return this.scrollPos; + }; + /** + * Scroll position of the ruler (horizontal: x, vertical: y) + */ + + + __proto.getRulerScrollPos = function () { + return this.ruler.getScrollPos(); + }; + /** + * Scroll the position of the ruler. + * @memberof Guides + * @instance + */ + + + __proto.scroll = function (pos, nextZoom) { + if (nextZoom === void 0) { + nextZoom = this._zoom; + } + + this._setZoom({ + zoom: nextZoom + }); + + this.ruler.scroll(pos, nextZoom); + }; + /** + * Recalculate the size of the ruler. + * @memberof Guides + * @instance + */ + + + __proto.resize = function (nextZoom) { + if (nextZoom === void 0) { + nextZoom = this._zoom; + } + + this._setZoom({ + zoom: nextZoom + }); + + this.ruler.resize(nextZoom); + }; + + __proto.movePos = function (e) { + var datas = e.datas, + distX = e.distX, + distY = e.distY; + var props = this.props; + var type = props.type, + snaps = props.snaps, + snapThreshold = props.snapThreshold, + displayDragPos = props.displayDragPos, + digit = props.digit; + var guidesOffset = props.guidesOffset || 0; + var zoom = this._guidesZoom; + + var dragPosFormat = props.dragPosFormat || function (v) { + return v; + }; + + var isHorizontal = type === "horizontal"; + var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]); + var offsetPos = datas.offsetPos; + var offsetX = matrixPos[0] + offsetPos[0]; + var offsetY = matrixPos[1] + offsetPos[1]; + var guidesZoomOffset = guidesOffset * zoom; + var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset; + var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0)); + var guideSnaps = snaps.slice().sort(function (a, b) { + return Math.abs(guidePos - a) - Math.abs(guidePos - b); + }); + + if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) { + guidePos = guideSnaps[0]; + nextPos = guidePos * zoom; + } + + if (!datas.fromRuler || !this._isFirstMove) { + if (displayDragPos) { + var displayPos = type === "horizontal" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY]; + this.displayElement.style.cssText += "display: block;" + "transform: translate(-50%, -50%) " + "translate(".concat(displayPos.map(function (v) { + return "".concat(v, "px"); + }).join(", "), ")"); + this.displayElement.innerHTML = "".concat(dragPosFormat(guidePos)); + } + + var target = datas.target; + target.setAttribute("data-pos", guidePos); + target.style.transform = "".concat(this.getTranslateName(), "(").concat(nextPos + guidesOffset * zoom, "px)"); + } + + return nextPos; + }; + + __proto.getTranslateName = function () { + return this.props.type === "horizontal" ? "translateY" : "translateX"; + }; + + __proto._startDragScroll = function (e) { + var _this = this; + + var scrollOptions = this.props.scrollOptions; + + if (!scrollOptions) { + return; + } + + var datas = e.datas; + var dragScroll = new DragScroll(); + datas.dragScroll = dragScroll; + dragScroll.on("scroll", function (_a) { + var _b, _c; + + var container = _a.container, + direction = _a.direction; + /** + * If scroll can be triggered through drag, the `requestScroll` event is fired. + * @memberof Guides + * @event requestScroll + * @param {OnRequestScroll} - Parameters for the `requestScroll` event + */ + + (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, { + container: container, + direction: direction + }); + }).on("move", function (_a) { + var offsetX = _a.offsetX, + offsetY = _a.offsetY, + inputEvent = _a.inputEvent; + + _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true); + }); + dragScroll.dragStart(e, { + container: scrollOptions.container + }); + }; + + __proto._dragScroll = function (e) { + var scrollOptions = this.props.scrollOptions; + + if (!scrollOptions) { + return; + } + + var dragScroll = e.datas.dragScroll; + dragScroll.drag(e, scrollOptions); + }; + + __proto._endDragScroll = function (e) { + var _a; + + (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd(); + e.datas.dragScroll = null; + }; + + __proto._setZoom = function (zooms) { + var nextZoom = zooms.zoom, + nextGuidesZoom = zooms.guidesZoom; + var hasZoom = !!this.props.zoom; + var hasGuidesZoom = !!this.props.guidesZoom; + + if (hasGuidesZoom) { + if (nextGuidesZoom) { + this._guidesZoom = nextGuidesZoom; + } + } else { + if (nextGuidesZoom) { + this._zoom = nextGuidesZoom; + this._guidesZoom = nextGuidesZoom; + } + + if (nextZoom) { + this._guidesZoom = nextZoom; + } + } + + if (nextZoom) { + this._zoom = nextZoom; + } + }; + + Guides.defaultProps = { + className: "", + type: "horizontal", + zoom: 1, + guidesZoom: 0, + style: {}, + snapThreshold: 5, + snaps: [], + digit: 0, + onClickRuler: function () {}, + onChangeGuides: function () {}, + onRequestScroll: function () {}, + onDragStart: function () {}, + onDrag: function () {}, + onDragEnd: function () {}, + displayDragPos: false, + dragPosFormat: function (v) { + return v; + }, + defaultGuides: [], + lockGuides: false, + showGuides: true, + guideStyle: {}, + dragGuideStyle: {}, + guidePosStyle: {}, + defaultGuidesPos: 0 + }; + return Guides; + }(PureComponent); + + var PROPERTIES$2 = PROPERTIES$1; + var METHODS$1 = METHODS; + var EVENTS$1 = EVENTS; + + var InnerGuides = + /*#__PURE__*/ + function (_super) { + __extends(InnerGuides, _super); + + function InnerGuides(props) { + var _this = _super.call(this, props) || this; + + _this.state = {}; + _this.state = _this.props; + return _this; + } + + var __proto = InnerGuides.prototype; + + __proto.render = function () { + return createElement(Guides, __assign({ + ref: ref(this, "guides") + }, this.state)); + }; + + return InnerGuides; + }(Component); + + var Guides$1 = + /*#__PURE__*/ + function (_super) { + __extends(Guides, _super); + /** + * @sort 1 + * @param - guides' container + * @param {$ts:Partial} - guides' options + */ + + + function Guides(container, options) { + if (options === void 0) { + options = {}; + } + + var _this = _super.call(this) || this; + + _this.containerProvider = null; + _this.selfElement = null; + _this._warp = false; + var events = {}; + EVENTS$1.forEach(function (name) { + events[camelize("on ".concat(name))] = function (e) { + return _this.trigger(name, e); + }; + }); + var selfElement; + + if (options.warpSelf) { + delete options.warpSelf; + _this._warp = true; + selfElement = container; + } else { + selfElement = document.createElement("div"); + container.appendChild(selfElement); + } + + _this.containerProvider = renderSelf(createElement(InnerGuides, __assign({ + ref: ref(_this, "innerGuides") + }, events, options)), selfElement); + return _this; + } + /** + * @param state + * @param callback + */ + + + var __proto = Guides.prototype; + + __proto.setState = function (state, callback) { + this.innerGuides.setState(state, callback); + }; + /** + * @param callback + */ + + + __proto.forceUpdate = function (callback) { + this.innerGuides.forceUpdate(callback); + }; + /** + * destroy guides + */ + + + __proto.destroy = function () { + var _a; + + var selfElement = this.selfElement; + renderSelf(null, selfElement, this.containerProvider); + + if (!this._warp) { + (_a = selfElement === null || selfElement === void 0 ? void 0 : selfElement.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(selfElement); + } + + this.selfElement = null; + this.innerGuides = null; + }; + + __proto.getInnerGuides = function () { + return this.innerGuides.guides; + }; + + Guides = __decorate([Properties(METHODS$1, function (prototype, property) { + if (prototype[property]) { + return; + } + + prototype[property] = function () { + var args = []; + + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + + var self = this.getInnerGuides(); + + if (!self || !self[property]) { + return; + } + + return self[property].apply(self, args); + }; + }), Properties(PROPERTIES$2, function (prototype, property) { + Object.defineProperty(prototype, property, { + get: function () { + return this.getInnerGuides().props[property]; + }, + set: function (value) { + var _a; + + this.innerGuides.setState((_a = {}, _a[property] = value, _a)); + }, + enumerable: true, + configurable: true + }); + }) + /** + * @sort 1 + * @extends EventEmitter + */ + ], Guides); + return Guides; + }(EventEmitter); + + var Guides$2 = + /*#__PURE__*/ + function (_super) { + __extends(Guides, _super); + + function Guides() { + return _super !== null && _super.apply(this, arguments) || this; + } + + return Guides; + }(Guides$1); + + + + var others = { + __proto__: null, + 'default': Guides$2, + PROPERTIES: PROPERTIES$2, + METHODS: METHODS$1, + EVENTS: EVENTS$1 + }; + + for (var name in others) { + Guides$2[name] = others[name]; + } + + return Guides$2; + +}))); +//# sourceMappingURL=guides.js.map diff --git a/release/0.29.2/dist/guides.js.map b/release/0.29.2/dist/guides.js.map new file mode 100644 index 0000000..4146eae --- /dev/null +++ b/release/0.29.2/dist/guides.js.map @@ -0,0 +1 @@ +{"version":3,"file":"guides.js","sources":["../../react-guides/dist/guides.esm.js","../src/consts.ts","../src/InnerGuides.tsx","../src/GuidesManager.tsx","../src/Guides.tsx","../src/index.umd.ts"],"sourcesContent":["/*\nCopyright (c) 2019 Daybrush\nname: @scena/react-guides\nlicense: MIT\nauthor: Daybrush\nrepository: https://github.com/daybrush/guides/blob/master/packages/react-guides\nversion: 0.28.2\n*/\nimport { createElement, createRef, PureComponent } from 'react';\nimport Ruler, { PROPERTIES as PROPERTIES$1 } from '@scena/react-ruler';\nimport { prefixNames, prefixCSS, ref, refs } from 'framework-utils';\nimport DragScroll from '@scena/dragscroll';\nimport Gesto from 'gesto';\nimport { styled } from 'react-css-styled';\nimport { hasClass, addClass, removeClass } from '@daybrush/utils';\nimport { getDistElementMatrix, calculateMatrixDist } from 'css-to-mat';\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n\n/* global Reflect, Promise */\nvar extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf || {\n __proto__: []\n } instanceof Array && function (d, b) {\n d.__proto__ = b;\n } || function (d, b) {\n for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];\n };\n\n return extendStatics(d, b);\n};\n\nfunction __extends(d, b) {\n if (typeof b !== \"function\" && b !== null) throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n\n function __() {\n this.constructor = d;\n }\n\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\nvar __assign = function () {\n __assign = Object.assign || function __assign(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n }\n\n return t;\n };\n\n return __assign.apply(this, arguments);\n};\nfunction __spreadArray(to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nfunction prefix() {\n var classNames = [];\n\n for (var _i = 0; _i < arguments.length; _i++) {\n classNames[_i] = arguments[_i];\n }\n\n return prefixNames.apply(void 0, __spreadArray([\"scena-guides-\"], classNames, false));\n}\n\nvar ADDER = prefix(\"guide\", \"adder\");\nvar GUIDES = prefix(\"guides\");\nvar GUIDE = prefix(\"guide\");\nvar DRAGGING = prefix(\"dragging\");\nvar DISPLAY_DRAG = prefix(\"display-drag\");\nvar GUIDES_CSS = prefixCSS(\"scena-guides-\", \"\\n{\\n position: relative;\\n width: 100%;\\n height: 100%;\\n}\\ncanvas {\\n position: relative;\\n}\\n.guide-origin {\\n position: absolute;\\n width: 1px;\\n height: 1px;\\n top: 0;\\n left: 0;\\n opacity: 0;\\n}\\n.guides {\\n position: absolute;\\n bottom: 0;\\n right: 0;\\n will-change: transform;\\n z-index: 2000;\\n}\\n.guide-pos {\\n position: absolute;\\n font-weight: bold;\\n font-size: 12px;\\n color: #f33;\\n}\\n.horizontal .guide-pos {\\n bottom: 100%;\\n left: 50%;\\n transform: translate(-50%);\\n}\\n.vertical .guide-pos {\\n left: calc(100% + 2px);\\n top: 50%;\\n transform: translateY(-50%);\\n}\\n.display-drag {\\n position: absolute;\\n will-change: transform;\\n z-index: 2000;\\n font-weight: bold;\\n font-size: 12px;\\n display: none;\\n left: 20px;\\n top: -20px;\\n color: #f33;\\n}\\n:host.horizontal .guides {\\n width: 100%;\\n height: 0;\\n}\\n:host.vertical .guides {\\n height: 100%;\\n width: 0;\\n}\\n:host.horizontal canvas {\\n cursor: ns-resize;\\n}\\n:host.vertical canvas {\\n cursor: ew-resize;\\n}\\n.guide {\\n position: absolute;\\n background: #f33;\\n z-index: 2;\\n}\\n.guide.dragging:before {\\n position: absolute;\\n content: \\\"\\\";\\n width: 100%;\\n height: 100%;\\n top: 50%;\\n left: 50%;\\n transform: translate(-50%, -50%);\\n}\\n:host.horizontal .guide {\\n width: 100%;\\n height: 1px;\\n cursor: row-resize;\\n}\\n:host.vertical .guide {\\n width: 1px;\\n height: 100%;\\n cursor: col-resize;\\n}\\n.mobile :host.horizontal .guide {\\n transform: scale(1, 2);\\n}\\n.mobile :host.vertical .guide {\\n transform: scale(2, 1);\\n}\\n:host.horizontal .guide:before {\\n height: 20px;\\n}\\n:host.vertical .guide:before {\\n width: 20px;\\n}\\n.adder {\\n display: none;\\n}\\n.adder.dragging {\\n display: block;\\n}\\n\");\nvar PROPERTIES = __spreadArray([\"className\", \"rulerStyle\", 'snapThreshold', \"snaps\", \"displayDragPos\", \"cspNonce\", 'dragPosFormat', \"defaultGuides\", \"showGuides\", \"scrollOptions\", \"guideStyle\", \"guidesOffset\", \"digit\", \"defaultGuidesPos\", \"dragGuideStyle\", \"displayGuidePos\", \"guidePosFormat\", \"guidePosStyle\", \"lockGuides\", \"guidesZoom\"], PROPERTIES$1, true);\nvar METHODS = [\"getGuides\", \"loadGuides\", \"scroll\", \"scrollGuides\", \"resize\", \"getElement\", \"getRulerElement\", \"forceUpdate\", \"getRulerScrollPos\", \"getGuideScrollPos\", \"zoomTo\", \"drawRuler\"];\nvar EVENTS = [\"changeGuides\", \"requestScroll\", \"dragStart\", \"drag\", \"dragEnd\", \"clickRuler\"];\n\nvar GuidesElement = styled(\"div\", GUIDES_CSS);\n\nvar Guides =\n/*#__PURE__*/\nfunction (_super) {\n __extends(Guides, _super);\n\n function Guides(props) {\n var _this = _super.call(this, props) || this;\n\n _this.state = {\n guides: []\n };\n _this.scrollPos = 0;\n _this.managerRef = createRef();\n _this.guideElements = [];\n _this._isFirstMove = false;\n _this._zoom = 1;\n _this._guidesZoom = 1;\n _this._observer = null;\n\n _this.onDragStart = function (e) {\n var datas = e.datas,\n inputEvent = e.inputEvent;\n _this._isFirstMove = true;\n\n _this.movePos(e);\n /**\n * When the drag starts, the dragStart event is called.\n * @memberof Guides\n * @event dragStart\n * @param {OnDragStart} - Parameters for the dragStart event\n */\n\n\n _this.props.onDragStart(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n return;\n }\n\n inputEvent.stopPropagation();\n inputEvent.preventDefault();\n\n _this._startDragScroll(e);\n };\n\n _this._onDrag = function (e) {\n if (_this._isFirstMove) {\n _this._isFirstMove = false;\n addClass(e.datas.target, DRAGGING);\n }\n\n var nextPos = _this.movePos(e);\n /**\n * When dragging, the drag event is called.\n * @memberof Guides\n * @event drag\n * @param {OnDrag} - Parameters for the drag event\n */\n\n\n _this.props.onDrag(__assign(__assign({}, e), {\n dragElement: e.datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n _this._endDragScroll(e);\n\n return;\n }\n\n _this._dragScroll(e);\n\n return nextPos;\n };\n\n _this.onDragEnd = function (e) {\n var datas = e.datas,\n isDouble = e.isDouble,\n distX = e.distX,\n distY = e.distY;\n\n var pos = _this.movePos(e);\n\n var guides = _this.state.guides;\n var _a = _this.props,\n onChangeGuides = _a.onChangeGuides,\n displayDragPos = _a.displayDragPos,\n digit = _a.digit,\n lockGuides = _a.lockGuides,\n guidesOffset = _a.guidesOffset;\n var zoom = _this._guidesZoom;\n var guidePos = parseFloat((pos / zoom).toFixed(digit || 0));\n var baseScrollPos = _this.scrollPos - (guidesOffset || 0);\n\n if (displayDragPos) {\n _this.displayElement.style.cssText += \"display: none;\";\n }\n\n removeClass(datas.target, DRAGGING);\n /**\n * When the drag finishes, the dragEnd event is called.\n * @memberof Guides\n * @event dragEnd\n * @param {OnDragEnd} - Parameters for the dragEnd event\n */\n\n _this.props.onDragEnd(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n _this._endDragScroll(e);\n\n if (datas.fromRuler) {\n if (_this._isFirstMove) {\n /**\n * When click the ruler, the click ruler is called.\n * @memberof Guides\n * @event clickRuler\n * @param {OnClickRuler} - Parameters for the clickRuler event\n */\n _this.props.onClickRuler(__assign(__assign({}, e), {\n pos: 0\n }));\n }\n\n if (guidePos >= baseScrollPos && guides.indexOf(guidePos) < 0) {\n _this.setState({\n guides: __spreadArray(__spreadArray([], guides, true), [guidePos], false)\n }, function () {\n /**\n * The `changeGuides` event occurs when the guideline is added / removed / changed.\n * @memberof Guides\n * @event changeGuides\n * @param {OnChangeGuides} - Parameters for the changeGuides event\n */\n onChangeGuides({\n guides: _this.state.guides,\n distX: distX,\n distY: distY,\n index: guides.length,\n isAdd: true,\n isRemove: false,\n isChange: false\n });\n });\n }\n } else {\n var index_1 = parseFloat(datas.target.getAttribute(\"data-index\"));\n var isRemove_1 = false;\n var isChange_1 = false;\n guides = __spreadArray([], guides, true);\n var guideIndex = guides.indexOf(guidePos);\n\n if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"remove\") > -1)) {\n return;\n }\n\n guides.splice(index_1, 1);\n isRemove_1 = true;\n } else if (guideIndex > -1) {\n return;\n } else {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"change\") > -1)) {\n return;\n }\n\n guides[index_1] = guidePos;\n isChange_1 = true;\n }\n\n _this.setState({\n guides: guides\n }, function () {\n var nextGuides = _this.state.guides;\n onChangeGuides({\n distX: distX,\n distY: distY,\n guides: nextGuides,\n isAdd: false,\n index: index_1,\n isChange: isChange_1,\n isRemove: isRemove_1\n });\n });\n }\n };\n\n _this._onCheck = function () {\n _this.resize();\n };\n\n _this.state.guides = props.defaultGuides || [];\n _this.scrollPos = props.defaultGuidesPos || 0;\n return _this;\n }\n\n var __proto = Guides.prototype;\n\n __proto.render = function () {\n var _a = this.props,\n className = _a.className,\n type = _a.type,\n zoom = _a.zoom,\n guidesZoom = _a.guidesZoom,\n style = _a.style,\n rulerStyle = _a.rulerStyle,\n displayDragPos = _a.displayDragPos,\n cspNonce = _a.cspNonce,\n dragGuideStyle = _a.dragGuideStyle,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b;\n var props = this.props;\n var translateName = this.getTranslateName();\n var rulerProps = {};\n PROPERTIES$1.forEach(function (name) {\n if (name === \"style\" || name === \"warpSelf\" || name === \"useResizeObserver\") {\n return;\n }\n\n rulerProps[name] = props[name];\n });\n this._zoom = zoom;\n this._guidesZoom = guidesZoom || zoom;\n return createElement(GuidesElement, {\n ref: this.managerRef,\n cspNonce: cspNonce,\n className: \"\".concat(prefix(\"manager\", type), \" \").concat(className),\n style: style\n }, createElement(\"div\", {\n className: prefix(\"guide-origin\"),\n ref: ref(this, \"originElement\")\n }), createElement(Ruler, __assign({\n ref: ref(this, \"ruler\"),\n style: rulerStyle\n }, rulerProps)), createElement(\"div\", {\n className: GUIDES,\n ref: ref(this, \"guidesElement\"),\n style: {\n transform: \"\".concat(translateName, \"(\").concat(-this.scrollPos * this._guidesZoom, \"px)\")\n }\n }, displayDragPos && createElement(\"div\", {\n className: DISPLAY_DRAG,\n ref: ref(this, \"displayElement\"),\n style: guidePosStyle || {}\n }), createElement(\"div\", {\n className: ADDER,\n ref: ref(this, \"adderElement\"),\n style: dragGuideStyle\n }), this.renderGuides()));\n };\n /**\n * Draw ruler\n */\n\n\n __proto.drawRuler = function (options) {\n this.ruler.draw(options);\n };\n\n __proto.renderGuides = function () {\n var _this = this;\n\n var props = this.props;\n var _a = props,\n type = _a.type,\n showGuides = _a.showGuides,\n guideStyle = _a.guideStyle,\n displayGuidePos = _a.displayGuidePos,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b,\n guidesOffset = _a.guidesOffset;\n var zoom = this._guidesZoom;\n var translateName = this.getTranslateName();\n var guides = this.state.guides;\n\n var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) {\n return v;\n };\n\n this.guideElements = [];\n\n if (showGuides) {\n return guides.map(function (pos, i) {\n var guidePos = pos + (guidesOffset || 0);\n return createElement(\"div\", {\n className: prefix(\"guide\", type),\n ref: refs(_this, \"guideElements\", i),\n key: i,\n \"data-index\": i,\n \"data-pos\": pos,\n style: __assign(__assign({}, guideStyle), {\n transform: \"\".concat(translateName, \"(\").concat(guidePos * zoom, \"px) translateZ(0px)\")\n })\n }, displayGuidePos && createElement(\"div\", {\n className: prefix(\"guide-pos\"),\n style: guidePosStyle || {}\n }, guidePosFormat(pos)));\n });\n }\n\n return;\n };\n\n __proto.componentDidMount = function () {\n var _this = this;\n\n this.gesto = new Gesto(this.managerRef.current, {\n container: document.body\n }).on(\"dragStart\", function (e) {\n var _a = _this.props,\n type = _a.type,\n lockGuides = _a.lockGuides;\n var zoom = _this._guidesZoom;\n\n if (lockGuides === true) {\n e.stop();\n return;\n }\n\n var inputEvent = e.inputEvent;\n var target = inputEvent.target;\n var datas = e.datas;\n var canvasElement = _this.ruler.canvasElement;\n var guidesElement = _this.guidesElement;\n var isHorizontal = type === \"horizontal\";\n\n var originRect = _this.originElement.getBoundingClientRect();\n\n var matrix = getDistElementMatrix(_this.managerRef.current);\n var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]);\n offsetPos[0] -= guidesElement.offsetLeft;\n offsetPos[1] -= guidesElement.offsetTop;\n offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom;\n datas.offsetPos = offsetPos;\n datas.matrix = matrix;\n var isLockAdd = lockGuides && lockGuides.indexOf(\"add\") > -1;\n var isLockRemove = lockGuides && lockGuides.indexOf(\"remove\") > -1;\n var isLockChange = lockGuides && lockGuides.indexOf(\"change\") > -1;\n\n if (target === canvasElement) {\n if (isLockAdd) {\n e.stop();\n return;\n }\n\n datas.fromRuler = true;\n datas.target = _this.adderElement; // add\n } else if (hasClass(target, GUIDE)) {\n if (isLockRemove && isLockChange) {\n e.stop();\n return;\n }\n\n datas.target = target; // change\n } else {\n e.stop();\n return false;\n }\n\n _this.onDragStart(e);\n }).on(\"drag\", this._onDrag).on(\"dragEnd\", this.onDragEnd);\n\n if (this.props.useResizeObserver) {\n this._observer = new ResizeObserver(this._onCheck);\n\n this._observer.observe(this.guidesElement, {\n box: \"border-box\"\n });\n\n this._observer.observe(this.getRulerElement(), {\n box: \"border-box\"\n });\n } else {\n this._onCheck();\n }\n };\n\n __proto.componentWillUnmount = function () {\n var _a;\n\n this.gesto.unset();\n (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n };\n\n __proto.componentDidUpdate = function (prevProps) {\n var nextGuides = this.props.defaultGuides;\n\n if (prevProps.defaultGuides !== nextGuides) {\n // to dynamically update guides from code rather than dragging guidelines\n this.setState({\n guides: nextGuides || []\n });\n }\n };\n /**\n * Load the current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.loadGuides = function (guides) {\n this.setState({\n guides: guides\n });\n };\n /**\n * Get current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getGuides = function () {\n return this.state.guides;\n };\n /**\n * Scroll the positions of the guidelines opposite the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scrollGuides = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._guidesZoom;\n }\n\n this._setZoom({\n guidesZoom: nextZoom\n });\n\n var translateName = this.getTranslateName();\n var guidesElement = this.guidesElement;\n this.scrollPos = pos;\n guidesElement.style.transform = \"\".concat(translateName, \"(\").concat(-pos * nextZoom, \"px)\");\n var guides = this.state.guides;\n var guidesOffset = this.props.guidesOffset || 0;\n this.guideElements.forEach(function (el, i) {\n if (!el) {\n return;\n }\n\n var guidePos = guides[i] + (guidesOffset || 0);\n el.style.transform = \"\".concat(translateName, \"(\").concat(guidePos * nextZoom, \"px) translateZ(0px)\");\n el.style.display = -pos + guidePos < 0 ? \"none\" : \"block\";\n });\n };\n /**\n * Set to the next zoom.\n * @memberof Guides\n * @since 0.22.0\n * @param nextZoom - next zoom\n */\n\n\n __proto.zoomTo = function (nextZoom, nextGuidesZoom) {\n if (nextGuidesZoom === void 0) {\n nextGuidesZoom = nextZoom;\n }\n\n this.scroll(this.getRulerScrollPos(), nextZoom);\n this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);\n };\n /**\n * Get Guides DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getElement = function () {\n return this.managerRef.current;\n };\n /**\n * Get Ruler DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getRulerElement = function () {\n return this.ruler.canvasElement;\n };\n /**\n * Scroll position of guides (horizontal: y, vertical: x)\n */\n\n\n __proto.getGuideScrollPos = function () {\n return this.scrollPos;\n };\n /**\n * Scroll position of the ruler (horizontal: x, vertical: y)\n */\n\n\n __proto.getRulerScrollPos = function () {\n return this.ruler.getScrollPos();\n };\n /**\n * Scroll the position of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scroll = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.scroll(pos, nextZoom);\n };\n /**\n * Recalculate the size of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.resize = function (nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.resize(nextZoom);\n };\n\n __proto.movePos = function (e) {\n var datas = e.datas,\n distX = e.distX,\n distY = e.distY;\n var props = this.props;\n var type = props.type,\n snaps = props.snaps,\n snapThreshold = props.snapThreshold,\n displayDragPos = props.displayDragPos,\n digit = props.digit;\n var guidesOffset = props.guidesOffset || 0;\n var zoom = this._guidesZoom;\n\n var dragPosFormat = props.dragPosFormat || function (v) {\n return v;\n };\n\n var isHorizontal = type === \"horizontal\";\n var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);\n var offsetPos = datas.offsetPos;\n var offsetX = matrixPos[0] + offsetPos[0];\n var offsetY = matrixPos[1] + offsetPos[1];\n var guidesZoomOffset = guidesOffset * zoom;\n var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;\n var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0));\n var guideSnaps = snaps.slice().sort(function (a, b) {\n return Math.abs(guidePos - a) - Math.abs(guidePos - b);\n });\n\n if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) {\n guidePos = guideSnaps[0];\n nextPos = guidePos * zoom;\n }\n\n if (!datas.fromRuler || !this._isFirstMove) {\n if (displayDragPos) {\n var displayPos = type === \"horizontal\" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY];\n this.displayElement.style.cssText += \"display: block;\" + \"transform: translate(-50%, -50%) \" + \"translate(\".concat(displayPos.map(function (v) {\n return \"\".concat(v, \"px\");\n }).join(\", \"), \")\");\n this.displayElement.innerHTML = \"\".concat(dragPosFormat(guidePos));\n }\n\n var target = datas.target;\n target.setAttribute(\"data-pos\", guidePos);\n target.style.transform = \"\".concat(this.getTranslateName(), \"(\").concat(nextPos + guidesOffset * zoom, \"px)\");\n }\n\n return nextPos;\n };\n\n __proto.getTranslateName = function () {\n return this.props.type === \"horizontal\" ? \"translateY\" : \"translateX\";\n };\n\n __proto._startDragScroll = function (e) {\n var _this = this;\n\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var datas = e.datas;\n var dragScroll = new DragScroll();\n datas.dragScroll = dragScroll;\n dragScroll.on(\"scroll\", function (_a) {\n var _b, _c;\n\n var container = _a.container,\n direction = _a.direction;\n /**\n * If scroll can be triggered through drag, the `requestScroll` event is fired.\n * @memberof Guides\n * @event requestScroll\n * @param {OnRequestScroll} - Parameters for the `requestScroll` event\n */\n\n (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, {\n container: container,\n direction: direction\n });\n }).on(\"move\", function (_a) {\n var offsetX = _a.offsetX,\n offsetY = _a.offsetY,\n inputEvent = _a.inputEvent;\n\n _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);\n });\n dragScroll.dragStart(e, {\n container: scrollOptions.container\n });\n };\n\n __proto._dragScroll = function (e) {\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var dragScroll = e.datas.dragScroll;\n dragScroll.drag(e, scrollOptions);\n };\n\n __proto._endDragScroll = function (e) {\n var _a;\n\n (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd();\n e.datas.dragScroll = null;\n };\n\n __proto._setZoom = function (zooms) {\n var nextZoom = zooms.zoom,\n nextGuidesZoom = zooms.guidesZoom;\n var hasZoom = !!this.props.zoom;\n var hasGuidesZoom = !!this.props.guidesZoom;\n\n if (hasGuidesZoom) {\n if (nextGuidesZoom) {\n this._guidesZoom = nextGuidesZoom;\n }\n } else {\n if (nextGuidesZoom) {\n this._zoom = nextGuidesZoom;\n this._guidesZoom = nextGuidesZoom;\n }\n\n if (nextZoom) {\n this._guidesZoom = nextZoom;\n }\n }\n\n if (nextZoom) {\n this._zoom = nextZoom;\n }\n };\n\n Guides.defaultProps = {\n className: \"\",\n type: \"horizontal\",\n zoom: 1,\n guidesZoom: 0,\n style: {},\n snapThreshold: 5,\n snaps: [],\n digit: 0,\n onClickRuler: function () {},\n onChangeGuides: function () {},\n onRequestScroll: function () {},\n onDragStart: function () {},\n onDrag: function () {},\n onDragEnd: function () {},\n displayDragPos: false,\n dragPosFormat: function (v) {\n return v;\n },\n defaultGuides: [],\n lockGuides: false,\n showGuides: true,\n guideStyle: {},\n dragGuideStyle: {},\n guidePosStyle: {},\n defaultGuidesPos: 0\n };\n return Guides;\n}(PureComponent);\n\nexport default Guides;\nexport { EVENTS, METHODS, PROPERTIES };\n//# sourceMappingURL=guides.esm.js.map\n","import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\n\nexport default Guides;\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","__spreadArray","to","from","pack","l","ar","slice","concat","prefix","classNames","_i","prefixNames","ADDER","GUIDES","GUIDE","DRAGGING","DISPLAY_DRAG","GUIDES_CSS","prefixCSS","PROPERTIES","PROPERTIES$1","METHODS","EVENTS","GuidesElement","styled","Guides","_super","props","_this","state","guides","scrollPos","managerRef","createRef","guideElements","_isFirstMove","_zoom","_guidesZoom","_observer","onDragStart","e","datas","inputEvent","movePos","dragElement","target","gesto","isFlag","stopPropagation","preventDefault","_startDragScroll","_onDrag","addClass","nextPos","onDrag","_endDragScroll","_dragScroll","onDragEnd","isDouble","distX","distY","pos","_a","onChangeGuides","displayDragPos","digit","lockGuides","guidesOffset","zoom","guidePos","parseFloat","toFixed","baseScrollPos","displayElement","style","cssText","removeClass","fromRuler","onClickRuler","indexOf","setState","index","isAdd","isRemove","isChange","index_1","getAttribute","isRemove_1","isChange_1","guideIndex","splice","nextGuides","_onCheck","resize","defaultGuides","defaultGuidesPos","__proto","render","className","type","guidesZoom","rulerStyle","cspNonce","dragGuideStyle","_b","guidePosStyle","translateName","getTranslateName","rulerProps","forEach","name","createElement","ref","Ruler","transform","renderGuides","drawRuler","options","ruler","draw","showGuides","guideStyle","displayGuidePos","guidePosFormat","dragPosFormat","v","map","refs","key","componentDidMount","Gesto","current","container","document","body","on","stop","canvasElement","guidesElement","isHorizontal","originRect","originElement","getBoundingClientRect","matrix","getDistElementMatrix","offsetPos","calculateMatrixDist","clientX","left","clientY","top","offsetLeft","offsetTop","isLockAdd","isLockRemove","isLockChange","adderElement","hasClass","useResizeObserver","ResizeObserver","observe","box","getRulerElement","componentWillUnmount","unset","disconnect","componentDidUpdate","prevProps","loadGuides","getGuides","scrollGuides","nextZoom","_setZoom","el","display","zoomTo","nextGuidesZoom","scroll","getRulerScrollPos","getGuideScrollPos","getElement","getScrollPos","snaps","snapThreshold","matrixPos","offsetX","offsetY","guidesZoomOffset","Math","round","guideSnaps","sort","a","abs","displayPos","join","innerHTML","setAttribute","scrollOptions","dragScroll","DragScroll","_c","direction","onRequestScroll","scrollBy","dragStart","drag","dragEnd","zooms","hasZoom","hasGuidesZoom","defaultProps","PureComponent","GUIDES_PROPERTIES","GUIDES_METHODS","GUIDES_EVENTS","React","ReactGuides","events","camelize","trigger","selfElement","warpSelf","_warp","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","forceUpdate","parentElement","removeChild","Properties","property","args","self","getInnerGuides","defineProperty","get","set","value","enumerable","configurable","EventEmitter","GuidesManager","others"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;AACA,IASA;IACA;AACA;IACA;IACA;AACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;IAEA;;IACA,IAAIA,eAAa,GAAG,UAAUC,CAAV,EAAaC,CAAb,EAAgB;MAClCF,eAAa,GAAGG,MAAM,CAACC,cAAP,IAAyB;QACvCC,SAAS,EAAE;mBACAC,KAF4B,IAEnB,UAAUL,CAAV,EAAaC,CAAb,EAAgB;QACpCD,CAAC,CAACI,SAAF,GAAcH,CAAd;OAHc,IAIX,UAAUD,CAAV,EAAaC,CAAb,EAAgB;QACnB,KAAK,IAAIK,CAAT,IAAcL,CAAd,EAAiB,IAAIC,MAAM,CAACK,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqCR,CAArC,EAAwCK,CAAxC,CAAJ,EAAgDN,CAAC,CAACM,CAAD,CAAD,GAAOL,CAAC,CAACK,CAAD,CAAR;OALnE;;MAQA,OAAOP,eAAa,CAACC,CAAD,EAAIC,CAAJ,CAApB;IACD,CAVD;;IAYA,SAASS,WAAT,CAAmBV,CAAnB,EAAsBC,CAAtB,EAAyB;MACvB,IAAI,OAAOA,CAAP,KAAa,UAAb,IAA2BA,CAAC,KAAK,IAArC,EAA2C,MAAM,IAAIU,SAAJ,CAAc,yBAAyBC,MAAM,CAACX,CAAD,CAA/B,GAAqC,+BAAnD,CAAN;MAC3CF,eAAa,CAACC,CAAD,EAAIC,CAAJ,CAAb;;MAEA,SAASY,EAAT,GAAc;QACZ,KAAKC,WAAL,GAAmBd,CAAnB;;;MAGFA,CAAC,CAACO,SAAF,GAAcN,CAAC,KAAK,IAAN,GAAaC,MAAM,CAACa,MAAP,CAAcd,CAAd,CAAb,IAAiCY,EAAE,CAACN,SAAH,GAAeN,CAAC,CAACM,SAAjB,EAA4B,IAAIM,EAAJ,EAA7D,CAAd;IACD;;IACD,IAAIG,UAAQ,GAAG,YAAY;MACzBA,UAAQ,GAAGd,MAAM,CAACe,MAAP,IAAiB,SAASD,QAAT,CAAkBE,CAAlB,EAAqB;QAC/C,KAAK,IAAIC,CAAJ,EAAOC,CAAC,GAAG,CAAX,EAAcC,CAAC,GAAGC,SAAS,CAACC,MAAjC,EAAyCH,CAAC,GAAGC,CAA7C,EAAgDD,CAAC,EAAjD,EAAqD;UACnDD,CAAC,GAAGG,SAAS,CAACF,CAAD,CAAb;;UAEA,KAAK,IAAId,CAAT,IAAca,CAAd,EAAiB,IAAIjB,MAAM,CAACK,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqCU,CAArC,EAAwCb,CAAxC,CAAJ,EAAgDY,CAAC,CAACZ,CAAD,CAAD,GAAOa,CAAC,CAACb,CAAD,CAAR;;;QAGnE,OAAOY,CAAP;OAPF;;MAUA,OAAOF,UAAQ,CAACQ,KAAT,CAAe,IAAf,EAAqBF,SAArB,CAAP;IACD,CAZD;;IAaA,SAASG,eAAT,CAAuBC,EAAvB,EAA2BC,IAA3B,EAAiCC,IAAjC,EAAuC;MACrC,IAAIA,IAAI,IAAIN,SAAS,CAACC,MAAV,KAAqB,CAAjC,EAAoC,KAAK,IAAIH,CAAC,GAAG,CAAR,EAAWS,CAAC,GAAGF,IAAI,CAACJ,MAApB,EAA4BO,EAAjC,EAAqCV,CAAC,GAAGS,CAAzC,EAA4CT,CAAC,EAA7C,EAAiD;QACnF,IAAIU,EAAE,IAAI,EAAEV,CAAC,IAAIO,IAAP,CAAV,EAAwB;UACtB,IAAI,CAACG,EAAL,EAASA,EAAE,GAAGzB,KAAK,CAACE,SAAN,CAAgBwB,KAAhB,CAAsBtB,IAAtB,CAA2BkB,IAA3B,EAAiC,CAAjC,EAAoCP,CAApC,CAAL;UACTU,EAAE,CAACV,CAAD,CAAF,GAAQO,IAAI,CAACP,CAAD,CAAZ;;;MAGJ,OAAOM,EAAE,CAACM,MAAH,CAAUF,EAAE,IAAIzB,KAAK,CAACE,SAAN,CAAgBwB,KAAhB,CAAsBtB,IAAtB,CAA2BkB,IAA3B,CAAhB,CAAP;IACD;;IAED,SAASM,MAAT,GAAkB;MAChB,IAAIC,UAAU,GAAG,EAAjB;;MAEA,KAAK,IAAIC,EAAE,GAAG,CAAd,EAAiBA,EAAE,GAAGb,SAAS,CAACC,MAAhC,EAAwCY,EAAE,EAA1C,EAA8C;QAC5CD,UAAU,CAACC,EAAD,CAAV,GAAiBb,SAAS,CAACa,EAAD,CAA1B;;;MAGF,OAAOC,WAAW,CAACZ,KAAZ,CAAkB,KAAK,CAAvB,EAA0BC,eAAa,CAAC,CAAC,eAAD,CAAD,EAAoBS,UAApB,EAAgC,KAAhC,CAAvC,CAAP;IACD;;IAED,IAAIG,KAAK,GAAGJ,MAAM,CAAC,OAAD,EAAU,OAAV,CAAlB;IACA,IAAIK,MAAM,GAAGL,MAAM,CAAC,QAAD,CAAnB;IACA,IAAIM,KAAK,GAAGN,MAAM,CAAC,OAAD,CAAlB;IACA,IAAIO,QAAQ,GAAGP,MAAM,CAAC,UAAD,CAArB;IACA,IAAIQ,YAAY,GAAGR,MAAM,CAAC,cAAD,CAAzB;IACA,IAAIS,UAAU,GAAGC,SAAS,CAAC,eAAD,EAAkB,u0DAAlB,CAA1B;;IACA,IAAIC,YAAU,GAAGnB,eAAa,CAAC,CAAC,WAAD,EAAc,YAAd,EAA4B,eAA5B,EAA6C,OAA7C,EAAsD,gBAAtD,EAAwE,UAAxE,EAAoF,eAApF,EAAqG,eAArG,EAAsH,YAAtH,EAAoI,eAApI,EAAqJ,YAArJ,EAAmK,cAAnK,EAAmL,OAAnL,EAA4L,kBAA5L,EAAgN,gBAAhN,EAAkO,iBAAlO,EAAqP,gBAArP,EAAuQ,eAAvQ,EAAwR,YAAxR,EAAsS,YAAtS,CAAD,EAAsToB,UAAtT,EAAoU,IAApU,CAA9B;;IACA,IAAIC,OAAO,GAAG,CAAC,WAAD,EAAc,YAAd,EAA4B,QAA5B,EAAsC,cAAtC,EAAsD,QAAtD,EAAgE,YAAhE,EAA8E,iBAA9E,EAAiG,aAAjG,EAAgH,mBAAhH,EAAqI,mBAArI,EAA0J,QAA1J,EAAoK,WAApK,CAAd;IACA,IAAIC,MAAM,GAAG,CAAC,cAAD,EAAiB,eAAjB,EAAkC,WAAlC,EAA+C,MAA/C,EAAuD,SAAvD,EAAkE,YAAlE,CAAb;IAEA,IAAIC,aAAa,GAAGC,QAAM,CAAC,KAAD,EAAQP,UAAR,CAA1B;;IAEA,IAAIQ,MAAM,gBAEV,UAAUC,MAAV,EAAkB;MAChBzC,WAAS,CAACwC,MAAD,EAASC,MAAT,CAAT;;MAEA,SAASD,MAAT,CAAgBE,KAAhB,EAAuB;QACrB,IAAIC,KAAK,GAAGF,MAAM,CAAC1C,IAAP,CAAY,IAAZ,EAAkB2C,KAAlB,KAA4B,IAAxC;;QAEAC,KAAK,CAACC,KAAN,GAAc;UACZC,MAAM,EAAE;SADV;QAGAF,KAAK,CAACG,SAAN,GAAkB,CAAlB;QACAH,KAAK,CAACI,UAAN,GAAmBC,SAAS,EAA5B;QACAL,KAAK,CAACM,aAAN,GAAsB,EAAtB;QACAN,KAAK,CAACO,YAAN,GAAqB,KAArB;QACAP,KAAK,CAACQ,KAAN,GAAc,CAAd;QACAR,KAAK,CAACS,WAAN,GAAoB,CAApB;QACAT,KAAK,CAACU,SAAN,GAAkB,IAAlB;;QAEAV,KAAK,CAACW,WAAN,GAAoB,UAAUC,CAAV,EAAa;UAC/B,IAAIC,KAAK,GAAGD,CAAC,CAACC,KAAd;cACIC,UAAU,GAAGF,CAAC,CAACE,UADnB;UAEAd,KAAK,CAACO,YAAN,GAAqB,IAArB;;UAEAP,KAAK,CAACe,OAAN,CAAcH,CAAd;;IAEN;IACA;IACA;IACA;IACA;;;UAGMZ,KAAK,CAACD,KAAN,CAAYY,WAAZ,CAAwBhD,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;YAChDI,WAAW,EAAEH,KAAK,CAACI;WADW,CAAhC;;UAIA,IAAI,CAACjB,KAAK,CAACkB,KAAN,CAAYC,MAAZ,EAAL,EAA2B;YACzB;;;UAGFL,UAAU,CAACM,eAAX;UACAN,UAAU,CAACO,cAAX;;UAEArB,KAAK,CAACsB,gBAAN,CAAuBV,CAAvB;SAzBF;;QA4BAZ,KAAK,CAACuB,OAAN,GAAgB,UAAUX,CAAV,EAAa;UAC3B,IAAIZ,KAAK,CAACO,YAAV,EAAwB;YACtBP,KAAK,CAACO,YAAN,GAAqB,KAArB;YACAiB,QAAQ,CAACZ,CAAC,CAACC,KAAF,CAAQI,MAAT,EAAiB9B,QAAjB,CAAR;;;UAGF,IAAIsC,OAAO,GAAGzB,KAAK,CAACe,OAAN,CAAcH,CAAd,CAAd;;IAEN;IACA;IACA;IACA;IACA;;;UAGMZ,KAAK,CAACD,KAAN,CAAY2B,MAAZ,CAAmB/D,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;YAC3CI,WAAW,EAAEJ,CAAC,CAACC,KAAF,CAAQI;WADI,CAA3B;;UAIA,IAAI,CAACjB,KAAK,CAACkB,KAAN,CAAYC,MAAZ,EAAL,EAA2B;YACzBnB,KAAK,CAAC2B,cAAN,CAAqBf,CAArB;;YAEA;;;UAGFZ,KAAK,CAAC4B,WAAN,CAAkBhB,CAAlB;;UAEA,OAAOa,OAAP;SA3BF;;QA8BAzB,KAAK,CAAC6B,SAAN,GAAkB,UAAUjB,CAAV,EAAa;UAC7B,IAAIC,KAAK,GAAGD,CAAC,CAACC,KAAd;cACIiB,QAAQ,GAAGlB,CAAC,CAACkB,QADjB;cAEIC,KAAK,GAAGnB,CAAC,CAACmB,KAFd;cAGIC,KAAK,GAAGpB,CAAC,CAACoB,KAHd;;UAKA,IAAIC,GAAG,GAAGjC,KAAK,CAACe,OAAN,CAAcH,CAAd,CAAV;;UAEA,IAAIV,MAAM,GAAGF,KAAK,CAACC,KAAN,CAAYC,MAAzB;UACA,IAAIgC,EAAE,GAAGlC,KAAK,CAACD,KAAf;cACIoC,cAAc,GAAGD,EAAE,CAACC,cADxB;cAEIC,cAAc,GAAGF,EAAE,CAACE,cAFxB;cAGIC,KAAK,GAAGH,EAAE,CAACG,KAHf;cAIIC,UAAU,GAAGJ,EAAE,CAACI,UAJpB;cAKIC,YAAY,GAAGL,EAAE,CAACK,YALtB;UAMA,IAAIC,IAAI,GAAGxC,KAAK,CAACS,WAAjB;UACA,IAAIgC,QAAQ,GAAGC,UAAU,CAAC,CAACT,GAAG,GAAGO,IAAP,EAAaG,OAAb,CAAqBN,KAAK,IAAI,CAA9B,CAAD,CAAzB;UACA,IAAIO,aAAa,GAAG5C,KAAK,CAACG,SAAN,IAAmBoC,YAAY,IAAI,CAAnC,CAApB;;UAEA,IAAIH,cAAJ,EAAoB;YAClBpC,KAAK,CAAC6C,cAAN,CAAqBC,KAArB,CAA2BC,OAA3B,IAAsC,gBAAtC;;;UAGFC,WAAW,CAACnC,KAAK,CAACI,MAAP,EAAe9B,QAAf,CAAX;;IAEN;IACA;IACA;IACA;IACA;;UAEMa,KAAK,CAACD,KAAN,CAAY8B,SAAZ,CAAsBlE,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;YAC9CI,WAAW,EAAEH,KAAK,CAACI;WADS,CAA9B;;UAIAjB,KAAK,CAAC2B,cAAN,CAAqBf,CAArB;;UAEA,IAAIC,KAAK,CAACoC,SAAV,EAAqB;YACnB,IAAIjD,KAAK,CAACO,YAAV,EAAwB;;IAEhC;IACA;IACA;IACA;IACA;cACUP,KAAK,CAACD,KAAN,CAAYmD,YAAZ,CAAyBvF,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;gBACjDqB,GAAG,EAAE;eAD0B,CAAjC;;;YAKF,IAAIQ,QAAQ,IAAIG,aAAZ,IAA6B1C,MAAM,CAACiD,OAAP,CAAeV,QAAf,IAA2B,CAA5D,EAA+D;cAC7DzC,KAAK,CAACoD,QAAN,CAAe;gBACblD,MAAM,EAAE9B,eAAa,CAACA,eAAa,CAAC,EAAD,EAAK8B,MAAL,EAAa,IAAb,CAAd,EAAkC,CAACuC,QAAD,CAAlC,EAA8C,KAA9C;eADvB,EAEG,YAAY;;IAEzB;IACA;IACA;IACA;IACA;gBACYN,cAAc,CAAC;kBACbjC,MAAM,EAAEF,KAAK,CAACC,KAAN,CAAYC,MADP;kBAEb6B,KAAK,EAAEA,KAFM;kBAGbC,KAAK,EAAEA,KAHM;kBAIbqB,KAAK,EAAEnD,MAAM,CAAChC,MAJD;kBAKboF,KAAK,EAAE,IALM;kBAMbC,QAAQ,EAAE,KANG;kBAObC,QAAQ,EAAE;iBAPE,CAAd;eATF;;WAdJ,MAkCO;YACL,IAAIC,OAAO,GAAGf,UAAU,CAAC7B,KAAK,CAACI,MAAN,CAAayC,YAAb,CAA0B,YAA1B,CAAD,CAAxB;YACA,IAAIC,UAAU,GAAG,KAAjB;YACA,IAAIC,UAAU,GAAG,KAAjB;YACA1D,MAAM,GAAG9B,eAAa,CAAC,EAAD,EAAK8B,MAAL,EAAa,IAAb,CAAtB;YACA,IAAI2D,UAAU,GAAG3D,MAAM,CAACiD,OAAP,CAAeV,QAAf,CAAjB;;YAEA,IAAIX,QAAQ,IAAIW,QAAQ,GAAGG,aAAvB,IAAwCiB,UAAU,GAAG,CAAC,CAAd,IAAmBA,UAAU,KAAKJ,OAA9E,EAAuF;cACrF,IAAInB,UAAU,KAAKA,UAAU,KAAK,IAAf,IAAuBA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAA5D,CAAd,EAA8E;gBAC5E;;;cAGFjD,MAAM,CAAC4D,MAAP,CAAcL,OAAd,EAAuB,CAAvB;cACAE,UAAU,GAAG,IAAb;aANF,MAOO,IAAIE,UAAU,GAAG,CAAC,CAAlB,EAAqB;cAC1B;aADK,MAEA;cACL,IAAIvB,UAAU,KAAKA,UAAU,KAAK,IAAf,IAAuBA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAA5D,CAAd,EAA8E;gBAC5E;;;cAGFjD,MAAM,CAACuD,OAAD,CAAN,GAAkBhB,QAAlB;cACAmB,UAAU,GAAG,IAAb;;;YAGF5D,KAAK,CAACoD,QAAN,CAAe;cACblD,MAAM,EAAEA;aADV,EAEG,YAAY;cACb,IAAI6D,UAAU,GAAG/D,KAAK,CAACC,KAAN,CAAYC,MAA7B;cACAiC,cAAc,CAAC;gBACbJ,KAAK,EAAEA,KADM;gBAEbC,KAAK,EAAEA,KAFM;gBAGb9B,MAAM,EAAE6D,UAHK;gBAIbT,KAAK,EAAE,KAJM;gBAKbD,KAAK,EAAEI,OALM;gBAMbD,QAAQ,EAAEI,UANG;gBAObL,QAAQ,EAAEI;eAPE,CAAd;aAJF;;SAhGJ;;QAiHA3D,KAAK,CAACgE,QAAN,GAAiB,YAAY;UAC3BhE,KAAK,CAACiE,MAAN;SADF;;QAIAjE,KAAK,CAACC,KAAN,CAAYC,MAAZ,GAAqBH,KAAK,CAACmE,aAAN,IAAuB,EAA5C;QACAlE,KAAK,CAACG,SAAN,GAAkBJ,KAAK,CAACoE,gBAAN,IAA0B,CAA5C;QACA,OAAOnE,KAAP;;;MAGF,IAAIoE,OAAO,GAAGvE,MAAM,CAAC3C,SAArB;;MAEAkH,OAAO,CAACC,MAAR,GAAiB,YAAY;QAC3B,IAAInC,EAAE,GAAG,KAAKnC,KAAd;YACIuE,SAAS,GAAGpC,EAAE,CAACoC,SADnB;YAEIC,IAAI,GAAGrC,EAAE,CAACqC,IAFd;YAGI/B,IAAI,GAAGN,EAAE,CAACM,IAHd;YAIIgC,UAAU,GAAGtC,EAAE,CAACsC,UAJpB;YAKI1B,KAAK,GAAGZ,EAAE,CAACY,KALf;YAMI2B,UAAU,GAAGvC,EAAE,CAACuC,UANpB;YAOIrC,cAAc,GAAGF,EAAE,CAACE,cAPxB;YAQIsC,QAAQ,GAAGxC,EAAE,CAACwC,QARlB;YASIC,cAAc,GAAGzC,EAAE,CAACyC,cATxB;YAUIC,EAAE,GAAG1C,EAAE,CAAC2C,aAVZ;YAWIA,aAAa,GAAGD,EAAE,KAAK,KAAK,CAAZ,GAAgB,EAAhB,GAAqBA,EAXzC;QAYA,IAAI7E,KAAK,GAAG,KAAKA,KAAjB;QACA,IAAI+E,aAAa,GAAG,KAAKC,gBAAL,EAApB;QACA,IAAIC,UAAU,GAAG,EAAjB;QACAxF,UAAY,CAACyF,OAAb,CAAqB,UAAUC,IAAV,EAAgB;UACnC,IAAIA,IAAI,KAAK,OAAT,IAAoBA,IAAI,KAAK,UAA7B,IAA2CA,IAAI,KAAK,mBAAxD,EAA6E;YAC3E;;;UAGFF,UAAU,CAACE,IAAD,CAAV,GAAmBnF,KAAK,CAACmF,IAAD,CAAxB;SALF;QAOA,KAAK1E,KAAL,GAAagC,IAAb;QACA,KAAK/B,WAAL,GAAmB+D,UAAU,IAAIhC,IAAjC;QACA,OAAO2C,aAAa,CAACxF,aAAD,EAAgB;UAClCyF,GAAG,EAAE,KAAKhF,UADwB;UAElCsE,QAAQ,EAAEA,QAFwB;UAGlCJ,SAAS,EAAE,GAAG3F,MAAH,CAAUC,MAAM,CAAC,SAAD,EAAY2F,IAAZ,CAAhB,EAAmC,GAAnC,EAAwC5F,MAAxC,CAA+C2F,SAA/C,CAHuB;UAIlCxB,KAAK,EAAEA;SAJW,EAKjBqC,aAAa,CAAC,KAAD,EAAQ;UACtBb,SAAS,EAAE1F,MAAM,CAAC,cAAD,CADK;UAEtBwG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,eAAP;SAFM,CALI,EAQhBD,aAAa,CAACE,KAAD,EAAQ1H,UAAQ,CAAC;UAChCyH,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,OAAP,CADwB;UAEhCtC,KAAK,EAAE2B;SAFwB,EAG9BO,UAH8B,CAAhB,CARG,EAWHG,aAAa,CAAC,KAAD,EAAQ;UACpCb,SAAS,EAAErF,MADyB;UAEpCmG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,eAAP,CAF4B;UAGpCtC,KAAK,EAAE;YACLwC,SAAS,EAAE,GAAG3G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC,CAAC,KAAKwB,SAAN,GAAkB,KAAKM,WAA5D,EAAyE,KAAzE;;SAJe,EAM3B2B,cAAc,IAAI+C,aAAa,CAAC,KAAD,EAAQ;UACxCb,SAAS,EAAElF,YAD6B;UAExCgG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,gBAAP,CAFgC;UAGxCtC,KAAK,EAAE+B,aAAa,IAAI;SAHQ,CANJ,EAU1BM,aAAa,CAAC,KAAD,EAAQ;UACvBb,SAAS,EAAEtF,KADY;UAEvBoG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,cAAP,CAFe;UAGvBtC,KAAK,EAAE6B;SAHQ,CAVa,EAc1B,KAAKY,YAAL,EAd0B,CAXV,CAApB;OAzBF;;IAqDF;IACA;;;MAGEnB,OAAO,CAACoB,SAAR,GAAoB,UAAUC,OAAV,EAAmB;QACrC,KAAKC,KAAL,CAAWC,IAAX,CAAgBF,OAAhB;OADF;;MAIArB,OAAO,CAACmB,YAAR,GAAuB,YAAY;QACjC,IAAIvF,KAAK,GAAG,IAAZ;;QAEA,IAAID,KAAK,GAAG,KAAKA,KAAjB;QACA,IAAImC,EAAE,GAAGnC,KAAT;YACIwE,IAAI,GAAGrC,EAAE,CAACqC,IADd;YAEIqB,UAAU,GAAG1D,EAAE,CAAC0D,UAFpB;YAGIC,UAAU,GAAG3D,EAAE,CAAC2D,UAHpB;YAIIC,eAAe,GAAG5D,EAAE,CAAC4D,eAJzB;YAKIlB,EAAE,GAAG1C,EAAE,CAAC2C,aALZ;YAMIA,aAAa,GAAGD,EAAE,KAAK,KAAK,CAAZ,GAAgB,EAAhB,GAAqBA,EANzC;YAOIrC,YAAY,GAAGL,EAAE,CAACK,YAPtB;QAQA,IAAIC,IAAI,GAAG,KAAK/B,WAAhB;QACA,IAAIqE,aAAa,GAAG,KAAKC,gBAAL,EAApB;QACA,IAAI7E,MAAM,GAAG,KAAKD,KAAL,CAAWC,MAAxB;;QAEA,IAAI6F,cAAc,GAAGhG,KAAK,CAACgG,cAAN,IAAwBhG,KAAK,CAACiG,aAA9B,IAA+C,UAAUC,CAAV,EAAa;UAC/E,OAAOA,CAAP;SADF;;QAIA,KAAK3F,aAAL,GAAqB,EAArB;;QAEA,IAAIsF,UAAJ,EAAgB;UACd,OAAO1F,MAAM,CAACgG,GAAP,CAAW,UAAUjE,GAAV,EAAelE,CAAf,EAAkB;YAClC,IAAI0E,QAAQ,GAAGR,GAAG,IAAIM,YAAY,IAAI,CAApB,CAAlB;YACA,OAAO4C,aAAa,CAAC,KAAD,EAAQ;cAC1Bb,SAAS,EAAE1F,MAAM,CAAC,OAAD,EAAU2F,IAAV,CADS;cAE1Ba,GAAG,EAAEe,IAAI,CAACnG,KAAD,EAAQ,eAAR,EAAyBjC,CAAzB,CAFiB;cAG1BqI,GAAG,EAAErI,CAHqB;cAI1B,cAAcA,CAJY;cAK1B,YAAYkE,GALc;cAM1Ba,KAAK,EAAEnF,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKkI,UAAL,CAAT,EAA2B;gBACxCP,SAAS,EAAE,GAAG3G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC8D,QAAQ,GAAGD,IAAhD,EAAsD,qBAAtD;eADE;aANG,EASjBsD,eAAe,IAAIX,aAAa,CAAC,KAAD,EAAQ;cACzCb,SAAS,EAAE1F,MAAM,CAAC,WAAD,CADwB;cAEzCkE,KAAK,EAAE+B,aAAa,IAAI;aAFS,EAGhCkB,cAAc,CAAC9D,GAAD,CAHkB,CATf,CAApB;WAFK,CAAP;;;QAkBF;OAzCF;;MA4CAmC,OAAO,CAACiC,iBAAR,GAA4B,YAAY;QACtC,IAAIrG,KAAK,GAAG,IAAZ;;QAEA,KAAKkB,KAAL,GAAa,IAAIoF,KAAJ,CAAU,KAAKlG,UAAL,CAAgBmG,OAA1B,EAAmC;UAC9CC,SAAS,EAAEC,QAAQ,CAACC;SADT,EAEVC,EAFU,CAEP,WAFO,EAEM,UAAU/F,CAAV,EAAa;UAC9B,IAAIsB,EAAE,GAAGlC,KAAK,CAACD,KAAf;cACIwE,IAAI,GAAGrC,EAAE,CAACqC,IADd;cAEIjC,UAAU,GAAGJ,EAAE,CAACI,UAFpB;UAGA,IAAIE,IAAI,GAAGxC,KAAK,CAACS,WAAjB;;UAEA,IAAI6B,UAAU,KAAK,IAAnB,EAAyB;YACvB1B,CAAC,CAACgG,IAAF;YACA;;;UAGF,IAAI9F,UAAU,GAAGF,CAAC,CAACE,UAAnB;UACA,IAAIG,MAAM,GAAGH,UAAU,CAACG,MAAxB;UACA,IAAIJ,KAAK,GAAGD,CAAC,CAACC,KAAd;UACA,IAAIgG,aAAa,GAAG7G,KAAK,CAAC0F,KAAN,CAAYmB,aAAhC;UACA,IAAIC,aAAa,GAAG9G,KAAK,CAAC8G,aAA1B;UACA,IAAIC,YAAY,GAAGxC,IAAI,KAAK,YAA5B;;UAEA,IAAIyC,UAAU,GAAGhH,KAAK,CAACiH,aAAN,CAAoBC,qBAApB,EAAjB;;UAEA,IAAIC,MAAM,GAAGC,oBAAoB,CAACpH,KAAK,CAACI,UAAN,CAAiBmG,OAAlB,CAAjC;UACA,IAAIc,SAAS,GAAGC,mBAAmB,CAACH,MAAD,EAAS,CAACvG,CAAC,CAAC2G,OAAF,GAAYP,UAAU,CAACQ,IAAxB,EAA8B5G,CAAC,CAAC6G,OAAF,GAAYT,UAAU,CAACU,GAArD,CAAT,CAAnC;UACAL,SAAS,CAAC,CAAD,CAAT,IAAgBP,aAAa,CAACa,UAA9B;UACAN,SAAS,CAAC,CAAD,CAAT,IAAgBP,aAAa,CAACc,SAA9B;UACAP,SAAS,CAACN,YAAY,GAAG,CAAH,GAAO,CAApB,CAAT,IAAmC/G,KAAK,CAACG,SAAN,GAAkBqC,IAArD;UACA3B,KAAK,CAACwG,SAAN,GAAkBA,SAAlB;UACAxG,KAAK,CAACsG,MAAN,GAAeA,MAAf;UACA,IAAIU,SAAS,GAAGvF,UAAU,IAAIA,UAAU,CAACa,OAAX,CAAmB,KAAnB,IAA4B,CAAC,CAA3D;UACA,IAAI2E,YAAY,GAAGxF,UAAU,IAAIA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAAjE;UACA,IAAI4E,YAAY,GAAGzF,UAAU,IAAIA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAAjE;;UAEA,IAAIlC,MAAM,KAAK4F,aAAf,EAA8B;YAC5B,IAAIgB,SAAJ,EAAe;cACbjH,CAAC,CAACgG,IAAF;cACA;;;YAGF/F,KAAK,CAACoC,SAAN,GAAkB,IAAlB;YACApC,KAAK,CAACI,MAAN,GAAejB,KAAK,CAACgI,YAArB,CAP4B;WAA9B,MAQO,IAAIC,QAAQ,CAAChH,MAAD,EAAS/B,KAAT,CAAZ,EAA6B;YAClC,IAAI4I,YAAY,IAAIC,YAApB,EAAkC;cAChCnH,CAAC,CAACgG,IAAF;cACA;;;YAGF/F,KAAK,CAACI,MAAN,GAAeA,MAAf,CANkC;WAA7B,MAOA;YACLL,CAAC,CAACgG,IAAF;YACA,OAAO,KAAP;;;UAGF5G,KAAK,CAACW,WAAN,CAAkBC,CAAlB;SArDW,EAsDV+F,EAtDU,CAsDP,MAtDO,EAsDC,KAAKpF,OAtDN,EAsDeoF,EAtDf,CAsDkB,SAtDlB,EAsD6B,KAAK9E,SAtDlC,CAAb;;QAwDA,IAAI,KAAK9B,KAAL,CAAWmI,iBAAf,EAAkC;UAChC,KAAKxH,SAAL,GAAiB,IAAIyH,cAAJ,CAAmB,KAAKnE,QAAxB,CAAjB;;UAEA,KAAKtD,SAAL,CAAe0H,OAAf,CAAuB,KAAKtB,aAA5B,EAA2C;YACzCuB,GAAG,EAAE;WADP;;UAIA,KAAK3H,SAAL,CAAe0H,OAAf,CAAuB,KAAKE,eAAL,EAAvB,EAA+C;YAC7CD,GAAG,EAAE;WADP;SAPF,MAUO;UACL,KAAKrE,QAAL;;OAtEJ;;MA0EAI,OAAO,CAACmE,oBAAR,GAA+B,YAAY;QACzC,IAAIrG,EAAJ;;QAEA,KAAKhB,KAAL,CAAWsH,KAAX;QACA,CAACtG,EAAE,GAAG,KAAKxB,SAAX,MAA0B,IAA1B,IAAkCwB,EAAE,KAAK,KAAK,CAA9C,GAAkD,KAAK,CAAvD,GAA2DA,EAAE,CAACuG,UAAH,EAA3D;OAJF;;MAOArE,OAAO,CAACsE,kBAAR,GAA6B,UAAUC,SAAV,EAAqB;QAChD,IAAI5E,UAAU,GAAG,KAAKhE,KAAL,CAAWmE,aAA5B;;QAEA,IAAIyE,SAAS,CAACzE,aAAV,KAA4BH,UAAhC,EAA4C;;UAE1C,KAAKX,QAAL,CAAc;YACZlD,MAAM,EAAE6D,UAAU,IAAI;WADxB;;OALJ;;IAWF;IACA;IACA;IACA;;;MAGEK,OAAO,CAACwE,UAAR,GAAqB,UAAU1I,MAAV,EAAkB;QACrC,KAAKkD,QAAL,CAAc;UACZlD,MAAM,EAAEA;SADV;OADF;;IAMF;IACA;IACA;IACA;;;MAGEkE,OAAO,CAACyE,SAAR,GAAoB,YAAY;QAC9B,OAAO,KAAK5I,KAAL,CAAWC,MAAlB;OADF;;IAIF;IACA;IACA;IACA;;;MAGEkE,OAAO,CAAC0E,YAAR,GAAuB,UAAU7G,GAAV,EAAe8G,QAAf,EAAyB;QAC9C,IAAIA,QAAQ,KAAK,KAAK,CAAtB,EAAyB;UACvBA,QAAQ,GAAG,KAAKtI,WAAhB;;;QAGF,KAAKuI,QAAL,CAAc;UACZxE,UAAU,EAAEuE;SADd;;QAIA,IAAIjE,aAAa,GAAG,KAAKC,gBAAL,EAApB;QACA,IAAI+B,aAAa,GAAG,KAAKA,aAAzB;QACA,KAAK3G,SAAL,GAAiB8B,GAAjB;QACA6E,aAAa,CAAChE,KAAd,CAAoBwC,SAApB,GAAgC,GAAG3G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC,CAACsD,GAAD,GAAO8G,QAA5C,EAAsD,KAAtD,CAAhC;QACA,IAAI7I,MAAM,GAAG,KAAKD,KAAL,CAAWC,MAAxB;QACA,IAAIqC,YAAY,GAAG,KAAKxC,KAAL,CAAWwC,YAAX,IAA2B,CAA9C;QACA,KAAKjC,aAAL,CAAmB2E,OAAnB,CAA2B,UAAUgE,EAAV,EAAclL,CAAd,EAAiB;UAC1C,IAAI,CAACkL,EAAL,EAAS;YACP;;;UAGF,IAAIxG,QAAQ,GAAGvC,MAAM,CAACnC,CAAD,CAAN,IAAawE,YAAY,IAAI,CAA7B,CAAf;UACA0G,EAAE,CAACnG,KAAH,CAASwC,SAAT,GAAqB,GAAG3G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC8D,QAAQ,GAAGsG,QAAhD,EAA0D,qBAA1D,CAArB;UACAE,EAAE,CAACnG,KAAH,CAASoG,OAAT,GAAmB,CAACjH,GAAD,GAAOQ,QAAP,GAAkB,CAAlB,GAAsB,MAAtB,GAA+B,OAAlD;SAPF;OAfF;;IA0BF;IACA;IACA;IACA;IACA;;;MAGE2B,OAAO,CAAC+E,MAAR,GAAiB,UAAUJ,QAAV,EAAoBK,cAApB,EAAoC;QACnD,IAAIA,cAAc,KAAK,KAAK,CAA5B,EAA+B;UAC7BA,cAAc,GAAGL,QAAjB;;;QAGF,KAAKM,MAAL,CAAY,KAAKC,iBAAL,EAAZ,EAAsCP,QAAtC;QACA,KAAKD,YAAL,CAAkB,KAAKS,iBAAL,EAAlB,EAA4CH,cAA5C;OANF;;IASF;IACA;IACA;IACA;;;MAGEhF,OAAO,CAACoF,UAAR,GAAqB,YAAY;QAC/B,OAAO,KAAKpJ,UAAL,CAAgBmG,OAAvB;OADF;;IAIF;IACA;IACA;IACA;;;MAGEnC,OAAO,CAACkE,eAAR,GAA0B,YAAY;QACpC,OAAO,KAAK5C,KAAL,CAAWmB,aAAlB;OADF;;IAIF;IACA;;;MAGEzC,OAAO,CAACmF,iBAAR,GAA4B,YAAY;QACtC,OAAO,KAAKpJ,SAAZ;OADF;;IAIF;IACA;;;MAGEiE,OAAO,CAACkF,iBAAR,GAA4B,YAAY;QACtC,OAAO,KAAK5D,KAAL,CAAW+D,YAAX,EAAP;OADF;;IAIF;IACA;IACA;IACA;;;MAGErF,OAAO,CAACiF,MAAR,GAAiB,UAAUpH,GAAV,EAAe8G,QAAf,EAAyB;QACxC,IAAIA,QAAQ,KAAK,KAAK,CAAtB,EAAyB;UACvBA,QAAQ,GAAG,KAAKvI,KAAhB;;;QAGF,KAAKwI,QAAL,CAAc;UACZxG,IAAI,EAAEuG;SADR;;QAIA,KAAKrD,KAAL,CAAW2D,MAAX,CAAkBpH,GAAlB,EAAuB8G,QAAvB;OATF;;IAYF;IACA;IACA;IACA;;;MAGE3E,OAAO,CAACH,MAAR,GAAiB,UAAU8E,QAAV,EAAoB;QACnC,IAAIA,QAAQ,KAAK,KAAK,CAAtB,EAAyB;UACvBA,QAAQ,GAAG,KAAKvI,KAAhB;;;QAGF,KAAKwI,QAAL,CAAc;UACZxG,IAAI,EAAEuG;SADR;;QAIA,KAAKrD,KAAL,CAAWzB,MAAX,CAAkB8E,QAAlB;OATF;;MAYA3E,OAAO,CAACrD,OAAR,GAAkB,UAAUH,CAAV,EAAa;QAC7B,IAAIC,KAAK,GAAGD,CAAC,CAACC,KAAd;YACIkB,KAAK,GAAGnB,CAAC,CAACmB,KADd;YAEIC,KAAK,GAAGpB,CAAC,CAACoB,KAFd;QAGA,IAAIjC,KAAK,GAAG,KAAKA,KAAjB;QACA,IAAIwE,IAAI,GAAGxE,KAAK,CAACwE,IAAjB;YACImF,KAAK,GAAG3J,KAAK,CAAC2J,KADlB;YAEIC,aAAa,GAAG5J,KAAK,CAAC4J,aAF1B;YAGIvH,cAAc,GAAGrC,KAAK,CAACqC,cAH3B;YAIIC,KAAK,GAAGtC,KAAK,CAACsC,KAJlB;QAKA,IAAIE,YAAY,GAAGxC,KAAK,CAACwC,YAAN,IAAsB,CAAzC;QACA,IAAIC,IAAI,GAAG,KAAK/B,WAAhB;;QAEA,IAAIuF,aAAa,GAAGjG,KAAK,CAACiG,aAAN,IAAuB,UAAUC,CAAV,EAAa;UACtD,OAAOA,CAAP;SADF;;QAIA,IAAIc,YAAY,GAAGxC,IAAI,KAAK,YAA5B;QACA,IAAIqF,SAAS,GAAGtC,mBAAmB,CAACzG,KAAK,CAACsG,MAAP,EAAe,CAACpF,KAAD,EAAQC,KAAR,CAAf,CAAnC;QACA,IAAIqF,SAAS,GAAGxG,KAAK,CAACwG,SAAtB;QACA,IAAIwC,OAAO,GAAGD,SAAS,CAAC,CAAD,CAAT,GAAevC,SAAS,CAAC,CAAD,CAAtC;QACA,IAAIyC,OAAO,GAAGF,SAAS,CAAC,CAAD,CAAT,GAAevC,SAAS,CAAC,CAAD,CAAtC;QACA,IAAI0C,gBAAgB,GAAGxH,YAAY,GAAGC,IAAtC;QACA,IAAIf,OAAO,GAAGuI,IAAI,CAACC,KAAL,CAAWlD,YAAY,GAAG+C,OAAH,GAAaD,OAApC,IAA+CtH,YAA7D;QACA,IAAIE,QAAQ,GAAGC,UAAU,CAAC,CAACjB,OAAO,GAAGe,IAAX,EAAiBG,OAAjB,CAAyBN,KAAK,IAAI,CAAlC,CAAD,CAAzB;QACA,IAAI6H,UAAU,GAAGR,KAAK,CAAChL,KAAN,GAAcyL,IAAd,CAAmB,UAAUC,CAAV,EAAaxN,CAAb,EAAgB;UAClD,OAAOoN,IAAI,CAACK,GAAL,CAAS5H,QAAQ,GAAG2H,CAApB,IAAyBJ,IAAI,CAACK,GAAL,CAAS5H,QAAQ,GAAG7F,CAApB,CAAhC;SADe,CAAjB;;QAIA,IAAIsN,UAAU,CAAChM,MAAX,IAAqB8L,IAAI,CAACK,GAAL,CAASH,UAAU,CAAC,CAAD,CAAV,GAAgB1H,IAAhB,GAAuBf,OAAhC,IAA2CkI,aAApE,EAAmF;UACjFlH,QAAQ,GAAGyH,UAAU,CAAC,CAAD,CAArB;UACAzI,OAAO,GAAGgB,QAAQ,GAAGD,IAArB;;;QAGF,IAAI,CAAC3B,KAAK,CAACoC,SAAP,IAAoB,CAAC,KAAK1C,YAA9B,EAA4C;UAC1C,IAAI6B,cAAJ,EAAoB;YAClB,IAAIkI,UAAU,GAAG/F,IAAI,KAAK,YAAT,GAAwB,CAACsF,OAAD,EAAUpI,OAAO,GAAGsI,gBAApB,CAAxB,GAAgE,CAACtI,OAAO,GAAGsI,gBAAX,EAA6BD,OAA7B,CAAjF;YACA,KAAKjH,cAAL,CAAoBC,KAApB,CAA0BC,OAA1B,IAAqC,oBAAoB,mCAApB,GAA0D,aAAapE,MAAb,CAAoB2L,UAAU,CAACpE,GAAX,CAAe,UAAUD,CAAV,EAAa;cAC7I,OAAO,GAAGtH,MAAH,CAAUsH,CAAV,EAAa,IAAb,CAAP;aADiH,EAEhHsE,IAFgH,CAE3G,IAF2G,CAApB,EAEhF,GAFgF,CAA/F;YAGA,KAAK1H,cAAL,CAAoB2H,SAApB,GAAgC,GAAG7L,MAAH,CAAUqH,aAAa,CAACvD,QAAD,CAAvB,CAAhC;;;UAGF,IAAIxB,MAAM,GAAGJ,KAAK,CAACI,MAAnB;UACAA,MAAM,CAACwJ,YAAP,CAAoB,UAApB,EAAgChI,QAAhC;UACAxB,MAAM,CAAC6B,KAAP,CAAawC,SAAb,GAAyB,GAAG3G,MAAH,CAAU,KAAKoG,gBAAL,EAAV,EAAmC,GAAnC,EAAwCpG,MAAxC,CAA+C8C,OAAO,GAAGc,YAAY,GAAGC,IAAxE,EAA8E,KAA9E,CAAzB;;;QAGF,OAAOf,OAAP;OAhDF;;MAmDA2C,OAAO,CAACW,gBAAR,GAA2B,YAAY;QACrC,OAAO,KAAKhF,KAAL,CAAWwE,IAAX,KAAoB,YAApB,GAAmC,YAAnC,GAAkD,YAAzD;OADF;;MAIAH,OAAO,CAAC9C,gBAAR,GAA2B,UAAUV,CAAV,EAAa;QACtC,IAAIZ,KAAK,GAAG,IAAZ;;QAEA,IAAI0K,aAAa,GAAG,KAAK3K,KAAL,CAAW2K,aAA/B;;QAEA,IAAI,CAACA,aAAL,EAAoB;UAClB;;;QAGF,IAAI7J,KAAK,GAAGD,CAAC,CAACC,KAAd;QACA,IAAI8J,UAAU,GAAG,IAAIC,UAAJ,EAAjB;QACA/J,KAAK,CAAC8J,UAAN,GAAmBA,UAAnB;QACAA,UAAU,CAAChE,EAAX,CAAc,QAAd,EAAwB,UAAUzE,EAAV,EAAc;UACpC,IAAI0C,EAAJ,EAAQiG,EAAR;;UAEA,IAAIrE,SAAS,GAAGtE,EAAE,CAACsE,SAAnB;cACIsE,SAAS,GAAG5I,EAAE,CAAC4I,SADnB;;IAGN;IACA;IACA;IACA;IACA;;UAEM,CAACD,EAAE,GAAG,CAACjG,EAAE,GAAG5E,KAAK,CAACD,KAAZ,EAAmBgL,eAAzB,MAA8C,IAA9C,IAAsDF,EAAE,KAAK,KAAK,CAAlE,GAAsE,KAAK,CAA3E,GAA+EA,EAAE,CAACzN,IAAH,CAAQwH,EAAR,EAAY;YACzF4B,SAAS,EAAEA,SAD8E;YAEzFsE,SAAS,EAAEA;WAFkE,CAA/E;SAZF,EAgBGnE,EAhBH,CAgBM,MAhBN,EAgBc,UAAUzE,EAAV,EAAc;UAC1B,IAAI2H,OAAO,GAAG3H,EAAE,CAAC2H,OAAjB;cACIC,OAAO,GAAG5H,EAAE,CAAC4H,OADjB;cAEIhJ,UAAU,GAAGoB,EAAE,CAACpB,UAFpB;;UAIAd,KAAK,CAACkB,KAAN,CAAY8J,QAAZ,CAAqBnB,OAArB,EAA8BC,OAA9B,EAAuChJ,UAAU,CAACA,UAAlD,EAA8D,IAA9D;SArBF;QAuBA6J,UAAU,CAACM,SAAX,CAAqBrK,CAArB,EAAwB;UACtB4F,SAAS,EAAEkE,aAAa,CAAClE;SAD3B;OAnCF;;MAwCApC,OAAO,CAACxC,WAAR,GAAsB,UAAUhB,CAAV,EAAa;QACjC,IAAI8J,aAAa,GAAG,KAAK3K,KAAL,CAAW2K,aAA/B;;QAEA,IAAI,CAACA,aAAL,EAAoB;UAClB;;;QAGF,IAAIC,UAAU,GAAG/J,CAAC,CAACC,KAAF,CAAQ8J,UAAzB;QACAA,UAAU,CAACO,IAAX,CAAgBtK,CAAhB,EAAmB8J,aAAnB;OARF;;MAWAtG,OAAO,CAACzC,cAAR,GAAyB,UAAUf,CAAV,EAAa;QACpC,IAAIsB,EAAJ;;QAEA,CAACA,EAAE,GAAGtB,CAAC,CAACC,KAAF,CAAQ8J,UAAd,MAA8B,IAA9B,IAAsCzI,EAAE,KAAK,KAAK,CAAlD,GAAsD,KAAK,CAA3D,GAA+DA,EAAE,CAACiJ,OAAH,EAA/D;QACAvK,CAAC,CAACC,KAAF,CAAQ8J,UAAR,GAAqB,IAArB;OAJF;;MAOAvG,OAAO,CAAC4E,QAAR,GAAmB,UAAUoC,KAAV,EAAiB;QAClC,IAAIrC,QAAQ,GAAGqC,KAAK,CAAC5I,IAArB;YACI4G,cAAc,GAAGgC,KAAK,CAAC5G,UAD3B;QAEA,IAAI6G,OAAO,GAAG,CAAC,CAAC,KAAKtL,KAAL,CAAWyC,IAA3B;QACA,IAAI8I,aAAa,GAAG,CAAC,CAAC,KAAKvL,KAAL,CAAWyE,UAAjC;;QAEA,IAAI8G,aAAJ,EAAmB;UACjB,IAAIlC,cAAJ,EAAoB;YAClB,KAAK3I,WAAL,GAAmB2I,cAAnB;;SAFJ,MAIO;UACL,IAAIA,cAAJ,EAAoB;YAClB,KAAK5I,KAAL,GAAa4I,cAAb;YACA,KAAK3I,WAAL,GAAmB2I,cAAnB;;;UAGF,IAAIL,QAAJ,EAAc;YACZ,KAAKtI,WAAL,GAAmBsI,QAAnB;;;;QAIJ,IAAIA,QAAJ,EAAc;UACZ,KAAKvI,KAAL,GAAauI,QAAb;;OAtBJ;;MA0BAlJ,MAAM,CAAC0L,YAAP,GAAsB;QACpBjH,SAAS,EAAE,EADS;QAEpBC,IAAI,EAAE,YAFc;QAGpB/B,IAAI,EAAE,CAHc;QAIpBgC,UAAU,EAAE,CAJQ;QAKpB1B,KAAK,EAAE,EALa;QAMpB6G,aAAa,EAAE,CANK;QAOpBD,KAAK,EAAE,EAPa;QAQpBrH,KAAK,EAAE,CARa;QASpBa,YAAY,EAAE,YAAY,EATN;QAUpBf,cAAc,EAAE,YAAY,EAVR;QAWpB4I,eAAe,EAAE,YAAY,EAXT;QAYpBpK,WAAW,EAAE,YAAY,EAZL;QAapBe,MAAM,EAAE,YAAY,EAbA;QAcpBG,SAAS,EAAE,YAAY,EAdH;QAepBO,cAAc,EAAE,KAfI;QAgBpB4D,aAAa,EAAE,UAAUC,CAAV,EAAa;UAC1B,OAAOA,CAAP;SAjBkB;QAmBpB/B,aAAa,EAAE,EAnBK;QAoBpB5B,UAAU,EAAE,KApBQ;QAqBpBsD,UAAU,EAAE,IArBQ;QAsBpBC,UAAU,EAAE,EAtBQ;QAuBpBlB,cAAc,EAAE,EAvBI;QAwBpBE,aAAa,EAAE,EAxBK;QAyBpBV,gBAAgB,EAAE;OAzBpB;MA2BA,OAAOtE,MAAP;IACD,CAjsBD,CAisBE2L,aAjsBF,CAFA;;IC5FO,IAAMjM,YAAU,GAA+BkM,YAA/C;AAEP,IAAO,IAAMhM,SAAO,GAAGiM,OAAhB;AAEP,IAAO,IAAMhM,QAAM,GAAGiM,MAAf;;ICJP;;;MAAyCtO,8BAAA;;MAGrC,oBAAA,CAAY0C,KAAZ;QAAA,YACID,WAAA,KAAA,EAAMC,KAAN,SADJ;;QAFOC,WAAA,GAA0B,EAA1B;QAIHA,KAAI,CAACC,KAAL,GAAaD,KAAI,CAACD,KAAlB;;;;;;MAEG,cAAA,GAAP;QACI,OAAO6L,aAAA,CAACC,MAAD;UAAazG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,QAAP;WAAsB,KAAKnF,MAAhD,CAAP;OADG;;MAGX,kBAAA;IAAC,EAVwC2L,UAAzC;;ICgCA;;;MAAqBvO,yBAAA;;;;;;;;MAUjB,eAAA,CAAYmJ,SAAZ,EAAoCf,OAApC;QAAoC,sBAAA,EAAA;UAAAA,YAAA;;;QAApC,YACI3F,WAAA,KAAA,SADJ;;QATQE,uBAAA,GAA8C,IAA9C;QACAA,iBAAA,GAAkC,IAAlC;QACAA,WAAA,GAAQ,KAAR;QASJ,IAAM8L,MAAM,GAAQ,EAApB;QAEApM,QAAM,CAACuF,OAAP,CAAe,UAAAC,IAAA;UACX4G,MAAM,CAACC,QAAQ,CAAC,YAAA,CAAM7G,IAAN,CAAD,CAAT,CAAN,GAAiC,UAACtE,CAAD;YAAY,OAAAZ,KAAI,CAACgM,OAAL,CAAa9G,IAAb,EAA0BtE,CAA1B,CAAA;WAA7C;SADJ;QAGA,IAAIqL,WAAJ;;QAEA,IAAIxG,OAAO,CAACyG,QAAZ,EAAsB;UAClB,OAAOzG,OAAO,CAACyG,QAAf;UACAlM,KAAI,CAACmM,KAAL,GAAa,IAAb;UACAF,WAAW,GAAGzF,SAAd;SAHJ,MAIO;UACHyF,WAAW,GAAGxF,QAAQ,CAACtB,aAAT,CAAuB,KAAvB,CAAd;UACAqB,SAAS,CAAC4F,WAAV,CAAsBH,WAAtB;;;QAEJjM,KAAI,CAACqM,iBAAL,GAAyBC,UAAU,CAC/BV,aAAA,CAACW,WAAD;UAAanH,GAAG,EAAEA,GAAG,CAACpF,KAAD,EAAO,aAAP;WACb8L,QACArG,QAFR,CAD+B,EAI/BwG,WAJ+B,CAAnC;;;;;;;;;;;MAWG,gBAAA,GAAP,UAAgBhM,KAAhB,EAA+CuM,QAA/C;QACI,KAAKC,WAAL,CAAiBrJ,QAAjB,CAA0BnD,KAA1B,EAAiCuM,QAAjC;OADG;;;;;;MAMA,mBAAA,GAAP,UAAmBA,QAAnB;QACI,KAAKC,WAAL,CAAiBC,WAAjB,CAA6BF,QAA7B;OADG;;;;;;MAMA,eAAA,GAAP;;;QACI,IAAMP,WAAW,GAAG,KAAKA,WAAzB;QAEAK,UAAU,CACN,IADM,EAENL,WAFM,EAGN,KAAKI,iBAHC,CAAV;;QAKA,IAAI,CAAC,KAAKF,KAAV,EAAiB;UACb,MAAAF,WAAW,SAAX,IAAAA,WAAW,WAAX,SAAA,GAAAA,WAAW,CAAEU,aAAb,UAAA,iBAAA,SAAA,MAA4BC,YAAYX,YAAxC;;;QAEJ,KAAKA,WAAL,GAAmB,IAAnB;QACA,KAAKQ,WAAL,GAAmB,IAAnB;OAZG;;MAcC,sBAAA,GAAR;QACI,OAAO,KAAKA,WAAL,CAAiBvM,MAAxB;OADI;;MAhENL,MAAM,eA/BXgN,UAAU,CAACpN,SAAD,EAAiB,UAACvC,SAAD,EAAY4P,QAAZ;QACxB,IAAI5P,SAAS,CAAC4P,QAAD,CAAb,EAAyB;UACrB;;;QAEJ5P,SAAS,CAAC4P,QAAD,CAAT,GAAsB;UAAS,aAAA;;eAAA,YAAAhO,uBAAAA;YAAAiO,QAAA,gBAAA;;;UAC3B,IAAMC,IAAI,GAAG,KAAKC,cAAL,EAAb;;UAEA,IAAI,CAACD,IAAD,IAAS,CAACA,IAAI,CAACF,QAAD,CAAlB,EAA8B;YAC1B;;;UAEJ,OAAOE,IAAI,CAACF,QAAD,CAAJ,MAAA,CAAAE,IAAA,EAAkBD,IAAlB,CAAP;SANJ;OAJO,GAaVF,UAAU,CAACtN,YAAD,EAAa,UAACrC,SAAD,EAAY4P,QAAZ;QACpBjQ,MAAM,CAACqQ,cAAP,CAAsBhQ,SAAtB,EAAiC4P,QAAjC,EAA2C;UACvCK,GAAG;YACC,OAAO,KAAKF,cAAL,GAAsBlN,KAAtB,CAA4B+M,QAA5B,CAAP;WAFmC;UAIvCM,GAAG,YAACC;;;YACA,KAAKZ,WAAL,CAAiBrJ,QAAjB,WACIlB,GAAC4K,SAAD,GAAYO,SADhB;WALmC;UASvCC,UAAU,EAAE,IAT2B;UAUvCC,YAAY,EAAE;SAVlB;OADO;;;;;SAkBL1N,OAAA;MAmEN,aAAA;IAAC,EAnEoB2N,aAArB;;ICtCA;;;MAAoCnQ,yBAAA;;MAApC,eAAA;;;;MAAmD,aAAA;IAAnD,EAAoCoQ,SAApC;;;;;;;;;;;;ICAA,KAAK,IAAMvI,IAAX,IAAmBwI,MAAnB,EAA2B;MACtB7N,QAAc,CAACqF,IAAD,CAAd,GAAuBwI,MAAM,CAACxI,IAAD,CAA7B;IACJ;;;;;;;;"} \ No newline at end of file diff --git a/release/0.29.2/dist/guides.min.js b/release/0.29.2/dist/guides.min.js new file mode 100644 index 0000000..45c9e3b --- /dev/null +++ b/release/0.29.2/dist/guides.min.js @@ -0,0 +1,10 @@ +/* +Copyright (c) Daybrush +name: @scena/guides +license: MIT +author: Daybrush +repository: git+https://github.com/daybrush/guides.git +version: 0.29.2 +*/ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t=t||self).Guides=e()}(this,function(){"use strict";var z=function(t,e){return(z=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n])})(t,e)};function n(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Class extends value "+String(e)+" is not a constructor or null");function n(){this.constructor=t}z(t,e),t.prototype=null===e?Object.create(e):(n.prototype=e.prototype,new n)}var s=function(){return(s=Object.assign||function(t){for(var e,n=1,r=arguments.length;nh[1])){var F=0===M?S:M%2==0?W:U,j=0;switch(d){case"start":j=0;break;case"center":j=O/2-F/2;break;case"end":j=O-F}var z=y?[R+w[0],j+w[1]]:[j+w[0],R+w[1]],R=z[0],z=z[1],tt=y?[R,z+F]:[R+F,z],et=tt[0],tt=tt[1];_.moveTo(R+w[0],z+w[1]),_.lineTo(et+w[0],tt+w[1])}}}_.stroke(),_.beginPath(),_.strokeStyle=p,_.lineWidth=1,(n||[]).forEach(function(t){var e,n,r=(-l+t)*c;r<0||C<=r||th[1]||(r=(t=y?[r+w[0],w[1]]:[w[0],r+w[1]])[0],t=t[1],e=(n=y?[r,t+E]:[r+E,t])[0],n=n[1],_.moveTo(r+w[0],t+w[1]),_.lineTo(e+w[0],n+w[1]))}),_.stroke(),D.forEach(function(t){var e=t.value,n=t.offset,r=t.backgroundColor,i=t.color,o=t.text,s=t.textSize;if(L||!(e<0)){t=(e-l)*c;if(!(t<-P||C+f*c<=t||eh[1])){var a=0;switch(d){case"start":a=17;break;case"center":a=O/2;break;case"end":a=O-17}e=y?[t+-3*H,a]:[a,t+3*H],t=e[0],e=e[1];if(r){var u=0;switch(b){case"left":u=0;break;case"center":u=-s/2;break;case"right":u=-s}_.save(),_.fillStyle=r,y?_.fillRect(t+n[0]+u,0,s,S):(_.translate(0,e+n[1]),_.rotate(-Math.PI/2),_.fillRect(u,0,s,S)),_.restore()}_.save(),_.fillStyle=i,y?_.fillText(o,t+n[0],e+n[1]):(_.translate(t+n[0],e+n[1]),_.rotate(-Math.PI/2),_.fillText(o,0,0)),_.restore()}}}),_.restore()},n._getRulerScale=function(){var t,e,n=this.props.defaultPixelScale||2;return this._rulerScale||(!(e=1r-(i=void 0===i?0:i)?(s[1]>o.top||rs[1])&&(a[1]=1),o.left>n-i?(s[0]>o.left||ns[0])&&(a[0]=1),!(!a[0]&&!a[1])&&this._continueDrag(f(f({},e),{direction:a,inputEvent:t,isDrag:!0}))},i.checkScroll=function(t){var e,n,r,i,o,s,a,u=this;return!this._isWait&&(s=void 0===(s=t.prevScrollPos)?this._prevScrollPos:s,a=t.direction,e=void 0===(e=t.throttleTime)?0:e,n=t.inputEvent,r=t.isDrag,o=(i=this._getScrollPosition(a||[0,0],t))[0]-s[0],s=i[1]-s[1],a=a||[o?Math.abs(o)/o:0,s?Math.abs(s)/s:0],this._prevScrollPos=i,!(!o&&!s)&&(this.trigger("move",{offsetX:a[0]?o:0,offsetY:a[1]?s:0,inputEvent:n}),e&&r&&(clearTimeout(this._timer),this._timer=window.setTimeout(function(){u._continueDrag(t)},e)),!0))},i.dragEnd=function(){this._flag=!1,clearTimeout(this._timer)},i._getScrollPosition=function(t,e){var n=e.container,e=e.getScrollPosition;return(void 0===e?zt:e)({container:Ft(n),direction:t})},i._continueDrag=function(t){var e=this,n=t.container,r=t.direction,i=t.throttleTime,o=t.useScroll,s=t.isDrag,a=t.inputEvent;if(!(!this._flag||s&&this._isWait)){var u=b(),i=Math.max(i+this._prevTime-u,0);if(0n||(n=new Bt(D(t)),this.pinchFlag=!0,this._addStore(n),!1===this.emit("pinchStart",P(P({data:this.data,datas:this.data,angle:n.getAngle(),touches:this.getCurrentStore().getPositions()},n.getPosition()),{inputEvent:t,isTrusted:this._isTrusted,preventDefault:function(){t.preventDefault()},preventDrag:function(){e._dragFlag=!1}}))&&(this.pinchFlag=!1))},r.prototype.onPinch=function(t,e){var n;!this.flag||!this.pinchFlag||e.length<2||(n=this.getCurrentStore(),this.isPinch=!0,this.emit("pinch",P(P({data:this.data,datas:this.data,movement:this.getMovement(e),angle:n.getAngle(e),rotation:n.getRotation(e),touches:n.getPositions(e),scale:n.getScale(e),distance:n.getDistance(e)},n.getPosition(e)),{inputEvent:t,isTrusted:this._isTrusted})))},r.prototype.onPinchEnd=function(t){var e,n;this.pinchFlag&&(e=this.isPinch,this.isPinch=!1,this.pinchFlag=!1,n=this.getCurrentStore(),this.emit("pinchEnd",P(P({data:this.data,datas:this.data,isPinch:e,touches:n.getPositions()},n.getPosition()),{inputEvent:t})))},r.prototype.getCurrentStore=function(){return this.clientStores[0]},r.prototype.moveClients=function(t,e,n){var n=this._getPosition(t,n),r=this.isDrag,i=((n.deltaX||n.deltaY)&&(this.isDrag=!0),!1);return!r&&this.isDrag&&(i=!0),P(P({data:this.data,datas:this.data},n),{movement:this.getMovement(t),isDrag:this.isDrag,isPinch:this.isPinch,isScroll:!1,isMouseEvent:this._isMouseEvent,isSecondaryButton:this._isSecondaryButton,inputEvent:e,isTrusted:this._isTrusted,isFirstDrag:i})},r.prototype._addStore=function(t){this.clientStores.splice(0,0,t)},r.prototype._getPosition=function(t,e){var t=this.getCurrentStore().getPosition(t,e),e=this.clientStores.slice(1).reduce(function(t,e){e=e.getPosition();return t.distX+=e.distX,t.distY+=e.distY,t},t),n=e.distX,e=e.distY;return P(P({},t),{distX:n,distY:e})},r.prototype._attchDragEvent=function(){var t=this.options.container,e={passive:!1};this._isDragAPI&&(S(t,"dragover",this.onDrag),S(t,"dragend",this.onDragEnd)),this.isMouse&&(S(t,"mousemove",this.onDrag),S(t,"mouseup",this.onDragEnd)),this.isTouch&&(S(t,"touchmove",this.onDrag,e),S(t,"touchend",this.onDragEnd,e),S(t,"touchcancel",this.onDragEnd,e))},r.prototype._dettachDragEvent=function(){var t=this.options.container;this._isDragAPI&&(w(t,"dragover",this.onDrag),w(t,"dragend",this.onDragEnd)),this.isMouse&&(w(t,"mousemove",this.onDrag),w(t,"mouseup",this.onDragEnd)),this.isTouch&&(w(t,"touchstart",this.onDragStart),w(t,"touchmove",this.onDrag),w(t,"touchend",this.onDragEnd),w(t,"touchcancel",this.onDragEnd))},r}(t);var Lt=function(t){for(var e=5381,n=t.length;n;)e=33*e^t.charCodeAt(--n);return e>>>0};function $t(t,e,n,r,i){var o,s=document.createElement("style"),e=(s.setAttribute("type","text/css"),s.setAttribute("data-styled-id",t),s.setAttribute("data-styled-count","1"),n.nonce&&s.setAttribute("nonce",n.nonce),s.innerHTML=(o=t,t=e,n.original?t:t.replace(/([^};{\s}][^};{]*|^\s*){/gm,function(t,e){e=e.trim();return(e?u(e):[""]).map(function(t){t=t.trim();return 0===t.indexOf("@")?t:-1= baseScrollPos && guides.indexOf(guidePos) < 0) {\n _this.setState({\n guides: __spreadArray(__spreadArray([], guides, true), [guidePos], false)\n }, function () {\n /**\n * The `changeGuides` event occurs when the guideline is added / removed / changed.\n * @memberof Guides\n * @event changeGuides\n * @param {OnChangeGuides} - Parameters for the changeGuides event\n */\n onChangeGuides({\n guides: _this.state.guides,\n distX: distX,\n distY: distY,\n index: guides.length,\n isAdd: true,\n isRemove: false,\n isChange: false\n });\n });\n }\n } else {\n var index_1 = parseFloat(datas.target.getAttribute(\"data-index\"));\n var isRemove_1 = false;\n var isChange_1 = false;\n guides = __spreadArray([], guides, true);\n var guideIndex = guides.indexOf(guidePos);\n\n if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"remove\") > -1)) {\n return;\n }\n\n guides.splice(index_1, 1);\n isRemove_1 = true;\n } else if (guideIndex > -1) {\n return;\n } else {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"change\") > -1)) {\n return;\n }\n\n guides[index_1] = guidePos;\n isChange_1 = true;\n }\n\n _this.setState({\n guides: guides\n }, function () {\n var nextGuides = _this.state.guides;\n onChangeGuides({\n distX: distX,\n distY: distY,\n guides: nextGuides,\n isAdd: false,\n index: index_1,\n isChange: isChange_1,\n isRemove: isRemove_1\n });\n });\n }\n };\n\n _this._onCheck = function () {\n _this.resize();\n };\n\n _this.state.guides = props.defaultGuides || [];\n _this.scrollPos = props.defaultGuidesPos || 0;\n return _this;\n }\n\n var __proto = Guides.prototype;\n\n __proto.render = function () {\n var _a = this.props,\n className = _a.className,\n type = _a.type,\n zoom = _a.zoom,\n guidesZoom = _a.guidesZoom,\n style = _a.style,\n rulerStyle = _a.rulerStyle,\n displayDragPos = _a.displayDragPos,\n cspNonce = _a.cspNonce,\n dragGuideStyle = _a.dragGuideStyle,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b;\n var props = this.props;\n var translateName = this.getTranslateName();\n var rulerProps = {};\n PROPERTIES$1.forEach(function (name) {\n if (name === \"style\" || name === \"warpSelf\" || name === \"useResizeObserver\") {\n return;\n }\n\n rulerProps[name] = props[name];\n });\n this._zoom = zoom;\n this._guidesZoom = guidesZoom || zoom;\n return createElement(GuidesElement, {\n ref: this.managerRef,\n cspNonce: cspNonce,\n className: \"\".concat(prefix(\"manager\", type), \" \").concat(className),\n style: style\n }, createElement(\"div\", {\n className: prefix(\"guide-origin\"),\n ref: ref(this, \"originElement\")\n }), createElement(Ruler, __assign({\n ref: ref(this, \"ruler\"),\n style: rulerStyle\n }, rulerProps)), createElement(\"div\", {\n className: GUIDES,\n ref: ref(this, \"guidesElement\"),\n style: {\n transform: \"\".concat(translateName, \"(\").concat(-this.scrollPos * this._guidesZoom, \"px)\")\n }\n }, displayDragPos && createElement(\"div\", {\n className: DISPLAY_DRAG,\n ref: ref(this, \"displayElement\"),\n style: guidePosStyle || {}\n }), createElement(\"div\", {\n className: ADDER,\n ref: ref(this, \"adderElement\"),\n style: dragGuideStyle\n }), this.renderGuides()));\n };\n /**\n * Draw ruler\n */\n\n\n __proto.drawRuler = function (options) {\n this.ruler.draw(options);\n };\n\n __proto.renderGuides = function () {\n var _this = this;\n\n var props = this.props;\n var _a = props,\n type = _a.type,\n showGuides = _a.showGuides,\n guideStyle = _a.guideStyle,\n displayGuidePos = _a.displayGuidePos,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b,\n guidesOffset = _a.guidesOffset;\n var zoom = this._guidesZoom;\n var translateName = this.getTranslateName();\n var guides = this.state.guides;\n\n var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) {\n return v;\n };\n\n this.guideElements = [];\n\n if (showGuides) {\n return guides.map(function (pos, i) {\n var guidePos = pos + (guidesOffset || 0);\n return createElement(\"div\", {\n className: prefix(\"guide\", type),\n ref: refs(_this, \"guideElements\", i),\n key: i,\n \"data-index\": i,\n \"data-pos\": pos,\n style: __assign(__assign({}, guideStyle), {\n transform: \"\".concat(translateName, \"(\").concat(guidePos * zoom, \"px) translateZ(0px)\")\n })\n }, displayGuidePos && createElement(\"div\", {\n className: prefix(\"guide-pos\"),\n style: guidePosStyle || {}\n }, guidePosFormat(pos)));\n });\n }\n\n return;\n };\n\n __proto.componentDidMount = function () {\n var _this = this;\n\n this.gesto = new Gesto(this.managerRef.current, {\n container: document.body\n }).on(\"dragStart\", function (e) {\n var _a = _this.props,\n type = _a.type,\n lockGuides = _a.lockGuides;\n var zoom = _this._guidesZoom;\n\n if (lockGuides === true) {\n e.stop();\n return;\n }\n\n var inputEvent = e.inputEvent;\n var target = inputEvent.target;\n var datas = e.datas;\n var canvasElement = _this.ruler.canvasElement;\n var guidesElement = _this.guidesElement;\n var isHorizontal = type === \"horizontal\";\n\n var originRect = _this.originElement.getBoundingClientRect();\n\n var matrix = getDistElementMatrix(_this.managerRef.current);\n var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]);\n offsetPos[0] -= guidesElement.offsetLeft;\n offsetPos[1] -= guidesElement.offsetTop;\n offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom;\n datas.offsetPos = offsetPos;\n datas.matrix = matrix;\n var isLockAdd = lockGuides && lockGuides.indexOf(\"add\") > -1;\n var isLockRemove = lockGuides && lockGuides.indexOf(\"remove\") > -1;\n var isLockChange = lockGuides && lockGuides.indexOf(\"change\") > -1;\n\n if (target === canvasElement) {\n if (isLockAdd) {\n e.stop();\n return;\n }\n\n datas.fromRuler = true;\n datas.target = _this.adderElement; // add\n } else if (hasClass(target, GUIDE)) {\n if (isLockRemove && isLockChange) {\n e.stop();\n return;\n }\n\n datas.target = target; // change\n } else {\n e.stop();\n return false;\n }\n\n _this.onDragStart(e);\n }).on(\"drag\", this._onDrag).on(\"dragEnd\", this.onDragEnd);\n\n if (this.props.useResizeObserver) {\n this._observer = new ResizeObserver(this._onCheck);\n\n this._observer.observe(this.guidesElement, {\n box: \"border-box\"\n });\n\n this._observer.observe(this.getRulerElement(), {\n box: \"border-box\"\n });\n } else {\n this._onCheck();\n }\n };\n\n __proto.componentWillUnmount = function () {\n var _a;\n\n this.gesto.unset();\n (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n };\n\n __proto.componentDidUpdate = function (prevProps) {\n var nextGuides = this.props.defaultGuides;\n\n if (prevProps.defaultGuides !== nextGuides) {\n // to dynamically update guides from code rather than dragging guidelines\n this.setState({\n guides: nextGuides || []\n });\n }\n };\n /**\n * Load the current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.loadGuides = function (guides) {\n this.setState({\n guides: guides\n });\n };\n /**\n * Get current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getGuides = function () {\n return this.state.guides;\n };\n /**\n * Scroll the positions of the guidelines opposite the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scrollGuides = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._guidesZoom;\n }\n\n this._setZoom({\n guidesZoom: nextZoom\n });\n\n var translateName = this.getTranslateName();\n var guidesElement = this.guidesElement;\n this.scrollPos = pos;\n guidesElement.style.transform = \"\".concat(translateName, \"(\").concat(-pos * nextZoom, \"px)\");\n var guides = this.state.guides;\n var guidesOffset = this.props.guidesOffset || 0;\n this.guideElements.forEach(function (el, i) {\n if (!el) {\n return;\n }\n\n var guidePos = guides[i] + (guidesOffset || 0);\n el.style.transform = \"\".concat(translateName, \"(\").concat(guidePos * nextZoom, \"px) translateZ(0px)\");\n el.style.display = -pos + guidePos < 0 ? \"none\" : \"block\";\n });\n };\n /**\n * Set to the next zoom.\n * @memberof Guides\n * @since 0.22.0\n * @param nextZoom - next zoom\n */\n\n\n __proto.zoomTo = function (nextZoom, nextGuidesZoom) {\n if (nextGuidesZoom === void 0) {\n nextGuidesZoom = nextZoom;\n }\n\n this.scroll(this.getRulerScrollPos(), nextZoom);\n this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);\n };\n /**\n * Get Guides DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getElement = function () {\n return this.managerRef.current;\n };\n /**\n * Get Ruler DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getRulerElement = function () {\n return this.ruler.canvasElement;\n };\n /**\n * Scroll position of guides (horizontal: y, vertical: x)\n */\n\n\n __proto.getGuideScrollPos = function () {\n return this.scrollPos;\n };\n /**\n * Scroll position of the ruler (horizontal: x, vertical: y)\n */\n\n\n __proto.getRulerScrollPos = function () {\n return this.ruler.getScrollPos();\n };\n /**\n * Scroll the position of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scroll = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.scroll(pos, nextZoom);\n };\n /**\n * Recalculate the size of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.resize = function (nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.resize(nextZoom);\n };\n\n __proto.movePos = function (e) {\n var datas = e.datas,\n distX = e.distX,\n distY = e.distY;\n var props = this.props;\n var type = props.type,\n snaps = props.snaps,\n snapThreshold = props.snapThreshold,\n displayDragPos = props.displayDragPos,\n digit = props.digit;\n var guidesOffset = props.guidesOffset || 0;\n var zoom = this._guidesZoom;\n\n var dragPosFormat = props.dragPosFormat || function (v) {\n return v;\n };\n\n var isHorizontal = type === \"horizontal\";\n var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);\n var offsetPos = datas.offsetPos;\n var offsetX = matrixPos[0] + offsetPos[0];\n var offsetY = matrixPos[1] + offsetPos[1];\n var guidesZoomOffset = guidesOffset * zoom;\n var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;\n var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0));\n var guideSnaps = snaps.slice().sort(function (a, b) {\n return Math.abs(guidePos - a) - Math.abs(guidePos - b);\n });\n\n if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) {\n guidePos = guideSnaps[0];\n nextPos = guidePos * zoom;\n }\n\n if (!datas.fromRuler || !this._isFirstMove) {\n if (displayDragPos) {\n var displayPos = type === \"horizontal\" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY];\n this.displayElement.style.cssText += \"display: block;\" + \"transform: translate(-50%, -50%) \" + \"translate(\".concat(displayPos.map(function (v) {\n return \"\".concat(v, \"px\");\n }).join(\", \"), \")\");\n this.displayElement.innerHTML = \"\".concat(dragPosFormat(guidePos));\n }\n\n var target = datas.target;\n target.setAttribute(\"data-pos\", guidePos);\n target.style.transform = \"\".concat(this.getTranslateName(), \"(\").concat(nextPos + guidesOffset * zoom, \"px)\");\n }\n\n return nextPos;\n };\n\n __proto.getTranslateName = function () {\n return this.props.type === \"horizontal\" ? \"translateY\" : \"translateX\";\n };\n\n __proto._startDragScroll = function (e) {\n var _this = this;\n\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var datas = e.datas;\n var dragScroll = new DragScroll();\n datas.dragScroll = dragScroll;\n dragScroll.on(\"scroll\", function (_a) {\n var _b, _c;\n\n var container = _a.container,\n direction = _a.direction;\n /**\n * If scroll can be triggered through drag, the `requestScroll` event is fired.\n * @memberof Guides\n * @event requestScroll\n * @param {OnRequestScroll} - Parameters for the `requestScroll` event\n */\n\n (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, {\n container: container,\n direction: direction\n });\n }).on(\"move\", function (_a) {\n var offsetX = _a.offsetX,\n offsetY = _a.offsetY,\n inputEvent = _a.inputEvent;\n\n _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);\n });\n dragScroll.dragStart(e, {\n container: scrollOptions.container\n });\n };\n\n __proto._dragScroll = function (e) {\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var dragScroll = e.datas.dragScroll;\n dragScroll.drag(e, scrollOptions);\n };\n\n __proto._endDragScroll = function (e) {\n var _a;\n\n (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd();\n e.datas.dragScroll = null;\n };\n\n __proto._setZoom = function (zooms) {\n var nextZoom = zooms.zoom,\n nextGuidesZoom = zooms.guidesZoom;\n var hasZoom = !!this.props.zoom;\n var hasGuidesZoom = !!this.props.guidesZoom;\n\n if (hasGuidesZoom) {\n if (nextGuidesZoom) {\n this._guidesZoom = nextGuidesZoom;\n }\n } else {\n if (nextGuidesZoom) {\n this._zoom = nextGuidesZoom;\n this._guidesZoom = nextGuidesZoom;\n }\n\n if (nextZoom) {\n this._guidesZoom = nextZoom;\n }\n }\n\n if (nextZoom) {\n this._zoom = nextZoom;\n }\n };\n\n Guides.defaultProps = {\n className: \"\",\n type: \"horizontal\",\n zoom: 1,\n guidesZoom: 0,\n style: {},\n snapThreshold: 5,\n snaps: [],\n digit: 0,\n onClickRuler: function () {},\n onChangeGuides: function () {},\n onRequestScroll: function () {},\n onDragStart: function () {},\n onDrag: function () {},\n onDragEnd: function () {},\n displayDragPos: false,\n dragPosFormat: function (v) {\n return v;\n },\n defaultGuides: [],\n lockGuides: false,\n showGuides: true,\n guideStyle: {},\n dragGuideStyle: {},\n guidePosStyle: {},\n defaultGuidesPos: 0\n };\n return Guides;\n}(PureComponent);\n\nexport default Guides;\nexport { EVENTS, METHODS, PROPERTIES };\n//# sourceMappingURL=guides.esm.js.map\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\n\nexport default Guides;\n","import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__assign","assign","t","s","i","n","arguments","length","apply","this","__spreadArray","to","from","pack","ar","l","slice","concat","prefix","classNames","_i","name","ADDER","GUIDES","GUIDE","DRAGGING","DISPLAY_DRAG","GUIDES_CSS","PROPERTIES","PROPERTIES$1","GuidesElement","Guides","_super","__extends","TypeError","String","__","constructor","props","_this","state","guides","scrollPos","managerRef","createRef","guideElements","_isFirstMove","_zoom","_guidesZoom","_observer","onDragStart","e","datas","inputEvent","movePos","dragElement","target","gesto","isFlag","stopPropagation","preventDefault","_startDragScroll","_onDrag","nextPos","onDrag","_dragScroll","_endDragScroll","onDragEnd","isDouble","distX","distY","pos","_a","onChangeGuides","displayDragPos","digit","lockGuides","guidesOffset","zoom","guidePos","parseFloat","toFixed","baseScrollPos","displayElement","style","cssText","fromRuler","onClickRuler","indexOf","setState","index","isAdd","isRemove","isChange","index_1","getAttribute","isRemove_1","isChange_1","guideIndex","splice","nextGuides","_onCheck","resize","defaultGuides","defaultGuidesPos","create","__proto","render","className","type","guidesZoom","rulerStyle","cspNonce","dragGuideStyle","_b","guidePosStyle","translateName","getTranslateName","rulerProps","forEach","createElement","ref","Ruler","transform","renderGuides","drawRuler","options","ruler","draw","showGuides","guideStyle","displayGuidePos","guidePosFormat","dragPosFormat","v","map","key","data-index","data-pos","componentDidMount","Gesto","current","container","document","body","on","stop","canvasElement","guidesElement","isHorizontal","originRect","originElement","getBoundingClientRect","matrix","getDistElementMatrix","offsetPos","calculateMatrixDist","clientX","left","clientY","top","isLockAdd","offsetLeft","offsetTop","isLockRemove","isLockChange","adderElement","useResizeObserver","ResizeObserver","observe","box","getRulerElement","componentWillUnmount","unset","disconnect","componentDidUpdate","prevProps","loadGuides","getGuides","scrollGuides","nextZoom","_setZoom","el","display","zoomTo","nextGuidesZoom","scroll","getRulerScrollPos","getGuideScrollPos","getElement","getScrollPos","snaps","snapThreshold","matrixPos","offsetX","offsetY","guidesZoomOffset","Math","round","guideSnaps","sort","a","abs","join","innerHTML","setAttribute","dragScroll","scrollOptions","DragScroll","_c","direction","onRequestScroll","scrollBy","dragStart","drag","dragEnd","zooms","defaultProps","PureComponent","GUIDES_PROPERTIES","METHODS","EVENTS","React","ReactGuides","selfElement","events","trigger","warpSelf","_warp","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","forceUpdate","parentElement","removeChild","Properties","property","args","self","getInnerGuides","defineProperty","get","set","value","enumerable","configurable","EventEmitter","others"],"mappings":"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"} \ No newline at end of file diff --git a/release/0.29.2/doc/EventEmitter.html b/release/0.29.2/doc/EventEmitter.html new file mode 100644 index 0000000..334abb9 --- /dev/null +++ b/release/0.29.2/doc/EventEmitter.html @@ -0,0 +1,2766 @@ + + + + + EventEmitter - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

EventEmitter

+ + + + + + + +
+ +
+ +

+ EventEmitter +

+ +
Implement EventEmitter on object or component.
+ + +
+ +
+
+ + + + +

Constructor

+ + +

new EventEmitter()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + +

Methods

+ + + + + + +

trigger<Name extends keyof Events>(eventName, paramopt) → {boolean}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Fires an event to call listeners. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
eventName + + +Name +| + +... + + + + + + Event name
param? + + +TargetParam<any> +| + +... + + + + + + {} + + Event parameter
+ + + + +

+ trigger<Name extends keyof Events, Param = Events[Name]>(eventName) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + + extends TargetParam<Param> ? Name : never + + + +
+ +
+ +

+ trigger<Name extends keyof Events, Param = Events[Name]>(eventName, param) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
param + + +TargetParam<Param> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+
+
+const emitter = new EventEmitter();
+
+emitter.on("a", e => {
+});
+
+// emit
+emitter.trigger("a", {
+  a: 1,
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ If false, stop the event. +
+ + + +
+
+ Type +
+
+ +boolean + + +
+
+ + + + + + + + + +

trigger<Name extends keyof Events>(eventName, paramopt) → {boolean}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Fires an event to call listeners. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
eventName + + +Name +| + +... + + + + + + Event name
param? + + +TargetParam<any> +| + +... + + + + + + {} + + Event parameter
+ + + + +

+ trigger<Name extends keyof Events, Param = Events[Name]>(eventName) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + + extends TargetParam<Param> ? Name : never + + + +
+ +
+ +

+ trigger<Name extends keyof Events, Param = Events[Name]>(eventName, param) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
param + + +TargetParam<Param> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+
+
+const emitter = new EventEmitter();
+
+emitter.on("a", e => {
+});
+
+
+emitter.emit("a", {
+  a: 1,
+});
+
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ If false, stop the event. +
+ + + +
+
+ Type +
+
+ +boolean + + +
+
+ + + + + + + + + +

once<Name extends keyof Events & string, Param = Events[Name]>(eventName, listeneropt) → {Promise<OnEvent<Param, this>>}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Add a disposable listener and Use promise to the registered event. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + + Name of the event to be added
listener? + + +EventListener<Param, this> + + + + disposable listener function of the event to be added
+ + + + + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+cosnt emitter = new EventEmitter();
+
+// Add a disposable listener in "a" event
+emitter.once("a", () => {
+});
+
+// Use Promise
+emitter.once("a").then(e => {
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +Promise<OnEvent<Param, this>> + + +
+
+ + + + + + + + + +

on(eventName, listeneropt) → {this}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Add a listener to the registered event. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +string | object +| + +... + + + + Name of the event to be added
listener? + + +EventListener<Events[any], this> +| + +... + + + + listener function of the event to be added
+ + + + +

+ on<Name extends keyof Events, Param = Events[Name]>(eventName, listener) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
listener + + +EventListener<Param, this> + + + +
+ +
+ +

+ on(events) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
events + + +EventHash<Events, this> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+cosnt emitter = new EventEmitter();
+
+// Add listener in "a" event
+emitter.on("a", () => {
+});
+// Add listeners
+emitter.on({
+ a: () => {},
+ b: () => {},
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +this + + +
+
+ + + + + + + + + +

off(eventNameopt, listeneropt) → {this}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Remove listeners registered in the event target. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName? + + +string | object +| + +... + + + + Name of the event to be removed
listener? + + +EventListener<Events[any], this> +| + +... + + + + listener function of the event to be removed
+ + + + +

+ off<Name extends keyof Events, Param = Events[Name]>(eventName, listener) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName? + + +Name + + + +
listener? + + +EventListener<Param, this> + + + +
+ +
+ +

+ off(events) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
events + + +EventHash<Events, this> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+cosnt emitter = new EventEmitter();
+
+// Remove all listeners.
+emitter.off();
+
+// Remove all listeners in "A" event.
+emitter.off("a");
+
+
+// Remove "listener" listener in "a" event.
+emitter.off("a", listener);
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +this + + +
+
+ + + + + + + + + +

emit(eventName, paramopt) → {boolean}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Fires an event to call listeners. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
eventName + + +string +| + +... + + + + + + Event name
param? + + +TargetParam<any> +| + +... + + + + + + {} + + Event parameter
+ + + + +

+ emit<Name extends keyof Events, Param = Events[Name]>(eventName) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + + extends Param ? Name : never + + + +
+ +
+ +

+ emit<Name extends keyof Events, Param = Events[Name]>(eventName, param) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
param + + +TargetParam<Param> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+
+
+const emitter = new EventEmitter();
+
+emitter.on("a", e => {
+});
+
+
+emitter.emit("a", {
+  a: 1,
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ If false, stop the event. +
+ + + +
+
+ Type +
+
+ +boolean + + +
+
+ + + + + + + + +

Type Definitions

+ + + +

EmitterParam<Target = any>

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ type + + +
+ + + + + + + +
+ + type: +string + + + +
+ + +
+ +
+ + +
+ +
+ +
+ currentTarget + + +
+ + + + + + + +
+ + currentTarget: +Target + + + +
+ + +
+ +
+ + +
+ +
+ +
+ stop + + +
+ + + + + + + +
+ + stop: +() => void + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

EventHash<Events, Target>

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + +
Type:
+
    +
  • + +Partial<[Key extends keyof Events]: EventListener<Events[Key], Target>> + + +
    • +
+ + + + + + + + +

EventInfo

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ listener + + +
+ + + + + + + +
+ + listener: +EventListener<any, any> + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

EventListener<Param, Target>

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + +
Type:
+
    +
  • + +(e: OnEvent<Param, Target>) => any + + +
    • +
+ + + + + + + + +

EventOptions

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ once + + +
+ + + + + + + +
+ + once: +boolean + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnEvent<Param, Target = any>

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + +
Type:
+ + + + + + + + + +

TargetParam<Param>

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + +
Type:
+ + + + + + + + + + + +
+ +
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + \ No newline at end of file diff --git a/release/0.29.2/doc/Guides.html b/release/0.29.2/doc/Guides.html new file mode 100644 index 0000000..0a089f5 --- /dev/null +++ b/release/0.29.2/doc/Guides.html @@ -0,0 +1,12323 @@ + + + + + Guides - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

Guides

+ + + + + + + +
+ +
+ +

+ Guides +

+ + +
+ +
+
+ + + + + +

new Guides(container, optionsopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
container + + +HTMLElement + + + + + + guides' container
options? + + +Partial<Guides.GuidesOptions> + + + + + + {} + + guides' options
+ + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + +

Methods

+ + + + + + +

trigger<Name extends keyof Events>(eventName, paramopt) → {boolean}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + +
Overrides:
+
+ + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Fires an event to call listeners. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
eventName + + +Name +| + +... + + + + + + Event name
param? + + +TargetParam<any> +| + +... + + + + + + {} + + Event parameter
+ + + + +

+ trigger<Name extends keyof Events, Param = Events[Name]>(eventName) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + + extends TargetParam<Param> ? Name : never + + + +
+ +
+ +

+ trigger<Name extends keyof Events, Param = Events[Name]>(eventName, param) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
param + + +TargetParam<Param> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+
+
+const emitter = new EventEmitter();
+
+emitter.on("a", e => {
+});
+
+
+emitter.emit("a", {
+  a: 1,
+});
+
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ If false, stop the event. +
+ + + +
+
+ Type +
+
+ +boolean + + +
+
+ + + + + + + + + +

setState(state, callbackopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
state + + +Partial<GuidesOptions> + + + +
callback? + + +() => void + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

scrollGuides(pos, nextZoomopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Scroll the positions of the guidelines opposite the ruler. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
pos + + +number + + + + + +
nextZoom? + + + + + + + + + this._guidesZoom + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

scroll(pos, nextZoomopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Scroll the position of the ruler. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
pos + + +number + + + + + +
nextZoom? + + + + + + + + + this._zoom + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

resize(nextZoomopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Recalculate the size of the ruler. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
nextZoom? + + + + + + + + + this._zoom + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

once<Name extends keyof Events & string, Param = Events[Name]>(eventName, listeneropt) → {Promise<OnEvent<Param, this>>}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + +
Inherited From:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Add a disposable listener and Use promise to the registered event. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + + Name of the event to be added
listener? + + +EventListener<Param, this> + + + + disposable listener function of the event to be added
+ + + + + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+cosnt emitter = new EventEmitter();
+
+// Add a disposable listener in "a" event
+emitter.once("a", () => {
+});
+
+// Use Promise
+emitter.once("a").then(e => {
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +Promise<OnEvent<Param, this>> + + +
+
+ + + + + + + + + +

on(eventName, listeneropt) → {this}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + +
Inherited From:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Add a listener to the registered event. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +string | object +| + +... + + + + Name of the event to be added
listener? + + +EventListener<Events[any], this> +| + +... + + + + listener function of the event to be added
+ + + + +

+ on<Name extends keyof Events, Param = Events[Name]>(eventName, listener) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
listener + + +EventListener<Param, this> + + + +
+ +
+ +

+ on(events) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
events + + +EventHash<Events, this> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+cosnt emitter = new EventEmitter();
+
+// Add listener in "a" event
+emitter.on("a", () => {
+});
+// Add listeners
+emitter.on({
+ a: () => {},
+ b: () => {},
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +this + + +
+
+ + + + + + + + + +

off(eventNameopt, listeneropt) → {this}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + +
Inherited From:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Remove listeners registered in the event target. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName? + + +string | object +| + +... + + + + Name of the event to be removed
listener? + + +EventListener<Events[any], this> +| + +... + + + + listener function of the event to be removed
+ + + + +

+ off<Name extends keyof Events, Param = Events[Name]>(eventName, listener) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName? + + +Name + + + +
listener? + + +EventListener<Param, this> + + + +
+ +
+ +

+ off(events) + → {this} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
events + + +EventHash<Events, this> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+cosnt emitter = new EventEmitter();
+
+// Remove all listeners.
+emitter.off();
+
+// Remove all listeners in "A" event.
+emitter.off("a");
+
+
+// Remove "listener" listener in "a" event.
+emitter.off("a", listener);
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +this + + +
+
+ + + + + + + + + +

loadGuides(guides)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Load the current guidelines. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
guides + + +number[] + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

getRulerElement()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Get Ruler DOM Element +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

getGuides() → {number[]}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Get current guidelines. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +number[] + + +
+
+ + + + + + + + + +

getElement()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Get Guides DOM Element +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

forceUpdate(callbackopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
callback? + + +() => void + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

emit(eventName, paramopt) → {boolean}

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + +
Inherited From:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Fires an event to call listeners. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
eventName + + +string +| + +... + + + + + + Event name
param? + + +TargetParam<any> +| + +... + + + + + + {} + + Event parameter
+ + + + +

+ emit<Name extends keyof Events, Param = Events[Name]>(eventName) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + + extends Param ? Name : never + + + +
+ +
+ +

+ emit<Name extends keyof Events, Param = Events[Name]>(eventName, param) + → {boolean} +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
eventName + + +Name + + + +
param + + +TargetParam<Param> + + + +
+ +
+ + + +
Example
+ + 
import EventEmitter from "@scena/event-emitter";
+
+
+const emitter = new EventEmitter();
+
+emitter.on("a", e => {
+});
+
+
+emitter.emit("a", {
+  a: 1,
+});
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ If false, stop the event. +
+ + + +
+
+ Type +
+
+ +boolean + + +
+
+ + + + + + + + + +

destroy()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ destroy guides +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

(static) zoomTo(nextZoom, nextGuidesZoomopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + +
Since:
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Set to the next zoom. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
nextZoom + + +number + + + + + + next zoom
nextGuidesZoom? + + + + + + + + + nextZoom + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +

Type Definitions

+ + + +

GuideOptions

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ type + optional + +
+ + + + + + +
+ Default Value: "horizontal" + +
+ + +
+ + type?: +"horizontal" | "vertical" + + + +
+ + +
+ ruler's direction + +
+ + +
+ +
+ +
+ width + optional + +
+ + + + + + +
+ Default Value: target's offsetWidth + +
+ + +
+ + width?: +number + + + +
+ + +
+ ruler's width + +
+ + +
+ +
+ +
+ height + optional + +
+ + + + + + +
+ Default Value: target's offsetHeight + +
+ + +
+ + height?: +number + + + +
+ + +
+ ruler's height + +
+ + +
+ +
+ +
+ unit + optional + +
+ + + + + + +
+ Default Value: 50 + +
+ + +
+ + unit?: +number + + + +
+ + +
+ main scale unit + +
+ + Examples +
+ + 
```
+1px (Default) zoom: 1, unit: 50 (every 50px)
+1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+```
+ +
+ + +
+ +
+ +
+ zoom + optional + +
+ + + + + + +
+ Default Value: 1 + +
+ + +
+ + zoom?: +number + + + +
+ + +
+ zoom + +
+ + Examples +
+ + 
```
+1px (Default) zoom: 1, unit: 50 (every 50px)
+1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+```
+ +
+ + +
+ +
+ +
+ direction + optional + +
+ + + + + + +
+ Default Value: "end" + +
+ + +
+ + direction?: +"start" | "center" | "end" + + + +
+ + +
+ line's direction (align) + +
+ + +
+ +
+ +
+ textAlign + optional + +
+ + + + + + +
+ Default Value: "start" + +
+ + +
+ + textAlign?: +"left" | "center" | "right" + + + +
+ + +
+ text align + +
+ + +
+ +
+ +
+ font + optional + +
+ + + + + + +
+ Default Value: "10px sans-serif" + +
+ + +
+ + font?: +string + + + +
+ + +
+ font and size + +
+ + +
+ +
+ +
+ segment + optional + +
+ + + + + + +
+ Default Value: 10 + +
+ + +
+ + segment?: +number + + + +
+ + +
+ Number of areas to divide between two main lines + +
+ + +
+ +
+ +
+ mainLineSize + optional + +
+ + + + + + +
+ Default Value: "100%" + +
+ + +
+ + mainLineSize?: +string | number + + + +
+ + +
+ main line size + +
+ + +
+ +
+ +
+ longLineSize + optional + +
+ + + + + + +
+ Default Value: 10 + +
+ + +
+ + longLineSize?: +string | number + + + +
+ + +
+ long line size + +
+ + +
+ +
+ +
+ shortLineSize + optional + +
+ + + + + + +
+ Default Value: 7 + +
+ + +
+ + shortLineSize?: +string | number + + + +
+ + +
+ short line size + +
+ + +
+ +
+ +
+ lineOffset + optional + +
+ + + + + + +
+ Default Value: [0, 0] + +
+ + +
+ + lineOffset?: +number[] + + + +
+ + +
+ line's position offset + +
+ + +
+ +
+ +
+ textOffset + optional + +
+ + + + + + +
+ Default Value: [0, 0] + +
+ + +
+ + textOffset?: +number[] + + + +
+ + +
+ text's position offset + +
+ + +
+ +
+ +
+ negativeRuler + optional + +
+ + + + + + +
+ Default Value: true + +
+ + +
+ + negativeRuler?: +boolean + + + +
+ + +
+ Whether to display the ruler in the negative direction. + +
+ + +
+ +
+ +
+ range + optional + +
+ + + + + + +
+ Default Value: [-Infinity, Infinity] + +
+ + +
+ + range?: +[number, number] + + + +
+ + +
+ The range to show the ruler's scales + +
+ + +
+ +
+ +
+ scrollPos + optional + +
+ + + + + + +
+ Default Value: undefined + +
+ + +
+ + scrollPos?: +number + + + +
+ + +
+ you can set scroll position by prop. +If you use the scrollPos prop, you can't use the scroll method. + +
+ + +
+ +
+ +
+ defaultScrollPos + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + defaultScrollPos?: +number + + + +
+ + +
+ you can set scroll position by prop for init. +don't use `scrollPos` prop + +
+ + +
+ +
+ +
+ style + optional + +
+ + + + + + + +
+ + style?: +IObject<any> + + + +
+ + +
+ ruler canvas style + +
+ + +
+ +
+ +
+ backgroundColor + optional + +
+ + + + + + +
+ Default Value: "#333333" + +
+ + +
+ + backgroundColor?: +string + + + +
+ + +
+ ruler's background color + +
+ + +
+ +
+ +
+ rangeBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "transparent" + +
+ + +
+ + rangeBackgroundColor?: +string + + + +
+ + +
+ background color within range in ruler + +
+ + +
+ +
+ +
+ lineColor + optional + +
+ + + + + + +
+ Default Value: "#777777" + +
+ + +
+ + lineColor?: +string + + + +
+ + +
+ ruler's line color + +
+ + +
+ +
+ +
+ textColor + optional + +
+ + + + + + +
+ Default Value: "#ffffff" + +
+ + +
+ + textColor?: +string + + + +
+ + +
+ ruler's text color + +
+ + +
+ +
+ +
+ textBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "transparent" + +
+ + +
+ + textBackgroundColor?: +string + + + +
+ + +
+ The background color that wraps the text + +
+ + +
+ +
+ +
+ textFormat + optional + +
+ + + + + + +
+ Default Value: ownself + +
+ + +
+ + textFormat?: +(scale: number) => string + + + +
+ + +
+ text foramt + +
+ + +
+ +
+ +
+ marks + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + marks?: +number[] + + + +
+ + +
+ positions to mark + +
+ + +
+ +
+ +
+ markColor + optional + +
+ + + + + + +
+ Default Value: "#f55" + + +
+ + +
+ + markColor?: +string + + + +
+ + +
+ +
+ + +
+ +
+ +
+ lineWidth + optional + +
+ + + + + + +
+ Default Value: 1 + +
+ + +
+ + lineWidth?: +number + + + +
+ + +
+ Ruler's line width + +
+ + +
+ +
+ +
+ warpSelf + optional + +
+ + + + + + + +
+ + warpSelf?: +boolean + + + +
+ + +
+ Whether to warp self + +
+ + +
+ +
+ +
+ selectedRanges + optional + +
+ + + + + + + +
+ + selectedRanges?: +number[][] + + + +
+ + +
+ You can paint the selected area(selectedranges) with the `selectedBackgroundColor` color. + +
+ + +
+ +
+ +
+ selectedBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "#555555" + +
+ + +
+ + selectedBackgroundColor?: +string + + + +
+ + +
+ background color within selected range in ruler with `selectedRanges` area + +
+ + +
+ +
+ +
+ selectedRangesText + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: false + +
+ + +
+ + selectedRangesText?: +boolean + + + +
+ + +
+ Text is displayed in the selected ranges. If it overlaps existing text, only the selected range text is visible. + +
+ + +
+ +
+ +
+ selectedRangesTextOffset + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: "0, 0" + +
+ + +
+ + selectedRangesTextOffset?: +number[] + + + +
+ + +
+ Position offset of text in selected ranges + +
+ + +
+ +
+ +
+ selectedRangesTextColor + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: "#44aaff" + +
+ + +
+ + selectedRangesTextColor?: +string + + + +
+ + +
+ Color of text in selected ranges + +
+ + +
+ +
+ +
+ defaultPixelScale + optional + +
+ + + + + + +
+ Default Value: 2 + +
+ + +
+ + defaultPixelScale?: +number + + + +
+ + +
+ Scale value of canvase when device high density is 1. +Less than 2 may cause pixels to blur. +If device high density is greater than 1, it is forcibly set to 3. + +
+ + +
+ +
+ +
+ useResizeObserver + optional + +
+ + + + + + + +
+ + useResizeObserver?: +boolean + + + +
+ + +
+ Whether to use the resize observer. When the size changes, the resize method is automatically called. + +
+ + +
+ +
+ +
+ className + optional + +
+ + + + + + +
+ Default Value: "" + +
+ + +
+ + className?: +string + + + +
+ + +
+ guides' class name + +
+ + +
+ +
+ +
+ rulerStyle + optional + +
+ + + + + + +
+ Default Value: "width 100%, height: 100%" + +
+ + +
+ + rulerStyle?: +IObject<any> + + + +
+ + +
+ ruler's css style + +
+ + +
+ +
+ +
+ snapThreshold + optional + +
+ + + + + + +
+ Default Value: 5 + +
+ + +
+ + snapThreshold?: +number + + + +
+ + +
+ Interval to snap + +
+ + +
+ +
+ +
+ snaps + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + snaps?: +number[] + + + +
+ + +
+ Positions to snap + +
+ + +
+ +
+ +
+ displayDragPos + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + displayDragPos?: +boolean + + + +
+ + +
+ Whether to show the moving pos when dragging + +
+ + +
+ +
+ +
+ guidesZoom + optional + +
+ + + +
+ Since: + 0.29.0 + + +
+ + + + +
+ Default Value: zoom + +
+ + +
+ + guidesZoom?: +number + + + +
+ + +
+ guides zoom(side zoom). If not set, it is the same as `zoom`. + +
+ + +
+ +
+ +
+ cspNonce + optional + +
+ + + + + + + +
+ + cspNonce?: +string + + + +
+ + +
+ csp nonce + +
+ + +
+ +
+ +
+ dragPosFormat + optional + +
+ + + + + + +
+ Default Value: self + +
+ + +
+ + dragPosFormat?: +(value: number) => string | number + + + +
+ + +
+ Format of drag pos + +
+ + +
+ +
+ +
+ defaultGuides + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + defaultGuides?: +number[] + + + +
+ + +
+ default guidelines + +
+ + +
+ +
+ +
+ defaultGuidesPos + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + defaultGuidesPos?: +number + + + +
+ + +
+ default guide pos for init + +
+ + +
+ +
+ +
+ showGuides + optional + +
+ + + + + + +
+ Default Value: true + +
+ + +
+ + showGuides?: +boolean + + + +
+ + +
+ Whether to show guidelines + +
+ + +
+ +
+ +
+ lockGuides + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + lockGuides?: +boolean | Array<"add" | "change" | "remove"> + + + +
+ + +
+ Whether to lock add/remove/change functions via drag/click of guides + +
+ + +
+ +
+ +
+ digit + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + digit?: +number + + + +
+ + +
+ pos digit of guidelines + +
+ + +
+ +
+ +
+ guideStyle + optional + +
+ + + + + + +
+ Default Value: "{}" + +
+ + +
+ + guideStyle?: +Record<string, any> + + + +
+ + +
+ CSS style objects for guide elements + +
+ + +
+ +
+ +
+ dragGuideStyle + optional + +
+ + + + + + +
+ Default Value: "{}" + +
+ + +
+ + dragGuideStyle?: +Record<string, any> + + + +
+ + +
+ CSS style objects for drag guide element + +
+ + +
+ +
+ +
+ displayGuidePos + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + displayGuidePos?: +boolean + + + +
+ + +
+ Whether to show the guide pos text + +
+ + +
+ +
+ +
+ guidePosFormat + optional + +
+ + + + + + +
+ Default Value: dragPosFormat + +
+ + +
+ + guidePosFormat?: +(value: number) => string | number + + + +
+ + +
+ Format of displayed guide pos + +
+ + +
+ +
+ +
+ guidePosStyle + optional + +
+ + + + + + + +
+ + guidePosStyle?: +IObject<any> + + + +
+ + +
+ CSS style objects for displayed guide pos text element + +
+ + +
+ +
+ +
+ scrollOptions + optional + +
+ + + + + + +
+ Default Value: null + +
+ + +
+ + scrollOptions?: +DragScrollOptions | null + + + +
+ + +
+ Set the scroll options, time, etc. to automatically scroll by dragging. + +
+ + +
+ +
+ +
+ guidesOffset + optional + +
+ + + +
+ Since: + 0.22.0 + + +
+ + + + +
+ Default Value: 0 + +
+ + +
+ + guidesOffset?: +number + + + +
+ + +
+ Numerical value of how far away from the guideline position + +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

GuidesEvents

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ changeGuides + + +
+ + + + + + + +
+ + changeGuides: +OnChangeGuides + + + +
+ + +
+ +
+ + +
+ +
+ +
+ requestScroll + + +
+ + + + + + + +
+ + requestScroll: +OnRequestScroll + + + +
+ + +
+ +
+ + +
+ +
+ +
+ dragStart + + +
+ + + + + + + +
+ + dragStart: +OnDragStart + + + +
+ + +
+ +
+ + +
+ +
+ +
+ drag + + +
+ + + + + + + +
+ + drag: +OnDrag + + + +
+ + +
+ +
+ + +
+ +
+ +
+ dragEnd + + +
+ + + + + + + +
+ + dragEnd: +OnDragEnd + + + +
+ + +
+ +
+ + +
+ +
+ +
+ clickRuler + + +
+ + + + + + + +
+ + clickRuler: +OnClickRuler + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

GuidesInterface

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ getGuides + + +
+ + + + + + + +
+ + getGuides: +() => number[] + + + +
+ + +
+ +
+ + +
+ +
+ +
+ scroll + + +
+ + + + + + + +
+ + scroll: +(pos: number) => void + + + +
+ + +
+ +
+ + +
+ +
+ +
+ scrollGuides + + +
+ + + + + + + +
+ + scrollGuides: +(pos: number) => void + + + +
+ + +
+ +
+ + +
+ +
+ +
+ drawRuler + + +
+ + + + + + + +
+ + drawRuler: +(options: DrawRulerOptions) => void + + + +
+ + +
+ +
+ + +
+ +
+ +
+ loadGuides + + +
+ + + + + + + +
+ + loadGuides: +(guides: number[]) => void + + + +
+ + +
+ +
+ + +
+ +
+ +
+ resize + + +
+ + + + + + + +
+ + resize: +() => void + + + +
+ + +
+ +
+ + +
+ +
+ +
+ getElement + + +
+ + + + + + + +
+ + getElement: +() => HTMLElement + + + +
+ + +
+ +
+ + +
+ +
+ +
+ getRulerElement + + +
+ + + + + + + +
+ + getRulerElement: +() => HTMLCanvasElement + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

GuidesOptions

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ type + optional + +
+ + + + + + +
+ Default Value: "horizontal" + +
+ + +
+ + type?: +"horizontal" | "vertical" + + + +
+ + +
+ ruler's direction + +
+ + +
+ +
+ +
+ width + optional + +
+ + + + + + +
+ Default Value: target's offsetWidth + +
+ + +
+ + width?: +number + + + +
+ + +
+ ruler's width + +
+ + +
+ +
+ +
+ height + optional + +
+ + + + + + +
+ Default Value: target's offsetHeight + +
+ + +
+ + height?: +number + + + +
+ + +
+ ruler's height + +
+ + +
+ +
+ +
+ unit + optional + +
+ + + + + + +
+ Default Value: 50 + +
+ + +
+ + unit?: +number + + + +
+ + +
+ main scale unit + +
+ + Examples +
+ + 
```
+1px (Default) zoom: 1, unit: 50 (every 50px)
+1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+```
+ +
+ + +
+ +
+ +
+ zoom + optional + +
+ + + + + + +
+ Default Value: 1 + +
+ + +
+ + zoom?: +number + + + +
+ + +
+ zoom + +
+ + Examples +
+ + 
```
+1px (Default) zoom: 1, unit: 50 (every 50px)
+1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+```
+ +
+ + +
+ +
+ +
+ direction + optional + +
+ + + + + + +
+ Default Value: "end" + +
+ + +
+ + direction?: +"start" | "center" | "end" + + + +
+ + +
+ line's direction (align) + +
+ + +
+ +
+ +
+ textAlign + optional + +
+ + + + + + +
+ Default Value: "start" + +
+ + +
+ + textAlign?: +"left" | "center" | "right" + + + +
+ + +
+ text align + +
+ + +
+ +
+ +
+ font + optional + +
+ + + + + + +
+ Default Value: "10px sans-serif" + +
+ + +
+ + font?: +string + + + +
+ + +
+ font and size + +
+ + +
+ +
+ +
+ segment + optional + +
+ + + + + + +
+ Default Value: 10 + +
+ + +
+ + segment?: +number + + + +
+ + +
+ Number of areas to divide between two main lines + +
+ + +
+ +
+ +
+ mainLineSize + optional + +
+ + + + + + +
+ Default Value: "100%" + +
+ + +
+ + mainLineSize?: +string | number + + + +
+ + +
+ main line size + +
+ + +
+ +
+ +
+ longLineSize + optional + +
+ + + + + + +
+ Default Value: 10 + +
+ + +
+ + longLineSize?: +string | number + + + +
+ + +
+ long line size + +
+ + +
+ +
+ +
+ shortLineSize + optional + +
+ + + + + + +
+ Default Value: 7 + +
+ + +
+ + shortLineSize?: +string | number + + + +
+ + +
+ short line size + +
+ + +
+ +
+ +
+ lineOffset + optional + +
+ + + + + + +
+ Default Value: [0, 0] + +
+ + +
+ + lineOffset?: +number[] + + + +
+ + +
+ line's position offset + +
+ + +
+ +
+ +
+ textOffset + optional + +
+ + + + + + +
+ Default Value: [0, 0] + +
+ + +
+ + textOffset?: +number[] + + + +
+ + +
+ text's position offset + +
+ + +
+ +
+ +
+ negativeRuler + optional + +
+ + + + + + +
+ Default Value: true + +
+ + +
+ + negativeRuler?: +boolean + + + +
+ + +
+ Whether to display the ruler in the negative direction. + +
+ + +
+ +
+ +
+ range + optional + +
+ + + + + + +
+ Default Value: [-Infinity, Infinity] + +
+ + +
+ + range?: +[number, number] + + + +
+ + +
+ The range to show the ruler's scales + +
+ + +
+ +
+ +
+ scrollPos + optional + +
+ + + + + + +
+ Default Value: undefined + +
+ + +
+ + scrollPos?: +number + + + +
+ + +
+ you can set scroll position by prop. +If you use the scrollPos prop, you can't use the scroll method. + +
+ + +
+ +
+ +
+ defaultScrollPos + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + defaultScrollPos?: +number + + + +
+ + +
+ you can set scroll position by prop for init. +don't use `scrollPos` prop + +
+ + +
+ +
+ +
+ style + optional + +
+ + + + + + + +
+ + style?: +IObject<any> + + + +
+ + +
+ ruler canvas style + +
+ + +
+ +
+ +
+ backgroundColor + optional + +
+ + + + + + +
+ Default Value: "#333333" + +
+ + +
+ + backgroundColor?: +string + + + +
+ + +
+ ruler's background color + +
+ + +
+ +
+ +
+ rangeBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "transparent" + +
+ + +
+ + rangeBackgroundColor?: +string + + + +
+ + +
+ background color within range in ruler + +
+ + +
+ +
+ +
+ lineColor + optional + +
+ + + + + + +
+ Default Value: "#777777" + +
+ + +
+ + lineColor?: +string + + + +
+ + +
+ ruler's line color + +
+ + +
+ +
+ +
+ textColor + optional + +
+ + + + + + +
+ Default Value: "#ffffff" + +
+ + +
+ + textColor?: +string + + + +
+ + +
+ ruler's text color + +
+ + +
+ +
+ +
+ textBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "transparent" + +
+ + +
+ + textBackgroundColor?: +string + + + +
+ + +
+ The background color that wraps the text + +
+ + +
+ +
+ +
+ textFormat + optional + +
+ + + + + + +
+ Default Value: ownself + +
+ + +
+ + textFormat?: +(scale: number) => string + + + +
+ + +
+ text foramt + +
+ + +
+ +
+ +
+ marks + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + marks?: +number[] + + + +
+ + +
+ positions to mark + +
+ + +
+ +
+ +
+ markColor + optional + +
+ + + + + + +
+ Default Value: "#f55" + + +
+ + +
+ + markColor?: +string + + + +
+ + +
+ +
+ + +
+ +
+ +
+ lineWidth + optional + +
+ + + + + + +
+ Default Value: 1 + +
+ + +
+ + lineWidth?: +number + + + +
+ + +
+ Ruler's line width + +
+ + +
+ +
+ +
+ warpSelf + optional + +
+ + + + + + + +
+ + warpSelf?: +boolean + + + +
+ + +
+ Whether to warp self + +
+ + +
+ +
+ +
+ selectedRanges + optional + +
+ + + + + + + +
+ + selectedRanges?: +number[][] + + + +
+ + +
+ You can paint the selected area(selectedranges) with the `selectedBackgroundColor` color. + +
+ + +
+ +
+ +
+ selectedBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "#555555" + +
+ + +
+ + selectedBackgroundColor?: +string + + + +
+ + +
+ background color within selected range in ruler with `selectedRanges` area + +
+ + +
+ +
+ +
+ selectedRangesText + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: false + +
+ + +
+ + selectedRangesText?: +boolean + + + +
+ + +
+ Text is displayed in the selected ranges. If it overlaps existing text, only the selected range text is visible. + +
+ + +
+ +
+ +
+ selectedRangesTextOffset + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: "0, 0" + +
+ + +
+ + selectedRangesTextOffset?: +number[] + + + +
+ + +
+ Position offset of text in selected ranges + +
+ + +
+ +
+ +
+ selectedRangesTextColor + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: "#44aaff" + +
+ + +
+ + selectedRangesTextColor?: +string + + + +
+ + +
+ Color of text in selected ranges + +
+ + +
+ +
+ +
+ defaultPixelScale + optional + +
+ + + + + + +
+ Default Value: 2 + +
+ + +
+ + defaultPixelScale?: +number + + + +
+ + +
+ Scale value of canvase when device high density is 1. +Less than 2 may cause pixels to blur. +If device high density is greater than 1, it is forcibly set to 3. + +
+ + +
+ +
+ +
+ useResizeObserver + optional + +
+ + + + + + + +
+ + useResizeObserver?: +boolean + + + +
+ + +
+ Whether to use the resize observer. When the size changes, the resize method is automatically called. + +
+ + +
+ +
+ +
+ className + optional + +
+ + + + + + +
+ Default Value: "" + +
+ + +
+ + className?: +string + + + +
+ + +
+ guides' class name + +
+ + +
+ +
+ +
+ rulerStyle + optional + +
+ + + + + + +
+ Default Value: "width 100%, height: 100%" + +
+ + +
+ + rulerStyle?: +IObject<any> + + + +
+ + +
+ ruler's css style + +
+ + +
+ +
+ +
+ snapThreshold + optional + +
+ + + + + + +
+ Default Value: 5 + +
+ + +
+ + snapThreshold?: +number + + + +
+ + +
+ Interval to snap + +
+ + +
+ +
+ +
+ snaps + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + snaps?: +number[] + + + +
+ + +
+ Positions to snap + +
+ + +
+ +
+ +
+ displayDragPos + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + displayDragPos?: +boolean + + + +
+ + +
+ Whether to show the moving pos when dragging + +
+ + +
+ +
+ +
+ guidesZoom + optional + +
+ + + +
+ Since: + 0.29.0 + + +
+ + + + +
+ Default Value: zoom + +
+ + +
+ + guidesZoom?: +number + + + +
+ + +
+ guides zoom(side zoom). If not set, it is the same as `zoom`. + +
+ + +
+ +
+ +
+ cspNonce + optional + +
+ + + + + + + +
+ + cspNonce?: +string + + + +
+ + +
+ csp nonce + +
+ + +
+ +
+ +
+ dragPosFormat + optional + +
+ + + + + + +
+ Default Value: self + +
+ + +
+ + dragPosFormat?: +(value: number) => string | number + + + +
+ + +
+ Format of drag pos + +
+ + +
+ +
+ +
+ defaultGuides + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + defaultGuides?: +number[] + + + +
+ + +
+ default guidelines + +
+ + +
+ +
+ +
+ defaultGuidesPos + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + defaultGuidesPos?: +number + + + +
+ + +
+ default guide pos for init + +
+ + +
+ +
+ +
+ showGuides + optional + +
+ + + + + + +
+ Default Value: true + +
+ + +
+ + showGuides?: +boolean + + + +
+ + +
+ Whether to show guidelines + +
+ + +
+ +
+ +
+ lockGuides + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + lockGuides?: +boolean | Array<"add" | "change" | "remove"> + + + +
+ + +
+ Whether to lock add/remove/change functions via drag/click of guides + +
+ + +
+ +
+ +
+ digit + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + digit?: +number + + + +
+ + +
+ pos digit of guidelines + +
+ + +
+ +
+ +
+ guideStyle + optional + +
+ + + + + + +
+ Default Value: "{}" + +
+ + +
+ + guideStyle?: +Record<string, any> + + + +
+ + +
+ CSS style objects for guide elements + +
+ + +
+ +
+ +
+ dragGuideStyle + optional + +
+ + + + + + +
+ Default Value: "{}" + +
+ + +
+ + dragGuideStyle?: +Record<string, any> + + + +
+ + +
+ CSS style objects for drag guide element + +
+ + +
+ +
+ +
+ displayGuidePos + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + displayGuidePos?: +boolean + + + +
+ + +
+ Whether to show the guide pos text + +
+ + +
+ +
+ +
+ guidePosFormat + optional + +
+ + + + + + +
+ Default Value: dragPosFormat + +
+ + +
+ + guidePosFormat?: +(value: number) => string | number + + + +
+ + +
+ Format of displayed guide pos + +
+ + +
+ +
+ +
+ guidePosStyle + optional + +
+ + + + + + + +
+ + guidePosStyle?: +IObject<any> + + + +
+ + +
+ CSS style objects for displayed guide pos text element + +
+ + +
+ +
+ +
+ scrollOptions + optional + +
+ + + + + + +
+ Default Value: null + +
+ + +
+ + scrollOptions?: +DragScrollOptions | null + + + +
+ + +
+ Set the scroll options, time, etc. to automatically scroll by dragging. + +
+ + +
+ +
+ +
+ guidesOffset + optional + +
+ + + +
+ Since: + 0.22.0 + + +
+ + + + +
+ Default Value: 0 + +
+ + +
+ + guidesOffset?: +number + + + +
+ + +
+ Numerical value of how far away from the guideline position + +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

GuidesProps

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ type + optional + +
+ + + + + + +
+ Default Value: "horizontal" + +
+ + +
+ + type?: +"horizontal" | "vertical" + + + +
+ + +
+ ruler's direction + +
+ + +
+ +
+ +
+ width + optional + +
+ + + + + + +
+ Default Value: target's offsetWidth + +
+ + +
+ + width?: +number + + + +
+ + +
+ ruler's width + +
+ + +
+ +
+ +
+ height + optional + +
+ + + + + + +
+ Default Value: target's offsetHeight + +
+ + +
+ + height?: +number + + + +
+ + +
+ ruler's height + +
+ + +
+ +
+ +
+ unit + optional + +
+ + + + + + +
+ Default Value: 50 + +
+ + +
+ + unit?: +number + + + +
+ + +
+ main scale unit + +
+ + Examples +
+ + 
```
+1px (Default) zoom: 1, unit: 50 (every 50px)
+1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+```
+ +
+ + +
+ +
+ +
+ zoom + optional + +
+ + + + + + +
+ Default Value: 1 + +
+ + +
+ + zoom?: +number + + + +
+ + +
+ zoom + +
+ + Examples +
+ + 
```
+1px (Default) zoom: 1, unit: 50 (every 50px)
+1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+```
+ +
+ + +
+ +
+ +
+ direction + optional + +
+ + + + + + +
+ Default Value: "end" + +
+ + +
+ + direction?: +"start" | "center" | "end" + + + +
+ + +
+ line's direction (align) + +
+ + +
+ +
+ +
+ textAlign + optional + +
+ + + + + + +
+ Default Value: "start" + +
+ + +
+ + textAlign?: +"left" | "center" | "right" + + + +
+ + +
+ text align + +
+ + +
+ +
+ +
+ font + optional + +
+ + + + + + +
+ Default Value: "10px sans-serif" + +
+ + +
+ + font?: +string + + + +
+ + +
+ font and size + +
+ + +
+ +
+ +
+ segment + optional + +
+ + + + + + +
+ Default Value: 10 + +
+ + +
+ + segment?: +number + + + +
+ + +
+ Number of areas to divide between two main lines + +
+ + +
+ +
+ +
+ mainLineSize + optional + +
+ + + + + + +
+ Default Value: "100%" + +
+ + +
+ + mainLineSize?: +string | number + + + +
+ + +
+ main line size + +
+ + +
+ +
+ +
+ longLineSize + optional + +
+ + + + + + +
+ Default Value: 10 + +
+ + +
+ + longLineSize?: +string | number + + + +
+ + +
+ long line size + +
+ + +
+ +
+ +
+ shortLineSize + optional + +
+ + + + + + +
+ Default Value: 7 + +
+ + +
+ + shortLineSize?: +string | number + + + +
+ + +
+ short line size + +
+ + +
+ +
+ +
+ lineOffset + optional + +
+ + + + + + +
+ Default Value: [0, 0] + +
+ + +
+ + lineOffset?: +number[] + + + +
+ + +
+ line's position offset + +
+ + +
+ +
+ +
+ textOffset + optional + +
+ + + + + + +
+ Default Value: [0, 0] + +
+ + +
+ + textOffset?: +number[] + + + +
+ + +
+ text's position offset + +
+ + +
+ +
+ +
+ negativeRuler + optional + +
+ + + + + + +
+ Default Value: true + +
+ + +
+ + negativeRuler?: +boolean + + + +
+ + +
+ Whether to display the ruler in the negative direction. + +
+ + +
+ +
+ +
+ range + optional + +
+ + + + + + +
+ Default Value: [-Infinity, Infinity] + +
+ + +
+ + range?: +[number, number] + + + +
+ + +
+ The range to show the ruler's scales + +
+ + +
+ +
+ +
+ scrollPos + optional + +
+ + + + + + +
+ Default Value: undefined + +
+ + +
+ + scrollPos?: +number + + + +
+ + +
+ you can set scroll position by prop. +If you use the scrollPos prop, you can't use the scroll method. + +
+ + +
+ +
+ +
+ defaultScrollPos + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + defaultScrollPos?: +number + + + +
+ + +
+ you can set scroll position by prop for init. +don't use `scrollPos` prop + +
+ + +
+ +
+ +
+ style + optional + +
+ + + + + + + +
+ + style?: +IObject<any> + + + +
+ + +
+ ruler canvas style + +
+ + +
+ +
+ +
+ backgroundColor + optional + +
+ + + + + + +
+ Default Value: "#333333" + +
+ + +
+ + backgroundColor?: +string + + + +
+ + +
+ ruler's background color + +
+ + +
+ +
+ +
+ rangeBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "transparent" + +
+ + +
+ + rangeBackgroundColor?: +string + + + +
+ + +
+ background color within range in ruler + +
+ + +
+ +
+ +
+ lineColor + optional + +
+ + + + + + +
+ Default Value: "#777777" + +
+ + +
+ + lineColor?: +string + + + +
+ + +
+ ruler's line color + +
+ + +
+ +
+ +
+ textColor + optional + +
+ + + + + + +
+ Default Value: "#ffffff" + +
+ + +
+ + textColor?: +string + + + +
+ + +
+ ruler's text color + +
+ + +
+ +
+ +
+ textBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "transparent" + +
+ + +
+ + textBackgroundColor?: +string + + + +
+ + +
+ The background color that wraps the text + +
+ + +
+ +
+ +
+ textFormat + optional + +
+ + + + + + +
+ Default Value: ownself + +
+ + +
+ + textFormat?: +(scale: number) => string + + + +
+ + +
+ text foramt + +
+ + +
+ +
+ +
+ marks + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + marks?: +number[] + + + +
+ + +
+ positions to mark + +
+ + +
+ +
+ +
+ markColor + optional + +
+ + + + + + +
+ Default Value: "#f55" + + +
+ + +
+ + markColor?: +string + + + +
+ + +
+ +
+ + +
+ +
+ +
+ lineWidth + optional + +
+ + + + + + +
+ Default Value: 1 + +
+ + +
+ + lineWidth?: +number + + + +
+ + +
+ Ruler's line width + +
+ + +
+ +
+ +
+ warpSelf + optional + +
+ + + + + + + +
+ + warpSelf?: +boolean + + + +
+ + +
+ Whether to warp self + +
+ + +
+ +
+ +
+ selectedRanges + optional + +
+ + + + + + + +
+ + selectedRanges?: +number[][] + + + +
+ + +
+ You can paint the selected area(selectedranges) with the `selectedBackgroundColor` color. + +
+ + +
+ +
+ +
+ selectedBackgroundColor + optional + +
+ + + + + + +
+ Default Value: "#555555" + +
+ + +
+ + selectedBackgroundColor?: +string + + + +
+ + +
+ background color within selected range in ruler with `selectedRanges` area + +
+ + +
+ +
+ +
+ selectedRangesText + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: false + +
+ + +
+ + selectedRangesText?: +boolean + + + +
+ + +
+ Text is displayed in the selected ranges. If it overlaps existing text, only the selected range text is visible. + +
+ + +
+ +
+ +
+ selectedRangesTextOffset + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: "0, 0" + +
+ + +
+ + selectedRangesTextOffset?: +number[] + + + +
+ + +
+ Position offset of text in selected ranges + +
+ + +
+ +
+ +
+ selectedRangesTextColor + optional + +
+ + + +
+ Since: + 0.16.0 + + +
+ + + + +
+ Default Value: "#44aaff" + +
+ + +
+ + selectedRangesTextColor?: +string + + + +
+ + +
+ Color of text in selected ranges + +
+ + +
+ +
+ +
+ defaultPixelScale + optional + +
+ + + + + + +
+ Default Value: 2 + +
+ + +
+ + defaultPixelScale?: +number + + + +
+ + +
+ Scale value of canvase when device high density is 1. +Less than 2 may cause pixels to blur. +If device high density is greater than 1, it is forcibly set to 3. + +
+ + +
+ +
+ +
+ useResizeObserver + optional + +
+ + + + + + + +
+ + useResizeObserver?: +boolean + + + +
+ + +
+ Whether to use the resize observer. When the size changes, the resize method is automatically called. + +
+ + +
+ +
+ +
+ className + optional + +
+ + + + + + +
+ Default Value: "" + +
+ + +
+ + className?: +string + + + +
+ + +
+ guides' class name + +
+ + +
+ +
+ +
+ rulerStyle + optional + +
+ + + + + + +
+ Default Value: "width 100%, height: 100%" + +
+ + +
+ + rulerStyle?: +IObject<any> + + + +
+ + +
+ ruler's css style + +
+ + +
+ +
+ +
+ snapThreshold + optional + +
+ + + + + + +
+ Default Value: 5 + +
+ + +
+ + snapThreshold?: +number + + + +
+ + +
+ Interval to snap + +
+ + +
+ +
+ +
+ snaps + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + snaps?: +number[] + + + +
+ + +
+ Positions to snap + +
+ + +
+ +
+ +
+ displayDragPos + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + displayDragPos?: +boolean + + + +
+ + +
+ Whether to show the moving pos when dragging + +
+ + +
+ +
+ +
+ guidesZoom + optional + +
+ + + +
+ Since: + 0.29.0 + + +
+ + + + +
+ Default Value: zoom + +
+ + +
+ + guidesZoom?: +number + + + +
+ + +
+ guides zoom(side zoom). If not set, it is the same as `zoom`. + +
+ + +
+ +
+ +
+ cspNonce + optional + +
+ + + + + + + +
+ + cspNonce?: +string + + + +
+ + +
+ csp nonce + +
+ + +
+ +
+ +
+ dragPosFormat + optional + +
+ + + + + + +
+ Default Value: self + +
+ + +
+ + dragPosFormat?: +(value: number) => string | number + + + +
+ + +
+ Format of drag pos + +
+ + +
+ +
+ +
+ defaultGuides + optional + +
+ + + + + + +
+ Default Value: [] + +
+ + +
+ + defaultGuides?: +number[] + + + +
+ + +
+ default guidelines + +
+ + +
+ +
+ +
+ defaultGuidesPos + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + defaultGuidesPos?: +number + + + +
+ + +
+ default guide pos for init + +
+ + +
+ +
+ +
+ showGuides + optional + +
+ + + + + + +
+ Default Value: true + +
+ + +
+ + showGuides?: +boolean + + + +
+ + +
+ Whether to show guidelines + +
+ + +
+ +
+ +
+ lockGuides + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + lockGuides?: +boolean | Array<"add" | "change" | "remove"> + + + +
+ + +
+ Whether to lock add/remove/change functions via drag/click of guides + +
+ + +
+ +
+ +
+ digit + optional + +
+ + + + + + +
+ Default Value: 0 + +
+ + +
+ + digit?: +number + + + +
+ + +
+ pos digit of guidelines + +
+ + +
+ +
+ +
+ guideStyle + optional + +
+ + + + + + +
+ Default Value: "{}" + +
+ + +
+ + guideStyle?: +Record<string, any> + + + +
+ + +
+ CSS style objects for guide elements + +
+ + +
+ +
+ +
+ dragGuideStyle + optional + +
+ + + + + + +
+ Default Value: "{}" + +
+ + +
+ + dragGuideStyle?: +Record<string, any> + + + +
+ + +
+ CSS style objects for drag guide element + +
+ + +
+ +
+ +
+ displayGuidePos + optional + +
+ + + + + + +
+ Default Value: false + +
+ + +
+ + displayGuidePos?: +boolean + + + +
+ + +
+ Whether to show the guide pos text + +
+ + +
+ +
+ +
+ guidePosFormat + optional + +
+ + + + + + +
+ Default Value: dragPosFormat + +
+ + +
+ + guidePosFormat?: +(value: number) => string | number + + + +
+ + +
+ Format of displayed guide pos + +
+ + +
+ +
+ +
+ guidePosStyle + optional + +
+ + + + + + + +
+ + guidePosStyle?: +IObject<any> + + + +
+ + +
+ CSS style objects for displayed guide pos text element + +
+ + +
+ +
+ +
+ scrollOptions + optional + +
+ + + + + + +
+ Default Value: null + +
+ + +
+ + scrollOptions?: +DragScrollOptions | null + + + +
+ + +
+ Set the scroll options, time, etc. to automatically scroll by dragging. + +
+ + +
+ +
+ +
+ guidesOffset + optional + +
+ + + +
+ Since: + 0.22.0 + + +
+ + + + +
+ Default Value: 0 + +
+ + +
+ + guidesOffset?: +number + + + +
+ + +
+ Numerical value of how far away from the guideline position + +
+ + +
+ +
+ +
+ onChangeGuides + optional + +
+ + + + + + + +
+ + onChangeGuides?: +(e: OnChangeGuides) => any + + + +
+ + +
+ +
+ + +
+ +
+ +
+ onRequestScroll + optional + +
+ + + + + + + +
+ + onRequestScroll?: +(e: OnRequestScroll) => any + + + +
+ + +
+ +
+ + +
+ +
+ +
+ onDragStart + optional + +
+ + + + + + + +
+ + onDragStart?: +(e: OnDragStart) => any + + + +
+ + +
+ +
+ + +
+ +
+ +
+ onDrag + optional + +
+ + + + + + + +
+ + onDrag?: +(e: OnDrag) => any + + + +
+ + +
+ +
+ + +
+ +
+ +
+ onDragEnd + optional + +
+ + + + + + + +
+ + onDragEnd?: +(e: OnDragEnd) => any + + + +
+ + +
+ +
+ + +
+ +
+ +
+ onClickRuler + optional + +
+ + + + + + + +
+ + onClickRuler?: +(e: OnClickRuler) => any + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnChangeGuides

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ guides + + +
+ + + + + + + +
+ + guides: +number[] + + + +
+ + +
+ +
+ + +
+ +
+ +
+ isAdd + + +
+ + + + + + + +
+ + isAdd: +boolean + + + +
+ + +
+ +
+ + +
+ +
+ +
+ isRemove + + +
+ + + + + + + +
+ + isRemove: +boolean + + + +
+ + +
+ +
+ + +
+ +
+ +
+ isChange + + +
+ + + + + + + +
+ + isChange: +boolean + + + +
+ + +
+ +
+ + +
+ +
+ +
+ index + + +
+ + + + + + + +
+ + index: +number + + + +
+ + +
+ +
+ + +
+ +
+ +
+ distX + + +
+ + + + + + + +
+ + distX: +number + + + +
+ + +
+ +
+ + +
+ +
+ +
+ distY + + +
+ + + + + + + +
+ + distY: +number + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnClickRuler

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ pos + + +
+ + + + + + + +
+ + pos: +number + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnDrag

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ dragElement + + +
+ + + + + + + +
+ + dragElement: +HTMLElement + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnDragEnd

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ dragElement + + +
+ + + + + + + +
+ + dragElement: +HTMLElement + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnDragStart

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ dragElement + + +
+ + + + + + + +
+ + dragElement: +HTMLElement + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + +

OnRequestScroll

+ + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
Properties:
+ + + + +
+ +
+ container + + +
+ + + + + + + +
+ + container: +HTMLElement | SVGElement + + + +
+ + +
+ +
+ + +
+ +
+ +
+ direction + + +
+ + + + + + + +
+ + direction: +number[] + + + +
+ + +
+ +
+ + +
+ + + + + + + + + +
Type:
+
    +
  • + +TSInterface + + +
    • +
+ + + + + + + + + + +

Events

+ + + + + + +

changeGuides

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ The `changeGuides` event occurs when the guideline is added / removed / changed. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeDescription
+ + +OnChangeGuides + + + + Parameters for the changeGuides event
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

clickRuler

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ When click the ruler, the click ruler is called. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeDescription
+ + +OnClickRuler + + + + Parameters for the clickRuler event
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

drag

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ When dragging, the drag event is called. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeDescription
+ + +OnDrag + + + + Parameters for the drag event
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

dragEnd

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ When the drag finishes, the dragEnd event is called. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeDescription
+ + +OnDragEnd + + + + Parameters for the dragEnd event
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

dragStart

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ When the drag starts, the dragStart event is called. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeDescription
+ + +OnDragStart + + + + Parameters for the dragStart event
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

requestScroll

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ If scroll can be triggered through drag, the `requestScroll` event is fired. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeDescription
+ + +OnRequestScroll + + + + Parameters for the `requestScroll` event
+ + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + \ No newline at end of file diff --git a/release/0.29.2/doc/global.html b/release/0.29.2/doc/global.html new file mode 100644 index 0000000..b2e4afb --- /dev/null +++ b/release/0.29.2/doc/global.html @@ -0,0 +1,702 @@ + + + + + Global - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

Global

+ + + + + + + +
+ +
+ +

+ +

+ + +
+ +
+
+ + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + +
+ + + + + + + + + + + + + + +

Methods

+ + + + + + +

getScrollPos()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Gets the scroll position of the ruler. +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

getRulerScrollPos()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Scroll position of the ruler (horizontal: x, vertical: y) +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

getGuideScrollPos()

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Scroll position of guides (horizontal: y, vertical: x) +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

drawRuler(options)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ Draw ruler +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
options + + +DrawRulerOptions + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

draw(optionsopt)

+ + + + + + +
+ + +
Source:
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ draw a ruler +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDefaultDescription
options? + + +DrawRulerOptions + + + + + + {} + + It is drawn with an external value, not the existing state.
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + \ No newline at end of file diff --git a/release/0.29.2/doc/index.html b/release/0.29.2/doc/index.html new file mode 100644 index 0000000..6c58f29 --- /dev/null +++ b/release/0.29.2/doc/index.html @@ -0,0 +1,214 @@ + + + + + Home - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + +
+

+

Guides

+

+npm version + + +React +Preact +Angular +Vue +Vue3 +Svelte +

+

A Guides component that can draw ruler and manage guidelines.

+

+ Demo / + API / + Ruler / + Main Project +

+

⚙️ Installation

+

npm

+
$ npm i @scena/guides
+
+

scripts

+
<script src="//daybrush.com/guides/release/latest/dist/guides.min.js"></script>
+
+

🚀 How to use

+

+import Guides from "@scena/guides";
+
+const guides = new Guides(document.body, {
+    type: "horizontal",
+}).on("changeGuides", e => {
+    console.log(e.guides);
+});
+
+
+let scrollX = 0;
+let scrollY = 0;
+window.addEventListener("resize", () => {
+    guides.resize();
+});
+
+window.addEventListener("wheel", e => {
+    scrollX += e.deltaX;
+    scrollY += e.deltaY;
+
+    guides.scrollGuides(scrollY);
+    guides.scroll(scrollX);
+});
+
+
+

Ruler Units

+

The default unit is px, and a line is drawn every 50px. If you want to use a different unit instead of the px unit, use it like this:

+
    +
  • 1px (Default) +
      +
    • zoom: 1
      • +
    • unit: 50 (every 50px)
      • +
    +
    • +
  • 1cm = 37.7952px +
      +
    • zoom: 37.7952
      • +
    • unit: 1 (every 1cm)
      • +
    +
    • +
  • 1in = 96px = 2.54cm +
      +
    • zoom: 96
      • +
    • unit: 1 (every 1in)
      • +
    +
    • +
+

See:

+
    +
  • https://www.w3schools.com/cssref/css_units.asp
    • +
  • https://www.scaler.com/topics/css/css-units/
    • +
+

⚙️ Developments

+

The guides repo is managed as a monorepo with yarn.

+
yarn config set registry https://registry.npmjs.org/
+
+

⭐️ Show Your Support

+

Please give a ⭐️ if this project helped you!

+

👏 Contributing

+

If you have any questions or requests or want to contribute to guides or other packages, please write the issue or give me a Pull Request freely.

+

🐞 Bug Report

+

If you find a bug, please report to us opening a new Issue on GitHub.

+

📝 License

+

This project is MIT licensed.

+
MIT License
+
+Copyright (c) 2019 Daybrush
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+ + + + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + \ No newline at end of file diff --git a/release/0.29.2/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html b/release/0.29.2/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html new file mode 100644 index 0000000..22b5588 --- /dev/null +++ b/release/0.29.2/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html @@ -0,0 +1,292 @@ + + + + + node_modules/@scena/event-emitter/src/EventEmitter.ts - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

node_modules/@scena/event-emitter/src/EventEmitter.ts

+ + + + + + + +
+
+ 
import { findIndex, isObject } from "@daybrush/utils";
+import { EventListener, EventHash, EventInfo, EventOptions, OnEvent, TargetParam } from "./types";
+
+/**
+ * Implement EventEmitter on object or component.
+ */
+class EventEmitter<Events extends {} = { [key: string]: { [key: string]: any } }> {
+
+    private _events: {
+        [name: string]: EventInfo[],
+    } = {};
+    public on<Name extends keyof Events, Param = Events[Name]>(
+        eventName: Name, listener: EventListener<Param, this>): this;
+    public on(events: EventHash<Events, this>): this;
+    /**
+     * Add a listener to the registered event.
+     * @param - Name of the event to be added
+     * @param - listener function of the event to be added
+     * @example
+     * import EventEmitter from "@scena/event-emitter";
+     * cosnt emitter = new EventEmitter();
+     *
+     * // Add listener in "a" event
+     * emitter.on("a", () => {
+     * });
+     * // Add listeners
+     * emitter.on({
+     *  a: () => {},
+     *  b: () => {},
+     * });
+     */
+    public on(eventName: string | object, listener?: EventListener<Events[any], this>): this {
+        if (isObject(eventName)) {
+            for (const name in eventName) {
+                this.on<any>(name, eventName[name]);
+            }
+        } else {
+            this._addEvent(eventName, listener, {});
+        }
+        return this;
+    }
+    public off<Name extends keyof Events, Param = Events[Name]>(
+        eventName?: Name, listener?: EventListener<Param, this>): this;
+    public off(events: EventHash<Events, this>): this;
+    /**
+     * Remove listeners registered in the event target.
+     * @param - Name of the event to be removed
+     * @param - listener function of the event to be removed
+     * @example
+     * import EventEmitter from "@scena/event-emitter";
+     * cosnt emitter = new EventEmitter();
+     *
+     * // Remove all listeners.
+     * emitter.off();
+     *
+     * // Remove all listeners in "A" event.
+     * emitter.off("a");
+     *
+     *
+     * // Remove "listener" listener in "a" event.
+     * emitter.off("a", listener);
+     */
+    public off(eventName?: string | object, listener?: EventListener<Events[any], this>): this {
+        if (!eventName) {
+            this._events = {};
+        } else if(isObject(eventName)) {
+            for (const name in eventName) {
+                this.off<any>(name);
+            }
+        } else if (!listener) {
+            this._events[eventName] = [];
+        } else {
+            const events = this._events[eventName];
+
+            if (events) {
+                const index = findIndex(events, e => e.listener === listener);
+
+                if (index > -1) {
+                    events.splice(index, 1);
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * Add a disposable listener and Use promise to the registered event.
+     * @param - Name of the event to be added
+     * @param - disposable listener function of the event to be added
+     * @example
+     * import EventEmitter from "@scena/event-emitter";
+     * cosnt emitter = new EventEmitter();
+     *
+     * // Add a disposable listener in "a" event
+     * emitter.once("a", () => {
+     * });
+     *
+     * // Use Promise
+     * emitter.once("a").then(e => {
+     * });
+     */
+    public once<Name extends keyof Events & string, Param = Events[Name]>(
+        eventName: Name, listener?: EventListener<Param, this>): Promise<OnEvent<Param, this>> {
+        if (listener) {
+            this._addEvent(eventName, listener, { once: true });
+        }
+        return new Promise<OnEvent<Param, this>>(resolve => {
+            this._addEvent(eventName, resolve, { once: true });
+        });
+    }
+    public emit<Name extends keyof Events, Param = Events[Name]>(
+        eventName: {} extends Param ? Name : never): boolean;
+    public emit<Name extends keyof Events, Param = Events[Name]>(
+        eventName: Name, param: TargetParam<Param>): boolean;
+    /**
+     * Fires an event to call listeners.
+     * @param - Event name
+     * @param - Event parameter
+     * @return If false, stop the event.
+     * @example
+     *
+     * import EventEmitter from "@scena/event-emitter";
+     *
+     *
+     * const emitter = new EventEmitter();
+     *
+     * emitter.on("a", e => {
+     * });
+     *
+     *
+     * emitter.emit("a", {
+     *   a: 1,
+     * });
+     */
+    public emit(eventName: string, param: TargetParam<any> = {}): boolean {
+        const events = this._events[eventName];
+
+        if (!eventName || !events) {
+            return true;
+        }
+        let isStop = false;
+
+        param.eventType = eventName;
+        param.stop = () => {
+            isStop = true;
+        };
+        param.currentTarget = this;
+
+
+        [...events].forEach(info => {
+            info.listener(param);
+            if (info.once) {
+                this.off<any>(eventName, info.listener);
+            }
+        });
+
+        return !isStop;
+    }
+    public trigger<Name extends keyof Events, Param = Events[Name]>(eventName: {} extends TargetParam<Param> ? Name : never): boolean;
+    public trigger<Name extends keyof Events, Param = Events[Name]>(eventName: Name, param: TargetParam<Param>): boolean;
+    /**
+     * Fires an event to call listeners.
+     * @param - Event name
+     * @param - Event parameter
+     * @return If false, stop the event.
+     * @example
+     *
+     * import EventEmitter from "@scena/event-emitter";
+     *
+     *
+     * const emitter = new EventEmitter();
+     *
+     * emitter.on("a", e => {
+     * });
+     *
+     *
+     * emitter.emit("a", {
+     *   a: 1,
+     * });
+     *//**
+     * Fires an event to call listeners.
+     * @param - Event name
+     * @param - Event parameter
+     * @return If false, stop the event.
+     * @example
+     *
+     * import EventEmitter from "@scena/event-emitter";
+     *
+     *
+     * const emitter = new EventEmitter();
+     *
+     * emitter.on("a", e => {
+     * });
+     *
+     * // emit
+     * emitter.trigger("a", {
+     *   a: 1,
+     * });
+     */
+    public trigger<Name extends keyof Events>(eventName: Name, param: TargetParam<any>= {}): boolean {
+        return this.emit<any>(eventName, param);
+    }
+
+    private _addEvent(eventName: string, listener: EventListener<Events[any], this>, options: Partial<EventOptions>) {
+        const events = this._events;
+
+        events[eventName] = events[eventName] || [];
+
+        const listeners = events[eventName];
+
+        listeners.push({ listener, ...options });
+    }
+}
+
+export default EventEmitter;
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/node_modules_@scena_event-emitter_src_types.ts.html b/release/0.29.2/doc/node_modules_@scena_event-emitter_src_types.ts.html new file mode 100644 index 0000000..8cd169b --- /dev/null +++ b/release/0.29.2/doc/node_modules_@scena_event-emitter_src_types.ts.html @@ -0,0 +1,125 @@ + + + + + node_modules/@scena/event-emitter/src/types.ts - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

node_modules/@scena/event-emitter/src/types.ts

+ + + + + + + +
+
+ 

+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export type TargetParam<Param> = Pick<Param, Exclude<keyof Param, keyof EmitterParam>> & Partial<EmitterParam>;
+
+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export interface EmitterParam<Target = any> {
+    type: string;
+    currentTarget: Target;
+    stop(): void;
+}
+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export type OnEvent<Param, Target = any> = EmitterParam<Target> & Param;
+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export type EventHash<Events, Target> = Partial<{ [Key in keyof Events]: EventListener<Events[Key], Target> }>;
+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export type EventListener<Param, Target> = (e: OnEvent<Param, Target>) => any;
+
+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export interface EventOptions {
+    once: boolean;
+}
+
+/**
+ * @memberof EventEmitter
+ * @typedef
+ */
+export interface EventInfo extends Partial<EventOptions> {
+    listener: EventListener<any, any>;
+}
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html b/release/0.29.2/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html new file mode 100644 index 0000000..b73adaf --- /dev/null +++ b/release/0.29.2/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html @@ -0,0 +1,538 @@ + + + + + node_modules/@scena/react-ruler/src/react-ruler/Ruler.tsx - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

node_modules/@scena/react-ruler/src/react-ruler/Ruler.tsx

+ + + + + + + +
+
+ 
import * as React from "react";
+import { ref } from "framework-utils";
+import { DrawRulerOptions, RulerInterface, RulerProps } from "./types";
+import { convertUnitSize, findLast } from "@daybrush/utils";
+
+export default class Ruler extends React.PureComponent<RulerProps> implements RulerInterface {
+    public static defaultProps: Partial<RulerProps> = {
+        type: "horizontal",
+        zoom: 1,
+        width: 0,
+        height: 0,
+        unit: 50,
+        negativeRuler: true,
+        mainLineSize: "100%",
+        longLineSize: 10,
+        shortLineSize: 7,
+        segment: 10,
+        direction: "end",
+        style: { width: "100%", height: "100%" },
+        backgroundColor: "#333333",
+        font: "10px sans-serif",
+        textColor: "#ffffff",
+        textBackgroundColor: 'transparent',
+        lineColor: "#777777",
+        range: [-Infinity, Infinity],
+        rangeBackgroundColor: 'transparent',
+        lineWidth: 1,
+        selectedBackgroundColor: "#555555",
+        defaultScrollPos: 0,
+        markColor: "#f55",
+        marks: [],
+    };
+    public divisionsElement!: HTMLElement;
+    public state = {
+        scrollPos: 0,
+    };
+    public canvasElement!: HTMLCanvasElement;
+    private canvasContext!: CanvasRenderingContext2D;
+    private width: number = 0;
+    private height: number = 0;
+    private _zoom = 0;
+    private _rulerScale = 0;
+    private _observer: ResizeObserver | null = null;
+
+    public render() {
+        const props = this.props;
+        this._zoom = props.zoom!;
+
+        return <canvas
+            ref={ref(this, "canvasElement")}
+            style={this.props.style} />;
+
+    }
+    public componentDidMount() {
+        const props = this.props;
+        this.state.scrollPos = props.defaultScrollPos || 0;
+        const canvas = this.canvasElement;
+        const context = canvas.getContext("2d", { alpha: true })!;
+
+        this.canvasContext = context;
+
+        if (props.useResizeObserver) {
+            this._observer = new ResizeObserver(this._checkResize);
+
+            this._observer.observe(canvas, {
+                box: "border-box",
+            });
+        } else {
+            this.resize();
+        }
+    }
+    public componentDidUpdate() {
+        this.resize();
+    }
+    public componentWillUnmount(): void {
+        this.state.scrollPos = 0;
+        this._observer?.disconnect();
+    }
+    /**
+     * Gets the scroll position of the ruler.
+     */
+    public getScrollPos() {
+        return this.state.scrollPos;
+    }
+    /**
+     * @method Ruler#scroll
+     * @param scrollPos
+     */
+    public scroll(scrollPos: number, zoom?: number) {
+        this.draw({
+            scrollPos,
+            zoom,
+        });
+    }
+    /**
+     * @method Ruler#resize
+     */
+    public resize(nextZoom?: number) {
+        const canvas = this.canvasElement;
+        const {
+            width,
+            height,
+            scrollPos,
+        } = this.props;
+        const rulerScale = this._getRulerScale();
+
+        this.width = width || canvas.offsetWidth;
+        this.height = height || canvas.offsetHeight;
+        canvas.width = this.width * rulerScale;
+        canvas.height = this.height * rulerScale;
+
+        this.draw({
+            scrollPos,
+            zoom: nextZoom,
+        });
+    }
+    /**
+     * draw a ruler
+     * @param options - It is drawn with an external value, not the existing state.
+     */
+    public draw(options: DrawRulerOptions = {}) {
+        const props = this.props;
+        const {
+            zoom: nextZoom = this._zoom,
+            scrollPos = this.state.scrollPos,
+            marks = props.marks,
+            selectedRanges = props.selectedRanges!,
+            segment = props.segment || 10,
+            unit = props.unit!,
+        } = options;
+
+        this._zoom = nextZoom;
+
+        const {
+            type,
+            backgroundColor,
+            lineColor,
+            textColor,
+            textBackgroundColor,
+            direction,
+            negativeRuler = true,
+            textFormat,
+            range = [-Infinity, Infinity],
+            rangeBackgroundColor,
+            selectedBackgroundColor,
+            lineWidth = 1,
+            selectedRangesText,
+            selectedRangesTextColor = "#44aaff",
+            selectedRangesTextOffset = [0, 0],
+            markColor = "#ff5",
+        } = props as Required<RulerProps>;
+
+        const rulerScale = this._getRulerScale();
+        const width = this.width;
+        const height = this.height;
+        const state = this.state;
+        state.scrollPos = scrollPos;
+        const context = this.canvasContext;
+        const isHorizontal = type === "horizontal";
+        const isNegative = negativeRuler !== false;
+        const font = props.font || "10px sans-serif";
+        const textAlign = props.textAlign || "left";
+        const textOffset = props.textOffset || [0, 0];
+        const containerSize = isHorizontal ? height : width;
+        const mainLineSize = convertUnitSize(`${props.mainLineSize || "100%"}`, containerSize);
+        const longLineSize = convertUnitSize(`${props.longLineSize || 10}`, containerSize);
+        const shortLineSize = convertUnitSize(`${props.shortLineSize || 7}`, containerSize);
+        const lineOffset = props.lineOffset || [0, 0];
+
+        if (backgroundColor === "transparent") {
+            // Clear existing paths & text
+            context.clearRect(0, 0, width * rulerScale, height * rulerScale);
+        } else {
+            // Draw the background
+            context.rect(0, 0, width * rulerScale, height * rulerScale);
+            context.fillStyle = backgroundColor;
+            context.fill();
+        }
+
+
+        context.save();
+        context.scale(rulerScale, rulerScale);
+        context.strokeStyle = lineColor;
+        context.lineWidth = lineWidth;
+        context.font = font;
+        context.fillStyle = textColor;
+        context.textAlign = textAlign;
+
+        switch (direction) {
+            case "start":
+                context.textBaseline = "top";
+                break;
+            case "center":
+                context.textBaseline = "middle";
+                break;
+            case "end":
+                context.textBaseline = "bottom";
+                break;
+        }
+
+        context.translate(0.5, 0);
+        context.beginPath();
+
+        const size = isHorizontal ? width : height;
+        const zoomUnit = nextZoom * unit;
+        const minRange = Math.floor(scrollPos * nextZoom / zoomUnit);
+        const maxRange = Math.ceil((scrollPos * nextZoom + size) / zoomUnit);
+        const length = maxRange - minRange;
+        const alignOffset = Math.max(["left", "center", "right"].indexOf(textAlign) - 1, -1);
+        const barSize = isHorizontal ? height : width;
+        const values: Array<{
+            color: string;
+            backgroundColor?: string;
+            offset: number[];
+            value: number;
+            text: string;
+            textSize: number;
+        }> = [];
+
+        for (let i = 0; i <= length; ++i) {
+            const value = (i + minRange) * unit;
+            let text = `${value}`;
+
+            if (textFormat) {
+                text = textFormat(value);
+            }
+            const textSize = context.measureText(text).width;
+
+            values.push({
+                color: textColor,
+                offset: textOffset,
+                backgroundColor: textBackgroundColor,
+                value,
+                text,
+                textSize: textSize,
+            });
+        }
+
+
+        // Draw Selected Range Background
+        if (selectedBackgroundColor !== "transparent" && selectedRanges?.length) {
+            selectedRanges.forEach(selectedRange => {
+                const rangeStart = Math.max(selectedRange[0], range[0], negativeRuler ? -Infinity : 0);
+                const rangeEnd = Math.min(selectedRange[1], range[1]);
+                const rangeX = (rangeStart - scrollPos) * nextZoom;
+                const rangeWidth = ((rangeEnd - rangeStart) * nextZoom);
+
+                if (selectedRangesText) {
+                    selectedRange.forEach(value => {
+                        let text = `${value}`;
+
+                        if (textFormat) {
+                            text = textFormat(value);
+                        }
+                        const textSize = context.measureText(text).width;
+
+                        const startPos = value * nextZoom;
+                        const endPos = startPos + textSize;
+
+                        findLast(values, ({ value: prevValue, textSize: prevTextSize }, index) => {
+                            const prevStartPos = prevValue * nextZoom;
+                            const prevEndPos = prevStartPos + prevTextSize;
+
+                            if (prevStartPos <= endPos && startPos <= prevEndPos) {
+                                values.splice(index, 1);
+                            }
+                        });
+                        values.push({
+                            value,
+                            color: selectedRangesTextColor,
+                            offset: selectedRangesTextOffset,
+                            text,
+                            textSize,
+                        });
+                    });
+                }
+
+                if (rangeWidth <= 0) {
+                    return;
+                }
+                context.save();
+                context.fillStyle = selectedBackgroundColor;
+
+                if (isHorizontal) {
+                    context.fillRect(rangeX, 0, rangeWidth, barSize);
+                } else {
+                    context.fillRect(0, rangeX, barSize, rangeWidth);
+                }
+                context.restore();
+            });
+        }
+        // Draw Range Background
+        if (rangeBackgroundColor !== "transparent" && range[0] !== -Infinity && range[1] !== Infinity) {
+            const rangeStart = (range[0] - scrollPos) * nextZoom;
+            const rangeEnd = ((range[1] - range[0]) * nextZoom);
+            context.save();
+            context.fillStyle = rangeBackgroundColor;
+            if (isHorizontal) {
+                context.fillRect(rangeStart, 0, rangeEnd, barSize);
+            } else {
+                context.fillRect(0, rangeStart, barSize, rangeEnd);
+            }
+
+            context.restore();
+        }
+
+        // Render Segments First
+
+        for (let i = 0; i <= length; ++i) {
+            const value = i + minRange;
+
+            if (!isNegative && value < 0) {
+                continue;
+            }
+            const startValue = value * unit;
+            const startPos = (startValue - scrollPos) * nextZoom;
+
+            for (let j = 0; j < segment; ++j) {
+                const pos = startPos + j / segment * zoomUnit;
+                const value = startValue + j / segment * unit;
+
+                if (pos < 0 || pos >= size || value < range[0] || value > range[1]) {
+                    continue;
+                }
+
+                const lineSize = j === 0
+                    ? mainLineSize
+                    : (j % 2 === 0 ? longLineSize : shortLineSize);
+
+                let origin = 0
+                switch (direction) {
+                    case "start":
+                        origin = 0;
+                        break;
+                    case "center":
+                        origin = barSize / 2 - lineSize / 2;
+                        break;
+                    case "end":
+                        origin = barSize - lineSize;
+                        break;
+                }
+
+                const [x1, y1] = isHorizontal ?
+                    [pos + lineOffset[0], origin + lineOffset[1]] :
+                    [origin + lineOffset[0], pos + lineOffset[1]];
+
+                const [x2, y2] = isHorizontal ? [x1, y1 + lineSize] : [x1 + lineSize, y1];
+
+                context.moveTo(x1 + lineOffset[0], y1 + lineOffset[1]);
+                context.lineTo(x2 + lineOffset[0], y2 + lineOffset[1]);
+            }
+        }
+        context.stroke();
+
+        context.beginPath();
+        // Render marks
+        context.strokeStyle = markColor;
+        context.lineWidth = 1;
+        (marks || []).forEach(value => {
+            const pos = (-scrollPos + value) * nextZoom;
+
+            if (pos < 0 || pos >= size || value < range[0] || value > range[1]) {
+                return;
+            }
+            const [x1, y1] = isHorizontal ?
+                [pos + lineOffset[0], lineOffset[1]] :
+                [lineOffset[0], pos + lineOffset[1]];
+            const [x2, y2] = isHorizontal ? [x1, y1 + containerSize] : [x1 + containerSize, y1];
+
+            context.moveTo(x1 + lineOffset[0], y1 + lineOffset[1]);
+            context.lineTo(x2 + lineOffset[0], y2 + lineOffset[1]);
+        });
+        context.stroke();
+
+        // Render Labels
+
+        values.forEach(({ value, offset, backgroundColor, color, text, textSize }) => {
+            if (!isNegative && value < 0) {
+                return;
+            }
+            const startPos = (value - scrollPos) * nextZoom;
+
+            if (startPos < -zoomUnit || startPos >= size + unit * nextZoom || value < range[0] || value > range[1]) {
+                return;
+            }
+
+            let origin = 0
+            switch (direction) {
+                case "start":
+                    origin = 17;
+                    break;
+                case "center":
+                    origin = barSize / 2;
+                    break;
+                case "end":
+                    origin = barSize - 17;
+                    break;
+            }
+
+            const [startX, startY] = isHorizontal
+                ? [startPos + alignOffset * -3, origin]
+                : [origin, startPos + alignOffset * 3];
+
+            if (backgroundColor) {
+                let backgroundOffset = 0
+                switch (textAlign) {
+                    case "left":
+                        backgroundOffset = 0;
+                        break;
+                    case "center":
+                        backgroundOffset = -textSize / 2;
+                        break;
+                    case "right":
+                        backgroundOffset = -textSize;
+                        break;
+                }
+                context.save();
+                context.fillStyle = backgroundColor;
+                if (isHorizontal) {
+                    context.fillRect(startX + offset[0] + backgroundOffset, 0, textSize, mainLineSize);
+                } else {
+                    context.translate(0, startY + offset[1]);
+                    context.rotate(-Math.PI / 2);
+                    context.fillRect(backgroundOffset, 0, textSize, mainLineSize);
+                }
+                context.restore();
+            }
+
+            context.save();
+            context.fillStyle = color;
+            if (isHorizontal) {
+                context.fillText(text, startX + offset[0], startY + offset[1]);
+            } else {
+                context.translate(startX + offset[0], startY + offset[1]);
+                context.rotate(-Math.PI / 2);
+                context.fillText(text, 0, 0);
+            }
+            context.restore();
+        });
+
+        context.restore();
+    }
+    private _getRulerScale() {
+        const defaultPixelScale = this.props.defaultPixelScale || 2;
+
+        if (!this._rulerScale) {
+            let isHighDensity = window.devicePixelRatio > 1;
+
+            if (!isHighDensity && window.matchMedia) {
+                const mq = window.matchMedia('only screen and (min--moz-device-pixel-ratio: 1.3), only screen and (-o-min-device-pixel-ratio: 2.6/2), only screen and (-webkit-min-device-pixel-ratio: 1.3), only screen  and (min-device-pixel-ratio: 1.3), only screen and (min-resolution: 1.3dppx)');
+                isHighDensity = mq && mq.matches;
+            }
+            this._rulerScale = isHighDensity ? 3 : defaultPixelScale;
+        }
+        return this._rulerScale;
+    }
+    private _checkResize = () => {
+        this.resize();
+    }
+}
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html b/release/0.29.2/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html new file mode 100644 index 0000000..a5b5965 --- /dev/null +++ b/release/0.29.2/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html @@ -0,0 +1,314 @@ + + + + + node_modules/@scena/react-ruler/src/react-ruler/types.ts - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

node_modules/@scena/react-ruler/src/react-ruler/types.ts

+ + + + + + + +
+
+ 
import { IObject } from "@daybrush/utils";
+
+/**
+ * @typedef
+ * @memberof Ruler
+ */
+export interface RulerInterface {
+    /**
+     * Scroll to that location. It can be used when the scrollPos prop is not used.
+     * @param - scroll position
+     */
+    scroll(scrollPos: number): void;
+    /**
+     * Recalculate the style of the ruler.
+     */
+    resize(): void;
+    /**
+     * Gets the scroll position of the ruler.
+     */
+    getScrollPos(): number;
+    /**
+     * draw a ruler
+     */
+    draw(options?: DrawRulerOptions): void;
+}
+
+export interface DrawRulerOptions {
+    scrollPos?: number;
+    zoom?: number;
+    selectedRanges?: number[][];
+    marks?: number[];
+    unit?: number;
+    segment?: number;
+}
+
+/**
+ * @typedef
+ * @memberof Ruler
+ */
+export interface RulerProps {
+    /**
+     * ruler's direction
+     * @default "horizontal"
+     */
+    type?: "horizontal" | "vertical";
+    /**
+     * ruler's width
+     * @default target's offsetWidth
+     */
+    width?: number;
+    /**
+     * ruler's height
+     * @default target's offsetHeight
+     */
+    height?: number;
+    /**
+     * main scale unit
+     * @default 50
+     * @example
+     * ```
+     * 1px (Default) zoom: 1, unit: 50 (every 50px)
+     * 1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+     * 1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+     * ```
+     */
+    unit?: number;
+    /**
+     * zoom
+     * @default 1
+     * @example
+     * ```
+     * 1px (Default) zoom: 1, unit: 50 (every 50px)
+     * 1cm = 37.7952px zoom: 37.7952 unit: 1 (every 1cm)
+     * 1in = 96px = 2.54cm zoom: 9 unit: 1 (every 1in)
+     * ```
+     */
+    zoom?: number;
+    /**
+     * line's direction (align)
+     * @default "end"
+     */
+    direction?: "start" | "center" | "end";
+    /**
+     * text align
+     * @default "start"
+     */
+    textAlign?: "left" | "center" | "right";
+    /**
+     * font and size
+     * @default "10px sans-serif"
+     */
+    font?: string;
+    /**
+     * Number of areas to divide between two main lines
+     * @default 10
+     */
+    segment?: number;
+    /**
+     * main line size
+     * @default "100%"
+     */
+    mainLineSize?: string | number;
+    /**
+     * long line size
+     * @default 10
+     */
+    longLineSize?: string | number;
+    /**
+     * short line size
+     * @default 7
+     */
+    shortLineSize?: string | number;
+    /**
+     * line's position offset
+     * @default [0, 0]
+     */
+    lineOffset?: number[];
+    /**
+     * text's position offset
+     * @default [0, 0]
+     */
+    textOffset?: number[];
+    /**
+     * Whether to display the ruler in the negative direction.
+     * @default true
+     */
+    negativeRuler?: boolean;
+    /**
+     * The range to show the ruler's scales
+     * @default [-Infinity, Infinity]
+     */
+    range?: [number, number];
+    /**
+     * you can set scroll position by prop.
+     * If you use the scrollPos prop, you can't use the scroll method.
+     * @default undefined
+     */
+    scrollPos?: number;
+    /**
+     * you can set scroll position by prop for init.
+     * don't use `scrollPos` prop
+     * @default 0
+     */
+    defaultScrollPos?: number;
+    /**
+     * ruler canvas style
+     */
+    style?: IObject<any>;
+    /**
+     * ruler's background color
+     * @default "#333333"
+     */
+    backgroundColor?: string;
+    /**
+     * background color within range in ruler
+     * @default "transparent"
+     */
+    rangeBackgroundColor?: string;
+    /**
+     * ruler's line color
+     * @default "#777777"
+     */
+    lineColor?: string;
+    /**
+     * ruler's text color
+     * @default "#ffffff"
+     */
+    textColor?: string;
+    /**
+     * The background color that wraps the text
+     * @default "transparent"
+     */
+    textBackgroundColor?: string;
+    /**
+     * text foramt
+     * @default ownself
+     */
+    textFormat?: (scale: number) => string;
+    /**
+     * positions to mark
+     * @default []
+     */
+    marks?: number[];
+    /**
+     * @default "#f55"
+     *
+     */
+    markColor?: string;
+    /**
+     * Ruler's line width
+     * @default 1
+     */
+    lineWidth?: number;
+    /**
+     * Whether to warp self
+     */
+    warpSelf?: boolean;
+    /**
+     * You can paint the selected area(selectedranges) with the `selectedBackgroundColor` color.
+     */
+    selectedRanges?: number[][];
+    /**
+     * background color within selected range in ruler with `selectedRanges` area
+     * @default "#555555"
+     */
+    selectedBackgroundColor?: string;
+    /**
+     * Text is displayed in the selected ranges. If it overlaps existing text, only the selected range text is visible.
+     * @since 0.16.0
+     * @default false
+     */
+    selectedRangesText?: boolean;
+    /**
+     * Position offset of text in selected ranges
+     * @since 0.16.0
+     * @default "0, 0"
+     */
+    selectedRangesTextOffset?: number[];
+    /**
+     * Color of text in selected ranges
+     * @since 0.16.0
+     * @default "#44aaff"
+     */
+    selectedRangesTextColor?: string;
+    /**
+     * Scale value of canvase when device high density is 1.
+     * Less than 2 may cause pixels to blur.
+     * If device high density is greater than 1, it is forcibly set to 3.
+     * @default 2
+     */
+    defaultPixelScale?: number;
+    /**
+     * Whether to use the resize observer. When the size changes, the resize method is automatically called.
+     */
+    useResizeObserver?: boolean;
+}
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/packages_guides_src_GuidesManager.tsx.html b/release/0.29.2/doc/packages_guides_src_GuidesManager.tsx.html new file mode 100644 index 0000000..4e9a352 --- /dev/null +++ b/release/0.29.2/doc/packages_guides_src_GuidesManager.tsx.html @@ -0,0 +1,189 @@ + + + + + packages/guides/src/GuidesManager.tsx - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

packages/guides/src/GuidesManager.tsx

+ + + + + + + +
+
+ 
import { ref, Properties } from "framework-utils";
+import * as React from "react";
+import { PROPERTIES, METHODS, EVENTS } from "./consts";
+import { GuidesInterface, GuidesEvents, GuidesOptions } from "@scena/react-guides/declaration/types";
+import InnerGuides from "./InnerGuides";
+import EventEmitter from "@scena/event-emitter";
+import { camelize } from "@daybrush/utils";
+import { ContainerProvider, renderSelf } from "croact";
+
+@Properties(METHODS as any, (prototype, property) => {
+    if (prototype[property]) {
+        return;
+    }
+    prototype[property] = function(...args) {
+        const self = this.getInnerGuides();
+
+        if (!self || !self[property]) {
+            return;
+        }
+        return self[property](...args);
+    };
+})
+@Properties(PROPERTIES, (prototype, property) => {
+    Object.defineProperty(prototype, property, {
+        get() {
+            return this.getInnerGuides().props[property];
+        },
+        set(value) {
+            this.innerGuides.setState({
+                [property]: value,
+            });
+        },
+        enumerable: true,
+        configurable: true,
+    });
+})
+/**
+ * @sort 1
+ * @extends EventEmitter
+ */
+class Guides extends EventEmitter<GuidesEvents> {
+    private containerProvider: ContainerProvider | null = null;
+    private selfElement: HTMLElement | null = null;
+    private _warp = false;
+    private innerGuides!: InnerGuides;
+    /**
+     * @sort 1
+     * @param - guides' container
+     * @param {$ts:Partial<Guides.GuidesOptions>} - guides' options
+     */
+    constructor(container: HTMLElement, options: Partial<GuidesOptions> = {}) {
+        super();
+        const events: any = {};
+
+        EVENTS.forEach(name => {
+            events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);
+        });
+        let selfElement!: HTMLElement;
+
+        if (options.warpSelf) {
+            delete options.warpSelf;
+            this._warp = true;
+            selfElement = container;
+        } else {
+            selfElement = document.createElement("div");
+            container.appendChild(selfElement);
+        }
+        this.containerProvider = renderSelf(
+            <InnerGuides ref={ref(this, "innerGuides")}
+                {...events}
+                {...options} />,
+            selfElement,
+        );
+    }
+    /**
+     * @param state
+     * @param callback
+     */
+    public setState(state: Partial<GuidesOptions>, callback?: () => void) {
+        this.innerGuides.setState(state, callback);
+    }
+    /**
+     * @param callback
+     */
+    public forceUpdate(callback?: () => void) {
+        this.innerGuides.forceUpdate(callback);
+    }
+    /**
+     * destroy guides
+     */
+    public destroy() {
+        const selfElement = this.selfElement!;
+
+        renderSelf(
+            null,
+            selfElement!,
+            this.containerProvider,
+        );
+        if (!this._warp) {
+            selfElement?.parentElement?.removeChild(selfElement);
+        }
+        this.selfElement = null;
+        this.innerGuides = null;
+    }
+    private getInnerGuides() {
+        return this.innerGuides.guides;
+    }
+}
+interface Guides extends GuidesInterface {}
+
+export default Guides;
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/packages_react-guides_src_react-guides_Guides.tsx.html b/release/0.29.2/doc/packages_react-guides_src_react-guides_Guides.tsx.html new file mode 100644 index 0000000..df570ad --- /dev/null +++ b/release/0.29.2/doc/packages_react-guides_src_react-guides_Guides.tsx.html @@ -0,0 +1,688 @@ + + + + + packages/react-guides/src/react-guides/Guides.tsx - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

packages/react-guides/src/react-guides/Guides.tsx

+ + + + + + + +
+
+ 
import * as React from "react";
+import Ruler, { DrawRulerOptions, PROPERTIES as RULER_PROPERTIES, RulerProps } from "@scena/react-ruler";
+import { ref, refs } from "framework-utils";
+import DragScroll from "@scena/dragscroll";
+import Gesto, { OnDrag, OnDragEnd, OnDragStart } from "gesto";
+import { styled } from "react-css-styled";
+import { GUIDES, GUIDE, DRAGGING, ADDER, DISPLAY_DRAG, GUIDES_CSS } from "./consts";
+import { prefix } from "./utils";
+import { hasClass, addClass, removeClass } from "@daybrush/utils";
+import { GuidesState, GuidesProps, GuidesInterface } from "./types";
+import { getDistElementMatrix, calculateMatrixDist } from "css-to-mat";
+
+const GuidesElement = styled("div", GUIDES_CSS);
+
+export default class Guides extends React.PureComponent<GuidesProps, GuidesState> implements GuidesInterface {
+    public static defaultProps: GuidesProps = {
+        className: "",
+        type: "horizontal",
+        zoom: 1,
+        guidesZoom: 0,
+        style: {},
+        snapThreshold: 5,
+        snaps: [],
+        digit: 0,
+        onClickRuler: () => { },
+        onChangeGuides: () => { },
+        onRequestScroll: () => { },
+        onDragStart: () => { },
+        onDrag: () => { },
+        onDragEnd: () => { },
+        displayDragPos: false,
+        dragPosFormat: v => v,
+        defaultGuides: [],
+        lockGuides: false,
+        showGuides: true,
+        guideStyle: {},
+        dragGuideStyle: {},
+        guidePosStyle: {},
+        defaultGuidesPos: 0,
+    };
+    public state: GuidesState = {
+        guides: [],
+    };
+    public adderElement!: HTMLElement;
+    public scrollPos: number = 0;
+    public ruler!: Ruler;
+    private managerRef = React.createRef<HTMLElement>();
+    private guidesElement!: HTMLElement;
+    private displayElement!: HTMLElement;
+    private originElement!: HTMLElement;
+    private gesto!: Gesto;
+    private guideElements: HTMLElement[] = [];
+    private _isFirstMove = false;
+    private _zoom = 1;
+    private _guidesZoom = 1;
+    private _observer: ResizeObserver | null = null;
+
+    constructor(props: GuidesProps) {
+        super(props);
+        this.state.guides = props.defaultGuides || [];
+        this.scrollPos = props.defaultGuidesPos || 0;
+    }
+    public render() {
+        const {
+            className,
+            type,
+            zoom,
+            guidesZoom,
+            style,
+            rulerStyle,
+            displayDragPos,
+            cspNonce,
+            dragGuideStyle,
+            guidePosStyle = {}
+        } = this.props as Required<GuidesProps>;
+        const props = this.props;
+        const translateName = this.getTranslateName();
+        const rulerProps: RulerProps = {};
+
+        RULER_PROPERTIES.forEach(name => {
+            if (name === "style" || name === "warpSelf" || name === "useResizeObserver") {
+                return;
+            }
+            (rulerProps as any)[name] = props[name];
+        });
+
+        this._zoom = zoom;
+        this._guidesZoom = guidesZoom || zoom;
+
+        return <GuidesElement
+            ref={this.managerRef}
+            cspNonce={cspNonce}
+            className={`${prefix("manager", type)} ${className}`}
+            style={style}
+        >
+            <div className={prefix("guide-origin")} ref={ref(this, "originElement")}></div>
+            <Ruler
+                ref={ref(this, "ruler")}
+                style={rulerStyle}
+                {...rulerProps}
+            />
+            <div className={GUIDES} ref={ref(this, "guidesElement")} style={{
+                transform: `${translateName}(${-this.scrollPos * this._guidesZoom}px)`,
+            }}>
+                {displayDragPos && <div className={DISPLAY_DRAG}
+                    ref={ref(this, "displayElement")} style={guidePosStyle || {}} />}
+                <div className={ADDER} ref={ref(this, "adderElement")} style={dragGuideStyle} />
+                {this.renderGuides()}
+            </div>
+        </GuidesElement>;
+    }
+    /**
+     * Draw ruler
+     */
+    public drawRuler(options: DrawRulerOptions) {
+        this.ruler.draw(options);
+    }
+    public renderGuides() {
+        const props = this.props;
+        const {
+            type,
+            showGuides,
+            guideStyle,
+            displayGuidePos,
+            guidePosStyle = {},
+            guidesOffset,
+        } = props as Required<GuidesProps>;
+
+        const zoom = this._guidesZoom;
+        const translateName = this.getTranslateName();
+        const guides = this.state.guides;
+        const guidePosFormat = props.guidePosFormat || props.dragPosFormat || (v => v);
+
+        this.guideElements = [];
+        if (showGuides) {
+            return guides.map((pos, i) => {
+                const guidePos = pos + (guidesOffset || 0);
+
+                return (<div className={prefix("guide", type)}
+                    ref={refs(this, "guideElements", i)}
+                    key={i}
+                    data-index={i}
+                    data-pos={pos}
+                    style={{
+                        ...guideStyle,
+                        transform: `${translateName}(${guidePos * zoom}px) translateZ(0px)`,
+                    }}>
+                    {displayGuidePos && <div className={prefix("guide-pos")} style={guidePosStyle || {}}>
+                        {guidePosFormat!(pos)}
+                    </div>}
+                </div>);
+            });
+        }
+        return;
+    }
+    public componentDidMount() {
+        this.gesto = new Gesto(this.managerRef.current!, {
+            container: document.body,
+        }).on("dragStart", e => {
+            const {
+                type,
+                lockGuides,
+            } = this.props;
+            const zoom = this._guidesZoom;
+
+            if (lockGuides === true) {
+                e.stop();
+                return;
+            }
+            const inputEvent = e.inputEvent;
+            const target = inputEvent.target;
+            const datas = e.datas;
+            const canvasElement = this.ruler.canvasElement;
+            const guidesElement = this.guidesElement;
+            const isHorizontal = type === "horizontal";
+            const originRect = this.originElement.getBoundingClientRect();
+            const matrix = getDistElementMatrix(this.managerRef.current!);
+            const offsetPos = calculateMatrixDist(matrix, [
+                e.clientX - originRect.left,
+                e.clientY - originRect.top,
+            ]);
+            offsetPos[0] -= guidesElement.offsetLeft;
+            offsetPos[1] -= guidesElement.offsetTop;
+            offsetPos[isHorizontal ? 1 : 0] += this.scrollPos * zoom!;
+
+            datas.offsetPos = offsetPos;
+            datas.matrix = matrix;
+
+            let isLockAdd = lockGuides && lockGuides.indexOf("add") > -1;
+            let isLockRemove = lockGuides && lockGuides.indexOf("remove") > -1;
+            let isLockChange = lockGuides && lockGuides.indexOf("change") > -1;
+
+            if (target === canvasElement) {
+                if (isLockAdd) {
+                    e.stop();
+                    return;
+                }
+                datas.fromRuler = true;
+                datas.target = this.adderElement;
+                // add
+            } else if (hasClass(target, GUIDE)) {
+                if (isLockRemove && isLockChange) {
+                    e.stop();
+                    return;
+                }
+                datas.target = target;
+                // change
+            } else {
+                e.stop();
+                return false;
+            }
+            this.onDragStart(e);
+        }).on("drag", this._onDrag).on("dragEnd", this.onDragEnd);
+
+        if (this.props.useResizeObserver) {
+            this._observer = new ResizeObserver(this._onCheck);
+            this._observer.observe(this.guidesElement, {
+                box: "border-box",
+            });
+            this._observer.observe(this.getRulerElement(), {
+                box: "border-box",
+            });
+        } else {
+            this._onCheck();
+        }
+    }
+    public componentWillUnmount() {
+        this.gesto.unset();
+        this._observer?.disconnect();
+    }
+    public componentDidUpdate(prevProps: any) {
+        const nextGuides = this.props.defaultGuides;
+
+        if (prevProps.defaultGuides !== nextGuides) {
+            // to dynamically update guides from code rather than dragging guidelines
+            this.setState({ guides: nextGuides || [] });
+        }
+    }
+    /**
+     * Load the current guidelines.
+     * @memberof Guides
+     * @instance
+     */
+    public loadGuides(guides: number[]) {
+        this.setState({
+            guides,
+        });
+    }
+    /**
+     * Get current guidelines.
+     * @memberof Guides
+     * @instance
+     */
+    public getGuides(): number[] {
+        return this.state.guides;
+    }
+    /**
+     * Scroll the positions of the guidelines opposite the ruler.
+     * @memberof Guides
+     * @instance
+     */
+    public scrollGuides(pos: number, nextZoom = this._guidesZoom) {
+        this._setZoom({ guidesZoom: nextZoom });
+        const translateName = this.getTranslateName();
+        const guidesElement = this.guidesElement;
+
+        this.scrollPos = pos;
+        guidesElement.style.transform = `${translateName}(${-pos * nextZoom}px)`;
+
+        const guides = this.state.guides;
+        const guidesOffset = this.props.guidesOffset || 0;
+        this.guideElements.forEach((el, i) => {
+            if (!el) {
+                return;
+            }
+            const guidePos = guides[i] + (guidesOffset || 0);
+
+            el.style.transform = `${translateName}(${guidePos * nextZoom}px) translateZ(0px)`;
+            el.style.display = -pos + guidePos < 0 ? "none" : "block";
+        });
+    }
+    /**
+     * Set to the next zoom.
+     * @memberof Guides
+     * @since 0.22.0
+     * @param nextZoom - next zoom
+     */
+    public zoomTo(nextZoom: number, nextGuidesZoom = nextZoom) {
+        this.scroll(this.getRulerScrollPos(), nextZoom);
+        this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);
+    }
+    /**
+     * Get Guides DOM Element
+     * @memberof Guides
+     * @instance
+     */
+    public getElement() {
+        return this.managerRef.current!;
+    }
+    /**
+     * Get Ruler DOM Element
+     * @memberof Guides
+     * @instance
+     */
+    public getRulerElement() {
+        return this.ruler.canvasElement;
+    }
+    /**
+     * Scroll position of guides (horizontal: y, vertical: x)
+     */
+    public getGuideScrollPos() {
+        return this.scrollPos;
+    }
+    /**
+     * Scroll position of the ruler (horizontal: x, vertical: y)
+     */
+    public getRulerScrollPos() {
+        return this.ruler.getScrollPos();
+    }
+    /**
+     * Scroll the position of the ruler.
+     * @memberof Guides
+     * @instance
+     */
+    public scroll(pos: number, nextZoom = this._zoom) {
+        this._setZoom({ zoom: nextZoom });
+        this.ruler.scroll(pos, nextZoom);
+    }
+    /**
+     * Recalculate the size of the ruler.
+     * @memberof Guides
+     * @instance
+     */
+    public resize(nextZoom = this._zoom) {
+        this._setZoom({ zoom: nextZoom });
+        this.ruler.resize(nextZoom);
+    }
+    private onDragStart = (e: any) => {
+        const { datas, inputEvent } = e;
+
+        this._isFirstMove = true;
+        this.movePos(e);
+
+        /**
+         * When the drag starts, the dragStart event is called.
+         * @memberof Guides
+         * @event dragStart
+         * @param {OnDragStart} - Parameters for the dragStart event
+         */
+        this.props.onDragStart!({
+            ...e,
+            dragElement: datas.target,
+        });
+
+        if (!this.gesto.isFlag()) {
+            return;
+        }
+        inputEvent.stopPropagation();
+        inputEvent.preventDefault();
+
+
+        this._startDragScroll(e);
+    }
+    private _onDrag = (e: any) => {
+        if (this._isFirstMove) {
+            this._isFirstMove = false;
+            addClass(e.datas.target, DRAGGING);
+        }
+        const nextPos = this.movePos(e);
+
+        /**
+         * When dragging, the drag event is called.
+         * @memberof Guides
+         * @event drag
+         * @param {OnDrag} - Parameters for the drag event
+         */
+        this.props.onDrag!({
+            ...e,
+            dragElement: e.datas.target,
+        });
+
+        if (!this.gesto.isFlag()) {
+            this._endDragScroll(e);
+            return;
+        }
+
+        this._dragScroll(e);
+        return nextPos;
+    }
+    private onDragEnd = (e: OnDragEnd) => {
+        const { datas, isDouble, distX, distY } = e;
+        const pos = this.movePos(e);
+        let guides = this.state.guides;
+        const { onChangeGuides, displayDragPos, digit, lockGuides, guidesOffset } = this.props;
+        const zoom = this._guidesZoom;
+        const guidePos = parseFloat((pos / zoom!).toFixed(digit || 0));
+        const baseScrollPos = this.scrollPos - (guidesOffset || 0);
+
+        if (displayDragPos) {
+            this.displayElement.style.cssText += `display: none;`;
+        }
+        removeClass(datas.target, DRAGGING);
+        /**
+         * When the drag finishes, the dragEnd event is called.
+         * @memberof Guides
+         * @event dragEnd
+         * @param {OnDragEnd} - Parameters for the dragEnd event
+         */
+        this.props.onDragEnd!({
+            ...e,
+            dragElement: datas.target,
+        });
+
+        this._endDragScroll(e);
+        if (datas.fromRuler) {
+            if (this._isFirstMove) {
+                /**
+                 * When click the ruler, the click ruler is called.
+                 * @memberof Guides
+                 * @event clickRuler
+                 * @param {OnClickRuler} - Parameters for the clickRuler event
+                 */
+                this.props.onClickRuler!({
+                    ...e,
+                    pos: 0,
+                });
+            }
+            if (guidePos >= baseScrollPos && guides.indexOf(guidePos) < 0) {
+                this.setState({
+                    guides: [...guides, guidePos],
+                }, () => {
+                    /**
+                     * The `changeGuides` event occurs when the guideline is added / removed / changed.
+                     * @memberof Guides
+                     * @event changeGuides
+                     * @param {OnChangeGuides} - Parameters for the changeGuides event
+                     */
+                    onChangeGuides!({
+                        guides: this.state.guides,
+                        distX,
+                        distY,
+                        index: guides.length,
+                        isAdd: true,
+                        isRemove: false,
+                        isChange: false,
+                    });
+                });
+            }
+        } else {
+            const index = parseFloat(datas.target.getAttribute("data-index"));
+            let isRemove = false;
+            let isChange = false;
+
+            guides = [...guides];
+
+            const guideIndex = guides.indexOf(guidePos);
+            if (
+                isDouble
+                || guidePos < baseScrollPos
+                || (guideIndex > -1 && guideIndex !== index)
+            ) {
+                if (lockGuides && (lockGuides === true || lockGuides.indexOf("remove") > -1)) {
+                    return;
+                }
+                guides.splice(index, 1);
+                isRemove = true;
+            } else if (guideIndex > -1) {
+                return;
+            } else {
+                if (lockGuides && (lockGuides === true || lockGuides.indexOf("change") > -1)) {
+                    return;
+                }
+                guides[index] = guidePos;
+                isChange = true;
+            }
+            this.setState({
+                guides,
+            }, () => {
+                const nextGuides = this.state.guides;
+                onChangeGuides!({
+                    distX,
+                    distY,
+                    guides: nextGuides,
+                    isAdd: false,
+                    index,
+                    isChange,
+                    isRemove,
+                });
+            });
+        }
+    }
+    private movePos(e: any) {
+        const { datas, distX, distY } = e;
+        const props = this.props;
+        const {
+            type, snaps, snapThreshold,
+            displayDragPos,
+            digit,
+        } = props;
+        const guidesOffset = props.guidesOffset || 0;
+        const zoom = this._guidesZoom;
+        const dragPosFormat = props.dragPosFormat || (v => v);
+        const isHorizontal = type === "horizontal";
+        const matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);
+        const offsetPos = datas.offsetPos;
+        const offsetX = matrixPos[0] + offsetPos[0];
+        const offsetY = matrixPos[1] + offsetPos[1];
+        const guidesZoomOffset = guidesOffset * zoom;
+        let nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;
+        let guidePos = parseFloat((nextPos / zoom!).toFixed(digit || 0));
+        const guideSnaps = snaps!.slice().sort((a, b) => {
+            return Math.abs(guidePos - a) - Math.abs(guidePos - b);
+        });
+
+        if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom! - nextPos) < snapThreshold!) {
+            guidePos = guideSnaps[0];
+            nextPos = guidePos * zoom!;
+        }
+        if (!datas.fromRuler || !this._isFirstMove) {
+            if (displayDragPos) {
+                const displayPos = type === "horizontal"
+                    ? [offsetX, nextPos + guidesZoomOffset]
+                    : [nextPos + guidesZoomOffset, offsetY];
+
+                this.displayElement.style.cssText += `display: block;`
+                    + `transform: translate(-50%, -50%) `
+                    + `translate(${displayPos.map(v => `${v}px`).join(", ")})`;
+                this.displayElement.innerHTML = `${dragPosFormat!(guidePos)}`;
+            }
+            const target = datas.target;
+
+
+            target.setAttribute("data-pos", guidePos);
+            target.style.transform = `${this.getTranslateName()}(${nextPos + guidesOffset * zoom}px)`;
+        }
+
+        return nextPos;
+    }
+    private getTranslateName() {
+        return this.props.type === "horizontal" ? "translateY" : "translateX";
+    }
+
+    private _startDragScroll(e: OnDragStart) {
+        const scrollOptions = this.props.scrollOptions;
+
+        if (!scrollOptions) {
+            return;
+        }
+        const datas = e.datas;
+        const dragScroll = new DragScroll();
+
+        datas.dragScroll = dragScroll;
+        dragScroll.on("scroll", ({ container, direction }) => {
+            /**
+             * If scroll can be triggered through drag, the `requestScroll` event is fired.
+             * @memberof Guides
+             * @event requestScroll
+             * @param {OnRequestScroll} - Parameters for the `requestScroll` event
+             */
+            this.props.onRequestScroll?.({ container, direction });
+        }).on("move", ({ offsetX, offsetY, inputEvent }) => {
+            this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);
+        });
+        dragScroll.dragStart(e, {
+            container: scrollOptions.container,
+        });
+    }
+    private _dragScroll(e: OnDrag) {
+        const scrollOptions = this.props.scrollOptions;
+
+        if (!scrollOptions) {
+            return;
+        }
+        const dragScroll = e.datas.dragScroll as DragScroll;
+
+        dragScroll.drag(e, scrollOptions);
+    }
+    private _endDragScroll(e: OnDragEnd) {
+        e.datas.dragScroll?.dragEnd();
+        e.datas.dragScroll = null;
+    }
+    private _onCheck = () => {
+        this.resize();
+    }
+    private _setZoom(zooms: { zoom?: number; guidesZoom?: number }) {
+        const {
+            zoom: nextZoom,
+            guidesZoom: nextGuidesZoom,
+        } = zooms;
+        const hasZoom = !!this.props.zoom;
+        const hasGuidesZoom = !!this.props.guidesZoom;
+
+        if (hasGuidesZoom) {
+            if (nextGuidesZoom) {
+                this._guidesZoom = nextGuidesZoom;
+            }
+        } else {
+            if (nextGuidesZoom) {
+                this._zoom = nextGuidesZoom;
+                this._guidesZoom = nextGuidesZoom;
+            }
+            if (nextZoom) {
+                this._guidesZoom = nextZoom;
+            }
+        }
+        if (nextZoom) {
+            this._zoom  = nextZoom;
+        }
+    }
+}
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/packages_react-guides_src_react-guides_types.ts.html b/release/0.29.2/doc/packages_react-guides_src_react-guides_types.ts.html new file mode 100644 index 0000000..bc38756 --- /dev/null +++ b/release/0.29.2/doc/packages_react-guides_src_react-guides_types.ts.html @@ -0,0 +1,303 @@ + + + + + packages/react-guides/src/react-guides/types.ts - Documentation + + + + + + + + + + + + + + + + + + + + + +
+ +

packages/react-guides/src/react-guides/types.ts

+ + + + + + + +
+
+ 
import { DrawRulerOptions, RulerProps } from "@scena/react-ruler/declaration/types";
+import { IObject } from "@daybrush/utils";
+import {
+    OnDragStart as OnGestoDragStart,
+    OnDrag as OnGestoDrag,
+    OnDragEnd as OnGestoDragEnd,
+} from "gesto";
+import { DragScrollOptions } from "@scena/dragscroll";
+
+
+export interface GuidesState {
+    guides: number[];
+}
+
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Ruler.RulerProps
+ */
+export interface GuidesOptions extends RulerProps {
+    /**
+     * guides' class name
+     * @default ""
+     */
+    className?: string;
+    /**
+     * ruler's css style
+     * @default "width 100%, height: 100%"
+     */
+    rulerStyle?: IObject<any>;
+    /**
+     * Interval to snap
+     * @default 5
+     */
+    snapThreshold?: number;
+    /**
+     * Positions to snap
+     * @default []
+     */
+    snaps?: number[];
+    /**
+     * Whether to show the moving pos when dragging
+     * @default false
+     */
+    displayDragPos?: boolean;
+    /**
+     * guides zoom(side zoom). If not set, it is the same as `zoom`.
+     * @default zoom
+     * @since 0.29.0
+     */
+    guidesZoom?: number;
+    /**
+     * csp nonce
+     */
+    cspNonce?: string;
+    /**
+     * Format of drag pos
+     * @default self
+     */
+    dragPosFormat?: (value: number) => string | number;
+    /**
+     * default guidelines
+     * @default []
+     */
+    defaultGuides?: number[];
+    /**
+     * default guide pos for init
+     * @default 0
+     */
+    defaultGuidesPos?: number
+    /**
+     * Whether to show guidelines
+     * @default true
+     */
+    showGuides?: boolean;
+    /**
+     * Whether to lock add/remove/change functions via drag/click of guides
+     * @default false
+     */
+    lockGuides?: boolean | Array<"add" | "change" | "remove">;
+    /**
+     * pos digit of guidelines
+     * @default 0
+     */
+    digit?: number;
+    /**
+     * CSS style objects for guide elements
+     * @default "{}"
+     */
+    guideStyle?: Record<string, any>;
+    /**
+     * CSS style objects for drag guide element
+     * @default "{}"
+     */
+    dragGuideStyle?: Record<string, any>;
+    /**
+     * Whether to show the guide pos text
+     * @default false
+     */
+    displayGuidePos?: boolean;
+    /**
+     * Format of displayed guide pos
+     * @default dragPosFormat
+     */
+    guidePosFormat?: (value: number) => string | number;
+    /**
+     * CSS style objects for displayed guide pos text element
+     * @default: "{}"
+     */
+    guidePosStyle?: IObject<any>;
+    /**
+     * Set the scroll options, time, etc. to automatically scroll by dragging.
+     * @default null
+     */
+    scrollOptions?: DragScrollOptions | null;
+    /**
+     * Numerical value of how far away from the guideline position
+     * @since 0.22.0
+     * @default 0
+     */
+    guidesOffset?: number;
+}
+
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Guides.GuidesOptions
+ */
+export interface GuideOptions extends GuidesOptions {
+}
+
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Guides.GuidesOptions
+ */
+export interface GuidesProps extends GuidesOptions {
+    onChangeGuides?: (e: OnChangeGuides) => any;
+    onRequestScroll?: (e: OnRequestScroll) => any;
+    onDragStart?: (e: OnDragStart) => any;
+    onDrag?: (e: OnDrag) => any;
+    onDragEnd?: (e: OnDragEnd) => any;
+    onClickRuler?: (e: OnClickRuler) => any;
+}
+/**
+ * @typedef
+ * @memberof Guides
+ */
+export interface OnChangeGuides {
+    guides: number[];
+    isAdd: boolean;
+    isRemove: boolean;
+    isChange: boolean;
+    index: number;
+    distX: number;
+    distY: number;
+}
+/**
+ * @typedef
+ * @memberof Guides
+ */
+export interface OnRequestScroll {
+    container: HTMLElement | SVGElement;
+    direction: number[];
+}
+
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Gesto.OnDragStart
+ */
+export interface OnDragStart extends OnGestoDragStart {
+    dragElement: HTMLElement;
+}
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Gesto.OnDrag
+ */
+export interface OnDrag extends OnGestoDrag {
+    dragElement: HTMLElement;
+}
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Gesto.OnDragEnd
+ */
+export interface OnDragEnd extends OnGestoDragEnd {
+    dragElement: HTMLElement;
+}
+/**
+ * @typedef
+ * @memberof Guides
+ * @extends Gesto.OnDragEnd
+ */
+export interface OnClickRuler extends OnGestoDragEnd {
+    pos: number;
+}
+/**
+ * @typedef
+ * @memberof Guides
+ */
+export interface GuidesInterface {
+    getGuides(): number[];
+    scroll(pos: number): void;
+    scrollGuides(pos: number): void;
+    drawRuler(options: DrawRulerOptions): void;
+    loadGuides(guides: number[]): void;
+    resize(): void;
+    getElement(): HTMLElement;
+    getRulerElement(): HTMLCanvasElement;
+}
+
+/**
+ * @typedef
+ * @memberof Guides
+ */
+export interface GuidesEvents {
+    changeGuides: OnChangeGuides;
+    requestScroll: OnRequestScroll;
+    dragStart: OnDragStart;
+    drag: OnDrag;
+    dragEnd: OnDragEnd;
+    clickRuler: OnClickRuler;
+}
+
+
+
+ + + + + + + +
+ +
+ +
+ Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme. +
+ + + + + + + + diff --git a/release/0.29.2/doc/scripts/custom.js b/release/0.29.2/doc/scripts/custom.js new file mode 100644 index 0000000..a26d5ba --- /dev/null +++ b/release/0.29.2/doc/scripts/custom.js @@ -0,0 +1,12 @@ +(function () { + window.dataLayer = window.dataLayer || []; + function gtag() { dataLayer.push(arguments); } + gtag('js', new Date()); + + gtag('config', 'G-TRBNXHQ0ZF'); + var script = document.createElement("script"); + + script.src = "https://www.googletagmanager.com/gtag/js?id=G-TRBNXHQ0ZF"; + + document.body.appendChild(script); +})(); diff --git a/release/0.29.2/doc/scripts/linenumber.js b/release/0.29.2/doc/scripts/linenumber.js new file mode 100644 index 0000000..9cb8914 --- /dev/null +++ b/release/0.29.2/doc/scripts/linenumber.js @@ -0,0 +1,25 @@ +/*global document */ +(function() { + var source = document.getElementsByClassName('prettyprint source linenums'); + var i = 0; + var lineNumber = 0; + var lineId; + var lines; + var totalLines; + var anchorHash; + + if (source && source[0]) { + anchorHash = document.location.hash.substring(1); + lines = source[0].getElementsByTagName('li'); + totalLines = lines.length; + + for (; i < totalLines; i++) { + lineNumber++; + lineId = 'line' + lineNumber; + lines[i].id = lineId; + if (lineId === anchorHash) { + lines[i].className += ' selected'; + } + } + } +})(); diff --git a/release/0.29.2/doc/scripts/prettify/Apache-License-2.0.txt b/release/0.29.2/doc/scripts/prettify/Apache-License-2.0.txt new file mode 100644 index 0000000..75b5248 --- /dev/null +++ b/release/0.29.2/doc/scripts/prettify/Apache-License-2.0.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/release/0.29.2/doc/scripts/prettify/lang-css.js b/release/0.29.2/doc/scripts/prettify/lang-css.js new file mode 100644 index 0000000..bb6dbea --- /dev/null +++ b/release/0.29.2/doc/scripts/prettify/lang-css.js @@ -0,0 +1,2 @@ +PR.registerLangHandler(PR.createSimpleLexer([["pln",/^[\t\n\f\r ]+/,null," \t\r\n "]],[["str",/^"(?:[^\n\f\r"\\]|\\(?:\r\n?|\n|\f)|\\[\S\s])*"/,null],["str",/^'(?:[^\n\f\r'\\]|\\(?:\r\n?|\n|\f)|\\[\S\s])*'/,null],["lang-css-str",/^url\(([^"')]*)\)/i],["kwd",/^(?:url|rgb|!important|@import|@page|@media|@charset|inherit)(?=[^\w-]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*)\s*:/i],["com",/^\/\*[^*]*\*+(?:[^*/][^*]*\*+)*\//],["com", +/^(?:<\!--|--\>)/],["lit",/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],["lit",/^#[\da-f]{3,6}/i],["pln",/^-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*/i],["pun",/^[^\s\w"']+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[["kwd",/^-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[["str",/^[^"')]+/]]),["css-str"]); diff --git a/release/0.29.2/doc/scripts/prettify/prettify.js b/release/0.29.2/doc/scripts/prettify/prettify.js new file mode 100644 index 0000000..ec2a488 --- /dev/null +++ b/release/0.29.2/doc/scripts/prettify/prettify.js @@ -0,0 +1,28 @@ +var q=null;window.PR_SHOULD_USE_CONTINUATION=!0; +(function(){function L(a){function m(a){var f=a.charCodeAt(0);if(f!==92)return f;var b=a.charAt(1);return(f=r[b])?f:"0"<=b&&b<="7"?parseInt(a.substring(1),8):b==="u"||b==="x"?parseInt(a.substring(2),16):a.charCodeAt(1)}function e(a){if(a<32)return(a<16?"\\x0":"\\x")+a.toString(16);a=String.fromCharCode(a);if(a==="\\"||a==="-"||a==="["||a==="]")a="\\"+a;return a}function h(a){for(var f=a.substring(1,a.length-1).match(/\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\[0-3][0-7]{0,2}|\\[0-7]{1,2}|\\[\S\s]|[^\\]/g),a= +[],b=[],o=f[0]==="^",c=o?1:0,i=f.length;c122||(d<65||j>90||b.push([Math.max(65,j)|32,Math.min(d,90)|32]),d<97||j>122||b.push([Math.max(97,j)&-33,Math.min(d,122)&-33]))}}b.sort(function(a,f){return a[0]-f[0]||f[1]-a[1]});f=[];j=[NaN,NaN];for(c=0;ci[0]&&(i[1]+1>i[0]&&b.push("-"),b.push(e(i[1])));b.push("]");return b.join("")}function y(a){for(var f=a.source.match(/\[(?:[^\\\]]|\\[\S\s])*]|\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\\d+|\\[^\dux]|\(\?[!:=]|[()^]|[^()[\\^]+/g),b=f.length,d=[],c=0,i=0;c=2&&a==="["?f[c]=h(j):a!=="\\"&&(f[c]=j.replace(/[A-Za-z]/g,function(a){a=a.charCodeAt(0);return"["+String.fromCharCode(a&-33,a|32)+"]"}));return f.join("")}for(var t=0,s=!1,l=!1,p=0,d=a.length;p=5&&"lang-"===b.substring(0,5))&&!(o&&typeof o[1]==="string"))c=!1,b="src";c||(r[f]=b)}i=d;d+=f.length;if(c){c=o[1];var j=f.indexOf(c),k=j+c.length;o[2]&&(k=f.length-o[2].length,j=k-c.length);b=b.substring(5);B(l+i,f.substring(0,j),e,p);B(l+i+j,c,C(b,c),p);B(l+i+k,f.substring(k),e,p)}else p.push(l+i,b)}a.e=p}var h={},y;(function(){for(var e=a.concat(m), +l=[],p={},d=0,g=e.length;d=0;)h[n.charAt(k)]=r;r=r[1];n=""+r;p.hasOwnProperty(n)||(l.push(r),p[n]=q)}l.push(/[\S\s]/);y=L(l)})();var t=m.length;return e}function u(a){var m=[],e=[];a.tripleQuotedStrings?m.push(["str",/^(?:'''(?:[^'\\]|\\[\S\s]|''?(?=[^']))*(?:'''|$)|"""(?:[^"\\]|\\[\S\s]|""?(?=[^"]))*(?:"""|$)|'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$))/,q,"'\""]):a.multiLineStrings?m.push(["str",/^(?:'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$)|`(?:[^\\`]|\\[\S\s])*(?:`|$))/, +q,"'\"`"]):m.push(["str",/^(?:'(?:[^\n\r'\\]|\\.)*(?:'|$)|"(?:[^\n\r"\\]|\\.)*(?:"|$))/,q,"\"'"]);a.verbatimStrings&&e.push(["str",/^@"(?:[^"]|"")*(?:"|$)/,q]);var h=a.hashComments;h&&(a.cStyleComments?(h>1?m.push(["com",/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,q,"#"]):m.push(["com",/^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\n\r]*)/,q,"#"]),e.push(["str",/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,q])):m.push(["com",/^#[^\n\r]*/, +q,"#"]));a.cStyleComments&&(e.push(["com",/^\/\/[^\n\r]*/,q]),e.push(["com",/^\/\*[\S\s]*?(?:\*\/|$)/,q]));a.regexLiterals&&e.push(["lang-regex",/^(?:^^\.?|[!+-]|!=|!==|#|%|%=|&|&&|&&=|&=|\(|\*|\*=|\+=|,|-=|->|\/|\/=|:|::|;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|[?@[^]|\^=|\^\^|\^\^=|{|\||\|=|\|\||\|\|=|~|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\s*(\/(?=[^*/])(?:[^/[\\]|\\[\S\s]|\[(?:[^\\\]]|\\[\S\s])*(?:]|$))+\/)/]);(h=a.types)&&e.push(["typ",h]);a=(""+a.keywords).replace(/^ | $/g, +"");a.length&&e.push(["kwd",RegExp("^(?:"+a.replace(/[\s,]+/g,"|")+")\\b"),q]);m.push(["pln",/^\s+/,q," \r\n\t\xa0"]);e.push(["lit",/^@[$_a-z][\w$@]*/i,q],["typ",/^(?:[@_]?[A-Z]+[a-z][\w$@]*|\w+_t\b)/,q],["pln",/^[$_a-z][\w$@]*/i,q],["lit",/^(?:0x[\da-f]+|(?:\d(?:_\d+)*\d*(?:\.\d*)?|\.\d\+)(?:e[+-]?\d+)?)[a-z]*/i,q,"0123456789"],["pln",/^\\[\S\s]?/,q],["pun",/^.[^\s\w"-$'./@\\`]*/,q]);return x(m,e)}function D(a,m){function e(a){switch(a.nodeType){case 1:if(k.test(a.className))break;if("BR"===a.nodeName)h(a), +a.parentNode&&a.parentNode.removeChild(a);else for(a=a.firstChild;a;a=a.nextSibling)e(a);break;case 3:case 4:if(p){var b=a.nodeValue,d=b.match(t);if(d){var c=b.substring(0,d.index);a.nodeValue=c;(b=b.substring(d.index+d[0].length))&&a.parentNode.insertBefore(s.createTextNode(b),a.nextSibling);h(a);c||a.parentNode.removeChild(a)}}}}function h(a){function b(a,d){var e=d?a.cloneNode(!1):a,f=a.parentNode;if(f){var f=b(f,1),g=a.nextSibling;f.appendChild(e);for(var h=g;h;h=g)g=h.nextSibling,f.appendChild(h)}return e} +for(;!a.nextSibling;)if(a=a.parentNode,!a)return;for(var a=b(a.nextSibling,0),e;(e=a.parentNode)&&e.nodeType===1;)a=e;d.push(a)}var k=/(?:^|\s)nocode(?:\s|$)/,t=/\r\n?|\n/,s=a.ownerDocument,l;a.currentStyle?l=a.currentStyle.whiteSpace:window.getComputedStyle&&(l=s.defaultView.getComputedStyle(a,q).getPropertyValue("white-space"));var p=l&&"pre"===l.substring(0,3);for(l=s.createElement("LI");a.firstChild;)l.appendChild(a.firstChild);for(var d=[l],g=0;g=0;){var h=m[e];A.hasOwnProperty(h)?window.console&&console.warn("cannot override language handler %s",h):A[h]=a}}function C(a,m){if(!a||!A.hasOwnProperty(a))a=/^\s*=o&&(h+=2);e>=c&&(a+=2)}}catch(w){"console"in window&&console.log(w&&w.stack?w.stack:w)}}var v=["break,continue,do,else,for,if,return,while"],w=[[v,"auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"], +"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"],F=[w,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"],G=[w,"abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient"], +H=[G,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var"],w=[w,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"],I=[v,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"], +J=[v,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"],v=[v,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"],K=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)/,N=/\S/,O=u({keywords:[F,H,w,"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END"+ +I,J,v],hashComments:!0,cStyleComments:!0,multiLineStrings:!0,regexLiterals:!0}),A={};k(O,["default-code"]);k(x([],[["pln",/^[^]*(?:>|$)/],["com",/^<\!--[\S\s]*?(?:--\>|$)/],["lang-",/^<\?([\S\s]+?)(?:\?>|$)/],["lang-",/^<%([\S\s]+?)(?:%>|$)/],["pun",/^(?:<[%?]|[%?]>)/],["lang-",/^]*>([\S\s]+?)<\/xmp\b[^>]*>/i],["lang-js",/^]*>([\S\s]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\S\s]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]), +["default-markup","htm","html","mxml","xhtml","xml","xsl"]);k(x([["pln",/^\s+/,q," \t\r\n"],["atv",/^(?:"[^"]*"?|'[^']*'?)/,q,"\"'"]],[["tag",/^^<\/?[a-z](?:[\w-.:]*\w)?|\/?>$/i],["atn",/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^\s"'>]*(?:[^\s"'/>]|\/(?=\s)))/],["pun",/^[/<->]+/],["lang-js",/^on\w+\s*=\s*"([^"]+)"/i],["lang-js",/^on\w+\s*=\s*'([^']+)'/i],["lang-js",/^on\w+\s*=\s*([^\s"'>]+)/i],["lang-css",/^style\s*=\s*"([^"]+)"/i],["lang-css",/^style\s*=\s*'([^']+)'/i],["lang-css", +/^style\s*=\s*([^\s"'>]+)/i]]),["in.tag"]);k(x([],[["atv",/^[\S\s]+/]]),["uq.val"]);k(u({keywords:F,hashComments:!0,cStyleComments:!0,types:K}),["c","cc","cpp","cxx","cyc","m"]);k(u({keywords:"null,true,false"}),["json"]);k(u({keywords:H,hashComments:!0,cStyleComments:!0,verbatimStrings:!0,types:K}),["cs"]);k(u({keywords:G,cStyleComments:!0}),["java"]);k(u({keywords:v,hashComments:!0,multiLineStrings:!0}),["bsh","csh","sh"]);k(u({keywords:I,hashComments:!0,multiLineStrings:!0,tripleQuotedStrings:!0}), +["cv","py"]);k(u({keywords:"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["perl","pl","pm"]);k(u({keywords:J,hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["rb"]);k(u({keywords:w,cStyleComments:!0,regexLiterals:!0}),["js"]);k(u({keywords:"all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,true,try,unless,until,when,while,yes", +hashComments:3,cStyleComments:!0,multilineStrings:!0,tripleQuotedStrings:!0,regexLiterals:!0}),["coffee"]);k(x([],[["str",/^[\S\s]+/]]),["regex"]);window.prettyPrintOne=function(a,m,e){var h=document.createElement("PRE");h.innerHTML=a;e&&D(h,e);E({g:m,i:e,h:h});return h.innerHTML};window.prettyPrint=function(a){function m(){for(var e=window.PR_SHOULD_USE_CONTINUATION?l.now()+250:Infinity;p=0){var k=k.match(g),f,b;if(b= +!k){b=n;for(var o=void 0,c=b.firstChild;c;c=c.nextSibling)var i=c.nodeType,o=i===1?o?b:c:i===3?N.test(c.nodeValue)?b:o:o;b=(f=o===b?void 0:o)&&"CODE"===f.tagName}b&&(k=f.className.match(g));k&&(k=k[1]);b=!1;for(o=n.parentNode;o;o=o.parentNode)if((o.tagName==="pre"||o.tagName==="code"||o.tagName==="xmp")&&o.className&&o.className.indexOf("prettyprint")>=0){b=!0;break}b||((b=(b=n.className.match(/\blinenums\b(?::(\d+))?/))?b[1]&&b[1].length?+b[1]:!0:!1)&&D(n,b),d={g:k,h:n,i:b},E(d))}}pul .parent")).map(function (group) { + var items = Array.prototype.slice.call(group.querySelectorAll("a")); + var strings = items.map(function (a) { + return a.innerText.toLowerCase(); + }); + + return {el: group, items: items, strings, strings}; + }); + input.addEventListener("keyup", function (e) { + var value = input.value.toLowerCase(); + + if (value) { + utils.addClass(nav, "searching"); + } else { + utils.removeClass(nav, "searching"); + return; + } + groups.forEach(function (group) { + var isSearch = false; + var items = group.items; + + group.strings.forEach(function (v, i) { + var item = items[i]; + if (utils.hasClass(item.parentNode, "parent")) { + item = item.parentNode; + } + if (v.indexOf(value) > -1) { + utils.addClass(item, "targeting"); + isSearch = true; + } else { + utils.removeClass(item, "targeting"); + } + }); + if (isSearch) { + utils.addClass(group.el, "module-targeting"); + } else { + utils.removeClass(group.el, "module-targeting"); + } + }); + }); +})(); \ No newline at end of file diff --git a/release/0.29.2/doc/scripts/utils.min.js b/release/0.29.2/doc/scripts/utils.min.js new file mode 100644 index 0000000..8489a35 --- /dev/null +++ b/release/0.29.2/doc/scripts/utils.min.js @@ -0,0 +1,9 @@ +/* +Copyright (c) 2018 Daybrush +@name: @daybrush/utils +license: MIT +author: Daybrush +repository: https://github.com/daybrush/utils +@version 0.4.0 +*/ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.utils=t()}(this,function(){"use strict";var u="rgb",c="rgba",f="hsl",l="hsla",e=[u,c,f,l],t="function",n="object",r="string",i="undefined",a=typeof window!==i,o=["webkit","ms","moz","o"],s=function(e){if(typeof document===i)return"";var t=(document.body||document.documentElement).style,n=o.length;if(typeof t[e]!==i)return e;for(var r=0;rul>li:after { + content: ""; + position: absolute; + right: 10px; + top: 0; + bottom: 0; + width: 0; + height: 0; + margin: auto 0px; + border-top: 7px solid #ccc; + border-left: 6px solid transparent; + border-right: 6px solid transparent; +} +nav li h4, nav li ul { + display: none; +} + +.name.typescript { + background: #374E79; + font-size: 14px; +} +.name.typescript .signature { + color: #21de60; +} +.ts-params.typescript table .last { + display: none; +} +table.params th, table.params tr td , table.params tr td.type{ + word-break: break-word; + white-space: normal; +} + +nav .search { + position: relative; + margin: 0px 10px; + border: 3px solid #333; + height: 43px; +} +nav .search .input-area { + position: absolute; + left: 0; + top: 0; + right: 35px; + height: 35px; +} +nav .search input { + position: relative; + width: 100%; + height: 100%; + border: 0; + padding: 0; + text-indent: 10px; + font-weight: bold; + font-size: 14px; + outline: none; +} +nav .search button { + position: absolute; + top: 0; + right: 0px; + width: 35px; + height: 35px; + border: 0; + padding: 0; + outline: none; + cursor: pointer; +} +nav .search button:before { + position: absolute; + content: ""; + width: 18px; + height: 18px; + top: 7px; + left: 7px; + border: 3px solid #333; + border-radius: 50%; + box-sizing: border-box; +} +nav .search button:after { + position: absolute; + content: ""; + width: 3px; + height: 11px; + top: 21px; + left: 18px; + background: #333; + transform-origin: 50% 0%; + -ms-transform-origin: 50% 0%; + -webkit-transform-origin: 50% 0%; + transform: rotate(-45deg); + -ms-transform: rotate(-45deg); + -webkit-transform: rotate(-45deg); +} + +nav.searching li:after { + display: none!important; +} +nav.searching li h4, nav.searching li ul { + display: block!important; +} + +nav.searching .parent { + display: none; +} +nav.searching .parent ul li a { + display: none; +} + +nav.searching .parent.module-targeting { + display: block; +} +nav.searching .parent.module-targeting ul li a { + display: none; +} +nav.searching .parent.module-targeting ul li a.targeting { + display: block; +} +nav.searching .parent.targeting ul li a { + display: block; +} + +nav>h2.custom>a { + margin:12px 10px; +} + +tr.deprecated td { + text-decoration: line-through; +} + + +.db-prop { + margin-top: 20px; + margin-bottom: 40px; +} + +.db-name { + font-size: 120%; + font-weight: normal; +} + +.db-default, .db-since, .db-story { + margin-top: 10px; + margin-bottom: 10px; + font-size: 90%; +} +.db-optional { + display: inline-block; + font-size: 70%; + font-weight: normal; + background: #333; + border-radius: 3px; + padding: 1px 4px; + color: #eee; + vertical-align: middle; + margin-left: 10px; +} +.db-type { + margin-top: 10px; + margin-bottom: 10px; + padding: 13px 10px; + border: 1px solid #d8dcdf; + font-size: 90%; +} +.db-examples-header { + display: block; + font-weight: bold; + padding-top: 20px; + padding-bottom: 0px; +} +.db-examples { + overflow: auto; + max-height: 400px; +} diff --git a/release/0.29.2/doc/styles/jsdoc.css b/release/0.29.2/doc/styles/jsdoc.css new file mode 100644 index 0000000..c36e8af --- /dev/null +++ b/release/0.29.2/doc/styles/jsdoc.css @@ -0,0 +1,679 @@ +@import url(https://fonts.googleapis.com/css?family=Montserrat:400,700); + +* { + box-sizing: border-box +} + +html, body { + height: 100%; + width: 100%; +} + +body { + color: #333; + background-color: white; + margin: 0 auto; + padding: 0 20px; + font-family: 'Helvetica Neue', Helvetica, sans-serif; + font-size: 16px; + /* line-height: 160%; */ +} + +a, +a:active { + color: #333; + text-decoration: none; +} + +a:hover { + text-decoration: none; +} + +article a { + border-bottom: 1px solid #ddd; +} + +article a:hover, article a:active { + border-bottom-color: #222; +} + +p, ul, ol, blockquote { + margin-bottom: 1em; +} + +h1, h2, h3, h4, h5, h6 { + font-family: 'Montserrat', sans-serif; +} + +h1, h2, h3, h4, h5, h6 { + color: #000; + font-weight: 400; + margin: 0; +} + +h1 { + font-weight: 300; + font-size: 48px; + margin: 1em 0 .5em; +} + +h1.page-title { + font-size: 48px; + margin: 1em 30px; +} + +h2 { + font-size: 24px; + margin: 1.5em 0 .3em; +} + +h3 { + font-size: 24px; + margin: 1.2em 0 .3em; +} + +h4 { + font-size: 18px; + margin: 1em 0 .2em; + color: #4d4e53; +} + +h4.name { + color: #fff; + background: #333; + box-shadow: 0 .25em .5em #d3d3d3; + border-top: 1px solid #d3d3d3; + border-bottom: 1px solid #d3d3d3; + margin: 1.5em 0 0.5em; + padding: .75em 0 .75em 10px; +} + +h4.name a { + color: #fff; +} + +h4.name a:hover { + border-bottom-color: #fff; +} + +h5, .container-overview .subsection-title { + font-size: 120%; + letter-spacing: -0.01em; + margin: 8px 0 3px 0; +} + +h6 { + font-size: 100%; + letter-spacing: -0.01em; + margin: 6px 0 3px 0; + font-style: italic; +} + +tt, code, kbd, samp { + font-family: Consolas, Monaco, 'Andale Mono', monospace; + background: #f4f4f4; + padding: 1px 5px; +} + +.class-description { + font-size: 130%; + line-height: 140%; + margin-bottom: 1em; + margin-top: 1em; +} + +.class-description:empty { + margin: 0 +} + +#main { + float: right; + width: calc(100% - 240px); +} + +header { + display: block +} + +section { + display: block; + background-color: #fff; + padding: 0 0 0 30px; +} + +.variation { + display: none +} + +.signature-attributes { + font-size: 60%; + color: #eee; + font-style: italic; + font-weight: lighter; +} + +nav { + float: left; + display: block; + width: 250px; + left: 10px; + background: #fff; + overflow: auto; + position: fixed; + height: 100%; + padding-bottom: 40px; +} + +nav h3 { + margin-top: 12px; + font-size: 13px; + text-transform: uppercase; + letter-spacing: 1px; + font-weight: 700; + line-height: 24px; + margin: 15px 0 10px; + padding: 0; + color: #000; +} + +nav ul { + font-size: 100%; + line-height: 17px; + padding: 0; + margin: 0; + list-style-type: none; +} +nav ul a { + font-size: 12px; +} +nav ul a, +nav ul a:active { + line-height: 18px; + padding: 0; + display: block; +} + + +nav > ul { + padding: 0 10px; +} +nav > ul > li { + position: relative; + padding: 13px 20px 13px 10px; + word-break: break-word; + box-sizing: border-box; + border-bottom: 1px solid #ccc; +} +nav > ul > li > a { + font-size: 14px; + color: black; + font-weight: bold; +} +nav .method a, nav .event a { + font-family: sans-serif; + color: black; + font-weight: 600; + font-size: 13px; +} +nav .method.inherits a { + color: #777; +} +nav .method.inherits a:after { + content: "ⓘ"; + margin-left: 5px; + font-size: 50%; + +} +nav ul h4, nav ul ul { + margin-left: 15px; +} +nav ul ul { + margin-bottom: 10px +} +nav ul h4 { + font-size: 14px; + margin-top: 5px; + color: black; +} +nav ul h4 a, nav ul h4 a:hover, nav ul h4 a:active { + color: black; + font-size: 14px; +} +nav ul ul + ul { + /* margin-top: -10px; */ +} + +nav ul ul a { + color: #333; + font-weight: bold; + border-left: 1px solid hsl(207, 10%, 86%); +} + +nav ul ul a, +nav ul ul a:active { + padding: 2px 0px; + padding-left: 20px; +} + +nav h2 { + font-size: 12px; + margin: 0; + padding: 0px 10px; +} + +nav > h2 > a { + display: block; + margin: 30px 10px 20px; + font-size: 16px; + font-weight: bold; + color: #333 !important; +} + +footer { + color: hsl(0, 0%, 28%); + margin-left: 250px; + display: block; + padding: 15px; + font-style: italic; + font-size: 90%; +} + +.ancestors { + color: #999 +} + +.ancestors a { + color: #999 !important; +} + +.clear { + clear: both +} + +.important { + font-weight: bold; + color: #950B02; +} + +.yes-def { + text-indent: -1000px +} + +.type-signature { + color: #88CCAA; +} + +.type-signature:last-child { + color: #eee; +} + +.name, .signature { + font-family: Consolas, Monaco, 'Andale Mono', monospace +} + +.signature { + color: #88CCAA; +} + +.details { + margin-top: 6px; + border-left: 2px solid #DDD; + line-height: 20px; + font-size: 14px; +} + +.details dt { + width: 120px; + float: left; + padding-left: 10px; +} + +.details dd { + margin-left: 70px; + margin-top: 6px; + margin-bottom: 6px; +} + +.details ul { + margin: 0 +} + +.details ul { + list-style-type: none +} + +.details pre.prettyprint { + margin: 0 +} + +.details .object-value { + padding-top: 0 +} + +.description { + margin-bottom: 1em; + margin-top: 1em; +} + +.code-caption { + font-style: italic; + font-size: 107%; + margin: 0; +} + +.prettyprint { + font-size: 14px; + overflow: auto; +} + +.prettyprint.source { + width: inherit; + line-height: 18px; + display: block; + background-color: #0d152a; + color: #aeaeae; +} + +.prettyprint code { + line-height: 18px; + display: block; + background-color: #0d152a; + color: #4D4E53; +} + +.prettyprint > code { + padding: 15px; +} + +.prettyprint .linenums code { + padding: 0 15px +} + +.prettyprint .linenums li:first-of-type code { + padding-top: 15px +} + +.prettyprint code span.line { + display: inline-block +} + +.prettyprint.linenums { + padding-left: 70px; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.prettyprint.linenums ol { + padding-left: 0 +} + +.prettyprint.linenums li { + border-left: 3px #34446B solid; +} + +.prettyprint.linenums li.selected, .prettyprint.linenums li.selected * { + background-color: #34446B; +} + +.prettyprint.linenums li * { + -webkit-user-select: text; + -moz-user-select: text; + -ms-user-select: text; + user-select: text; +} + +.params, .props { + border-spacing: 0; + border: 1px solid #ddd; + border-collapse: collapse; + border-radius: 3px; + box-shadow: 0 1px 3px rgba(0,0,0,0.1); + width: 100%; + font-size: 14px; + margin: 1em 0; +} + +.params .type { + white-space: nowrap; +} + +.params code { + white-space: pre; +} + +.params td, .params .name, .props .name, .name code { + color: #4D4E53; + font-family: Consolas, Monaco, 'Andale Mono', monospace; + font-size: 100%; +} + +.params td, .params th, .props td, .props th { + margin: 0px; + text-align: left; + vertical-align: top; + padding: 10px; + display: table-cell; +} + +.params td { + font-weight: bold; + border-top: 1px solid #eee +} + +.params thead tr, .props thead tr { + background-color: #fff; + font-weight: bold; +} + +.params .params thead tr, .props .props thead tr { + background-color: #fff; + font-weight: bold; +} + +.params td.description > p:first-child, .props td.description > p:first-child { + margin-top: 0; + padding-top: 0; +} + +.params td.description > p:last-child, .props td.description > p:last-child { + margin-bottom: 0; + padding-bottom: 0; +} + +span.param-type, .params td .param-type, .param-type dd { + color: #999; + font-family: Consolas, Monaco, 'Andale Mono', monospace +} + +.param-type dt, .param-type dd { + display: inline-block +} + +.param-type { + margin: 14px 0; +} + +.disabled { + color: #454545 +} + +/* navicon button */ +.navicon-button { + display: none; + position: relative; + padding: 2.0625rem 1.5rem; + transition: 0.25s; + cursor: pointer; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + opacity: .8; +} +.navicon-button .navicon:before, .navicon-button .navicon:after { + transition: 0.25s; +} +.navicon-button:hover { + transition: 0.5s; + opacity: 1; +} +.navicon-button:hover .navicon:before, .navicon-button:hover .navicon:after { + transition: 0.25s; +} +.navicon-button:hover .navicon:before { + top: .825rem; +} +.navicon-button:hover .navicon:after { + top: -.825rem; +} + +/* navicon */ +.navicon { + position: relative; + width: 2.5em; + height: .3125rem; + background: #000; + transition: 0.3s; + border-radius: 2.5rem; +} +.navicon:before, .navicon:after { + display: block; + content: ""; + height: .3125rem; + width: 2.5rem; + background: #000; + position: absolute; + z-index: -1; + transition: 0.3s 0.25s; + border-radius: 1rem; +} +.navicon:before { + top: .625rem; +} +.navicon:after { + top: -.625rem; +} + +/* open */ +.nav-trigger:checked + label:not(.steps) .navicon:before, +.nav-trigger:checked + label:not(.steps) .navicon:after { + top: 0 !important; +} + +.nav-trigger:checked + label .navicon:before, +.nav-trigger:checked + label .navicon:after { + transition: 0.5s; +} + +/* Minus */ +.nav-trigger:checked + label { + -webkit-transform: scale(0.75); + transform: scale(0.75); +} + +/* × and + */ +.nav-trigger:checked + label.plus .navicon, +.nav-trigger:checked + label.x .navicon { + background: transparent; +} + +.nav-trigger:checked + label.plus .navicon:before, +.nav-trigger:checked + label.x .navicon:before { + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); + background: #FFF; +} + +.nav-trigger:checked + label.plus .navicon:after, +.nav-trigger:checked + label.x .navicon:after { + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + background: #FFF; +} + +.nav-trigger:checked + label.plus { + -webkit-transform: scale(0.75) rotate(45deg); + transform: scale(0.75) rotate(45deg); +} + +.nav-trigger:checked ~ nav { + left: 0 !important; +} + +.nav-trigger:checked ~ .overlay { + display: block; +} + +.nav-trigger { + position: fixed; + top: 0; + clip: rect(0, 0, 0, 0); +} + +.overlay { + display: none; + position: fixed; + top: 0; + bottom: 0; + left: 0; + right: 0; + width: 100%; + height: 100%; + background: hsla(0, 0%, 0%, 0.5); + z-index: 1; +} + +@media only screen and (max-width: 680px) { + body { + overflow-x: hidden; + padding: 0 10px; + } + + nav { + background: #FFF; + width: 250px; + height: 100%; + position: fixed; + top: 0; + right: 0; + bottom: 0; + left: -250px; + z-index: 3; + padding: 0 10px; + transition: left 0.2s; + } + + .navicon-button { + display: inline-block; + position: fixed; + top: 1.5em; + right: 0; + z-index: 2; + } + + #main { + width: 100%; + } + + #main h1.page-title { + margin: 1em 0; + } + + #main section { + padding: 0; + } + + footer { + margin-left: 0; + } +} + +/** Add a '#' to static members */ +[data-type="member"] a::before { + content: '#'; + display: inline-block; + margin-left: -14px; + margin-right: 5px; +} diff --git a/release/0.29.2/doc/styles/prettify.css b/release/0.29.2/doc/styles/prettify.css new file mode 100644 index 0000000..629bde5 --- /dev/null +++ b/release/0.29.2/doc/styles/prettify.css @@ -0,0 +1,79 @@ +.pln { + color: #ddd; +} + +/* string content */ +.str { + color: #61ce3c; +} + +/* a keyword */ +.kwd { + color: #fbde2d; +} + +/* a comment */ +.com { + color: #aeaeae; +} + +/* a type name */ +.typ { + color: #8da6ce; +} + +/* a literal value */ +.lit { + color: #fbde2d; +} + +/* punctuation */ +.pun { + color: #ddd; +} + +/* lisp open bracket */ +.opn { + color: #000000; +} + +/* lisp close bracket */ +.clo { + color: #000000; +} + +/* a markup tag name */ +.tag { + color: #8da6ce; +} + +/* a markup attribute name */ +.atn { + color: #fbde2d; +} + +/* a markup attribute value */ +.atv { + color: #ddd; +} + +/* a declaration */ +.dec { + color: #EF5050; +} + +/* a variable name */ +.var { + color: #c82829; +} + +/* a function name */ +.fun { + color: #4271ae; +} + +/* Specify class=linenums on a pre to get line numbering */ +ol.linenums { + margin-top: 0; + margin-bottom: 0; +} diff --git a/release/latest/dist/guides.cjs.js b/release/latest/dist/guides.cjs.js index 8a5bedc..f26b8dc 100644 --- a/release/latest/dist/guides.cjs.js +++ b/release/latest/dist/guides.cjs.js @@ -4,7 +4,7 @@ name: @scena/guides license: MIT author: Daybrush repository: git+https://github.com/daybrush/guides.git -version: 0.29.1 +version: 0.29.2 */ 'use strict'; diff --git a/release/latest/dist/guides.esm.js b/release/latest/dist/guides.esm.js index 8258ac1..37c6799 100644 --- a/release/latest/dist/guides.esm.js +++ b/release/latest/dist/guides.esm.js @@ -4,7 +4,7 @@ name: @scena/guides license: MIT author: Daybrush repository: git+https://github.com/daybrush/guides.git -version: 0.29.1 +version: 0.29.2 */ import { ref, Properties } from 'framework-utils'; import { createElement, Component, renderSelf } from 'croact'; diff --git a/release/latest/dist/guides.js b/release/latest/dist/guides.js index dabc871..7d8252c 100644 --- a/release/latest/dist/guides.js +++ b/release/latest/dist/guides.js @@ -4,7 +4,7 @@ name: @scena/guides license: MIT author: Daybrush repository: git+https://github.com/daybrush/guides.git -version: 0.29.1 +version: 0.29.2 */ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : @@ -4616,7 +4616,7 @@ version: 0.29.1 license: MIT author: Daybrush repository: https://github.com/daybrush/guides/blob/master/packages/react-guides - version: 0.28.1 + version: 0.28.2 */ /****************************************************************************** Copyright (c) Microsoft Corporation. @@ -4929,7 +4929,6 @@ version: 0.29.1 }); this._zoom = zoom; this._guidesZoom = guidesZoom || zoom; - console.log(type, zoom, guidesZoom); return createElement(GuidesElement, { ref: this.managerRef, cspNonce: cspNonce, diff --git a/release/latest/dist/guides.js.map b/release/latest/dist/guides.js.map index 5577416..4146eae 100644 --- a/release/latest/dist/guides.js.map +++ b/release/latest/dist/guides.js.map @@ -1 +1 @@ -{"version":3,"file":"guides.js","sources":["../../react-guides/dist/guides.esm.js","../src/consts.ts","../src/InnerGuides.tsx","../src/GuidesManager.tsx","../src/Guides.tsx","../src/index.umd.ts"],"sourcesContent":["/*\nCopyright (c) 2019 Daybrush\nname: @scena/react-guides\nlicense: MIT\nauthor: Daybrush\nrepository: https://github.com/daybrush/guides/blob/master/packages/react-guides\nversion: 0.28.1\n*/\nimport { createElement, createRef, PureComponent } from 'react';\nimport Ruler, { PROPERTIES as PROPERTIES$1 } from '@scena/react-ruler';\nimport { prefixNames, prefixCSS, ref, refs } from 'framework-utils';\nimport DragScroll from '@scena/dragscroll';\nimport Gesto from 'gesto';\nimport { styled } from 'react-css-styled';\nimport { hasClass, addClass, removeClass } from '@daybrush/utils';\nimport { getDistElementMatrix, calculateMatrixDist } from 'css-to-mat';\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n\n/* global Reflect, Promise */\nvar extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf || {\n __proto__: []\n } instanceof Array && function (d, b) {\n d.__proto__ = b;\n } || function (d, b) {\n for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];\n };\n\n return extendStatics(d, b);\n};\n\nfunction __extends(d, b) {\n if (typeof b !== \"function\" && b !== null) throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n\n function __() {\n this.constructor = d;\n }\n\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\nvar __assign = function () {\n __assign = Object.assign || function __assign(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n }\n\n return t;\n };\n\n return __assign.apply(this, arguments);\n};\nfunction __spreadArray(to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nfunction prefix() {\n var classNames = [];\n\n for (var _i = 0; _i < arguments.length; _i++) {\n classNames[_i] = arguments[_i];\n }\n\n return prefixNames.apply(void 0, __spreadArray([\"scena-guides-\"], classNames, false));\n}\n\nvar ADDER = prefix(\"guide\", \"adder\");\nvar GUIDES = prefix(\"guides\");\nvar GUIDE = prefix(\"guide\");\nvar DRAGGING = prefix(\"dragging\");\nvar DISPLAY_DRAG = prefix(\"display-drag\");\nvar GUIDES_CSS = prefixCSS(\"scena-guides-\", \"\\n{\\n position: relative;\\n width: 100%;\\n height: 100%;\\n}\\ncanvas {\\n position: relative;\\n}\\n.guide-origin {\\n position: absolute;\\n width: 1px;\\n height: 1px;\\n top: 0;\\n left: 0;\\n opacity: 0;\\n}\\n.guides {\\n position: absolute;\\n bottom: 0;\\n right: 0;\\n will-change: transform;\\n z-index: 2000;\\n}\\n.guide-pos {\\n position: absolute;\\n font-weight: bold;\\n font-size: 12px;\\n color: #f33;\\n}\\n.horizontal .guide-pos {\\n bottom: 100%;\\n left: 50%;\\n transform: translate(-50%);\\n}\\n.vertical .guide-pos {\\n left: calc(100% + 2px);\\n top: 50%;\\n transform: translateY(-50%);\\n}\\n.display-drag {\\n position: absolute;\\n will-change: transform;\\n z-index: 2000;\\n font-weight: bold;\\n font-size: 12px;\\n display: none;\\n left: 20px;\\n top: -20px;\\n color: #f33;\\n}\\n:host.horizontal .guides {\\n width: 100%;\\n height: 0;\\n}\\n:host.vertical .guides {\\n height: 100%;\\n width: 0;\\n}\\n:host.horizontal canvas {\\n cursor: ns-resize;\\n}\\n:host.vertical canvas {\\n cursor: ew-resize;\\n}\\n.guide {\\n position: absolute;\\n background: #f33;\\n z-index: 2;\\n}\\n.guide.dragging:before {\\n position: absolute;\\n content: \\\"\\\";\\n width: 100%;\\n height: 100%;\\n top: 50%;\\n left: 50%;\\n transform: translate(-50%, -50%);\\n}\\n:host.horizontal .guide {\\n width: 100%;\\n height: 1px;\\n cursor: row-resize;\\n}\\n:host.vertical .guide {\\n width: 1px;\\n height: 100%;\\n cursor: col-resize;\\n}\\n.mobile :host.horizontal .guide {\\n transform: scale(1, 2);\\n}\\n.mobile :host.vertical .guide {\\n transform: scale(2, 1);\\n}\\n:host.horizontal .guide:before {\\n height: 20px;\\n}\\n:host.vertical .guide:before {\\n width: 20px;\\n}\\n.adder {\\n display: none;\\n}\\n.adder.dragging {\\n display: block;\\n}\\n\");\nvar PROPERTIES = __spreadArray([\"className\", \"rulerStyle\", 'snapThreshold', \"snaps\", \"displayDragPos\", \"cspNonce\", 'dragPosFormat', \"defaultGuides\", \"showGuides\", \"scrollOptions\", \"guideStyle\", \"guidesOffset\", \"digit\", \"defaultGuidesPos\", \"dragGuideStyle\", \"displayGuidePos\", \"guidePosFormat\", \"guidePosStyle\", \"lockGuides\", \"guidesZoom\"], PROPERTIES$1, true);\nvar METHODS = [\"getGuides\", \"loadGuides\", \"scroll\", \"scrollGuides\", \"resize\", \"getElement\", \"getRulerElement\", \"forceUpdate\", \"getRulerScrollPos\", \"getGuideScrollPos\", \"zoomTo\", \"drawRuler\"];\nvar EVENTS = [\"changeGuides\", \"requestScroll\", \"dragStart\", \"drag\", \"dragEnd\", \"clickRuler\"];\n\nvar GuidesElement = styled(\"div\", GUIDES_CSS);\n\nvar Guides =\n/*#__PURE__*/\nfunction (_super) {\n __extends(Guides, _super);\n\n function Guides(props) {\n var _this = _super.call(this, props) || this;\n\n _this.state = {\n guides: []\n };\n _this.scrollPos = 0;\n _this.managerRef = createRef();\n _this.guideElements = [];\n _this._isFirstMove = false;\n _this._zoom = 1;\n _this._guidesZoom = 1;\n _this._observer = null;\n\n _this.onDragStart = function (e) {\n var datas = e.datas,\n inputEvent = e.inputEvent;\n _this._isFirstMove = true;\n\n _this.movePos(e);\n /**\n * When the drag starts, the dragStart event is called.\n * @memberof Guides\n * @event dragStart\n * @param {OnDragStart} - Parameters for the dragStart event\n */\n\n\n _this.props.onDragStart(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n return;\n }\n\n inputEvent.stopPropagation();\n inputEvent.preventDefault();\n\n _this._startDragScroll(e);\n };\n\n _this._onDrag = function (e) {\n if (_this._isFirstMove) {\n _this._isFirstMove = false;\n addClass(e.datas.target, DRAGGING);\n }\n\n var nextPos = _this.movePos(e);\n /**\n * When dragging, the drag event is called.\n * @memberof Guides\n * @event drag\n * @param {OnDrag} - Parameters for the drag event\n */\n\n\n _this.props.onDrag(__assign(__assign({}, e), {\n dragElement: e.datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n _this._endDragScroll(e);\n\n return;\n }\n\n _this._dragScroll(e);\n\n return nextPos;\n };\n\n _this.onDragEnd = function (e) {\n var datas = e.datas,\n isDouble = e.isDouble,\n distX = e.distX,\n distY = e.distY;\n\n var pos = _this.movePos(e);\n\n var guides = _this.state.guides;\n var _a = _this.props,\n onChangeGuides = _a.onChangeGuides,\n displayDragPos = _a.displayDragPos,\n digit = _a.digit,\n lockGuides = _a.lockGuides,\n guidesOffset = _a.guidesOffset;\n var zoom = _this._guidesZoom;\n var guidePos = parseFloat((pos / zoom).toFixed(digit || 0));\n var baseScrollPos = _this.scrollPos - (guidesOffset || 0);\n\n if (displayDragPos) {\n _this.displayElement.style.cssText += \"display: none;\";\n }\n\n removeClass(datas.target, DRAGGING);\n /**\n * When the drag finishes, the dragEnd event is called.\n * @memberof Guides\n * @event dragEnd\n * @param {OnDragEnd} - Parameters for the dragEnd event\n */\n\n _this.props.onDragEnd(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n _this._endDragScroll(e);\n\n if (datas.fromRuler) {\n if (_this._isFirstMove) {\n /**\n * When click the ruler, the click ruler is called.\n * @memberof Guides\n * @event clickRuler\n * @param {OnClickRuler} - Parameters for the clickRuler event\n */\n _this.props.onClickRuler(__assign(__assign({}, e), {\n pos: 0\n }));\n }\n\n if (guidePos >= baseScrollPos && guides.indexOf(guidePos) < 0) {\n _this.setState({\n guides: __spreadArray(__spreadArray([], guides, true), [guidePos], false)\n }, function () {\n /**\n * The `changeGuides` event occurs when the guideline is added / removed / changed.\n * @memberof Guides\n * @event changeGuides\n * @param {OnChangeGuides} - Parameters for the changeGuides event\n */\n onChangeGuides({\n guides: _this.state.guides,\n distX: distX,\n distY: distY,\n index: guides.length,\n isAdd: true,\n isRemove: false,\n isChange: false\n });\n });\n }\n } else {\n var index_1 = parseFloat(datas.target.getAttribute(\"data-index\"));\n var isRemove_1 = false;\n var isChange_1 = false;\n guides = __spreadArray([], guides, true);\n var guideIndex = guides.indexOf(guidePos);\n\n if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"remove\") > -1)) {\n return;\n }\n\n guides.splice(index_1, 1);\n isRemove_1 = true;\n } else if (guideIndex > -1) {\n return;\n } else {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"change\") > -1)) {\n return;\n }\n\n guides[index_1] = guidePos;\n isChange_1 = true;\n }\n\n _this.setState({\n guides: guides\n }, function () {\n var nextGuides = _this.state.guides;\n onChangeGuides({\n distX: distX,\n distY: distY,\n guides: nextGuides,\n isAdd: false,\n index: index_1,\n isChange: isChange_1,\n isRemove: isRemove_1\n });\n });\n }\n };\n\n _this._onCheck = function () {\n _this.resize();\n };\n\n _this.state.guides = props.defaultGuides || [];\n _this.scrollPos = props.defaultGuidesPos || 0;\n return _this;\n }\n\n var __proto = Guides.prototype;\n\n __proto.render = function () {\n var _a = this.props,\n className = _a.className,\n type = _a.type,\n zoom = _a.zoom,\n guidesZoom = _a.guidesZoom,\n style = _a.style,\n rulerStyle = _a.rulerStyle,\n displayDragPos = _a.displayDragPos,\n cspNonce = _a.cspNonce,\n dragGuideStyle = _a.dragGuideStyle,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b;\n var props = this.props;\n var translateName = this.getTranslateName();\n var rulerProps = {};\n PROPERTIES$1.forEach(function (name) {\n if (name === \"style\" || name === \"warpSelf\" || name === \"useResizeObserver\") {\n return;\n }\n\n rulerProps[name] = props[name];\n });\n this._zoom = zoom;\n this._guidesZoom = guidesZoom || zoom;\n console.log(type, zoom, guidesZoom);\n return createElement(GuidesElement, {\n ref: this.managerRef,\n cspNonce: cspNonce,\n className: \"\".concat(prefix(\"manager\", type), \" \").concat(className),\n style: style\n }, createElement(\"div\", {\n className: prefix(\"guide-origin\"),\n ref: ref(this, \"originElement\")\n }), createElement(Ruler, __assign({\n ref: ref(this, \"ruler\"),\n style: rulerStyle\n }, rulerProps)), createElement(\"div\", {\n className: GUIDES,\n ref: ref(this, \"guidesElement\"),\n style: {\n transform: \"\".concat(translateName, \"(\").concat(-this.scrollPos * this._guidesZoom, \"px)\")\n }\n }, displayDragPos && createElement(\"div\", {\n className: DISPLAY_DRAG,\n ref: ref(this, \"displayElement\"),\n style: guidePosStyle || {}\n }), createElement(\"div\", {\n className: ADDER,\n ref: ref(this, \"adderElement\"),\n style: dragGuideStyle\n }), this.renderGuides()));\n };\n /**\n * Draw ruler\n */\n\n\n __proto.drawRuler = function (options) {\n this.ruler.draw(options);\n };\n\n __proto.renderGuides = function () {\n var _this = this;\n\n var props = this.props;\n var _a = props,\n type = _a.type,\n showGuides = _a.showGuides,\n guideStyle = _a.guideStyle,\n displayGuidePos = _a.displayGuidePos,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b,\n guidesOffset = _a.guidesOffset;\n var zoom = this._guidesZoom;\n var translateName = this.getTranslateName();\n var guides = this.state.guides;\n\n var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) {\n return v;\n };\n\n this.guideElements = [];\n\n if (showGuides) {\n return guides.map(function (pos, i) {\n var guidePos = pos + (guidesOffset || 0);\n return createElement(\"div\", {\n className: prefix(\"guide\", type),\n ref: refs(_this, \"guideElements\", i),\n key: i,\n \"data-index\": i,\n \"data-pos\": pos,\n style: __assign(__assign({}, guideStyle), {\n transform: \"\".concat(translateName, \"(\").concat(guidePos * zoom, \"px) translateZ(0px)\")\n })\n }, displayGuidePos && createElement(\"div\", {\n className: prefix(\"guide-pos\"),\n style: guidePosStyle || {}\n }, guidePosFormat(pos)));\n });\n }\n\n return;\n };\n\n __proto.componentDidMount = function () {\n var _this = this;\n\n this.gesto = new Gesto(this.managerRef.current, {\n container: document.body\n }).on(\"dragStart\", function (e) {\n var _a = _this.props,\n type = _a.type,\n lockGuides = _a.lockGuides;\n var zoom = _this._guidesZoom;\n\n if (lockGuides === true) {\n e.stop();\n return;\n }\n\n var inputEvent = e.inputEvent;\n var target = inputEvent.target;\n var datas = e.datas;\n var canvasElement = _this.ruler.canvasElement;\n var guidesElement = _this.guidesElement;\n var isHorizontal = type === \"horizontal\";\n\n var originRect = _this.originElement.getBoundingClientRect();\n\n var matrix = getDistElementMatrix(_this.managerRef.current);\n var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]);\n offsetPos[0] -= guidesElement.offsetLeft;\n offsetPos[1] -= guidesElement.offsetTop;\n offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom;\n datas.offsetPos = offsetPos;\n datas.matrix = matrix;\n var isLockAdd = lockGuides && lockGuides.indexOf(\"add\") > -1;\n var isLockRemove = lockGuides && lockGuides.indexOf(\"remove\") > -1;\n var isLockChange = lockGuides && lockGuides.indexOf(\"change\") > -1;\n\n if (target === canvasElement) {\n if (isLockAdd) {\n e.stop();\n return;\n }\n\n datas.fromRuler = true;\n datas.target = _this.adderElement; // add\n } else if (hasClass(target, GUIDE)) {\n if (isLockRemove && isLockChange) {\n e.stop();\n return;\n }\n\n datas.target = target; // change\n } else {\n e.stop();\n return false;\n }\n\n _this.onDragStart(e);\n }).on(\"drag\", this._onDrag).on(\"dragEnd\", this.onDragEnd);\n\n if (this.props.useResizeObserver) {\n this._observer = new ResizeObserver(this._onCheck);\n\n this._observer.observe(this.guidesElement, {\n box: \"border-box\"\n });\n\n this._observer.observe(this.getRulerElement(), {\n box: \"border-box\"\n });\n } else {\n this._onCheck();\n }\n };\n\n __proto.componentWillUnmount = function () {\n var _a;\n\n this.gesto.unset();\n (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n };\n\n __proto.componentDidUpdate = function (prevProps) {\n var nextGuides = this.props.defaultGuides;\n\n if (prevProps.defaultGuides !== nextGuides) {\n // to dynamically update guides from code rather than dragging guidelines\n this.setState({\n guides: nextGuides || []\n });\n }\n };\n /**\n * Load the current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.loadGuides = function (guides) {\n this.setState({\n guides: guides\n });\n };\n /**\n * Get current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getGuides = function () {\n return this.state.guides;\n };\n /**\n * Scroll the positions of the guidelines opposite the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scrollGuides = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._guidesZoom;\n }\n\n this._setZoom({\n guidesZoom: nextZoom\n });\n\n var translateName = this.getTranslateName();\n var guidesElement = this.guidesElement;\n this.scrollPos = pos;\n guidesElement.style.transform = \"\".concat(translateName, \"(\").concat(-pos * nextZoom, \"px)\");\n var guides = this.state.guides;\n var guidesOffset = this.props.guidesOffset || 0;\n this.guideElements.forEach(function (el, i) {\n if (!el) {\n return;\n }\n\n var guidePos = guides[i] + (guidesOffset || 0);\n el.style.transform = \"\".concat(translateName, \"(\").concat(guidePos * nextZoom, \"px) translateZ(0px)\");\n el.style.display = -pos + guidePos < 0 ? \"none\" : \"block\";\n });\n };\n /**\n * Set to the next zoom.\n * @memberof Guides\n * @since 0.22.0\n * @param nextZoom - next zoom\n */\n\n\n __proto.zoomTo = function (nextZoom, nextGuidesZoom) {\n if (nextGuidesZoom === void 0) {\n nextGuidesZoom = nextZoom;\n }\n\n this.scroll(this.getRulerScrollPos(), nextZoom);\n this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);\n };\n /**\n * Get Guides DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getElement = function () {\n return this.managerRef.current;\n };\n /**\n * Get Ruler DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getRulerElement = function () {\n return this.ruler.canvasElement;\n };\n /**\n * Scroll position of guides (horizontal: y, vertical: x)\n */\n\n\n __proto.getGuideScrollPos = function () {\n return this.scrollPos;\n };\n /**\n * Scroll position of the ruler (horizontal: x, vertical: y)\n */\n\n\n __proto.getRulerScrollPos = function () {\n return this.ruler.getScrollPos();\n };\n /**\n * Scroll the position of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scroll = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.scroll(pos, nextZoom);\n };\n /**\n * Recalculate the size of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.resize = function (nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.resize(nextZoom);\n };\n\n __proto.movePos = function (e) {\n var datas = e.datas,\n distX = e.distX,\n distY = e.distY;\n var props = this.props;\n var type = props.type,\n snaps = props.snaps,\n snapThreshold = props.snapThreshold,\n displayDragPos = props.displayDragPos,\n digit = props.digit;\n var guidesOffset = props.guidesOffset || 0;\n var zoom = this._guidesZoom;\n\n var dragPosFormat = props.dragPosFormat || function (v) {\n return v;\n };\n\n var isHorizontal = type === \"horizontal\";\n var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);\n var offsetPos = datas.offsetPos;\n var offsetX = matrixPos[0] + offsetPos[0];\n var offsetY = matrixPos[1] + offsetPos[1];\n var guidesZoomOffset = guidesOffset * zoom;\n var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;\n var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0));\n var guideSnaps = snaps.slice().sort(function (a, b) {\n return Math.abs(guidePos - a) - Math.abs(guidePos - b);\n });\n\n if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) {\n guidePos = guideSnaps[0];\n nextPos = guidePos * zoom;\n }\n\n if (!datas.fromRuler || !this._isFirstMove) {\n if (displayDragPos) {\n var displayPos = type === \"horizontal\" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY];\n this.displayElement.style.cssText += \"display: block;\" + \"transform: translate(-50%, -50%) \" + \"translate(\".concat(displayPos.map(function (v) {\n return \"\".concat(v, \"px\");\n }).join(\", \"), \")\");\n this.displayElement.innerHTML = \"\".concat(dragPosFormat(guidePos));\n }\n\n var target = datas.target;\n target.setAttribute(\"data-pos\", guidePos);\n target.style.transform = \"\".concat(this.getTranslateName(), \"(\").concat(nextPos + guidesOffset * zoom, \"px)\");\n }\n\n return nextPos;\n };\n\n __proto.getTranslateName = function () {\n return this.props.type === \"horizontal\" ? \"translateY\" : \"translateX\";\n };\n\n __proto._startDragScroll = function (e) {\n var _this = this;\n\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var datas = e.datas;\n var dragScroll = new DragScroll();\n datas.dragScroll = dragScroll;\n dragScroll.on(\"scroll\", function (_a) {\n var _b, _c;\n\n var container = _a.container,\n direction = _a.direction;\n /**\n * If scroll can be triggered through drag, the `requestScroll` event is fired.\n * @memberof Guides\n * @event requestScroll\n * @param {OnRequestScroll} - Parameters for the `requestScroll` event\n */\n\n (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, {\n container: container,\n direction: direction\n });\n }).on(\"move\", function (_a) {\n var offsetX = _a.offsetX,\n offsetY = _a.offsetY,\n inputEvent = _a.inputEvent;\n\n _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);\n });\n dragScroll.dragStart(e, {\n container: scrollOptions.container\n });\n };\n\n __proto._dragScroll = function (e) {\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var dragScroll = e.datas.dragScroll;\n dragScroll.drag(e, scrollOptions);\n };\n\n __proto._endDragScroll = function (e) {\n var _a;\n\n (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd();\n e.datas.dragScroll = null;\n };\n\n __proto._setZoom = function (zooms) {\n var nextZoom = zooms.zoom,\n nextGuidesZoom = zooms.guidesZoom;\n var hasZoom = !!this.props.zoom;\n var hasGuidesZoom = !!this.props.guidesZoom;\n\n if (hasGuidesZoom) {\n if (nextGuidesZoom) {\n this._guidesZoom = nextGuidesZoom;\n }\n } else {\n if (nextGuidesZoom) {\n this._zoom = nextGuidesZoom;\n this._guidesZoom = nextGuidesZoom;\n }\n\n if (nextZoom) {\n this._guidesZoom = nextZoom;\n }\n }\n\n if (nextZoom) {\n this._zoom = nextZoom;\n }\n };\n\n Guides.defaultProps = {\n className: \"\",\n type: \"horizontal\",\n zoom: 1,\n guidesZoom: 0,\n style: {},\n snapThreshold: 5,\n snaps: [],\n digit: 0,\n onClickRuler: function () {},\n onChangeGuides: function () {},\n onRequestScroll: function () {},\n onDragStart: function () {},\n onDrag: function () {},\n onDragEnd: function () {},\n displayDragPos: false,\n dragPosFormat: function (v) {\n return v;\n },\n defaultGuides: [],\n lockGuides: false,\n showGuides: true,\n guideStyle: {},\n dragGuideStyle: {},\n guidePosStyle: {},\n defaultGuidesPos: 0\n };\n return Guides;\n}(PureComponent);\n\nexport default Guides;\nexport { EVENTS, METHODS, PROPERTIES };\n//# sourceMappingURL=guides.esm.js.map\n","import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\n\nexport default Guides;\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","__spreadArray","to","from","pack","l","ar","slice","concat","prefix","classNames","_i","prefixNames","ADDER","GUIDES","GUIDE","DRAGGING","DISPLAY_DRAG","GUIDES_CSS","prefixCSS","PROPERTIES","PROPERTIES$1","METHODS","EVENTS","GuidesElement","styled","Guides","_super","props","_this","state","guides","scrollPos","managerRef","createRef","guideElements","_isFirstMove","_zoom","_guidesZoom","_observer","onDragStart","e","datas","inputEvent","movePos","dragElement","target","gesto","isFlag","stopPropagation","preventDefault","_startDragScroll","_onDrag","addClass","nextPos","onDrag","_endDragScroll","_dragScroll","onDragEnd","isDouble","distX","distY","pos","_a","onChangeGuides","displayDragPos","digit","lockGuides","guidesOffset","zoom","guidePos","parseFloat","toFixed","baseScrollPos","displayElement","style","cssText","removeClass","fromRuler","onClickRuler","indexOf","setState","index","isAdd","isRemove","isChange","index_1","getAttribute","isRemove_1","isChange_1","guideIndex","splice","nextGuides","_onCheck","resize","defaultGuides","defaultGuidesPos","__proto","render","className","type","guidesZoom","rulerStyle","cspNonce","dragGuideStyle","_b","guidePosStyle","translateName","getTranslateName","rulerProps","forEach","name","console","log","createElement","ref","Ruler","transform","renderGuides","drawRuler","options","ruler","draw","showGuides","guideStyle","displayGuidePos","guidePosFormat","dragPosFormat","v","map","refs","key","componentDidMount","Gesto","current","container","document","body","on","stop","canvasElement","guidesElement","isHorizontal","originRect","originElement","getBoundingClientRect","matrix","getDistElementMatrix","offsetPos","calculateMatrixDist","clientX","left","clientY","top","offsetLeft","offsetTop","isLockAdd","isLockRemove","isLockChange","adderElement","hasClass","useResizeObserver","ResizeObserver","observe","box","getRulerElement","componentWillUnmount","unset","disconnect","componentDidUpdate","prevProps","loadGuides","getGuides","scrollGuides","nextZoom","_setZoom","el","display","zoomTo","nextGuidesZoom","scroll","getRulerScrollPos","getGuideScrollPos","getElement","getScrollPos","snaps","snapThreshold","matrixPos","offsetX","offsetY","guidesZoomOffset","Math","round","guideSnaps","sort","a","abs","displayPos","join","innerHTML","setAttribute","scrollOptions","dragScroll","DragScroll","_c","direction","onRequestScroll","scrollBy","dragStart","drag","dragEnd","zooms","hasZoom","hasGuidesZoom","defaultProps","PureComponent","GUIDES_PROPERTIES","GUIDES_METHODS","GUIDES_EVENTS","React","ReactGuides","events","camelize","trigger","selfElement","warpSelf","_warp","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","forceUpdate","parentElement","removeChild","Properties","property","args","self","getInnerGuides","defineProperty","get","set","value","enumerable","configurable","EventEmitter","GuidesManager","others"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;AACA,IASA;IACA;AACA;IACA;IACA;AACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;IAEA;;IACA,IAAIA,eAAa,GAAG,UAAUC,CAAV,EAAaC,CAAb,EAAgB;MAClCF,eAAa,GAAGG,MAAM,CAACC,cAAP,IAAyB;QACvCC,SAAS,EAAE;mBACAC,KAF4B,IAEnB,UAAUL,CAAV,EAAaC,CAAb,EAAgB;QACpCD,CAAC,CAACI,SAAF,GAAcH,CAAd;OAHc,IAIX,UAAUD,CAAV,EAAaC,CAAb,EAAgB;QACnB,KAAK,IAAIK,CAAT,IAAcL,CAAd,EAAiB,IAAIC,MAAM,CAACK,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqCR,CAArC,EAAwCK,CAAxC,CAAJ,EAAgDN,CAAC,CAACM,CAAD,CAAD,GAAOL,CAAC,CAACK,CAAD,CAAR;OALnE;;MAQA,OAAOP,eAAa,CAACC,CAAD,EAAIC,CAAJ,CAApB;IACD,CAVD;;IAYA,SAASS,WAAT,CAAmBV,CAAnB,EAAsBC,CAAtB,EAAyB;MACvB,IAAI,OAAOA,CAAP,KAAa,UAAb,IAA2BA,CAAC,KAAK,IAArC,EAA2C,MAAM,IAAIU,SAAJ,CAAc,yBAAyBC,MAAM,CAACX,CAAD,CAA/B,GAAqC,+BAAnD,CAAN;MAC3CF,eAAa,CAACC,CAAD,EAAIC,CAAJ,CAAb;;MAEA,SAASY,EAAT,GAAc;QACZ,KAAKC,WAAL,GAAmBd,CAAnB;;;MAGFA,CAAC,CAACO,SAAF,GAAcN,CAAC,KAAK,IAAN,GAAaC,MAAM,CAACa,MAAP,CAAcd,CAAd,CAAb,IAAiCY,EAAE,CAACN,SAAH,GAAeN,CAAC,CAACM,SAAjB,EAA4B,IAAIM,EAAJ,EAA7D,CAAd;IACD;;IACD,IAAIG,UAAQ,GAAG,YAAY;MACzBA,UAAQ,GAAGd,MAAM,CAACe,MAAP,IAAiB,SAASD,QAAT,CAAkBE,CAAlB,EAAqB;QAC/C,KAAK,IAAIC,CAAJ,EAAOC,CAAC,GAAG,CAAX,EAAcC,CAAC,GAAGC,SAAS,CAACC,MAAjC,EAAyCH,CAAC,GAAGC,CAA7C,EAAgDD,CAAC,EAAjD,EAAqD;UACnDD,CAAC,GAAGG,SAAS,CAACF,CAAD,CAAb;;UAEA,KAAK,IAAId,CAAT,IAAca,CAAd,EAAiB,IAAIjB,MAAM,CAACK,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqCU,CAArC,EAAwCb,CAAxC,CAAJ,EAAgDY,CAAC,CAACZ,CAAD,CAAD,GAAOa,CAAC,CAACb,CAAD,CAAR;;;QAGnE,OAAOY,CAAP;OAPF;;MAUA,OAAOF,UAAQ,CAACQ,KAAT,CAAe,IAAf,EAAqBF,SAArB,CAAP;IACD,CAZD;;IAaA,SAASG,eAAT,CAAuBC,EAAvB,EAA2BC,IAA3B,EAAiCC,IAAjC,EAAuC;MACrC,IAAIA,IAAI,IAAIN,SAAS,CAACC,MAAV,KAAqB,CAAjC,EAAoC,KAAK,IAAIH,CAAC,GAAG,CAAR,EAAWS,CAAC,GAAGF,IAAI,CAACJ,MAApB,EAA4BO,EAAjC,EAAqCV,CAAC,GAAGS,CAAzC,EAA4CT,CAAC,EAA7C,EAAiD;QACnF,IAAIU,EAAE,IAAI,EAAEV,CAAC,IAAIO,IAAP,CAAV,EAAwB;UACtB,IAAI,CAACG,EAAL,EAASA,EAAE,GAAGzB,KAAK,CAACE,SAAN,CAAgBwB,KAAhB,CAAsBtB,IAAtB,CAA2BkB,IAA3B,EAAiC,CAAjC,EAAoCP,CAApC,CAAL;UACTU,EAAE,CAACV,CAAD,CAAF,GAAQO,IAAI,CAACP,CAAD,CAAZ;;;MAGJ,OAAOM,EAAE,CAACM,MAAH,CAAUF,EAAE,IAAIzB,KAAK,CAACE,SAAN,CAAgBwB,KAAhB,CAAsBtB,IAAtB,CAA2BkB,IAA3B,CAAhB,CAAP;IACD;;IAED,SAASM,MAAT,GAAkB;MAChB,IAAIC,UAAU,GAAG,EAAjB;;MAEA,KAAK,IAAIC,EAAE,GAAG,CAAd,EAAiBA,EAAE,GAAGb,SAAS,CAACC,MAAhC,EAAwCY,EAAE,EAA1C,EAA8C;QAC5CD,UAAU,CAACC,EAAD,CAAV,GAAiBb,SAAS,CAACa,EAAD,CAA1B;;;MAGF,OAAOC,WAAW,CAACZ,KAAZ,CAAkB,KAAK,CAAvB,EAA0BC,eAAa,CAAC,CAAC,eAAD,CAAD,EAAoBS,UAApB,EAAgC,KAAhC,CAAvC,CAAP;IACD;;IAED,IAAIG,KAAK,GAAGJ,MAAM,CAAC,OAAD,EAAU,OAAV,CAAlB;IACA,IAAIK,MAAM,GAAGL,MAAM,CAAC,QAAD,CAAnB;IACA,IAAIM,KAAK,GAAGN,MAAM,CAAC,OAAD,CAAlB;IACA,IAAIO,QAAQ,GAAGP,MAAM,CAAC,UAAD,CAArB;IACA,IAAIQ,YAAY,GAAGR,MAAM,CAAC,cAAD,CAAzB;IACA,IAAIS,UAAU,GAAGC,SAAS,CAAC,eAAD,EAAkB,u0DAAlB,CAA1B;;IACA,IAAIC,YAAU,GAAGnB,eAAa,CAAC,CAAC,WAAD,EAAc,YAAd,EAA4B,eAA5B,EAA6C,OAA7C,EAAsD,gBAAtD,EAAwE,UAAxE,EAAoF,eAApF,EAAqG,eAArG,EAAsH,YAAtH,EAAoI,eAApI,EAAqJ,YAArJ,EAAmK,cAAnK,EAAmL,OAAnL,EAA4L,kBAA5L,EAAgN,gBAAhN,EAAkO,iBAAlO,EAAqP,gBAArP,EAAuQ,eAAvQ,EAAwR,YAAxR,EAAsS,YAAtS,CAAD,EAAsToB,UAAtT,EAAoU,IAApU,CAA9B;;IACA,IAAIC,OAAO,GAAG,CAAC,WAAD,EAAc,YAAd,EAA4B,QAA5B,EAAsC,cAAtC,EAAsD,QAAtD,EAAgE,YAAhE,EAA8E,iBAA9E,EAAiG,aAAjG,EAAgH,mBAAhH,EAAqI,mBAArI,EAA0J,QAA1J,EAAoK,WAApK,CAAd;IACA,IAAIC,MAAM,GAAG,CAAC,cAAD,EAAiB,eAAjB,EAAkC,WAAlC,EAA+C,MAA/C,EAAuD,SAAvD,EAAkE,YAAlE,CAAb;IAEA,IAAIC,aAAa,GAAGC,QAAM,CAAC,KAAD,EAAQP,UAAR,CAA1B;;IAEA,IAAIQ,MAAM,gBAEV,UAAUC,MAAV,EAAkB;MAChBzC,WAAS,CAACwC,MAAD,EAASC,MAAT,CAAT;;MAEA,SAASD,MAAT,CAAgBE,KAAhB,EAAuB;QACrB,IAAIC,KAAK,GAAGF,MAAM,CAAC1C,IAAP,CAAY,IAAZ,EAAkB2C,KAAlB,KAA4B,IAAxC;;QAEAC,KAAK,CAACC,KAAN,GAAc;UACZC,MAAM,EAAE;SADV;QAGAF,KAAK,CAACG,SAAN,GAAkB,CAAlB;QACAH,KAAK,CAACI,UAAN,GAAmBC,SAAS,EAA5B;QACAL,KAAK,CAACM,aAAN,GAAsB,EAAtB;QACAN,KAAK,CAACO,YAAN,GAAqB,KAArB;QACAP,KAAK,CAACQ,KAAN,GAAc,CAAd;QACAR,KAAK,CAACS,WAAN,GAAoB,CAApB;QACAT,KAAK,CAACU,SAAN,GAAkB,IAAlB;;QAEAV,KAAK,CAACW,WAAN,GAAoB,UAAUC,CAAV,EAAa;UAC/B,IAAIC,KAAK,GAAGD,CAAC,CAACC,KAAd;cACIC,UAAU,GAAGF,CAAC,CAACE,UADnB;UAEAd,KAAK,CAACO,YAAN,GAAqB,IAArB;;UAEAP,KAAK,CAACe,OAAN,CAAcH,CAAd;;IAEN;IACA;IACA;IACA;IACA;;;UAGMZ,KAAK,CAACD,KAAN,CAAYY,WAAZ,CAAwBhD,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;YAChDI,WAAW,EAAEH,KAAK,CAACI;WADW,CAAhC;;UAIA,IAAI,CAACjB,KAAK,CAACkB,KAAN,CAAYC,MAAZ,EAAL,EAA2B;YACzB;;;UAGFL,UAAU,CAACM,eAAX;UACAN,UAAU,CAACO,cAAX;;UAEArB,KAAK,CAACsB,gBAAN,CAAuBV,CAAvB;SAzBF;;QA4BAZ,KAAK,CAACuB,OAAN,GAAgB,UAAUX,CAAV,EAAa;UAC3B,IAAIZ,KAAK,CAACO,YAAV,EAAwB;YACtBP,KAAK,CAACO,YAAN,GAAqB,KAArB;YACAiB,QAAQ,CAACZ,CAAC,CAACC,KAAF,CAAQI,MAAT,EAAiB9B,QAAjB,CAAR;;;UAGF,IAAIsC,OAAO,GAAGzB,KAAK,CAACe,OAAN,CAAcH,CAAd,CAAd;;IAEN;IACA;IACA;IACA;IACA;;;UAGMZ,KAAK,CAACD,KAAN,CAAY2B,MAAZ,CAAmB/D,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;YAC3CI,WAAW,EAAEJ,CAAC,CAACC,KAAF,CAAQI;WADI,CAA3B;;UAIA,IAAI,CAACjB,KAAK,CAACkB,KAAN,CAAYC,MAAZ,EAAL,EAA2B;YACzBnB,KAAK,CAAC2B,cAAN,CAAqBf,CAArB;;YAEA;;;UAGFZ,KAAK,CAAC4B,WAAN,CAAkBhB,CAAlB;;UAEA,OAAOa,OAAP;SA3BF;;QA8BAzB,KAAK,CAAC6B,SAAN,GAAkB,UAAUjB,CAAV,EAAa;UAC7B,IAAIC,KAAK,GAAGD,CAAC,CAACC,KAAd;cACIiB,QAAQ,GAAGlB,CAAC,CAACkB,QADjB;cAEIC,KAAK,GAAGnB,CAAC,CAACmB,KAFd;cAGIC,KAAK,GAAGpB,CAAC,CAACoB,KAHd;;UAKA,IAAIC,GAAG,GAAGjC,KAAK,CAACe,OAAN,CAAcH,CAAd,CAAV;;UAEA,IAAIV,MAAM,GAAGF,KAAK,CAACC,KAAN,CAAYC,MAAzB;UACA,IAAIgC,EAAE,GAAGlC,KAAK,CAACD,KAAf;cACIoC,cAAc,GAAGD,EAAE,CAACC,cADxB;cAEIC,cAAc,GAAGF,EAAE,CAACE,cAFxB;cAGIC,KAAK,GAAGH,EAAE,CAACG,KAHf;cAIIC,UAAU,GAAGJ,EAAE,CAACI,UAJpB;cAKIC,YAAY,GAAGL,EAAE,CAACK,YALtB;UAMA,IAAIC,IAAI,GAAGxC,KAAK,CAACS,WAAjB;UACA,IAAIgC,QAAQ,GAAGC,UAAU,CAAC,CAACT,GAAG,GAAGO,IAAP,EAAaG,OAAb,CAAqBN,KAAK,IAAI,CAA9B,CAAD,CAAzB;UACA,IAAIO,aAAa,GAAG5C,KAAK,CAACG,SAAN,IAAmBoC,YAAY,IAAI,CAAnC,CAApB;;UAEA,IAAIH,cAAJ,EAAoB;YAClBpC,KAAK,CAAC6C,cAAN,CAAqBC,KAArB,CAA2BC,OAA3B,IAAsC,gBAAtC;;;UAGFC,WAAW,CAACnC,KAAK,CAACI,MAAP,EAAe9B,QAAf,CAAX;;IAEN;IACA;IACA;IACA;IACA;;UAEMa,KAAK,CAACD,KAAN,CAAY8B,SAAZ,CAAsBlE,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;YAC9CI,WAAW,EAAEH,KAAK,CAACI;WADS,CAA9B;;UAIAjB,KAAK,CAAC2B,cAAN,CAAqBf,CAArB;;UAEA,IAAIC,KAAK,CAACoC,SAAV,EAAqB;YACnB,IAAIjD,KAAK,CAACO,YAAV,EAAwB;;IAEhC;IACA;IACA;IACA;IACA;cACUP,KAAK,CAACD,KAAN,CAAYmD,YAAZ,CAAyBvF,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKiD,CAAL,CAAT,EAAkB;gBACjDqB,GAAG,EAAE;eAD0B,CAAjC;;;YAKF,IAAIQ,QAAQ,IAAIG,aAAZ,IAA6B1C,MAAM,CAACiD,OAAP,CAAeV,QAAf,IAA2B,CAA5D,EAA+D;cAC7DzC,KAAK,CAACoD,QAAN,CAAe;gBACblD,MAAM,EAAE9B,eAAa,CAACA,eAAa,CAAC,EAAD,EAAK8B,MAAL,EAAa,IAAb,CAAd,EAAkC,CAACuC,QAAD,CAAlC,EAA8C,KAA9C;eADvB,EAEG,YAAY;;IAEzB;IACA;IACA;IACA;IACA;gBACYN,cAAc,CAAC;kBACbjC,MAAM,EAAEF,KAAK,CAACC,KAAN,CAAYC,MADP;kBAEb6B,KAAK,EAAEA,KAFM;kBAGbC,KAAK,EAAEA,KAHM;kBAIbqB,KAAK,EAAEnD,MAAM,CAAChC,MAJD;kBAKboF,KAAK,EAAE,IALM;kBAMbC,QAAQ,EAAE,KANG;kBAObC,QAAQ,EAAE;iBAPE,CAAd;eATF;;WAdJ,MAkCO;YACL,IAAIC,OAAO,GAAGf,UAAU,CAAC7B,KAAK,CAACI,MAAN,CAAayC,YAAb,CAA0B,YAA1B,CAAD,CAAxB;YACA,IAAIC,UAAU,GAAG,KAAjB;YACA,IAAIC,UAAU,GAAG,KAAjB;YACA1D,MAAM,GAAG9B,eAAa,CAAC,EAAD,EAAK8B,MAAL,EAAa,IAAb,CAAtB;YACA,IAAI2D,UAAU,GAAG3D,MAAM,CAACiD,OAAP,CAAeV,QAAf,CAAjB;;YAEA,IAAIX,QAAQ,IAAIW,QAAQ,GAAGG,aAAvB,IAAwCiB,UAAU,GAAG,CAAC,CAAd,IAAmBA,UAAU,KAAKJ,OAA9E,EAAuF;cACrF,IAAInB,UAAU,KAAKA,UAAU,KAAK,IAAf,IAAuBA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAA5D,CAAd,EAA8E;gBAC5E;;;cAGFjD,MAAM,CAAC4D,MAAP,CAAcL,OAAd,EAAuB,CAAvB;cACAE,UAAU,GAAG,IAAb;aANF,MAOO,IAAIE,UAAU,GAAG,CAAC,CAAlB,EAAqB;cAC1B;aADK,MAEA;cACL,IAAIvB,UAAU,KAAKA,UAAU,KAAK,IAAf,IAAuBA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAA5D,CAAd,EAA8E;gBAC5E;;;cAGFjD,MAAM,CAACuD,OAAD,CAAN,GAAkBhB,QAAlB;cACAmB,UAAU,GAAG,IAAb;;;YAGF5D,KAAK,CAACoD,QAAN,CAAe;cACblD,MAAM,EAAEA;aADV,EAEG,YAAY;cACb,IAAI6D,UAAU,GAAG/D,KAAK,CAACC,KAAN,CAAYC,MAA7B;cACAiC,cAAc,CAAC;gBACbJ,KAAK,EAAEA,KADM;gBAEbC,KAAK,EAAEA,KAFM;gBAGb9B,MAAM,EAAE6D,UAHK;gBAIbT,KAAK,EAAE,KAJM;gBAKbD,KAAK,EAAEI,OALM;gBAMbD,QAAQ,EAAEI,UANG;gBAObL,QAAQ,EAAEI;eAPE,CAAd;aAJF;;SAhGJ;;QAiHA3D,KAAK,CAACgE,QAAN,GAAiB,YAAY;UAC3BhE,KAAK,CAACiE,MAAN;SADF;;QAIAjE,KAAK,CAACC,KAAN,CAAYC,MAAZ,GAAqBH,KAAK,CAACmE,aAAN,IAAuB,EAA5C;QACAlE,KAAK,CAACG,SAAN,GAAkBJ,KAAK,CAACoE,gBAAN,IAA0B,CAA5C;QACA,OAAOnE,KAAP;;;MAGF,IAAIoE,OAAO,GAAGvE,MAAM,CAAC3C,SAArB;;MAEAkH,OAAO,CAACC,MAAR,GAAiB,YAAY;QAC3B,IAAInC,EAAE,GAAG,KAAKnC,KAAd;YACIuE,SAAS,GAAGpC,EAAE,CAACoC,SADnB;YAEIC,IAAI,GAAGrC,EAAE,CAACqC,IAFd;YAGI/B,IAAI,GAAGN,EAAE,CAACM,IAHd;YAIIgC,UAAU,GAAGtC,EAAE,CAACsC,UAJpB;YAKI1B,KAAK,GAAGZ,EAAE,CAACY,KALf;YAMI2B,UAAU,GAAGvC,EAAE,CAACuC,UANpB;YAOIrC,cAAc,GAAGF,EAAE,CAACE,cAPxB;YAQIsC,QAAQ,GAAGxC,EAAE,CAACwC,QARlB;YASIC,cAAc,GAAGzC,EAAE,CAACyC,cATxB;YAUIC,EAAE,GAAG1C,EAAE,CAAC2C,aAVZ;YAWIA,aAAa,GAAGD,EAAE,KAAK,KAAK,CAAZ,GAAgB,EAAhB,GAAqBA,EAXzC;QAYA,IAAI7E,KAAK,GAAG,KAAKA,KAAjB;QACA,IAAI+E,aAAa,GAAG,KAAKC,gBAAL,EAApB;QACA,IAAIC,UAAU,GAAG,EAAjB;QACAxF,UAAY,CAACyF,OAAb,CAAqB,UAAUC,IAAV,EAAgB;UACnC,IAAIA,IAAI,KAAK,OAAT,IAAoBA,IAAI,KAAK,UAA7B,IAA2CA,IAAI,KAAK,mBAAxD,EAA6E;YAC3E;;;UAGFF,UAAU,CAACE,IAAD,CAAV,GAAmBnF,KAAK,CAACmF,IAAD,CAAxB;SALF;QAOA,KAAK1E,KAAL,GAAagC,IAAb;QACA,KAAK/B,WAAL,GAAmB+D,UAAU,IAAIhC,IAAjC;QACA2C,OAAO,CAACC,GAAR,CAAYb,IAAZ,EAAkB/B,IAAlB,EAAwBgC,UAAxB;QACA,OAAOa,aAAa,CAAC1F,aAAD,EAAgB;UAClC2F,GAAG,EAAE,KAAKlF,UADwB;UAElCsE,QAAQ,EAAEA,QAFwB;UAGlCJ,SAAS,EAAE,GAAG3F,MAAH,CAAUC,MAAM,CAAC,SAAD,EAAY2F,IAAZ,CAAhB,EAAmC,GAAnC,EAAwC5F,MAAxC,CAA+C2F,SAA/C,CAHuB;UAIlCxB,KAAK,EAAEA;SAJW,EAKjBuC,aAAa,CAAC,KAAD,EAAQ;UACtBf,SAAS,EAAE1F,MAAM,CAAC,cAAD,CADK;UAEtB0G,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,eAAP;SAFM,CALI,EAQhBD,aAAa,CAACE,KAAD,EAAQ5H,UAAQ,CAAC;UAChC2H,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,OAAP,CADwB;UAEhCxC,KAAK,EAAE2B;SAFwB,EAG9BO,UAH8B,CAAhB,CARG,EAWHK,aAAa,CAAC,KAAD,EAAQ;UACpCf,SAAS,EAAErF,MADyB;UAEpCqG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,eAAP,CAF4B;UAGpCxC,KAAK,EAAE;YACL0C,SAAS,EAAE,GAAG7G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC,CAAC,KAAKwB,SAAN,GAAkB,KAAKM,WAA5D,EAAyE,KAAzE;;SAJe,EAM3B2B,cAAc,IAAIiD,aAAa,CAAC,KAAD,EAAQ;UACxCf,SAAS,EAAElF,YAD6B;UAExCkG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,gBAAP,CAFgC;UAGxCxC,KAAK,EAAE+B,aAAa,IAAI;SAHQ,CANJ,EAU1BQ,aAAa,CAAC,KAAD,EAAQ;UACvBf,SAAS,EAAEtF,KADY;UAEvBsG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,cAAP,CAFe;UAGvBxC,KAAK,EAAE6B;SAHQ,CAVa,EAc1B,KAAKc,YAAL,EAd0B,CAXV,CAApB;OA1BF;;IAsDF;IACA;;;MAGErB,OAAO,CAACsB,SAAR,GAAoB,UAAUC,OAAV,EAAmB;QACrC,KAAKC,KAAL,CAAWC,IAAX,CAAgBF,OAAhB;OADF;;MAIAvB,OAAO,CAACqB,YAAR,GAAuB,YAAY;QACjC,IAAIzF,KAAK,GAAG,IAAZ;;QAEA,IAAID,KAAK,GAAG,KAAKA,KAAjB;QACA,IAAImC,EAAE,GAAGnC,KAAT;YACIwE,IAAI,GAAGrC,EAAE,CAACqC,IADd;YAEIuB,UAAU,GAAG5D,EAAE,CAAC4D,UAFpB;YAGIC,UAAU,GAAG7D,EAAE,CAAC6D,UAHpB;YAIIC,eAAe,GAAG9D,EAAE,CAAC8D,eAJzB;YAKIpB,EAAE,GAAG1C,EAAE,CAAC2C,aALZ;YAMIA,aAAa,GAAGD,EAAE,KAAK,KAAK,CAAZ,GAAgB,EAAhB,GAAqBA,EANzC;YAOIrC,YAAY,GAAGL,EAAE,CAACK,YAPtB;QAQA,IAAIC,IAAI,GAAG,KAAK/B,WAAhB;QACA,IAAIqE,aAAa,GAAG,KAAKC,gBAAL,EAApB;QACA,IAAI7E,MAAM,GAAG,KAAKD,KAAL,CAAWC,MAAxB;;QAEA,IAAI+F,cAAc,GAAGlG,KAAK,CAACkG,cAAN,IAAwBlG,KAAK,CAACmG,aAA9B,IAA+C,UAAUC,CAAV,EAAa;UAC/E,OAAOA,CAAP;SADF;;QAIA,KAAK7F,aAAL,GAAqB,EAArB;;QAEA,IAAIwF,UAAJ,EAAgB;UACd,OAAO5F,MAAM,CAACkG,GAAP,CAAW,UAAUnE,GAAV,EAAelE,CAAf,EAAkB;YAClC,IAAI0E,QAAQ,GAAGR,GAAG,IAAIM,YAAY,IAAI,CAApB,CAAlB;YACA,OAAO8C,aAAa,CAAC,KAAD,EAAQ;cAC1Bf,SAAS,EAAE1F,MAAM,CAAC,OAAD,EAAU2F,IAAV,CADS;cAE1Be,GAAG,EAAEe,IAAI,CAACrG,KAAD,EAAQ,eAAR,EAAyBjC,CAAzB,CAFiB;cAG1BuI,GAAG,EAAEvI,CAHqB;cAI1B,cAAcA,CAJY;cAK1B,YAAYkE,GALc;cAM1Ba,KAAK,EAAEnF,UAAQ,CAACA,UAAQ,CAAC,EAAD,EAAKoI,UAAL,CAAT,EAA2B;gBACxCP,SAAS,EAAE,GAAG7G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC8D,QAAQ,GAAGD,IAAhD,EAAsD,qBAAtD;eADE;aANG,EASjBwD,eAAe,IAAIX,aAAa,CAAC,KAAD,EAAQ;cACzCf,SAAS,EAAE1F,MAAM,CAAC,WAAD,CADwB;cAEzCkE,KAAK,EAAE+B,aAAa,IAAI;aAFS,EAGhCoB,cAAc,CAAChE,GAAD,CAHkB,CATf,CAApB;WAFK,CAAP;;;QAkBF;OAzCF;;MA4CAmC,OAAO,CAACmC,iBAAR,GAA4B,YAAY;QACtC,IAAIvG,KAAK,GAAG,IAAZ;;QAEA,KAAKkB,KAAL,GAAa,IAAIsF,KAAJ,CAAU,KAAKpG,UAAL,CAAgBqG,OAA1B,EAAmC;UAC9CC,SAAS,EAAEC,QAAQ,CAACC;SADT,EAEVC,EAFU,CAEP,WAFO,EAEM,UAAUjG,CAAV,EAAa;UAC9B,IAAIsB,EAAE,GAAGlC,KAAK,CAACD,KAAf;cACIwE,IAAI,GAAGrC,EAAE,CAACqC,IADd;cAEIjC,UAAU,GAAGJ,EAAE,CAACI,UAFpB;UAGA,IAAIE,IAAI,GAAGxC,KAAK,CAACS,WAAjB;;UAEA,IAAI6B,UAAU,KAAK,IAAnB,EAAyB;YACvB1B,CAAC,CAACkG,IAAF;YACA;;;UAGF,IAAIhG,UAAU,GAAGF,CAAC,CAACE,UAAnB;UACA,IAAIG,MAAM,GAAGH,UAAU,CAACG,MAAxB;UACA,IAAIJ,KAAK,GAAGD,CAAC,CAACC,KAAd;UACA,IAAIkG,aAAa,GAAG/G,KAAK,CAAC4F,KAAN,CAAYmB,aAAhC;UACA,IAAIC,aAAa,GAAGhH,KAAK,CAACgH,aAA1B;UACA,IAAIC,YAAY,GAAG1C,IAAI,KAAK,YAA5B;;UAEA,IAAI2C,UAAU,GAAGlH,KAAK,CAACmH,aAAN,CAAoBC,qBAApB,EAAjB;;UAEA,IAAIC,MAAM,GAAGC,oBAAoB,CAACtH,KAAK,CAACI,UAAN,CAAiBqG,OAAlB,CAAjC;UACA,IAAIc,SAAS,GAAGC,mBAAmB,CAACH,MAAD,EAAS,CAACzG,CAAC,CAAC6G,OAAF,GAAYP,UAAU,CAACQ,IAAxB,EAA8B9G,CAAC,CAAC+G,OAAF,GAAYT,UAAU,CAACU,GAArD,CAAT,CAAnC;UACAL,SAAS,CAAC,CAAD,CAAT,IAAgBP,aAAa,CAACa,UAA9B;UACAN,SAAS,CAAC,CAAD,CAAT,IAAgBP,aAAa,CAACc,SAA9B;UACAP,SAAS,CAACN,YAAY,GAAG,CAAH,GAAO,CAApB,CAAT,IAAmCjH,KAAK,CAACG,SAAN,GAAkBqC,IAArD;UACA3B,KAAK,CAAC0G,SAAN,GAAkBA,SAAlB;UACA1G,KAAK,CAACwG,MAAN,GAAeA,MAAf;UACA,IAAIU,SAAS,GAAGzF,UAAU,IAAIA,UAAU,CAACa,OAAX,CAAmB,KAAnB,IAA4B,CAAC,CAA3D;UACA,IAAI6E,YAAY,GAAG1F,UAAU,IAAIA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAAjE;UACA,IAAI8E,YAAY,GAAG3F,UAAU,IAAIA,UAAU,CAACa,OAAX,CAAmB,QAAnB,IAA+B,CAAC,CAAjE;;UAEA,IAAIlC,MAAM,KAAK8F,aAAf,EAA8B;YAC5B,IAAIgB,SAAJ,EAAe;cACbnH,CAAC,CAACkG,IAAF;cACA;;;YAGFjG,KAAK,CAACoC,SAAN,GAAkB,IAAlB;YACApC,KAAK,CAACI,MAAN,GAAejB,KAAK,CAACkI,YAArB,CAP4B;WAA9B,MAQO,IAAIC,QAAQ,CAAClH,MAAD,EAAS/B,KAAT,CAAZ,EAA6B;YAClC,IAAI8I,YAAY,IAAIC,YAApB,EAAkC;cAChCrH,CAAC,CAACkG,IAAF;cACA;;;YAGFjG,KAAK,CAACI,MAAN,GAAeA,MAAf,CANkC;WAA7B,MAOA;YACLL,CAAC,CAACkG,IAAF;YACA,OAAO,KAAP;;;UAGF9G,KAAK,CAACW,WAAN,CAAkBC,CAAlB;SArDW,EAsDViG,EAtDU,CAsDP,MAtDO,EAsDC,KAAKtF,OAtDN,EAsDesF,EAtDf,CAsDkB,SAtDlB,EAsD6B,KAAKhF,SAtDlC,CAAb;;QAwDA,IAAI,KAAK9B,KAAL,CAAWqI,iBAAf,EAAkC;UAChC,KAAK1H,SAAL,GAAiB,IAAI2H,cAAJ,CAAmB,KAAKrE,QAAxB,CAAjB;;UAEA,KAAKtD,SAAL,CAAe4H,OAAf,CAAuB,KAAKtB,aAA5B,EAA2C;YACzCuB,GAAG,EAAE;WADP;;UAIA,KAAK7H,SAAL,CAAe4H,OAAf,CAAuB,KAAKE,eAAL,EAAvB,EAA+C;YAC7CD,GAAG,EAAE;WADP;SAPF,MAUO;UACL,KAAKvE,QAAL;;OAtEJ;;MA0EAI,OAAO,CAACqE,oBAAR,GAA+B,YAAY;QACzC,IAAIvG,EAAJ;;QAEA,KAAKhB,KAAL,CAAWwH,KAAX;QACA,CAACxG,EAAE,GAAG,KAAKxB,SAAX,MAA0B,IAA1B,IAAkCwB,EAAE,KAAK,KAAK,CAA9C,GAAkD,KAAK,CAAvD,GAA2DA,EAAE,CAACyG,UAAH,EAA3D;OAJF;;MAOAvE,OAAO,CAACwE,kBAAR,GAA6B,UAAUC,SAAV,EAAqB;QAChD,IAAI9E,UAAU,GAAG,KAAKhE,KAAL,CAAWmE,aAA5B;;QAEA,IAAI2E,SAAS,CAAC3E,aAAV,KAA4BH,UAAhC,EAA4C;;UAE1C,KAAKX,QAAL,CAAc;YACZlD,MAAM,EAAE6D,UAAU,IAAI;WADxB;;OALJ;;IAWF;IACA;IACA;IACA;;;MAGEK,OAAO,CAAC0E,UAAR,GAAqB,UAAU5I,MAAV,EAAkB;QACrC,KAAKkD,QAAL,CAAc;UACZlD,MAAM,EAAEA;SADV;OADF;;IAMF;IACA;IACA;IACA;;;MAGEkE,OAAO,CAAC2E,SAAR,GAAoB,YAAY;QAC9B,OAAO,KAAK9I,KAAL,CAAWC,MAAlB;OADF;;IAIF;IACA;IACA;IACA;;;MAGEkE,OAAO,CAAC4E,YAAR,GAAuB,UAAU/G,GAAV,EAAegH,QAAf,EAAyB;QAC9C,IAAIA,QAAQ,KAAK,KAAK,CAAtB,EAAyB;UACvBA,QAAQ,GAAG,KAAKxI,WAAhB;;;QAGF,KAAKyI,QAAL,CAAc;UACZ1E,UAAU,EAAEyE;SADd;;QAIA,IAAInE,aAAa,GAAG,KAAKC,gBAAL,EAApB;QACA,IAAIiC,aAAa,GAAG,KAAKA,aAAzB;QACA,KAAK7G,SAAL,GAAiB8B,GAAjB;QACA+E,aAAa,CAAClE,KAAd,CAAoB0C,SAApB,GAAgC,GAAG7G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC,CAACsD,GAAD,GAAOgH,QAA5C,EAAsD,KAAtD,CAAhC;QACA,IAAI/I,MAAM,GAAG,KAAKD,KAAL,CAAWC,MAAxB;QACA,IAAIqC,YAAY,GAAG,KAAKxC,KAAL,CAAWwC,YAAX,IAA2B,CAA9C;QACA,KAAKjC,aAAL,CAAmB2E,OAAnB,CAA2B,UAAUkE,EAAV,EAAcpL,CAAd,EAAiB;UAC1C,IAAI,CAACoL,EAAL,EAAS;YACP;;;UAGF,IAAI1G,QAAQ,GAAGvC,MAAM,CAACnC,CAAD,CAAN,IAAawE,YAAY,IAAI,CAA7B,CAAf;UACA4G,EAAE,CAACrG,KAAH,CAAS0C,SAAT,GAAqB,GAAG7G,MAAH,CAAUmG,aAAV,EAAyB,GAAzB,EAA8BnG,MAA9B,CAAqC8D,QAAQ,GAAGwG,QAAhD,EAA0D,qBAA1D,CAArB;UACAE,EAAE,CAACrG,KAAH,CAASsG,OAAT,GAAmB,CAACnH,GAAD,GAAOQ,QAAP,GAAkB,CAAlB,GAAsB,MAAtB,GAA+B,OAAlD;SAPF;OAfF;;IA0BF;IACA;IACA;IACA;IACA;;;MAGE2B,OAAO,CAACiF,MAAR,GAAiB,UAAUJ,QAAV,EAAoBK,cAApB,EAAoC;QACnD,IAAIA,cAAc,KAAK,KAAK,CAA5B,EAA+B;UAC7BA,cAAc,GAAGL,QAAjB;;;QAGF,KAAKM,MAAL,CAAY,KAAKC,iBAAL,EAAZ,EAAsCP,QAAtC;QACA,KAAKD,YAAL,CAAkB,KAAKS,iBAAL,EAAlB,EAA4CH,cAA5C;OANF;;IASF;IACA;IACA;IACA;;;MAGElF,OAAO,CAACsF,UAAR,GAAqB,YAAY;QAC/B,OAAO,KAAKtJ,UAAL,CAAgBqG,OAAvB;OADF;;IAIF;IACA;IACA;IACA;;;MAGErC,OAAO,CAACoE,eAAR,GAA0B,YAAY;QACpC,OAAO,KAAK5C,KAAL,CAAWmB,aAAlB;OADF;;IAIF;IACA;;;MAGE3C,OAAO,CAACqF,iBAAR,GAA4B,YAAY;QACtC,OAAO,KAAKtJ,SAAZ;OADF;;IAIF;IACA;;;MAGEiE,OAAO,CAACoF,iBAAR,GAA4B,YAAY;QACtC,OAAO,KAAK5D,KAAL,CAAW+D,YAAX,EAAP;OADF;;IAIF;IACA;IACA;IACA;;;MAGEvF,OAAO,CAACmF,MAAR,GAAiB,UAAUtH,GAAV,EAAegH,QAAf,EAAyB;QACxC,IAAIA,QAAQ,KAAK,KAAK,CAAtB,EAAyB;UACvBA,QAAQ,GAAG,KAAKzI,KAAhB;;;QAGF,KAAK0I,QAAL,CAAc;UACZ1G,IAAI,EAAEyG;SADR;;QAIA,KAAKrD,KAAL,CAAW2D,MAAX,CAAkBtH,GAAlB,EAAuBgH,QAAvB;OATF;;IAYF;IACA;IACA;IACA;;;MAGE7E,OAAO,CAACH,MAAR,GAAiB,UAAUgF,QAAV,EAAoB;QACnC,IAAIA,QAAQ,KAAK,KAAK,CAAtB,EAAyB;UACvBA,QAAQ,GAAG,KAAKzI,KAAhB;;;QAGF,KAAK0I,QAAL,CAAc;UACZ1G,IAAI,EAAEyG;SADR;;QAIA,KAAKrD,KAAL,CAAW3B,MAAX,CAAkBgF,QAAlB;OATF;;MAYA7E,OAAO,CAACrD,OAAR,GAAkB,UAAUH,CAAV,EAAa;QAC7B,IAAIC,KAAK,GAAGD,CAAC,CAACC,KAAd;YACIkB,KAAK,GAAGnB,CAAC,CAACmB,KADd;YAEIC,KAAK,GAAGpB,CAAC,CAACoB,KAFd;QAGA,IAAIjC,KAAK,GAAG,KAAKA,KAAjB;QACA,IAAIwE,IAAI,GAAGxE,KAAK,CAACwE,IAAjB;YACIqF,KAAK,GAAG7J,KAAK,CAAC6J,KADlB;YAEIC,aAAa,GAAG9J,KAAK,CAAC8J,aAF1B;YAGIzH,cAAc,GAAGrC,KAAK,CAACqC,cAH3B;YAIIC,KAAK,GAAGtC,KAAK,CAACsC,KAJlB;QAKA,IAAIE,YAAY,GAAGxC,KAAK,CAACwC,YAAN,IAAsB,CAAzC;QACA,IAAIC,IAAI,GAAG,KAAK/B,WAAhB;;QAEA,IAAIyF,aAAa,GAAGnG,KAAK,CAACmG,aAAN,IAAuB,UAAUC,CAAV,EAAa;UACtD,OAAOA,CAAP;SADF;;QAIA,IAAIc,YAAY,GAAG1C,IAAI,KAAK,YAA5B;QACA,IAAIuF,SAAS,GAAGtC,mBAAmB,CAAC3G,KAAK,CAACwG,MAAP,EAAe,CAACtF,KAAD,EAAQC,KAAR,CAAf,CAAnC;QACA,IAAIuF,SAAS,GAAG1G,KAAK,CAAC0G,SAAtB;QACA,IAAIwC,OAAO,GAAGD,SAAS,CAAC,CAAD,CAAT,GAAevC,SAAS,CAAC,CAAD,CAAtC;QACA,IAAIyC,OAAO,GAAGF,SAAS,CAAC,CAAD,CAAT,GAAevC,SAAS,CAAC,CAAD,CAAtC;QACA,IAAI0C,gBAAgB,GAAG1H,YAAY,GAAGC,IAAtC;QACA,IAAIf,OAAO,GAAGyI,IAAI,CAACC,KAAL,CAAWlD,YAAY,GAAG+C,OAAH,GAAaD,OAApC,IAA+CxH,YAA7D;QACA,IAAIE,QAAQ,GAAGC,UAAU,CAAC,CAACjB,OAAO,GAAGe,IAAX,EAAiBG,OAAjB,CAAyBN,KAAK,IAAI,CAAlC,CAAD,CAAzB;QACA,IAAI+H,UAAU,GAAGR,KAAK,CAAClL,KAAN,GAAc2L,IAAd,CAAmB,UAAUC,CAAV,EAAa1N,CAAb,EAAgB;UAClD,OAAOsN,IAAI,CAACK,GAAL,CAAS9H,QAAQ,GAAG6H,CAApB,IAAyBJ,IAAI,CAACK,GAAL,CAAS9H,QAAQ,GAAG7F,CAApB,CAAhC;SADe,CAAjB;;QAIA,IAAIwN,UAAU,CAAClM,MAAX,IAAqBgM,IAAI,CAACK,GAAL,CAASH,UAAU,CAAC,CAAD,CAAV,GAAgB5H,IAAhB,GAAuBf,OAAhC,IAA2CoI,aAApE,EAAmF;UACjFpH,QAAQ,GAAG2H,UAAU,CAAC,CAAD,CAArB;UACA3I,OAAO,GAAGgB,QAAQ,GAAGD,IAArB;;;QAGF,IAAI,CAAC3B,KAAK,CAACoC,SAAP,IAAoB,CAAC,KAAK1C,YAA9B,EAA4C;UAC1C,IAAI6B,cAAJ,EAAoB;YAClB,IAAIoI,UAAU,GAAGjG,IAAI,KAAK,YAAT,GAAwB,CAACwF,OAAD,EAAUtI,OAAO,GAAGwI,gBAApB,CAAxB,GAAgE,CAACxI,OAAO,GAAGwI,gBAAX,EAA6BD,OAA7B,CAAjF;YACA,KAAKnH,cAAL,CAAoBC,KAApB,CAA0BC,OAA1B,IAAqC,oBAAoB,mCAApB,GAA0D,aAAapE,MAAb,CAAoB6L,UAAU,CAACpE,GAAX,CAAe,UAAUD,CAAV,EAAa;cAC7I,OAAO,GAAGxH,MAAH,CAAUwH,CAAV,EAAa,IAAb,CAAP;aADiH,EAEhHsE,IAFgH,CAE3G,IAF2G,CAApB,EAEhF,GAFgF,CAA/F;YAGA,KAAK5H,cAAL,CAAoB6H,SAApB,GAAgC,GAAG/L,MAAH,CAAUuH,aAAa,CAACzD,QAAD,CAAvB,CAAhC;;;UAGF,IAAIxB,MAAM,GAAGJ,KAAK,CAACI,MAAnB;UACAA,MAAM,CAAC0J,YAAP,CAAoB,UAApB,EAAgClI,QAAhC;UACAxB,MAAM,CAAC6B,KAAP,CAAa0C,SAAb,GAAyB,GAAG7G,MAAH,CAAU,KAAKoG,gBAAL,EAAV,EAAmC,GAAnC,EAAwCpG,MAAxC,CAA+C8C,OAAO,GAAGc,YAAY,GAAGC,IAAxE,EAA8E,KAA9E,CAAzB;;;QAGF,OAAOf,OAAP;OAhDF;;MAmDA2C,OAAO,CAACW,gBAAR,GAA2B,YAAY;QACrC,OAAO,KAAKhF,KAAL,CAAWwE,IAAX,KAAoB,YAApB,GAAmC,YAAnC,GAAkD,YAAzD;OADF;;MAIAH,OAAO,CAAC9C,gBAAR,GAA2B,UAAUV,CAAV,EAAa;QACtC,IAAIZ,KAAK,GAAG,IAAZ;;QAEA,IAAI4K,aAAa,GAAG,KAAK7K,KAAL,CAAW6K,aAA/B;;QAEA,IAAI,CAACA,aAAL,EAAoB;UAClB;;;QAGF,IAAI/J,KAAK,GAAGD,CAAC,CAACC,KAAd;QACA,IAAIgK,UAAU,GAAG,IAAIC,UAAJ,EAAjB;QACAjK,KAAK,CAACgK,UAAN,GAAmBA,UAAnB;QACAA,UAAU,CAAChE,EAAX,CAAc,QAAd,EAAwB,UAAU3E,EAAV,EAAc;UACpC,IAAI0C,EAAJ,EAAQmG,EAAR;;UAEA,IAAIrE,SAAS,GAAGxE,EAAE,CAACwE,SAAnB;cACIsE,SAAS,GAAG9I,EAAE,CAAC8I,SADnB;;IAGN;IACA;IACA;IACA;IACA;;UAEM,CAACD,EAAE,GAAG,CAACnG,EAAE,GAAG5E,KAAK,CAACD,KAAZ,EAAmBkL,eAAzB,MAA8C,IAA9C,IAAsDF,EAAE,KAAK,KAAK,CAAlE,GAAsE,KAAK,CAA3E,GAA+EA,EAAE,CAAC3N,IAAH,CAAQwH,EAAR,EAAY;YACzF8B,SAAS,EAAEA,SAD8E;YAEzFsE,SAAS,EAAEA;WAFkE,CAA/E;SAZF,EAgBGnE,EAhBH,CAgBM,MAhBN,EAgBc,UAAU3E,EAAV,EAAc;UAC1B,IAAI6H,OAAO,GAAG7H,EAAE,CAAC6H,OAAjB;cACIC,OAAO,GAAG9H,EAAE,CAAC8H,OADjB;cAEIlJ,UAAU,GAAGoB,EAAE,CAACpB,UAFpB;;UAIAd,KAAK,CAACkB,KAAN,CAAYgK,QAAZ,CAAqBnB,OAArB,EAA8BC,OAA9B,EAAuClJ,UAAU,CAACA,UAAlD,EAA8D,IAA9D;SArBF;QAuBA+J,UAAU,CAACM,SAAX,CAAqBvK,CAArB,EAAwB;UACtB8F,SAAS,EAAEkE,aAAa,CAAClE;SAD3B;OAnCF;;MAwCAtC,OAAO,CAACxC,WAAR,GAAsB,UAAUhB,CAAV,EAAa;QACjC,IAAIgK,aAAa,GAAG,KAAK7K,KAAL,CAAW6K,aAA/B;;QAEA,IAAI,CAACA,aAAL,EAAoB;UAClB;;;QAGF,IAAIC,UAAU,GAAGjK,CAAC,CAACC,KAAF,CAAQgK,UAAzB;QACAA,UAAU,CAACO,IAAX,CAAgBxK,CAAhB,EAAmBgK,aAAnB;OARF;;MAWAxG,OAAO,CAACzC,cAAR,GAAyB,UAAUf,CAAV,EAAa;QACpC,IAAIsB,EAAJ;;QAEA,CAACA,EAAE,GAAGtB,CAAC,CAACC,KAAF,CAAQgK,UAAd,MAA8B,IAA9B,IAAsC3I,EAAE,KAAK,KAAK,CAAlD,GAAsD,KAAK,CAA3D,GAA+DA,EAAE,CAACmJ,OAAH,EAA/D;QACAzK,CAAC,CAACC,KAAF,CAAQgK,UAAR,GAAqB,IAArB;OAJF;;MAOAzG,OAAO,CAAC8E,QAAR,GAAmB,UAAUoC,KAAV,EAAiB;QAClC,IAAIrC,QAAQ,GAAGqC,KAAK,CAAC9I,IAArB;YACI8G,cAAc,GAAGgC,KAAK,CAAC9G,UAD3B;QAEA,IAAI+G,OAAO,GAAG,CAAC,CAAC,KAAKxL,KAAL,CAAWyC,IAA3B;QACA,IAAIgJ,aAAa,GAAG,CAAC,CAAC,KAAKzL,KAAL,CAAWyE,UAAjC;;QAEA,IAAIgH,aAAJ,EAAmB;UACjB,IAAIlC,cAAJ,EAAoB;YAClB,KAAK7I,WAAL,GAAmB6I,cAAnB;;SAFJ,MAIO;UACL,IAAIA,cAAJ,EAAoB;YAClB,KAAK9I,KAAL,GAAa8I,cAAb;YACA,KAAK7I,WAAL,GAAmB6I,cAAnB;;;UAGF,IAAIL,QAAJ,EAAc;YACZ,KAAKxI,WAAL,GAAmBwI,QAAnB;;;;QAIJ,IAAIA,QAAJ,EAAc;UACZ,KAAKzI,KAAL,GAAayI,QAAb;;OAtBJ;;MA0BApJ,MAAM,CAAC4L,YAAP,GAAsB;QACpBnH,SAAS,EAAE,EADS;QAEpBC,IAAI,EAAE,YAFc;QAGpB/B,IAAI,EAAE,CAHc;QAIpBgC,UAAU,EAAE,CAJQ;QAKpB1B,KAAK,EAAE,EALa;QAMpB+G,aAAa,EAAE,CANK;QAOpBD,KAAK,EAAE,EAPa;QAQpBvH,KAAK,EAAE,CARa;QASpBa,YAAY,EAAE,YAAY,EATN;QAUpBf,cAAc,EAAE,YAAY,EAVR;QAWpB8I,eAAe,EAAE,YAAY,EAXT;QAYpBtK,WAAW,EAAE,YAAY,EAZL;QAapBe,MAAM,EAAE,YAAY,EAbA;QAcpBG,SAAS,EAAE,YAAY,EAdH;QAepBO,cAAc,EAAE,KAfI;QAgBpB8D,aAAa,EAAE,UAAUC,CAAV,EAAa;UAC1B,OAAOA,CAAP;SAjBkB;QAmBpBjC,aAAa,EAAE,EAnBK;QAoBpB5B,UAAU,EAAE,KApBQ;QAqBpBwD,UAAU,EAAE,IArBQ;QAsBpBC,UAAU,EAAE,EAtBQ;QAuBpBpB,cAAc,EAAE,EAvBI;QAwBpBE,aAAa,EAAE,EAxBK;QAyBpBV,gBAAgB,EAAE;OAzBpB;MA2BA,OAAOtE,MAAP;IACD,CAlsBD,CAksBE6L,aAlsBF,CAFA;;IC5FO,IAAMnM,YAAU,GAA+BoM,YAA/C;AAEP,IAAO,IAAMlM,SAAO,GAAGmM,OAAhB;AAEP,IAAO,IAAMlM,QAAM,GAAGmM,MAAf;;ICJP;;;MAAyCxO,8BAAA;;MAGrC,oBAAA,CAAY0C,KAAZ;QAAA,YACID,WAAA,KAAA,EAAMC,KAAN,SADJ;;QAFOC,WAAA,GAA0B,EAA1B;QAIHA,KAAI,CAACC,KAAL,GAAaD,KAAI,CAACD,KAAlB;;;;;;MAEG,cAAA,GAAP;QACI,OAAO+L,aAAA,CAACC,MAAD;UAAazG,GAAG,EAAEA,GAAG,CAAC,IAAD,EAAO,QAAP;WAAsB,KAAKrF,MAAhD,CAAP;OADG;;MAGX,kBAAA;IAAC,EAVwC6L,UAAzC;;ICgCA;;;MAAqBzO,yBAAA;;;;;;;;MAUjB,eAAA,CAAYqJ,SAAZ,EAAoCf,OAApC;QAAoC,sBAAA,EAAA;UAAAA,YAAA;;;QAApC,YACI7F,WAAA,KAAA,SADJ;;QATQE,uBAAA,GAA8C,IAA9C;QACAA,iBAAA,GAAkC,IAAlC;QACAA,WAAA,GAAQ,KAAR;QASJ,IAAMgM,MAAM,GAAQ,EAApB;QAEAtM,QAAM,CAACuF,OAAP,CAAe,UAAAC,IAAA;UACX8G,MAAM,CAACC,QAAQ,CAAC,YAAA,CAAM/G,IAAN,CAAD,CAAT,CAAN,GAAiC,UAACtE,CAAD;YAAY,OAAAZ,KAAI,CAACkM,OAAL,CAAahH,IAAb,EAA0BtE,CAA1B,CAAA;WAA7C;SADJ;QAGA,IAAIuL,WAAJ;;QAEA,IAAIxG,OAAO,CAACyG,QAAZ,EAAsB;UAClB,OAAOzG,OAAO,CAACyG,QAAf;UACApM,KAAI,CAACqM,KAAL,GAAa,IAAb;UACAF,WAAW,GAAGzF,SAAd;SAHJ,MAIO;UACHyF,WAAW,GAAGxF,QAAQ,CAACtB,aAAT,CAAuB,KAAvB,CAAd;UACAqB,SAAS,CAAC4F,WAAV,CAAsBH,WAAtB;;;QAEJnM,KAAI,CAACuM,iBAAL,GAAyBC,UAAU,CAC/BV,aAAA,CAACW,WAAD;UAAanH,GAAG,EAAEA,GAAG,CAACtF,KAAD,EAAO,aAAP;WACbgM,QACArG,QAFR,CAD+B,EAI/BwG,WAJ+B,CAAnC;;;;;;;;;;;MAWG,gBAAA,GAAP,UAAgBlM,KAAhB,EAA+CyM,QAA/C;QACI,KAAKC,WAAL,CAAiBvJ,QAAjB,CAA0BnD,KAA1B,EAAiCyM,QAAjC;OADG;;;;;;MAMA,mBAAA,GAAP,UAAmBA,QAAnB;QACI,KAAKC,WAAL,CAAiBC,WAAjB,CAA6BF,QAA7B;OADG;;;;;;MAMA,eAAA,GAAP;;;QACI,IAAMP,WAAW,GAAG,KAAKA,WAAzB;QAEAK,UAAU,CACN,IADM,EAENL,WAFM,EAGN,KAAKI,iBAHC,CAAV;;QAKA,IAAI,CAAC,KAAKF,KAAV,EAAiB;UACb,MAAAF,WAAW,SAAX,IAAAA,WAAW,WAAX,SAAA,GAAAA,WAAW,CAAEU,aAAb,UAAA,iBAAA,SAAA,MAA4BC,YAAYX,YAAxC;;;QAEJ,KAAKA,WAAL,GAAmB,IAAnB;QACA,KAAKQ,WAAL,GAAmB,IAAnB;OAZG;;MAcC,sBAAA,GAAR;QACI,OAAO,KAAKA,WAAL,CAAiBzM,MAAxB;OADI;;MAhENL,MAAM,eA/BXkN,UAAU,CAACtN,SAAD,EAAiB,UAACvC,SAAD,EAAY8P,QAAZ;QACxB,IAAI9P,SAAS,CAAC8P,QAAD,CAAb,EAAyB;UACrB;;;QAEJ9P,SAAS,CAAC8P,QAAD,CAAT,GAAsB;UAAS,aAAA;;eAAA,YAAAlO,uBAAAA;YAAAmO,QAAA,gBAAA;;;UAC3B,IAAMC,IAAI,GAAG,KAAKC,cAAL,EAAb;;UAEA,IAAI,CAACD,IAAD,IAAS,CAACA,IAAI,CAACF,QAAD,CAAlB,EAA8B;YAC1B;;;UAEJ,OAAOE,IAAI,CAACF,QAAD,CAAJ,MAAA,CAAAE,IAAA,EAAkBD,IAAlB,CAAP;SANJ;OAJO,GAaVF,UAAU,CAACxN,YAAD,EAAa,UAACrC,SAAD,EAAY8P,QAAZ;QACpBnQ,MAAM,CAACuQ,cAAP,CAAsBlQ,SAAtB,EAAiC8P,QAAjC,EAA2C;UACvCK,GAAG;YACC,OAAO,KAAKF,cAAL,GAAsBpN,KAAtB,CAA4BiN,QAA5B,CAAP;WAFmC;UAIvCM,GAAG,YAACC;;;YACA,KAAKZ,WAAL,CAAiBvJ,QAAjB,WACIlB,GAAC8K,SAAD,GAAYO,SADhB;WALmC;UASvCC,UAAU,EAAE,IAT2B;UAUvCC,YAAY,EAAE;SAVlB;OADO;;;;;SAkBL5N,OAAA;MAmEN,aAAA;IAAC,EAnEoB6N,aAArB;;ICtCA;;;MAAoCrQ,yBAAA;;MAApC,eAAA;;;;MAAmD,aAAA;IAAnD,EAAoCsQ,SAApC;;;;;;;;;;;;ICAA,KAAK,IAAMzI,IAAX,IAAmB0I,MAAnB,EAA2B;MACtB/N,QAAc,CAACqF,IAAD,CAAd,GAAuB0I,MAAM,CAAC1I,IAAD,CAA7B;IACJ;;;;;;;;"} \ No newline at end of file +{"version":3,"file":"guides.js","sources":["../../react-guides/dist/guides.esm.js","../src/consts.ts","../src/InnerGuides.tsx","../src/GuidesManager.tsx","../src/Guides.tsx","../src/index.umd.ts"],"sourcesContent":["/*\nCopyright (c) 2019 Daybrush\nname: @scena/react-guides\nlicense: MIT\nauthor: Daybrush\nrepository: https://github.com/daybrush/guides/blob/master/packages/react-guides\nversion: 0.28.2\n*/\nimport { createElement, createRef, PureComponent } from 'react';\nimport Ruler, { PROPERTIES as PROPERTIES$1 } from '@scena/react-ruler';\nimport { prefixNames, prefixCSS, ref, refs } from 'framework-utils';\nimport DragScroll from '@scena/dragscroll';\nimport Gesto from 'gesto';\nimport { styled } from 'react-css-styled';\nimport { hasClass, addClass, removeClass } from '@daybrush/utils';\nimport { getDistElementMatrix, calculateMatrixDist } from 'css-to-mat';\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n\n/* global Reflect, Promise */\nvar extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf || {\n __proto__: []\n } instanceof Array && function (d, b) {\n d.__proto__ = b;\n } || function (d, b) {\n for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];\n };\n\n return extendStatics(d, b);\n};\n\nfunction __extends(d, b) {\n if (typeof b !== \"function\" && b !== null) throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n\n function __() {\n this.constructor = d;\n }\n\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\nvar __assign = function () {\n __assign = Object.assign || function __assign(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n }\n\n return t;\n };\n\n return __assign.apply(this, arguments);\n};\nfunction __spreadArray(to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nfunction prefix() {\n var classNames = [];\n\n for (var _i = 0; _i < arguments.length; _i++) {\n classNames[_i] = arguments[_i];\n }\n\n return prefixNames.apply(void 0, __spreadArray([\"scena-guides-\"], classNames, false));\n}\n\nvar ADDER = prefix(\"guide\", \"adder\");\nvar GUIDES = prefix(\"guides\");\nvar GUIDE = prefix(\"guide\");\nvar DRAGGING = prefix(\"dragging\");\nvar DISPLAY_DRAG = prefix(\"display-drag\");\nvar GUIDES_CSS = prefixCSS(\"scena-guides-\", \"\\n{\\n position: relative;\\n width: 100%;\\n height: 100%;\\n}\\ncanvas {\\n position: relative;\\n}\\n.guide-origin {\\n position: absolute;\\n width: 1px;\\n height: 1px;\\n top: 0;\\n left: 0;\\n opacity: 0;\\n}\\n.guides {\\n position: absolute;\\n bottom: 0;\\n right: 0;\\n will-change: transform;\\n z-index: 2000;\\n}\\n.guide-pos {\\n position: absolute;\\n font-weight: bold;\\n font-size: 12px;\\n color: #f33;\\n}\\n.horizontal .guide-pos {\\n bottom: 100%;\\n left: 50%;\\n transform: translate(-50%);\\n}\\n.vertical .guide-pos {\\n left: calc(100% + 2px);\\n top: 50%;\\n transform: translateY(-50%);\\n}\\n.display-drag {\\n position: absolute;\\n will-change: transform;\\n z-index: 2000;\\n font-weight: bold;\\n font-size: 12px;\\n display: none;\\n left: 20px;\\n top: -20px;\\n color: #f33;\\n}\\n:host.horizontal .guides {\\n width: 100%;\\n height: 0;\\n}\\n:host.vertical .guides {\\n height: 100%;\\n width: 0;\\n}\\n:host.horizontal canvas {\\n cursor: ns-resize;\\n}\\n:host.vertical canvas {\\n cursor: ew-resize;\\n}\\n.guide {\\n position: absolute;\\n background: #f33;\\n z-index: 2;\\n}\\n.guide.dragging:before {\\n position: absolute;\\n content: \\\"\\\";\\n width: 100%;\\n height: 100%;\\n top: 50%;\\n left: 50%;\\n transform: translate(-50%, -50%);\\n}\\n:host.horizontal .guide {\\n width: 100%;\\n height: 1px;\\n cursor: row-resize;\\n}\\n:host.vertical .guide {\\n width: 1px;\\n height: 100%;\\n cursor: col-resize;\\n}\\n.mobile :host.horizontal .guide {\\n transform: scale(1, 2);\\n}\\n.mobile :host.vertical .guide {\\n transform: scale(2, 1);\\n}\\n:host.horizontal .guide:before {\\n height: 20px;\\n}\\n:host.vertical .guide:before {\\n width: 20px;\\n}\\n.adder {\\n display: none;\\n}\\n.adder.dragging {\\n display: block;\\n}\\n\");\nvar PROPERTIES = __spreadArray([\"className\", \"rulerStyle\", 'snapThreshold', \"snaps\", \"displayDragPos\", \"cspNonce\", 'dragPosFormat', \"defaultGuides\", \"showGuides\", \"scrollOptions\", \"guideStyle\", \"guidesOffset\", \"digit\", \"defaultGuidesPos\", \"dragGuideStyle\", \"displayGuidePos\", \"guidePosFormat\", \"guidePosStyle\", \"lockGuides\", \"guidesZoom\"], PROPERTIES$1, true);\nvar METHODS = [\"getGuides\", \"loadGuides\", \"scroll\", \"scrollGuides\", \"resize\", \"getElement\", \"getRulerElement\", \"forceUpdate\", \"getRulerScrollPos\", \"getGuideScrollPos\", \"zoomTo\", \"drawRuler\"];\nvar EVENTS = [\"changeGuides\", \"requestScroll\", \"dragStart\", \"drag\", \"dragEnd\", \"clickRuler\"];\n\nvar GuidesElement = styled(\"div\", GUIDES_CSS);\n\nvar Guides =\n/*#__PURE__*/\nfunction (_super) {\n __extends(Guides, _super);\n\n function Guides(props) {\n var _this = _super.call(this, props) || this;\n\n _this.state = {\n guides: []\n };\n _this.scrollPos = 0;\n _this.managerRef = createRef();\n _this.guideElements = [];\n _this._isFirstMove = false;\n _this._zoom = 1;\n _this._guidesZoom = 1;\n _this._observer = null;\n\n _this.onDragStart = function (e) {\n var datas = e.datas,\n inputEvent = e.inputEvent;\n _this._isFirstMove = true;\n\n _this.movePos(e);\n /**\n * When the drag starts, the dragStart event is called.\n * @memberof Guides\n * @event dragStart\n * @param {OnDragStart} - Parameters for the dragStart event\n */\n\n\n _this.props.onDragStart(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n return;\n }\n\n inputEvent.stopPropagation();\n inputEvent.preventDefault();\n\n _this._startDragScroll(e);\n };\n\n _this._onDrag = function (e) {\n if (_this._isFirstMove) {\n _this._isFirstMove = false;\n addClass(e.datas.target, DRAGGING);\n }\n\n var nextPos = _this.movePos(e);\n /**\n * When dragging, the drag event is called.\n * @memberof Guides\n * @event drag\n * @param {OnDrag} - Parameters for the drag event\n */\n\n\n _this.props.onDrag(__assign(__assign({}, e), {\n dragElement: e.datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n _this._endDragScroll(e);\n\n return;\n }\n\n _this._dragScroll(e);\n\n return nextPos;\n };\n\n _this.onDragEnd = function (e) {\n var datas = e.datas,\n isDouble = e.isDouble,\n distX = e.distX,\n distY = e.distY;\n\n var pos = _this.movePos(e);\n\n var guides = _this.state.guides;\n var _a = _this.props,\n onChangeGuides = _a.onChangeGuides,\n displayDragPos = _a.displayDragPos,\n digit = _a.digit,\n lockGuides = _a.lockGuides,\n guidesOffset = _a.guidesOffset;\n var zoom = _this._guidesZoom;\n var guidePos = parseFloat((pos / zoom).toFixed(digit || 0));\n var baseScrollPos = _this.scrollPos - (guidesOffset || 0);\n\n if (displayDragPos) {\n _this.displayElement.style.cssText += \"display: none;\";\n }\n\n removeClass(datas.target, DRAGGING);\n /**\n * When the drag finishes, the dragEnd event is called.\n * @memberof Guides\n * @event dragEnd\n * @param {OnDragEnd} - Parameters for the dragEnd event\n */\n\n _this.props.onDragEnd(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n _this._endDragScroll(e);\n\n if (datas.fromRuler) {\n if (_this._isFirstMove) {\n /**\n * When click the ruler, the click ruler is called.\n * @memberof Guides\n * @event clickRuler\n * @param {OnClickRuler} - Parameters for the clickRuler event\n */\n _this.props.onClickRuler(__assign(__assign({}, e), {\n pos: 0\n }));\n }\n\n if (guidePos >= baseScrollPos && guides.indexOf(guidePos) < 0) {\n _this.setState({\n guides: __spreadArray(__spreadArray([], guides, true), [guidePos], false)\n }, function () {\n /**\n * The `changeGuides` event occurs when the guideline is added / removed / changed.\n * @memberof Guides\n * @event changeGuides\n * @param {OnChangeGuides} - Parameters for the changeGuides event\n */\n onChangeGuides({\n guides: _this.state.guides,\n distX: distX,\n distY: distY,\n index: guides.length,\n isAdd: true,\n isRemove: false,\n isChange: false\n });\n });\n }\n } else {\n var index_1 = parseFloat(datas.target.getAttribute(\"data-index\"));\n var isRemove_1 = false;\n var isChange_1 = false;\n guides = __spreadArray([], guides, true);\n var guideIndex = guides.indexOf(guidePos);\n\n if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"remove\") > -1)) {\n return;\n }\n\n guides.splice(index_1, 1);\n isRemove_1 = true;\n } else if (guideIndex > -1) {\n return;\n } else {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"change\") > -1)) {\n return;\n }\n\n guides[index_1] = guidePos;\n isChange_1 = true;\n }\n\n _this.setState({\n guides: guides\n }, function () {\n var nextGuides = _this.state.guides;\n onChangeGuides({\n distX: distX,\n distY: distY,\n guides: nextGuides,\n isAdd: false,\n index: index_1,\n isChange: isChange_1,\n isRemove: isRemove_1\n });\n });\n }\n };\n\n _this._onCheck = function () {\n _this.resize();\n };\n\n _this.state.guides = props.defaultGuides || [];\n _this.scrollPos = props.defaultGuidesPos || 0;\n return _this;\n }\n\n var __proto = Guides.prototype;\n\n __proto.render = function () {\n var _a = this.props,\n className = _a.className,\n type = _a.type,\n zoom = _a.zoom,\n guidesZoom = _a.guidesZoom,\n style = _a.style,\n rulerStyle = _a.rulerStyle,\n displayDragPos = _a.displayDragPos,\n cspNonce = _a.cspNonce,\n dragGuideStyle = _a.dragGuideStyle,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b;\n var props = this.props;\n var translateName = this.getTranslateName();\n var rulerProps = {};\n PROPERTIES$1.forEach(function (name) {\n if (name === \"style\" || name === \"warpSelf\" || name === \"useResizeObserver\") {\n return;\n }\n\n rulerProps[name] = props[name];\n });\n this._zoom = zoom;\n this._guidesZoom = guidesZoom || zoom;\n return createElement(GuidesElement, {\n ref: this.managerRef,\n cspNonce: cspNonce,\n className: \"\".concat(prefix(\"manager\", type), \" \").concat(className),\n style: style\n }, createElement(\"div\", {\n className: prefix(\"guide-origin\"),\n ref: ref(this, \"originElement\")\n }), createElement(Ruler, __assign({\n ref: ref(this, \"ruler\"),\n style: rulerStyle\n }, rulerProps)), createElement(\"div\", {\n className: GUIDES,\n ref: ref(this, \"guidesElement\"),\n style: {\n transform: \"\".concat(translateName, \"(\").concat(-this.scrollPos * this._guidesZoom, \"px)\")\n }\n }, displayDragPos && createElement(\"div\", {\n className: DISPLAY_DRAG,\n ref: ref(this, \"displayElement\"),\n style: guidePosStyle || {}\n }), createElement(\"div\", {\n className: ADDER,\n ref: ref(this, \"adderElement\"),\n style: dragGuideStyle\n }), this.renderGuides()));\n };\n /**\n * Draw ruler\n */\n\n\n __proto.drawRuler = function (options) {\n this.ruler.draw(options);\n };\n\n __proto.renderGuides = function () {\n var _this = this;\n\n var props = this.props;\n var _a = props,\n type = _a.type,\n showGuides = _a.showGuides,\n guideStyle = _a.guideStyle,\n displayGuidePos = _a.displayGuidePos,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b,\n guidesOffset = _a.guidesOffset;\n var zoom = this._guidesZoom;\n var translateName = this.getTranslateName();\n var guides = this.state.guides;\n\n var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) {\n return v;\n };\n\n this.guideElements = [];\n\n if (showGuides) {\n return guides.map(function (pos, i) {\n var guidePos = pos + (guidesOffset || 0);\n return createElement(\"div\", {\n className: prefix(\"guide\", type),\n ref: refs(_this, \"guideElements\", i),\n key: i,\n \"data-index\": i,\n \"data-pos\": pos,\n style: __assign(__assign({}, guideStyle), {\n transform: \"\".concat(translateName, \"(\").concat(guidePos * zoom, \"px) translateZ(0px)\")\n })\n }, displayGuidePos && createElement(\"div\", {\n className: prefix(\"guide-pos\"),\n style: guidePosStyle || {}\n }, guidePosFormat(pos)));\n });\n }\n\n return;\n };\n\n __proto.componentDidMount = function () {\n var _this = this;\n\n this.gesto = new Gesto(this.managerRef.current, {\n container: document.body\n }).on(\"dragStart\", function (e) {\n var _a = _this.props,\n type = _a.type,\n lockGuides = _a.lockGuides;\n var zoom = _this._guidesZoom;\n\n if (lockGuides === true) {\n e.stop();\n return;\n }\n\n var inputEvent = e.inputEvent;\n var target = inputEvent.target;\n var datas = e.datas;\n var canvasElement = _this.ruler.canvasElement;\n var guidesElement = _this.guidesElement;\n var isHorizontal = type === \"horizontal\";\n\n var originRect = _this.originElement.getBoundingClientRect();\n\n var matrix = getDistElementMatrix(_this.managerRef.current);\n var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]);\n offsetPos[0] -= guidesElement.offsetLeft;\n offsetPos[1] -= guidesElement.offsetTop;\n offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom;\n datas.offsetPos = offsetPos;\n datas.matrix = matrix;\n var isLockAdd = lockGuides && lockGuides.indexOf(\"add\") > -1;\n var isLockRemove = lockGuides && lockGuides.indexOf(\"remove\") > -1;\n var isLockChange = lockGuides && lockGuides.indexOf(\"change\") > -1;\n\n if (target === canvasElement) {\n if (isLockAdd) {\n e.stop();\n return;\n }\n\n datas.fromRuler = true;\n datas.target = _this.adderElement; // add\n } else if (hasClass(target, GUIDE)) {\n if (isLockRemove && isLockChange) {\n e.stop();\n return;\n }\n\n datas.target = target; // change\n } else {\n e.stop();\n return false;\n }\n\n _this.onDragStart(e);\n }).on(\"drag\", this._onDrag).on(\"dragEnd\", this.onDragEnd);\n\n if (this.props.useResizeObserver) {\n this._observer = new ResizeObserver(this._onCheck);\n\n this._observer.observe(this.guidesElement, {\n box: \"border-box\"\n });\n\n this._observer.observe(this.getRulerElement(), {\n box: \"border-box\"\n });\n } else {\n this._onCheck();\n }\n };\n\n __proto.componentWillUnmount = function () {\n var _a;\n\n this.gesto.unset();\n (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n };\n\n __proto.componentDidUpdate = function (prevProps) {\n var nextGuides = this.props.defaultGuides;\n\n if (prevProps.defaultGuides !== nextGuides) {\n // to dynamically update guides from code rather than dragging guidelines\n this.setState({\n guides: nextGuides || []\n });\n }\n };\n /**\n * Load the current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.loadGuides = function (guides) {\n this.setState({\n guides: guides\n });\n };\n /**\n * Get current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getGuides = function () {\n return this.state.guides;\n };\n /**\n * Scroll the positions of the guidelines opposite the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scrollGuides = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._guidesZoom;\n }\n\n this._setZoom({\n guidesZoom: nextZoom\n });\n\n var translateName = this.getTranslateName();\n var guidesElement = this.guidesElement;\n this.scrollPos = pos;\n guidesElement.style.transform = \"\".concat(translateName, \"(\").concat(-pos * nextZoom, \"px)\");\n var guides = this.state.guides;\n var guidesOffset = this.props.guidesOffset || 0;\n this.guideElements.forEach(function (el, i) {\n if (!el) {\n return;\n }\n\n var guidePos = guides[i] + (guidesOffset || 0);\n el.style.transform = \"\".concat(translateName, \"(\").concat(guidePos * nextZoom, \"px) translateZ(0px)\");\n el.style.display = -pos + guidePos < 0 ? \"none\" : \"block\";\n });\n };\n /**\n * Set to the next zoom.\n * @memberof Guides\n * @since 0.22.0\n * @param nextZoom - next zoom\n */\n\n\n __proto.zoomTo = function (nextZoom, nextGuidesZoom) {\n if (nextGuidesZoom === void 0) {\n nextGuidesZoom = nextZoom;\n }\n\n this.scroll(this.getRulerScrollPos(), nextZoom);\n this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);\n };\n /**\n * Get Guides DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getElement = function () {\n return this.managerRef.current;\n };\n /**\n * Get Ruler DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getRulerElement = function () {\n return this.ruler.canvasElement;\n };\n /**\n * Scroll position of guides (horizontal: y, vertical: x)\n */\n\n\n __proto.getGuideScrollPos = function () {\n return this.scrollPos;\n };\n /**\n * Scroll position of the ruler (horizontal: x, vertical: y)\n */\n\n\n __proto.getRulerScrollPos = function () {\n return this.ruler.getScrollPos();\n };\n /**\n * Scroll the position of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scroll = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.scroll(pos, nextZoom);\n };\n /**\n * Recalculate the size of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.resize = function (nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.resize(nextZoom);\n };\n\n __proto.movePos = function (e) {\n var datas = e.datas,\n distX = e.distX,\n distY = e.distY;\n var props = this.props;\n var type = props.type,\n snaps = props.snaps,\n snapThreshold = props.snapThreshold,\n displayDragPos = props.displayDragPos,\n digit = props.digit;\n var guidesOffset = props.guidesOffset || 0;\n var zoom = this._guidesZoom;\n\n var dragPosFormat = props.dragPosFormat || function (v) {\n return v;\n };\n\n var isHorizontal = type === \"horizontal\";\n var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);\n var offsetPos = datas.offsetPos;\n var offsetX = matrixPos[0] + offsetPos[0];\n var offsetY = matrixPos[1] + offsetPos[1];\n var guidesZoomOffset = guidesOffset * zoom;\n var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;\n var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0));\n var guideSnaps = snaps.slice().sort(function (a, b) {\n return Math.abs(guidePos - a) - Math.abs(guidePos - b);\n });\n\n if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) {\n guidePos = guideSnaps[0];\n nextPos = guidePos * zoom;\n }\n\n if (!datas.fromRuler || !this._isFirstMove) {\n if (displayDragPos) {\n var displayPos = type === \"horizontal\" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY];\n this.displayElement.style.cssText += \"display: block;\" + \"transform: translate(-50%, -50%) \" + \"translate(\".concat(displayPos.map(function (v) {\n return \"\".concat(v, \"px\");\n }).join(\", \"), \")\");\n this.displayElement.innerHTML = \"\".concat(dragPosFormat(guidePos));\n }\n\n var target = datas.target;\n target.setAttribute(\"data-pos\", guidePos);\n target.style.transform = \"\".concat(this.getTranslateName(), \"(\").concat(nextPos + guidesOffset * zoom, \"px)\");\n }\n\n return nextPos;\n };\n\n __proto.getTranslateName = function () {\n return this.props.type === \"horizontal\" ? \"translateY\" : \"translateX\";\n };\n\n __proto._startDragScroll = function (e) {\n var _this = this;\n\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var datas = e.datas;\n var dragScroll = new DragScroll();\n datas.dragScroll = dragScroll;\n dragScroll.on(\"scroll\", function (_a) {\n var _b, _c;\n\n var container = _a.container,\n direction = _a.direction;\n /**\n * If scroll can be triggered through drag, the `requestScroll` event is fired.\n * @memberof Guides\n * @event requestScroll\n * @param {OnRequestScroll} - Parameters for the `requestScroll` event\n */\n\n (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, {\n container: container,\n direction: direction\n });\n }).on(\"move\", function (_a) {\n var offsetX = _a.offsetX,\n offsetY = _a.offsetY,\n inputEvent = _a.inputEvent;\n\n _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);\n });\n dragScroll.dragStart(e, {\n container: scrollOptions.container\n });\n };\n\n __proto._dragScroll = function (e) {\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var dragScroll = e.datas.dragScroll;\n dragScroll.drag(e, scrollOptions);\n };\n\n __proto._endDragScroll = function (e) {\n var _a;\n\n (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd();\n e.datas.dragScroll = null;\n };\n\n __proto._setZoom = function (zooms) {\n var nextZoom = zooms.zoom,\n nextGuidesZoom = zooms.guidesZoom;\n var hasZoom = !!this.props.zoom;\n var hasGuidesZoom = !!this.props.guidesZoom;\n\n if (hasGuidesZoom) {\n if (nextGuidesZoom) {\n this._guidesZoom = nextGuidesZoom;\n }\n } else {\n if (nextGuidesZoom) {\n this._zoom = nextGuidesZoom;\n this._guidesZoom = nextGuidesZoom;\n }\n\n if (nextZoom) {\n this._guidesZoom = nextZoom;\n }\n }\n\n if (nextZoom) {\n this._zoom = nextZoom;\n }\n };\n\n Guides.defaultProps = {\n className: \"\",\n type: \"horizontal\",\n zoom: 1,\n guidesZoom: 0,\n style: {},\n snapThreshold: 5,\n snaps: [],\n digit: 0,\n onClickRuler: function () {},\n onChangeGuides: function () {},\n onRequestScroll: function () {},\n onDragStart: function () {},\n onDrag: function () {},\n onDragEnd: function () {},\n displayDragPos: false,\n dragPosFormat: function (v) {\n return v;\n },\n defaultGuides: [],\n lockGuides: false,\n showGuides: true,\n guideStyle: {},\n dragGuideStyle: {},\n guidePosStyle: {},\n defaultGuidesPos: 0\n };\n return Guides;\n}(PureComponent);\n\nexport default Guides;\nexport { EVENTS, METHODS, PROPERTIES };\n//# sourceMappingURL=guides.esm.js.map\n","import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\n\nexport default Guides;\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","__spreadArray","to","from","pack","l","ar","slice","concat","prefix","classNames","_i","prefixNames","ADDER","GUIDES","GUIDE","DRAGGING","DISPLAY_DRAG","GUIDES_CSS","prefixCSS","PROPERTIES","PROPERTIES$1","METHODS","EVENTS","GuidesElement","styled","Guides","_super","props","_this","state","guides","scrollPos","managerRef","createRef","guideElements","_isFirstMove","_zoom","_guidesZoom","_observer","onDragStart","e","datas","inputEvent","movePos","dragElement","target","gesto","isFlag","stopPropagation","preventDefault","_startDragScroll","_onDrag","addClass","nextPos","onDrag","_endDragScroll","_dragScroll","onDragEnd","isDouble","distX","distY","pos","_a","onChangeGuides","displayDragPos","digit","lockGuides","guidesOffset","zoom","guidePos","parseFloat","toFixed","baseScrollPos","displayElement","style","cssText","removeClass","fromRuler","onClickRuler","indexOf","setState","index","isAdd","isRemove","isChange","index_1","getAttribute","isRemove_1","isChange_1","guideIndex","splice","nextGuides","_onCheck","resize","defaultGuides","defaultGuidesPos","__proto","render","className","type","guidesZoom","rulerStyle","cspNonce","dragGuideStyle","_b","guidePosStyle","translateName","getTranslateName","rulerProps","forEach","name","createElement","ref","Ruler","transform","renderGuides","drawRuler","options","ruler","draw","showGuides","guideStyle","displayGuidePos","guidePosFormat","dragPosFormat","v","map","refs","key","componentDidMount","Gesto","current","container","document","body","on","stop","canvasElement","guidesElement","isHorizontal","originRect","originElement","getBoundingClientRect","matrix","getDistElementMatrix","offsetPos","calculateMatrixDist","clientX","left","clientY","top","offsetLeft","offsetTop","isLockAdd","isLockRemove","isLockChange","adderElement","hasClass","useResizeObserver","ResizeObserver","observe","box","getRulerElement","componentWillUnmount","unset","disconnect","componentDidUpdate","prevProps","loadGuides","getGuides","scrollGuides","nextZoom","_setZoom","el","display","zoomTo","nextGuidesZoom","scroll","getRulerScrollPos","getGuideScrollPos","getElement","getScrollPos","snaps","snapThreshold","matrixPos","offsetX","offsetY","guidesZoomOffset","Math","round","guideSnaps","sort","a","abs","displayPos","join","innerHTML","setAttribute","scrollOptions","dragScroll","DragScroll","_c","direction","onRequestScroll","scrollBy","dragStart","drag","dragEnd","zooms","hasZoom","hasGuidesZoom","defaultProps","PureComponent","GUIDES_PROPERTIES","GUIDES_METHODS","GUIDES_EVENTS","React","ReactGuides","events","camelize","trigger","selfElement","warpSelf","_warp","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","forceUpdate","parentElement","removeChild","Properties","property","args","self","getInnerGuides","defineProperty","get","set","value","enumerable","configurable","EventEmitter","GuidesManager","others"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/release/latest/dist/guides.min.js b/release/latest/dist/guides.min.js index 340c9a0..45c9e3b 100644 --- a/release/latest/dist/guides.min.js +++ b/release/latest/dist/guides.min.js @@ -4,7 +4,7 @@ name: @scena/guides license: MIT author: Daybrush repository: git+https://github.com/daybrush/guides.git -version: 0.29.1 +version: 0.29.2 */ -!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t=t||self).Guides=e()}(this,function(){"use strict";var z=function(t,e){return(z=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n])})(t,e)};function n(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Class extends value "+String(e)+" is not a constructor or null");function n(){this.constructor=t}z(t,e),t.prototype=null===e?Object.create(e):(n.prototype=e.prototype,new n)}var s=function(){return(s=Object.assign||function(t){for(var e,n=1,r=arguments.length;nh[1])){var F=0===M?S:M%2==0?W:U,j=0;switch(d){case"start":j=0;break;case"center":j=O/2-F/2;break;case"end":j=O-F}var z=y?[R+w[0],j+w[1]]:[j+w[0],R+w[1]],R=z[0],z=z[1],tt=y?[R,z+F]:[R+F,z],et=tt[0],tt=tt[1];_.moveTo(R+w[0],z+w[1]),_.lineTo(et+w[0],tt+w[1])}}}_.stroke(),_.beginPath(),_.strokeStyle=p,_.lineWidth=1,(n||[]).forEach(function(t){var e,n,r=(-l+t)*u;r<0||C<=r||th[1]||(r=(t=y?[r+w[0],w[1]]:[w[0],r+w[1]])[0],t=t[1],e=(n=y?[r,t+E]:[r+E,t])[0],n=n[1],_.moveTo(r+w[0],t+w[1]),_.lineTo(e+w[0],n+w[1]))}),_.stroke(),D.forEach(function(t){var e=t.value,n=t.offset,r=t.backgroundColor,i=t.color,o=t.text,s=t.textSize;if(L||!(e<0)){t=(e-l)*u;if(!(t<-P||C+f*u<=t||eh[1])){var a=0;switch(d){case"start":a=17;break;case"center":a=O/2;break;case"end":a=O-17}e=y?[t+-3*H,a]:[a,t+3*H],t=e[0],e=e[1];if(r){var c=0;switch(b){case"left":c=0;break;case"center":c=-s/2;break;case"right":c=-s}_.save(),_.fillStyle=r,y?_.fillRect(t+n[0]+c,0,s,S):(_.translate(0,e+n[1]),_.rotate(-Math.PI/2),_.fillRect(c,0,s,S)),_.restore()}_.save(),_.fillStyle=i,y?_.fillText(o,t+n[0],e+n[1]):(_.translate(t+n[0],e+n[1]),_.rotate(-Math.PI/2),_.fillText(o,0,0)),_.restore()}}}),_.restore()},n._getRulerScale=function(){var t,e,n=this.props.defaultPixelScale||2;return this._rulerScale||(!(e=1r-(i=void 0===i?0:i)?(s[1]>o.top||rs[1])&&(a[1]=1),o.left>n-i?(s[0]>o.left||ns[0])&&(a[0]=1),!(!a[0]&&!a[1])&&this._continueDrag(f(f({},e),{direction:a,inputEvent:t,isDrag:!0}))},i.checkScroll=function(t){var e,n,r,i,o,s,a,c=this;return!this._isWait&&(s=void 0===(s=t.prevScrollPos)?this._prevScrollPos:s,a=t.direction,e=void 0===(e=t.throttleTime)?0:e,n=t.inputEvent,r=t.isDrag,o=(i=this._getScrollPosition(a||[0,0],t))[0]-s[0],s=i[1]-s[1],a=a||[o?Math.abs(o)/o:0,s?Math.abs(s)/s:0],this._prevScrollPos=i,!(!o&&!s)&&(this.trigger("move",{offsetX:a[0]?o:0,offsetY:a[1]?s:0,inputEvent:n}),e&&r&&(clearTimeout(this._timer),this._timer=window.setTimeout(function(){c._continueDrag(t)},e)),!0))},i.dragEnd=function(){this._flag=!1,clearTimeout(this._timer)},i._getScrollPosition=function(t,e){var n=e.container,e=e.getScrollPosition;return(void 0===e?zt:e)({container:Ft(n),direction:t})},i._continueDrag=function(t){var e=this,n=t.container,r=t.direction,i=t.throttleTime,o=t.useScroll,s=t.isDrag,a=t.inputEvent;if(!(!this._flag||s&&this._isWait)){var c=b(),i=Math.max(i+this._prevTime-c,0);if(0n||(n=new Bt(D(t)),this.pinchFlag=!0,this._addStore(n),!1===this.emit("pinchStart",P(P({data:this.data,datas:this.data,angle:n.getAngle(),touches:this.getCurrentStore().getPositions()},n.getPosition()),{inputEvent:t,isTrusted:this._isTrusted,preventDefault:function(){t.preventDefault()},preventDrag:function(){e._dragFlag=!1}}))&&(this.pinchFlag=!1))},r.prototype.onPinch=function(t,e){var n;!this.flag||!this.pinchFlag||e.length<2||(n=this.getCurrentStore(),this.isPinch=!0,this.emit("pinch",P(P({data:this.data,datas:this.data,movement:this.getMovement(e),angle:n.getAngle(e),rotation:n.getRotation(e),touches:n.getPositions(e),scale:n.getScale(e),distance:n.getDistance(e)},n.getPosition(e)),{inputEvent:t,isTrusted:this._isTrusted})))},r.prototype.onPinchEnd=function(t){var e,n;this.pinchFlag&&(e=this.isPinch,this.isPinch=!1,this.pinchFlag=!1,n=this.getCurrentStore(),this.emit("pinchEnd",P(P({data:this.data,datas:this.data,isPinch:e,touches:n.getPositions()},n.getPosition()),{inputEvent:t})))},r.prototype.getCurrentStore=function(){return this.clientStores[0]},r.prototype.moveClients=function(t,e,n){var n=this._getPosition(t,n),r=this.isDrag,i=((n.deltaX||n.deltaY)&&(this.isDrag=!0),!1);return!r&&this.isDrag&&(i=!0),P(P({data:this.data,datas:this.data},n),{movement:this.getMovement(t),isDrag:this.isDrag,isPinch:this.isPinch,isScroll:!1,isMouseEvent:this._isMouseEvent,isSecondaryButton:this._isSecondaryButton,inputEvent:e,isTrusted:this._isTrusted,isFirstDrag:i})},r.prototype._addStore=function(t){this.clientStores.splice(0,0,t)},r.prototype._getPosition=function(t,e){var t=this.getCurrentStore().getPosition(t,e),e=this.clientStores.slice(1).reduce(function(t,e){e=e.getPosition();return t.distX+=e.distX,t.distY+=e.distY,t},t),n=e.distX,e=e.distY;return P(P({},t),{distX:n,distY:e})},r.prototype._attchDragEvent=function(){var t=this.options.container,e={passive:!1};this._isDragAPI&&(S(t,"dragover",this.onDrag),S(t,"dragend",this.onDragEnd)),this.isMouse&&(S(t,"mousemove",this.onDrag),S(t,"mouseup",this.onDragEnd)),this.isTouch&&(S(t,"touchmove",this.onDrag,e),S(t,"touchend",this.onDragEnd,e),S(t,"touchcancel",this.onDragEnd,e))},r.prototype._dettachDragEvent=function(){var t=this.options.container;this._isDragAPI&&(w(t,"dragover",this.onDrag),w(t,"dragend",this.onDragEnd)),this.isMouse&&(w(t,"mousemove",this.onDrag),w(t,"mouseup",this.onDragEnd)),this.isTouch&&(w(t,"touchstart",this.onDragStart),w(t,"touchmove",this.onDrag),w(t,"touchend",this.onDragEnd),w(t,"touchcancel",this.onDragEnd))},r}(t);var Lt=function(t){for(var e=5381,n=t.length;n;)e=33*e^t.charCodeAt(--n);return e>>>0};function $t(t,e,n,r,i){var o,s=document.createElement("style"),e=(s.setAttribute("type","text/css"),s.setAttribute("data-styled-id",t),s.setAttribute("data-styled-count","1"),n.nonce&&s.setAttribute("nonce",n.nonce),s.innerHTML=(o=t,t=e,n.original?t:t.replace(/([^};{\s}][^};{]*|^\s*){/gm,function(t,e){e=e.trim();return(e?c(e):[""]).map(function(t){t=t.trim();return 0===t.indexOf("@")?t:-1h[1])){var F=0===M?S:M%2==0?W:U,j=0;switch(d){case"start":j=0;break;case"center":j=O/2-F/2;break;case"end":j=O-F}var z=y?[R+w[0],j+w[1]]:[j+w[0],R+w[1]],R=z[0],z=z[1],tt=y?[R,z+F]:[R+F,z],et=tt[0],tt=tt[1];_.moveTo(R+w[0],z+w[1]),_.lineTo(et+w[0],tt+w[1])}}}_.stroke(),_.beginPath(),_.strokeStyle=p,_.lineWidth=1,(n||[]).forEach(function(t){var e,n,r=(-l+t)*c;r<0||C<=r||th[1]||(r=(t=y?[r+w[0],w[1]]:[w[0],r+w[1]])[0],t=t[1],e=(n=y?[r,t+E]:[r+E,t])[0],n=n[1],_.moveTo(r+w[0],t+w[1]),_.lineTo(e+w[0],n+w[1]))}),_.stroke(),D.forEach(function(t){var e=t.value,n=t.offset,r=t.backgroundColor,i=t.color,o=t.text,s=t.textSize;if(L||!(e<0)){t=(e-l)*c;if(!(t<-P||C+f*c<=t||eh[1])){var a=0;switch(d){case"start":a=17;break;case"center":a=O/2;break;case"end":a=O-17}e=y?[t+-3*H,a]:[a,t+3*H],t=e[0],e=e[1];if(r){var u=0;switch(b){case"left":u=0;break;case"center":u=-s/2;break;case"right":u=-s}_.save(),_.fillStyle=r,y?_.fillRect(t+n[0]+u,0,s,S):(_.translate(0,e+n[1]),_.rotate(-Math.PI/2),_.fillRect(u,0,s,S)),_.restore()}_.save(),_.fillStyle=i,y?_.fillText(o,t+n[0],e+n[1]):(_.translate(t+n[0],e+n[1]),_.rotate(-Math.PI/2),_.fillText(o,0,0)),_.restore()}}}),_.restore()},n._getRulerScale=function(){var t,e,n=this.props.defaultPixelScale||2;return this._rulerScale||(!(e=1r-(i=void 0===i?0:i)?(s[1]>o.top||rs[1])&&(a[1]=1),o.left>n-i?(s[0]>o.left||ns[0])&&(a[0]=1),!(!a[0]&&!a[1])&&this._continueDrag(f(f({},e),{direction:a,inputEvent:t,isDrag:!0}))},i.checkScroll=function(t){var e,n,r,i,o,s,a,u=this;return!this._isWait&&(s=void 0===(s=t.prevScrollPos)?this._prevScrollPos:s,a=t.direction,e=void 0===(e=t.throttleTime)?0:e,n=t.inputEvent,r=t.isDrag,o=(i=this._getScrollPosition(a||[0,0],t))[0]-s[0],s=i[1]-s[1],a=a||[o?Math.abs(o)/o:0,s?Math.abs(s)/s:0],this._prevScrollPos=i,!(!o&&!s)&&(this.trigger("move",{offsetX:a[0]?o:0,offsetY:a[1]?s:0,inputEvent:n}),e&&r&&(clearTimeout(this._timer),this._timer=window.setTimeout(function(){u._continueDrag(t)},e)),!0))},i.dragEnd=function(){this._flag=!1,clearTimeout(this._timer)},i._getScrollPosition=function(t,e){var n=e.container,e=e.getScrollPosition;return(void 0===e?zt:e)({container:Ft(n),direction:t})},i._continueDrag=function(t){var e=this,n=t.container,r=t.direction,i=t.throttleTime,o=t.useScroll,s=t.isDrag,a=t.inputEvent;if(!(!this._flag||s&&this._isWait)){var u=b(),i=Math.max(i+this._prevTime-u,0);if(0n||(n=new Bt(D(t)),this.pinchFlag=!0,this._addStore(n),!1===this.emit("pinchStart",P(P({data:this.data,datas:this.data,angle:n.getAngle(),touches:this.getCurrentStore().getPositions()},n.getPosition()),{inputEvent:t,isTrusted:this._isTrusted,preventDefault:function(){t.preventDefault()},preventDrag:function(){e._dragFlag=!1}}))&&(this.pinchFlag=!1))},r.prototype.onPinch=function(t,e){var n;!this.flag||!this.pinchFlag||e.length<2||(n=this.getCurrentStore(),this.isPinch=!0,this.emit("pinch",P(P({data:this.data,datas:this.data,movement:this.getMovement(e),angle:n.getAngle(e),rotation:n.getRotation(e),touches:n.getPositions(e),scale:n.getScale(e),distance:n.getDistance(e)},n.getPosition(e)),{inputEvent:t,isTrusted:this._isTrusted})))},r.prototype.onPinchEnd=function(t){var e,n;this.pinchFlag&&(e=this.isPinch,this.isPinch=!1,this.pinchFlag=!1,n=this.getCurrentStore(),this.emit("pinchEnd",P(P({data:this.data,datas:this.data,isPinch:e,touches:n.getPositions()},n.getPosition()),{inputEvent:t})))},r.prototype.getCurrentStore=function(){return this.clientStores[0]},r.prototype.moveClients=function(t,e,n){var n=this._getPosition(t,n),r=this.isDrag,i=((n.deltaX||n.deltaY)&&(this.isDrag=!0),!1);return!r&&this.isDrag&&(i=!0),P(P({data:this.data,datas:this.data},n),{movement:this.getMovement(t),isDrag:this.isDrag,isPinch:this.isPinch,isScroll:!1,isMouseEvent:this._isMouseEvent,isSecondaryButton:this._isSecondaryButton,inputEvent:e,isTrusted:this._isTrusted,isFirstDrag:i})},r.prototype._addStore=function(t){this.clientStores.splice(0,0,t)},r.prototype._getPosition=function(t,e){var t=this.getCurrentStore().getPosition(t,e),e=this.clientStores.slice(1).reduce(function(t,e){e=e.getPosition();return t.distX+=e.distX,t.distY+=e.distY,t},t),n=e.distX,e=e.distY;return P(P({},t),{distX:n,distY:e})},r.prototype._attchDragEvent=function(){var t=this.options.container,e={passive:!1};this._isDragAPI&&(S(t,"dragover",this.onDrag),S(t,"dragend",this.onDragEnd)),this.isMouse&&(S(t,"mousemove",this.onDrag),S(t,"mouseup",this.onDragEnd)),this.isTouch&&(S(t,"touchmove",this.onDrag,e),S(t,"touchend",this.onDragEnd,e),S(t,"touchcancel",this.onDragEnd,e))},r.prototype._dettachDragEvent=function(){var t=this.options.container;this._isDragAPI&&(w(t,"dragover",this.onDrag),w(t,"dragend",this.onDragEnd)),this.isMouse&&(w(t,"mousemove",this.onDrag),w(t,"mouseup",this.onDragEnd)),this.isTouch&&(w(t,"touchstart",this.onDragStart),w(t,"touchmove",this.onDrag),w(t,"touchend",this.onDragEnd),w(t,"touchcancel",this.onDragEnd))},r}(t);var Lt=function(t){for(var e=5381,n=t.length;n;)e=33*e^t.charCodeAt(--n);return e>>>0};function $t(t,e,n,r,i){var o,s=document.createElement("style"),e=(s.setAttribute("type","text/css"),s.setAttribute("data-styled-id",t),s.setAttribute("data-styled-count","1"),n.nonce&&s.setAttribute("nonce",n.nonce),s.innerHTML=(o=t,t=e,n.original?t:t.replace(/([^};{\s}][^};{]*|^\s*){/gm,function(t,e){e=e.trim();return(e?u(e):[""]).map(function(t){t=t.trim();return 0===t.indexOf("@")?t:-1= baseScrollPos && guides.indexOf(guidePos) < 0) {\n _this.setState({\n guides: __spreadArray(__spreadArray([], guides, true), [guidePos], false)\n }, function () {\n /**\n * The `changeGuides` event occurs when the guideline is added / removed / changed.\n * @memberof Guides\n * @event changeGuides\n * @param {OnChangeGuides} - Parameters for the changeGuides event\n */\n onChangeGuides({\n guides: _this.state.guides,\n distX: distX,\n distY: distY,\n index: guides.length,\n isAdd: true,\n isRemove: false,\n isChange: false\n });\n });\n }\n } else {\n var index_1 = parseFloat(datas.target.getAttribute(\"data-index\"));\n var isRemove_1 = false;\n var isChange_1 = false;\n guides = __spreadArray([], guides, true);\n var guideIndex = guides.indexOf(guidePos);\n\n if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"remove\") > -1)) {\n return;\n }\n\n guides.splice(index_1, 1);\n isRemove_1 = true;\n } else if (guideIndex > -1) {\n return;\n } else {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"change\") > -1)) {\n return;\n }\n\n guides[index_1] = guidePos;\n isChange_1 = true;\n }\n\n _this.setState({\n guides: guides\n }, function () {\n var nextGuides = _this.state.guides;\n onChangeGuides({\n distX: distX,\n distY: distY,\n guides: nextGuides,\n isAdd: false,\n index: index_1,\n isChange: isChange_1,\n isRemove: isRemove_1\n });\n });\n }\n };\n\n _this._onCheck = function () {\n _this.resize();\n };\n\n _this.state.guides = props.defaultGuides || [];\n _this.scrollPos = props.defaultGuidesPos || 0;\n return _this;\n }\n\n var __proto = Guides.prototype;\n\n __proto.render = function () {\n var _a = this.props,\n className = _a.className,\n type = _a.type,\n zoom = _a.zoom,\n guidesZoom = _a.guidesZoom,\n style = _a.style,\n rulerStyle = _a.rulerStyle,\n displayDragPos = _a.displayDragPos,\n cspNonce = _a.cspNonce,\n dragGuideStyle = _a.dragGuideStyle,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b;\n var props = this.props;\n var translateName = this.getTranslateName();\n var rulerProps = {};\n PROPERTIES$1.forEach(function (name) {\n if (name === \"style\" || name === \"warpSelf\" || name === \"useResizeObserver\") {\n return;\n }\n\n rulerProps[name] = props[name];\n });\n this._zoom = zoom;\n this._guidesZoom = guidesZoom || zoom;\n console.log(type, zoom, guidesZoom);\n return createElement(GuidesElement, {\n ref: this.managerRef,\n cspNonce: cspNonce,\n className: \"\".concat(prefix(\"manager\", type), \" \").concat(className),\n style: style\n }, createElement(\"div\", {\n className: prefix(\"guide-origin\"),\n ref: ref(this, \"originElement\")\n }), createElement(Ruler, __assign({\n ref: ref(this, \"ruler\"),\n style: rulerStyle\n }, rulerProps)), createElement(\"div\", {\n className: GUIDES,\n ref: ref(this, \"guidesElement\"),\n style: {\n transform: \"\".concat(translateName, \"(\").concat(-this.scrollPos * this._guidesZoom, \"px)\")\n }\n }, displayDragPos && createElement(\"div\", {\n className: DISPLAY_DRAG,\n ref: ref(this, \"displayElement\"),\n style: guidePosStyle || {}\n }), createElement(\"div\", {\n className: ADDER,\n ref: ref(this, \"adderElement\"),\n style: dragGuideStyle\n }), this.renderGuides()));\n };\n /**\n * Draw ruler\n */\n\n\n __proto.drawRuler = function (options) {\n this.ruler.draw(options);\n };\n\n __proto.renderGuides = function () {\n var _this = this;\n\n var props = this.props;\n var _a = props,\n type = _a.type,\n showGuides = _a.showGuides,\n guideStyle = _a.guideStyle,\n displayGuidePos = _a.displayGuidePos,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b,\n guidesOffset = _a.guidesOffset;\n var zoom = this._guidesZoom;\n var translateName = this.getTranslateName();\n var guides = this.state.guides;\n\n var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) {\n return v;\n };\n\n this.guideElements = [];\n\n if (showGuides) {\n return guides.map(function (pos, i) {\n var guidePos = pos + (guidesOffset || 0);\n return createElement(\"div\", {\n className: prefix(\"guide\", type),\n ref: refs(_this, \"guideElements\", i),\n key: i,\n \"data-index\": i,\n \"data-pos\": pos,\n style: __assign(__assign({}, guideStyle), {\n transform: \"\".concat(translateName, \"(\").concat(guidePos * zoom, \"px) translateZ(0px)\")\n })\n }, displayGuidePos && createElement(\"div\", {\n className: prefix(\"guide-pos\"),\n style: guidePosStyle || {}\n }, guidePosFormat(pos)));\n });\n }\n\n return;\n };\n\n __proto.componentDidMount = function () {\n var _this = this;\n\n this.gesto = new Gesto(this.managerRef.current, {\n container: document.body\n }).on(\"dragStart\", function (e) {\n var _a = _this.props,\n type = _a.type,\n lockGuides = _a.lockGuides;\n var zoom = _this._guidesZoom;\n\n if (lockGuides === true) {\n e.stop();\n return;\n }\n\n var inputEvent = e.inputEvent;\n var target = inputEvent.target;\n var datas = e.datas;\n var canvasElement = _this.ruler.canvasElement;\n var guidesElement = _this.guidesElement;\n var isHorizontal = type === \"horizontal\";\n\n var originRect = _this.originElement.getBoundingClientRect();\n\n var matrix = getDistElementMatrix(_this.managerRef.current);\n var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]);\n offsetPos[0] -= guidesElement.offsetLeft;\n offsetPos[1] -= guidesElement.offsetTop;\n offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom;\n datas.offsetPos = offsetPos;\n datas.matrix = matrix;\n var isLockAdd = lockGuides && lockGuides.indexOf(\"add\") > -1;\n var isLockRemove = lockGuides && lockGuides.indexOf(\"remove\") > -1;\n var isLockChange = lockGuides && lockGuides.indexOf(\"change\") > -1;\n\n if (target === canvasElement) {\n if (isLockAdd) {\n e.stop();\n return;\n }\n\n datas.fromRuler = true;\n datas.target = _this.adderElement; // add\n } else if (hasClass(target, GUIDE)) {\n if (isLockRemove && isLockChange) {\n e.stop();\n return;\n }\n\n datas.target = target; // change\n } else {\n e.stop();\n return false;\n }\n\n _this.onDragStart(e);\n }).on(\"drag\", this._onDrag).on(\"dragEnd\", this.onDragEnd);\n\n if (this.props.useResizeObserver) {\n this._observer = new ResizeObserver(this._onCheck);\n\n this._observer.observe(this.guidesElement, {\n box: \"border-box\"\n });\n\n this._observer.observe(this.getRulerElement(), {\n box: \"border-box\"\n });\n } else {\n this._onCheck();\n }\n };\n\n __proto.componentWillUnmount = function () {\n var _a;\n\n this.gesto.unset();\n (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n };\n\n __proto.componentDidUpdate = function (prevProps) {\n var nextGuides = this.props.defaultGuides;\n\n if (prevProps.defaultGuides !== nextGuides) {\n // to dynamically update guides from code rather than dragging guidelines\n this.setState({\n guides: nextGuides || []\n });\n }\n };\n /**\n * Load the current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.loadGuides = function (guides) {\n this.setState({\n guides: guides\n });\n };\n /**\n * Get current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getGuides = function () {\n return this.state.guides;\n };\n /**\n * Scroll the positions of the guidelines opposite the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scrollGuides = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._guidesZoom;\n }\n\n this._setZoom({\n guidesZoom: nextZoom\n });\n\n var translateName = this.getTranslateName();\n var guidesElement = this.guidesElement;\n this.scrollPos = pos;\n guidesElement.style.transform = \"\".concat(translateName, \"(\").concat(-pos * nextZoom, \"px)\");\n var guides = this.state.guides;\n var guidesOffset = this.props.guidesOffset || 0;\n this.guideElements.forEach(function (el, i) {\n if (!el) {\n return;\n }\n\n var guidePos = guides[i] + (guidesOffset || 0);\n el.style.transform = \"\".concat(translateName, \"(\").concat(guidePos * nextZoom, \"px) translateZ(0px)\");\n el.style.display = -pos + guidePos < 0 ? \"none\" : \"block\";\n });\n };\n /**\n * Set to the next zoom.\n * @memberof Guides\n * @since 0.22.0\n * @param nextZoom - next zoom\n */\n\n\n __proto.zoomTo = function (nextZoom, nextGuidesZoom) {\n if (nextGuidesZoom === void 0) {\n nextGuidesZoom = nextZoom;\n }\n\n this.scroll(this.getRulerScrollPos(), nextZoom);\n this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);\n };\n /**\n * Get Guides DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getElement = function () {\n return this.managerRef.current;\n };\n /**\n * Get Ruler DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getRulerElement = function () {\n return this.ruler.canvasElement;\n };\n /**\n * Scroll position of guides (horizontal: y, vertical: x)\n */\n\n\n __proto.getGuideScrollPos = function () {\n return this.scrollPos;\n };\n /**\n * Scroll position of the ruler (horizontal: x, vertical: y)\n */\n\n\n __proto.getRulerScrollPos = function () {\n return this.ruler.getScrollPos();\n };\n /**\n * Scroll the position of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scroll = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.scroll(pos, nextZoom);\n };\n /**\n * Recalculate the size of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.resize = function (nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.resize(nextZoom);\n };\n\n __proto.movePos = function (e) {\n var datas = e.datas,\n distX = e.distX,\n distY = e.distY;\n var props = this.props;\n var type = props.type,\n snaps = props.snaps,\n snapThreshold = props.snapThreshold,\n displayDragPos = props.displayDragPos,\n digit = props.digit;\n var guidesOffset = props.guidesOffset || 0;\n var zoom = this._guidesZoom;\n\n var dragPosFormat = props.dragPosFormat || function (v) {\n return v;\n };\n\n var isHorizontal = type === \"horizontal\";\n var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);\n var offsetPos = datas.offsetPos;\n var offsetX = matrixPos[0] + offsetPos[0];\n var offsetY = matrixPos[1] + offsetPos[1];\n var guidesZoomOffset = guidesOffset * zoom;\n var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;\n var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0));\n var guideSnaps = snaps.slice().sort(function (a, b) {\n return Math.abs(guidePos - a) - Math.abs(guidePos - b);\n });\n\n if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) {\n guidePos = guideSnaps[0];\n nextPos = guidePos * zoom;\n }\n\n if (!datas.fromRuler || !this._isFirstMove) {\n if (displayDragPos) {\n var displayPos = type === \"horizontal\" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY];\n this.displayElement.style.cssText += \"display: block;\" + \"transform: translate(-50%, -50%) \" + \"translate(\".concat(displayPos.map(function (v) {\n return \"\".concat(v, \"px\");\n }).join(\", \"), \")\");\n this.displayElement.innerHTML = \"\".concat(dragPosFormat(guidePos));\n }\n\n var target = datas.target;\n target.setAttribute(\"data-pos\", guidePos);\n target.style.transform = \"\".concat(this.getTranslateName(), \"(\").concat(nextPos + guidesOffset * zoom, \"px)\");\n }\n\n return nextPos;\n };\n\n __proto.getTranslateName = function () {\n return this.props.type === \"horizontal\" ? \"translateY\" : \"translateX\";\n };\n\n __proto._startDragScroll = function (e) {\n var _this = this;\n\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var datas = e.datas;\n var dragScroll = new DragScroll();\n datas.dragScroll = dragScroll;\n dragScroll.on(\"scroll\", function (_a) {\n var _b, _c;\n\n var container = _a.container,\n direction = _a.direction;\n /**\n * If scroll can be triggered through drag, the `requestScroll` event is fired.\n * @memberof Guides\n * @event requestScroll\n * @param {OnRequestScroll} - Parameters for the `requestScroll` event\n */\n\n (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, {\n container: container,\n direction: direction\n });\n }).on(\"move\", function (_a) {\n var offsetX = _a.offsetX,\n offsetY = _a.offsetY,\n inputEvent = _a.inputEvent;\n\n _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);\n });\n dragScroll.dragStart(e, {\n container: scrollOptions.container\n });\n };\n\n __proto._dragScroll = function (e) {\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var dragScroll = e.datas.dragScroll;\n dragScroll.drag(e, scrollOptions);\n };\n\n __proto._endDragScroll = function (e) {\n var _a;\n\n (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd();\n e.datas.dragScroll = null;\n };\n\n __proto._setZoom = function (zooms) {\n var nextZoom = zooms.zoom,\n nextGuidesZoom = zooms.guidesZoom;\n var hasZoom = !!this.props.zoom;\n var hasGuidesZoom = !!this.props.guidesZoom;\n\n if (hasGuidesZoom) {\n if (nextGuidesZoom) {\n this._guidesZoom = nextGuidesZoom;\n }\n } else {\n if (nextGuidesZoom) {\n this._zoom = nextGuidesZoom;\n this._guidesZoom = nextGuidesZoom;\n }\n\n if (nextZoom) {\n this._guidesZoom = nextZoom;\n }\n }\n\n if (nextZoom) {\n this._zoom = nextZoom;\n }\n };\n\n Guides.defaultProps = {\n className: \"\",\n type: \"horizontal\",\n zoom: 1,\n guidesZoom: 0,\n style: {},\n snapThreshold: 5,\n snaps: [],\n digit: 0,\n onClickRuler: function () {},\n onChangeGuides: function () {},\n onRequestScroll: function () {},\n onDragStart: function () {},\n onDrag: function () {},\n onDragEnd: function () {},\n displayDragPos: false,\n dragPosFormat: function (v) {\n return v;\n },\n defaultGuides: [],\n lockGuides: false,\n showGuides: true,\n guideStyle: {},\n dragGuideStyle: {},\n guidePosStyle: {},\n defaultGuidesPos: 0\n };\n return Guides;\n}(PureComponent);\n\nexport default Guides;\nexport { EVENTS, METHODS, PROPERTIES };\n//# sourceMappingURL=guides.esm.js.map\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\n\nexport default Guides;\n","import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__assign","assign","t","s","i","n","arguments","length","apply","this","__spreadArray","to","from","pack","ar","l","slice","concat","prefix","classNames","_i","name","ADDER","GUIDES","GUIDE","DRAGGING","DISPLAY_DRAG","GUIDES_CSS","PROPERTIES","PROPERTIES$1","GuidesElement","Guides","_super","__extends","TypeError","String","__","constructor","props","_this","state","guides","scrollPos","managerRef","createRef","guideElements","_isFirstMove","_zoom","_guidesZoom","_observer","onDragStart","e","datas","inputEvent","movePos","dragElement","target","gesto","isFlag","stopPropagation","preventDefault","_startDragScroll","_onDrag","nextPos","onDrag","_dragScroll","_endDragScroll","onDragEnd","isDouble","distX","distY","pos","_a","onChangeGuides","displayDragPos","digit","lockGuides","guidesOffset","zoom","guidePos","parseFloat","toFixed","baseScrollPos","displayElement","style","cssText","fromRuler","onClickRuler","indexOf","setState","index","isAdd","isRemove","isChange","index_1","getAttribute","isRemove_1","isChange_1","guideIndex","splice","nextGuides","_onCheck","resize","defaultGuides","defaultGuidesPos","create","__proto","render","className","type","guidesZoom","rulerStyle","cspNonce","dragGuideStyle","_b","guidePosStyle","translateName","getTranslateName","rulerProps","forEach","console","log","createElement","ref","Ruler","transform","renderGuides","drawRuler","options","ruler","draw","showGuides","guideStyle","displayGuidePos","guidePosFormat","dragPosFormat","v","map","key","data-index","data-pos","componentDidMount","Gesto","current","container","document","body","on","stop","canvasElement","guidesElement","isHorizontal","originRect","originElement","getBoundingClientRect","matrix","getDistElementMatrix","offsetPos","calculateMatrixDist","clientX","left","clientY","top","isLockAdd","offsetLeft","offsetTop","isLockRemove","isLockChange","adderElement","useResizeObserver","ResizeObserver","observe","box","getRulerElement","componentWillUnmount","unset","disconnect","componentDidUpdate","prevProps","loadGuides","getGuides","scrollGuides","nextZoom","_setZoom","el","display","zoomTo","nextGuidesZoom","scroll","getRulerScrollPos","getGuideScrollPos","getElement","getScrollPos","snaps","snapThreshold","matrixPos","offsetX","offsetY","guidesZoomOffset","Math","round","guideSnaps","sort","a","abs","join","innerHTML","setAttribute","dragScroll","scrollOptions","DragScroll","_c","direction","onRequestScroll","scrollBy","dragStart","drag","dragEnd","zooms","defaultProps","PureComponent","GUIDES_PROPERTIES","METHODS","EVENTS","React","ReactGuides","selfElement","events","trigger","warpSelf","_warp","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","forceUpdate","parentElement","removeChild","Properties","property","args","self","getInnerGuides","defineProperty","get","set","value","enumerable","configurable","EventEmitter","others"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"guides.min.js","sources":["../../react-guides/dist/guides.esm.js","../src/index.umd.ts","../src/consts.ts","../src/InnerGuides.tsx","../src/Guides.tsx","../src/GuidesManager.tsx"],"sourcesContent":["/*\nCopyright (c) 2019 Daybrush\nname: @scena/react-guides\nlicense: MIT\nauthor: Daybrush\nrepository: https://github.com/daybrush/guides/blob/master/packages/react-guides\nversion: 0.28.2\n*/\nimport { createElement, createRef, PureComponent } from 'react';\nimport Ruler, { PROPERTIES as PROPERTIES$1 } from '@scena/react-ruler';\nimport { prefixNames, prefixCSS, ref, refs } from 'framework-utils';\nimport DragScroll from '@scena/dragscroll';\nimport Gesto from 'gesto';\nimport { styled } from 'react-css-styled';\nimport { hasClass, addClass, removeClass } from '@daybrush/utils';\nimport { getDistElementMatrix, calculateMatrixDist } from 'css-to-mat';\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n\n/* global Reflect, Promise */\nvar extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf || {\n __proto__: []\n } instanceof Array && function (d, b) {\n d.__proto__ = b;\n } || function (d, b) {\n for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];\n };\n\n return extendStatics(d, b);\n};\n\nfunction __extends(d, b) {\n if (typeof b !== \"function\" && b !== null) throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n\n function __() {\n this.constructor = d;\n }\n\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\nvar __assign = function () {\n __assign = Object.assign || function __assign(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n }\n\n return t;\n };\n\n return __assign.apply(this, arguments);\n};\nfunction __spreadArray(to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nfunction prefix() {\n var classNames = [];\n\n for (var _i = 0; _i < arguments.length; _i++) {\n classNames[_i] = arguments[_i];\n }\n\n return prefixNames.apply(void 0, __spreadArray([\"scena-guides-\"], classNames, false));\n}\n\nvar ADDER = prefix(\"guide\", \"adder\");\nvar GUIDES = prefix(\"guides\");\nvar GUIDE = prefix(\"guide\");\nvar DRAGGING = prefix(\"dragging\");\nvar DISPLAY_DRAG = prefix(\"display-drag\");\nvar GUIDES_CSS = prefixCSS(\"scena-guides-\", \"\\n{\\n position: relative;\\n width: 100%;\\n height: 100%;\\n}\\ncanvas {\\n position: relative;\\n}\\n.guide-origin {\\n position: absolute;\\n width: 1px;\\n height: 1px;\\n top: 0;\\n left: 0;\\n opacity: 0;\\n}\\n.guides {\\n position: absolute;\\n bottom: 0;\\n right: 0;\\n will-change: transform;\\n z-index: 2000;\\n}\\n.guide-pos {\\n position: absolute;\\n font-weight: bold;\\n font-size: 12px;\\n color: #f33;\\n}\\n.horizontal .guide-pos {\\n bottom: 100%;\\n left: 50%;\\n transform: translate(-50%);\\n}\\n.vertical .guide-pos {\\n left: calc(100% + 2px);\\n top: 50%;\\n transform: translateY(-50%);\\n}\\n.display-drag {\\n position: absolute;\\n will-change: transform;\\n z-index: 2000;\\n font-weight: bold;\\n font-size: 12px;\\n display: none;\\n left: 20px;\\n top: -20px;\\n color: #f33;\\n}\\n:host.horizontal .guides {\\n width: 100%;\\n height: 0;\\n}\\n:host.vertical .guides {\\n height: 100%;\\n width: 0;\\n}\\n:host.horizontal canvas {\\n cursor: ns-resize;\\n}\\n:host.vertical canvas {\\n cursor: ew-resize;\\n}\\n.guide {\\n position: absolute;\\n background: #f33;\\n z-index: 2;\\n}\\n.guide.dragging:before {\\n position: absolute;\\n content: \\\"\\\";\\n width: 100%;\\n height: 100%;\\n top: 50%;\\n left: 50%;\\n transform: translate(-50%, -50%);\\n}\\n:host.horizontal .guide {\\n width: 100%;\\n height: 1px;\\n cursor: row-resize;\\n}\\n:host.vertical .guide {\\n width: 1px;\\n height: 100%;\\n cursor: col-resize;\\n}\\n.mobile :host.horizontal .guide {\\n transform: scale(1, 2);\\n}\\n.mobile :host.vertical .guide {\\n transform: scale(2, 1);\\n}\\n:host.horizontal .guide:before {\\n height: 20px;\\n}\\n:host.vertical .guide:before {\\n width: 20px;\\n}\\n.adder {\\n display: none;\\n}\\n.adder.dragging {\\n display: block;\\n}\\n\");\nvar PROPERTIES = __spreadArray([\"className\", \"rulerStyle\", 'snapThreshold', \"snaps\", \"displayDragPos\", \"cspNonce\", 'dragPosFormat', \"defaultGuides\", \"showGuides\", \"scrollOptions\", \"guideStyle\", \"guidesOffset\", \"digit\", \"defaultGuidesPos\", \"dragGuideStyle\", \"displayGuidePos\", \"guidePosFormat\", \"guidePosStyle\", \"lockGuides\", \"guidesZoom\"], PROPERTIES$1, true);\nvar METHODS = [\"getGuides\", \"loadGuides\", \"scroll\", \"scrollGuides\", \"resize\", \"getElement\", \"getRulerElement\", \"forceUpdate\", \"getRulerScrollPos\", \"getGuideScrollPos\", \"zoomTo\", \"drawRuler\"];\nvar EVENTS = [\"changeGuides\", \"requestScroll\", \"dragStart\", \"drag\", \"dragEnd\", \"clickRuler\"];\n\nvar GuidesElement = styled(\"div\", GUIDES_CSS);\n\nvar Guides =\n/*#__PURE__*/\nfunction (_super) {\n __extends(Guides, _super);\n\n function Guides(props) {\n var _this = _super.call(this, props) || this;\n\n _this.state = {\n guides: []\n };\n _this.scrollPos = 0;\n _this.managerRef = createRef();\n _this.guideElements = [];\n _this._isFirstMove = false;\n _this._zoom = 1;\n _this._guidesZoom = 1;\n _this._observer = null;\n\n _this.onDragStart = function (e) {\n var datas = e.datas,\n inputEvent = e.inputEvent;\n _this._isFirstMove = true;\n\n _this.movePos(e);\n /**\n * When the drag starts, the dragStart event is called.\n * @memberof Guides\n * @event dragStart\n * @param {OnDragStart} - Parameters for the dragStart event\n */\n\n\n _this.props.onDragStart(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n return;\n }\n\n inputEvent.stopPropagation();\n inputEvent.preventDefault();\n\n _this._startDragScroll(e);\n };\n\n _this._onDrag = function (e) {\n if (_this._isFirstMove) {\n _this._isFirstMove = false;\n addClass(e.datas.target, DRAGGING);\n }\n\n var nextPos = _this.movePos(e);\n /**\n * When dragging, the drag event is called.\n * @memberof Guides\n * @event drag\n * @param {OnDrag} - Parameters for the drag event\n */\n\n\n _this.props.onDrag(__assign(__assign({}, e), {\n dragElement: e.datas.target\n }));\n\n if (!_this.gesto.isFlag()) {\n _this._endDragScroll(e);\n\n return;\n }\n\n _this._dragScroll(e);\n\n return nextPos;\n };\n\n _this.onDragEnd = function (e) {\n var datas = e.datas,\n isDouble = e.isDouble,\n distX = e.distX,\n distY = e.distY;\n\n var pos = _this.movePos(e);\n\n var guides = _this.state.guides;\n var _a = _this.props,\n onChangeGuides = _a.onChangeGuides,\n displayDragPos = _a.displayDragPos,\n digit = _a.digit,\n lockGuides = _a.lockGuides,\n guidesOffset = _a.guidesOffset;\n var zoom = _this._guidesZoom;\n var guidePos = parseFloat((pos / zoom).toFixed(digit || 0));\n var baseScrollPos = _this.scrollPos - (guidesOffset || 0);\n\n if (displayDragPos) {\n _this.displayElement.style.cssText += \"display: none;\";\n }\n\n removeClass(datas.target, DRAGGING);\n /**\n * When the drag finishes, the dragEnd event is called.\n * @memberof Guides\n * @event dragEnd\n * @param {OnDragEnd} - Parameters for the dragEnd event\n */\n\n _this.props.onDragEnd(__assign(__assign({}, e), {\n dragElement: datas.target\n }));\n\n _this._endDragScroll(e);\n\n if (datas.fromRuler) {\n if (_this._isFirstMove) {\n /**\n * When click the ruler, the click ruler is called.\n * @memberof Guides\n * @event clickRuler\n * @param {OnClickRuler} - Parameters for the clickRuler event\n */\n _this.props.onClickRuler(__assign(__assign({}, e), {\n pos: 0\n }));\n }\n\n if (guidePos >= baseScrollPos && guides.indexOf(guidePos) < 0) {\n _this.setState({\n guides: __spreadArray(__spreadArray([], guides, true), [guidePos], false)\n }, function () {\n /**\n * The `changeGuides` event occurs when the guideline is added / removed / changed.\n * @memberof Guides\n * @event changeGuides\n * @param {OnChangeGuides} - Parameters for the changeGuides event\n */\n onChangeGuides({\n guides: _this.state.guides,\n distX: distX,\n distY: distY,\n index: guides.length,\n isAdd: true,\n isRemove: false,\n isChange: false\n });\n });\n }\n } else {\n var index_1 = parseFloat(datas.target.getAttribute(\"data-index\"));\n var isRemove_1 = false;\n var isChange_1 = false;\n guides = __spreadArray([], guides, true);\n var guideIndex = guides.indexOf(guidePos);\n\n if (isDouble || guidePos < baseScrollPos || guideIndex > -1 && guideIndex !== index_1) {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"remove\") > -1)) {\n return;\n }\n\n guides.splice(index_1, 1);\n isRemove_1 = true;\n } else if (guideIndex > -1) {\n return;\n } else {\n if (lockGuides && (lockGuides === true || lockGuides.indexOf(\"change\") > -1)) {\n return;\n }\n\n guides[index_1] = guidePos;\n isChange_1 = true;\n }\n\n _this.setState({\n guides: guides\n }, function () {\n var nextGuides = _this.state.guides;\n onChangeGuides({\n distX: distX,\n distY: distY,\n guides: nextGuides,\n isAdd: false,\n index: index_1,\n isChange: isChange_1,\n isRemove: isRemove_1\n });\n });\n }\n };\n\n _this._onCheck = function () {\n _this.resize();\n };\n\n _this.state.guides = props.defaultGuides || [];\n _this.scrollPos = props.defaultGuidesPos || 0;\n return _this;\n }\n\n var __proto = Guides.prototype;\n\n __proto.render = function () {\n var _a = this.props,\n className = _a.className,\n type = _a.type,\n zoom = _a.zoom,\n guidesZoom = _a.guidesZoom,\n style = _a.style,\n rulerStyle = _a.rulerStyle,\n displayDragPos = _a.displayDragPos,\n cspNonce = _a.cspNonce,\n dragGuideStyle = _a.dragGuideStyle,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b;\n var props = this.props;\n var translateName = this.getTranslateName();\n var rulerProps = {};\n PROPERTIES$1.forEach(function (name) {\n if (name === \"style\" || name === \"warpSelf\" || name === \"useResizeObserver\") {\n return;\n }\n\n rulerProps[name] = props[name];\n });\n this._zoom = zoom;\n this._guidesZoom = guidesZoom || zoom;\n return createElement(GuidesElement, {\n ref: this.managerRef,\n cspNonce: cspNonce,\n className: \"\".concat(prefix(\"manager\", type), \" \").concat(className),\n style: style\n }, createElement(\"div\", {\n className: prefix(\"guide-origin\"),\n ref: ref(this, \"originElement\")\n }), createElement(Ruler, __assign({\n ref: ref(this, \"ruler\"),\n style: rulerStyle\n }, rulerProps)), createElement(\"div\", {\n className: GUIDES,\n ref: ref(this, \"guidesElement\"),\n style: {\n transform: \"\".concat(translateName, \"(\").concat(-this.scrollPos * this._guidesZoom, \"px)\")\n }\n }, displayDragPos && createElement(\"div\", {\n className: DISPLAY_DRAG,\n ref: ref(this, \"displayElement\"),\n style: guidePosStyle || {}\n }), createElement(\"div\", {\n className: ADDER,\n ref: ref(this, \"adderElement\"),\n style: dragGuideStyle\n }), this.renderGuides()));\n };\n /**\n * Draw ruler\n */\n\n\n __proto.drawRuler = function (options) {\n this.ruler.draw(options);\n };\n\n __proto.renderGuides = function () {\n var _this = this;\n\n var props = this.props;\n var _a = props,\n type = _a.type,\n showGuides = _a.showGuides,\n guideStyle = _a.guideStyle,\n displayGuidePos = _a.displayGuidePos,\n _b = _a.guidePosStyle,\n guidePosStyle = _b === void 0 ? {} : _b,\n guidesOffset = _a.guidesOffset;\n var zoom = this._guidesZoom;\n var translateName = this.getTranslateName();\n var guides = this.state.guides;\n\n var guidePosFormat = props.guidePosFormat || props.dragPosFormat || function (v) {\n return v;\n };\n\n this.guideElements = [];\n\n if (showGuides) {\n return guides.map(function (pos, i) {\n var guidePos = pos + (guidesOffset || 0);\n return createElement(\"div\", {\n className: prefix(\"guide\", type),\n ref: refs(_this, \"guideElements\", i),\n key: i,\n \"data-index\": i,\n \"data-pos\": pos,\n style: __assign(__assign({}, guideStyle), {\n transform: \"\".concat(translateName, \"(\").concat(guidePos * zoom, \"px) translateZ(0px)\")\n })\n }, displayGuidePos && createElement(\"div\", {\n className: prefix(\"guide-pos\"),\n style: guidePosStyle || {}\n }, guidePosFormat(pos)));\n });\n }\n\n return;\n };\n\n __proto.componentDidMount = function () {\n var _this = this;\n\n this.gesto = new Gesto(this.managerRef.current, {\n container: document.body\n }).on(\"dragStart\", function (e) {\n var _a = _this.props,\n type = _a.type,\n lockGuides = _a.lockGuides;\n var zoom = _this._guidesZoom;\n\n if (lockGuides === true) {\n e.stop();\n return;\n }\n\n var inputEvent = e.inputEvent;\n var target = inputEvent.target;\n var datas = e.datas;\n var canvasElement = _this.ruler.canvasElement;\n var guidesElement = _this.guidesElement;\n var isHorizontal = type === \"horizontal\";\n\n var originRect = _this.originElement.getBoundingClientRect();\n\n var matrix = getDistElementMatrix(_this.managerRef.current);\n var offsetPos = calculateMatrixDist(matrix, [e.clientX - originRect.left, e.clientY - originRect.top]);\n offsetPos[0] -= guidesElement.offsetLeft;\n offsetPos[1] -= guidesElement.offsetTop;\n offsetPos[isHorizontal ? 1 : 0] += _this.scrollPos * zoom;\n datas.offsetPos = offsetPos;\n datas.matrix = matrix;\n var isLockAdd = lockGuides && lockGuides.indexOf(\"add\") > -1;\n var isLockRemove = lockGuides && lockGuides.indexOf(\"remove\") > -1;\n var isLockChange = lockGuides && lockGuides.indexOf(\"change\") > -1;\n\n if (target === canvasElement) {\n if (isLockAdd) {\n e.stop();\n return;\n }\n\n datas.fromRuler = true;\n datas.target = _this.adderElement; // add\n } else if (hasClass(target, GUIDE)) {\n if (isLockRemove && isLockChange) {\n e.stop();\n return;\n }\n\n datas.target = target; // change\n } else {\n e.stop();\n return false;\n }\n\n _this.onDragStart(e);\n }).on(\"drag\", this._onDrag).on(\"dragEnd\", this.onDragEnd);\n\n if (this.props.useResizeObserver) {\n this._observer = new ResizeObserver(this._onCheck);\n\n this._observer.observe(this.guidesElement, {\n box: \"border-box\"\n });\n\n this._observer.observe(this.getRulerElement(), {\n box: \"border-box\"\n });\n } else {\n this._onCheck();\n }\n };\n\n __proto.componentWillUnmount = function () {\n var _a;\n\n this.gesto.unset();\n (_a = this._observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n };\n\n __proto.componentDidUpdate = function (prevProps) {\n var nextGuides = this.props.defaultGuides;\n\n if (prevProps.defaultGuides !== nextGuides) {\n // to dynamically update guides from code rather than dragging guidelines\n this.setState({\n guides: nextGuides || []\n });\n }\n };\n /**\n * Load the current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.loadGuides = function (guides) {\n this.setState({\n guides: guides\n });\n };\n /**\n * Get current guidelines.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getGuides = function () {\n return this.state.guides;\n };\n /**\n * Scroll the positions of the guidelines opposite the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scrollGuides = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._guidesZoom;\n }\n\n this._setZoom({\n guidesZoom: nextZoom\n });\n\n var translateName = this.getTranslateName();\n var guidesElement = this.guidesElement;\n this.scrollPos = pos;\n guidesElement.style.transform = \"\".concat(translateName, \"(\").concat(-pos * nextZoom, \"px)\");\n var guides = this.state.guides;\n var guidesOffset = this.props.guidesOffset || 0;\n this.guideElements.forEach(function (el, i) {\n if (!el) {\n return;\n }\n\n var guidePos = guides[i] + (guidesOffset || 0);\n el.style.transform = \"\".concat(translateName, \"(\").concat(guidePos * nextZoom, \"px) translateZ(0px)\");\n el.style.display = -pos + guidePos < 0 ? \"none\" : \"block\";\n });\n };\n /**\n * Set to the next zoom.\n * @memberof Guides\n * @since 0.22.0\n * @param nextZoom - next zoom\n */\n\n\n __proto.zoomTo = function (nextZoom, nextGuidesZoom) {\n if (nextGuidesZoom === void 0) {\n nextGuidesZoom = nextZoom;\n }\n\n this.scroll(this.getRulerScrollPos(), nextZoom);\n this.scrollGuides(this.getGuideScrollPos(), nextGuidesZoom);\n };\n /**\n * Get Guides DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getElement = function () {\n return this.managerRef.current;\n };\n /**\n * Get Ruler DOM Element\n * @memberof Guides\n * @instance\n */\n\n\n __proto.getRulerElement = function () {\n return this.ruler.canvasElement;\n };\n /**\n * Scroll position of guides (horizontal: y, vertical: x)\n */\n\n\n __proto.getGuideScrollPos = function () {\n return this.scrollPos;\n };\n /**\n * Scroll position of the ruler (horizontal: x, vertical: y)\n */\n\n\n __proto.getRulerScrollPos = function () {\n return this.ruler.getScrollPos();\n };\n /**\n * Scroll the position of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.scroll = function (pos, nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.scroll(pos, nextZoom);\n };\n /**\n * Recalculate the size of the ruler.\n * @memberof Guides\n * @instance\n */\n\n\n __proto.resize = function (nextZoom) {\n if (nextZoom === void 0) {\n nextZoom = this._zoom;\n }\n\n this._setZoom({\n zoom: nextZoom\n });\n\n this.ruler.resize(nextZoom);\n };\n\n __proto.movePos = function (e) {\n var datas = e.datas,\n distX = e.distX,\n distY = e.distY;\n var props = this.props;\n var type = props.type,\n snaps = props.snaps,\n snapThreshold = props.snapThreshold,\n displayDragPos = props.displayDragPos,\n digit = props.digit;\n var guidesOffset = props.guidesOffset || 0;\n var zoom = this._guidesZoom;\n\n var dragPosFormat = props.dragPosFormat || function (v) {\n return v;\n };\n\n var isHorizontal = type === \"horizontal\";\n var matrixPos = calculateMatrixDist(datas.matrix, [distX, distY]);\n var offsetPos = datas.offsetPos;\n var offsetX = matrixPos[0] + offsetPos[0];\n var offsetY = matrixPos[1] + offsetPos[1];\n var guidesZoomOffset = guidesOffset * zoom;\n var nextPos = Math.round(isHorizontal ? offsetY : offsetX) - guidesOffset;\n var guidePos = parseFloat((nextPos / zoom).toFixed(digit || 0));\n var guideSnaps = snaps.slice().sort(function (a, b) {\n return Math.abs(guidePos - a) - Math.abs(guidePos - b);\n });\n\n if (guideSnaps.length && Math.abs(guideSnaps[0] * zoom - nextPos) < snapThreshold) {\n guidePos = guideSnaps[0];\n nextPos = guidePos * zoom;\n }\n\n if (!datas.fromRuler || !this._isFirstMove) {\n if (displayDragPos) {\n var displayPos = type === \"horizontal\" ? [offsetX, nextPos + guidesZoomOffset] : [nextPos + guidesZoomOffset, offsetY];\n this.displayElement.style.cssText += \"display: block;\" + \"transform: translate(-50%, -50%) \" + \"translate(\".concat(displayPos.map(function (v) {\n return \"\".concat(v, \"px\");\n }).join(\", \"), \")\");\n this.displayElement.innerHTML = \"\".concat(dragPosFormat(guidePos));\n }\n\n var target = datas.target;\n target.setAttribute(\"data-pos\", guidePos);\n target.style.transform = \"\".concat(this.getTranslateName(), \"(\").concat(nextPos + guidesOffset * zoom, \"px)\");\n }\n\n return nextPos;\n };\n\n __proto.getTranslateName = function () {\n return this.props.type === \"horizontal\" ? \"translateY\" : \"translateX\";\n };\n\n __proto._startDragScroll = function (e) {\n var _this = this;\n\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var datas = e.datas;\n var dragScroll = new DragScroll();\n datas.dragScroll = dragScroll;\n dragScroll.on(\"scroll\", function (_a) {\n var _b, _c;\n\n var container = _a.container,\n direction = _a.direction;\n /**\n * If scroll can be triggered through drag, the `requestScroll` event is fired.\n * @memberof Guides\n * @event requestScroll\n * @param {OnRequestScroll} - Parameters for the `requestScroll` event\n */\n\n (_c = (_b = _this.props).onRequestScroll) === null || _c === void 0 ? void 0 : _c.call(_b, {\n container: container,\n direction: direction\n });\n }).on(\"move\", function (_a) {\n var offsetX = _a.offsetX,\n offsetY = _a.offsetY,\n inputEvent = _a.inputEvent;\n\n _this.gesto.scrollBy(offsetX, offsetY, inputEvent.inputEvent, true);\n });\n dragScroll.dragStart(e, {\n container: scrollOptions.container\n });\n };\n\n __proto._dragScroll = function (e) {\n var scrollOptions = this.props.scrollOptions;\n\n if (!scrollOptions) {\n return;\n }\n\n var dragScroll = e.datas.dragScroll;\n dragScroll.drag(e, scrollOptions);\n };\n\n __proto._endDragScroll = function (e) {\n var _a;\n\n (_a = e.datas.dragScroll) === null || _a === void 0 ? void 0 : _a.dragEnd();\n e.datas.dragScroll = null;\n };\n\n __proto._setZoom = function (zooms) {\n var nextZoom = zooms.zoom,\n nextGuidesZoom = zooms.guidesZoom;\n var hasZoom = !!this.props.zoom;\n var hasGuidesZoom = !!this.props.guidesZoom;\n\n if (hasGuidesZoom) {\n if (nextGuidesZoom) {\n this._guidesZoom = nextGuidesZoom;\n }\n } else {\n if (nextGuidesZoom) {\n this._zoom = nextGuidesZoom;\n this._guidesZoom = nextGuidesZoom;\n }\n\n if (nextZoom) {\n this._guidesZoom = nextZoom;\n }\n }\n\n if (nextZoom) {\n this._zoom = nextZoom;\n }\n };\n\n Guides.defaultProps = {\n className: \"\",\n type: \"horizontal\",\n zoom: 1,\n guidesZoom: 0,\n style: {},\n snapThreshold: 5,\n snaps: [],\n digit: 0,\n onClickRuler: function () {},\n onChangeGuides: function () {},\n onRequestScroll: function () {},\n onDragStart: function () {},\n onDrag: function () {},\n onDragEnd: function () {},\n displayDragPos: false,\n dragPosFormat: function (v) {\n return v;\n },\n defaultGuides: [],\n lockGuides: false,\n showGuides: true,\n guideStyle: {},\n dragGuideStyle: {},\n guidePosStyle: {},\n defaultGuidesPos: 0\n };\n return Guides;\n}(PureComponent);\n\nexport default Guides;\nexport { EVENTS, METHODS, PROPERTIES };\n//# sourceMappingURL=guides.esm.js.map\n","import Guides, * as others from \"./index.esm\";\n\nfor (const name in others) {\n (Guides as any)[name] = others[name];\n}\n\nexport default Guides;\n","import {\n PROPERTIES as GUIDES_PROPERTIES,\n METHODS as GUIDES_METHODS,\n EVENTS as GUIDES_EVENTS,\n} from \"@scena/react-guides\";\nimport {\n GuidesOptions,\n} from \"@scena/react-guides/declaration/types\";\nexport const PROPERTIES: Array = GUIDES_PROPERTIES;\n\nexport const METHODS = GUIDES_METHODS as readonly string[];\n\nexport const EVENTS = GUIDES_EVENTS as readonly string[];\n","import * as React from \"react\";\nimport { ref } from \"framework-utils\";\nimport ReactGuides from \"@scena/react-guides\";\nimport { GuidesOptions } from \"@scena/react-guides/declaration/types\";\n\nexport interface InnerGuidesProps extends GuidesOptions {\n container?: HTMLElement;\n}\nexport default class InnerGuides extends React.Component {\n public state: InnerGuidesProps = {};\n public guides: ReactGuides;\n constructor(props: InnerGuidesProps) {\n super(props);\n this.state = this.props;\n }\n public render() {\n return ;\n }\n}\n","import GuidesManager from \"./GuidesManager\";\n\nexport default class Guides extends GuidesManager {}\n","import { ref, Properties } from \"framework-utils\";\nimport * as React from \"react\";\nimport { PROPERTIES, METHODS, EVENTS } from \"./consts\";\nimport { GuidesInterface, GuidesEvents, GuidesOptions } from \"@scena/react-guides/declaration/types\";\nimport InnerGuides from \"./InnerGuides\";\nimport EventEmitter from \"@scena/event-emitter\";\nimport { camelize } from \"@daybrush/utils\";\nimport { ContainerProvider, renderSelf } from \"croact\";\n\n@Properties(METHODS as any, (prototype, property) => {\n if (prototype[property]) {\n return;\n }\n prototype[property] = function(...args) {\n const self = this.getInnerGuides();\n\n if (!self || !self[property]) {\n return;\n }\n return self[property](...args);\n };\n})\n@Properties(PROPERTIES, (prototype, property) => {\n Object.defineProperty(prototype, property, {\n get() {\n return this.getInnerGuides().props[property];\n },\n set(value) {\n this.innerGuides.setState({\n [property]: value,\n });\n },\n enumerable: true,\n configurable: true,\n });\n})\n/**\n * @sort 1\n * @extends EventEmitter\n */\nclass Guides extends EventEmitter {\n private containerProvider: ContainerProvider | null = null;\n private selfElement: HTMLElement | null = null;\n private _warp = false;\n private innerGuides!: InnerGuides;\n /**\n * @sort 1\n * @param - guides' container\n * @param {$ts:Partial} - guides' options\n */\n constructor(container: HTMLElement, options: Partial = {}) {\n super();\n const events: any = {};\n\n EVENTS.forEach(name => {\n events[camelize(`on ${name}`)] = (e: any) => this.trigger(name as any, e);\n });\n let selfElement!: HTMLElement;\n\n if (options.warpSelf) {\n delete options.warpSelf;\n this._warp = true;\n selfElement = container;\n } else {\n selfElement = document.createElement(\"div\");\n container.appendChild(selfElement);\n }\n this.containerProvider = renderSelf(\n ,\n selfElement,\n );\n }\n /**\n * @param state\n * @param callback\n */\n public setState(state: Partial, callback?: () => void) {\n this.innerGuides.setState(state, callback);\n }\n /**\n * @param callback\n */\n public forceUpdate(callback?: () => void) {\n this.innerGuides.forceUpdate(callback);\n }\n /**\n * destroy guides\n */\n public destroy() {\n const selfElement = this.selfElement!;\n\n renderSelf(\n null,\n selfElement!,\n this.containerProvider,\n );\n if (!this._warp) {\n selfElement?.parentElement?.removeChild(selfElement);\n }\n this.selfElement = null;\n this.innerGuides = null;\n }\n private getInnerGuides() {\n return this.innerGuides.guides;\n }\n}\ninterface Guides extends GuidesInterface {}\n\nexport default Guides;\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__assign","assign","t","s","i","n","arguments","length","apply","this","__spreadArray","to","from","pack","ar","l","slice","concat","prefix","classNames","_i","name","ADDER","GUIDES","GUIDE","DRAGGING","DISPLAY_DRAG","GUIDES_CSS","PROPERTIES","PROPERTIES$1","GuidesElement","Guides","_super","__extends","TypeError","String","__","constructor","props","_this","state","guides","scrollPos","managerRef","createRef","guideElements","_isFirstMove","_zoom","_guidesZoom","_observer","onDragStart","e","datas","inputEvent","movePos","dragElement","target","gesto","isFlag","stopPropagation","preventDefault","_startDragScroll","_onDrag","nextPos","onDrag","_dragScroll","_endDragScroll","onDragEnd","isDouble","distX","distY","pos","_a","onChangeGuides","displayDragPos","digit","lockGuides","guidesOffset","zoom","guidePos","parseFloat","toFixed","baseScrollPos","displayElement","style","cssText","fromRuler","onClickRuler","indexOf","setState","index","isAdd","isRemove","isChange","index_1","getAttribute","isRemove_1","isChange_1","guideIndex","splice","nextGuides","_onCheck","resize","defaultGuides","defaultGuidesPos","create","__proto","render","className","type","guidesZoom","rulerStyle","cspNonce","dragGuideStyle","_b","guidePosStyle","translateName","getTranslateName","rulerProps","forEach","createElement","ref","Ruler","transform","renderGuides","drawRuler","options","ruler","draw","showGuides","guideStyle","displayGuidePos","guidePosFormat","dragPosFormat","v","map","key","data-index","data-pos","componentDidMount","Gesto","current","container","document","body","on","stop","canvasElement","guidesElement","isHorizontal","originRect","originElement","getBoundingClientRect","matrix","getDistElementMatrix","offsetPos","calculateMatrixDist","clientX","left","clientY","top","isLockAdd","offsetLeft","offsetTop","isLockRemove","isLockChange","adderElement","useResizeObserver","ResizeObserver","observe","box","getRulerElement","componentWillUnmount","unset","disconnect","componentDidUpdate","prevProps","loadGuides","getGuides","scrollGuides","nextZoom","_setZoom","el","display","zoomTo","nextGuidesZoom","scroll","getRulerScrollPos","getGuideScrollPos","getElement","getScrollPos","snaps","snapThreshold","matrixPos","offsetX","offsetY","guidesZoomOffset","Math","round","guideSnaps","sort","a","abs","join","innerHTML","setAttribute","dragScroll","scrollOptions","DragScroll","_c","direction","onRequestScroll","scrollBy","dragStart","drag","dragEnd","zooms","defaultProps","PureComponent","GUIDES_PROPERTIES","METHODS","EVENTS","React","ReactGuides","selfElement","events","trigger","warpSelf","_warp","appendChild","containerProvider","renderSelf","InnerGuides","callback","innerGuides","forceUpdate","parentElement","removeChild","Properties","property","args","self","getInnerGuides","defineProperty","get","set","value","enumerable","configurable","EventEmitter","others"],"mappings":"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"} \ No newline at end of file diff --git a/release/latest/doc/EventEmitter.html b/release/latest/doc/EventEmitter.html index a866bfe..334abb9 100644 --- a/release/latest/doc/EventEmitter.html +++ b/release/latest/doc/EventEmitter.html @@ -2754,7 +2754,7 @@
Type:

- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/Guides.html b/release/latest/doc/Guides.html index f4a9b7d..0a089f5 100644 --- a/release/latest/doc/Guides.html +++ b/release/latest/doc/Guides.html @@ -762,7 +762,7 @@

scrollGui
Source:
@@ -933,7 +933,7 @@

scrollSource:
@@ -1104,7 +1104,7 @@

resizeSource:
@@ -2113,7 +2113,7 @@

loadGuides<
Source:
@@ -2249,7 +2249,7 @@

getRul
Source:
@@ -2337,7 +2337,7 @@

getGuidesSource:
@@ -2443,7 +2443,7 @@

getElement<
Source:
@@ -3102,7 +3102,7 @@

(static) zoomT
Source:
@@ -11510,7 +11510,7 @@

changeGuides

Source:
@@ -11642,7 +11642,7 @@

clickRuler

Source:
@@ -11774,7 +11774,7 @@

drag

Source:
@@ -11906,7 +11906,7 @@

dragEnd

Source:
@@ -12038,7 +12038,7 @@

dragStart

Source:
@@ -12170,7 +12170,7 @@

requestScroll

Source:
@@ -12311,7 +12311,7 @@

requestScroll


- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/global.html b/release/latest/doc/global.html index 030a001..b2e4afb 100644 --- a/release/latest/doc/global.html +++ b/release/latest/doc/global.html @@ -221,7 +221,7 @@

getR
Source:
@@ -309,7 +309,7 @@

getG
Source:
@@ -397,7 +397,7 @@

drawRulerSource:
@@ -690,7 +690,7 @@

draw
- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/index.html b/release/latest/doc/index.html index de3fd82..6c58f29 100644 --- a/release/latest/doc/index.html +++ b/release/latest/doc/index.html @@ -202,7 +202,7 @@

📝 License


- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html b/release/latest/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html index 6db1777..22b5588 100644 --- a/release/latest/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html +++ b/release/latest/doc/node_modules_@scena_event-emitter_src_EventEmitter.ts.html @@ -280,7 +280,7 @@

node_modules/@scena/event-emitter/src/EventEmitter.ts

- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/node_modules_@scena_event-emitter_src_types.ts.html b/release/latest/doc/node_modules_@scena_event-emitter_src_types.ts.html index ac9e188..8cd169b 100644 --- a/release/latest/doc/node_modules_@scena_event-emitter_src_types.ts.html +++ b/release/latest/doc/node_modules_@scena_event-emitter_src_types.ts.html @@ -113,7 +113,7 @@

node_modules/@scena/event-emitter/src/types.ts


- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html b/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html index 7c739b2..b73adaf 100644 --- a/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html +++ b/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_Ruler.tsx.html @@ -526,7 +526,7 @@

node_modules/@scena/react-ruler/src/react-ruler/Ruler.tsx
- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html b/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html index b6d9005..a5b5965 100644 --- a/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html +++ b/release/latest/doc/node_modules_@scena_react-ruler_src_react-ruler_types.ts.html @@ -302,7 +302,7 @@

node_modules/@scena/react-ruler/src/react-ruler/types.ts<
- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/packages_guides_src_GuidesManager.tsx.html b/release/latest/doc/packages_guides_src_GuidesManager.tsx.html index f84e4dd..4e9a352 100644 --- a/release/latest/doc/packages_guides_src_GuidesManager.tsx.html +++ b/release/latest/doc/packages_guides_src_GuidesManager.tsx.html @@ -177,7 +177,7 @@

packages/guides/src/GuidesManager.tsx


- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/packages_react-guides_src_react-guides_Guides.tsx.html b/release/latest/doc/packages_react-guides_src_react-guides_Guides.tsx.html index 717e378..df570ad 100644 --- a/release/latest/doc/packages_react-guides_src_react-guides_Guides.tsx.html +++ b/release/latest/doc/packages_react-guides_src_react-guides_Guides.tsx.html @@ -131,7 +131,6 @@

packages/react-guides/src/react-guides/Guides.tsx

this._zoom = zoom; this._guidesZoom = guidesZoom || zoom; - console.log(type, zoom, guidesZoom); return <GuidesElement ref={this.managerRef} cspNonce={cspNonce} @@ -677,7 +676,7 @@

packages/react-guides/src/react-guides/Guides.tsx


- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.
diff --git a/release/latest/doc/packages_react-guides_src_react-guides_types.ts.html b/release/latest/doc/packages_react-guides_src_react-guides_types.ts.html index 9c604ca..bc38756 100644 --- a/release/latest/doc/packages_react-guides_src_react-guides_types.ts.html +++ b/release/latest/doc/packages_react-guides_src_react-guides_types.ts.html @@ -291,7 +291,7 @@

packages/react-guides/src/react-guides/types.ts


- Documentation generated by JSDoc 0.4.7 on Sun Jul 23 2023 19:26:16 GMT+0900 (대한민국 표준시) using the docdash theme. + Documentation generated by JSDoc 0.4.7 on Sat Jul 29 2023 19:13:33 GMT+0900 (대한민국 표준시) using the docdash theme.