@kizmann/pico-js 1.0.14 → 2.0.1

package/src/format/FormatOption.js

@@ -0,0 +1,110 @@
+import { Arr, For, Mix, Obj } from "../index.esm.js";
+import { PicoFormat } from "../utils/Format.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));
+        }, {});
+    }
+
+}
+
+/**
+ * @param {typeof PicoFormat} self
+ * @returns {typeof 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,109 @@
+import { Arr, Mix, Obj, For } from "../index.esm.js";
+import { PicoFormat } from "../utils/Format.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));
+        }, {});
+    }
+
+}
+
+/**
+ * @param {typeof PicoFormat} self
+ * @returns {typeof 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,158 @@
+import { Mix, Obj } from "../index.esm.js";
+import { PicoFormat } from "../utils/Format.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);
+    }
+}
+
+/**
+ * @param {typeof PicoFormat} self
+ * @returns {typeof 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,77 @@
+import { Arr, Mix, Obj } from "../index.esm.js";
+import { PicoFormat } from "../utils/Format.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, '-');
+    }
+
+}
+
+/**
+ * @param {typeof PicoFormat} self
+ * @returns {typeof 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,31 @@
+import * as pi from "./index.esm.js";
+
+/**
+ * @typedef {Object} PicoLibrary
+ * @property {function(): *} [go]
+ * @property {function(): void} [browser]
+ * @property {function(): void} [device]
+ * @property {PicoMixed} [Any]
+ * @property {PicoArray} [Arr]
+ * @property {PicoDom} [Dom]
+ * @property {PicoFormat} [For]
+ * @property {PicoMap} [Map]
+ * @property {PicoMixed} [Mix]
+ * @property {PicoNow} [Now]
+ * @property {PicoNumber} [Num]
+ * @property {PicoObject} [Obj]
+ * @property {PicoRunner} [Run]
+ * @property {PicoString} [Str]
+ * @property {PicoHash} [Hash]
+ * @property {PicoEvent} [Event]
+ * @property {PicoLocale} [Locale]
+ * @property {PicoCookie} [Cookie]
+ * @property {PicoData} [Data]
+ * @property {PicoRoute} [Route]
+ * @property {PicoElement} [Element]
+ */
+
+/**
+ * @type {PicoLibrary}
+ */
+globalThis.pi = pi;

package/src/index.esm.js

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