@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/instructions/grouping.js

@@ -0,0 +1,106 @@
+/**
+ * xsl:for-each-group (XSLT 3.0 section 14): group-by, group-adjacent,
+ * group-starting-with and group-ending-with, then the groups processed
+ * in order (or sorted), each with its current group and grouping key.
+ *
+ * @module @tradik/xslt3/xslt/instructions/grouping
+ */
+
+import { getCollation } from "../../functions/collations.js";
+import { compileBody } from "../compiler/body.js";
+import { required, yesNo } from "../compiler/attributes.js";
+import { derive, evaluate } from "../runtime/context.js";
+import { groupByKeys, groupByPattern } from "../runtime/groups.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, xsltError } from "../names.js";
+import { compilePattern } from "../patterns/compile.js";
+import { BodyFrame, LoopFrame } from "../runtime/machine.js";
+import { compileSorts, splitSorts } from "./sort.js";
+
+const METHODS = [
+  "group-by",
+  "group-adjacent",
+  "group-starting-with",
+  "group-ending-with",
+];
+
+/**
+ * xsl:for-each-group.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileForEachGroup(element, cx, scope) {
+  const select = cx.exprs.xpath(
+    required(element, "select"),
+    element,
+    scope.vars,
+  );
+  const present = METHODS.filter((name) => attr(element, name) !== undefined);
+  if (present.length !== 1) {
+    throw xsltError("XTSE1080", "xsl:for-each-group needs one grouping method");
+  }
+  const method = present[0];
+  const text = attr(element, method);
+  const byPattern = method.endsWith("with");
+  const keys = byPattern ? null : cx.exprs.xpath(text, element, scope.vars);
+  const pattern = byPattern
+    ? compilePattern(text, element, cx, scope.vars)
+    : null;
+  const collationText = attr(element, "collation");
+  if (collationText !== undefined && byPattern) {
+    throw xsltError("XTSE1090", "collation needs group-by or group-adjacent");
+  }
+  const collation =
+    collationText === undefined
+      ? null
+      : avtEvaluator(cx.exprs.avt(collationText, element, scope.vars));
+  const { sorts, rest } = splitSorts(cx.children(element));
+  const sort = compileSorts(sorts, cx, scope);
+  const body = compileBody(element, cx, scope, rest);
+  const composite = yesNo(element, "composite", false);
+  return (xc, out, machine) => {
+    const items = evaluate(select, xc);
+    let collationObject = getCollation(undefined, xc.tx.dyn);
+    if (collation) {
+      const uri = collation(xc);
+      try {
+        collationObject = getCollation(uri, xc.tx.dyn);
+      } catch {
+        throw xsltError("XTDE1110", `Unknown collation ${uri}`);
+      }
+    }
+    const groups = byPattern
+      ? groupByPattern(items, pattern, xc, method === "group-starting-with")
+      : groupByKeys(items, (focus) => evaluate(keys, focus), xc, {
+          adjacent: method === "group-adjacent",
+          collation: collationObject,
+          composite,
+        });
+    const order = sort.order(
+      groups.map((group) => group.items[0]),
+      xc,
+      machine,
+      (focus, i) =>
+        derive(focus, { group: groups[i].items, groupKey: groups[i].key }),
+    );
+    const ordered = order.map((i) => groups[i]);
+    const size = ordered.length;
+    if (size === 0 || body.length === 0) return;
+    const base = derive(xc, { rule: null });
+    machine.push(
+      new LoopFrame(size, (i) => {
+        const group = ordered[i];
+        const context = derive(base, {
+          item: group.items[0],
+          position: i + 1,
+          size,
+          group: group.items,
+          groupKey: group.key,
+        });
+        machine.push(new BodyFrame(body, context, out));
+      }),
+    );
+  };
+}

package/src/xslt/instructions/index.js

@@ -0,0 +1,94 @@
+/**
+ * The compilers of the XSLT instructions, by local name. Each takes the
+ * instruction element, the stylesheet compiler and the scope, and returns
+ * a step of the sequence constructor (see runtime/machine.js) or null.
+ *
+ * @module @tradik/xslt3/xslt/instructions
+ */
+
+import { compileAnalyzeString } from "./analyzeString.js";
+import { compileAssert } from "./assert.js";
+import { compileChoose, compileForEach, compileIf } from "./control.js";
+import {
+  compileCopy,
+  compileCopyOf,
+  compileDocument,
+  compilePerformSort,
+} from "./copy.js";
+import { compileAttribute, compileElement } from "./elements.js";
+import {
+  compileOnEmpty,
+  compileOnNonEmpty,
+  compileWherePopulated,
+} from "./conditional.js";
+import { compileEvaluate } from "./evaluate.js";
+import { compileFork } from "./fork.js";
+import { compileForEachGroup } from "./grouping.js";
+import {
+  compileBreak,
+  compileIterate,
+  compileNextIteration,
+} from "./iterate.js";
+import { compileMerge } from "./merge.js";
+import { compileNumber } from "./number.js";
+import { compileMap, compileMapEntry } from "./maps.js";
+import { compileMessage } from "./output.js";
+import { compileResultDocument } from "./resultDocument.js";
+import { compileSourceDocument } from "./sourceDocument.js";
+import {
+  compileApplyImports,
+  compileApplyTemplates,
+  compileCallTemplate,
+} from "./templates.js";
+import { compileTry } from "./try.js";
+import {
+  compileComment,
+  compileNamespace,
+  compileProcessingInstruction,
+  compileSequence,
+  compileText,
+  compileValueOf,
+} from "./text.js";
+
+/** @type {Record<string, Function>} */
+export const instructionCompilers = {
+  "analyze-string": compileAnalyzeString,
+  "apply-imports": compileApplyImports,
+  "apply-templates": compileApplyTemplates,
+  attribute: compileAttribute,
+  "call-template": compileCallTemplate,
+  choose: compileChoose,
+  comment: compileComment,
+  copy: compileCopy,
+  "copy-of": compileCopyOf,
+  document: compileDocument,
+  element: compileElement,
+  "for-each": compileForEach,
+  "for-each-group": compileForEachGroup,
+  if: compileIf,
+  message: compileMessage,
+  namespace: compileNamespace,
+  "next-match": compileApplyImports,
+  number: compileNumber,
+  "perform-sort": compilePerformSort,
+  "processing-instruction": compileProcessingInstruction,
+  "result-document": compileResultDocument,
+  map: compileMap,
+  "map-entry": compileMapEntry,
+  try: compileTry,
+  sequence: compileSequence,
+  text: compileText,
+  "value-of": compileValueOf,
+  // XSLT 3.0 instructions of task 0031
+  break: compileBreak,
+  iterate: compileIterate,
+  "next-iteration": compileNextIteration,
+  "on-empty": compileOnEmpty,
+  "on-non-empty": compileOnNonEmpty,
+  "where-populated": compileWherePopulated,
+  fork: compileFork,
+  "source-document": compileSourceDocument,
+  merge: compileMerge,
+  evaluate: compileEvaluate,
+  assert: compileAssert,
+};

