ui

2022-04-07 18:09:31 +05:30
parent 36ea86d8e6
commit 1c779ef816
14095 changed files with 1769361 additions and 47 deletions
@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomHandler = void 0;
+var node_1 = require("./node");
+__exportStar(require("./node"), exports);
+var reWhitespace = /\s+/g;
+// Default options
+var defaultOpts = {
+    normalizeWhitespace: false,
+    withStartIndices: false,
+    withEndIndices: false,
+};
+var DomHandler = /** @class */ (function () {
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    function DomHandler(callback, options, elementCB) {
+        /** The constructed DOM */
+        this.dom = [];
+        /** Indicated whether parsing has been completed. */
+        this._done = false;
+        /** Stack of open tags. */
+        this._tagStack = [];
+        /** A data node that is still being written to. */
+        this._lastNode = null;
+        /** Reference to the parser instance. Used for location information. */
+        this._parser = null;
+        // Make it possible to skip arguments, for backwards-compatibility
+        if (typeof options === "function") {
+            elementCB = options;
+            options = defaultOpts;
+        }
+        if (typeof callback === "object") {
+            options = callback;
+            callback = undefined;
+        }
+        this._callback = callback !== null && callback !== void 0 ? callback : null;
+        this._options = options !== null && options !== void 0 ? options : defaultOpts;
+        this._elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;
+    }
+    DomHandler.prototype.onparserinit = function (parser) {
+        this._parser = parser;
+    };
+    // Resets the handler back to starting state
+    DomHandler.prototype.onreset = function () {
+        var _a;
+        this.dom = [];
+        this._done = false;
+        this._tagStack = [];
+        this._lastNode = null;
+        this._parser = (_a = this._parser) !== null && _a !== void 0 ? _a : null;
+    };
+    // Signals the handler that parsing is done
+    DomHandler.prototype.onend = function () {
+        if (this._done)
+            return;
+        this._done = true;
+        this._parser = null;
+        this.handleCallback(null);
+    };
+    DomHandler.prototype.onerror = function (error) {
+        this.handleCallback(error);
+    };
+    DomHandler.prototype.onclosetag = function () {
+        this._lastNode = null;
+        var elem = this._tagStack.pop();
+        if (!elem || !this._parser) {
+            return;
+        }
+        if (this._options.withEndIndices) {
+            elem.endIndex = this._parser.endIndex;
+        }
+        if (this._elementCB)
+            this._elementCB(elem);
+    };
+    DomHandler.prototype.onopentag = function (name, attribs) {
+        var element = new node_1.Element(name, attribs);
+        this.addNode(element);
+        this._tagStack.push(element);
+    };
+    DomHandler.prototype.ontext = function (data) {
+        var normalize = this._options.normalizeWhitespace;
+        var _lastNode = this._lastNode;
+        if (_lastNode && _lastNode.type === "text" /* Text */) {
+            if (normalize) {
+                _lastNode.data = (_lastNode.data + data).replace(reWhitespace, " ");
+            }
+            else {
+                _lastNode.data += data;
+            }
+        }
+        else {
+            if (normalize) {
+                data = data.replace(reWhitespace, " ");
+            }
+            var node = new node_1.Text(data);
+            this.addNode(node);
+            this._lastNode = node;
+        }
+    };
+    DomHandler.prototype.oncomment = function (data) {
+        if (this._lastNode && this._lastNode.type === "comment" /* Comment */) {
+            this._lastNode.data += data;
+            return;
+        }
+        var node = new node_1.Comment(data);
+        this.addNode(node);
+        this._lastNode = node;
+    };
+    DomHandler.prototype.oncommentend = function () {
+        this._lastNode = null;
+    };
+    DomHandler.prototype.oncdatastart = function () {
+        var text = new node_1.Text("");
+        var node = new node_1.NodeWithChildren("cdata" /* CDATA */, [text]);
+        this.addNode(node);
+        text.parent = node;
+        this._lastNode = text;
+    };
+    DomHandler.prototype.oncdataend = function () {
+        this._lastNode = null;
+    };
+    DomHandler.prototype.onprocessinginstruction = function (name, data) {
+        var node = new node_1.ProcessingInstruction(name, data);
+        this.addNode(node);
+    };
+    DomHandler.prototype.handleCallback = function (error) {
+        if (typeof this._callback === "function") {
+            this._callback(error, this.dom);
+        }
+        else if (error) {
+            throw error;
+        }
+    };
+    DomHandler.prototype.addNode = function (node) {
+        var parent = this._tagStack[this._tagStack.length - 1];
+        var siblings = parent ? parent.children : this.dom;
+        var previousSibling = siblings[siblings.length - 1];
+        if (this._parser) {
+            if (this._options.withStartIndices) {
+                node.startIndex = this._parser.startIndex;
+            }
+            if (this._options.withEndIndices) {
+                node.endIndex = this._parser.endIndex;
+            }
+        }
+        siblings.push(node);
+        if (previousSibling) {
+            node.prev = previousSibling;
+            previousSibling.next = node;
+        }
+        if (parent) {
+            node.parent = parent;
+        }
+        this._lastNode = null;
+    };
+    DomHandler.prototype.addDataNode = function (node) {
+        this.addNode(node);
+        this._lastNode = node;
+    };
+    return DomHandler;
+}());
+exports.DomHandler = DomHandler;
+exports.default = DomHandler;