yet-another-js-utils 0.0.7 → 0.0.9

package/js-utils.js

@@ -1,303 +1,297 @@
+module.exports = {
+    // # Nil
 
-// # Nil
-
-// I like the NOT operator
-// I like strict type checking
-// Hence a strictly typed equivalent:
-// - 3-letters name n
-// - single argument
+    // I like the NOT operator
+    // I like strict type checking
+    // Hence a strictly typed equivalent:
+    // - 3-letters name n
+    // - single argument
 
-/**
- * Nil
- * Neither null nor undefined
- * @param { boolean } exp
- * @returns { boolean }
- */
-function nil(exp) { // values implicitly considered functions
-    if (
-        exp === null
-        || typeof exp === 'undefined'
-    ) {
-        return true;
-    } else {
-        return false;
-    }
-}
+    /**
+     * Nil
+     * Neither null nor undefined
+     * @param { boolean } exp
+     * @returns { boolean }
+     */
+    nil(exp) { // values implicitly considered functions
+        if (
+            exp === null
+            || typeof exp === 'undefined'
+        ) {
+            return true;
+        } else {
+            return false;
+        }
+    },
 
-// # Hack
+    // # Hack
 
-// .slice() uses a closed-open interval
-// the mathematical convention goes closed-closed
+    // .slice() uses a closed-open interval
+    // the mathematical convention goes closed-closed
 
-/**
- * Hack
- * @param { number } start
- * @param { number } end
- * @returns
- */
-function hack(array, start, end) {
-    return array.slice(start, end + 1);
-}
+    /**
+     * Hack
+     * @param { number } start
+     * @param { number } end
+     * @returns
+     */
+    hack(array, start, end) {
+        return array.slice(start, end + 1);
+    },
 
-// # Prune/Pick
+    // # Prune/Pick
 
-// Javascript inherited spreadsheet-like .filter()
-// It felt confusing there
-// It feels confusing here too
+    // Javascript inherited spreadsheet-like .filter()
+    // It felt confusing there
+    // It feels confusing here too
 
-/**
- * Pick
- * @param {*} array
- * @param {*} pruningFunction
- * @returns
- */
-function pick(array, pruningFunction) {
-    return array.filter(pruningFunction);
-}
+    /**
+     * Pick
+     * @param {*} array
+     * @param {*} pruningFunction
+     * @returns
+     */
+    pick(array, pruningFunction) {
+        return array.filter(pruningFunction);
+    },
 
-/**
- * Prune
- * The inverse of filter()
- * @param {*} array
- * @param {*} filteringFunction
- * @returns
- */
-function prune(array, filteringFunction) {
-    return array.filter(function (x) {
-        return !filteringFunction(x);
-    });
-}
+    /**
+     * Prune
+     * The inverse of filter()
+     * @param {*} array
+     * @param {*} filteringFunction
+     * @returns
+     */
+    prune(array, filteringFunction) {
+        return array.filter(function (x) {
+            return !filteringFunction(x);
+        });
+    },
 
-// # Check
+    // # Check
 
-// .every() just sounds weird
-/**
- * Check
- * @param {*} array
- * @param {*} checkingFunction
- * @returns
- */
-function check(array, checkingFunction) {
-    return array.every(checkingFunction);
-}
+    // .every() just sounds weird
+    /**
+     * Check
+     * @param {*} array
+     * @param {*} checkingFunction
+     * @returns
+     */
+    check(array, checkingFunction) {
+        return array.every(checkingFunction);
+    },
 
-/**
- * Escape
- * @param { string } string
- * @returns
- */
-function escape(string) {
-    return string
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#039;');
-}
+    /**
+     * Escape
+     * @param { string } string
+     * @returns
+     */
+    escape(string) {
+        return string
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    },
 
-/**
- * DOM-rendering template tag
- * @param {Array} strings
- * @returns {object} a DocumentFragment
- */
-function html(strings) {
-    let output = strings[0], // assumes empty string start?
-        max = Math.max(strings.length, arguments.length - 1);
-    for (let i = 1; i < max; i++) {
-        output += arguments[i];
-        output += strings[i];
-    }
-    let fragment = document.createDocumentFragment();
-    fragment.innerHTML = output;
-    return fragment;
-}
+    /**
+     * DOM-rendering template tag
+     * @param {Array} strings
+     * @returns {object} a DocumentFragment
+     */
+    html(strings) {
+        let output = strings[0], // assumes empty string start?
+            max = Math.max(strings.length, arguments.length - 1);
+        for (let i = 1; i < max; i++) {
+            output += arguments[i];
+            output += strings[i];
+        }
+        return output;
+    },
 
-/**
- * Basic contents updater
- * Assuming:
- * - secondNode already holds states updates
- * - rendering applied event-listeners already
- * @param {*} firstNode
- * @param {*} secondNode
- */
-function replaceChildren(firstNode, secondNode) {
-    let firstNodeChildren = firstNode.childNodes,
-        secondNodeChildren = secondNode.childNodes;
-    for (let i = 0, c = firstNodeChildren.length; i < c; i++) {
-        if (
-            secondNodeChildren[i]
-            && firstNodeChildren[i].outerHTML !== secondNodeChildren[i].outerHTML
-        ) {
-            firstNodeChildren[i].parentNode.replaceChild(firstNodeChildren[i], secondNodeChildren[i]);
+    /**
+     * Basic contents updater
+     * Assuming:
+     * - secondNode already holds states updates
+     * - rendering applied event-listeners already
+     * @param {*} firstNode
+     * @param {*} secondNode
+     */
+    replaceChildren(firstNode, secondNode) {
+        let firstNodeChildren = firstNode.childNodes,
+            secondNodeChildren = secondNode.childNodes;
+        for (let i = 0, c = firstNodeChildren.length; i < c; i++) {
+            if (
+                secondNodeChildren[i]
+                && firstNodeChildren[i].outerHTML !== secondNodeChildren[i].outerHTML
+            ) {
+                firstNodeChildren[i].parentNode.replaceChild(firstNodeChildren[i], secondNodeChildren[i]);
+            }
         }
-    }
-    if (firstNodeChildren.length < secondNodeChildren.length) {
-        for (let i = firstNodeChildren.length, c = secondNodeChildren.length; i < c; i++) {
-            firstNodeChildren[i].parentNode.appendChild(secondNodeChildren[i])
+        if (firstNodeChildren.length < secondNodeChildren.length) {
+            for (let i = firstNodeChildren.length, c = secondNodeChildren.length; i < c; i++) {
+                firstNodeChildren[i].parentNode.appendChild(secondNodeChildren[i])
+            }
         }
-    }
-    if (firstNodeChildren.length > secondNodeChildren.length) {
-        for (let i = firstNodeChildren.length - 1; i > secondNodeChildren.length - 1; i--) {
-            firstNodeChildren[i].remove();
+        if (firstNodeChildren.length > secondNodeChildren.length) {
+            for (let i = firstNodeChildren.length - 1; i > secondNodeChildren.length - 1; i--) {
+                firstNodeChildren[i].remove();
+            }
         }
-    }
-}
+    },
 
-// # DATA-STATE
+    // # DATA-STATE
 
-// Alternative CSS state management
-// - using data-attributes instead of classes
-//     - easier to match model and vue
-//     - dataset over classlist allows specialization
-//     - classes work as booleans (".walked")
-//         - you need to notice abscence
-//     - data-state work as a string type you can dedicate to store state only, and more than one state
+    // Alternative CSS state management
+    // - using data-attributes instead of classes
+    //     - easier to match model and vue
+    //     - dataset over classlist allows specialization
+    //     - classes work as booleans (".walked")
+    //         - you need to notice abscence
+    //     - data-state work as a string type you can dedicate to store state only, and more than one state
 
-/**
- * Add
- * @param { object } element
- * @param { string } state
- */
-function addDataState(element, state) {
-    let stateArray = [];
-    if (
-        element.dataset.state
-    && element.dataset.state.indexOf(' ') > -1
-    ) {
-        stateArray = element.dataset.state.split(' ');
-    } else {
-        stateArray = [element.dataset.state];
-    }
-    if (stateArray.indexOf(state) === -1) {
-        stateArray.push(state);
-        element.dataset.state = stateArray.join(' ');
-    }
-}
+    /**
+     * Add
+     * @param { object } element
+     * @param { string } state
+     */
+    addDataState(element, state) {
+        let stateArray = [];
+        if (
+            element.dataset.state
+        && element.dataset.state.indexOf(' ') > -1
+        ) {
+            stateArray = element.dataset.state.split(' ');
+        } else {
+            stateArray = [element.dataset.state];
+        }
+        if (stateArray.indexOf(state) === -1) {
+            stateArray.push(state);
+            element.dataset.state = stateArray.join(' ');
+        }
+    },
 
-/**
- * Remove
- * @param { object } element
- * @param { string } state
- */
-function removeDataState(element, state) {
-    let stateArray = [];
-    if (
-        element.dataset.state
-    && element.dataset.state.indexOf(' ') > -1
-    ) {
-        stateArray = element.dataset.state.split(' ');
-    } else {
-        stateArray = [element.dataset.state];
-    }
-    element.dataset.state =
-    stateArray
-        .filter(element => (element !== state))
-        .join(' ');
-}
+    /**
+     * Remove
+     * @param { object } element
+     * @param { string } state
+     */
+    removeDataState(element, state) {
+        let stateArray = [];
+        if (
+            element.dataset.state
+        && element.dataset.state.indexOf(' ') > -1
+        ) {
+            stateArray = element.dataset.state.split(' ');
+        } else {
+            stateArray = [element.dataset.state];
+        }
+        element.dataset.state =
+        stateArray
+            .filter(element => (element !== state))
+            .join(' ');
+    },
 
-/**
- * Replace
- * @param { object } element
- * @param { string } stateToRemove
- * @param { string } stateToAdd
- */
-function replaceDataState(element, stateToRemove, stateToAdd) {
-    this.removeDataState(element, stateToRemove);
-    this.addDataState(element, stateToAdd);
-}
+    /**
+     * Replace
+     * @param { object } element
+     * @param { string } stateToRemove
+     * @param { string } stateToAdd
+     */
+    replaceDataState(element, stateToRemove, stateToAdd) {
+        this.removeDataState(element, stateToRemove);
+        this.addDataState(element, stateToAdd);
+    },
 
-/**
- * Toggle
- * @param { object } element
- * @param { string } state
- */
-function toggleDataState(element, state) {
-    let stateArray = element.dataset.state.split(' ');
-    if (stateArray.indexOf(state) == -1) {
-        this.addDataState(element, state);
-    } else {
-        this.removeDataState(element, state);
-    }
-}
+    /**
+     * Toggle
+     * @param { object } element
+     * @param { string } state
+     */
+    toggleDataState(element, state) {
+        let stateArray = element.dataset.state.split(' ');
+        if (stateArray.indexOf(state) == -1) {
+            this.addDataState(element, state);
+        } else {
+            this.removeDataState(element, state);
+        }
+    },
 
-//# AJAX Functions
+    //# AJAX Functions
 
-/**
- * AJAX GET
- * @param {string} url The target url
- * @param {function} callback
- * @param {boolean} isJson Response contains json
- * @param {object} callbackContext
- */
-function ajaxGet(url, callback, isJson, callbackContext) {
-    var req = new XMLHttpRequest();
-    req.open("GET", url);
-    req.addEventListener("load", function () {
-        if (req.status >= 200 && req.status < 400) {
-            if (isJson) {
-                var json = {};
-                try {
-                    json = JSON.parse(req.responseText);
-                } catch (error) {
-                    console.error("Get request returned invalid JSON.")
+    /**
+     * AJAX GET
+     * @param {string} url The target url
+     * @param {function} callback
+     * @param {boolean} isJson Response contains json
+     * @param {object} callbackContext
+     */
+    ajaxGet(url, callback, isJson, callbackContext) {
+        var req = new XMLHttpRequest();
+        req.open("GET", url);
+        req.addEventListener("load", function () {
+            if (req.status >= 200 && req.status < 400) {
+                if (isJson) {
+                    var json = {};
+                    try {
+                        json = JSON.parse(req.responseText);
+                    } catch (error) {
+                        console.error("Get request returned invalid JSON.")
+                    }
+                    callbackContext === undefined ? callback(json) : callback.apply(callbackContext, [json]);
+                } else {
+                    callbackContext === undefined ? callback(req.responseText) : callback.apply(callbackContext, [req.responseText]);
                 }
-                callbackContext === undefined ? callback(json) : callback.apply(callbackContext, [json]);
             } else {
-                callbackContext === undefined ? callback(req.responseText) : callback.apply(callbackContext, [req.responseText]);
+                console.error(req.status + " " + req.statusText + " " + url);
             }
-        } else {
-            console.error(req.status + " " + req.statusText + " " + url);
-        }
-    });
-    req.addEventListener("error", function () {
-        console.error("Network error trying to access: " + url);
-    });
-    req.send(null);
-}
+        });
+        req.addEventListener("error", function () {
+            console.error("Network error trying to access: " + url);
+        });
+        req.send(null);
+    },
 
-/**
- * AJAX POST
- * @param {string} url
- * @param {string} data
- * @param {function} successCallback
- * @param {function} failureCallback
- * @param {boolean} isJson
- * @param {object} successCallbackContext
- * @param {object} failureCallbackContext
- */
-function ajaxPost(url, data, successCallback, failureCallback, isJson, successCallbackContext, failureCallbackContext) {
-    var req = new XMLHttpRequest();
-    req.open("POST", url);
-    req.addEventListener("load", function () {
-        if (req.status >= 200 && req.status < 400) {
-            successCallbackContext === undefined ? successCallback(req) : successCallback.apply(successCallbackContext, [req]);
-        } else {
-            failureCallbackContext === undefined ? failureCallback(req) : failureCallback.apply(failureCallbackContext, [req]);
-            console.error(req.status + " " + req.statusText + " " + url);
+    /**
+     * AJAX POST
+     * @param {string} url
+     * @param {string} data
+     * @param {function} successCallback
+     * @param {function} failureCallback
+     * @param {boolean} isJson
+     * @param {object} successCallbackContext
+     * @param {object} failureCallbackContext
+     */
+    ajaxPost(url, data, successCallback, failureCallback, isJson, successCallbackContext, failureCallbackContext) {
+        var req = new XMLHttpRequest();
+        req.open("POST", url);
+        req.addEventListener("load", function () {
+            if (req.status >= 200 && req.status < 400) {
+                successCallbackContext === undefined ? successCallback(req) : successCallback.apply(successCallbackContext, [req]);
+            } else {
+                failureCallbackContext === undefined ? failureCallback(req) : failureCallback.apply(failureCallbackContext, [req]);
+                console.error(req.status + " " + req.statusText + " " + url);
+            }
+        });
+        req.addEventListener("error", function () {
+            console.error("Network error trying to access: " + url);
+        });
+        if (isJson) {
+            req.setRequestHeader("Content-Type", "application/json");
+            data = JSON.stringify(data);
         }
-    });
-    req.addEventListener("error", function () {
-        console.error("Network error trying to access: " + url);
-    });
-    if (isJson) {
-        req.setRequestHeader("Content-Type", "application/json");
-        data = JSON.stringify(data);
-    }
-    req.send(data);
-}
+        req.send(data);
+    },
 
-/**
- * Pipe
- * Function piping with initial input
- * @param {*} functions
- * @param {*} input
- * @returns {*}
- */
-function pipe(input, ...functions) {
-    return functions.reduce((res, fun) => fun(res), input);
+    /**
+     * Pipe
+     * Function piping with initial input
+     * @param {*} functions
+     * @param {*} input
+     * @returns {*}
+     */
+    pipe(input, ...functions) {
+        return functions.reduce((res, fun) => fun(res), input);
+    }
 }
-
-module.exports = {
-    nil, hack, pick, prune, check, escape, html, replaceChildren, addDataState, removeDataState, replaceDataState,
-    toggleDataState, ajaxGet, ajaxPost, pipe
-};

package/package.json

@@ -2,7 +2,7 @@
     "name": "yet-another-js-utils",
     "description": "Basic javascript utils",
     "authors": "Adrian Turcev",
-    "version": "0.0.7",
+    "version": "0.0.9",
     "license": "MPL-2.0",
     "homepage": "https://github.com/adrianturcev/js-utils",
     "repository": {
@@ -13,7 +13,7 @@
         "url": "https://github.com/adrianturcev/js-utils/issues"
     },
     "keywords": ["javascript", "utils"],
-    "main": ".js",
+    "main": "js-utils.js",
     "scripts": {
         "watch": "npx grunt watch",
         "test": "npx grunt test",