@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/instructions/merge.js

@@ -0,0 +1,190 @@
+/**
+ * xsl:merge, xsl:merge-source, xsl:merge-key and xsl:merge-action
+ * (XSLT 3.0 section 15): the static checks and the compiled sources; the
+ * merging itself is in runtime/merging.js.
+ *
+ * @module @tradik/xslt3/xslt/instructions/merge
+ */
+
+import { atomize, stringValue } from "../../xdm/nodes.js";
+import { types } from "../../xdm/types.js";
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { useAccumulators } from "../compiler/useAccumulators.js";
+import { checkAttributes, required, yesNo } from "../compiler/attributes.js";
+import { compileBody } from "../compiler/body.js";
+import { setApplicable } from "../runtime/accumulators.js";
+import {
+  derive,
+  dynamicContextOf,
+  evaluate,
+  withFocus,
+} from "../runtime/context.js";
+import { BodyFrame, LoopFrame } from "../runtime/machine.js";
+import { mergeGroups } from "../runtime/merging.js";
+import { attr, isNCName, isXsl, xsltError } from "../names.js";
+import { compileSortKey } from "./sort.js";
+import { checkNoValidation } from "./sourceDocument.js";
+
+/** Types a URI of for-each-source may have. */
+const URI_TYPES = new Set([types.string, types.anyURI, types.untypedAtomic]);
+
+/**
+ * Compiles an xsl:merge-key.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {object} the key, compiled as an xsl:sort
+ */
+function compileMergeKey(element, cx, scope) {
+  if (!isXsl(element, "merge-key")) {
+    throw xsltError("XTSE0010", "xsl:merge-source contains xsl:merge-key");
+  }
+  if (attr(element, "select") !== undefined && cx.children(element).length) {
+    throw xsltError("XTSE3200", "xsl:merge-key has select and content");
+  }
+  return compileSortKey(element, cx, scope);
+}
+
+/**
+ * The URIs of for-each-source as strings.
+ * @param {Array} items
+ * @returns {string[]}
+ */
+function uriStrings(items) {
+  return atomize(items).map((value) => {
+    if (!URI_TYPES.has(value.type)) {
+      throw xsltError("XPTY0004", "for-each-source must give URIs");
+    }
+    return stringValue(value);
+  });
+}
+
+/**
+ * Compiles an xsl:merge-source.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @param {number} index - Position among the sources
+ * @returns {object} `{name, keys, sortBeforeMerge, inputs(xc, machine)}`
+ */
+function compileMergeSource(element, cx, scope, index) {
+  checkAttributes(element);
+  const has = (name) => attr(element, name) !== undefined;
+  const forEachSource = has("for-each-source");
+  if (
+    (has("for-each-item") &&
+      (forEachSource || has("use-accumulators") || has("streamable"))) ||
+    (has("use-accumulators") && !forEachSource)
+  ) {
+    throw xsltError("XTSE3195", "Conflicting attributes on xsl:merge-source");
+  }
+  if (!forEachSource && (has("validation") || has("type"))) {
+    throw xsltError("XTSE0010", "validation and type need for-each-source");
+  }
+  if (has("validation") && has("type")) {
+    throw xsltError("XTSE1505", "validation and type are exclusive");
+  }
+  checkNoValidation(element);
+  yesNo(element, "streamable", false);
+  const name = attr(element, "name")?.trim();
+  if (name !== undefined && !isNCName(name)) {
+    throw xsltError("XTSE0020", `Invalid merge source name ${name}`);
+  }
+  const xpath = (text) => cx.exprs.xpath(text, element, scope.vars);
+  const select = xpath(required(element, "select"));
+  const itemExpr = has("for-each-item")
+    ? xpath(attr(element, "for-each-item"))
+    : null;
+  const sourceExpr = forEachSource
+    ? xpath(attr(element, "for-each-source"))
+    : null;
+  const accumulators = useAccumulators(
+    attr(element, "use-accumulators") ?? "",
+    element,
+    cx,
+  );
+  const base = cx.baseUriOf(element);
+  const keys = cx
+    .children(element)
+    .map((child) => compileMergeKey(child, cx, scope));
+  if (keys.length === 0) {
+    throw xsltError("XTSE0010", "xsl:merge-source needs xsl:merge-key");
+  }
+  const documents = (xc) =>
+    uriStrings(evaluate(sourceExpr, xc)).map((uri) => {
+      const document = dynamicContextOf(xc).loadDocument(resolveUri(uri, base));
+      setApplicable(xc.tx, document, accumulators);
+      return document;
+    });
+  return {
+    name: name ?? `#${index}`,
+    named: name !== undefined,
+    keys,
+    sortBeforeMerge: yesNo(element, "sort-before-merge", false),
+    inputs(xc) {
+      let anchors = null;
+      if (itemExpr) anchors = evaluate(itemExpr, xc);
+      else if (sourceExpr) anchors = documents(xc);
+      if (!anchors) return [evaluate(select, xc)];
+      return anchors.map((anchor, i) =>
+        evaluate(select, withFocus(xc, anchor, i + 1, anchors.length)),
+      );
+    },
+  };
+}
+
+/**
+ * xsl:merge.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileMerge(element, cx, scope) {
+  const children = cx.children(element);
+  while (children.length > 0 && isXsl(children.at(-1), "fallback")) {
+    children.pop();
+  }
+  const action = children.at(-1);
+  const sourceElements = children.slice(0, -1);
+  if (
+    !action ||
+    !isXsl(action, "merge-action") ||
+    sourceElements.length === 0 ||
+    !sourceElements.every((child) => isXsl(child, "merge-source"))
+  ) {
+    throw xsltError(
+      "XTSE0010",
+      "xsl:merge contains xsl:merge-source elements then xsl:merge-action",
+    );
+  }
+  const sources = sourceElements.map((child, i) =>
+    compileMergeSource(child, cx, scope, i),
+  );
+  const names = sources.filter((s) => s.named).map((s) => s.name);
+  if (new Set(names).size !== names.length) {
+    throw xsltError("XTSE3190", "Two merge sources have the same name");
+  }
+  if (sources.some((source) => source.keys.length !== sources[0].keys.length)) {
+    throw xsltError("XTSE2200", "The merge sources have different key counts");
+  }
+  checkAttributes(action);
+  const body = compileBody(action, cx, scope);
+  return (xc, out, machine) => {
+    const groups = mergeGroups(sources, xc, machine);
+    const size = groups.length;
+    if (size === 0 || body.length === 0) return;
+    machine.push(
+      new LoopFrame(size, (i) => {
+        const group = groups[i];
+        const context = derive(
+          withFocus(xc, group.entries[0].item, i + 1, size),
+          {
+            merge: { group, names },
+          },
+        );
+        machine.push(new BodyFrame(body, context, out));
+      }),
+    );
+  };
+}

package/src/xslt/instructions/number.js

@@ -0,0 +1,205 @@
+/**
+ * xsl:number (XSLT 3.0 section 12): numbers from the value attribute or
+ * the position of a node, formatted with a format string of
+ * alphanumeric tokens and separators.
+ *
+ * @module @tradik/xslt3/xslt/instructions/number
+ */
+
+import { isNode } from "../../xdm/atomic.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { toNumber } from "../../xdm/generalCompare.js";
+import { atomize } from "../../xdm/nodes.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { evaluate } from "../runtime/context.js";
+import {
+  countKey,
+  numberAny,
+  numberHierarchy,
+  numberMemo,
+  sameKindAndName,
+} from "../runtime/numbering.js";
+import { formatNumbers } from "../runtime/numberFormat.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, xsltError } from "../names.js";
+import { compilePattern, patternMatches } from "../patterns/compile.js";
+
+/**
+ * Converts the value attribute's result to integers.
+ * @param {Array} values
+ * @param {boolean} compatible
+ * @returns {bigint[]|string} integers, or a string for invalid numbers
+ *   in backwards-compatible mode
+ */
+function integersOf(values, compatible) {
+  const result = [];
+  const items = atomize(values);
+  // XSLT 1.0 behaviour: number(()) is NaN
+  if (compatible && items.length === 0) return "NaN";
+  // XSLT 1.0 behaviour: the first item only
+  for (const value of compatible ? items.slice(0, 1) : items) {
+    if (typeof value.value === "bigint" && value.value >= 0n) {
+      result.push(value.value);
+      continue;
+    }
+    const n = toNumber(value).value;
+    if (!Number.isFinite(n) || n < -0.5) {
+      if (compatible) return canonicalString(toNumber(value));
+      throw xsltError("XTDE0980", `Cannot number ${canonicalString(value)}`);
+    }
+    result.push(BigInt(Math.round(n)));
+  }
+  return result;
+}
+
+/**
+ * Checks a lang value: a language tag (xs:language).
+ * @param {string} text
+ * @param {string} code - XTSE0020 when static, XTDE0030 when evaluated
+ */
+function checkLanguage(text, code) {
+  if (!/^\s*[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*\s*$/.test(text)) {
+    throw xsltError(code, `Invalid lang "${text}"`);
+  }
+}
+
+/**
+ * Re-bases the numbers by the start-at attribute (XSLT 3.0 section 12.1).
+ * @param {bigint[]} numbers
+ * @param {string} text - Effective value of start-at
+ * @returns {bigint[]}
+ * @throws {import("../../errors.js").XPathError} XTDE0030 for a value
+ *   that is not a list of integers
+ */
+function rebase(numbers, text) {
+  if (!/^\s*-?\d+(\s+-?\d+)*\s*$/.test(text)) {
+    throw xsltError("XTDE0030", `Invalid start-at "${text}"`);
+  }
+  const starts = text.trim().split(/\s+/).map(BigInt);
+  return numbers.map(
+    (number, i) => number + starts[Math.min(i, starts.length - 1)] - 1n,
+  );
+}
+
+/**
+ * Compiles an optional pattern attribute.
+ * @returns {object|null}
+ */
+function optionalPattern(element, name, cx, scope) {
+  const text = attr(element, name);
+  return text === undefined
+    ? null
+    : compilePattern(text, element, cx, scope.vars);
+}
+
+/**
+ * Whether the numbers an instruction gives may be memoized: its count
+ * and from patterns must not read variables (local ones differ between
+ * invocations) or the dynamic context of the instruction.
+ * @param {Element} element
+ * @returns {boolean}
+ */
+function isMemoizable(element) {
+  const text = `${attr(element, "count") ?? ""} ${attr(element, "from") ?? ""}`;
+  return !/\$|current-|regex-group/.test(text);
+}
+
+/**
+ * xsl:number.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileNumber(element, cx, scope) {
+  const expr = (name) => {
+    const text = attr(element, name);
+    return text === undefined
+      ? null
+      : cx.exprs.xpath(text, element, scope.vars);
+  };
+  const avt = (name, fallback) => {
+    const text = attr(element, name);
+    return text === undefined
+      ? () => fallback
+      : avtEvaluator(cx.exprs.avt(text, element, scope.vars));
+  };
+  const value = expr("value");
+  const select = expr("select");
+  const level = attr(element, "level")?.trim() ?? "single";
+  if (!["single", "multiple", "any"].includes(level)) {
+    throw xsltError("XTSE0020", `Invalid level ${level}`);
+  }
+  const count = optionalPattern(element, "count", cx, scope);
+  const from = optionalPattern(element, "from", cx, scope);
+  if (value && (select || count || from || attr(element, "level"))) {
+    throw xsltError(
+      "XTSE0975",
+      "xsl:number value excludes select, level, count, from",
+    );
+  }
+  const format = avt("format", "1");
+  const ordinal = avt("ordinal", "");
+  const separator = avt("grouping-separator", "");
+  const size = avt("grouping-size", "");
+  const compatible = infoOf(element).version < 2;
+  const startAt =
+    attr(element, "start-at") === undefined ? null : avt("start-at");
+  const langText = attr(element, "lang");
+  if (langText !== undefined && !langText.includes("{")) {
+    checkLanguage(langText, "XTSE0020");
+  }
+  const lang = langText === undefined ? null : avt("lang");
+  // identity of the instruction for the memos of each transformation
+  const instruction = {};
+  const memoizable = isMemoizable(element);
+  return (xc, out) => {
+    let numbers;
+    if (value) {
+      numbers = integersOf(evaluate(value, xc), compatible);
+      if (typeof numbers === "string") {
+        out.text(numbers);
+        return;
+      }
+    } else {
+      const nodes = select ? evaluate(select, xc) : [xc.item];
+      if (nodes.length !== 1 || !isNode(nodes[0])) {
+        throw xsltError(
+          select ? "XTTE1000" : "XTTE0990",
+          "xsl:number needs one node to number",
+        );
+      }
+      const node = nodes[0];
+      const countTest = count
+        ? (n) => patternMatches(count, n, xc)
+        : sameKindAndName(node);
+      const fromTest = from ? (n) => patternMatches(from, n, xc) : null;
+      const memo = memoizable
+        ? numberMemo(xc.tx, instruction, count ? "" : countKey(node))
+        : null;
+      const places =
+        level === "any"
+          ? numberAny(node, countTest, fromTest, memo)
+          : numberHierarchy(
+              node,
+              countTest,
+              fromTest,
+              level === "multiple",
+              memo,
+            );
+      numbers = places.map(BigInt);
+    }
+    if (startAt) numbers = rebase(numbers, startAt(xc));
+    const language = lang ? lang(xc) : null;
+    if (language !== null) checkLanguage(language, "XTDE0030");
+    const ordinalText = ordinal(xc).trim();
+    out.text(
+      formatNumbers(numbers, format(xc), {
+        ordinal: ordinalText !== "" && ordinalText !== "no" && ordinalText,
+        lang: language,
+        separator: separator(xc),
+        size: Number(size(xc)),
+      }),
+    );
+  };
+}

package/src/xslt/instructions/output.js

@@ -0,0 +1,102 @@
+/**
+ * xsl:message (XSLT 3.0 section 22.1): messages collected as documents,
+ * optionally terminating the transformation.
+ *
+ * @module @tradik/xslt3/xslt/instructions/output
+ */
+
+import { stringItem } from "../../xpath/eval/atomics.js";
+import { compileBody } from "../compiler/body.js";
+import { evaluate } from "../runtime/context.js";
+import { TreeReceiver } from "../runtime/treeReceiver.js";
+import { avtEvaluator, bodySequence } from "../runtime/values.js";
+import { attr, isNCName, isXsl, xsltError } from "../names.js";
+
+/** Values of yes/no attributes: the "yes" ones first. */
+const YES_NO = ["yes", "true", "1", "no", "false", "0"];
+
+/**
+ * Builds a document node holding items.
+ * @param {Array} items
+ * @param {object} xc
+ * @returns {Node} a document fragment
+ */
+function buildDocument(items, xc) {
+  const fragment = xc.tx.scratch().createDocumentFragment();
+  const out = new TreeReceiver(fragment, new Map());
+  for (const item of items) out.item(item);
+  return fragment;
+}
+
+/**
+ * xsl:message.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileMessage(element, cx, scope) {
+  const selectText = attr(element, "select");
+  const select =
+    selectText === undefined
+      ? null
+      : cx.exprs.xpath(selectText, element, scope.vars);
+  const body = compileBody(
+    element,
+    cx,
+    scope,
+    cx.children(element).filter((child) => !isXsl(child, "fallback")),
+  );
+  const terminateText = attr(element, "terminate");
+  if (
+    terminateText !== undefined &&
+    !terminateText.includes("{") &&
+    !YES_NO.includes(terminateText.trim())
+  ) {
+    throw xsltError("XTSE0020", `Invalid terminate value ${terminateText}`);
+  }
+  const terminate = terminateText
+    ? avtEvaluator(cx.exprs.avt(terminateText, element, scope.vars))
+    : () => "no";
+  const codeText = attr(element, "error-code");
+  const errorCode = codeText
+    ? avtEvaluator(cx.exprs.avt(codeText, element, scope.vars))
+    : () => "XTMM9000";
+  return (xc, out, machine) => {
+    let items;
+    try {
+      items = [
+        ...(select ? evaluate(select, xc) : []),
+        ...bodySequence(body, xc, machine, false),
+      ];
+    } catch (error) {
+      if (typeof error?.code !== "string") throw error;
+      // XSLT 3.0 section 23.1: an error in the content of a message is
+      // reported in the message, not by failing the transformation
+      items = [stringItem(`Error in xsl:message: ${error.message}`)];
+    }
+    let message;
+    try {
+      message = buildDocument(items, xc);
+    } catch {
+      // XSLT 3.0: a message that cannot be a document does not fail
+      message = items;
+    }
+    xc.tx.messages.push(message);
+    xc.tx.onMessage?.(message);
+    const value = terminate(xc).trim();
+    if (!YES_NO.includes(value)) {
+      throw xsltError("XTDE0030", `Invalid terminate value ${value}`);
+    }
+    if (YES_NO.indexOf(value) < 3) {
+      const code = errorCode(xc).trim();
+      const local = code.replace(/^Q\{[^}]*\}/, "").replace(/^[^:]*:/, "");
+      const error = xsltError(
+        isNCName(local) ? local : "XTMM9000",
+        "Terminated by xsl:message",
+      );
+      error.value = message;
+      throw error;
+    }
+  };
+}

package/src/xslt/instructions/params.js

@@ -0,0 +1,110 @@
+/**
+ * Parameters (XSLT 3.0 sections 9.2 and 10.1.1): the xsl:param
+ * declarations of templates and functions, and the xsl:with-param
+ * children of invocations.
+ *
+ * @module @tradik/xslt3/xslt/instructions/params
+ */
+
+import { checkAttributes, yesNo } from "../compiler/attributes.js";
+import { displayName, isXsl, xsltError } from "../names.js";
+import { compileValue, typeConverter, variableName } from "./variables.js";
+
+/**
+ * Compiles the xsl:with-param children of an instruction.
+ * @param {Node[]} children
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {{names: Set<string>,
+ *   evaluate: (xc: object, machine: object) => import("../runtime/apply.js").Args}}
+ */
+export function compileWithParams(children, cx, scope) {
+  const compiled = [];
+  for (const child of children) {
+    if (!isXsl(child, "with-param")) continue;
+    checkAttributes(child);
+    const key = variableName(child, cx);
+    if (compiled.some((param) => param.key === key)) {
+      throw xsltError("XTSE0670", `Duplicate parameter ${key}`);
+    }
+    const { value } = compileValue(child, cx, scope, "XTTE0570");
+    compiled.push({ key, value, tunnel: yesNo(child, "tunnel", false) });
+  }
+  return {
+    names: new Set(compiled.filter((p) => !p.tunnel).map((p) => p.key)),
+    evaluate(xc, machine) {
+      const params = new Map();
+      const tunnel = new Map();
+      for (const param of compiled) {
+        const target = param.tunnel ? tunnel : params;
+        target.set(param.key, param.value(xc, machine));
+      }
+      return { params, tunnel };
+    },
+  };
+}
+
+/**
+ * The default value of a parameter with a type and no default: the
+ * empty sequence, or XTDE0610 when the type does not allow it.
+ * @param {object} compiled - See variables.compileValue
+ * @param {string} key
+ * @returns {(xc: object, machine: object) => Array}
+ */
+function implicitDefault(compiled, key) {
+  return (xc, machine) => {
+    try {
+      return compiled.value(xc, machine);
+    } catch (error) {
+      throw error.code === "XTTE0590"
+        ? xsltError("XTDE0610", `No value for the parameter ${key}`)
+        : error;
+    }
+  };
+}
+
+/**
+ * The parameters of a template or function, compiled in order (each
+ * default value sees the parameters before it).
+ * @param {Element[]} elements - The xsl:param children
+ * @param {object} cx
+ * @param {object} scope
+ * @param {boolean} [isFunction]
+ * @returns {{params: object[], scope: object}}
+ */
+export function compileParams(elements, cx, scope, isFunction = false) {
+  const params = [];
+  let current = scope;
+  for (const element of elements) {
+    checkAttributes(element);
+    const key = variableName(element, cx);
+    if (params.some((param) => param.key === key)) {
+      throw xsltError("XTSE0580", `Duplicate parameter ${key}`);
+    }
+    const compiled = compileValue(element, cx, current, "XTTE0590");
+    if (isFunction && compiled.hasDefault) {
+      throw xsltError("XTSE0760", "A function parameter cannot have a default");
+    }
+    const required = isFunction || yesNo(element, "required", false);
+    if (!isFunction && required && compiled.hasDefault) {
+      throw xsltError("XTSE0010", "A required parameter cannot have a default");
+    }
+    params.push({
+      key,
+      required,
+      tunnel: yesNo(element, "tunnel", false),
+      value:
+        compiled.hasDefault || !compiled.type
+          ? compiled.value
+          : implicitDefault(compiled, key),
+      type: compiled.type,
+      convert: typeConverter(
+        compiled.type,
+        "XTTE0590",
+        `parameter $${displayName(key)}`,
+      ),
+    });
+    current = { ...current, vars: { key, next: current.vars } };
+  }
+  return { params, scope: current };
+}