@kizmann/pico-js 1.0.13 → 2.0.0

package/src/format/FormatOption.js

@@ -0,0 +1,108 @@
+import { Arr, For, Mix, Obj } from "#src/index.esm.js";
+
+export const OPTION_REGEX = {
+    entry: /(^|;)(\s*(?<key>.*?)\s*:\s*(?<val>".*?"|'.*?'|.*?)\s*)(?=;|$)/g
+};
+
+/**
+ * @memberof PicoFormat
+ */
+export class PicoFormatOptionStatic
+{
+
+    /**
+     * Cast object to options string
+     *
+     * @example Format.castOptions({ a: 1 }) // => "a: 1;"
+     *
+     * @param {any} [options] Input options
+     * @param {boolean} [space] Add space
+     * @returns {string} Options string
+     */
+    static castOptions(options = {}, space = true)
+    {
+        if ( Mix.isEmpty(options) ) {
+            return '';
+        }
+
+        let result = Arr.each(options, (val, key) => {
+            return this.castOption(key, val, null, space);
+        });
+
+        return result.join(';') + ';';
+    }
+
+    /**
+     * Cast single option to string
+     *
+     * @example Format.castOption("a", 1) // => "a: 1"
+     *
+     * @param {string} key Option key
+     * @param {any} value Option value
+     * @param {string} [path] Key path
+     * @param {boolean} [space] Add space
+     * @returns {string} Option string
+     */
+    static castOption(key, value, path = null, space = true)
+    {
+        if ( path != null ) {
+            key = path + '.' + key;
+        }
+
+        let div = space ? ': ' : ':';
+
+        if ( !Mix.isObj(value) ) {
+            return Mix.str(key) + div + For.casted(value, false);
+        }
+
+        let result = Arr.map(value, (v, k) => {
+            return this.castOption(k, v, key);
+        });
+
+        return result.join(';');
+    }
+
+    /**
+     * Parse options string
+     *
+     * @example Format.parseOptions("a: 1;") // => { a: 1 }
+     *
+     * @param {string} value Options string
+     * @returns {any} Options object
+     */
+    static parseOptions(value)
+    {
+        if ( Mix.isEmpty(value) ) {
+            return {};
+        }
+
+        let matches = value.matchAll(...[
+            OPTION_REGEX.entry
+        ]);
+
+        if ( matches == null ) {
+            return {};
+        }
+
+        const [key, val] = [
+            For.keyed, For.parsed
+        ];
+
+        return Arr.reduce(Array.from(matches), (result, { groups }) => {
+            return Obj.set(result, key(groups.key), val(groups.val));
+        }, {});
+    }
+
+}
+
+/**
+ * @returns {typeof import('#src/utils/Format.js').PicoFormat}
+ */
+export const PicoFormatOptionPlugin = function (self) {
+
+    Obj.each(Mix.class(PicoFormatOptionStatic), (fn, id) => {
+        self[id] = fn;
+    });
+
+    return self;
+}

package/src/format/FormatParam.js

