ngx-bootstrap 3.0.1 → 3.1.4

package/utils/fesm2015/ngx-bootstrap-utils.js

@@ -0,0 +1,650 @@
+import { isDevMode } from '@angular/core';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @copyright Valor Software
+ * @copyright Angular ng-bootstrap team
+ */
+class Trigger {
+    /**
+     * @param {?} open
+     * @param {?=} close
+     */
+    constructor(open, close) {
+        this.open = open;
+        this.close = close || open;
+    }
+    /**
+     * @return {?}
+     */
+    isManual() {
+        return this.open === 'manual' || this.close === 'manual';
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+const /** @type {?} */ DEFAULT_ALIASES = {
+    hover: ['mouseover', 'mouseout'],
+    focus: ['focusin', 'focusout']
+};
+/**
+ * @param {?} triggers
+ * @param {?=} aliases
+ * @return {?}
+ */
+function parseTriggers(triggers, aliases = DEFAULT_ALIASES) {
+    const /** @type {?} */ trimmedTriggers = (triggers || '').trim();
+    if (trimmedTriggers.length === 0) {
+        return [];
+    }
+    const /** @type {?} */ parsedTriggers = trimmedTriggers
+        .split(/\s+/)
+        .map((trigger) => trigger.split(':'))
+        .map((triggerPair) => {
+        const /** @type {?} */ alias = aliases[triggerPair[0]] || triggerPair;
+        return new Trigger(alias[0], alias[1]);
+    });
+    const /** @type {?} */ 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;
+}
+/**
+ * @param {?} renderer
+ * @param {?} target
+ * @param {?} triggers
+ * @param {?} showFn
+ * @param {?} hideFn
+ * @param {?} toggleFn
+ * @return {?}
+ */
+function listenToTriggers(renderer, /* tslint:disable-next-line: no-any */
+/* tslint:disable-next-line: no-any */
+target, triggers, showFn, hideFn, toggleFn) {
+    const /** @type {?} */ parsedTriggers = parseTriggers(triggers);
+    /* tslint:disable-next-line: no-any */
+    const /** @type {?} */ 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());
+    };
+}
+/**
+ * @param {?} renderer
+ * @param {?} options
+ * @return {?}
+ */
+function listenToTriggersV2(renderer, options) {
+    const /** @type {?} */ parsedTriggers = parseTriggers(options.triggers);
+    const /** @type {?} */ target = options.target;
+    // do nothing
+    if (parsedTriggers.length === 1 && parsedTriggers[0].isManual()) {
+        return Function.prototype;
+    }
+    // all listeners
+    /* tslint:disable-next-line: no-any */
+    const /** @type {?} */ listeners = [];
+    // lazy listeners registration
+    const /** @type {?} */ _registerHide = [];
+    const /** @type {?} */ 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 /** @type {?} */ useToggle = trigger.open === trigger.close;
+        const /** @type {?} */ 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());
+    };
+}
+/**
+ * @param {?} renderer
+ * @param {?} options
+ * @return {?}
+ */
+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();
+    });
+}
+/**
+ * @param {?} renderer
+ * @param {?} options
+ * @return {?}
+ */
+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();
+    });
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * JS version of browser APIs. This library can only run in the browser.
+ */
+const /** @type {?} */ win = (typeof window !== 'undefined' && window) || /** @type {?} */ ({});
+const /** @type {?} */ document$1 = win.document;
+const /** @type {?} */ location = win.location;
+const /** @type {?} */ gc = win.gc ? () => win.gc() : () => null;
+const /** @type {?} */ performance = win.performance ? win.performance : null;
+const /** @type {?} */ Event = win.Event;
+const /** @type {?} */ MouseEvent = win.MouseEvent;
+const /** @type {?} */ KeyboardEvent = win.KeyboardEvent;
+const /** @type {?} */ EventTarget = win.EventTarget;
+const /** @type {?} */ History = win.History;
+const /** @type {?} */ Location = win.Location;
+const /** @type {?} */ EventListener = win.EventListener;
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+let /** @type {?} */ guessedVersion;
+/**
+ * @return {?}
+ */
+function _guessBsVersion() {
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    const /** @type {?} */ spanEl = document.createElement('span');
+    spanEl.innerText = 'test bs version';
+    document.body.appendChild(spanEl);
+    spanEl.classList.add('d-none');
+    const /** @type {?} */ rect = spanEl.getBoundingClientRect();
+    document.body.removeChild(spanEl);
+    if (!rect) {
+        return 'bs3';
+    }
+    return rect.top === 0 ? 'bs4' : 'bs3';
+}
+/**
+ * @param {?} theme
+ * @return {?}
+ */
+function setTheme(theme) {
+    guessedVersion = theme;
+}
+/**
+ * @return {?}
+ */
+function isBs3() {
+    if (typeof win === 'undefined') {
+        return true;
+    }
+    if (typeof win.__theme === 'undefined') {
+        if (guessedVersion) {
+            return guessedVersion === 'bs3';
+        }
+        guessedVersion = _guessBsVersion();
+        return guessedVersion === 'bs3';
+    }
+    return win.__theme !== 'bs4';
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @template T
+ */
+class LinkedList {
+    constructor() {
+        this.length = 0;
+        this.asArray = [];
+    }
+    /**
+     * @param {?} position
+     * @return {?}
+     */
+    get(position) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            return void 0;
+        }
+        let /** @type {?} */ current = this.head;
+        for (let /** @type {?} */ index = 0; index < position; index++) {
+            current = current.next;
+        }
+        return current.value;
+    }
+    /**
+     * @param {?} value
+     * @param {?=} position
+     * @return {?}
+     */
+    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 /** @type {?} */ 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 /** @type {?} */ currentPreviousNode = this.getNode(position - 1);
+                const /** @type {?} */ currentNextNode = currentPreviousNode.next;
+                currentPreviousNode.next = node;
+                currentNextNode.previous = node;
+                node.previous = currentPreviousNode;
+                node.next = currentNextNode;
+            }
+        }
+        this.length++;
+        this.createInternalArrayRepresentation();
+    }
+    /**
+     * @param {?=} position
+     * @return {?}
+     */
+    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 /** @type {?} */ removedNode = this.getNode(position);
+            removedNode.next.previous = removedNode.previous;
+            removedNode.previous.next = removedNode.next;
+        }
+        this.length--;
+        this.createInternalArrayRepresentation();
+    }
+    /**
+     * @param {?} position
+     * @param {?} value
+     * @return {?}
+     */
+    set(position, value) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            throw new Error('Position is out of the list');
+        }
+        const /** @type {?} */ node = this.getNode(position);
+        node.value = value;
+        this.createInternalArrayRepresentation();
+    }
+    /**
+     * @return {?}
+     */
+    toArray() {
+        return this.asArray;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    findAll(fn) {
+        let /** @type {?} */ current = this.head;
+        /* tslint:disable-next-line: no-any*/
+        const /** @type {?} */ result = [];
+        for (let /** @type {?} */ index = 0; index < this.length; index++) {
+            if (fn(current.value, index)) {
+                result.push({ index, value: current.value });
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * @param {...?} args
+     * @return {?}
+     */
+    push(...args) {
+        /* tslint:disable-next-line: no-any*/
+        args.forEach((arg) => {
+            this.add(arg);
+        });
+        return this.length;
+    }
+    /**
+     * @return {?}
+     */
+    pop() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const /** @type {?} */ last = this.tail;
+        this.remove(this.length - 1);
+        return last.value;
+    }
+    /**
+     * @param {...?} args
+     * @return {?}
+     */
+    unshift(...args) {
+        args.reverse();
+        /* tslint:disable-next-line: no-any*/
+        args.forEach((arg) => {
+            this.add(arg, 0);
+        });
+        return this.length;
+    }
+    /**
+     * @return {?}
+     */
+    shift() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const /** @type {?} */ lastItem = this.head.value;
+        this.remove();
+        return lastItem;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    forEach(fn) {
+        let /** @type {?} */ current = this.head;
+        for (let /** @type {?} */ index = 0; index < this.length; index++) {
+            fn(current.value, index);
+            current = current.next;
+        }
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    indexOf(value) {
+        let /** @type {?} */ current = this.head;
+        let /** @type {?} */ position = 0;
+        for (let /** @type {?} */ index = 0; index < this.length; index++) {
+            if (current.value === value) {
+                position = index;
+                break;
+            }
+            current = current.next;
+        }
+        return position;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    some(fn) {
+        let /** @type {?} */ current = this.head;
+        let /** @type {?} */ result = false;
+        while (current && !result) {
+            if (fn(current.value)) {
+                result = true;
+                break;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    every(fn) {
+        let /** @type {?} */ current = this.head;
+        let /** @type {?} */ result = true;
+        while (current && result) {
+            if (!fn(current.value)) {
+                result = false;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * @return {?}
+     */
+    toString() {
+        return '[Linked List]';
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    find(fn) {
+        let /** @type {?} */ current = this.head;
+        let /** @type {?} */ result;
+        for (let /** @type {?} */ index = 0; index < this.length; index++) {
+            if (fn(current.value, index)) {
+                result = current.value;
+                break;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    findIndex(fn) {
+        let /** @type {?} */ current = this.head;
+        let /** @type {?} */ result;
+        for (let /** @type {?} */ index = 0; index < this.length; index++) {
+            if (fn(current.value, index)) {
+                result = index;
+                break;
+            }
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * @param {?} position
+     * @return {?}
+     */
+    getNode(position) {
+        if (this.length === 0 || position < 0 || position >= this.length) {
+            throw new Error('Position is out of the list');
+        }
+        let /** @type {?} */ current = this.head;
+        for (let /** @type {?} */ index = 0; index < position; index++) {
+            current = current.next;
+        }
+        return current;
+    }
+    /**
+     * @return {?}
+     */
+    createInternalArrayRepresentation() {
+        /* tslint:disable-next-line: no-any*/
+        const /** @type {?} */ outArray = [];
+        let /** @type {?} */ current = this.head;
+        while (current) {
+            outArray.push(current.value);
+            current = current.next;
+        }
+        this.asArray = outArray;
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?=} defaultValue
+ * @return {?}
+ */
+function OnChange(defaultValue) {
+    const /** @type {?} */ sufix = 'Change';
+    /* tslint:disable-next-line: no-any */
+    return function OnChangeHandler(target, propertyKey) {
+        const /** @type {?} */ _key = ` __${propertyKey}Value`;
+        Object.defineProperty(target, propertyKey, {
+            /**
+             * @return {?}
+             */
+            get() {
+                return this[_key];
+            },
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            set(value) {
+                const /** @type {?} */ prevValue = this[_key];
+                this[_key] = value;
+                if (prevValue !== value && this[propertyKey + sufix]) {
+                    this[propertyKey + sufix].emit(value);
+                }
+            }
+        });
+    };
+}
+/* tslint:enable */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+class Utils {
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    static reflow(element) {
+        /* tslint:disable-next-line: no-any */
+        ((bs) => bs)(element.offsetHeight);
+    }
+    /**
+     * @param {?} elem
+     * @return {?}
+     */
+    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 /** @type {?} */ view = elem.ownerDocument.defaultView;
+        if (!view || !view.opener) {
+            view = win;
+        }
+        return view.getComputedStyle(elem);
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+const /** @type {?} */ _messagesHash = {};
+const /** @type {?} */ _hideMsg = typeof console === 'undefined' || !('warn' in console);
+/**
+ * @param {?} msg
+ * @return {?}
+ */
+function warnOnce(msg) {
+    if (!isDevMode() || _hideMsg || msg in _messagesHash) {
+        return;
+    }
+    _messagesHash[msg] = true;
+    /*tslint:disable-next-line*/
+    console.warn(msg);
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+export { isBs3, LinkedList, listenToTriggersV2, registerOutsideClick, registerEscClick, OnChange, setTheme, Trigger, Utils, win as window, document$1 as document, warnOnce, parseTriggers, listenToTriggers };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-utils.js.map","sources":["ng://ngx-bootstrap/utils/trigger.class.ts","ng://ngx-bootstrap/utils/triggers.ts","ng://ngx-bootstrap/utils/facade/browser.ts","ng://ngx-bootstrap/utils/theme-provider.ts","ng://ngx-bootstrap/utils/linked-list.class.ts","ng://ngx-bootstrap/utils/decorators.ts","ng://ngx-bootstrap/utils/utils.class.ts","ng://ngx-bootstrap/utils/warn-once.ts"],"sourcesContent":["/**\n * @copyright Valor Software\n * @copyright Angular ng-bootstrap team\n */\n\nexport class Trigger {\n  open: string;\n  close?: string;\n\n  constructor(open: string, close?: string) {\n    this.open = open;\n    this.close = close || open;\n  }\n\n  isManual(): boolean {\n    return this.open === 'manual' || this.close === 'manual';\n  }\n}\n","/**\n * @copyright Valor Software\n * @copyright Angular ng-bootstrap team\n */\nimport { 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","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * JS version of browser APIs. This library can only run in the browser.\n */\nconst win = (typeof window !== 'undefined' && window) || {} as any;\n\nexport { win as window };\nexport const document = win.document;\nexport const location = win.location;\nexport const gc = win.gc ? () => win.gc() : (): any => null;\nexport const performance = win.performance ? win.performance : null;\nexport const Event = win.Event;\nexport const MouseEvent = win.MouseEvent;\nexport const KeyboardEvent = win.KeyboardEvent;\nexport const EventTarget = win.EventTarget;\nexport const History = win.History;\nexport const Location = win.Location;\nexport const EventListener = win.EventListener;\n","import { window } from './facade/browser';\n\nlet guessedVersion: 'bs3' | 'bs4';\n\nfunction _guessBsVersion(): 'bs3' | 'bs4' {\n  if (typeof document === 'undefined') {\n    return null;\n  }\n  const spanEl = document.createElement('span');\n  spanEl.innerText = 'test bs version';\n  document.body.appendChild(spanEl);\n  spanEl.classList.add('d-none');\n  const rect = spanEl.getBoundingClientRect();\n  document.body.removeChild(spanEl);\n  if (!rect) {\n    return 'bs3';\n  }\n\n  return rect.top === 0 ? 'bs4' : 'bs3';\n}\n\nexport function setTheme(theme: 'bs3' | 'bs4'): void {\n  guessedVersion = theme;\n}\n\n// todo: in ngx-bootstrap, bs4 will became a default one\nexport function isBs3(): boolean {\n  if (typeof window === 'undefined') {\n    return true;\n  }\n\n  if (typeof window.__theme === 'undefined') {\n    if (guessedVersion) {\n      return guessedVersion === 'bs3';\n    }\n    guessedVersion = _guessBsVersion();\n\n    return guessedVersion === 'bs3';\n  }\n\n  return window.__theme !== 'bs4';\n}\n","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","/*tslint:disable:no-invalid-this */\n/* tslint:disable-next-line: no-any */\nexport function OnChange(defaultValue?: any): any {\n  const sufix = 'Change';\n\n  /* tslint:disable-next-line: no-any */\n  return function OnChangeHandler(target: any, propertyKey: string): void {\n    const _key = ` __${propertyKey}Value`;\n    Object.defineProperty(target, propertyKey, {\n      /* tslint:disable-next-line: no-any */\n      get(): any {\n        return this[_key];\n      },\n      /* tslint:disable-next-line: no-any */\n      set(value: any): void {\n        const prevValue = this[_key];\n        this[_key] = value;\n        if (prevValue !== value && this[propertyKey + sufix]) {\n          this[propertyKey + sufix].emit(value);\n        }\n      }\n    });\n  };\n}\n/* tslint:enable */\n","import { window } from './facade/browser';\n\nexport class Utils {\n  /* tslint:disable-next-line: no-any */\n  static reflow(element: any): void {\n    /* tslint:disable-next-line: no-any */\n    ((bs: any): void => bs)(element.offsetHeight);\n  }\n\n  // source: https://github.com/jquery/jquery/blob/master/src/css/var/getStyles.js\n  /* tslint:disable-next-line: no-any */\n  static getStyles(elem: any): any {\n    // Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n    // IE throws on elements created in popups\n    // FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n    let view = elem.ownerDocument.defaultView;\n\n    if (!view || !view.opener) {\n      view = window;\n    }\n\n    return view.getComputedStyle(elem);\n  }\n}\n","import { isDevMode } from '@angular/core';\nconst _messagesHash: { [key: string]: boolean } = {};\nconst _hideMsg = typeof console === 'undefined' || !('warn' in console);\n\nexport function warnOnce(msg: string): void {\n  if (!isDevMode() || _hideMsg || msg in _messagesHash) {\n    return;\n  }\n\n  _messagesHash[msg] = true;\n  /*tslint:disable-next-line*/\n  console.warn(msg);\n}\n"],"names":["document","window"],"mappings":"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"}