@webalternatif/js-core 1.6.0 → 1.6.4

package/src/Translator.js

@@ -0,0 +1,148 @@
+import { isFunction, isPlainObject } from './is.js'
+import { each, extend } from './traversal.js'
+
+/**
+ * @typedef {string|(()=>string)} TranslatorValue
+ */
+
+/**
+ * @typedef {Record<string,Record<string,Record<string,TranslatorValue>>>} TranslatorNsMapping
+ */
+
+/**
+ * @typedef {Record<string,Record<string,TranslatorValue>>} TranslatorCoreMapping
+ */
+
+/**
+ * @typedef {TranslatorNsMapping | TranslatorCoreMapping} TranslatorMapping
+ */
+
+class Translator {
+    /** @type string */
+    #lang
+
+    /** @type TranslatorMapping */
+    #mapping
+
+    /**
+     * @param {TranslatorMapping} mapping
+     * @param {string} [defaultLang]
+     */
+    constructor(mapping, defaultLang) {
+        this.#setMapping(mapping)
+        this.setLang(defaultLang)
+    }
+
+    #setMapping(mapping) {
+        let nsMapping = {},
+            coreMapping = {}
+
+        each(mapping, (ns, langs) => {
+            each(langs, (lang, trads) => {
+                if (isPlainObject(trads)) {
+                    if (undefined === nsMapping[ns]) nsMapping[ns] = {}
+                    nsMapping[ns][lang] = trads
+                } else {
+                    if (undefined === coreMapping[ns]) coreMapping[ns] = {}
+                    coreMapping[ns][lang] = trads
+                }
+            })
+        })
+
+        this.#mapping = extend(true, nsMapping, {
+            core: extend({}, nsMapping.core || {}, coreMapping),
+        })
+    }
+
+    /**
+     * @param {string} label
+     * @param {string} [lang]
+     * @param {string} [namespace='core']
+     * @returns {string}
+     */
+    translate(label, lang, namespace = 'core') {
+        lang = undefined === lang ? this.getLang() : lang
+
+        const translationExists =
+            undefined !== this.#mapping[namespace] &&
+            undefined !== this.#mapping[namespace][lang] &&
+            undefined !== this.#mapping[namespace][lang][label]
+
+        if (translationExists) {
+            const entry = this.#mapping[namespace][lang][label]
+            return this.#resolve(entry)
+        }
+
+        return 'en' !== lang ? this.translate(label, 'en', namespace) : label
+    }
+
+    /**
+     * @param {string} label
+     * @param {string} from - Language from.
+     * @param {string} to - Language to.
+     * @param {string} [namespace='core']
+     */
+    translateFrom(label, from, to, namespace = 'core') {
+        if (!label) return label
+
+        const mapNs = this.#mapping?.[namespace]
+        if (!mapNs) return label
+
+        const mapFrom = mapNs?.[from]
+        const mapTo = mapNs?.[to]
+        if (!mapFrom || !mapTo) return label
+
+        const key = this.#findKeyByValue(mapFrom, label)
+        if (!key) return label
+
+        const entryTo = mapTo[key]
+        const resolvedTo = this.#resolve(entryTo)
+
+        return resolvedTo ?? label
+    }
+
+    _(...args) {
+        return this.translate(...args)
+    }
+
+    getLang() {
+        return this.#lang
+    }
+
+    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
+            }
+        }
+
+        this.#lang = (lang || 'en').trim().toLowerCase().slice(0, 2)
+    }
+
+    #findKeyByValue(entries, label) {
+        for (const key in entries) {
+            const resolved = this.#resolve(entries[key])
+            if (resolved === label) return key
+        }
+
+        return null
+    }
+
+    #resolve(entry) {
+        if (isFunction(entry)) {
+            return entry()
+        }
+
+        return entry
+    }
+}
+
+export default Translator
+
+/* istanbul ignore next */
+if (typeof window !== 'undefined') {
+    window.webf = window.webf || {}
+    window.webf.Translator = Translator
+}

package/src/array.js

