@bbn/bbn 1.0.58 → 1.0.60

package/dist/fn/browser/getDeviceType.js

@@ -0,0 +1,23 @@
+/**
+ * Returns the current device type.
+ * @method   getDeviceType
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.getDeviceType();
+ * // mobile
+ * ```
+ * @memberof bbn.fn
+ * @returns  {String}
+ */
+const getDeviceType = function () {
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (/iPhone|Android/i.test(navigator.userAgent)) {
+        return 'mobile';
+    }
+    if (/(ipad|tablet|(android(?!.*mobile))|(windows(?!.*phone)(.*touch))|kindle|playbook|silk|(puffin(?!.*(IP|AP|WP))))/.test(userAgent)) {
+        return 'tablet';
+    }
+    return 'desktop';
+};
+export { getDeviceType };

package/dist/fn/browser/getEventData.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a promise having the event's data as argument.
+ * @method   getEventData
+ * @global
+ * @example
+ * ``` javascript
+ * let type = e.type;
+ *   bbn.fn.getEventData(e).then((data) => {
+ *     bbn.fn.log("DATA FROM " + type, data);
+ *   });
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Promise}
+ */
+declare const getEventData: (e: any) => Promise<unknown>;
+export { getEventData };

package/dist/fn/browser/getEventData.js

@@ -0,0 +1,116 @@
+import { getHTMLOfSelection } from '../html/getHTMLOfSelection';
+import { each } from '../loop/each';
+import { defaultErrorFunction } from '../default/defaultErrorFunction';
+/**
+ * Returns a promise having the event's data as argument.
+ * @method   getEventData
+ * @global
+ * @example
+ * ``` javascript
+ * let type = e.type;
+ *   bbn.fn.getEventData(e).then((data) => {
+ *     bbn.fn.log("DATA FROM " + type, data);
+ *   });
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Promise}
+ */
+const getEventData = function (e) {
+    let dt = e.dataTransfer || e.clipboardData;
+    let t = dt.getData('Text');
+    let res = { raw: t, files: [], str: [] };
+    let p = new Promise((ok, err) => {
+        let done = !(dt instanceof DataTransfer);
+        if (!t && e.type === 'copy') {
+            let sel = window.getSelection();
+            res.raw = sel.toString();
+            let html = getHTMLOfSelection();
+            res.str.push({
+                type: 'text/plain',
+                data: res.raw,
+            });
+            if (html !== res.raw) {
+                res.str.push({
+                    type: 'text/html',
+                    data: html,
+                });
+            }
+            else if (res.raw.trim().indexOf('<') === 0) {
+                res.str.push({
+                    type: 'text/html',
+                    data: "<meta charset='utf-8'><code style=\"white-space: pre; font-family: 'Courier New', sans-serif\">\n" +
+                        res.raw +
+                        '\n</code>',
+                });
+            }
+            done = true;
+            ok(res);
+        }
+        if (!done) {
+            let strings = [];
+            let num = dt.items.length;
+            each(dt.items, (item, idx) => {
+                let kind = item.kind;
+                let type = item.type;
+                if (kind === 'file') {
+                    let cp = dt.files[idx];
+                    if (!type && cp.name) {
+                        let bits = cp.name.split('.');
+                        type = bits[bits.length - 1];
+                    }
+                    let name = cp ? cp.name : bbn._('untitled');
+                    let size = cp ? cp.size : null;
+                    let lastModified = cp ? cp.lastModified : null;
+                    let blob = item.getAsFile();
+                    if (blob) {
+                        done = true;
+                        num--;
+                        res.files.push({
+                            type: type,
+                            data: blob,
+                            name: name,
+                            size: size,
+                            mdate: lastModified,
+                        });
+                        strings.push(name);
+                        if (!num) {
+                            if (!res.raw) {
+                                res.raw = strings.join(', ');
+                            }
+                            ok(res);
+                        }
+                    }
+                    else {
+                        defaultErrorFunction(bbn._('Impossible to read the file') + ' ' + name);
+                    }
+                }
+                else {
+                    done = true;
+                    item.getAsString((data) => {
+                        num--;
+                        res.str.push({
+                            type: type,
+                            data: data,
+                        });
+                        if (type === 'text/plain') {
+                            strings.push(name);
+                        }
+                        if (!num) {
+                            if (!res.raw) {
+                                res.raw = strings.join(', ');
+                            }
+                            ok(res);
+                        }
+                    });
+                }
+            });
+        }
+        if (!done) {
+            setTimeout(() => {
+                ok(res);
+            });
+        }
+    });
+    return p;
+};
+export { getEventData };

