xmlui 0.4.0

package/dist/scripts/src/components-core/utils/treeUtils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenNode = flattenNode;
+exports.toFlatTree = toFlatTree;
+exports.walkTree = walkTree;
+exports.unPackTree = unPackTree;
+function flattenNode(node, depth, result, openedIds) {
+    const { children, uid } = node;
+    const isExpanded = openedIds.includes(uid);
+    result.push(Object.assign(Object.assign({}, node), { hasChildren: !!children && children.length > 0, depth,
+        isExpanded }));
+    if (isExpanded && children) {
+        for (let child of children) {
+            flattenNode(child, depth + 1, result, openedIds);
+        }
+    }
+}
+function toFlatTree(treeData, openedIds) {
+    const ret = [];
+    treeData.forEach((node) => {
+        flattenNode(node, 0, ret, openedIds);
+    });
+    return ret;
+}
+function walkTree(treeData, visit) {
+    treeData.forEach((node) => {
+        visit(node);
+        walkTree(node.children || [], visit);
+    });
+}
+function unPackTree(items = [], parentIds = [], parentPath = []) {
+    const treeData = [];
+    let treeItemsById = {};
+    items.forEach((item, index) => {
+        const path = [...parentPath, index];
+        const uid = item.uid || item.cid;
+        const childTree = unPackTree(item.children, [...parentIds, uid], path);
+        const treeItem = Object.assign(Object.assign({}, item), { uid: uid, key: uid, parentIds,
+            path, children: childTree.treeData, selectable: item.selectable });
+        treeData.push(treeItem);
+        treeItemsById[uid] = treeItem;
+        treeItemsById = Object.assign(Object.assign({}, treeItemsById), childTree.treeItemsById);
+    });
+    return {
+        treeData,
+        treeItemsById,
+    };
+}

package/dist/scripts/src/components-core/xmlui-parser.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXmlUiMarkup = parseXmlUiMarkup;
+const UemlParser_1 = require("../parsers/ueml/UemlParser");
+const parser_1 = require("../parsers/xmlui-parser/parser");
+const transform_1 = require("../parsers/xmlui-parser/transform");
+function parseXmlUiMarkup(source, moduleResolver, useOldParser = false) {
+    if (useOldParser) {
+        const parser = new UemlParser_1.UemlParser(source, moduleResolver);
+        return parser.transformToComponentDef();
+    }
+    else {
+        const { parse, getText } = (0, parser_1.createXmlUiParser)(source);
+        const { node, errors } = parse();
+        if (errors.length > 0) {
+            const newlinePositions = [];
+            for (let i = 0; i < source.length; ++i) {
+                if (source[i] === "\n") {
+                    newlinePositions.push(i);
+                }
+            }
+            const errorWithLines = addPositions(errors, newlinePositions);
+            const errorMessages = errorWithLines
+                .map((e) => `Error at line ${e.line}, column:${e.col}:\n   ${e.message}\n`)
+                .join("\n");
+            throw new Error(errorMessages);
+        }
+        return (0, transform_1.nodeToComponentDef)(node, getText, moduleResolver);
+    }
+}
+function addPositions(errors, newlinePositions) {
+    var _a;
+    if (newlinePositions.length === 0) {
+        for (let err of errors) {
+            err.line = 1;
+            err.col = err.pos + 1;
+        }
+        return errors;
+        ;
+    }
+    for (let err of errors) {
+        for (let i = 0; i < newlinePositions.length; ++i) {
+            const newlinePos = newlinePositions[i];
+            if (err.pos < newlinePos) {
+                err.line = i + 1;
+                err.col = err.pos - ((_a = newlinePositions[i - 1]) !== null && _a !== void 0 ? _a : 0) + 1;
+                break;
+            }
+        }
+    }
+    return errors;
+}

package/dist/scripts/src/parsers/scripting/InputStream.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputStream = void 0;
+// This class represents the input stream of the binding parser
+class InputStream {
+    // 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.InputStream = InputStream;