@kizmann/pico-js 1.0.13 → 2.0.0

package/src/utils/Event.js

@@ -0,0 +1,140 @@
+import { Str, Event, For, Mix, Arr } from "#src/index.esm.js";
+export class PicoEvent
+{
+    static $events = [];
+
+    /**
+     * Bind callback to event name
+     *
+     * @example Event.bind("x", cb) // => Event
+     * @example Event.bind(["a","b"], cb) // => Event
+     *
+     * @param {any} event Event name(s)
+     * @param {function} cb Event callback
+     * @param {any} [options] Listener options
+     * @param {boolean} [paused] Start paused
+     * @returns {typeof PicoEvent} Event class
+     */
+    static bind(event, cb, options = {}, paused = false)
+    {
+        if ( Mix.isArr(event) ) {
+            return Arr.each(event, (e) => this.bind(e, ...arguments), this);
+        }
+
+        if ( Mix.isPrim(options) ) {
+            options = { id: options };
+        }
+
+        this.$events = Arr.append(this.$events, {
+            event, cb, options, paused
+        });
+
+        return this;
+    }
+
+    /**
+     * Unbind callback(s) from event
+     *
+     * @example Event.unbind("x") // => Event
+     * @example Event.unbind(["a","b"]) // => Event
+     *
+     * @param {any} event Event name(s)
+     * @param {any} [options] Listener options
+     * @returns {typeof PicoEvent} Event class
+     */
+    static unbind(event, options = {})
+    {
+        if ( Mix.isArr(event) ) {
+            return Arr.each(event, (e) => this.unbind(e, ...arguments), this);
+        }
+
+        if ( Mix.isPrim(options) ) {
+            options = { id: options };
+        }
+
+        Arr.remove(this.$events, {
+            event, options
+        });
+
+        return this;
+    }
+
+    /**
+     * Fire event with arguments
+     *
+     * @example Event.fire("x", 1) // => Event
+     *
+     * @param {string} event Event name
+     * @param {...any} [args] Event args
+     * @returns {typeof PicoEvent} Event class
+     */
+    static fire(event, ...args)
+    {
+        let events = this.$events.filter((item) => {
+            return item.event === event;
+        });
+
+        Arr.each(events, (e) => {
+            if ( ! e.paused ) {
+                e.cb.call({}, ...args);
+            }
+        });
+
+        return this;
+    }
+
+    /**
+     * Pause listeners for event
+     *
+     * @example Event.pause("x") // => Event
+     *
+     * @param {any} event Event name(s)
+     * @param {any} [options] Listener options
+     * @returns {typeof PicoEvent} Event class
+     */
+    static pause(event, options = {})
+    {
+        if ( Mix.isArr(event) ) {
+            return Arr.each(event, (e) => this.pause(e, ...arguments), this);
+        }
+
+        let value = Arr.find(this.$events, {
+            event, options
+        });
+
+        if ( value != null ) {
+            value.paused = true;
+        }
+
+        return this;
+    }
+
+    /**
+     * Unpause listeners for event
+     *
+     * @example Event.unpause("x") // => Event
+     *
+     * @param {any} event Event name(s)
+     * @param {any} [options] Listener options
+     * @returns {typeof PicoEvent} Event class
+     */
+    static unpause(event, options = {})
+    {
+        if ( Mix.isArr(event) ) {
+            return Arr.each(event, (e) => this.pause(e, ...arguments), this);
+        }
+
+        let value = Arr.find(this.$events, {
+            event, options
+        });
+
+        if ( value != null ) {
+            value.paused = false;
+        }
+
+        return this;
+    }
+
+}
+
+export default PicoEvent;

package/src/utils/Format.js