package/dist/fn/browser/happy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Logs the given argument in the browser's console highlighting it with a green background.
+ * @method   happy
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.happy('I want to log the success of my function');
+ * ```
+ * @memberof bbn.fn
+ * @param    {...any} args
+ * @returns
+ */
+declare const happy: (...args: any[]) => any;
+export { happy };

package/dist/fn/browser/happy.js

@@ -0,0 +1,22 @@
+import { log } from './log';
+/**
+ * Logs the given argument in the browser's console highlighting it with a green background.
+ * @method   happy
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.happy('I want to log the success of my function');
+ * ```
+ * @memberof bbn.fn
+ * @param    {...any} args
+ * @returns
+ */
+const happy = function (...args) {
+    args.unshift({
+        _bbn_console_level: 3,
+        _bbn_console_style: 'color: white; background: green; font-size: 18px;',
+    });
+    log.apply(this, args);
+    return this;
+};
+export { happy };

package/dist/fn/browser/history.d.ts

@@ -0,0 +1,2 @@
+declare const history: () => false | History;
+export { history };

package/dist/fn/browser/history.js

@@ -0,0 +1,4 @@
+const history = function () {
+    return window.history || false;
+};
+export { history };

package/dist/fn/browser/info.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Logs the given argument in the browser's console highlighting it with a blue background.
+ * @method   info
+ * @global
+ * @memberof bbn.fn
+ * @param    {...any} args
+ * @returns  {*}
+ */
+declare const info: (...args: any[]) => any;
+export { info };

package/dist/fn/browser/info.js

@@ -0,0 +1,19 @@
+import { log } from './log';
+/**
+ * Logs the given argument in the browser's console highlighting it with a blue background.
+ * @method   info
+ * @global
+ * @memberof bbn.fn
+ * @param    {...any} args
+ * @returns  {*}
+ */
+const info = function (...args) {
+    args.unshift({
+        //_bbn_console_mode: "info",
+        _bbn_console_level: 4,
+        _bbn_console_style: 'color: #EEE; background: blue; font-size: 12px;',
+    });
+    log.apply(this, args);
+    return this;
+};
+export { info };

package/dist/fn/browser/isActiveInterface.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tells if the interface is beeing active for the past x seconds.
+ * @method   isActiveInterface
+ * @global
+ * @example
+ * // true
+ * ``` javascript
+ * bbn.fn.isActiveInterface(54764654);
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isActiveInterface: (secs?: number) => boolean;
+export { isActiveInterface };

package/dist/fn/browser/isActiveInterface.js

@@ -0,0 +1,20 @@
+/**
+ * Tells if the interface is beeing active for the past x seconds.
+ * @method   isActiveInterface
+ * @global
+ * @example
+ * // true
+ * ``` javascript
+ * bbn.fn.isActiveInterface(54764654);
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isActiveInterface = function (secs = 600) {
+    if (!bbn.env.last_focus) {
+        return false;
+    }
+    let t = new Date().getTime();
+    return t - bbn.env.last_focus < secs * 1000;
+};
+export { isActiveInterface };

package/dist/fn/browser/isDesktopDevice.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns true if the current device type is a desktop.
+ * @method   isDesktopDevice
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.isDesktopDevice();
+ * // true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isDesktopDevice: () => boolean;
+export { isDesktopDevice };

package/dist/fn/browser/isDesktopDevice.js

@@ -0,0 +1,17 @@
+import { getDeviceType } from '../browser/getDeviceType';
+/**
+ * Returns true if the current device type is a desktop.
+ * @method   isDesktopDevice
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.isDesktopDevice();
+ * // true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isDesktopDevice = function () {
+    return getDeviceType() === 'desktop';
+};
+export { isDesktopDevice };

package/dist/fn/browser/isFocused.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Checks whether the given elemet is focused or not.
+ *
+ * @method   isFocused
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.isFocused(document.getElementById('input_name'));
+ * // false
+ * bbn.fn.isFocused(bbn.sel('.container'));
+ * // true
+ * ```
+ * @memberof bbn.fn
+ *
+ * @param {Element} ele     The element to be checked for focus
+ * @param {Boolean} contain If true will check if the focused element is contained in the given element
+ *
+ * @returns  {Boolean} True if focused
+ */
+declare const isFocused: (ele: HTMLElement, contain?: boolean) => boolean;
+export { isFocused };

package/dist/fn/browser/isFocused.js

