@schukai/monster 1.12.0 → 1.15.0

package/source/i18n/locale.js

@@ -0,0 +1,322 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+import {Monster, assignToNamespace} from '../namespace.js';
+import {Base} from "../types/base.js";
+import {validateString} from "../types/validate.js";
+import {clone} from "../util/clone.js";
+
+/**
+ * @type {symbol}
+ */
+const propertiesSymbol = Symbol('properties');
+
+/**
+ * @type {symbol}
+ */
+const localeStringSymbol = Symbol('localeString');
+
+/**
+ * You can call the method via the monster namespace `new Monster.I18n.Locale()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/locale.js';
+ * console.log(new Monster.I18n.Locale())
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {Locale} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/locale.js';
+ * console.log(new Locale())
+ * </script>
+ * ```
+ *
+ * RFC
+ *
+ * ```
+ * A Language-Tag consists of:
+ * langtag                           ; generated tag
+ *           -or- private-use        ; a private use tag
+ *
+ * langtag       = (language
+ *                    ["-" script]
+ *                    ["-" region]
+ *                    *("-" variant)
+ *                    *("-" extension)
+ *                    ["-" privateuse])
+ *
+ * language      = "en", "ale", or a registered value
+ *
+ * script        = "Latn", "Cyrl", "Hant" ISO 15924 codes
+ *
+ * region        = "US", "CS", "FR" ISO 3166 codes
+ *                 "419", "019",  or UN M.49 codes
+ *
+ * variant       = "rozaj", "nedis", "1996", multiple subtags can be used in a tag
+ *
+ * extension     = single letter followed by additional subtags; more than one extension
+ *                 may be used in a language tag
+ *
+ * private-use   = "x-" followed by additional subtags, as many as are required
+ *                 Note that these can start a tag or appear at the end (but not
+ *                 in the middle)
+ * ```
+ *
+ * @since 1.13.0
+ * @copyright schukai GmbH
+ * @memberOf Monster/I18n
+ * @see https://datatracker.ietf.org/doc/html/rfc3066
+ */
+class Locale extends Base {
+
+    /**
+     * @param {string|undefined} language
+     * @param {string|undefined} region
+     * @param {string|undefined} script
+     * @param {string|undefined} variants
+     * @param {string|undefined} extlang
+     * @param {string|undefined} privateUse
+     * @throws {Error} unsupported locale
+     */
+    constructor(language, region, script, variants, extlang, privateUse) {
+        super();
+
+        this[propertiesSymbol] = {
+            language: (language === undefined) ? undefined : validateString(language),
+            script: (script === undefined) ? undefined : validateString(script),
+            region: (region === undefined) ? undefined : validateString(region),
+            variants: (variants === undefined) ? undefined : validateString(variants),
+            extlang: (extlang === undefined) ? undefined : validateString(extlang),
+            privateUse: (privateUse === undefined) ? undefined : validateString(privateUse),
+        };
+
+        let s = [];
+        if (language !== undefined) s.push(language);
+        if (script !== undefined) s.push(script);
+        if (region !== undefined) s.push(region);
+        if (variants !== undefined) s.push(variants);
+        if (extlang !== undefined) s.push(extlang);
+        if (privateUse !== undefined) s.push(privateUse);
+
+        if (s.length === 0) {
+            throw new Error('unsupported locale');
+        }
+
+        this[localeStringSymbol] = s.join('-');
+
+    }
+
+    /**
+     * @return {string}
+     */
+    get localeString() {
+        return this[localeStringSymbol];
+    }
+
+    /**
+     * @return {string|undefined}
+     */
+    get language() {
+        return this[propertiesSymbol].language;
+    }
+
+    /**
+     * @return {string|undefined}
+     */
+    get region() {
+        return this[propertiesSymbol].region;
+    }
+
+    /**
+     * @return {string|undefined}
+     */
+    get script() {
+        return this[propertiesSymbol].script;
+    }
+
+    /**
+     * @return {string|undefined}
+     */
+    get variants() {
+        return this[propertiesSymbol].variants;
+    }
+
+    /**
+     * @return {string|undefined}
+     */
+    get extlang() {
+        return this[propertiesSymbol].extlang;
+    }
+
+    /**
+     * @return {string|undefined}
+     */
+    get privateUse() {
+        return this[propertiesSymbol].privateValue;
+    }
+
+
+    /**
+     * @return {string}
+     */
+    toString() {
+        return "" + this.localeString;
+    }
+
+    /**
+     * @return {object}
+     */
+    getMap() {
+        return clone(this[propertiesSymbol])
+    }
+
+
+}
+
+
+/**
+ * Parse local according to rfc4646 standard
+ *
+ * Limitations: The regex cannot handle multiple variants or private.
+ *
+ * You can call the method via the monster namespace `Monster.I18n.createLocale()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/locale.js';
+ * console.log(new Monster.I18n.createLocale())
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {createLocale} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/locale.js';
+ * console.log(createLocale())
+ * </script>
+ * ```
+ *
+ * RFC
+ *
+ * ```
+ *   The syntax of the language tag in ABNF [RFC4234] is:
+ *
+ *   Language-Tag  = langtag
+ *                 / privateuse             ; private use tag
+ *                 / grandfathered          ; grandfathered registrations
+ *
+ *   langtag       = (language
+ *                    ["-" script]
+ *                    ["-" region]
+ *                    *("-" variant)
+ *                    *("-" extension)
+ *                    ["-" privateuse])
+ *
+ *   language      = (2*3ALPHA [ extlang ]) ; shortest ISO 639 code
+ *                 / 4ALPHA                 ; reserved for future use
+ *                 / 5*8ALPHA               ; registered language subtag
+ *
+ *   extlang       = *3("-" 3ALPHA)         ; reserved for future use
+ *
+ *   script        = 4ALPHA                 ; ISO 15924 code
+ *
+ *   region        = 2ALPHA                 ; ISO 3166 code
+ *                 / 3DIGIT                 ; UN M.49 code
+ *
+ *   variant       = 5*8alphanum            ; registered variants
+ *                 / (DIGIT 3alphanum)
+ *
+ *   extension     = singleton 1*("-" (2*8alphanum))
+ *
+ *   singleton     = %x41-57 / %x59-5A / %x61-77 / %x79-7A / DIGIT
+ *                 ; "a"-"w" / "y"-"z" / "A"-"W" / "Y"-"Z" / "0"-"9"
+ *                 ; Single letters: x/X is reserved for private use
+ *
+ *   privateuse    = ("x"/"X") 1*("-" (1*8alphanum))
+ *
+ *   grandfathered = 1*3ALPHA 1*2("-" (2*8alphanum))
+ *                   ; grandfathered registration
+ *                   ; Note: i is the only singleton
+ *                   ; that starts a grandfathered tag
+ *
+ *   alphanum      = (ALPHA / DIGIT)       ; letters and numbers
+ *
+ *                        Figure 1: Language Tag ABNF
+ * ```
+ *
+ * @param {string} locale
+ * @returns {Locale}
+ * @since 1.14.0
+ * @copyright schukai GmbH
+ * @memberOf Monster/I18n
+ * @throws {TypeError} value is not a string
+ * @throws {Error} unsupported locale
+ */
+function parseLocale(locale) {
+
+    locale = validateString(locale).replace(/_/g, "-");
+
+    let language, region, variants, parts, script, extlang,
+        regexRegular = "(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)",
+        regexIrregular = "(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)",
+        regexGrandfathered = "(" + regexIrregular + "|" + regexRegular + ")",
+        regexPrivateUse = "(x(-[A-Za-z0-9]{1,8})+)",
+        regexSingleton = "[0-9A-WY-Za-wy-z]",
+        regexExtension = "(" + regexSingleton + "(-[A-Za-z0-9]{2,8})+)",
+        regexVariant = "([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})",
+        regexRegion = "([A-Za-z]{2}|[0-9]{3})",
+        regexScript = "([A-Za-z]{4})",
+        regexExtlang = "([A-Za-z]{3}(-[A-Za-z]{3}){0,2})",
+        regexLanguage = "(([A-Za-z]{2,3}(-" + regexExtlang + ")?)|[A-Za-z]{4}|[A-Za-z]{5,8})",
+        regexLangtag = "(" + regexLanguage + "(-" + regexScript + ")?" + "(-" + regexRegion + ")?" + "(-" + regexVariant + ")*" + "(-" + regexExtension + ")*" + "(-" + regexPrivateUse + ")?" + ")",
+        regexLanguageTag = "^(" + regexGrandfathered + "|" + regexLangtag + "|" + regexPrivateUse + ")$",
+        regex = new RegExp(regexLanguageTag), match;
+
+
+    if ((match = regex.exec(locale)) !== null) {
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+    }
+
+    if (match === undefined || match === null) {
+        throw new Error('unsupported locale');
+    }
+
+    if (match[6] !== undefined) {
+        language = match[6];
+
+        parts = language.split('-');
+        if (parts.length > 1) {
+            language = parts[0];
+            extlang = parts[1];
+        }
+
+    }
+
+    if (match[14] !== undefined) {
+        region = match[14];
+    }
+
+    if (match[12] !== undefined) {
+        script = match[12];
+    }
+
+    if (match[16] !== undefined) {
+        variants = match[16];
+    }
+
+    return new Locale(language, region, script, variants, extlang);
+
+}
+
+
+assignToNamespace('Monster.I18n', Locale, parseLocale);
+export {Monster, Locale, parseLocale}

