@bizdoc/core 1.14.9 → 1.14.10

package/esm2020/lib/core/functions.mjs

@@ -0,0 +1,205 @@
+import { MATERIAL_PALETTES } from "./colors";
+const IMAGE_TYPE = ['image/png', 'image/jpeg', 'image/jpg', 'image/gif'];
+export function mapToArray(map) {
+    return Object.keys(map).map(k => ({ key: k, value: map[k] }));
+}
+export function isImage(contentType) {
+    return IMAGE_TYPE.indexOf(contentType) > -1;
+}
+export function cleanup(params) {
+    Object.keys(params).forEach(k => {
+        const val = params[k];
+        if (val === null || val === undefined || (isArray(val) && !val.length))
+            delete params[k];
+    });
+    return params;
+}
+export function outOfBound(element) {
+    const bounding = element.getBoundingClientRect();
+    return bounding.top < 0 ||
+        bounding.left < 0 ||
+        bounding.right > document.documentElement.clientWidth ||
+        bounding.bottom > document.documentElement.clientHeight;
+}
+const IS_MOBILE = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+export function isMobile() {
+    return IS_MOBILE /*|| document.cookie.indexOf('aria=1') > -1*/;
+}
+export function isFunction(val) {
+    return typeof val === 'function';
+}
+export function isBoolean(val) {
+    return typeof val === 'boolean';
+}
+export function isObject(val) {
+    return val !== null && typeof val === 'object';
+}
+export function isPrimitive(val) {
+    return typeof val !== 'object' && !Array.isArray(val);
+}
+export function isPromise(obj) {
+    return obj instanceof Promise;
+}
+export function isDate(val) {
+    return val instanceof Date;
+}
+export function isArray(val) {
+    return Array.isArray(val);
+}
+export function isString(val) {
+    return typeof val === 'string' || val instanceof String;
+}
+export function getWarn(mode = 500) {
+    return MATERIAL_PALETTES['red'][mode];
+}
+export function playAudio(name) {
+    try {
+        const audio = new Audio();
+        audio.src = `/assets/sounds/${name}.ogg`;
+        audio.load();
+        audio.play();
+    }
+    catch (e) {
+        console.log(e);
+    }
+}
+/**
+ *
+ * @param o1
+ * @param o2
+ */
+export function deepAssign(o1, o2) {
+    o2 && Object.keys(o2).forEach(p => {
+        const val2 = o2[p], val1 = o1[p];
+        if (val1 === undefined || val1 === null || isPrimitive(val2)) // val !== 'object' && !Array.isArray(val)
+            o1[p] = val2;
+        else if (Array.isArray(val2)) {
+            if (val2.length && !isPrimitive(val2[0])) {
+                for (let i = 0; i < val2.length; i++) {
+                    if (val1[i] !== undefined)
+                        deepAssign(val1[i], val2[i]);
+                    else
+                        val1.push(val2[i]);
+                }
+                val1.splice(val2.length);
+            }
+            else
+                //(val2 as any[]).splice(0, val2.length, ...val);
+                o1[p] = val2;
+        }
+        else //if (isObject(val2))
+            deepAssign(val1, val2);
+    });
+    return o1;
+}
+function generateEncryptionMap() {
+    const values = {};
+    for (let i = 65; i < 91; i++) {
+        const d = (i - 65).toString(), c = String.fromCharCode(i);
+        values[d] = c;
+        values[c] = d;
+    }
+    for (let i = 97; i < 123; i++) {
+        const d = (i - 71).toString(), c = String.fromCharCode(i);
+        values[d] = c;
+        values[c] = d;
+    }
+    return values;
+}
+const decode = generateEncryptionMap();
+String.prototype.decodeId = function () {
+    let v = '';
+    for (let i = 0; i < this.length; i++) {
+        const c = this.charAt(i);
+        v += decode[c];
+    }
+    return parseInt(v);
+};
+Number.prototype.encodeId = function () {
+    let v = '', d = this.toString();
+    while (d.length > 0) {
+        let i = 51, c = i.toString();
+        while (!d.startsWith(c)) {
+            --i, c = i.toString();
+        }
+        v += decode[c];
+        d = d.substring(c.length);
+    }
+    return v;
+};
+/** global extended array functions */
+window.global = window;
+String.prototype.normalize = function () {
+    return this.replace(/ /g, '_').replace(/[^\w]/g, '').toLowerCase();
+};
+String.prototype.formatArgs = function (...args) {
+    return this.replace(/{(\d+)}/g, (_, index) => args[index] || '');
+};
+Array.prototype.last = function () {
+    return this[this.length - 1];
+};
+/** remove element from array */
+Array.prototype.remove = function (value) {
+    const index = this.indexOf(value);
+    if (index > -1)
+        this.splice(index, 1);
+    return this;
+};
+/** calculate average using element predicate */
+Array.prototype.average = function (predicate) {
+    let average = 0;
+    this.forEach(i => average += predicate(i));
+    return average !== 0 ? average / this.length : 0;
+};
+Array.prototype.distinct = function (predicate) {
+    const values = new Set();
+    this.forEach(i => values.add(predicate(i)));
+    return values;
+};
+Array.prototype.max = function (predicate) {
+    let n = 0;
+    this.forEach(i => n = Math.max(n, predicate(i)));
+    return n;
+};
+/** sum elements using predicate */
+Array.prototype.sum = function (predicate) {
+    let n = 0;
+    this.forEach(i => n += predicate(i));
+    return n;
+};
+/**
+ *
+ * @param args
+ */
+export function queryParams(args) {
+    const params = {};
+    args &&
+        Object.keys(args).forEach(k => {
+            const val = args[k];
+            if (val !== null && val !== undefined) {
+                if (isString(val))
+                    params[k] = val;
+                else if (isArray(val) && val.length)
+                    params[k] = val;
+                else if (isDate(val))
+                    params[k] = val.toJSON();
+                else if (isObject(val)) {
+                    if (Object.keys(val).length)
+                        params[k] = queryParams(val);
+                }
+                else
+                    params[k] = val;
+            }
+        });
+    return params;
+}
+function getParameterByName(name, url = window.location.href) {
+    name = name.replace(/[\[\]]/g, '\\$&');
+    var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'), results = regex.exec(url);
+    if (!results)
+        return null;
+    if (!results[2])
+        return '';
+    return decodeURIComponent(results[2].replace(/\+/g, ' '));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functions.js","sourceRoot":"","sources":["../../../../../libraries/core/src/lib/core/functions.ts"],"names":[],"mappings":"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","sourcesContent":["import { MATERIAL_PALETTES } from \"./colors\";\r\n\r\nexport declare type MaterialMode = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 'A100' | 'A200' | 'A400' | 'A700';\r\n\r\nconst IMAGE_TYPE = ['image/png', 'image/jpeg', 'image/jpg', 'image/gif'];\r\n\r\nexport function mapToArray(map: { [key: string]: any }) {\r\n  return Object.keys(map).map(k => ({ key: k, value: map[k] }));\r\n}\r\n\r\nexport function isImage(contentType: string): boolean {\r\n  return IMAGE_TYPE.indexOf(contentType) > -1;\r\n}\r\n\r\nexport function cleanup(params) {\r\n  Object.keys(params).forEach(k => {\r\n    const val = params[k];\r\n    if (val === null || val === undefined || (isArray(val) && !val.length)) delete params[k]\r\n  });\r\n  return params;\r\n}\r\n\r\nexport function outOfBound(element: HTMLElement) {\r\n  const bounding = element.getBoundingClientRect();\r\n  return bounding.top < 0 ||\r\n    bounding.left < 0 ||\r\n    bounding.right > document.documentElement.clientWidth ||\r\n    bounding.bottom > document.documentElement.clientHeight;\r\n}\r\n\r\nconst IS_MOBILE = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);\r\nexport function isMobile() {\r\n  return IS_MOBILE /*|| document.cookie.indexOf('aria=1') > -1*/;\r\n} export function isFunction(val): val is Function {\r\n  return typeof val === 'function';\r\n}\r\nexport function isBoolean(val): val is boolean {\r\n  return typeof val === 'boolean';\r\n}\r\nexport function isObject(val) {\r\n  return val !== null && typeof val === 'object';\r\n}\r\nexport function isPrimitive(val) {\r\n  return typeof val !== 'object' && !Array.isArray(val);\r\n}\r\nexport function isPromise(obj): obj is Promise<any> {\r\n  return obj instanceof Promise;\r\n}\r\nexport function isDate(val): val is Date {\r\n  return val instanceof Date;\r\n}\r\nexport function isArray(val): val is Array<any> {\r\n  return Array.isArray(val);\r\n}\r\nexport function isString(val: any): val is string {\r\n  return typeof val === 'string' || val instanceof String;\r\n}\r\n\r\nexport function getWarn(mode: MaterialMode = 500) {\r\n  return MATERIAL_PALETTES['red'][mode];\r\n}\r\n\r\nexport function playAudio(name: 'notification_simple-01' | 'alert_error-03') {\r\n  try {\r\n    const audio = new Audio();\r\n    audio.src = `/assets/sounds/${name}.ogg`;\r\n    audio.load();\r\n    audio.play();\r\n  } catch (e) {\r\n    console.log(e);\r\n  }\r\n}\r\n\r\n/**\r\n * \r\n * @param o1\r\n * @param o2\r\n */\r\nexport function deepAssign(o1, o2) {\r\n  o2 && Object.keys(o2).forEach(p => {\r\n    const val2 = o2[p], val1 = o1[p];\r\n    if (val1 === undefined || val1 === null || isPrimitive(val2)) // val !== 'object' && !Array.isArray(val)\r\n      o1[p] = val2;\r\n    else if (Array.isArray(val2)) {\r\n      if (val2.length && !isPrimitive(val2[0])) {\r\n        for (let i = 0; i < val2.length; i++) {\r\n          if (val1[i] !== undefined)\r\n            deepAssign(val1[i], val2[i]);\r\n          else\r\n            val1.push(val2[i]);\r\n        }\r\n        (val1 as any[]).splice(val2.length);\r\n      }\r\n      else\r\n        //(val2 as any[]).splice(0, val2.length, ...val);\r\n        o1[p] = val2;\r\n    }\r\n    else //if (isObject(val2))\r\n      deepAssign(val1, val2);\r\n  });\r\n  return o1;\r\n}\r\n\r\nfunction generateEncryptionMap(): { [key: string]: string | number } {\r\n  const values = {};\r\n  for (let i = 65; i < 91; i++) {\r\n    const d = (i - 65).toString(),\r\n      c = String.fromCharCode(i);\r\n    values[d] = c;\r\n    values[c] = d;\r\n  }\r\n  for (let i = 97; i < 123; i++) {\r\n    const d = (i - 71).toString(),\r\n      c = String.fromCharCode(i);\r\n    values[d] = c;\r\n    values[c] = d;\r\n  }\r\n  return values;\r\n}\r\nconst decode = generateEncryptionMap();\r\ndeclare global {\r\n  interface String {\r\n    decodeId: () => number;\r\n  }\r\n  interface Number {\r\n    encodeId: () => string;\r\n  }\r\n}\r\nString.prototype.decodeId = function (): number {\r\n  let v = '';\r\n  for (let i = 0; i < this.length; i++) {\r\n    const c = this.charAt(i);\r\n    v += decode[c];\r\n  }\r\n  return parseInt(v);\r\n};\r\nNumber.prototype.encodeId = function (): string {\r\n  let v = '',\r\n    d = this.toString();\r\n  while (d.length > 0) {\r\n    let i = 51,\r\n      c = i.toString();\r\n    while (!d.startsWith(c)) {\r\n      --i, c = i.toString();\r\n    } v += decode[c];\r\n    d = d.substring(c.length);\r\n  }\r\n  return v;\r\n};\r\n\r\n/** global extended array functions */\r\n(window as any).global = window;\r\ndeclare global {\r\n  interface Array<T> {\r\n    remove(item: T): T[];\r\n    last(): T;\r\n    average(predicate: (i: T) => number): number;\r\n    distinct<M>(predicate: (i: T) => M): Set<M>;\r\n    sum(predicate: (i: T) => number): number;\r\n    max(predicate: (i: T) => number): number;\r\n  }\r\n  interface String {\r\n    formatArgs(...args): string;\r\n    normalize(): string;\r\n  }\r\n}\r\nString.prototype.normalize = function () {\r\n  return this.replace(/ /g, '_').replace(/[^\\w]/g, '').toLowerCase();\r\n}\r\n\r\nString.prototype.formatArgs = function (...args): string {\r\n  return this.replace(/{(\\d+)}/g, (_, index) => args[index] || '');\r\n}\r\nArray.prototype.last = function () {\r\n  return this[this.length - 1];\r\n}\r\n/** remove element from array */\r\nArray.prototype.remove = function <T>(value: T): T[] {\r\n  const index = this.indexOf(value);\r\n  if (index > -1) this.splice(index, 1);\r\n  return this;\r\n};\r\n/** calculate average using element predicate */\r\nArray.prototype.average = function <T>(predicate?: (i: T) => number): number {\r\n  let average = 0;\r\n  this.forEach(i =>\r\n    average += predicate(i)\r\n  );\r\n  return average !== 0 ? average / this.length : 0;\r\n}\r\nArray.prototype.distinct = function <T, M>(predicate?: (i: T) => M): Set<M> {\r\n  const values = new Set<M>();\r\n  this.forEach(i =>\r\n    values.add(predicate(i))\r\n  );\r\n  return values;\r\n}\r\nArray.prototype.max = function <T>(predicate?: (i: T) => number): number {\r\n  let n = 0;\r\n  this.forEach(i =>\r\n    n = Math.max(n, predicate(i))\r\n  );\r\n  return n;\r\n}\r\n/** sum elements using predicate */\r\nArray.prototype.sum = function <T>(predicate?: (i: T) => number): number {\r\n  let n = 0;\r\n  this.forEach(i =>\r\n    n += predicate(i)\r\n  );\r\n  return n;\r\n}\r\n/**\r\n * \r\n * @param args\r\n */\r\nexport function queryParams(args: any) {\r\n  const params = {};\r\n  args &&\r\n    Object.keys(args).forEach(k => {\r\n      const val = args[k];\r\n\r\n      if (val !== null && val !== undefined) {\r\n        if (isString(val))\r\n          params[k] = val;\r\n        else if (isArray(val) && val.length)\r\n          params[k] = val;\r\n        else if (isDate(val))\r\n          params[k] = val.toJSON();\r\n        else if (isObject(val)) {\r\n          if (Object.keys(val).length) params[k] = queryParams(val);\r\n        }\r\n        else\r\n          params[k] = val;\r\n      }\r\n    });\r\n  return params;\r\n}\r\nfunction getParameterByName(name, url = window.location.href) {\r\n  name = name.replace(/[\\[\\]]/g, '\\\\$&');\r\n  var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),\r\n    results = regex.exec(url);\r\n  if (!results) return null;\r\n  if (!results[2]) return '';\r\n  return decodeURIComponent(results[2].replace(/\\+/g, ' '));\r\n}\r\n"]}