@@ -0,0 +1,23 @@
+/**
+ * Checks whether the given elemet is focused or not.
+ *
+ * @method   isFocused
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.isFocused(document.getElementById('input_name'));
+ * // false
+ * bbn.fn.isFocused(bbn.sel('.container'));
+ * // true
+ * ```
+ * @memberof bbn.fn
+ *
+ * @param {Element} ele     The element to be checked for focus
+ * @param {Boolean} contain If true will check if the focused element is contained in the given element
+ *
+ * @returns  {Boolean} True if focused
+ */
+const isFocused = function (ele, contain) {
+    return ele === document.activeElement || (contain && ele.contains && ele.contains(document.activeElement));
+};
+export { isFocused };

package/dist/fn/browser/isMobile.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns true if the current browser is on a mobile device (smartphone or tablet).
+ * @method   isMobile
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.isMobile();
+ * // false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isMobile: () => boolean;
+export { isMobile };

package/dist/fn/browser/isMobile.js

@@ -0,0 +1,18 @@
+import { isMobileDevice } from './isMobileDevice';
+import { isTabletDevice } from './isTabletDevice';
+/**
+ * Returns true if the current browser is on a mobile device (smartphone or tablet).
+ * @method   isMobile
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.isMobile();
+ * // false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isMobile = function () {
+    return isMobileDevice() || isTabletDevice();
+};
+export { isMobile };

package/dist/fn/browser/isMobileDevice.d.ts

@@ -0,0 +1,2 @@
+declare const isMobileDevice: () => boolean;
+export { isMobileDevice };

package/dist/fn/browser/isMobileDevice.js

@@ -0,0 +1,5 @@
+import { getDeviceType } from '../browser/getDeviceType';
+const isMobileDevice = function () {
+    return getDeviceType() === 'mobile';
+};
+export { isMobileDevice };

package/dist/fn/browser/isTabletDevice.d.ts

@@ -0,0 +1,14 @@
+/**
+  * Returns true if the current device type is a tablet.
+  * @method   isTabletDevice
+  * @global
+  * @example
+  * ``` javascript
+  * bbn.fn.isTabletDevice();
+  * // false
+  * ```
+  * @memberof bbn.fn
+  * @returns  {Boolean}
+  */
+declare const isTabletDevice: () => boolean;
+export { isTabletDevice };

package/dist/fn/browser/isTabletDevice.js

@@ -0,0 +1,17 @@
+import { getDeviceType } from '../browser/getDeviceType';
+/**
+  * Returns true if the current device type is a tablet.
+  * @method   isTabletDevice
+  * @global
+  * @example
+  * ``` javascript
+  * bbn.fn.isTabletDevice();
+  * // false
+  * ```
+  * @memberof bbn.fn
+  * @returns  {Boolean}
+  */
+const isTabletDevice = function () {
+    return getDeviceType() === 'tablet';
+};
+export { isTabletDevice };

package/dist/fn/browser/log.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Logs the given arguments in the browser's console.
+ * @method   log
+ * @global
+ * @example
+ * ```javascript
+ * //'hello'
+ * bbn.fn.log('hello');
+ * ```
+ * @memberof bbn.fn
+ * @param    {...any} args
+ * @returns
+ */
+declare const log: (...args: any[]) => any;
+export { log };

package/dist/fn/browser/log.js

@@ -0,0 +1,46 @@
+import { isFunction } from '../type/isFunction';
+/**
+ * Logs the given arguments in the browser's console.
+ * @method   log
+ * @global
+ * @example
+ * ```javascript
+ * //'hello'
+ * bbn.fn.log('hello');
+ * ```
+ * @memberof bbn.fn
+ * @param    {...any} args
+ * @returns
+ */
+const log = function (...args) {
+    if (window.console !== undefined) {
+        let cfg;
+        let level = 5;
+        let fn = 'log';
+        if (args[0] && typeof args[0] === 'object' && args[0]._bbn_console_style) {
+            if (args[0]._bbn_console_mode && isFunction(console[args[0]._bbn_console_mode])) {
+                fn = args[0]._bbn_console_mode;
+            }
+            else {
+                cfg = args[0]._bbn_console_style;
+                level = args[0]._bbn_console_level;
+            }
+            args.shift();
+        }
+        if (bbn.env.loggingLevel >= level) {
+            let i = 0;
+            while (i < args.length) {
+                let t = typeof args[i];
+                if (t === 'string' || t === 'number') {
+                    window.console[fn]('%c %s ', cfg, args[i]);
+                }
+                else {
+                    window.console[fn](args[i]);
+                }
+                i++;
+            }
+        }
+    }
+    return this;
+};
+export { log };

package/dist/fn/browser/replaceSelection.d.ts

@@ -0,0 +1,2 @@
+declare const replaceSelection: (html: any, selectInserted: any) => void;
+export { replaceSelection };

package/dist/fn/browser/replaceSelection.js

