@webalternatif/js-core 1.0.0

package/src/i18n.js

@@ -0,0 +1,55 @@
+import * as i18n from "../i18n/index.js";
+import {isFunction, isUndefined} from "./is.js";
+
+export const translate = function (lang, ns, label) {
+    let language = lang;
+
+    if (isUndefined(label)) {
+        if (isUndefined(ns)) {
+            label = lang;
+            ns = 'core';
+        } else {
+            label = ns;
+            ns = lang;
+        }
+
+        language = getLang();
+    }
+
+    const translationExists =
+        !isUndefined(i18n[ns]) &&
+        !isUndefined(i18n[ns][language]) &&
+        !isUndefined(i18n[ns][language][label]);
+
+    if (translationExists) {
+        const tr = i18n[ns][language][label];
+        return isFunction(tr) ? tr() : tr;
+    }
+
+    if (lang !== 'en') {
+        return translate('en', ns, label);
+    }
+
+    return label;
+}
+
+export const _ = translate
+
+let _lang;
+
+export const getLang = () => {
+    if (!_lang) setLang();
+    return _lang;
+}
+
+export const setLang = (lang) => {
+    if (!lang) {
+        if (typeof navigator !== 'undefined' && navigator.language) {
+            lang = navigator.language;
+        } else if (typeof process !== 'undefined' && process.env) {
+            lang = (process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES);
+        }
+    }
+
+    _lang = (lang || 'en').trim().toLowerCase().slice(0, 2);
+}

package/src/index.js

@@ -0,0 +1,33 @@
+import * as stringFunctions from './string.js';
+import './stringPrototype.js';
+import * as arrayFunctions from './array.js';
+import * as traversal from './traversal.js';
+import dom, {getStyle, isDomElement, isWindow} from './dom.js';
+import * as math from './math.js';
+import * as utils from './utils.js';
+import * as i18n from './i18n.js';
+import eventDispatcher from './eventDispatcher.js'
+
+const webf = {
+    ...stringFunctions,
+    ...arrayFunctions,
+    ...traversal,
+    dom, isWindow, isDomElement, getStyle,
+    ...math,
+    ...utils,
+    ...i18n,
+    eventDispatcher
+}
+
+export default webf
+
+export {
+    stringFunctions,
+    arrayFunctions,
+    traversal,
+    getStyle,
+    dom,
+    math,
+    utils,
+    eventDispatcher,
+};

package/src/is.js

@@ -0,0 +1,89 @@
+import {inArray} from "./array.js";
+
+export const isString = function (str) {
+    return typeof(str) == 'string' || Object.prototype.toString.call(str) === '[object String]';
+}
+
+export const isObject = function (o) {
+    return !!o && !isArray(o) && typeof o === 'object';
+}
+
+export const isFunction = function(f) {
+    return !!f && typeof f === 'function';
+}
+
+export const isPlainObject = function(o) {
+    if (false === isObject(o)) return false
+    if (undefined === o.constructor) return true
+    if (false === isObject(o.constructor.prototype)) return false;
+    if (o.constructor.prototype.hasOwnProperty('isPrototypeOf') === false) return false;
+
+    return true;
+}
+
+export const isBoolean = function(b) {
+    return b === true || b === false;
+}
+
+export const isBool = isBoolean;
+
+export const isUndefined = function(v) {
+    return typeof v === 'undefined';
+}
+
+export const isArray = function(a) {
+    return Array.isArray(a);
+}
+
+export const isDate = function (o) {
+    return !!o && Object.prototype.toString.call(o) === '[object Date]'
+}
+
+export const isEvent = function(o) {
+    return isObject(o) && (!!o.preventDefault || /\[object Event\]/.test(o.constructor.toString()));
+}
+
+export const isInteger = function(n) {
+    return /^[\-]?\d+$/.test(n + '');
+}
+
+export const isInt = isInteger
+
+export const isFloat = function(n) {
+    return /^[\-]?\d+(\.\d+)?$/.test(n + '');
+}
+
+export const isScalar = (value) => {
+    const type = typeof value;
+
+    return value === null || inArray(type, ['string', 'number', 'bigint', 'symbol', 'boolean']);
+}
+
+export const isEventSupported = (function() {
+    const TAGNAMES = {
+        select: 'input',
+        change: 'input',
+        submit: 'form',
+        reset: 'form',
+        error: 'img',
+        load: 'img',
+        abort: 'img'
+    }
+
+    function isEventSupported(eventName) {
+        let el = document.createElement(TAGNAMES[eventName] || 'div');
+        eventName = 'on' + eventName;
+        const isSupported = (eventName in el);
+
+        el = null;
+
+        return isSupported;
+    }
+
+    return isEventSupported;
+})();
+
+export const isTouchDevice = function()
+{
+    return isEventSupported('touchstart');
+}

