xmlui 0.7.30 → 0.7.32

package/dist/xmlui-parser.mjs

@@ -0,0 +1,407 @@
+import { K as A } from "./lint-DgP_MIP6.mjs";
+import { ag as $, M as v, a2 as j, _ as O, Y as P, a1 as T, X as V, $ as L, O as I, a0 as w, Z as z, U as M, R as Q, W as k, Q as B, D as R, E as F, a4 as K, C as W, a7 as H, S as q, ae as G, A as Y, z as Z, a9 as J, n as ee, N as te, a8 as re, aj as ae, B as se, ad as ie, aa as ne, ac as le, ab as ce, a5 as de, F as me, H as he, a3 as ue, p as fe, af as oe, a6 as pe, G as Ee, ai as Ne, ah as ye } from "./lint-DgP_MIP6.mjs";
+const p = /[\r\n<>'"&]/;
+class D {
+  /**
+   * Serialize the specified XML fragment into a string
+   * @param xml XML fragment to serialize
+   * @param options Formatting options to use
+   */
+  serialize(t, e) {
+    const r = Array.isArray(t) ? t : [t];
+    return s(r, 0);
+    function s(i, d) {
+      return i.map((l) => a(l, d)).join(e != null && e.prettify ? `
+` + n(d) : "");
+    }
+    function a(i, d) {
+      switch (i.type) {
+        case "XmlUiComment":
+          return c(i, d);
+        case "XmlUiElement":
+          return h(i, d);
+        default:
+          return "";
+      }
+    }
+    function n(i) {
+      return e != null && e.prettify ? "".padEnd(((e == null ? void 0 : e.indents) ?? 2) * i, " ") : "";
+    }
+    function c(i, d) {
+      return `${n(d)}<!--${i.text}-->`;
+    }
+    function h(i, d) {
+      var y, g;
+      let l = `${n(d)}<${N()}`;
+      const E = (((y = i.attributes) == null ? void 0 : y.length) ?? 0) > 0, o = (((g = i.childNodes) == null ? void 0 : g.length) ?? 0) > 0;
+      if (i.text || E || o) {
+        if (E) {
+          const m = i.attributes.map((u) => b(u));
+          e != null && e.prettify && l.length + 1 + // --- Space after
+          m.join(" ").length + // --- Attributes total length
+          (o ? 1 : (e == null ? void 0 : e.useSpaceBeforeClose) ?? !1 ? 3 : 2) > ((e == null ? void 0 : e.lineLength) ?? 80) ? (m.forEach((_) => {
+            l += `
+` + n(d + 1) + _;
+          }), ((e == null ? void 0 : e.breakClosingTag) ?? !1) && (l += `
+` + n(d))) : l += " " + m.join(" ");
+        }
+        if (i.text || o) {
+          if (l += ">", i.text) {
+            const m = i.preserveSpaces ? f(i.text) : C(i.text);
+            e != null && e.prettify && l.length + m.length + i.name.length + 3 > ((e == null ? void 0 : e.lineLength) ?? 80) ? l += `
+` + n(d + 1) + m + `
+` : l += m;
+          }
+          if (o) {
+            const m = i.childNodes.map((u) => a(u, d + 1));
+            e != null && e.prettify ? (m.forEach((u) => {
+              l += `
+` + u;
+            }), l += `
+`) : l += m.join("");
+          }
+          l += `${n(d)}</${i.name}>`;
+        } else
+          l += ((e == null ? void 0 : e.useSpaceBeforeClose) ?? !1 ? " " : "") + "/>";
+      } else
+        l += ((e == null ? void 0 : e.useSpaceBeforeClose) ?? !1 ? " " : "") + "/>", i.text === "" && (l += `""</${N()}>`);
+      return l;
+      function N() {
+        return i.namespace ? `${i.namespace}:${i.name}` : i.name;
+      }
+    }
+    function b(i) {
+      if (i.value === void 0 || i.value === null)
+        return `${l()}`;
+      if (i.preserveSpaces)
+        return `${l()}=${f(i.value)}`;
+      const d = i.value ?? "";
+      return `${l()}=${f(d)}`;
+      function l() {
+        return i.namespace ? `${i.namespace}:${i.name}` : i.name;
+      }
+    }
+    function C(i) {
+      return e != null && e.useQuotes || p.test(i) ? f(i) : i;
+    }
+    function f(i) {
+      const d = i.indexOf("'") >= 0, l = i.indexOf('"') >= 0;
+      return !d && !l || d && !l ? `"${i.replaceAll("`", "\\`")}"` : l && !d ? `'${i.replaceAll("`", "\\`")}'` : `\`${i.replaceAll("`", "\\`")}\``;
+    }
+  }
+  /**
+   * Transform the specified component definition into an UEML node
+   * @param def Component definitions
+   * @param options Transformation options
+   */
+  transformComponentDefinition(t, e) {
+    return t.type ? this.transformSimpleComponentDefinition(t, e) : this.transformCompoundComponentDefinition(t, e);
+  }
+  /**
+   * Transform the specified object into an UEML nodes
+   * @param def Object definition
+   * @param options Transformation options
+   */
+  transformObject(t, e) {
+    const r = this.transformValue("Object", "", t, e);
+    return r ? r.childNodes ?? [] : null;
+  }
+  /**
+   * Transforms the specified simple component definition into an UEML node
+   * @param def Component definition
+   * @param options Transformation options
+   */
+  transformSimpleComponentDefinition(t, e) {
+    const r = {
+      type: "XmlUiElement",
+      name: t.type
+    };
+    return t.uid !== void 0 && this.addProperty(r, "id", t.uid, e), t.testId !== void 0 && this.addProperty(r, "testId", t.testId, e), t.when !== void 0 && this.addProperty(r, "when", t.when, e), t.vars && Object.keys(t.vars).forEach((s) => {
+      const a = this.transformValue("var", s, t.vars[s], e);
+      a !== null && (r.childNodes ?? (r.childNodes = []), r.childNodes.push(a));
+    }), t.props && Object.keys(t.props).forEach((s) => {
+      const a = t.props[s];
+      if (s.endsWith("Template") && a.type) {
+        r.childNodes ?? (r.childNodes = []);
+        const n = {
+          type: "XmlUiElement",
+          name: "property",
+          attributes: [
+            {
+              type: "XmlUiAttribute",
+              name: "name",
+              value: s
+            }
+          ]
+        };
+        this.addComponentElement(n, a), r.childNodes.push(n);
+      } else {
+        if (a === void 0)
+          return;
+        if (a === null) {
+          const n = {
+            type: "XmlUiElement",
+            name: "property",
+            attributes: [
+              {
+                type: "XmlUiAttribute",
+                name: "name",
+                value: s
+              }
+            ]
+          };
+          r.childNodes ?? (r.childNodes = []), r.childNodes.push(n);
+          return;
+        }
+        if (s === "id" || s === "when" || s === "testId" || e != null && e.extractProps) {
+          const n = {
+            type: "XmlUiElement",
+            name: "property"
+          };
+          this.addProperty(n, s, a, e), r.childNodes ?? (r.childNodes = []), r.childNodes.push(n);
+          return;
+        }
+        this.addProperty(r, s, a, e);
+      }
+    }), t.events && Object.keys(t.events).forEach((s) => {
+      const a = this.transformValue("event", s, t.events[s], e);
+      a !== null && (r.childNodes ?? (r.childNodes = []), r.childNodes.push(a));
+    }), t.loaders && this.addComponentList(r, "loaders", t.loaders), t.api && Object.keys(t.api).forEach((s) => {
+      const a = this.transformValue("api", s, t.api[s], e);
+      a !== null && (r.childNodes ?? (r.childNodes = []), r.childNodes.push(a));
+    }), t.uses && this.addList(r, "uses", "", t.uses, e), t.children && (typeof t.children == "string" ? this.addProperty(r, "children", t.children, e) : t.children.forEach((s) => {
+      this.addComponentElement(r, s);
+    })), r;
+  }
+  /**
+   * Transforms the specified simple component definition into an Xml node
+   * @param def Compound component definition
+   * @param options Transformation options
+   */
+  transformCompoundComponentDefinition(t, e) {
+    if (typeof t == "string")
+      return {
+        type: "XmlUiElement",
+        name: t
+      };
+    const r = this.transformSimpleComponentDefinition(
+      t.component,
+      e
+    ), s = {
+      type: "XmlUiElement",
+      name: A,
+      attributes: [
+        {
+          type: "XmlUiAttribute",
+          name: "name",
+          value: t.name
+        }
+      ],
+      childNodes: Array.isArray(r) ? [...r] : [r]
+    };
+    return t.api && Object.keys(t.api).forEach((a) => {
+      const n = this.transformValue("api", a, t.api[a], e);
+      n !== null && (s.childNodes ?? (s.childNodes = []), s.childNodes.push(n));
+    }), s;
+  }
+  /**
+   * 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(t, e, r, s) {
+    if (r === void 0) return null;
+    const a = {
+      type: "XmlUiElement",
+      name: t
+    };
+    if (e && (a.attributes = [
+      {
+        type: "XmlUiAttribute",
+        name: "name",
+        value: e
+      }
+    ]), r === null)
+      return a;
+    if (typeof r == "string" || typeof r == "number" || typeof r == "boolean") {
+      const n = typeof r == "string" ? r.toString() : `{${r.toString()}}`, c = p.test(n) || n.trim().length != n.length;
+      return s != null && s.preferTextToValue ? (a.text = n, a.preserveSpaces = c) : (a.attributes ?? (a.attributes = []), a.attributes.push({
+        type: "XmlUiAttribute",
+        name: "value",
+        value: n,
+        preserveSpaces: c
+      })), a;
+    }
+    if (Array.isArray(r))
+      r.length === 0 ? (a.attributes ?? (a.attributes = []), a.attributes.push({
+        type: "XmlUiAttribute",
+        name: "value",
+        value: "{[]}"
+      })) : r.forEach((n) => {
+        const c = this.transformValue("item", void 0, n, s);
+        c && (a.childNodes ?? (a.childNodes = []), a.childNodes.push(c));
+      });
+    else if (typeof r == "object") {
+      const n = Object.keys(r);
+      n.length === 0 ? (a.attributes ?? (a.attributes = []), a.attributes.push({
+        type: "XmlUiAttribute",
+        name: "value",
+        value: "{{}}"
+      })) : n.forEach((c) => {
+        const h = this.transformValue("field", c, r[c], s);
+        h && (a.childNodes ?? (a.childNodes = []), a.childNodes.push(h));
+      });
+    } else
+      throw new Error(`Cannot serialize '${typeof r}' value`);
+    return a;
+  }
+  /**
+   * Transforms the specified simple component definition into an Xml node
+   * @param name Element name
+   * @param value Value to transform
+   * @param options Transformation options
+   */
+  transformObjectValue(t, e, r) {
+    const s = {
+      type: "XmlUiElement",
+      name: t
+    };
+    return e && Object.keys(e).forEach(
+      (a) => this.addProperty(s, a, e[a], r)
+    ), s;
+  }
+  /**
+   * 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(t, e, r, s) {
+    switch (typeof r) {
+      case "undefined":
+        break;
+      case "string":
+        t.attributes ?? (t.attributes = []), t.attributes.push({
+          type: "XmlUiAttribute",
+          name: e,
+          value: r == null ? void 0 : r.toString(),
+          preserveQuotes: (s == null ? void 0 : s.removeQuotes) ?? !1,
+          preserveSpaces: p.test(r.toString())
+        });
+        break;
+      case "boolean":
+      case "number":
+      case "object":
+        const a = this.transformValue("property", e, r, s);
+        a && (t.childNodes ?? (t.childNodes = []), t.childNodes.push(a));
+        break;
+      default:
+        throw new Error(`'${typeof r}' transformation is not implemented yet`);
+    }
+  }
+  addComponentElement(t, e) {
+    t.childNodes ?? (t.childNodes = []);
+    const r = this.transformComponentDefinition(e);
+    Array.isArray(r) ? t.childNodes.push(...r) : t.childNodes.push(r);
+  }
+  /**
+   * 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(t, e, r, s, a) {
+    const n = `${r ? r + "." : ""}${e}`;
+    t.childNodes ?? (t.childNodes = []), s.forEach((c) => {
+      if (typeof c == "string")
+        t.childNodes.push({
+          type: "XmlUiElement",
+          name: n,
+          text: c,
+          preserveSpaces: p.test(c) || c !== c.trim() || c === ""
+        });
+      else if (c === null)
+        t.childNodes.push({
+          type: "XmlUiElement",
+          name: n
+        });
+      else {
+        const h = this.transformObjectValue(n, c, a);
+        Array.isArray(h) ? t.childNodes.push(...h) : t.childNodes.push(h);
+      }
+    });
+  }
+  /**
+   * 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(t, e, r) {
+    const s = [];
+    r.forEach((n) => {
+      const c = this.transformSimpleComponentDefinition(n);
+      Array.isArray(c) ? s.push(...c) : s.push(c);
+    });
+    const a = {
+      type: "XmlUiElement",
+      name: e,
+      childNodes: s
+    };
+    t.childNodes ?? (t.childNodes = []), t.childNodes.push(a);
+  }
+}
+export {
+  A as COMPOUND_COMP_ID,
+  $ as CORE_NAMESPACE_VALUE,
+  v as CharacterCodes,
+  j as Diag_Attr_Identifier_Expected,
+  O as Diag_Attr_Value_Expected,
+  P as Diag_CloseNodeStart_Token_Expected,
+  T as Diag_End_Or_Close_Token_Expected,
+  V as Diag_End_Token_Expected,
+  L as Diag_Eq_Token_Expected,
+  I as Diag_Invalid_Character,
+  w as Diag_OpenNodeStart_Token_Expected,
+  z as Diag_Tag_Identifier_Expected,
+  M as Diag_Unterminated_CData,
+  Q as Diag_Unterminated_Comment,
+  k as Diag_Unterminated_Script,
+  B as Diag_Unterminated_String_Literal,
+  R as DiagnosticCategory,
+  F as ErrCodes,
+  K as LintDiagKind,
+  W as LintSeverity,
+  H as ParserError,
+  q as SyntaxKind,
+  G as UCRegex,
+  D as XmlUiHelper,
+  Y as codeBehindFileExtension,
+  Z as componentFileExtension,
+  J as createScanner,
+  ee as createXmlUiParser,
+  te as diagnosticCategoryName,
+  re as errorMessages,
+  ae as findTokenAtPos,
+  se as getLintSeverity,
+  ie as getSyntaxKindStrRepr,
+  ne as isIdentifierStart,
+  le as isInnerNode,
+  ce as isTrivia,
+  de as lint,
+  me as lintApp,
+  he as lintErrorsComponent,
+  ue as moduleFileExtension,
+  fe as nodeToComponentDef,
+  oe as onPrefixRegex,
+  pe as parseXmlUiMarkup,
+  Ee as printComponentLints,
+  Ne as tagNameNodesWithoutErrorsMatch,
+  ye as toDbgString
+};