@@ -0,0 +1,42 @@
+const replaceSelection = function (html, selectInserted) {
+    let sel, range, fragment;
+    sel = window.getSelection();
+    // Test that the Selection object contains at least one Range
+    if (sel.getRangeAt && sel.rangeCount) {
+        // Get the first Range (only Firefox supports more than one)
+        range = window.getSelection().getRangeAt(0);
+        range.deleteContents();
+        // Create a DocumentFragment to insert and populate it with HTML
+        // Need to test for the existence of range.createContextualFragment
+        // because it's non-standard and IE 9 does not support it
+        if (range.createContextualFragment) {
+            fragment = range.createContextualFragment(html);
+        }
+        else {
+            // In IE 9 we need to use innerHTML of a temporary element
+            const div = document.createElement('div');
+            let child;
+            div.innerHTML = html;
+            fragment = document.createDocumentFragment();
+            while ((child = div.firstChild)) {
+                fragment.appendChild(child);
+            }
+        }
+        const firstInsertedNode = fragment.firstChild;
+        const lastInsertedNode = fragment.lastChild;
+        range.insertNode(fragment);
+        sel.removeAllRanges();
+        if (selectInserted) {
+            if (firstInsertedNode) {
+                range.setStartBefore(firstInsertedNode);
+                range.setEndAfter(lastInsertedNode);
+            }
+            sel.addRange(range);
+        }
+        else {
+            range.setStartAfter(lastInsertedNode);
+            sel.addRange(range);
+        }
+    }
+};
+export { replaceSelection };

package/dist/fn/browser/selectElementText.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Selects the content of an element.
+ *
+ * @method   selectElementText
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.selectElementText(document.getElementById('my_input_id'));
+ * // false
+ * bbn.fn.selectElementText(bbn.$('#my_span_id'));
+ * // true
+ * ```
+ * @memberof bbn.fn
+ *
+ * @param {Element} ele The element in which the text should be selected
+ * @param {Boolean} win The window object
+ *
+ * @returns  {Boolean} True if focused
+ */
+declare const selectElementText: (ele: HTMLElement, win?: Window) => void;
+export { selectElementText };

package/dist/fn/browser/selectElementText.js

@@ -0,0 +1,42 @@
+/**
+ * Selects the content of an element.
+ *
+ * @method   selectElementText
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.selectElementText(document.getElementById('my_input_id'));
+ * // false
+ * bbn.fn.selectElementText(bbn.$('#my_span_id'));
+ * // true
+ * ```
+ * @memberof bbn.fn
+ *
+ * @param {Element} ele The element in which the text should be selected
+ * @param {Boolean} win The window object
+ *
+ * @returns  {Boolean} True if focused
+ */
+const selectElementText = function (ele, win) {
+    win = win || window;
+    if (ele instanceof HTMLInputElement) {
+        ele.select();
+        return;
+    }
+    let doc = win.document;
+    let sel;
+    let range;
+    if (win.getSelection && doc.createRange) {
+        sel = win.getSelection();
+        range = doc.createRange();
+        range.selectNodeContents(ele);
+        sel.removeAllRanges();
+        sel.addRange(range);
+    }
+    else if (('createTextRange' in doc.body) && (typeof doc.body.createTextRange === 'function')) {
+        range = doc.body.createTextRange();
+        range.moveToElementText(ele);
+        range.select();
+    }
+};
+export { selectElementText };

package/dist/fn/browser/setCookie.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a cookie and assigns it to document.cookie.
+ * @method   setCookie
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.setCookie('lang', 'en', 2);
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} name  The name of the cookie.
+ * @param    {String} value The value of the cookie.
+ * @param    {Number} days  The days before expiration of the cookie.
+ * @returns
+ */
+declare const setCookie: (name: any, value: any, days: any) => void;
+export { setCookie };

package/dist/fn/browser/setCookie.js

@@ -0,0 +1,25 @@
+/**
+ * Creates a cookie and assigns it to document.cookie.
+ * @method   setCookie
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.setCookie('lang', 'en', 2);
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} name  The name of the cookie.
+ * @param    {String} value The value of the cookie.
+ * @param    {Number} days  The days before expiration of the cookie.
+ * @returns
+ */
+const setCookie = function (name, value, days) {
+    let expires = '';
+    if (days) {
+        let date = new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+        expires = '; expires=' + date.toUTCString();
+    }
+    let st = escape(JSON.stringify({ value: value }));
+    document.cookie = name + '=' + st + expires + '; path=/';
+};
+export { setCookie };

package/dist/fn/browser/toggleFullScreen.d.ts

@@ -0,0 +1,2 @@
+declare const toggleFullScreen: () => void;
+export { toggleFullScreen };