@@ -0,0 +1,107 @@
+import { Arr, Mix, Obj, For } from "#src/index.esm.js";
+
+export const PARAM_REGEX = {
+    entry: /(?<=^|&|\?)(\s*(?<key>.*?)\s*=\s*(?<val>".*?"|'.*?'|.*?)\s*)(?=&|$)/g
+};
+
+/**
+ * @memberof PicoFormat
+ * @extends {PicoFormat}
+ */
+export class PicoFormatParamStatic
+{
+
+    /**
+     * Cast object to params string
+     *
+     * @example Format.castParams({ a: 1 }) // => "a=1"
+     *
+     * @param {any} [params] Input params
+     * @returns {string} Params string
+     */
+    static castParams(params = {})
+    {
+        if ( Mix.isEmpty(params) ) {
+            return '';
+        }
+
+        let result = Arr.each(params, (val, key) => {
+            return this.castParam(key, val);
+        });
+
+        return result.join('&');
+    }
+
+    /**
+     * Cast single param to string
+     *
+     * @example Format.castParam("a", 1) // => "a=1"
+     *
+     * @param {string} key Param key
+     * @param {any} value Param value
+     * @param {string} [path] Key path
+     * @returns {string} Param string
+     */
+    static castParam(key, value, path = null)
+    {
+        if ( path != null ) {
+            key = path + '[' + key + ']';
+        }
+
+        if ( !Mix.isRef(value) ) {
+            return Mix.str(key) + '=' + For.casted(value, true);
+        }
+
+        let result = Arr.each(value, (v, k) => {
+            return this.castParam(Mix.isArr(value) ? '' : k, v, key);
+        });
+
+        return result.join('&');
+    }
+
+    /**
+     * Parse params string
+     *
+     * @example Format.parseParams("a=1") // => { a: 1 }
+     *
+     * @param {string} value Params string
+     * @returns {any} Params object
+     */
+    static parseParams(value)
+    {
+        if ( Mix.isEmpty(value) ) {
+            return {};
+        }
+
+        value = decodeURIComponent(value);
+
+        let matches = value.matchAll(...[
+            PARAM_REGEX.entry
+        ]);
+
+        if ( matches == null ) {
+            return {};
+        }
+
+        const [key, val] = [
+            For.keyed, For.parsed
+        ];
+
+        return Arr.reduce(Array.from(matches), (result, { groups }) => {
+            return Obj.set(result, key(groups.key), val(groups.val));
+        }, {});
+    }
+
+}
+
+/**
+ * @returns {typeof import('#src/utils/Format.js').PicoFormat}
+ */
+export const PicoFormatParamPlugin = function (self) {
+
+    Obj.each(Mix.class(PicoFormatParamStatic), (fn, id) => {
+        self[id] = fn;
+    });
+
+    return self;
+}

package/src/format/FormatParser.js

@@ -0,0 +1,156 @@
+import { Mix, Obj } from "#src/index.esm.js";
+
+export const TYPE_PARSERS = [
+    { // null
+        match: (val) => {
+            return /^(null|undefined)$/i.test(val);
+        },
+        parse: (val) => {
+            return Mix.null(val);
+        }
+    },
+    { // boolean
+        match: (val) => {
+            return /^(true|false|yes|no)$/i.test(val);
+        },
+        parse: (val) => {
+            return Mix.bool(val);
+        }
+    },
+    { // integer
+        match: (val) => {
+            return /^-?[0-9]+$/.test(val);
+        },
+        parse: (val) => {
+            return Mix.int(val);
+        }
+    },
+    { // number
+        match: (val) => {
+            return /^-?[0-9]+\.[0-9]+$/.test(val);
+        },
+        parse: (val) => {
+            return Mix.num(val);
+        }
+    },
+    { // array
+        match: (val) => {
+            return /^[{\[].*?[}\]]$/.test(val);
+        },
+        parse: (val) => {
+            return JSON.parse(val);
+        }
+    },
+];
+
+export const TYPE_CASTERS = [
+    { // array
+        match: (val) => {
+            return Mix.isArr(val);
+        },
+        parse: (val) => {
+            return JSON.stringify(val);
+        }
+    }
+];
+
+/**
+ * @memberof PicoFormat
+ */
+export class PicoFormatParserStatic
+{
+
+    /**
+     * Convert key path format
+     *
+     * @example Format.keyed("a[b]") // => "a.b"
+     *
+     * @param {any} value Input key
+     * @param {any} [fallback] Fallback value
+     * @returns {string} Keyed string
+     */
+    static keyed(value, fallback = null)
+    {
+        if ( ! Mix.isStr(value) ) {
+            return fallback;
+        }
+
+        if ( value.indexOf('[') === -1 ) {
+            return value;
+        }
+
+        return value.replace(/\[([^\]]+)\]/g, '.$1');
+    }
+
+    /**
+     * Parse value by type
+     *
+     * @example Format.parsed("true") // => true
+     *
+     * @param {any} value Input value
+     * @param {any} [fallback] Fallback value
+     * @param {Array<any>} [parsers] Custom parsers
+     * @returns {any} Parsed value
+     */
+    static parsed(value, fallback = null, parsers = [])
+    {
+        if ( ! Mix.isStr(value) ) {
+            return fallback;
+        }
+
+        value = value.replace(/(^"|^'|'$|"$)/g, '');
+
+        for ( let type of parsers ) {
+            if ( type.match(value) ) return type.parse(value);
+        }
+
+        for ( let type of TYPE_PARSERS ) {
+            if ( type.match(value) ) return type.parse(value);
+        }
+
+        return value;
+    }
+
+    /**
+     * Cast value to string
+     *
+     * @example Format.casted(true) // => "true"
+     *
+     * @param {any} value Input value
+     * @param {boolean} [encode] Encode value
+     * @param {Array<any>} [casters] Custom casters
+     * @returns {string} Casted string
+     */
+    static casted(value, encode = false, casters = [])
+    {
+        if ( encode ) {
+            value = encodeURI(value);
+        }
+
+        if ( Mix.isStr(value) ) {
+            return value;
+        }
+
+        for ( let type of casters ) {
+            if ( type.match(value) ) return type.parse(value);
+        }
+
+        for ( let type of TYPE_CASTERS ) {
+            if ( type.match(value) ) return type.parse(value);
+        }
+
+        return Mix.str(value);
+    }
+}
+
+/**
+ * @returns {typeof import('#src/utils/Format.js').PicoFormat}
+ */
+export const PicoFormatParserPlugin = function (self) {
+
+    Obj.each(Mix.class(PicoFormatParserStatic), (fn, id) => {
+        self[id] = fn;
+    });
+
+    return self;
+}

