@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/ast.js

@@ -0,0 +1,630 @@
+export function isDocumentNode(node) {
+  return node.type === "Document";
+}
+export function isTextNode(node) {
+  return node.type === "Text";
+}
+export function isExpressionNode(node) {
+  return node.type === "Expression";
+}
+export function isDirectiveNode(node) {
+  return node.type === "Directive";
+}
+export function isComponentNode(node) {
+  return node.type === "Component";
+}
+export function isElementNode(node) {
+  return node.type === "Element";
+}
+export function isAttributeNode(node) {
+  return node.type === "Attribute";
+}
+export function isCommentNode(node) {
+  return node.type === "Comment";
+}
+export function isScriptNode(node) {
+  return node.type === "Script";
+}
+export function isStyleNode(node) {
+  return node.type === "Style";
+}
+export function createDocument(children = [], loc) {
+  return { type: "Document", children, loc };
+}
+export function createText(value, loc) {
+  return { type: "Text", value, loc };
+}
+export function createExpression(expression, escaped = !0, loc) {
+  const raw = escaped ? `{{ ${expression} }}` : `{!! ${expression} !!}`;
+  return { type: "Expression", expression, escaped, raw, loc };
+}
+export function createDirective(name, params = null, body = null, loc) {
+  const selfClosing = body === null;
+  let raw = `@${name}`;
+  if (params)
+    raw += `(${params})`;
+  return { type: "Directive", name, params, body, selfClosing, raw, loc };
+}
+export function createComponent(name, attributes = [], children = [], selfClosing = !1, loc) {
+  return { type: "Component", name, attributes, children, selfClosing, loc };
+}
+export function createElement(tag, attributes = [], children = [], loc) {
+  const isVoid = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]).has(tag.toLowerCase());
+  return {
+    type: "Element",
+    tag,
+    attributes,
+    children: isVoid ? [] : children,
+    selfClosing: isVoid || children.length === 0,
+    void: isVoid,
+    loc
+  };
+}
+export function createAttribute(name, value = null, loc) {
+  return { type: "Attribute", name, value, dynamic: value !== null && typeof value !== "string", loc };
+}
+export function createComment(value, style = "html", loc) {
+  return { type: "Comment", value, style, loc };
+}
+export function createScript(content, attributes = [], loc) {
+  return { type: "Script", content, attributes, loc };
+}
+export function createStyle(content, attributes = [], scoped = !1, loc) {
+  return { type: "Style", content, attributes, scoped, loc };
+}
+export function walkAST(node, visitor, parent = null) {
+  node.parent = parent ?? void 0;
+  if (visitor.enter) {
+    if (visitor.enter(node, parent) === !1)
+      return;
+  }
+  const typeVisitor = visitor[node.type];
+  if (typeVisitor && typeof typeVisitor === "object" && "enter" in typeVisitor) {
+    const enterFn = typeVisitor.enter;
+    if (enterFn(node) === !1)
+      return;
+  }
+  const children = getChildren(node);
+  for (const child of children)
+    walkAST(child, visitor, node);
+  if (typeVisitor && typeof typeVisitor === "object" && "leave" in typeVisitor) {
+    const leaveFn = typeVisitor.leave;
+    leaveFn(node);
+  }
+  if (visitor.leave)
+    visitor.leave(node, parent);
+}
+export function getChildren(node) {
+  switch (node.type) {
+    case "Document":
+      return node.children;
+    case "Directive":
+      return node.body || [];
+    case "Component":
+      return [...node.attributes, ...node.children];
+    case "Element":
+      return [...node.attributes, ...node.children];
+    case "Script":
+    case "Style":
+      return node.attributes;
+    default:
+      return [];
+  }
+}
+export function cloneNode(node) {
+  const clone = { ...node };
+  if ("children" in clone && Array.isArray(clone.children))
+    clone.children = clone.children.map((child) => cloneNode(child));
+  if ("body" in clone && Array.isArray(clone.body))
+    clone.body = clone.body.map((child) => cloneNode(child));
+  if ("attributes" in clone && Array.isArray(clone.attributes))
+    clone.attributes = clone.attributes.map((attr) => cloneNode(attr));
+  delete clone.parent;
+  return clone;
+}
+export function replaceNode(root, target, replacement) {
+  walkAST(root, {
+    enter(node) {
+      const children = getChildrenArray(node);
+      if (children) {
+        const index = children.indexOf(target);
+        if (index !== -1) {
+          const replacements = Array.isArray(replacement) ? replacement : [replacement];
+          children.splice(index, 1, ...replacements);
+        }
+      }
+    }
+  });
+}
+export function removeNode(root, target) {
+  walkAST(root, {
+    enter(node) {
+      const children = getChildrenArray(node);
+      if (children) {
+        const index = children.indexOf(target);
+        if (index !== -1)
+          children.splice(index, 1);
+      }
+    }
+  });
+}
+function getChildrenArray(node) {
+  if ("children" in node && Array.isArray(node.children))
+    return node.children;
+  if ("body" in node && Array.isArray(node.body))
+    return node.body;
+  return null;
+}
+export function findNodes(root, predicate) {
+  const results = [];
+  walkAST(root, {
+    enter(node) {
+      if (predicate(node))
+        results.push(node);
+    }
+  });
+  return results;
+}
+export function findNodesByType(root, type) {
+  return findNodes(root, (node) => node.type === type);
+}
+export function findDirectives(root, name) {
+  return findNodes(root, (node) => isDirectiveNode(node) && node.name === name);
+}
+export function findComponents(root, name) {
+  return findNodes(root, (node) => isComponentNode(node) && node.name === name);
+}
+export function findElements(root, tag) {
+  return findNodes(root, (node) => isElementNode(node) && node.tag.toLowerCase() === tag.toLowerCase());
+}
+export function getExpressions(root) {
+  return findNodesByType(root, "Expression");
+}
+export function getDirectiveNames(root) {
+  const names = new Set;
+  walkAST(root, {
+    Directive: {
+      enter(node) {
+        names.add(node.name);
+      }
+    }
+  });
+  return names;
+}
+export function getComponentNames(root) {
+  const names = new Set;
+  walkAST(root, {
+    Component: {
+      enter(node) {
+        names.add(node.name);
+      }
+    }
+  });
+  return names;
+}
+export function generateCode(node) {
+  switch (node.type) {
+    case "Document":
+      return node.children.map((child) => generateCode(child)).join("");
+    case "Text":
+      return node.value;
+    case "Expression":
+      return node.raw;
+    case "Directive":
+      if (node.selfClosing)
+        return node.raw;
+      else {
+        const bodyCode = node.body?.map((child) => generateCode(child)).join("") || "";
+        return `${node.raw}${bodyCode}@end${node.name}`;
+      }
+    case "Component": {
+      const attrs = node.attributes.map((attr) => generateCode(attr)).join(" "), attrStr = attrs ? ` ${attrs}` : "";
+      if (node.selfClosing)
+        return `<${node.name}${attrStr} />`;
+      else {
+        const childrenCode = node.children.map((child) => generateCode(child)).join("");
+        return `<${node.name}${attrStr}>${childrenCode}</${node.name}>`;
+      }
+    }
+    case "Element": {
+      const attrs = node.attributes.map((attr) => generateCode(attr)).join(" "), attrStr = attrs ? ` ${attrs}` : "";
+      if (node.void)
+        return `<${node.tag}${attrStr}>`;
+      else if (node.selfClosing && node.children.length === 0)
+        return `<${node.tag}${attrStr} />`;
+      else {
+        const childrenCode = node.children.map((child) => generateCode(child)).join("");
+        return `<${node.tag}${attrStr}>${childrenCode}</${node.tag}>`;
+      }
+    }
+    case "Attribute":
+      if (node.value === null)
+        return node.name;
+      else if (typeof node.value === "string")
+        return `${node.name}="${node.value}"`;
+      else
+        return `${node.name}="${generateCode(node.value)}"`;
+    case "Comment":
+      if (node.style === "stx")
+        return `{{-- ${node.value} --}}`;
+      else
+        return `<!-- ${node.value} -->`;
+    case "Script": {
+      const attrs = node.attributes.map((attr) => generateCode(attr)).join(" ");
+      return `<script${attrs ? ` ${attrs}` : ""}>${node.content}</script>`;
+    }
+    case "Style": {
+      const attrs = node.attributes.map((attr) => generateCode(attr)).join(" "), attrStr = attrs ? ` ${attrs}` : "", scopedAttr = node.scoped && !attrStr.includes("scoped") ? " scoped" : "";
+      return `<style${attrStr}${scopedAttr}>${node.content}</style>`;
+    }
+    default:
+      return "";
+  }
+}
+
+export class TemplateParser {
+  source = "";
+  pos = 0;
+  line = 1;
+  column = 0;
+  filePath;
+  parse(template, filePath) {
+    this.source = template;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 0;
+    this.filePath = filePath;
+    const children = this.parseChildren();
+    return createDocument(children, {
+      start: { line: 1, column: 0 },
+      end: { line: this.line, column: this.column },
+      source: this.filePath
+    });
+  }
+  parseChildren(stopAt) {
+    const children = [];
+    while (this.pos < this.source.length) {
+      if (stopAt && stopAt.test(this.source.slice(this.pos)))
+        break;
+      const node = this.parseNext();
+      if (node)
+        children.push(node);
+      else
+        break;
+    }
+    return children;
+  }
+  parseNext() {
+    if (this.pos >= this.source.length)
+      return null;
+    const remaining = this.source.slice(this.pos);
+    if (remaining.startsWith("{{--"))
+      return this.parseStxComment();
+    if (remaining.startsWith("{{"))
+      return this.parseExpression(!0);
+    if (remaining.startsWith("{!!"))
+      return this.parseExpression(!1);
+    if (remaining.match(/^@[a-z]/i))
+      return this.parseDirective();
+    if (remaining.startsWith("<!--"))
+      return this.parseHtmlComment();
+    if (remaining.match(/^<script/i))
+      return this.parseScript();
+    if (remaining.match(/^<style/i))
+      return this.parseStyle();
+    if (remaining.startsWith("<") && !remaining.startsWith("</"))
+      return this.parseTag();
+    return this.parseText();
+  }
+  parseText() {
+    const start = this.getPosition();
+    let value = "";
+    while (this.pos < this.source.length) {
+      const char = this.source[this.pos], remaining = this.source.slice(this.pos);
+      if (remaining.startsWith("{{") || remaining.startsWith("{!!") || remaining.match(/^@[a-z]/i) || remaining.startsWith("<"))
+        break;
+      value += char;
+      this.advance();
+    }
+    if (value.length === 0)
+      return null;
+    return createText(value, {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseExpression(escaped) {
+    const start = this.getPosition(), startDelim = escaped ? "{{" : "{!!", endDelim = escaped ? "}}" : "!!}";
+    this.advance(startDelim.length);
+    let expression = "";
+    while (this.pos < this.source.length) {
+      if (this.source.slice(this.pos).startsWith(endDelim))
+        break;
+      expression += this.source[this.pos];
+      this.advance();
+    }
+    this.advance(endDelim.length);
+    return createExpression(expression.trim(), escaped, {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseDirective() {
+    const start = this.getPosition();
+    this.advance();
+    let name = "";
+    while (this.pos < this.source.length && /[a-z]/i.test(this.source[this.pos])) {
+      name += this.source[this.pos];
+      this.advance();
+    }
+    let params = null;
+    if (this.source[this.pos] === "(")
+      params = this.parseParenthesized();
+    const blockDirectives = new Set([
+      "if",
+      "unless",
+      "isset",
+      "empty",
+      "auth",
+      "guest",
+      "env",
+      "foreach",
+      "for",
+      "forelse",
+      "while",
+      "switch",
+      "section",
+      "push",
+      "prepend",
+      "once",
+      "component",
+      "slot",
+      "verbatim",
+      "php",
+      "js",
+      "ts"
+    ]);
+    let body = null;
+    if (blockDirectives.has(name)) {
+      const endPattern = new RegExp(`^@end${name}\\b`);
+      body = this.parseChildren(endPattern);
+      const endMatch = this.source.slice(this.pos).match(endPattern);
+      if (endMatch)
+        this.advance(endMatch[0].length);
+    }
+    return createDirective(name, params, body, {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseParenthesized() {
+    let content = "", depth = 0;
+    while (this.pos < this.source.length) {
+      const char = this.source[this.pos];
+      if (char === "(") {
+        depth++;
+        if (depth > 1)
+          content += char;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0) {
+          this.advance();
+          break;
+        }
+        content += char;
+      } else if (depth > 0)
+        content += char;
+      this.advance();
+    }
+    return content;
+  }
+  parseStxComment() {
+    const start = this.getPosition();
+    this.advance(4);
+    let value = "";
+    while (this.pos < this.source.length) {
+      if (this.source.slice(this.pos).startsWith("--}}"))
+        break;
+      value += this.source[this.pos];
+      this.advance();
+    }
+    this.advance(4);
+    return createComment(value.trim(), "stx", {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseHtmlComment() {
+    const start = this.getPosition();
+    this.advance(4);
+    let value = "";
+    while (this.pos < this.source.length) {
+      if (this.source.slice(this.pos).startsWith("-->"))
+        break;
+      value += this.source[this.pos];
+      this.advance();
+    }
+    this.advance(3);
+    return createComment(value.trim(), "html", {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseTag() {
+    const start = this.getPosition();
+    this.advance();
+    let tagName = "";
+    while (this.pos < this.source.length && /[a-z0-9-]/i.test(this.source[this.pos])) {
+      tagName += this.source[this.pos];
+      this.advance();
+    }
+    const attributes = this.parseAttributes();
+    this.skipWhitespace();
+    const selfClosing = this.source.slice(this.pos).startsWith("/>");
+    if (selfClosing)
+      this.advance(2);
+    else
+      this.advance();
+    const isComponent = /^[A-Z]/.test(tagName), isVoid = new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]).has(tagName.toLowerCase());
+    let children = [];
+    if (!selfClosing && !isVoid) {
+      const closePattern = new RegExp(`^</${tagName}>`, "i");
+      children = this.parseChildren(closePattern);
+      const closeMatch = this.source.slice(this.pos).match(closePattern);
+      if (closeMatch)
+        this.advance(closeMatch[0].length);
+    }
+    const loc = {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    };
+    if (isComponent)
+      return createComponent(tagName, attributes, children, selfClosing, loc);
+    else {
+      const element = createElement(tagName, attributes, children, loc);
+      element.selfClosing = selfClosing || isVoid;
+      return element;
+    }
+  }
+  parseAttributes() {
+    const attributes = [];
+    while (this.pos < this.source.length) {
+      this.skipWhitespace();
+      if (this.source[this.pos] === ">" || this.source.slice(this.pos).startsWith("/>"))
+        break;
+      const attr = this.parseAttribute();
+      if (attr)
+        attributes.push(attr);
+    }
+    return attributes;
+  }
+  parseAttribute() {
+    const start = this.getPosition();
+    let name = "";
+    while (this.pos < this.source.length && /[a-z0-9-:@.]/i.test(this.source[this.pos])) {
+      name += this.source[this.pos];
+      this.advance();
+    }
+    if (!name)
+      return null;
+    let value = null;
+    this.skipWhitespace();
+    if (this.source[this.pos] === "=") {
+      this.advance();
+      this.skipWhitespace();
+      const quote = this.source[this.pos];
+      if (quote === '"' || quote === "'") {
+        this.advance();
+        let attrValue = "";
+        while (this.pos < this.source.length && this.source[this.pos] !== quote) {
+          attrValue += this.source[this.pos];
+          this.advance();
+        }
+        this.advance();
+        if (attrValue.includes("{{") || attrValue.includes("{!!"))
+          value = attrValue;
+        else
+          value = attrValue;
+      }
+    }
+    return createAttribute(name, value, {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseScript() {
+    const start = this.getPosition();
+    this.advance(7);
+    const attributes = this.parseAttributes();
+    this.skipWhitespace();
+    this.advance();
+    let content = "";
+    while (this.pos < this.source.length) {
+      if (this.source.slice(this.pos).match(/^<\/script>/i))
+        break;
+      content += this.source[this.pos];
+      this.advance();
+    }
+    this.advance(9);
+    return createScript(content, attributes, {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  parseStyle() {
+    const start = this.getPosition();
+    this.advance(6);
+    const attributes = this.parseAttributes(), scoped = attributes.some((attr) => attr.name === "scoped");
+    this.skipWhitespace();
+    this.advance();
+    let content = "";
+    while (this.pos < this.source.length) {
+      if (this.source.slice(this.pos).match(/^<\/style>/i))
+        break;
+      content += this.source[this.pos];
+      this.advance();
+    }
+    this.advance(8);
+    return createStyle(content, attributes, scoped, {
+      start,
+      end: this.getPosition(),
+      source: this.filePath
+    });
+  }
+  advance(count = 1) {
+    for (let i = 0;i < count && this.pos < this.source.length; i++) {
+      if (this.source[this.pos] === `
+`) {
+        this.line++;
+        this.column = 0;
+      } else
+        this.column++;
+      this.pos++;
+    }
+  }
+  skipWhitespace() {
+    while (this.pos < this.source.length && /\s/.test(this.source[this.pos]))
+      this.advance();
+  }
+  getPosition() {
+    return { line: this.line, column: this.column };
+  }
+}