@@ -0,0 +1,62 @@
+import { PicoFormatParserPlugin } from "#src/format/FormatParser.js";
+import { PicoFormatParamPlugin } from "#src/format/FormatParam.js";
+import { PicoFormatOptionPlugin } from "#src/format/FormatOption.js";
+import { PicoFormatUrlPlugin } from "#src/format/FormatUrl.js";
+import { PicoFormatFilePlugin } from "#src/format/FormatFile.js";
+
+export const PicoFormatPlugins = [
+    PicoFormatParserPlugin,
+    PicoFormatParamPlugin,
+    PicoFormatOptionPlugin,
+    PicoFormatUrlPlugin,
+    PicoFormatFilePlugin,
+];
+
+/**
+ * @class PicoFormat
+ *
+ * @typedef {import('#src/format/FormatParser.js').PicoFormatParserStatic} PicoFormatParserStatic
+ * @typedef {import('#src/format/FormatParam.js').PicoFormatParamStatic} PicoFormatParamStatic
+ * @typedef {import('#src/format/FormatOption.js').PicoFormatOptionStatic} PicoFormatOptionStatic
+ * @typedef {import('#src/format/FormatUrl.js').PicoFormatUrlStatic} PicoFormatUrlStatic
+ * @typedef {import('#src/format/FormatFile.js').PicoFormatFileStatic} PicoFormatFileStatic
+ *
+ * @mixes PicoFormatParserStatic
+ * @mixes PicoFormatParamStatic
+ * @mixes PicoFormatOptionStatic
+ * @mixes PicoFormatUrlStatic
+ * @mixes PicoFormatFileStatic
+ */
+export class PicoFormat
+{
+
+    /**
+     * Extend format with a plugin
+     *
+     * @example For.extend(fn)
+     *
+     * @param {function} plugin Plugin function
+     * @returns {void} No return value
+     */
+    static extend(plugin)
+    {
+        plugin.call({}, this);
+    }
+
+}
+
+/**
+ * @returns {typeof PicoFormat}
+ */
+export function PicoFormatBuilder() {
+
+    let cls = PicoFormat;
+
+    for ( const plugin of PicoFormatPlugins ) {
+        cls = plugin.call(cls, cls);
+    }
+
+    return cls;
+}
+
+export default PicoFormatBuilder;

package/src/utils/Hash.js