package/src/xslt/instructions/iterate.js

@@ -0,0 +1,182 @@
+/**
+ * xsl:iterate, xsl:next-iteration, xsl:break and xsl:on-completion
+ * (XSLT 3.0 section 7.2). The iterations run on the work stack (see
+ * runtime/iteration.js); xsl:next-iteration and xsl:break record their
+ * effect in the iteration state of the context, read before the next
+ * item is processed.
+ *
+ * @module @tradik/xslt3/xslt/instructions/iterate
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { checkAttributes, required } from "../compiler/attributes.js";
+import { isWhitespaceText, splitLeading } from "../compiler/children.js";
+import { checkTailPosition } from "../compiler/tailPosition.js";
+import { evaluate } from "../runtime/context.js";
+import { IterateFrame } from "../runtime/iteration.js";
+import { BodyFrame } from "../runtime/machine.js";
+import { attr, isXsl, XSL_NS, xsltError } from "../names.js";
+import { compileParams, compileWithParams } from "./params.js";
+
+/** @type {WeakMap<Element, object[]>} the parameters of each xsl:iterate */
+const iterateParams = new WeakMap();
+
+/**
+ * Compiles the select attribute or the content of xsl:break or
+ * xsl:on-completion.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {import("../runtime/machine.js").Body}
+ */
+function compileContent(element, cx, scope) {
+  const select = attr(element, "select");
+  const children = cx.children(element).filter((c) => !isXsl(c, "fallback"));
+  if (select === undefined) return compileBody(element, cx, scope, children);
+  if (children.length > 0) {
+    throw xsltError(
+      "XTSE3125",
+      `xsl:${element.localName} has select and content`,
+    );
+  }
+  const expr = cx.exprs.xpath(select, element, scope.vars);
+  return [
+    (xc, out) => {
+      for (const item of evaluate(expr, xc)) out.item(item);
+    },
+  ];
+}
+
+/**
+ * Checks that a parameter of xsl:iterate without initial value accepts
+ * the empty sequence.
+ * @param {object} param
+ * @throws {import("../../errors.js").XPathError} XTSE3520
+ */
+function checkOptional(param) {
+  try {
+    param.convert([]);
+  } catch {
+    throw xsltError(
+      "XTSE3520",
+      `The parameter ${param.key} of xsl:iterate needs an initial value`,
+    );
+  }
+}
+
+/**
+ * Checks that the xsl:on-completion elements near an xsl:iterate (its
+ * siblings and descendants) are children of an xsl:iterate.
+ * @param {Element} element - xsl:iterate
+ * @throws {import("../../errors.js").XPathError} XTSE0010
+ */
+function checkCompletions(element) {
+  const nodes = [
+    ...element.parentNode.childNodes,
+    ...element.getElementsByTagNameNS(XSL_NS, "on-completion"),
+  ];
+  for (const node of nodes) {
+    if (isXsl(node, "on-completion") && !isXsl(node.parentNode, "iterate")) {
+      throw xsltError("XTSE0010", "xsl:on-completion must be in xsl:iterate");
+    }
+  }
+}
+
+/**
+ * xsl:iterate.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileIterate(element, cx, scope) {
+  const select = cx.exprs.xpath(
+    required(element, "select"),
+    element,
+    scope.vars,
+  );
+  checkCompletions(element);
+  const { leading, rest } = splitLeading(cx.children(element), "param");
+  const { params, scope: inner } = compileParams(leading, cx, scope);
+  leading.forEach((param, i) => {
+    const implicit =
+      attr(param, "select") === undefined && cx.children(param).length === 0;
+    if (implicit && params[i].type) checkOptional(params[i]);
+  });
+  iterateParams.set(element, params);
+  let body = rest;
+  let completion = [];
+  const first = rest.find((child) => !isWhitespaceText(child));
+  if (first && isXsl(first, "on-completion")) {
+    checkAttributes(first);
+    completion = compileContent(first, cx, inner);
+    body = rest.filter((child) => child !== first);
+  }
+  if (body.some((c) => isXsl(c, "param") || isXsl(c, "on-completion"))) {
+    throw xsltError(
+      "XTSE0010",
+      "xsl:param, then xsl:on-completion, must come first in xsl:iterate",
+    );
+  }
+  const steps = compileBody(element, cx, inner, body);
+  return (xc, out, machine) => {
+    const items = evaluate(select, xc);
+    machine.push(
+      new IterateFrame({ items, params, steps, completion, xc, out }),
+    );
+  };
+}
+
+/**
+ * The innermost xsl:iterate ancestor of an element.
+ * @param {Element} element
+ * @returns {Element}
+ */
+function enclosingIterate(element) {
+  let node = element.parentNode;
+  while (!isXsl(node, "iterate")) node = node.parentNode;
+  return node;
+}
+
+/**
+ * xsl:next-iteration.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileNextIteration(element, cx, scope) {
+  checkTailPosition(element, cx);
+  const children = cx.children(element);
+  if (!children.every((c) => isXsl(c, "with-param") || isXsl(c, "fallback"))) {
+    throw xsltError("XTSE0010", "xsl:next-iteration contains xsl:with-param");
+  }
+  const withParams = compileWithParams(children, cx, scope);
+  const declared = iterateParams.get(enclosingIterate(element));
+  const keys = new Set(declared.map((param) => param.key));
+  for (const name of withParams.names) {
+    if (!keys.has(name)) {
+      throw xsltError("XTSE3130", `xsl:iterate has no parameter ${name}`);
+    }
+  }
+  return (xc, out, machine) => {
+    const { params } = withParams.evaluate(xc, machine);
+    xc.iteration.next = params;
+  };
+}
+
+/**
+ * xsl:break.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileBreak(element, cx, scope) {
+  checkTailPosition(element, cx);
+  const body = compileContent(element, cx, scope);
+  return (xc, out, machine) => {
+    xc.iteration.broken = true;
+    if (body.length > 0) machine.push(new BodyFrame(body, xc, out));
+  };
+}

package/src/xslt/instructions/literal.js

@@ -0,0 +1,142 @@
+/**
+ * Literal result elements (XSLT 3.0 section 11.1): the element is copied
+ * with its namespace nodes (less the XSLT namespace and the excluded
+ * ones, with namespace aliases applied) and its attributes, whose values
+ * are attribute value templates; its content is a sequence constructor.
+ *
+ * @module @tradik/xslt3/xslt/instructions/literal
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { isNamespaceDeclaration } from "../../xpath/eval/domNodes.js";
+import { markConstructed } from "../runtime/baseUri.js";
+import { BodyFrame } from "../runtime/machine.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { XSL_NS, xslAttr, xsltError } from "../names.js";
+import { attributeSetNames, applyAttributeSets } from "./attributeSets.js";
+
+/** Attributes in the XSLT namespace allowed on literal result elements. */
+const LRE_ATTRIBUTES = new Set([
+  "version",
+  "exclude-result-prefixes",
+  "extension-element-prefixes",
+  "xpath-default-namespace",
+  "default-collation",
+  "default-mode",
+  "default-validation",
+  "expand-text",
+  "use-attribute-sets",
+  "use-when",
+  "type",
+  "validation",
+  "inherit-namespaces",
+]);
+
+/**
+ * The result name of a stylesheet name after namespace aliasing.
+ * @param {string} uri
+ * @param {string} prefix
+ * @param {string} local
+ * @param {Map<string, {uri: string, prefix: string}>} aliases
+ * @returns {{uri: string, qname: string}}
+ */
+export function aliasedName(uri, prefix, local, aliases) {
+  const alias = aliases.get(uri);
+  if (!alias) return { uri, qname: prefix ? `${prefix}:${local}` : local };
+  const resultPrefix = alias.uri === "" ? "" : alias.prefix;
+  return {
+    uri: alias.uri,
+    qname: resultPrefix ? `${resultPrefix}:${local}` : local,
+  };
+}
+
+/**
+ * The namespace nodes a literal result element copies.
+ * @param {Element} element
+ * @param {Map<string, object>} aliases
+ * @returns {Array<[string, string]>} prefix, URI pairs
+ */
+function copiedNamespaces(element, aliases) {
+  const info = infoOf(element);
+  const result = [];
+  for (const [prefix, uri] of info.namespaces) {
+    if (prefix === "xml" || uri === XSL_NS) continue;
+    if (aliases.has(uri) || info.excluded.has(uri)) continue;
+    if (uri === "" && prefix !== "") continue;
+    result.push([prefix, uri]);
+  }
+  return result;
+}
+
+/**
+ * Compiles a literal result element.
+ * @param {Element} element
+ * @param {object} cx - Stylesheet compiler
+ * @param {import("../compiler/body.js").Scope} scope
+ * @returns {Function} the step
+ */
+export function compileLiteralElement(element, cx, scope) {
+  const { uri, qname } = aliasedName(
+    element.namespaceURI ?? "",
+    element.prefix ?? "",
+    element.localName,
+    cx.aliases,
+  );
+  const namespaces = copiedNamespaces(element, cx.aliases);
+  const compatible = infoOf(element).version < 2;
+  const attributes = [];
+  const forwards = infoOf(element).version > 3;
+  for (const attribute of element.attributes) {
+    if (isNamespaceDeclaration(attribute)) continue;
+    if (attribute.namespaceURI === XSL_NS) {
+      if (!forwards && !LRE_ATTRIBUTES.has(attribute.localName)) {
+        throw xsltError(
+          "XTSE0805",
+          `Unknown attribute ${attribute.name} on a literal result element`,
+        );
+      }
+      // a non-schema-aware processor (XTSE1660)
+      const local = attribute.localName;
+      if (
+        local === "type" ||
+        (local === "validation" && attribute.value.trim() === "strict")
+      ) {
+        throw xsltError(
+          "XTSE1660",
+          `xsl:${local} needs a schema-aware processor`,
+        );
+      }
+      continue;
+    }
+    const name = aliasedName(
+      attribute.namespaceURI ?? "",
+      attribute.prefix ?? "",
+      attribute.localName,
+      cx.aliases,
+    );
+    const parts = cx.exprs.avt(attribute.value, element, scope.vars);
+    attributes.push({ ...name, value: avtEvaluator(parts, compatible) });
+  }
+  const sets = attributeSetNames(
+    xslAttr(element, "use-attribute-sets"),
+    element,
+    cx,
+  );
+  const body = compileBody(element, cx, scope);
+  // its own xml:base is copied: the base URI it applies to is the parent's
+  const parent = element.parentNode;
+  const base = infoOf(parent?.nodeType === 1 ? parent : element).baseUri;
+  return (xc, out, machine) => {
+    const content = out.element(uri, qname);
+    markConstructed(content, base);
+    for (const [prefix, namespace] of namespaces) {
+      content.declareExplicit(prefix, namespace);
+    }
+    if (sets.length > 0) applyAttributeSets(sets, xc, content, machine, cx);
+    for (const attribute of attributes) {
+      content.attribute(attribute.uri, attribute.qname, attribute.value(xc));
+    }
+    if (body.length > 0) machine.push(new BodyFrame(body, xc, content));
+  };
+}