@@ -0,0 +1,136 @@
+import { each, map } from './traversal.js'
+import { isArray, isInteger, isObject, isString, isUndefined } from './is.js'
+import { round } from './math.js'
+import { equals } from './utils.js'
+
+/**
+ * Checks if a value exists in an array or an object
+ *
+ * @param {any} value the searched value
+ * @param {Object|Array} arr the array
+ * @param {number} [index=0] if provided, search from this index
+ * @param {boolean} [strict=false] if true, search is done with strict equality
+ * @returns {boolean}
+ *
+ * @example
+ * inArray(2, [1, 2, 3]) => true
+ *
+ * @example
+ * inArray({a: 1}, {a: 1, b: 2}) // => true
+ *
+ * @example
+ * inArray(5, [1, 2, 3]) // => false
+ */
+export const inArray = function (value, arr, index = 0, strict = false) {
+    let ret = false
+
+    each(arr, (i, val) => {
+        if (i >= index) {
+            if (strict) {
+                if (val === value) {
+                    ret = true
+                    return false
+                }
+            } else {
+                if (isObject(value) && isObject(val)) {
+                    ret = equals(val, value)
+                    return false
+                } else if (isArray(value) && isObject(val)) {
+                    ret = equals(val, value)
+                    return false
+                    // eslint-disable-next-line eqeqeq
+                } else if (val == value) {
+                    ret = true
+                    return false
+                }
+            }
+        }
+    })
+
+    return ret
+}
+
+/**
+ * Returns the first index at which a given element can be found in an array or a string.
+ * or -1 if it is not present.
+ *
+ * @param {Array<any>|string} arr - The array to search in
+ * @param {any} elt - The element to search for
+ * @param {number} [from] - The index to start the search from. Can be negative.
+ * @returns {number} - The index of the element, or -1 if not found
+ */
+export const indexOf = function (arr, elt, from = 0) {
+    const a = isString(arr) ? map(arr, (_, a) => a) : arr
+
+    from = from < 0 ? Math.ceil(from) + a.length : Math.floor(from)
+
+    for (; from < a.length; from++) {
+        if (from in a && a[from] === elt) {
+            return from
+        }
+    }
+
+    return -1
+}
+
+/**
+ * Returns the last index at which a given element can be found in an array or a string.
+ * or -1 if it is not present.
+ *
+ * @param {Array<any>|string} arr - The array to search in
+ * @param {any} elt - The element to search for
+ * @param {number} [from] - The index to start the search from. Can be negative.
+ * @returns {number} - The index of the element, or -1 if not found
+ */
+export const lastIndexOf = function (arr, elt, from = -1) {
+    const a = isString(arr) ? map(arr, (_, a) => a) : arr
+
+    from = from < 0 ? a.length + Math.ceil(from) : Math.floor(from)
+
+    for (; from >= 0; from--) {
+        if (from in a && a[from] === elt) {
+            return from
+        }
+    }
+
+    return -1
+}
+
+export const arrayUnique = function (arr) {
+    return arr.filter((el, index, arr) => index === indexOf(arr, el))
+}
+
+export const array_unique = arrayUnique
+
+export const arrayDiff = (array1, array2, strict = false) => {
+    return array1.filter((item) => !inArray(item, array2, 0, strict))
+}
+
+export const array_diff = arrayDiff
+
+export const range = function (size, startAt = 0, step = 1) {
+    size = round(size)
+    step = round(step)
+
+    const rng = []
+
+    if (isUndefined(startAt) || size < 1 || step === 0 || size < Math.abs(step)) {
+        return rng
+    }
+
+    const end = size * step
+
+    if (isString(startAt)) {
+        startAt = startAt.charCodeAt(0)
+
+        for (let i = 0; step > 0 ? i < end : i > end; i += step) {
+            rng.push(String.fromCharCode(startAt + i))
+        }
+    } else if (isInteger(startAt)) {
+        for (let i = 0; step > 0 ? i < end : i > end; i += step) {
+            rng.push(startAt + i)
+        }
+    }
+
+    return rng
+}