package/esm2020/lib/core/guide/guide.component.mjs

@@ -0,0 +1,231 @@
+import { Inject, Component, ElementRef, InjectionToken, HostListener } from '@angular/core';
+import { trigger, state, style, transition, animate } from '@angular/animations';
+import { ESCAPE, LEFT_ARROW, RIGHT_ARROW } from '@angular/cdk/keycodes';
+import { outOfBound } from '../functions';
+import * as i0 from "@angular/core";
+import * as i1 from "../session.service";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/flex-layout/flex";
+import * as i7 from "@angular/common";
+import * as i8 from "../pipes/sanitize-html.pipe";
+import * as i9 from "../pipes/translate.pipe";
+export const TOUR_TOKEN = new InjectionToken('guide');
+const BELOW = [{
+        originX: 'start',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'top',
+        panelClass: ['below', 'start']
+    }, {
+        originX: 'center',
+        originY: 'bottom',
+        overlayX: 'center',
+        overlayY: 'top',
+        panelClass: ['below', 'center']
+    }, {
+        originX: 'end',
+        originY: 'bottom',
+        overlayX: 'end',
+        overlayY: 'top',
+        panelClass: ['below', 'end']
+    }], ABOVE = [{
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'start',
+        overlayY: 'bottom',
+        panelClass: ['above', 'start']
+    },
+    {
+        originX: 'center',
+        originY: 'top',
+        overlayX: 'center',
+        overlayY: 'bottom',
+        panelClass: ['above', 'center']
+    },
+    {
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'end',
+        overlayY: 'bottom',
+        panelClass: ['above', 'end']
+    }], AFTER = [{
+        originX: 'end',
+        originY: 'top',
+        overlayX: 'start',
+        overlayY: 'top',
+        panelClass: ['after', 'start']
+    },
+    {
+        originX: 'end',
+        originY: 'center',
+        overlayX: 'start',
+        overlayY: 'center',
+        panelClass: ['after', 'center']
+    },
+    {
+        originX: 'end',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'bottom',
+        panelClass: ['after', 'end']
+    }], BEFORE = [{
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'end',
+        overlayY: 'top',
+        panelClass: ['before', 'start']
+    }, {
+        originX: 'start',
+        originY: 'center',
+        overlayX: 'end',
+        overlayY: 'center',
+        panelClass: ['before', 'center']
+    }, {
+        originX: 'start',
+        originY: 'center',
+        overlayX: 'end',
+        overlayY: 'bottom',
+        panelClass: ['before', 'end']
+    }];
+export class GuideComponent {
+    constructor(_data, _session, _overlay, _ngRouter, _overlayRef) {
+        this._data = _data;
+        this._session = _session;
+        this._overlay = _overlay;
+        this._ngRouter = _ngRouter;
+        this._overlayRef = _overlayRef;
+        this.index = -1;
+        this.count = this._data.steps.length;
+        this.working = true;
+    }
+    ngOnInit() {
+        if (this._data.name) {
+            const lastindex = localStorage.getItem(this._data.name + '_guide_step');
+            if (lastindex) {
+                this.index = Number.parseInt(lastindex);
+            }
+        }
+        this._moveBy(1);
+    }
+    /**
+     *
+     * @param steps
+     */
+    _moveBy(steps) {
+        const index = this.index + steps;
+        if ((index < 0) || (index > this.count - 1)) {
+            localStorage.removeItem(this._data.name + '_guide_step');
+            return;
+        }
+        this.working = true;
+        const step = this._data.steps[index];
+        const { selector, position, navigate, simulate } = step, promisses = [];
+        if (navigate) {
+            const promise = this._ngRouter.navigateByUrl(navigate);
+            promisses.push(promise);
+        }
+        let positionStrategy;
+        if (selector) {
+            const element = document.querySelector(selector);
+            if (!element) {
+                console.warn(`Guide ${this._data.name} selector '${selector}' not found. skipping.`);
+                //this._moveBy(steps);
+                return;
+            }
+            let positions;
+            switch (position) {
+                case 'Above':
+                    positions = [...ABOVE, ...BELOW, ...AFTER, ...BEFORE];
+                    break;
+                case 'End':
+                    positions = [...AFTER, ...BEFORE, ...BELOW, ...ABOVE];
+                    break;
+                case 'Start':
+                    positions = [...BEFORE, ...AFTER, ...BELOW, ...ABOVE];
+                    break;
+                case 'Below':
+                    positions = [...BELOW, ...BEFORE, ...ABOVE, ...AFTER];
+                    break;
+                default:
+                    positions = [...BEFORE, ...BELOW, ...ABOVE, ...AFTER];
+            }
+            positionStrategy = this._overlay.position().
+                flexibleConnectedTo(new ElementRef(element)).
+                withPositions(positions).
+                withGrowAfterOpen();
+            if (outOfBound(element)) {
+                promisses.push(new Promise(resolve => {
+                    const task = setInterval(() => {
+                        if (!outOfBound(element)) {
+                            clearInterval(task);
+                            resolve(null);
+                        }
+                    }, 150);
+                }));
+                element.scrollIntoView({ behavior: 'smooth' });
+            }
+            simulate &&
+                promisses.push(new Promise(resolve => {
+                    element.click();
+                    resolve(null);
+                }));
+        }
+        else
+            positionStrategy = this._overlay.position().global().centerVertically().centerHorizontally();
+        const complete = () => {
+            this._data.name && localStorage.setItem(this._data.name + '_guide_step', this.index.toString());
+            this.index = index;
+            this.step = step;
+            this.working = false;
+            this._overlayRef.updatePositionStrategy(positionStrategy);
+            this._overlayRef.updatePosition();
+        };
+        promisses.length ? Promise.all(promisses).then(() => complete()) : complete();
+    }
+    keydown(evt) {
+        if (!this.working)
+            switch (evt.keyCode) {
+                case LEFT_ARROW:
+                    this._moveBy(this._session.direction === 'ltr' ? -1 : 1);
+                    break;
+                case RIGHT_ARROW:
+                    this._moveBy(this._session.direction === 'ltr' ? 1 : -1);
+                    break;
+                case ESCAPE:
+                    this.close();
+                    evt.stopPropagation();
+                    break;
+            }
+    }
+    next() {
+        this._moveBy(1);
+    }
+    prev() {
+        this._moveBy(-1);
+    }
+    close() {
+        this._overlayRef.detach();
+    }
+}
+GuideComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: GuideComponent, deps: [{ token: TOUR_TOKEN }, { token: i1.SessionService }, { token: i2.Overlay }, { token: i3.Router }, { token: i2.OverlayRef }], target: i0.ɵɵFactoryTarget.Component });
+GuideComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: GuideComponent, selector: "ng-component", host: { listeners: { "window:keydown": "keydown($event)" } }, ngImport: i0, template: "<div class=\"container\" [style.display]=\"step ? '': 'none'\" cdkTrapFocus>\r\n  <div fxLayout=\"column\" class=\"content\">\r\n    <div fxLayout=\"row\">\r\n      <h2 *ngIf=\"step?.title\" class=\"mat-h2\">{{step?.title}}</h2>\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"close()\" *ngIf=\"index < count - 1\"><mat-icon>close</mat-icon></button>\r\n    </div>\r\n    <p class=\"mat-body\" [innerHTML]=\"step?.content | sanitizeHtml\">\r\n    </p>\r\n    <div fxLayout=\"row\">\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"prev()\" [disabled]=\"index < 1 || working\"><mat-icon class=\"mat-icon-rtl-mirror\">keyboard_arrow_left</mat-icon></button>\r\n      <button mat-icon-button (click)=\"next()\" [disabled]=\"index >= count - 1 || working\" cdkFocusInitial><mat-icon class=\"mat-icon-rtl-mirror\">keyboard_arrow_right</mat-icon></button>\r\n      <button mat-button (click)=\"close()\" *ngIf=\"index >= count - 1\">{{'GuideFinish'|translate}}</button>\r\n    </div>\r\n  </div>\r\n  <div class=\"tooltip-container\">\r\n    <div class=\"tooltip\"></div>\r\n  </div>\r\n</div>\r\n", components: [{ type: i4.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i6.DefaultLayoutDirective, selector: "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", inputs: ["fxLayout", "fxLayout.xs", "fxLayout.sm", "fxLayout.md", "fxLayout.lg", "fxLayout.xl", "fxLayout.lt-sm", "fxLayout.lt-md", "fxLayout.lt-lg", "fxLayout.lt-xl", "fxLayout.gt-xs", "fxLayout.gt-sm", "fxLayout.gt-md", "fxLayout.gt-lg"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "sanitizeHtml": i8.SanitizeHtmlPipe, "translate": i9.TranslatePipe }, animations: [trigger('body', [
+            state('here', style({ width: '*', height: '*' })),
+            transition('*<=>*', animate('250ms', style({})))
+        ])] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: GuideComponent, decorators: [{
+            type: Component,
+            args: [{ animations: [trigger('body', [
+                            state('here', style({ width: '*', height: '*' })),
+                            transition('*<=>*', animate('250ms', style({})))
+                        ])], template: "<div class=\"container\" [style.display]=\"step ? '': 'none'\" cdkTrapFocus>\r\n  <div fxLayout=\"column\" class=\"content\">\r\n    <div fxLayout=\"row\">\r\n      <h2 *ngIf=\"step?.title\" class=\"mat-h2\">{{step?.title}}</h2>\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"close()\" *ngIf=\"index < count - 1\"><mat-icon>close</mat-icon></button>\r\n    </div>\r\n    <p class=\"mat-body\" [innerHTML]=\"step?.content | sanitizeHtml\">\r\n    </p>\r\n    <div fxLayout=\"row\">\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"prev()\" [disabled]=\"index < 1 || working\"><mat-icon class=\"mat-icon-rtl-mirror\">keyboard_arrow_left</mat-icon></button>\r\n      <button mat-icon-button (click)=\"next()\" [disabled]=\"index >= count - 1 || working\" cdkFocusInitial><mat-icon class=\"mat-icon-rtl-mirror\">keyboard_arrow_right</mat-icon></button>\r\n      <button mat-button (click)=\"close()\" *ngIf=\"index >= count - 1\">{{'GuideFinish'|translate}}</button>\r\n    </div>\r\n  </div>\r\n  <div class=\"tooltip-container\">\r\n    <div class=\"tooltip\"></div>\r\n  </div>\r\n</div>\r\n" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TOUR_TOKEN]
+                }] }, { type: i1.SessionService }, { type: i2.Overlay }, { type: i3.Router }, { type: i2.OverlayRef }]; }, propDecorators: { keydown: [{
+                type: HostListener,
+                args: ['window:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guide.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/guide/guide.component.ts","../../../../../../libraries/core/src/lib/core/guide/guide.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Component, OnInit, ElementRef, InjectionToken, HostListener } from '@angular/core';\r\nimport { Overlay, OverlayRef, PositionStrategy, ConnectedPosition } from \"@angular/cdk/overlay\";\r\nimport { trigger, state, style, transition, animate } from '@angular/animations';\r\nimport { ESCAPE, LEFT_ARROW, RIGHT_ARROW } from '@angular/cdk/keycodes';\r\nimport { GuideStep, Guide } from '../models';\r\nimport { outOfBound } from '../functions';\r\nimport { Router } from '@angular/router';\r\nimport { SessionService } from '../session.service';\r\n\r\nexport const TOUR_TOKEN = new InjectionToken<Guide>('guide');\r\n\r\nconst BELOW: ConnectedPosition[] = [{\r\n  originX: 'start',\r\n  originY: 'bottom',\r\n  overlayX: 'start',\r\n  overlayY: 'top',\r\n  panelClass: ['below', 'start']\r\n}, {\r\n  originX: 'center',\r\n  originY: 'bottom',\r\n  overlayX: 'center',\r\n  overlayY: 'top',\r\n  panelClass: ['below', 'center']\r\n}, {\r\n  originX: 'end',\r\n  originY: 'bottom',\r\n  overlayX: 'end',\r\n  overlayY: 'top',\r\n  panelClass: ['below', 'end']\r\n}],\r\n  ABOVE: ConnectedPosition[] = [{\r\n    originX: 'start',\r\n    originY: 'top',\r\n    overlayX: 'start',\r\n    overlayY: 'bottom',\r\n    panelClass: ['above', 'start']\r\n  },\r\n  {\r\n    originX: 'center',\r\n    originY: 'top',\r\n    overlayX: 'center',\r\n    overlayY: 'bottom',\r\n    panelClass: ['above', 'center']\r\n  },\r\n  {\r\n    originX: 'start',\r\n    originY: 'top',\r\n    overlayX: 'end',\r\n    overlayY: 'bottom',\r\n    panelClass: ['above', 'end']\r\n  }],\r\n  AFTER: ConnectedPosition[] = [{\r\n    originX: 'end',\r\n    originY: 'top',\r\n    overlayX: 'start',\r\n    overlayY: 'top',\r\n    panelClass: ['after', 'start']\r\n  },\r\n  {\r\n    originX: 'end',\r\n    originY: 'center',\r\n    overlayX: 'start',\r\n    overlayY: 'center',\r\n    panelClass: ['after', 'center']\r\n  },\r\n  {\r\n    originX: 'end',\r\n    originY: 'bottom',\r\n    overlayX: 'start',\r\n    overlayY: 'bottom',\r\n    panelClass: ['after', 'end']\r\n  }],\r\n  BEFORE: ConnectedPosition[] = [{\r\n    originX: 'start',\r\n    originY: 'top',\r\n    overlayX: 'end',\r\n    overlayY: 'top',\r\n    panelClass: ['before', 'start']\r\n  }, {\r\n    originX: 'start',\r\n    originY: 'center',\r\n    overlayX: 'end',\r\n    overlayY: 'center',\r\n    panelClass: ['before', 'center']\r\n  }, {\r\n    originX: 'start',\r\n    originY: 'center',\r\n    overlayX: 'end',\r\n    overlayY: 'bottom',\r\n    panelClass: ['before', 'end']\r\n  }];\r\n\r\n@Component({\r\n  templateUrl: './guide.component.html',\r\n  animations: [trigger('body', [\r\n    state('here', style({ width: '*', height: '*' })),\r\n    transition('*<=>*', animate('250ms', style({})))])]\r\n})\r\nexport class GuideComponent implements OnInit {\r\n  step: GuideStep;\r\n  index = -1;\r\n  readonly count: number = this._data.steps.length;\r\n  working = true;\r\n  constructor(\r\n    @Inject(TOUR_TOKEN)\r\n    private _data: Guide,\r\n    private _session: SessionService,\r\n    private _overlay: Overlay,\r\n    private _ngRouter: Router,\r\n    private _overlayRef: OverlayRef) {\r\n  }\r\n  ngOnInit(): void {\r\n    if (this._data.name) {\r\n      const lastindex = localStorage.getItem(this._data.name + '_guide_step');\r\n      if (lastindex) {\r\n        this.index = Number.parseInt(lastindex);\r\n      }\r\n    }\r\n    this._moveBy(1);\r\n  }\r\n  /**\r\n   * \r\n   * @param steps\r\n   */\r\n  private _moveBy(steps: 1 | -1) {\r\n    const index = this.index + steps;\r\n    if ((index < 0) || (index > this.count - 1)) {\r\n      localStorage.removeItem(this._data.name + '_guide_step');\r\n      return;\r\n    }\r\n    this.working = true;\r\n    const step = this._data.steps[index];\r\n    const { selector, position, navigate, simulate } = step, promisses: Promise<any>[] = [];\r\n    if (navigate) {\r\n      const promise = this._ngRouter.navigateByUrl(navigate);\r\n      promisses.push(promise);\r\n    }\r\n    let positionStrategy: PositionStrategy;\r\n    if (selector) {\r\n      const element = document.querySelector(selector) as HTMLElement;\r\n      if (!element) {\r\n        console.warn(`Guide ${this._data.name} selector '${selector}' not found. skipping.`);\r\n        //this._moveBy(steps);\r\n        return;\r\n      }\r\n      let positions: ConnectedPosition[];\r\n      switch (position) {\r\n        case 'Above':\r\n          positions = [...ABOVE, ...BELOW, ...AFTER, ...BEFORE];\r\n          break;\r\n        case 'End':\r\n          positions = [...AFTER, ...BEFORE, ...BELOW, ...ABOVE];\r\n          break;\r\n        case 'Start':\r\n          positions = [...BEFORE, ...AFTER, ...BELOW, ...ABOVE];\r\n          break;\r\n        case 'Below':\r\n          positions = [...BELOW, ...BEFORE, ...ABOVE, ...AFTER];\r\n          break;\r\n        default:\r\n          positions = [...BEFORE, ...BELOW, ...ABOVE, ...AFTER];\r\n      }\r\n      positionStrategy = this._overlay.position().\r\n        flexibleConnectedTo(new ElementRef(element)).\r\n        withPositions(positions).\r\n        withGrowAfterOpen();\r\n      if (outOfBound(element)) {\r\n        promisses.push(new Promise<any>(resolve => {\r\n          const task = setInterval(() => {\r\n            if (!outOfBound(element)) {\r\n              clearInterval(task);\r\n              resolve(null);\r\n            }\r\n          }, 150);\r\n        }));\r\n        element.scrollIntoView({ behavior: 'smooth' });\r\n      }\r\n      simulate &&\r\n        promisses.push(new Promise(resolve => {\r\n          element.click();\r\n          resolve(null);\r\n        }));\r\n    }\r\n    else positionStrategy = this._overlay.position().global().centerVertically().centerHorizontally();\r\n\r\n    const complete = () => {\r\n      this._data.name && localStorage.setItem(this._data.name + '_guide_step', this.index.toString());\r\n      this.index = index;\r\n      this.step = step;\r\n      this.working = false;\r\n      this._overlayRef.updatePositionStrategy(positionStrategy);\r\n      this._overlayRef.updatePosition();\r\n    };\r\n    promisses.length ? Promise.all(promisses).then(() => complete()) : complete();\r\n  }\r\n  @HostListener('window:keydown', ['$event'])\r\n  keydown(evt: KeyboardEvent) {\r\n    if (!this.working)\r\n      switch (evt.keyCode) {\r\n        case LEFT_ARROW:\r\n          this._moveBy(this._session.direction === 'ltr' ? -1 : 1);\r\n          break;\r\n        case RIGHT_ARROW:\r\n          this._moveBy(this._session.direction === 'ltr' ? 1 : -1);\r\n          break;\r\n        case ESCAPE:\r\n          this.close();\r\n          evt.stopPropagation();\r\n          break;\r\n      }\r\n  }\r\n  next() {\r\n    this._moveBy(1);\r\n  }\r\n  prev() {\r\n    this._moveBy(-1);\r\n  }\r\n  close() {\r\n    this._overlayRef.detach();\r\n  }\r\n}\r\n","<div class=\"container\" [style.display]=\"step ? '': 'none'\" cdkTrapFocus>\r\n  <div fxLayout=\"column\" class=\"content\">\r\n    <div fxLayout=\"row\">\r\n      <h2 *ngIf=\"step?.title\" class=\"mat-h2\">{{step?.title}}</h2>\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"close()\" *ngIf=\"index < count - 1\"><mat-icon>close</mat-icon></button>\r\n    </div>\r\n    <p class=\"mat-body\" [innerHTML]=\"step?.content | sanitizeHtml\">\r\n    </p>\r\n    <div fxLayout=\"row\">\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"prev()\" [disabled]=\"index < 1 || working\"><mat-icon class=\"mat-icon-rtl-mirror\">keyboard_arrow_left</mat-icon></button>\r\n      <button mat-icon-button (click)=\"next()\" [disabled]=\"index >= count - 1 || working\" cdkFocusInitial><mat-icon class=\"mat-icon-rtl-mirror\">keyboard_arrow_right</mat-icon></button>\r\n      <button mat-button (click)=\"close()\" *ngIf=\"index >= count - 1\">{{'GuideFinish'|translate}}</button>\r\n    </div>\r\n  </div>\r\n  <div class=\"tooltip-container\">\r\n    <div class=\"tooltip\"></div>\r\n  </div>\r\n</div>\r\n"]}