package/src/xslt/instructions/maps.js

@@ -0,0 +1,72 @@
+/**
+ * xsl:map and xsl:map-entry (XSLT 3.0 section 21.4): maps built from
+ * instructions.
+ *
+ * @module @tradik/xslt3/xslt/instructions/maps
+ */
+
+import { XdmMap } from "../../items/map.js";
+import { isMap } from "../../xdm/atomic.js";
+import { atomize } from "../../xdm/nodes.js";
+import { compileBody } from "../compiler/body.js";
+import { required } from "../compiler/attributes.js";
+import { evaluate } from "../runtime/context.js";
+import { bodySequence } from "../runtime/values.js";
+import { attr, xsltError } from "../names.js";
+
+/**
+ * xsl:map.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileMap(element, cx, scope) {
+  const body = compileBody(element, cx, scope);
+  return (xc, out, machine) => {
+    const pairs = [];
+    for (const item of bodySequence(body, xc, machine)) {
+      if (!isMap(item)) {
+        throw xsltError("XTTE3375", "xsl:map content must be maps");
+      }
+      for (const { key, value } of item.entries.values()) {
+        pairs.push([key, value]);
+      }
+    }
+    out.item(
+      XdmMap.from(pairs, () => {
+        throw xsltError("XTDE3365", "Duplicate key in xsl:map");
+      }),
+    );
+  };
+}
+
+/**
+ * xsl:map-entry.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileMapEntry(element, cx, scope) {
+  const key = cx.exprs.xpath(required(element, "key"), element, scope.vars);
+  const select = attr(element, "select");
+  const body = compileBody(element, cx, scope);
+  if (select !== undefined && body.length > 0) {
+    throw xsltError("XTSE3280", "xsl:map-entry has select and content");
+  }
+  const value =
+    select === undefined
+      ? (xc, machine) => bodySequence(body, xc, machine)
+      : (
+          (expr) => (xc) =>
+            evaluate(expr, xc)
+        )(cx.exprs.xpath(select, element, scope.vars));
+  return (xc, out, machine) => {
+    const keys = atomize(evaluate(key, xc));
+    if (keys.length !== 1) {
+      throw xsltError("XPTY0004", "A map key must be a single atomic value");
+    }
+    out.item(XdmMap.from([[keys[0], value(xc, machine)]]));
+  };
+}