package/source/i18n/namespace.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * In this namespace you will find classes and methods for handling locale and localized texts.
+ * 
+ * @namespace Monster/I18n
+ * @author schukai GmbH
+ */
+
+
+/**
+ * @private
+ * @type {string}
+ */
+const namespace = "Monster.I18n";

package/source/i18n/provider.js

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+import {Monster, assignToNamespace} from '../namespace.js';
+import {BaseWithOptions} from "../types/basewithoptions.js";
+import {Locale} from "./locale.js"
+import {Translations} from "./translations.js"
+
+/**
+ * A provider makes a translation object available.
+ * 
+ * You can call the method via the monster namespace `new Monster.I18n.Provider()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/provider.js';
+ * console.log(new Monster.I18n.Provider())
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {Provider} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/provider.js';
+ * console.log(new Provider())
+ * </script>
+ * ```
+ *
+ * @since 1.13.0
+ * @copyright schukai GmbH
+ * @memberOf Monster/I18n
+ * @see https://datatracker.ietf.org/doc/html/rfc3066
+ */
+class Provider extends BaseWithOptions {
+
+    /**
+     * @param {Locale|string} locale
+     * @return {Promise}
+     */
+    getTranslations(locale) {
+        return new Promise((resolve, reject) => {
+            try {
+                resolve(new Translations(locale));
+            } catch (e) {
+                reject(e);
+            }
+
+        });
+    }
+
+}
+
+
+assignToNamespace('Monster.I18n', Provider);
+export {Monster, Provider}