package/src/math.js

@@ -0,0 +1,109 @@
+import {each} from "./traversal.js";
+import {isArray, isFunction, isObject} from "./is.js";
+import {reverse} from "./string.js";
+
+export const round = function(val, precision = 0) {
+    return Math.round(val * Math.pow(10, precision)) / Math.pow(10, precision);
+}
+
+export const floorTo = function(n, precision) {
+    if (precision <= 0) throw new Error('Precision must be greater than 0');
+
+    return round(Math.floor(n / precision) * precision, 6);
+}
+
+export const plancher = floorTo
+
+export const min = function(list, cmp_func)
+{
+    if (isArray(list)) {
+        return Math.min.apply(null, list);
+    }
+
+    let min;
+
+    cmp_func = isFunction(cmp_func)
+        ? cmp_func
+        : function(a, b) {
+            return a < b ? -1 : 1;
+        }
+    ;
+
+    if (isObject(list)) {
+        each(list, function(key, val, obj, index) {
+            if (index === 0) {
+                min = val;
+            } else {
+                min = cmp_func.call(null, min, val) > 0 ? val : min;
+            }
+        });
+    }
+
+    return min;
+}
+
+export const max = function(list, cmp_func)
+{
+    if (isArray(list)) {
+        return Math.max.apply(null, list);
+    }
+
+    let max;
+
+    cmp_func = isFunction(cmp_func)
+        ? cmp_func
+        : function(a, b) {
+            return b - a;
+        }
+    ;
+
+    if (isObject(list)) {
+        each(list, function(key, val, obj, index) {
+            if (index === 0) {
+                max = val;
+            } else {
+                max = cmp_func.call(null, max, val) > 0 ? val : max;
+            }
+        });
+    }
+
+    return max;
+}
+
+/**
+ * Converts a decimal number into hexadecimal
+ *
+ * @param {number} n
+ * @returns {string}
+ */
+export const dec2hex = function(n)
+{
+    return n.toString(16);
+}
+
+/**
+ * Converts a hexadecimal into a decimal number
+ *
+ * @param {string} hex
+ * @returns {number}
+ */
+export const hex2dec = function(hex)
+{
+    hex = reverse(hex + '').toUpperCase();
+
+    const c = '0123456789ABCDEF';
+    let value = 0;
+
+    each(hex, (i, char) => {
+        const index = (c.indexOf(char));
+
+        if (index === -1) {
+            value = 0;
+            return false;
+        }
+
+        value += ((index) * Math.pow(2, 4 * i));
+    })
+
+    return value;
+}

package/src/random.js

@@ -0,0 +1,40 @@
+export const uniqid = function()
+{
+    return randAlpha(10);
+};
+
+export const randAlpha = function(n)
+{
+    return rand("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(','), n);
+};
+
+export const randAlphaCs = function(n)
+{
+    return rand("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','), n);
+};
+
+export const randAlphaNum = function(n)
+{
+    return rand("0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(','), n);
+};
+
+export const randAlphaNumCs = function(n)
+{
+    return rand("0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','), n);
+};
+
+export const randNum = function(n)
+{
+    return rand("0,1,2,3,4,5,6,7,8,9".split(','), n);
+};
+
+export const rand = function(range, n)
+{
+    let rand = "";
+
+    for (let i=0; i<n; i++) {
+        rand += range[Math.floor(Math.random() * 1000) % range.length];
+    }
+
+    return rand;
+};