@mis-wis/common 0.1.5 → 0.1.7

package/esm2020/lib/components/datepicker/utils-v2/linked-list.class.mjs

@@ -0,0 +1,240 @@
+export class LinkedList {
+    constructor() {
+        this.length = 0;
+        this.asArray = [];
+        // Array methods overriding END
+    }
+    get(position) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            return void 0;
+        }
+        let current = this.head;
+        for (let index = 0; index < position; index++) {
+            current = current.next;
+        }
+        return current.value;
+    }
+    add(value, position = this.length) {
+        if (position < 0 || position > this.length) {
+            throw new Error('Position is out of the list');
+        }
+        /* tslint:disable-next-line: no-any*/
+        const node = {
+            value,
+            next: undefined,
+            previous: undefined
+        };
+        if (this.length === 0) {
+            this.head = node;
+            this.tail = node;
+            this.current = node;
+        }
+        else {
+            if (position === 0) {
+                // first node
+                node.next = this.head;
+                this.head.previous = node;
+                this.head = node;
+            }
+            else if (position === this.length) {
+                // last node
+                this.tail.next = node;
+                node.previous = this.tail;
+                this.tail = node;
+            }
+            else {
+                // node in middle
+                const currentPreviousNode = this.getNode(position - 1);
+                const currentNextNode = currentPreviousNode.next;
+                currentPreviousNode.next = node;
+                currentNextNode.previous = node;
+                node.previous = currentPreviousNode;
+                node.next = currentNextNode;
+            }
+        }
+        this.length++;
+        this.createInternalArrayRepresentation();
+    }
+    remove(position = 0) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            throw new Error('Position is out of the list');
+        }
+        if (position === 0) {
+            // first node
+            this.head = this.head.next;
+            if (this.head) {
+                // there is no second node
+                this.head.previous = undefined;
+            }
+            else {
+                // there is no second node
+                this.tail = undefined;
+            }
+        }
+        else if (position === this.length - 1) {
+            // last node
+            this.tail = this.tail.previous;
+            this.tail.next = undefined;
+        }
+        else {
+            // middle node
+            const removedNode = this.getNode(position);
+            removedNode.next.previous = removedNode.previous;
+            removedNode.previous.next = removedNode.next;
+        }
+        this.length--;
+        this.createInternalArrayRepresentation();
+    }
+    set(position, value) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            throw new Error('Position is out of the list');
+        }
+        const node = this.getNode(position);
+        node.value = value;
+        this.createInternalArrayRepresentation();
+    }
+    toArray() {
+        return this.asArray;
+    }
+    /* tslint:disable-next-line: no-any*/
+    findAll(fn) {
+        let current = this.head;
+        /* tslint:disable-next-line: no-any*/
+        const result = [];
+        for (let index = 0; index < this.length; index++) {
+            if (fn(current.value, index)) {
+                result.push({ index, value: current.value });
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    // Array methods overriding start
+    push(...args) {
+        /* tslint:disable-next-line: no-any*/
+        args.forEach((arg) => {
+            this.add(arg);
+        });
+        return this.length;
+    }
+    pop() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const last = this.tail;
+        this.remove(this.length - 1);
+        return last.value;
+    }
+    unshift(...args) {
+        args.reverse();
+        /* tslint:disable-next-line: no-any*/
+        args.forEach((arg) => {
+            this.add(arg, 0);
+        });
+        return this.length;
+    }
+    shift() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const lastItem = this.head.value;
+        this.remove();
+        return lastItem;
+    }
+    /* tslint:disable-next-line: no-any*/
+    forEach(fn) {
+        let current = this.head;
+        for (let index = 0; index < this.length; index++) {
+            fn(current.value, index);
+            current = current.next;
+        }
+    }
+    indexOf(value) {
+        let current = this.head;
+        let position = 0;
+        for (let index = 0; index < this.length; index++) {
+            if (current.value === value) {
+                position = index;
+                break;
+            }
+            current = current.next;
+        }
+        return position;
+    }
+    /* tslint:disable-next-line: no-any*/
+    some(fn) {
+        let current = this.head;
+        let result = false;
+        while (current && !result) {
+            if (fn(current.value)) {
+                result = true;
+                break;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /* tslint:disable-next-line: no-any*/
+    every(fn) {
+        let current = this.head;
+        let result = true;
+        while (current && result) {
+            if (!fn(current.value)) {
+                result = false;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    toString() {
+        return '[Linked List]';
+    }
+    /* tslint:disable-next-line: no-any*/
+    find(fn) {
+        let current = this.head;
+        let result;
+        for (let index = 0; index < this.length; index++) {
+            if (fn(current.value, index)) {
+                result = current.value;
+                break;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /* tslint:disable-next-line: no-any*/
+    findIndex(fn) {
+        let current = this.head;
+        let result;
+        for (let index = 0; index < this.length; index++) {
+            if (fn(current.value, index)) {
+                result = index;
+                break;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /* tslint:disable-next-line: no-any*/
+    getNode(position) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            throw new Error('Position is out of the list');
+        }
+        let current = this.head;
+        for (let index = 0; index < position; index++) {
+            current = current.next;
+        }
+        return current;
+    }
+    createInternalArrayRepresentation() {
+        /* tslint:disable-next-line: no-any*/
+        const outArray = [];
+        let current = this.head;
+        while (current) {
+            outArray.push(current.value);
+            current = current.next;
+        }
+        this.asArray = outArray;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linked-list.class.js","sourceRoot":"","sources":["../../../../../../../libraries/wis-common/src/lib/components/datepicker/utils-v2/linked-list.class.ts"],"names":[],"mappings":"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","sourcesContent":["export class LinkedList<T> {\n  length = 0;\n  /* tslint:disable-next-line: no-any*/\n  protected head: any;\n  /* tslint:disable-next-line: no-any*/\n  protected tail: any;\n  /* tslint:disable-next-line: no-any*/\n  protected current: any;\n  protected asArray: T[] = [];\n\n  get(position: number): T {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      return void 0;\n    }\n\n    let current = this.head;\n\n    for (let index = 0; index < position; index++) {\n      current = current.next;\n    }\n\n    return current.value;\n  }\n\n  add(value: T, position: number = this.length): void {\n    if (position < 0 || position > this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    /* tslint:disable-next-line: no-any*/\n    const node: any = {\n      value,\n      next: undefined,\n      previous: undefined\n    };\n\n    if (this.length === 0) {\n      this.head = node;\n      this.tail = node;\n      this.current = node;\n    } else {\n      if (position === 0) {\n        // first node\n        node.next = this.head;\n        this.head.previous = node;\n        this.head = node;\n      } else if (position === this.length) {\n        // last node\n        this.tail.next = node;\n        node.previous = this.tail;\n        this.tail = node;\n      } else {\n        // node in middle\n        const currentPreviousNode = this.getNode(position - 1);\n        const currentNextNode = currentPreviousNode.next;\n\n        currentPreviousNode.next = node;\n        currentNextNode.previous = node;\n\n        node.previous = currentPreviousNode;\n        node.next = currentNextNode;\n      }\n    }\n    this.length++;\n    this.createInternalArrayRepresentation();\n  }\n\n  remove(position = 0): void {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    if (position === 0) {\n      // first node\n      this.head = this.head.next;\n\n      if (this.head) {\n        // there is no second node\n        this.head.previous = undefined;\n      } else {\n        // there is no second node\n        this.tail = undefined;\n      }\n    } else if (position === this.length - 1) {\n      // last node\n      this.tail = this.tail.previous;\n      this.tail.next = undefined;\n    } else {\n      // middle node\n      const removedNode = this.getNode(position);\n      removedNode.next.previous = removedNode.previous;\n      removedNode.previous.next = removedNode.next;\n    }\n\n    this.length--;\n    this.createInternalArrayRepresentation();\n  }\n\n  set(position: number, value: T): void {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    const node = this.getNode(position);\n    node.value = value;\n    this.createInternalArrayRepresentation();\n  }\n\n  toArray(): T[] {\n    return this.asArray;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  findAll(fn: any): any[] {\n    let current = this.head;\n    /* tslint:disable-next-line: no-any*/\n    const result: any[] = [];\n    for (let index = 0; index < this.length; index++) {\n      if (fn(current.value, index)) {\n        result.push({index, value: current.value});\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  // Array methods overriding start\n  push(...args: T[]): number {\n    /* tslint:disable-next-line: no-any*/\n    args.forEach((arg: any) => {\n      this.add(arg);\n    });\n\n    return this.length;\n  }\n\n  pop(): T {\n    if (this.length === 0) {\n      return undefined;\n    }\n    const last = this.tail;\n    this.remove(this.length - 1);\n\n    return last.value;\n  }\n\n  unshift(...args: T[]): number {\n    args.reverse();\n    /* tslint:disable-next-line: no-any*/\n    args.forEach((arg: any) => {\n      this.add(arg, 0);\n    });\n\n    return this.length;\n  }\n\n  shift(): T {\n    if (this.length === 0) {\n      return undefined;\n    }\n    const lastItem = this.head.value;\n    this.remove();\n\n    return lastItem;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  forEach(fn: any): void {\n    let current = this.head;\n    for (let index = 0; index < this.length; index++) {\n      fn(current.value, index);\n      current = current.next;\n    }\n  }\n\n  indexOf(value: T): number {\n    let current = this.head;\n    let position = 0;\n\n    for (let index = 0; index < this.length; index++) {\n      if (current.value === value) {\n        position = index;\n        break;\n      }\n      current = current.next;\n    }\n\n    return position;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  some(fn: any): boolean {\n    let current = this.head;\n    let result = false;\n    while (current && !result) {\n      if (fn(current.value)) {\n        result = true;\n        break;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  every(fn: any): boolean {\n    let current = this.head;\n    let result = true;\n    while (current && result) {\n      if (!fn(current.value)) {\n        result = false;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  toString(): string {\n    return '[Linked List]';\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  find(fn: any): T {\n    let current = this.head;\n    let result: T;\n    for (let index = 0; index < this.length; index++) {\n      if (fn(current.value, index)) {\n        result = current.value;\n        break;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  findIndex(fn: any): number {\n    let current = this.head;\n    let result: number;\n    for (let index = 0; index < this.length; index++) {\n      if (fn(current.value, index)) {\n        result = index;\n        break;\n      }\n      current = current.next;\n    }\n\n    return result;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  protected getNode(position: number): any {\n    if (this.length === 0 || position < 0 || position >= this.length) {\n      throw new Error('Position is out of the list');\n    }\n\n    let current = this.head;\n\n    for (let index = 0; index < position; index++) {\n      current = current.next;\n    }\n\n    return current;\n  }\n\n  protected createInternalArrayRepresentation(): void {\n    /* tslint:disable-next-line: no-any*/\n    const outArray: any[] = [];\n    let current = this.head;\n\n    while (current) {\n      outArray.push(current.value);\n      current = current.next;\n    }\n    this.asArray = outArray;\n  }\n\n  // Array methods overriding END\n}\n"]}

package/esm2020/lib/components/datepicker/utils-v2/public_api.mjs

@@ -0,0 +1,11 @@
+export * from './triggers';
+export { isBs3 } from './theme-provider';
+export { LinkedList } from './linked-list.class';
+export { listenToTriggersV2, registerOutsideClick, registerEscClick } from './triggers';
+export { OnChange } from './decorators';
+export { setTheme } from './theme-provider';
+export { Trigger } from './trigger.class';
+export { Utils } from './utils.class';
+export { window, document } from './facade/browser';
+export { warnOnce } from './warn-once';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnJhcmllcy93aXMtY29tbW9uL3NyYy9saWIvY29tcG9uZW50cy9kYXRlcGlja2VyL3V0aWxzLXYyL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVqRCxPQUFPLEVBQ0wsa0JBQWtCLEVBQ2xCLG9CQUFvQixFQUNwQixnQkFBZ0IsRUFDakIsTUFBTSxZQUFZLENBQUM7QUFFcEIsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzFDLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQUssYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90cmlnZ2Vycyc7XG5leHBvcnQgeyBpc0JzMyB9IGZyb20gJy4vdGhlbWUtcHJvdmlkZXInO1xuZXhwb3J0IHsgTGlua2VkTGlzdCB9IGZyb20gJy4vbGlua2VkLWxpc3QuY2xhc3MnO1xuXG5leHBvcnQge1xuICBsaXN0ZW5Ub1RyaWdnZXJzVjIsXG4gIHJlZ2lzdGVyT3V0c2lkZUNsaWNrLFxuICByZWdpc3RlckVzY0NsaWNrXG59IGZyb20gJy4vdHJpZ2dlcnMnO1xuXG5leHBvcnQgeyBPbkNoYW5nZSB9IGZyb20gJy4vZGVjb3JhdG9ycyc7XG5leHBvcnQgeyBzZXRUaGVtZSB9IGZyb20gJy4vdGhlbWUtcHJvdmlkZXInO1xuZXhwb3J0IHsgVHJpZ2dlciB9IGZyb20gJy4vdHJpZ2dlci5jbGFzcyc7XG5leHBvcnQgeyBVdGlscyB9IGZyb20gJy4vdXRpbHMuY2xhc3MnO1xuZXhwb3J0IHsgd2luZG93LCBkb2N1bWVudCB9IGZyb20gJy4vZmFjYWRlL2Jyb3dzZXInO1xuZXhwb3J0IHsgd2Fybk9uY2UgfWZyb20gJy4vd2Fybi1vbmNlJztcbiJdfQ==

package/esm2020/lib/components/datepicker/utils-v2/theme-provider.mjs

@@ -0,0 +1,35 @@
+import { window } from './facade/browser';
+let guessedVersion;
+function _guessBsVersion() {
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    const spanEl = document.createElement('span');
+    spanEl.innerText = 'test bs version';
+    document.body.appendChild(spanEl);
+    spanEl.classList.add('d-none');
+    const rect = spanEl.getBoundingClientRect();
+    document.body.removeChild(spanEl);
+    if (!rect) {
+        return 'bs3';
+    }
+    return rect.top === 0 ? 'bs4' : 'bs3';
+}
+export function setTheme(theme) {
+    guessedVersion = theme;
+}
+// todo: in mis-design-system, bs4 will became a default one
+export function isBs3() {
+    if (typeof window === 'undefined') {
+        return true;
+    }
+    if (typeof window.__theme === 'undefined') {
+        if (guessedVersion) {
+            return guessedVersion === 'bs3';
+        }
+        guessedVersion = _guessBsVersion();
+        return guessedVersion === 'bs3';
+    }
+    return window.__theme !== 'bs4';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/datepicker/utils-v2/trigger.class.mjs

@@ -0,0 +1,10 @@
+export class Trigger {
+    constructor(open, close) {
+        this.open = open;
+        this.close = close || open;
+    }
+    isManual() {
+        return this.open === 'manual' || this.close === 'manual';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJpZ2dlci5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnJhcmllcy93aXMtY29tbW9uL3NyYy9saWIvY29tcG9uZW50cy9kYXRlcGlja2VyL3V0aWxzLXYyL3RyaWdnZXIuY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLE9BQU87SUFJbEIsWUFBWSxJQUFZLEVBQUUsS0FBYztRQUN0QyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssSUFBSSxJQUFJLENBQUM7SUFDN0IsQ0FBQztJQUVELFFBQVE7UUFDTixPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssUUFBUSxJQUFJLElBQUksQ0FBQyxLQUFLLEtBQUssUUFBUSxDQUFDO0lBQzNELENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBUcmlnZ2VyIHtcbiAgb3Blbjogc3RyaW5nO1xuICBjbG9zZT86IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihvcGVuOiBzdHJpbmcsIGNsb3NlPzogc3RyaW5nKSB7XG4gICAgdGhpcy5vcGVuID0gb3BlbjtcbiAgICB0aGlzLmNsb3NlID0gY2xvc2UgfHwgb3BlbjtcbiAgfVxuXG4gIGlzTWFudWFsKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLm9wZW4gPT09ICdtYW51YWwnIHx8IHRoaXMuY2xvc2UgPT09ICdtYW51YWwnO1xuICB9XG59XG4iXX0=

package/esm2020/lib/components/datepicker/utils-v2/triggers.mjs

@@ -0,0 +1,110 @@
+import { Trigger } from './trigger.class';
+const DEFAULT_ALIASES = {
+    hover: ['mouseover', 'mouseout'],
+    focus: ['focusin', 'focusout']
+};
+/* tslint:disable-next-line: no-any */
+export function parseTriggers(triggers, aliases = DEFAULT_ALIASES) {
+    const trimmedTriggers = (triggers || '').trim();
+    if (trimmedTriggers.length === 0) {
+        return [];
+    }
+    const parsedTriggers = trimmedTriggers
+        .split(/\s+/)
+        .map((trigger) => trigger.split(':'))
+        .map((triggerPair) => {
+        const alias = aliases[triggerPair[0]] || triggerPair;
+        return new Trigger(alias[0], alias[1]);
+    });
+    const manualTriggers = parsedTriggers.filter((triggerPair) => triggerPair.isManual());
+    if (manualTriggers.length > 1) {
+        throw new Error('Triggers parse error: only one manual trigger is allowed');
+    }
+    if (manualTriggers.length === 1 && parsedTriggers.length > 1) {
+        throw new Error('Triggers parse error: manual trigger can\'t be mixed with other triggers');
+    }
+    return parsedTriggers;
+}
+export function listenToTriggers(renderer, 
+/* tslint:disable-next-line: no-any */
+target, triggers, showFn, hideFn, toggleFn) {
+    const parsedTriggers = parseTriggers(triggers);
+    /* tslint:disable-next-line: no-any */
+    const listeners = [];
+    if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {
+        return Function.prototype;
+    }
+    parsedTriggers.forEach((trigger) => {
+        if (trigger.open === trigger.close) {
+            listeners.push(renderer.listen(target, trigger.open, toggleFn));
+            return;
+        }
+        listeners.push(renderer.listen(target, trigger.open, showFn), renderer.listen(target, trigger.close, hideFn));
+    });
+    return () => {
+        listeners.forEach((unsubscribeFn) => unsubscribeFn());
+    };
+}
+export function listenToTriggersV2(renderer, options) {
+    const parsedTriggers = parseTriggers(options.triggers);
+    const target = options.target;
+    // do nothing
+    if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {
+        return Function.prototype;
+    }
+    // all listeners
+    /* tslint:disable-next-line: no-any */
+    const listeners = [];
+    // lazy listeners registration
+    const _registerHide = [];
+    const registerHide = () => {
+        // add hide listeners to unregister array
+        _registerHide.forEach((fn) => listeners.push(fn()));
+        // register hide events only once
+        _registerHide.length = 0;
+    };
+    // register open\close\toggle listeners
+    parsedTriggers.forEach((trigger) => {
+        const useToggle = trigger.open === trigger.close;
+        const showFn = useToggle ? options.toggle : options.show;
+        if (!useToggle) {
+            _registerHide.push(() => renderer.listen(target, trigger.close, options.hide));
+        }
+        listeners.push(renderer.listen(target, trigger.open, () => showFn(registerHide)));
+    });
+    return () => {
+        listeners.forEach((unsubscribeFn) => unsubscribeFn());
+    };
+}
+export function registerOutsideClick(renderer, options) {
+    if (!options.outsideClick) {
+        return Function.prototype;
+    }
+    /* tslint:disable-next-line: no-any */
+    return renderer.listen('document', 'click', (event) => {
+        if (options.target && options.target.contains(event.target)) {
+            return undefined;
+        }
+        if (options.targets &&
+            options.targets.some(target => target.contains(event.target))) {
+            return undefined;
+        }
+        options.hide();
+    });
+}
+export function registerEscClick(renderer, options) {
+    if (!options.outsideEsc) {
+        return Function.prototype;
+    }
+    return renderer.listen('document', 'keyup.esc', (event) => {
+        if (options.target && options.target.contains(event.target)) {
+            return undefined;
+        }
+        if (options.targets &&
+            options.targets.some(target => target.contains(event.target))) {
+            return undefined;
+        }
+        options.hide();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"triggers.js","sourceRoot":"","sources":["../../../../../../../libraries/wis-common/src/lib/components/datepicker/utils-v2/triggers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Renderer2 } from '@angular/core';\nimport { Trigger } from './trigger.class';\n\n/* tslint:disable-next-line: no-any */\nexport type BsEventCallback = (event?: any) => boolean | void;\n\nexport interface ListenOptions {\n  target?: HTMLElement;\n  targets?: HTMLElement[];\n  triggers?: string;\n  outsideClick?: boolean;\n  outsideEsc?: boolean;\n  show?: BsEventCallback;\n  hide?: BsEventCallback;\n  toggle?: BsEventCallback;\n}\n\nconst DEFAULT_ALIASES = {\n  hover: ['mouseover', 'mouseout'],\n  focus: ['focusin', 'focusout']\n};\n\n/* tslint:disable-next-line: no-any */\nexport function parseTriggers(triggers: string, aliases: any = DEFAULT_ALIASES): Trigger[] {\n  const trimmedTriggers = (triggers || '').trim();\n\n  if (trimmedTriggers.length === 0) {\n    return [];\n  }\n\n  const parsedTriggers = trimmedTriggers\n    .split(/\\s+/)\n    .map((trigger: string) => trigger.split(':'))\n    .map((triggerPair: string[]) => {\n      const alias = aliases[triggerPair[0]] || triggerPair;\n\n      return new Trigger(alias[0], alias[1]);\n    });\n\n  const manualTriggers = parsedTriggers.filter((triggerPair: Trigger) =>\n    triggerPair.isManual()\n  );\n\n  if (manualTriggers.length > 1) {\n    throw new Error('Triggers parse error: only one manual trigger is allowed');\n  }\n\n  if (manualTriggers.length === 1 && parsedTriggers.length > 1) {\n    throw new Error('Triggers parse error: manual trigger can\\'t be mixed with other triggers');\n  }\n\n  return parsedTriggers;\n}\n\nexport function listenToTriggers(renderer: Renderer2,\n                                 /* tslint:disable-next-line: no-any */\n                                 target: any,\n                                 triggers: string,\n                                 showFn: BsEventCallback,\n                                 hideFn: BsEventCallback,\n                                 toggleFn: BsEventCallback): Function {\n  const parsedTriggers = parseTriggers(triggers);\n  /* tslint:disable-next-line: no-any */\n  const listeners: any[] = [];\n\n  if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {\n    return Function.prototype;\n  }\n\n  parsedTriggers.forEach((trigger: Trigger) => {\n    if (trigger.open === trigger.close) {\n      listeners.push(renderer.listen(target, trigger.open, toggleFn));\n\n      return;\n    }\n\n    listeners.push(\n      renderer.listen(target, trigger.open, showFn),\n      renderer.listen(target, trigger.close, hideFn)\n    );\n  });\n\n  return () => {\n    listeners.forEach((unsubscribeFn: Function) => unsubscribeFn());\n  };\n}\n\nexport function listenToTriggersV2(renderer: Renderer2,\n                                   options: ListenOptions): Function {\n  const parsedTriggers = parseTriggers(options.triggers);\n  const target = options.target;\n  // do nothing\n  if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {\n    return Function.prototype;\n  }\n\n  // all listeners\n  /* tslint:disable-next-line: no-any */\n  const listeners: any[] = [];\n\n  // lazy listeners registration\n  const _registerHide: Function[] = [];\n  const registerHide = () => {\n    // add hide listeners to unregister array\n    _registerHide.forEach((fn: Function) => listeners.push(fn()));\n    // register hide events only once\n    _registerHide.length = 0;\n  };\n\n  // register open\\close\\toggle listeners\n  parsedTriggers.forEach((trigger: Trigger) => {\n    const useToggle = trigger.open === trigger.close;\n    const showFn = useToggle ? options.toggle : options.show;\n\n    if (!useToggle) {\n      _registerHide.push(() =>\n        renderer.listen(target, trigger.close, options.hide)\n      );\n    }\n\n    listeners.push(\n      renderer.listen(target, trigger.open, () => showFn(registerHide))\n    );\n  });\n\n  return () => {\n    listeners.forEach((unsubscribeFn: Function) => unsubscribeFn());\n  };\n}\n\nexport function registerOutsideClick(renderer: Renderer2,\n                                     options: ListenOptions) {\n  if (!options.outsideClick) {\n    return Function.prototype;\n  }\n\n  /* tslint:disable-next-line: no-any */\n  return renderer.listen('document', 'click', (event: any) => {\n    if (options.target && options.target.contains(event.target)) {\n      return undefined;\n    }\n    if (\n      options.targets &&\n      options.targets.some(target => target.contains(event.target))\n    ) {\n      return undefined;\n    }\n\n    options.hide();\n  });\n}\n\nexport function registerEscClick(renderer: Renderer2,\n                                 options: ListenOptions) {\n  if (!options.outsideEsc) {\n    return Function.prototype;\n  }\n\n  return renderer.listen('document', 'keyup.esc', (event: any) => {\n    if (options.target && options.target.contains(event.target)) {\n      return undefined;\n    }\n    if (\n      options.targets &&\n      options.targets.some(target => target.contains(event.target))\n    ) {\n      return undefined;\n    }\n\n    options.hide();\n  });\n}\n"]}

package/esm2020/lib/components/datepicker/utils-v2/utils.class.mjs

@@ -0,0 +1,21 @@
+import { window } from './facade/browser';
+export class Utils {
+    /* tslint:disable-next-line: no-any */
+    static reflow(element) {
+        /* tslint:disable-next-line: no-any */
+        ((bs) => bs)(element.offsetHeight);
+    }
+    // source: https://github.com/jquery/jquery/blob/master/src/css/var/getStyles.js
+    /* tslint:disable-next-line: no-any */
+    static getStyles(elem) {
+        // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
+        // IE throws on elements created in popups
+        // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+        let view = elem.ownerDocument.defaultView;
+        if (!view || !view.opener) {
+            view = window;
+        }
+        return view.getComputedStyle(elem);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJyYXJpZXMvd2lzLWNvbW1vbi9zcmMvbGliL2NvbXBvbmVudHMvZGF0ZXBpY2tlci91dGlscy12Mi91dGlscy5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFMUMsTUFBTSxPQUFPLEtBQUs7SUFDaEIsc0NBQXNDO0lBQ3RDLE1BQU0sQ0FBQyxNQUFNLENBQUMsT0FBWTtRQUN4QixzQ0FBc0M7UUFDdEMsQ0FBQyxDQUFDLEVBQU8sRUFBUSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFFRCxnRkFBZ0Y7SUFDaEYsc0NBQXNDO0lBQ3RDLE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBUztRQUN4Qix1REFBdUQ7UUFDdkQsMENBQTBDO1FBQzFDLCtFQUErRTtRQUMvRSxJQUFJLElBQUksR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQztRQUUxQyxJQUFJLENBQUMsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRTtZQUN6QixJQUFJLEdBQUcsTUFBTSxDQUFDO1NBQ2Y7UUFFRCxPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNyQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB3aW5kb3cgfSBmcm9tICcuL2ZhY2FkZS9icm93c2VyJztcblxuZXhwb3J0IGNsYXNzIFV0aWxzIHtcbiAgLyogdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOiBuby1hbnkgKi9cbiAgc3RhdGljIHJlZmxvdyhlbGVtZW50OiBhbnkpOiB2b2lkIHtcbiAgICAvKiB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6IG5vLWFueSAqL1xuICAgICgoYnM6IGFueSk6IHZvaWQgPT4gYnMpKGVsZW1lbnQub2Zmc2V0SGVpZ2h0KTtcbiAgfVxuXG4gIC8vIHNvdXJjZTogaHR0cHM6Ly9naXRodWIuY29tL2pxdWVyeS9qcXVlcnkvYmxvYi9tYXN0ZXIvc3JjL2Nzcy92YXIvZ2V0U3R5bGVzLmpzXG4gIC8qIHRzbGludDpkaXNhYmxlLW5leHQtbGluZTogbm8tYW55ICovXG4gIHN0YXRpYyBnZXRTdHlsZXMoZWxlbTogYW55KTogYW55IHtcbiAgICAvLyBTdXBwb3J0OiBJRSA8PTExIG9ubHksIEZpcmVmb3ggPD0zMCAoIzE1MDk4LCAjMTQxNTApXG4gICAgLy8gSUUgdGhyb3dzIG9uIGVsZW1lbnRzIGNyZWF0ZWQgaW4gcG9wdXBzXG4gICAgLy8gRkYgbWVhbndoaWxlIHRocm93cyBvbiBmcmFtZSBlbGVtZW50cyB0aHJvdWdoIFwiZGVmYXVsdFZpZXcuZ2V0Q29tcHV0ZWRTdHlsZVwiXG4gICAgbGV0IHZpZXcgPSBlbGVtLm93bmVyRG9jdW1lbnQuZGVmYXVsdFZpZXc7XG5cbiAgICBpZiAoIXZpZXcgfHwgIXZpZXcub3BlbmVyKSB7XG4gICAgICB2aWV3ID0gd2luZG93O1xuICAgIH1cblxuICAgIHJldHVybiB2aWV3LmdldENvbXB1dGVkU3R5bGUoZWxlbSk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/components/datepicker/utils-v2/warn-once.mjs

@@ -0,0 +1,12 @@
+import { isDevMode } from '@angular/core';
+const _messagesHash = {};
+const _hideMsg = typeof console === 'undefined' || !('warn' in console);
+export function warnOnce(msg) {
+    if (!isDevMode() || _hideMsg || msg in _messagesHash) {
+        return;
+    }
+    _messagesHash[msg] = true;
+    /*tslint:disable-next-line*/
+    console.warn(msg);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Fybi1vbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicmFyaWVzL3dpcy1jb21tb24vc3JjL2xpYi9jb21wb25lbnRzL2RhdGVwaWNrZXIvdXRpbHMtdjIvd2Fybi1vbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDMUMsTUFBTSxhQUFhLEdBQStCLEVBQUUsQ0FBQztBQUNyRCxNQUFNLFFBQVEsR0FBRyxPQUFPLE9BQU8sS0FBSyxXQUFXLElBQUksQ0FBQyxDQUFDLE1BQU0sSUFBSSxPQUFPLENBQUMsQ0FBQztBQUV4RSxNQUFNLFVBQVUsUUFBUSxDQUFDLEdBQVc7SUFDbEMsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLFFBQVEsSUFBSSxHQUFHLElBQUksYUFBYSxFQUFFO1FBQ3BELE9BQU87S0FDUjtJQUVELGFBQWEsQ0FBQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUM7SUFDMUIsNEJBQTRCO0lBQzVCLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDcEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGlzRGV2TW9kZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuY29uc3QgX21lc3NhZ2VzSGFzaDogeyBba2V5OiBzdHJpbmddOiBib29sZWFuIH0gPSB7fTtcbmNvbnN0IF9oaWRlTXNnID0gdHlwZW9mIGNvbnNvbGUgPT09ICd1bmRlZmluZWQnIHx8ICEoJ3dhcm4nIGluIGNvbnNvbGUpO1xuXG5leHBvcnQgZnVuY3Rpb24gd2Fybk9uY2UobXNnOiBzdHJpbmcpOiB2b2lkIHtcbiAgaWYgKCFpc0Rldk1vZGUoKSB8fCBfaGlkZU1zZyB8fCBtc2cgaW4gX21lc3NhZ2VzSGFzaCkge1xuICAgIHJldHVybjtcbiAgfVxuXG4gIF9tZXNzYWdlc0hhc2hbbXNnXSA9IHRydWU7XG4gIC8qdHNsaW50OmRpc2FibGUtbmV4dC1saW5lKi9cbiAgY29uc29sZS53YXJuKG1zZyk7XG59XG4iXX0=