package/source/i18n/providers/fetch.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+import {Monster, assignToNamespace} from '../../namespace.js';
+import {Formatter} from "../../text/formatter.js";
+import {getGlobalFunction} from "../../types/global.js";
+import { validateObject, validateString} from "../../types/validate.js";
+import {isString,  isInstance} from "../../types/is.js";
+import {parseLocale} from "../locale.js";
+import {Provider} from "../provider.js";
+import {PROPERTY_KEY_INTERNALDATA} from "../../constants.js";
+import {Translations} from "../translations.js";
+import {extend} from "../../data/extend.js";
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const optionsSymbol = Symbol.for(PROPERTY_KEY_INTERNALDATA);
+
+/**
+ * The fetch provider retrieves a JSON file from the given URL and returns a translation object.
+ *
+ * You can call the method via the monster namespace `new Monster.I18n.Provider()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/providers/fetch.js';
+ * console.log(new Monster.I18n.Providers.Fetch())
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {Fetch} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.15.0/dist/modules/i18n/providers/fetch.js';
+ * console.log(new Fetch())
+ * </script>
+ * ```
+ *
+ * @since 1.13.0
+ * @copyright schukai GmbH
+ * @memberOf Monster/I18n/Providers
+ * @see https://datatracker.ietf.org/doc/html/rfc3066
+ */
+class Fetch extends Provider {
+
+    /**
+     * As options the key `fetch` can be passed. This config object is passed to the fetch method as init.
+     *
+     * @param {string|URL} url
+     * @param {object} options
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/fetch
+     */
+    constructor(url, options) {
+        super(options);
+
+        if (isInstance(url, URL)) {
+            url = url.toString();
+        }
+
+        if (options === undefined) {
+            options = {};
+        }
+
+        validateString(url);
+
+        this.url = url;
+        this[optionsSymbol] = extend({}, super.defaults, this.defaults, validateObject(options));
+
+    }
+
+    /**
+     * Defaults
+     * @return {object}
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+     */
+    get defaults() {
+
+        return {
+            fetch: {
+                method: 'GET', // *GET, POST, PUT, DELETE, etc.
+                mode: 'cors', // no-cors, *cors, same-origin
+                cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached
+                credentials: 'omit', // include, *same-origin, omit
+                redirect: 'follow', // manual, *follow, error
+                referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
+            }
+        }
+
+    }
+
+    /**
+     *
+     * @param {Locale|string} locale
+     * @return {Promise}
+     */
+    getTranslations(locale) {
+
+        if (isString(locale)) {
+            locale = parseLocale(locale);
+        }
+
+        let formatter = new Formatter(locale.getMap())
+
+        return getGlobalFunction('fetch')(formatter.format(this.url), this.getOption('fetch', {}))
+            .then((response) => response.json()).then(data => {
+                return new Translations(locale).assignTranslations(data);
+            });
+
+    }
+
+
+}
+
+
+assignToNamespace('Monster.I18n.Providers', Fetch);
+export {Monster, Fetch}

package/source/i18n/providers/namespace.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * Namespace for different translation providers.
+ *
+ * @namespace Monster/I18n/Providers
+ * @author schukai GmbH
+ */
+
+
+/**
+ * @private
+ * @type {string}
+ */
+const namespace = "Monster.I18n.Providers";