@nebularstreams/libmui 0.1.11 → 0.1.13

package/src/util/util.tokenizer.js

@@ -1,227 +0,0 @@
-/* eslint-disable */
-/**
- *
- * String Tokenizer functions
- *
- * Substitutes parameters inside strings
- * Parameters are separated by $ at the beggining and end: $PARAM$, $PARAM1$
- * Parameters can navigate source object like $object/very/deep$
- * Parameters can include VERY SIMPLE default values like $object/very/deep=myvalue$
- *
- *          Note that default values cannot contain conflicting regexp symbols. This is a side functionality
- *          and never meant to support any default value use case, but alpha chars and numbers
- *
- * (c) Rodolfo LP 2001 - Public Domain
- *
- * @typedef {{ id:string,url:string}} UrlDefinition
- * @typedef {{ message:string, getTitle:boolean=false, defaultTitle:string="url" }} ResolveUrlOptions
- */
-
-/* eslint-disable no-use-before-define,no-unused-vars,prefer-destructuring,no-param-reassign,no-prototype-builtins */
-
-// eslint-disable-next-line no-useless-escape
-// noinspection RegExpRedundantEscape
-const
-    TAG = "[TOKENIZER]",
-    TOK_EXPR = /\$([A-Za-z0-9_\/\:\=]+)\$/g,
-
-    tokenize = (str, obj, isEncode) => tokenizeCore(str, obj, {
-        encode: isEncode,
-        defvalue: ""
-    }),
-    tokenizeKeep = (str, obj, isEncode) => tokenizeCore(str, obj, {encode: isEncode}),
-    tokenizeWithDefault = (str, obj, defaultValue) => tokenizeCore(str, obj, defaultValue == null ? null : {defvalue: defaultValue}),
-    tokenizeStrict = (str, obj, isEncode, isUnescape) => tokenizeCore(str, obj, {
-        encode: isEncode,
-        unescape: isUnescape,
-        dothrow: true
-    }),
-
-    Parsers = {
-        daterel: epoch => new Date(epoch).toISOString()
-    };
-
-function tokenizeCore(str, obj, options) {
-
-    if (!str) return "";
-    if (typeof (str) !== "string") return str;
-
-    // eslint-disable-next-line no-param-reassign
-    options = options || {};
-    obj = obj || {};
-
-    let ckey;
-
-    return str.replace(TOK_EXPR, (match, complexkey) => {
-
-        let defval = null,
-            isFreak = false;
-
-        if (complexkey.indexOf("=") > 0) {
-            ckey = complexkey.split("=");
-            complexkey = ckey[0];
-            isFreak = (ckey.length === 3);
-            // eslint-disable-next-line no-nested-ternary
-            defval = isFreak
-                ? options.dothrow ? ckey[2] : null
-                : ckey[1];
-        }
-
-        const typed = complexkey.split(":"),
-            key = typed[0],
-            keytype = typed[1] || null,
-
-            keys = key.split("/"),
-            root = keys.shift();
-
-        let
-            data = obj[root];
-
-        if (typeof (data) === "number") data = "" + data;
-
-        let fdata = (keys.length ? getPointedData(data, keys.join("/")) : data) || defval;
-
-        if (fdata == null && options.dothrow) {
-            throw new Error("Parameter " + root + (keys.length ? "/" + keys.join("/") : "") + " is required");
-        }
-
-        if (fdata == null) {
-            fdata = options.hasOwnProperty("defvalue")
-                ? options.defvalue
-                : "$" + key + (isFreak ? "==" + ckey[2] : "") + "$";
-        }
-
-        if (keytype && Parsers[keytype]) {
-            fdata = Parsers[keytype](fdata);
-        }
-
-        if (options.unescape) {
-            fdata = unescape(fdata);
-        }
-
-        return (options.encode ? escape(fdata) : fdata);
-
-    });
-}
-
-/**
- * Resolves a pointer into a JSON data structure
- * @param {Object} data JSON Data
- * @param {String} pointer Pointer expression
- * @return {Object | null} resolved data
- */
-
-const getPointedData = function (data, pointer) {
-    if (!pointer) return data;
-    try {
-        const ps = pointer.split("/");
-        let d = data;
-        // eslint-disable-next-line guard-for-in
-        for (const l in ps) {
-            d = d[ps[l]];
-            if (!d) {
-                d = null;
-                break;
-            }
-        }
-        return d;
-    } catch (e) {
-        return null;
-    }
-};
-
-/**
- * Tokenizes one object with another
- * @param {object} source
- * @param {object} tokenizeValues
- * @param strict Whether to require all templates to be resolved
- * @retuen {object} source
- */
-
-function tokenizeObject(source, tokenizeValues, strict, asNewObject) {
-
-    const tokenizer = strict ? tokenizeStrict : tokenizeKeep;
-    const retObject = asNewObject ? {} : source;
-
-    if (typeof source === "string") {
-        return tokenizer(source, tokenizeValues);
-    }
-
-    if (typeof source === "object") {
-
-        if (source.length) {
-            // root is an array
-            // an array
-            const arr = [];
-            for (const item of source) {
-                arr.push(tokenizeObject(item, tokenizeValues, strict, true));
-            }
-            return arr;
-        }
-
-        for (const prop of Object.keys(source)) {
-            const value = source[prop];
-            if (typeof value === "object") {
-                retObject[prop] = tokenizeObject(value, tokenizeValues, strict, true);
-            } else if (typeof value === "string") {
-                retObject[prop] = tokenizer(source[prop], tokenizeValues);
-            } else {
-                retObject[prop] = value;
-            }
-        }
-    }
-    return retObject;
-}
-
-/**
- * Resolves a playout URL
- * @param {string|UrlDefinition} tokenizedUrl The URL to parse
- * @param {Object=} parameters Parameters to tokenize the URL with
- * @param {ResolveUrlOptions=} options Miscellaneous options for this call
- * @return string
- */
-
-function tokenizeUrl(tokenizedUrl, parameters, options) {
-
-    options = options || {};
-
-    const
-        {message, getTitle, defaultTitle} = options,
-        finalDefaultTitle = defaultTitle || "Url",
-        title = typeof tokenizedUrl === "string"
-            ? defaultTitle
-            : (typeof tokenizedUrl === "object" && tokenizedUrl.id ? tokenizedUrl.id || finalDefaultTitle : finalDefaultTitle);
-
-
-    // just return the title of an URL
-    if (getTitle) {
-        return title;
-    }
-
-    //  return the url itself
-    const
-        url = typeof tokenizedUrl === "string"
-            ? tokenizedUrl
-            : (typeof tokenizedUrl === "object" && tokenizedUrl.url ? tokenizedUrl.url : null);
-
-    try {
-        return tokenizeStrict(
-            url,
-            parameters || {},
-            "..."
-        );
-    } catch (e) {
-        console.log(TAG, e.message);
-        return message || "(not enough parameters)";
-    }
-}
-
-export {
-    tokenize,
-    tokenizeStrict,
-    tokenizeObject,
-    tokenizeKeep,
-    tokenizeWithDefault,
-    tokenizeUrl,
-    getPointedData
-};