package/src/format/FormatUrl.js

@@ -0,0 +1,75 @@
+import { Arr, Mix, Obj } from "#src/index.esm.js";
+
+export const SLUG_CONVERT = [
+    ['à', 'a'],
+    ['á', 'a'],
+    ['â', 'a'],
+    ['è', 'e'],
+    ['é', 'e'],
+    ['ê', 'e'],
+    ['ì', 'i'],
+    ['í', 'i'],
+    ['ï', 'i'],
+    ['î', 'i'],
+    ['ò', 'o'],
+    ['ó', 'o'],
+    ['ô', 'o'],
+    ['ù', 'u'],
+    ['ú', 'u'],
+    ['û', 'u'],
+    ['ñ', 'n'],
+    ['ç', 'c'],
+    ['.', '-'],
+    ['·', '-'],
+    ['/', '-'],
+    ['_', '-'],
+    [',', '-'],
+    [':', '-'],
+    [';', '-'],
+    ['ä', 'ae'],
+    ['ö', 'oe'],
+    ['ü', 'ue'],
+    ['ß', 'ss'],
+];
+
+/**
+ * @memberof PicoFormat
+ * @extends {PicoFormat}
+ */
+export class PicoFormatUrlStatic
+{
+
+    /**
+     * Create slug from string
+     *
+     * @example Format.slugify("Hello World") // => "hello-world"
+     *
+     * @param {any} value Input string
+     * @returns {string} Slug string
+     */
+    static slugify(value)
+    {
+        value = String(value).replace(/(^\s+|\s+$)/g, '')
+            .toLowerCase();
+
+        Arr.each(SLUG_CONVERT, (v) => {
+            value = value.replaceAll(v[0], v[1]);
+        });
+
+        return value.replace(/[^a-z0-9-\s]+/g, '')
+            .replace(/\s+/g, '-').replace(/-+/g, '-');
+    }
+
+}
+
+/**
+ * @returns {typeof import('#src/utils/Format.js').PicoFormat}
+ */
+export const PicoFormatUrlPlugin = function (self) {
+
+    Obj.each(Mix.class(PicoFormatUrlStatic), (fn, id) => {
+        self[id] = fn;
+    });
+
+    return self;
+}

package/src/index.browser.js

@@ -0,0 +1,10 @@
+import * as pi from "#src/index.esm.js";
+
+// Force immediate global access
+if (typeof globalThis !== 'undefined') {
+    if ( globalThis.pi === undefined ) {
+        globalThis.pi = pi;
+    } else {
+        globalThis.pix = pi;
+    }
+}

package/src/index.esm.js

