yet-another-js-utils 0.0.8 → 0.0.11

package/README.md

@@ -1,25 +1,26 @@
-- Each CID has an npm counterpart
-- One main function for inputs
-- Link to original
-- Happy programming
+# Yet-Another-JS-Utils
 
-# Usage
+## Installation
 
-- update package.json
-- update .nvmrc
-- update grunfile.js
-- update launcher.sh
-- update index.md
-- update LICENSE.txt
-- update README.md
-- Run "Tasks: Allow Automatic Tasks" in vscode's palette (Ctrl+Shift+P)
+```
+npm install yet-another-js-utils
+```
 
-# Dependencies
+## Usage
 
-- normalize.css
-    - https://github.com/csstools/normalize.css/blob/main/normalize.css
+```js
+const yaju = require('yet-another-js-utils');
+// (...)
+yaju.diffVDomAndUpdate(newRender, previousRender, dom);
+this.previousRender = newRender;
+applyState(dom);
+```
 
-# License
+## Dependencies
+
+0
+
+## License
 
 Copyright (c) PLANVIII. All rights reserved.
 

package/dist/yaju.min.js

@@ -0,0 +1 @@
+"use strict";(()=>{var l=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var f=l((g,p)=>{"use strict";p.exports={nil(e){return e===null||typeof e>"u"},hack(e,t,r){return e.slice(t,r+1)},pick(e,t){return e.filter(t)},prune(e,t){return e.filter(function(r){return!t(r)})},check(e,t){return e.every(t)},escape(e){return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#039;")},html(e){let t=e[0],r=Math.max(e.length,arguments.length-1);for(let s=1;s<r;s++)t+=arguments[s],t+=e[s];return t},diffVDomAndUpdate(e,t,r){let s=this;s.changedNodes=[];let n=e.childNodes,d=t.childNodes,i=r.childNodes;if(i.length>d.length){let a=i.length-d.length;for(let u=0,o=a;u<o;u++)r.lastChild.remove()}for(let a=0,u=d.length;a<u;a++)if(n[a]){if(n[a].outerHTML!==d[a].outerHTML){let o=d[a].cloneNode(!0);s.changedNodes.push(o),i[a].replaceWith(o)}}else{let o=d[a].cloneNode(!0);s.changedNodes.push(o),r.appendChild(o)}},addDataState(e,t){let r=[];e.dataset.state&&e.dataset.state.indexOf(" ")>-1?r=e.dataset.state.split(" "):r=[e.dataset.state],r.indexOf(t)===-1&&(r.push(t),e.dataset.state=r.join(" "))},removeDataState(e,t){let r=[];e.dataset.state&&e.dataset.state.indexOf(" ")>-1?r=e.dataset.state.split(" "):r=[e.dataset.state],e.dataset.state=r.filter(s=>s!==t).join(" ")},replaceDataState(e,t,r){this.removeDataState(e,t),this.addDataState(e,r)},toggleDataState(e,t){e.dataset.state.split(" ").indexOf(t)==-1?this.addDataState(e,t):this.removeDataState(e,t)},ajaxGet(e,t,r,s){var n=new XMLHttpRequest;n.open("GET",e),n.addEventListener("load",function(){if(n.status>=200&&n.status<400)if(r){var d={};try{d=JSON.parse(n.responseText)}catch{console.error("Get request returned invalid JSON.")}s===void 0?t(d):t.apply(s,[d])}else s===void 0?t(n.responseText):t.apply(s,[n.responseText]);else console.error(n.status+" "+n.statusText+" "+e)}),n.addEventListener("error",function(){console.error("Network error trying to access: "+e)}),n.send(null)},ajaxPost(e,t,r,s,n,d,i){var a=new XMLHttpRequest;a.open("POST",e),a.addEventListener("load",function(){a.status>=200&&a.status<400?d===void 0?r(a):r.apply(d,[a]):(i===void 0?s(a):s.apply(i,[a]),console.error(a.status+" "+a.statusText+" "+e))}),a.addEventListener("error",function(){console.error("Network error trying to access: "+e)}),n&&(a.setRequestHeader("Content-Type","application/json"),t=JSON.stringify(t)),a.send(t)},pipe(e,...t){return t.reduce((r,s)=>s(r),e)}}});(function(){window.yaju=f()})();})();

package/gruntfile.js

@@ -21,13 +21,6 @@ module.exports = function(grunt) {
                     livereload: true
                 },
             },
-            cssConcatenation: {
-                files: ['css/*.css', '!css/main.css'],
-                tasks: ['concat:css'],
-                options: {
-                    livereload: true
-                },
-            },
         },
         exec: {
             mocha: {
@@ -45,44 +38,21 @@ module.exports = function(grunt) {
                 minify: true
             },
             dev: {
-                entryPoints: ['app.js'],
+                entryPoints: ['main.js'],
                 outfile: './out.js',
                 bundle: true,
                 sourcemap: true,
             }
         },
-        concat: {
-            css: {
-                options: {
-                    separator: '\n',
-                },
-                src: [
-                    'css/0-noscript.css',
-                    'css/1-root.css',
-                    'css/2-contents.css'
-                ],
-                dest: 'css/main.css'
-            }
-        },
-        cssmin: {
-            options: {},
-            target: {
-                files: {
-                    'css/main.min.css': ['css/main.css']
-                }
-            }
-        }
     });
 
     // Load the plugin that provides the tasks.
     grunt.loadNpmTasks('grunt-exec');
     grunt.loadNpmTasks('grunt-esbuild');
     grunt.loadNpmTasks('grunt-concurrent');
-    grunt.loadNpmTasks('grunt-contrib-concat');
-    grunt.loadNpmTasks('grunt-contrib-cssmin');
     grunt.loadNpmTasks('grunt-contrib-watch');
 
     // Default task(s).
     grunt.registerTask('test', ['exec:mocha']);
-    grunt.registerTask('dist', ['esbuild', 'cssmin']);
+    grunt.registerTask('dist', ['esbuild']);
 };

package/js-utils.js

@@ -107,38 +107,43 @@ module.exports = {
             output += arguments[i];
             output += strings[i];
         }
-        let fragment = document.createDocumentFragment();
-        fragment.innerHTML = output;
-        return fragment;
+        return output;
     },
 
     /**
      * Basic contents updater
      * Assuming:
-     * - secondNode already holds states updates
-     * - rendering applied event-listeners already
-     * @param {*} firstNode
-     * @param {*} secondNode
+     * - Rendering applied event-listeners already
+     * - You can apply state afterwards
+     * - You can store newRender afterwards
+     * @param {object} previousRender
+     * @param {object} newRender
+     * @param {object} dom
      */
-    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])
+    diffVDomAndUpdate(previousRender, newRender, dom) {
+        // Assuming overwrite or insertion
+        let $ =  this;
+        $.changedNodes = [];
+        let leftItems = previousRender.childNodes,
+            rightItems = newRender.childNodes,
+            domItems = dom.childNodes;
+        if (domItems.length > rightItems.length) {
+            let diffLength = domItems.length - rightItems.length;
+            for (let i = 0, c = diffLength; i < c; i++) {
+                dom.lastChild.remove();
             }
         }
-        if (firstNodeChildren.length > secondNodeChildren.length) {
-            for (let i = firstNodeChildren.length - 1; i > secondNodeChildren.length - 1; i--) {
-                firstNodeChildren[i].remove();
+        for (let i = 0, c = rightItems.length; i < c; i++) {
+            if (!leftItems[i]) {
+                let node = rightItems[i].cloneNode(true);
+                $.changedNodes.push(node);
+                dom.appendChild(node);
+            } else if (
+                leftItems[i].outerHTML !== rightItems[i].outerHTML
+            ) {
+                let node = rightItems[i].cloneNode(true);
+                $.changedNodes.push(node);
+                domItems[i].replaceWith(node);
             }
         }
     },

package/out.js

@@ -0,0 +1,277 @@
+"use strict";
+(() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+
+  // js-utils.js
+  var require_js_utils = __commonJS({
+    "js-utils.js"(exports, module) {
+      "use strict";
+      module.exports = {
+        // # Nil
+        // 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 }
+         */
+        nil(exp) {
+          if (exp === null || typeof exp === "undefined") {
+            return true;
+          } else {
+            return false;
+          }
+        },
+        // # Hack
+        // .slice() uses a closed-open interval
+        // the mathematical convention goes closed-closed
+        /**
+         * Hack
+         * @param { number } start
+         * @param { number } end
+         * @returns
+         */
+        hack(array, start, end) {
+          return array.slice(start, end + 1);
+        },
+        // # Prune/Pick
+        // Javascript inherited spreadsheet-like .filter()
+        // It felt confusing there
+        // It feels confusing here too
+        /**
+         * Pick
+         * @param {*} array
+         * @param {*} pruningFunction
+         * @returns
+         */
+        pick(array, pruningFunction) {
+          return array.filter(pruningFunction);
+        },
+        /**
+         * Prune
+         * The inverse of filter()
+         * @param {*} array
+         * @param {*} filteringFunction
+         * @returns
+         */
+        prune(array, filteringFunction) {
+          return array.filter(function(x) {
+            return !filteringFunction(x);
+          });
+        },
+        // # Check
+        // .every() just sounds weird
+        /**
+         * Check
+         * @param {*} array
+         * @param {*} checkingFunction
+         * @returns
+         */
+        check(array, checkingFunction) {
+          return array.every(checkingFunction);
+        },
+        /**
+         * 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
+         */
+        html(strings) {
+          let output = strings[0], 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:
+         * - Rendering applied event-listeners already
+         * - You can apply state afterwards
+         * - You can store newRender afterwards
+         * @param {object} previousRender
+         * @param {object} newRender
+         * @param {object} dom
+         */
+        diffVDomAndUpdate(previousRender, newRender, dom) {
+          let $ = this;
+          $.changedNodes = [];
+          let leftItems = previousRender.childNodes, rightItems = newRender.childNodes, domItems = dom.childNodes;
+          if (domItems.length > rightItems.length) {
+            let diffLength = domItems.length - rightItems.length;
+            for (let i = 0, c = diffLength; i < c; i++) {
+              dom.lastChild.remove();
+            }
+          }
+          for (let i = 0, c = rightItems.length; i < c; i++) {
+            if (!leftItems[i]) {
+              let node = rightItems[i].cloneNode(true);
+              $.changedNodes.push(node);
+              dom.appendChild(node);
+            } else if (leftItems[i].outerHTML !== rightItems[i].outerHTML) {
+              let node = rightItems[i].cloneNode(true);
+              $.changedNodes.push(node);
+              domItems[i].replaceWith(node);
+            }
+          }
+        },
+        // # 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
+        /**
+         * 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
+         */
+        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((element2) => element2 !== state).join(" ");
+        },
+        /**
+         * 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
+         */
+        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 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 === void 0 ? callback(json) : callback.apply(callbackContext, [json]);
+              } else {
+                callbackContext === void 0 ? callback(req.responseText) : callback.apply(callbackContext, [req.responseText]);
+              }
+            } else {
+              console.error(req.status + " " + req.statusText + " " + url);
+            }
+          });
+          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
+         */
+        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 === void 0 ? successCallback(req) : successCallback.apply(successCallbackContext, [req]);
+            } else {
+              failureCallbackContext === void 0 ? 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.send(data);
+        },
+        /**
+         * Pipe
+         * Function piping with initial input
+         * @param {*} functions
+         * @param {*} input
+         * @returns {*}
+         */
+        pipe(input, ...functions) {
+          return functions.reduce((res, fun) => fun(res), input);
+        }
+      };
+    }
+  });
+
+  // main.js
+  (function() {
+    window.yaju = require_js_utils();
+  })();
+})();
+//# sourceMappingURL=out.js.map

package/out.js.map

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

package/package.json

@@ -2,7 +2,7 @@
     "name": "yet-another-js-utils",
     "description": "Basic javascript utils",
     "authors": "Adrian Turcev",
-    "version": "0.0.8",
+    "version": "0.0.11",
     "license": "MPL-2.0",
     "homepage": "https://github.com/adrianturcev/js-utils",
     "repository": {