@@ -0,0 +1,164 @@
+import { Str, Hash } from "#src/index.esm.js";
+
+/**
+ * @var {Array<string>} RADIX_NUMBER Radix from 0 to 9
+ */
+export const RADIX_NUMBER = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+];
+
+/**
+ * @var {Array<string>} RADIX_LETTER_LC Radix from a to z
+ */
+export const RADIX_LETTER_LC = [
+    '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',
+];
+
+/**
+ * @var {Array<string>} RADIX_LETTER_UC Radix from A to Z
+ */
+export const RADIX_LETTER_UC = [
+    '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'
+];
+
+/**
+ * @var {Array<string>} RADIX_UUID Radix from 0-9, a-f and A-F
+ */
+export const RADIX_UUID = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F',
+];
+
+
+/**
+ * @var {Array<string>} RADIX_UP19 Radix with 8, 9, a and b
+ */
+export const RADIX_UP19 = [
+    '8', '9', 'a', 'b',
+];
+
+/**
+ * @var {Array<string>} radix_symbol_pass Radix for passwords
+ */
+export const radix_symbol_pass = [
+    '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '-', '=', '[', ']', '{', '}', ';', ':', ',', '.', '/', '<', '>', '?'
+];
+
+export class PicoHash
+{
+
+    /**
+     * @var {Array<string>} RADIX
+     */
+    static RADIX = [
+        ...RADIX_NUMBER, ...RADIX_LETTER_LC, ...RADIX_LETTER_UC
+    ];
+
+    /**
+     * Get random char from radix
+     *
+     * @example Hash.radix(2, ['R', 'f']) // => 'R' or 'f'
+     *
+     * @param {number} [limit=60] Maximum radix char index
+     * @param {Array<string>} [radix=null] A defined radix or null for default
+     * @returns {string} Returns random char from radix
+     */
+    static radix(limit = 60, radix = null)
+    {
+        return (radix || this.RADIX)[this.number(limit - 1)];
+    }
+
+    /**
+     * Get random number
+     *
+     * @example Hash.number(20, 18) // => 18, 19 or 20
+     *
+     * @param {number} [limit=1024] Maximum value
+     * @param {number} [start=0] Minimum value
+     * @returns {number} Returns a random number between start and limit
+     */
+    static number(limit = 1024, start = 0)
+    {
+        return Math.floor(Math.random() * (limit - start + 1)) + start;
+    }
+
+    /**
+     * Get a random hash with given options
+     *
+     * @example Hash.make(4, 32, { 0: '?' }) // => '?8Wj'
+     *
+     * @param {number} [length] Length of generated hash
+     * @param {number} [radix] Maximum radix char index (10 for 0-9, 36 incl. a-z, 62 incl. A-Z)
+     * @param {Record<number, string>} [map] Remap for generated string
+     * @returns {string} Returns a random hash with fixed length
+     */
+    static make(length = 6, radix = 62, map = {})
+    {
+        let hash = '';
+
+        for ( let i = 0; i < length; i ++ ) {
+            hash += Hash.radix(radix);
+        }
+
+        for ( const k of Object.keys(map) ) {
+            hash = Str.set(hash, k, map[k]);
+        }
+
+        return hash;
+    }
+
+    /**
+     * Get a valid v4 UUID
+     *
+     * @example Hash.uuid() // => 'FBbA001F-0a01-4bE8-b29C-A9c47fA090f'
+     *
+     * @param {string|number} [version] UUID version number
+     * @returns {string} Returns a valid UUID
+     */
+    static uuid(version = 4)
+    {
+        let hash = '';
+
+        // Use only selected chars from the radix store
+        for ( let i = 0; i < 31; i ++ ) {
+            if ( i === 15 ) {
+                hash += Hash.radix(RADIX_UP19.length, RADIX_UP19);
+            } else {
+                hash += Hash.radix(RADIX_UUID.length, RADIX_UUID);
+            }
+        }
+
+        // For higher performance use substring
+        return hash.substring(0, 8)
+            + '-' + hash.substring(8, 12)
+            + '-' + version + hash.substring(12, 15)
+            + '-' + hash.substring(15, 19)
+            + '-' + hash.substring(19, 31);
+    }
+
+    /**
+     * Generate a password with or without symbols
+     *
+     * @example Hash.password(12, ['%', '&']) // => '0unJ%VDi2RJX'
+     *
+     * @param {number} [length=24] Length of password
+     * @param {Array<string>} [symbols=null] Defined symbols or null for default
+     * @returns {string} A random password with fixed length
+     */
+    static password(length = 24, symbols = null)
+    {
+        let radix = [
+            ...this.RADIX, ...(symbols || radix_symbol_pass)
+        ];
+
+        let hash = '';
+
+        for ( let i = 0; i < length; i ++ ) {
+            hash += Hash.radix(radix.length, radix);
+        }
+
+        return hash;
+    }
+
+}
+
+export default PicoHash;

package/src/utils/Locale.js