package/src/util/widgets.core.js

@@ -1,314 +0,0 @@
-/* eslint-disable no-nested-ternary */
-/**
- * Basic Mithril Widget functions
- * Provides some utilities and basic UI functions like an Alert or a Confirmation dialog
- *
- * @author Rodolfo Lopez Pintor, 2020 <rlp@nebular.tv>
- * @module apps.widgets.basic
- *
- */
-import m from "mithril";
-import * as widget from "./widgets";
-import * as Tokenizer from "./util.tokenizer";
-import {Button, Empty} from "../widgets/Basic";
-
-/**
- *
- * Computes a Class String
- *
- * @param {string} initials INitial CSS Classes
- * @param {Object<string, boolean>} clases New classes dictionary
- * @return {string} The CSS Class expression like .class1.class2.class3
- * @public
- * @static
- */
-
-const packClassString = (initials, clases) => {
-    const finals = [];
-    if (clases) for (const cla of Object.keys(clases)) if (clases[cla]) finals.push("." + cla);
-    return (initials || "") + finals.join("");
-};
-
-
-const packClass = (initials, clases) => {
-    const finals = initials ? [initials] : [];
-    if (clases) for (const cla of Object.keys(clases)) if (clases[cla]) finals.push(cla);
-    return finals.join(" ");
-};
-
-/**
- * Shows a modal confirm dialog
- * @param {string} title The dialog title
- * @param {string} message The dialog message
- * @param {Array} buttons Buttons to display
- * @param {Object=} options noCancel: dialog is uncanellable
- * @public
- * @static
- */
-
-function Confirm(title, message,
-                 buttons = ["CANCEL", "OK"], options = {}
-) {
-    widget.popupMessage(
-        m(
-            {
-                view: () => [
-                    ...title ? [m("h3", title)] : [],
-                    ...message ? [m("h4", message)] : [],
-                    m(".container",
-                        buttons.map(
-                            option => m(
-                                "button",
-                                {
-                                    onclick: () => {
-                                        document.getElementById("modal-container").style.display = "none";
-                                        if (option.onclick) option.onclick(option.caption);
-                                    }
-                                },
-                                option.caption || "OK"
-                            )
-                        ))
-                ]
-            },
-            {}
-        ),
-        options.onCancel || !options.noCancel
-    );
-}
-
-function ConfirmPromise(title, message, actions, isModal = false) {
-
-    let onCancel = undefined;
-
-    if (typeof isModal === "function") {
-        onCancel = isModal;
-        isModal = false;
-    }
-
-    return new Promise((resolve) => {
-
-        const opts = actions.map((name, idx) => ({
-            caption: name,
-            onclick: () => resolve({
-                idx,
-                name
-            })
-        }));
-
-        Confirm(title, message, opts, {
-            onCancel,
-            noCancel: isModal
-        });
-    });
-}
-
-/**
- * Shows An Alert Modal Dialog
- * @param {string} title Dialog Title
- * @param {string} message Dialog Message
- * @param {string?} caption Button caption
- * @param {function?} onclick On press handler
- * @public
- * @static
- */
-
-function Alert(title, message, caption, onclick) {
-    return Confirm(title, message, [{caption, onclick}]);
-}
-
-
-function OverflowMenu(domItem, item, actions, options) {
-
-    return new Promise((resolve) => {
-
-        options = options || {};
-
-        function closeResolve(value) {
-            widget.popupMessage(null);
-            try {
-                resolve(value);
-            } catch (e) {
-                //
-            }
-        }
-
-        const
-            classes = packClassString(".popup.flexcol", {
-                ".favlist": options.favlist,
-                ".isfav": domItem && domItem.classList.contains("isfav"),
-                ".isplay": domItem && domItem.classList.contains("selected")
-            });
-
-        widget.popupMessage(
-            m({
-                view: () => m(
-                    classes,
-                    {
-                        onclick: (event) => {
-
-                            if (event.target.nodeName === "INPUT") {
-                                return;
-                            }
-
-                            const
-                                action = event.target.getAttribute("data-action");
-
-                            if (action) {
-                                closeResolve({
-                                    domItem,
-                                    item,
-                                    action
-                                });
-                            } else {
-                                widget.popupMessage(null);
-                            }
-                        }
-                    },
-                    [
-                        ...item.title ? [m("h3", {id: "modaltitle"}, item.title)] : [],
-                        ...actions.map(action => (action.type === "text"
-                            ? m(
-                                "input.action",
-                                {
-                                    value: action.value || "",
-                                    type: "text",
-                                    placeholder: action.hint || "",
-                                    oncreate: ({dom}) => dom.focus(),
-                                    onkeyup: (ev) => {
-                                        if (ev.keyCode === 27) {
-                                            closeResolve({domItem, item, action});
-                                        }
-                                    },
-                                    onchange: (ev) => {
-                                        ev.target.blur();
-                                        closeResolve({
-                                            domItem,
-                                            item,
-                                            action,
-                                            value: ev.target.value
-                                        });
-                                    }
-                                }
-                            )
-                            : m(
-                                Button,
-                                {
-                                    ...action,
-                                    onclick: () => closeResolve({
-                                        domItem,
-                                        item,
-                                        action
-                                    })
-                                },
-                                action.caption
-                            )))
-                    ]
-                )
-            }),
-            true
-        );
-    });
-}
-
-/**
- * Creates an HTML UL/LI structure with the object properties
- * @param {Object} object An object to render
- * @param {RenderOptions?} options
- * @param {Object[]} children additional vnodes
- * @param {string} recurse parent key
- * @param isArrayChild
- * @return {m} The rendered view
- * @public
- * @static
- */
-
-function RenderObject(object, options, children, recurse, isArrayChild = false) {
-
-    // noinspection JSValidateTypes
-    options = options || {};
-    const {arrayClass = "isarray", arrayChildClass = "ischildren", objectClass = "isobject"} = options;
-
-    return m(
-        "ul",
-        {
-            ...(options.attrs || {}),
-            class: options.class
-        },
-        object
-            ? [
-                ...(options.keys || Object.keys(object))
-                    .map((key) => {
-
-                        const
-                            value = object[key] || null,
-                            isObject = value !== null && (typeof value === "object"),
-                            isArray = isObject && value.length,
-                            fullkey = (recurse ? recurse + "_" : "") + key;
-
-                        return m(
-                            "li.field_" + (options.start || "") + fullkey,
-                            {
-                                class: (isArray ? arrayClass : isObject ? (objectClass + " ") : "") + (isArrayChild ? arrayChildClass : ""),
-                                "data-title": options.titles ? options.titles[key] || key : key,
-                                ...(options.itemAttrs || {})
-                            },
-                            // eslint-disable-next-line
-                            isObject
-                                ? [
-                                    m(".subvalues",
-                                        RenderObject(
-                                            value,
-                                            {
-                                                ...options,
-                                                keys: null
-                                            },
-                                            null,
-                                            (recurse ? recurse + "_" : "") + key,
-                                            isArray
-                                        ))]
-                                : (
-                                    (options.renderer && options.renderer[fullkey])
-                                        ? options.renderer[fullkey](value)
-                                        : m("span.value", object[key])
-                                )
-                        );
-                    }),
-                ...children || []
-            ]
-            : [
-                m(".empty", {})
-            ]
-    );
-
-}
-
-
-const
-    JSONWidget = {
-        view:
-            ({attrs, children}) => {
-                let object;
-                try {
-                    object = attrs.pointer
-                        ? Tokenizer.getPointedData(attrs.object, attrs.pointer)
-                        : attrs.object;
-                } catch (e) {
-                    return m(Empty, {message: e.message, ...attrs});
-                }
-
-                return object
-                    ? RenderObject(object, attrs, children)
-                    : m(Empty, attrs);
-            }
-    };
-
-// noinspection JSUnusedGlobalSymbols
-export {
-    Alert,
-    Confirm,
-    ConfirmPromise,
-    RenderObject,
-    OverflowMenu,
-    JSONWidget,
-    packClass
-}