@@ -0,0 +1,138 @@
+// You will be removed soon
+import { default as Data } from "#src/utils/Data.js";
+import { default as Route } from "#src/utils/Route.js";
+
+// Work in progress (not started yet)
+import { default as Map } from "#src/wip/Map.js";
+import { default as Element } from "#src/wip/Element.js";
+
+export {
+    Map, Data, Route, Element
+}
+
+/**
+ * @typedef {typeof import("#src/tool/scope.js").go} PicoToolGo
+ * @type {PicoToolGo}
+ */
+import { go as PicoToolGo } from "#src/tool/scope.js";
+export const go = PicoToolGo;
+
+/**
+ * @typedef {typeof import("#src/tool/scope.js").browser} PicoToolBrowser
+ * @type {PicoToolBrowser}
+ */
+import { browser as PicoToolBrowser } from "#src/tool/scope.js";
+export const browser = PicoToolBrowser;
+
+/**
+ * @typedef {typeof import("#src/tool/scope.js").device} PicoToolDevice
+ * @type {PicoToolDevice}
+ */
+import { device as PicoToolDevice } from "#src/tool/scope.js";
+export const device = PicoToolDevice;
+
+/**
+ * @typedef {typeof import("#src/utils/Dom.js").PicoDom} PicoDom
+ * @type {PicoDom}
+ */
+import { default as DomBuilder } from "#src/utils/Dom.js";
+export const Dom = DomBuilder();
+
+/**
+ * @typedef {typeof import("#src/utils/Now.js").PicoNow} PicoNow
+ * @type {PicoNow}
+ */
+import { default as NowBuilder } from "#src/utils/Now.js";
+export const Now = NowBuilder();
+
+/**
+ * @typedef {typeof import("#src/utils/Format.js").PicoFormat} PicoFormat
+ * @type {PicoFormat}
+ */
+import { default as ForBuilder } from "#src/utils/Format.js";
+export const For = ForBuilder();
+
+/**
+ * @typedef {typeof import("#src/utils/Runner.js").PicoRunner} PicoRunner
+ * @type {PicoRunner}
+ */
+import { default as PicoRunner } from "#src/utils/Runner.js";
+export const Run = PicoRunner;
+
+/**
+ * @typedef {typeof import("#src/utils/String.js").PicoString} PicoString
+ * @type {PicoString}
+ */
+import { default as PicoString } from "#src/utils/String.js";
+export const Str = PicoString;
+
+/**
+ * @typedef {typeof import("#src/utils/Number.js").PicoNumber} PicoNumber
+ * @type {PicoNumber}
+ */
+import { default as PicoNumber } from "#src/utils/Number.js";
+export const Num = PicoNumber;
+
+/**
+ * @typedef {typeof import("#src/utils/Array.js").PicoArray} PicoArray
+ * @type {PicoArray}
+ */
+import { default as PicoArray } from "#src/utils/Array.js";
+export const Arr = PicoArray;
+
+/**
+ * @typedef {typeof import("#src/utils/Object.js").PicoObject} PicoObject
+ * @type {PicoObject}
+ */
+import { default as PicoObject } from "#src/utils/Object.js";
+export const Obj = PicoObject;
+
+/**
+ * @typedef {typeof import("#src/utils/Mixed.js").PicoMixed} PicoMixed
+ * @type {PicoMixed}
+ */
+import { default as PicoMixed } from "#src/utils/Mixed.js";
+export const Mix = PicoMixed;
+
+/**
+ * @typedef {typeof import("#src/utils/Hash.js").PicoHash} PicoHash
+ * @type {PicoHash}
+ */
+import { default as PicoHash } from "#src/utils/Hash.js";
+export const Hash = PicoHash;
+
+/**
+ * @typedef {typeof import("#src/utils/Event.js").PicoEvent} PicoEvent
+ * @type {PicoEvent}
+ */
+import { default as PicoEvent } from "#src/utils/Event.js";
+export const Event = PicoEvent;
+
+/**
+ * @typedef {typeof import("#src/utils/Locale.js").PicoLocale} PicoLocale
+ * @type {PicoLocale}
+ */
+import { default as PicoLocale } from "#src/utils/Locale.js";
+export const Locale = PicoLocale;
+
+/**
+ * @typedef {typeof import("#src/utils/Cookie.js").PicoCookie} PicoCookie
+ * @type {PicoCookie}
+ */
+import { default as PicoCookie } from "#src/utils/Cookie.js";
+export const Cookie = PicoCookie;
+
+
+// Polyfills Any
+export const Any = new Proxy({}, {
+    get: function (target, prop) {
+        console.warn(`Any.${prop} is deprecated, use Mix.${prop}() instead.`);
+        return (...args) => Mix[prop](...args);
+    }
+});
+
+// Polyfills UUID
+export const UUID = function () {
+    console.warn('UUID() is deprecated, use Hash.make() instead.');
+    return Hash.make();
+};