@@ -0,0 +1,229 @@
+import { Mix, Obj, Locale } from "#src/index.esm.js";
+
+export class PicoLocale
+{
+    /**
+     * Translation dictionary
+     *
+     * @type {Record<any, any>}
+     */
+    static $text = {};
+
+    /**
+     * Cached collator instance
+     *
+     * @type {Intl.Collator|null}
+     */
+    static $sort = null;
+
+    /**
+     * Active locale code
+     *
+     * @type {string}
+     */
+    static $code = 'en';
+
+    /**
+     * Check if translation key exists
+     *
+     * @example Locale.has("known.key") // => true
+     * @example Locale.has("unknown.key") // => false
+     *
+     * @param {any} [key] Translation key
+     * @returns {boolean} True if exists
+     */
+    static has(key = undefined)
+    {
+        if ( key === undefined ) {
+            return true;
+        }
+
+        return Mix.has(PicoLocale.$text, key);
+    }
+
+    /**
+     * Get translation value or map
+     *
+     * @example Locale.get("known.key") // => "value"
+     * @example Locale.get() // => object
+     *
+     * @param {any} [key] Translation key
+     * @param {any} [fallback] Fallback value
+     * @returns {any} Translation value
+     */
+    static get(key = undefined, fallback = null)
+    {
+        if ( key === undefined ) {
+            return PicoLocale.$text;
+        }
+
+        return Obj.get(PicoLocale.$text, key, fallback);
+    }
+
+    /**
+     * Set translation key or map
+     *
+     * @example Locale.set({foo:"bar"})
+     * @example Locale.set("unknown", "nix")
+     *
+     * @param {any} [key] Key or map
+     * @param {any} [value] Value to set
+     * @returns {any} Updated map
+     */
+    static set(key = undefined, value = undefined)
+    {
+        if ( value === undefined ) {
+            return PicoLocale.$text = key;
+        }
+
+        return Obj.set(PicoLocale.$text, key, value);
+    }
+
+    /**
+     * Get or set locale code
+     *
+     * @example Locale.code() // => "en"
+     * @example Locale.code("de") // => "de"
+     *
+     * @param {string|null} [code] Locale code
+     * @returns {string} Active code
+     */
+    static code(code = null)
+    {
+        if ( ! Mix.isNull(code) ) {
+            return Locale.$code = code;
+        }
+
+        if ( ! Mix.isNull(Locale.$code) ) {
+            return Locale.$code;
+        }
+
+        Locale.$code = (navigator.language || 'en-US')
+            .replace(/-[A-Z]+$/, '');
+
+        return Locale.$code;
+    }
+
+    /**
+     * Get Intl.Collator for sorting
+     *
+     * @example Locale.collator().compare("a","b")
+     *
+     * @returns {Intl.Collator} Collator instance
+     */
+    static collator()
+    {
+        if ( ! Mix.isNull(Locale.$sort) ) {
+            return Locale.$sort;
+        }
+
+        Locale.$sort = new Intl.Collator(Locale.code(), {
+            numeric: true, sensitivity: 'base'
+        });
+
+        return Locale.$sort;
+    }
+
+    /**
+     * Replace :tokens in text
+     *
+     * @example Locale.replace("Hi :x", {x:"Bob"}) // => "Hi Bob"
+     * @example Locale.replace("Hi", null) // => "Hi"
+     *
+     * @param {string} text Input text
+     * @param {any} [replace] Replace map
+     * @returns {string} Replaced text
+     */
+    static replace(text, replace = null)
+    {
+        if ( replace == null ) {
+            return text;
+        }
+
+        Obj.each(replace, (val, key) => {
+            text = text.replace(new RegExp(':' + key, 'g'), val);
+        });
+
+        return text;
+    }
+
+    /**
+     * Translate key with replace map
+     *
+     * @example Locale.trans("known.key") // => "..."
+     * @example Locale.trans("Hi :x", {x:"Bob"}) // => "Hi Bob"
+     *
+     * @param {string} text Key or text
+     * @param {any} [replace] Replace map
+     * @returns {string} Translated text
+     */
+    static trans(text, replace = null)
+    {
+        text = Obj.get(PicoLocale.$text, text, text);
+
+        return Locale.replace(text, replace);
+    }
+
+    /**
+     * Translate plural choice by count
+     *
+     * @example Locale.choice("items", 2) // => "..."
+     * @example Locale.choice("items", 1, {x:"y"}) // => "..."
+     *
+     * @param {string} text Key or text
+     * @param {number} [count] Choice count
+     * @param {any} [replace] Replace map
+     * @returns {string} Chosen text
+     */
+    static choice(text, count = 0, replace = {})
+    {
+        text = Obj.get(PicoLocale.$text, text, text);
+
+        if ( typeof replace.count === 'undefined' ) {
+            replace.count = count;
+        }
+
+        text = Locale.countpick(text.split('|'), count);
+
+        return Locale.replace(text, replace);
+    }
+
+    /**
+     * Pick plural variant from list
+     *
+     * @example Locale.countpick(["a","b"], 2) // => "b"
+     *
+     * @param {Array<string>} splits Variant list
+     * @param {number} count Choice count
+     * @returns {string} Picked text
+     */
+    static countpick(splits, count)
+    {
+        let length = splits.length;
+
+        if ( length === 3 && count === 0 ) {
+            return splits[0];
+        }
+
+        if ( length === 3 && count === 1 ) {
+            return splits[1];
+        }
+
+        if ( length === 3 && count >= 2 ) {
+            return splits[2];
+        }
+
+        if ( length === 2 && count === 1 ) {
+            return splits[0];
+        }
+
+        if ( length === 2 && count !== 1 ) {
+            return splits[1];
+        }
+
+        return splits[0];
+    }
+
+}
+
+export default PicoLocale