package/src/util/widgets.js

@@ -1,72 +0,0 @@
-import m from "mithril";
-
-let
-	mCurrentCancelable;
-
-function runCancelable(container) {
-	if (typeof mCurrentCancelable === "function") {
-		mCurrentCancelable();
-		mCurrentCancelable = undefined;
-	}
-	container.style.display = "none";
-	delete popupMessage.redraw;
-}
-
-// There are ways of doing this inside m.route but it is probably
-// cleaner and faster when kept outside of the main auto
-// rendering system
-
-function popupMessage(message, cancelable = false, contentClass = ".modal-content") {
-
-	const container = document.getElementById("modal-container");
-	container.classList.toggle("iscustom", contentClass !== ".modal-content");
-
-	if (cancelable) {
-
-		mCurrentCancelable = cancelable;
-
-		container.onclick = (event) => {
-			if (event.target.id === "modal-container") {
-				runCancelable(container);
-			}
-		};
-	}
-
-	if (!message) {
-		delete popupMessage.redraw;
-		if (message === null)
-			container.style.display = "none";
-		else
-			runCancelable(container);
-
-		return;
-	}
-
-	container.style.display = "flex";
-
-	popupMessage.redraw = () => {
-		m.render(
-			container,
-			m(contentClass, {
-				role: "alertdialog",
-				"aria-labelledby": "modaltitle",
-				"aria-modal": true
-			}, [
-				typeof message === "function" ? message() : message
-			])
-		);
-	};
-
-	popupMessage.redraw();
-}
-
-function clearModal() {
-	const container = document.getElementById("modal-container");
-	if (container.style.display !== "none") {
-		runCancelable(container);
-		return true;
-	}
-	return false;
-}
-
-export { popupMessage, clearModal };

package/src/util/widgets.utils.js

@@ -1,10 +0,0 @@
-export default function defineWidget (view, oninit, oncreate, onremove, onupdate) {
-    return {
-        ...view && {view},
-        ...oninit && {oninit},
-        ...oncreate && {oncreate},
-        ...onupdate && {onupdate},
-        ...onremove && {onremove}
-    }
-}
-