xmlui 0.4.0

package/dist/scripts/src/parsers/ueml/UemlHelper.js

@@ -0,0 +1,579 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UemlHelper = exports.onPrefixRegex = exports.UCRegex = exports.COMPOUND_COMP_ID = void 0;
+exports.COMPOUND_COMP_ID = "Component";
+exports.UCRegex = /^[A-Z]/;
+exports.onPrefixRegex = /^on[A-Z]/;
+const attrBreakRegex = /[\r\n<>'"&]/;
+/**
+ * Helper class for UEML serialization and parsing
+ */
+class UemlHelper {
+    /**
+     * Serialize the specified XML fragment into a string
+     * @param xml XML fragment to serialize
+     * @param options Formatting options to use
+     */
+    serialize(xml, options) {
+        const fragment = Array.isArray(xml) ? xml : [xml];
+        return serializeFragment(fragment, 0);
+        function serializeFragment(nodes, depth) {
+            return nodes.map((n) => serializeNode(n, depth)).join((options === null || options === void 0 ? void 0 : options.prettify) ? "\n" + getIndent(depth) : "");
+        }
+        function serializeNode(node, depth) {
+            switch (node.type) {
+                case "UemlComment":
+                    return serializeXmlComment(node, depth);
+                case "UemlElement":
+                    return serializeXmlElement(node, depth);
+                default:
+                    return "";
+            }
+        }
+        function getIndent(depth) {
+            var _a;
+            return (options === null || options === void 0 ? void 0 : options.prettify) ? "".padEnd(((_a = options === null || options === void 0 ? void 0 : options.indents) !== null && _a !== void 0 ? _a : 2) * depth, " ") : "";
+        }
+        function serializeXmlComment(node, depth) {
+            return `${getIndent(depth)}<!--${node.text}-->`;
+        }
+        function serializeXmlElement(node, depth) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            let elementStr = `${getIndent(depth)}<${nodeName()}`;
+            const hasAttrs = ((_b = (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
+            const hasChildren = ((_d = (_c = node.childNodes) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+            if (node.text || hasAttrs || hasChildren) {
+                // --- Indicate that the node has not yet been broken into multiple lines
+                if (hasAttrs) {
+                    // --- Render attributes
+                    const attrTexts = node.attributes.map((a) => serializeXmlAttribute(a));
+                    if (!(options === null || options === void 0 ? void 0 : options.prettify)) {
+                        elementStr += " " + attrTexts.join(" ");
+                    }
+                    else {
+                        // --- Check line overflow
+                        const nodeLength = elementStr.length +
+                            1 + // --- Space after
+                            attrTexts.join(" ").length + // --- Attributes total length
+                            (hasChildren ? 1 : ((_e = options === null || options === void 0 ? void 0 : options.useSpaceBeforeClose) !== null && _e !== void 0 ? _e : false) ? 3 : 2); // --- Closing token length
+                        if (nodeLength > ((_f = options === null || options === void 0 ? void 0 : options.lineLength) !== null && _f !== void 0 ? _f : 80)) {
+                            // --- Too long, break attributes into new lines
+                            attrTexts.forEach((text) => {
+                                elementStr += "\n" + getIndent(depth + 1) + text;
+                            });
+                            if ((_g = options === null || options === void 0 ? void 0 : options.breakClosingTag) !== null && _g !== void 0 ? _g : false) {
+                                elementStr += "\n" + getIndent(depth);
+                            }
+                        }
+                        else {
+                            // --- Attributes fit into the line
+                            elementStr += " " + attrTexts.join(" ");
+                        }
+                    }
+                }
+                if (node.text || hasChildren) {
+                    // --- Close the opening tag
+                    elementStr += ">";
+                    // --- Render the text
+                    if (node.text) {
+                        const textContents = node.preserveSpaces ? serializeQuotedText(node.text) : serializeText(node.text);
+                        if ((options === null || options === void 0 ? void 0 : options.prettify) &&
+                            elementStr.length + textContents.length + node.name.length + 3 > ((_h = options === null || options === void 0 ? void 0 : options.lineLength) !== null && _h !== void 0 ? _h : 80)) {
+                            // --- break text
+                            elementStr += "\n" + getIndent(depth + 1) + textContents + "\n";
+                        }
+                        else {
+                            elementStr += textContents;
+                        }
+                    }
+                    // --- Render child nodes
+                    if (hasChildren) {
+                        const childrenTexts = node.childNodes.map((c) => serializeNode(c, depth + 1));
+                        if (!(options === null || options === void 0 ? void 0 : options.prettify)) {
+                            elementStr += childrenTexts.join("");
+                        }
+                        else {
+                            childrenTexts.forEach((text) => {
+                                elementStr += "\n" + text;
+                            });
+                            elementStr += "\n";
+                        }
+                    }
+                    // --- Render the closing tag
+                    elementStr += `${getIndent(depth)}</${node.name}>`;
+                }
+                else {
+                    elementStr += (((_j = options === null || options === void 0 ? void 0 : options.useSpaceBeforeClose) !== null && _j !== void 0 ? _j : false) ? " " : "") + "/>";
+                }
+            }
+            else {
+                elementStr += (((_k = options === null || options === void 0 ? void 0 : options.useSpaceBeforeClose) !== null && _k !== void 0 ? _k : false) ? " " : "") + "/>";
+                if (node.text === "") {
+                    elementStr += `""</${nodeName()}>`;
+                }
+            }
+            return elementStr;
+            function nodeName() {
+                return node.namespace ? `${node.namespace}:${node.name}` : node.name;
+            }
+        }
+        function serializeXmlAttribute(node) {
+            var _a;
+            // --- Handle valueless attributes
+            if (node.value === undefined || node.value === null) {
+                return `${nodeName()}`;
+            }
+            // --- Use quotes when required so
+            if (node.preserveSpaces) {
+                return `${nodeName()}=${serializeQuotedText(node.value)}`;
+            }
+            // --- Do the rest
+            const value = (_a = node.value) !== null && _a !== void 0 ? _a : "";
+            return `${nodeName()}=${serializeQuotedText(value)}`;
+            function nodeName() {
+                return node.namespace ? `${node.namespace}:${node.name}` : node.name;
+            }
+        }
+        function serializeText(text) {
+            return (options === null || options === void 0 ? void 0 : options.useQuotes) || attrBreakRegex.test(text) ? serializeQuotedText(text) : text;
+        }
+        function serializeQuotedText(text) {
+            const containsQuote = text.indexOf("'") >= 0;
+            const containsDQuote = text.indexOf('"') >= 0;
+            if ((!containsQuote && !containsDQuote) || (containsQuote && !containsDQuote)) {
+                return `"${text.replaceAll("`", "\\`")}"`;
+            }
+            if (containsDQuote && !containsQuote) {
+                return `'${text.replaceAll("`", "\\`")}'`;
+            }
+            return `\`${text.replaceAll("`", "\\`")}\``;
+        }
+    }
+    /**
+     * Transform the specified component definition into an UEML node
+     * @param def Component definitions
+     * @param options Transformation options
+     */
+    transformComponentDefinition(def, options) {
+        return def.type
+            ? this.transformSimpleComponentDefinition(def, options)
+            : this.transformCompoundComponentDefinition(def, options);
+    }
+    /**
+     * Transform the specified object into an UEML nodes
+     * @param def Object definition
+     * @param options Transformation options
+     */
+    transformObject(def, options) {
+        var _a;
+        const transformed = this.transformValue("Object", "", def, options);
+        if (!transformed) {
+            return null;
+        }
+        return (_a = transformed.childNodes) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Transforms the specified simple component definition into an UEML node
+     * @param def Component definition
+     * @param options Transformation options
+     */
+    transformSimpleComponentDefinition(def, options) {
+        const componentNode = {
+            type: "UemlElement",
+            name: def.type,
+        };
+        // --- Fundamental props
+        if (def.uid !== undefined) {
+            this.addProperty(componentNode, "id", def.uid, options);
+        }
+        if (def.testId !== undefined) {
+            this.addProperty(componentNode, "testId", def.testId, options);
+        }
+        if (def.when !== undefined) {
+            this.addProperty(componentNode, "when", def.when, options);
+        }
+        // --- Process vars
+        if (def.vars) {
+            Object.keys(def.vars).forEach((key) => {
+                var _a;
+                const varElement = this.transformValue("var", key, def.vars[key], options);
+                if (varElement === null)
+                    return;
+                (_a = componentNode.childNodes) !== null && _a !== void 0 ? _a : (componentNode.childNodes = []);
+                componentNode.childNodes.push(varElement);
+            });
+        }
+        // --- Process properties
+        if (def.props) {
+            Object.keys(def.props).forEach((key) => {
+                var _a, _b, _c;
+                // --- Special serialization for component-aware props
+                const propValue = def.props[key];
+                if (key.endsWith("Template") && propValue.type) {
+                    // --- Consider this property holds a component
+                    (_a = componentNode.childNodes) !== null && _a !== void 0 ? _a : (componentNode.childNodes = []);
+                    const propWrapper = {
+                        type: "UemlElement",
+                        name: "prop",
+                        attributes: [
+                            {
+                                type: "UemlAttribute",
+                                name: "name",
+                                value: key,
+                            },
+                        ],
+                    };
+                    this.addComponentElement(propWrapper, propValue);
+                    componentNode.childNodes.push(propWrapper);
+                }
+                else {
+                    // --- Undefined is not serialized
+                    if (propValue === undefined) {
+                        return;
+                    }
+                    // --- Handle null property value
+                    if (propValue === null) {
+                        const nullPropElement = {
+                            type: "UemlElement",
+                            name: "prop",
+                            attributes: [
+                                {
+                                    type: "UemlAttribute",
+                                    name: "name",
+                                    value: key,
+                                },
+                            ],
+                        };
+                        (_b = componentNode.childNodes) !== null && _b !== void 0 ? _b : (componentNode.childNodes = []);
+                        componentNode.childNodes.push(nullPropElement);
+                        return;
+                    }
+                    // --- Extract prop if asked so, or if those are special, like "id", "when", or "testIs"
+                    if (key === "id" || key === "when" || key === "testId" || (options === null || options === void 0 ? void 0 : options.extractProps)) {
+                        const idPropElement = {
+                            type: "UemlElement",
+                            name: "prop",
+                        };
+                        this.addProperty(idPropElement, key, propValue, options);
+                        (_c = componentNode.childNodes) !== null && _c !== void 0 ? _c : (componentNode.childNodes = []);
+                        componentNode.childNodes.push(idPropElement);
+                        return;
+                    }
+                    // --- Add property as the best according to the value
+                    this.addProperty(componentNode, key, propValue, options);
+                }
+            });
+        }
+        // --- Process events
+        if (def.events) {
+            Object.keys(def.events).forEach((key) => {
+                var _a;
+                const eventElement = this.transformValue("event", key, def.events[key], options);
+                if (eventElement === null)
+                    return;
+                (_a = componentNode.childNodes) !== null && _a !== void 0 ? _a : (componentNode.childNodes = []);
+                componentNode.childNodes.push(eventElement);
+            });
+        }
+        // --- Process loaders
+        if (def.loaders) {
+            this.addComponentList(componentNode, "loaders", def.loaders);
+        }
+        // --- Process APIs
+        if (def.api) {
+            Object.keys(def.api).forEach((key) => {
+                var _a;
+                const apiElement = this.transformValue("api", key, def.api[key], options);
+                if (apiElement === null)
+                    return;
+                (_a = componentNode.childNodes) !== null && _a !== void 0 ? _a : (componentNode.childNodes = []);
+                componentNode.childNodes.push(apiElement);
+            });
+        }
+        // --- Process uses
+        if (def.uses) {
+            this.addList(componentNode, "uses", "", def.uses, options);
+        }
+        // --- Process children
+        if (def.children) {
+            if (typeof def.children === "string") {
+                this.addProperty(componentNode, "children", def.children, options);
+            }
+            else {
+                def.children.forEach((ch) => {
+                    this.addComponentElement(componentNode, ch);
+                });
+            }
+        }
+        // --- Done
+        return componentNode;
+    }
+    /**
+     * Transforms the specified simple component definition into an Xml node
+     * @param def Compound component definition
+     * @param options Transformation options
+     */
+    transformCompoundComponentDefinition(def, options) {
+        if (typeof def === "string") {
+            return {
+                type: "UemlElement",
+                name: def,
+            };
+        }
+        const nested = this.transformSimpleComponentDefinition(def.component, options);
+        const componentNode = {
+            type: "UemlElement",
+            name: exports.COMPOUND_COMP_ID,
+            attributes: [
+                {
+                    type: "UemlAttribute",
+                    name: "name",
+                    value: def.name,
+                },
+            ],
+            childNodes: Array.isArray(nested) ? [...nested] : [nested],
+        };
+        // --- Transform APIs
+        if (def.api) {
+            Object.keys(def.api).forEach((key) => {
+                var _a;
+                const apiElement = this.transformValue("api", key, def.api[key], options);
+                if (apiElement === null)
+                    return;
+                (_a = componentNode.childNodes) !== null && _a !== void 0 ? _a : (componentNode.childNodes = []);
+                componentNode.childNodes.push(apiElement);
+            });
+        }
+        // --- Done
+        return componentNode;
+    }
+    /**
+     * Transforms a value into an UEML element
+     * @param nodeName Name of the value node
+     * @param name Optional (property) name
+     * @param value Value to transform
+     * @param options Transformation options
+     */
+    transformValue(nodeName, name, value, options) {
+        var _a, _b, _c;
+        // --- Do not transform undefined elements
+        if (value === undefined)
+            return null;
+        // --- Prepare the node with the value
+        const valueNode = {
+            type: "UemlElement",
+            name: nodeName,
+        };
+        if (name) {
+            valueNode.attributes = [
+                {
+                    type: "UemlAttribute",
+                    name: "name",
+                    value: name,
+                },
+            ];
+        }
+        // --- Extend the node according to the specified value
+        // --- Null value: we're done
+        if (value === null) {
+            return valueNode;
+        }
+        // --- Simple value: use text or value attribute
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            const strValue = typeof value === "string" ? value.toString() : `{${value.toString()}}`;
+            const preserveSpaces = attrBreakRegex.test(strValue) || strValue.trim().length != strValue.length;
+            if (options === null || options === void 0 ? void 0 : options.preferTextToValue) {
+                valueNode.text = strValue;
+                valueNode.preserveSpaces = preserveSpaces;
+            }
+            else {
+                (_a = valueNode.attributes) !== null && _a !== void 0 ? _a : (valueNode.attributes = []);
+                valueNode.attributes.push({
+                    type: "UemlAttribute",
+                    name: "value",
+                    value: strValue,
+                    preserveSpaces,
+                });
+            }
+            return valueNode;
+        }
+        // --- Array value
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                // --- Empty array
+                (_b = valueNode.attributes) !== null && _b !== void 0 ? _b : (valueNode.attributes = []);
+                valueNode.attributes.push({
+                    type: "UemlAttribute",
+                    name: "value",
+                    value: "{[]}",
+                });
+            }
+            else {
+                value.forEach((item) => {
+                    var _a;
+                    const itemElement = this.transformValue("item", undefined, item, options);
+                    if (!itemElement)
+                        return;
+                    (_a = valueNode.childNodes) !== null && _a !== void 0 ? _a : (valueNode.childNodes = []);
+                    valueNode.childNodes.push(itemElement);
+                });
+            }
+        }
+        else if (typeof value === "object") {
+            const keys = Object.keys(value);
+            if (keys.length === 0) {
+                // --- Empty object
+                (_c = valueNode.attributes) !== null && _c !== void 0 ? _c : (valueNode.attributes = []);
+                valueNode.attributes.push({
+                    type: "UemlAttribute",
+                    name: "value",
+                    value: "{{}}",
+                });
+            }
+            else {
+                keys.forEach((key) => {
+                    var _a;
+                    const fieldElement = this.transformValue("field", key, value[key], options);
+                    if (!fieldElement)
+                        return;
+                    (_a = valueNode.childNodes) !== null && _a !== void 0 ? _a : (valueNode.childNodes = []);
+                    valueNode.childNodes.push(fieldElement);
+                });
+            }
+        }
+        else {
+            throw new Error(`Cannot serialize '${typeof value}' value`);
+        }
+        return valueNode;
+    }
+    /**
+     * Transforms the specified simple component definition into an Xml node
+     * @param name Element name
+     * @param value Value to transform
+     * @param options Transformation options
+     */
+    transformObjectValue(name, value, options) {
+        const componentNode = {
+            type: "UemlElement",
+            name: name,
+        };
+        if (value) {
+            Object.keys(value).forEach((key) => this.addProperty(componentNode, key, value[key], options));
+        }
+        return componentNode;
+    }
+    /**
+     * Add a property to the specified UEML element
+     * @param element XML element
+     * @param name Element name
+     * @param value Element value
+     * @param options Transformation options
+     */
+    addProperty(element, name, value, options) {
+        var _a, _b, _c;
+        switch (typeof value) {
+            // --- We do not serialize undefined property values
+            case "undefined":
+                break;
+            case "string":
+                (_a = element.attributes) !== null && _a !== void 0 ? _a : (element.attributes = []);
+                element.attributes.push({
+                    type: "UemlAttribute",
+                    name,
+                    value: value === null || value === void 0 ? void 0 : value.toString(),
+                    preserveQuotes: (_b = options === null || options === void 0 ? void 0 : options.removeQuotes) !== null && _b !== void 0 ? _b : false,
+                    preserveSpaces: attrBreakRegex.test(value.toString()),
+                });
+                break;
+            case "boolean":
+            case "number":
+            case "object":
+                const objElement = this.transformValue("prop", name, value, options);
+                if (objElement) {
+                    (_c = element.childNodes) !== null && _c !== void 0 ? _c : (element.childNodes = []);
+                    element.childNodes.push(objElement);
+                }
+                break;
+            default:
+                throw new Error(`'${typeof value}' transformation is not implemented yet`);
+        }
+    }
+    addComponentElement(element, component) {
+        var _a;
+        (_a = element.childNodes) !== null && _a !== void 0 ? _a : (element.childNodes = []);
+        const childDef = this.transformComponentDefinition(component);
+        if (Array.isArray(childDef)) {
+            element.childNodes.push(...childDef);
+        }
+        else {
+            element.childNodes.push(childDef);
+        }
+    }
+    /**
+     * Adds a list to the specified XML element
+     * @param element XML element
+     * @param name Name of the list (child in `element`)
+     * @param prefix Prefix to use for the list
+     * @param list List with items
+     * @param options Transformation options
+     */
+    addList(element, name, prefix, list, options) {
+        var _a;
+        const nodeName = `${prefix ? prefix + "." : ""}${name}`;
+        (_a = element.childNodes) !== null && _a !== void 0 ? _a : (element.childNodes = []);
+        list.forEach((item) => {
+            if (typeof item === "string") {
+                // --- Special case, the item can be the text of an XML element
+                element.childNodes.push({
+                    type: "UemlElement",
+                    name: nodeName,
+                    text: item,
+                    preserveSpaces: attrBreakRegex.test(item) || item !== item.trim() || item === "",
+                });
+            }
+            else if (item === null) {
+                element.childNodes.push({
+                    type: "UemlElement",
+                    name: nodeName,
+                });
+            }
+            else {
+                const transformed = this.transformObjectValue(nodeName, item, options);
+                if (Array.isArray(transformed)) {
+                    element.childNodes.push(...transformed);
+                }
+                else {
+                    element.childNodes.push(transformed);
+                }
+            }
+        });
+    }
+    /**
+     * Adds a component list to the specified element
+     * @param element XML element
+     * @param name Name to use for the wrapper element
+     * @param list List with component items
+     * @private
+     */
+    addComponentList(element, name, list) {
+        var _a;
+        const children = [];
+        list.forEach((item) => {
+            const fragment = this.transformSimpleComponentDefinition(item);
+            if (Array.isArray(fragment)) {
+                children.push(...fragment);
+            }
+            else {
+                children.push(fragment);
+            }
+        });
+        const listElement = {
+            type: "UemlElement",
+            name,
+            childNodes: children,
+        };
+        (_a = element.childNodes) !== null && _a !== void 0 ? _a : (element.childNodes = []);
+        element.childNodes.push(listElement);
+    }
+}
+exports.UemlHelper = UemlHelper;

package/dist/scripts/src/parsers/ueml/UemlInputStream.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UemlInputStream = void 0;
+// This class represents the input stream of the UEML parser
+class UemlInputStream {
+    // Creates a stream that uses the specified source code
+    constructor(source) {
+        this.source = source;
+        // --- Current stream position
+        this._pos = 0;
+        // --- Current line number
+        this._line = 1;
+        // --- Current column number
+        this._column = 0;
+    }
+    // Gets the current position in the stream. Starts from 0.
+    get position() {
+        return this._pos;
+    }
+    // Gets the current line number. Starts from 1.
+    get line() {
+        return this._line;
+    }
+    // Gets the current column number. Starts from 0.
+    get column() {
+        return this._column;
+    }
+    // Peeks the next character in the stream. Returns null, if EOF; otherwise the current source code character
+    peek() {
+        return this.ahead(0);
+    }
+    // Looks ahead with `n` characters in the stream. Returns null, if EOF; otherwise the look-ahead character
+    ahead(n = 1) {
+        return this._pos + n > this.source.length - 1 ? null : this.source[this._pos + n];
+    }
+    // Gets the next character from the stream
+    get() {
+        // --- Check for EOF
+        if (this._pos >= this.source.length) {
+            return null;
+        }
+        // --- Get the char, and keep track of position
+        const ch = this.source[this._pos++];
+        if (ch === "\n") {
+            this._line++;
+            this._column = 0;
+        }
+        else {
+            this._column++;
+        }
+        return ch;
+    }
+    // Gets the tail of the input stream
+    getTail(start) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.substring(start)) !== null && _b !== void 0 ? _b : "";
+    }
+}
+exports.UemlInputStream = UemlInputStream;