@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/patterns/paths.js

@@ -0,0 +1,130 @@
+/**
+ * Path patterns: the steps checked against the pattern grammar, then
+ * matched from the last step upwards: the last step is tested on the
+ * node, each `/` moves to the parent and each `//` to some ancestor,
+ * until the first step; an absolute pattern requires a document node
+ * above it.
+ *
+ * @module @tradik/xslt3/xslt/patterns/paths
+ */
+
+import { parentOf } from "../../xpath/eval/domNodes.js";
+import { compileGeneralPath } from "./general.js";
+import { compileStep, stepPriority, stepKey } from "./steps.js";
+
+/** Functions allowed as the first step of a path pattern. */
+const ROOT_FUNCTIONS = new Set(["id", "key", "doc", "element-with-id", "root"]);
+
+/** @param {*} node @returns {boolean} whether a node is a document node */
+const isDocument = (node) => node?.nodeType === 9 || node?.nodeType === 11;
+
+/**
+ * Whether a step stands for `//` (descendant-or-self::node()).
+ * @param {object} step
+ * @returns {boolean}
+ */
+const isSlashSlash = (step) =>
+  step.type === "AxisStep" &&
+  step.axis === "descendant-or-self" &&
+  step.nodeTest.type === "AnyKindTest" &&
+  step.predicates.length === 0;
+
+/** Axes the fast matcher follows upwards (self:: only alone). */
+const FAST_AXES = new Set(["child", "attribute", "namespace"]);
+
+/**
+ * Whether the fast matcher handles a step: an axis step on a fast axis,
+ * `//`, or an unfiltered rooted first step (key(), id(), doc(), $var...).
+ * @param {object} step
+ * @param {boolean} first
+ * @param {boolean} alone - The step is the whole pattern
+ * @returns {boolean}
+ */
+function isFastStep(step, first, alone) {
+  if (step.type === "AxisStep") {
+    return (
+      FAST_AXES.has(step.axis) ||
+      isSlashSlash(step) ||
+      (alone && step.axis === "self")
+    );
+  }
+  return (
+    first &&
+    ((step.type === "FunctionCall" && ROOT_FUNCTIONS.has(step.name.local)) ||
+      step.type === "VarRef")
+  );
+}
+
+/**
+ * Builds the matcher of the parts of a path pattern.
+ * @param {Array<{separator: string|null, test: {test: Function}}>} parts -
+ *   Steps in order; `separator` is what precedes the step ("/", "//", or
+ *   null for the first step of a relative pattern)
+ * @returns {(item: *, xc: object) => boolean}
+ */
+export function matchParts(parts) {
+  const last = parts.length - 1;
+  const matchFrom = (node, k, xc) => {
+    if (!parts[k].test.test(node, xc)) return false;
+    const { separator } = parts[k];
+    if (k === 0) {
+      if (separator === null) return true;
+      if (separator === "/") return isDocument(parentOf(node));
+      for (let a = parentOf(node); a; a = parentOf(a)) {
+        if (isDocument(a)) return true;
+      }
+      return false;
+    }
+    if (separator === "/") {
+      const parent = parentOf(node);
+      return parent !== null && matchFrom(parent, k - 1, xc);
+    }
+    for (let a = parentOf(node); a; a = parentOf(a)) {
+      if (matchFrom(a, k - 1, xc)) return true;
+    }
+    return false;
+  };
+  return (item, xc) =>
+    typeof item?.nodeType === "number" && matchFrom(item, last, xc);
+}
+
+/**
+ * Compiles a path pattern (a PathExpr, or a single step).
+ * @param {object} ast
+ * @param {object} env - See compile.js
+ * @returns {import("./compile.js").PatternAlternative}
+ */
+export function compilePathPattern(ast, env) {
+  const absolute = ast.type === "PathExpr" && ast.absolute;
+  const steps = ast.type === "PathExpr" ? ast.steps : [ast];
+  if (absolute && steps.length === 0) {
+    return { matches: (item) => isDocument(item), priority: -0.5, key: "k9" };
+  }
+  const last = steps.at(-1);
+  const single = steps.length === 1 && !absolute;
+  const fast = steps.every((step, i) =>
+    isFastStep(step, i === 0 && !absolute, single),
+  );
+  if (!fast) {
+    return {
+      matches: compileGeneralPath(ast, env),
+      priority: single ? stepPriority(last) : 0.5,
+      key: last.type === "AxisStep" ? stepKey(last, env.sc) : "*",
+    };
+  }
+  const parts = [];
+  let separator = absolute ? "/" : null;
+  for (const step of steps) {
+    if (isSlashSlash(step)) {
+      separator = "//";
+      continue;
+    }
+    parts.push({ separator, test: compileStep(step, env) });
+    separator = "/";
+  }
+  return {
+    matches: matchParts(parts),
+    priority: single ? stepPriority(last) : 0.5,
+    key: last.type === "AxisStep" ? parts.at(-1).test.key : "*",
+  };
+}

package/src/xslt/patterns/patternChecks.js

@@ -0,0 +1,29 @@
+/**
+ * The grouping functions patterns cannot call (XTSE1060, XTSE1070).
+ *
+ * @module @tradik/xslt3/xslt/patterns/patternChecks
+ */
+
+import { xsltError } from "../names.js";
+
+/** Functions a pattern cannot call (XTSE1060, XTSE1070). */
+const GROUPING_CALLS = {
+  "current-group": "XTSE1060",
+  "current-grouping-key": "XTSE1070",
+};
+
+/**
+ * Checks that a pattern does not call current-group() or
+ * current-grouping-key().
+ * @param {object} ast
+ */
+export function checkGroupingCalls(ast) {
+  if (ast === null || typeof ast !== "object") return;
+  if (ast.type === "FunctionCall" && !ast.name.prefix && !ast.name.uri) {
+    const code = GROUPING_CALLS[ast.name.local];
+    if (code) {
+      throw xsltError(code, `A pattern cannot call ${ast.name.local}()`);
+    }
+  }
+  for (const value of Object.values(ast)) checkGroupingCalls(value);
+}

package/src/xslt/patterns/steps.js

@@ -0,0 +1,162 @@
+/**
+ * The steps of path patterns: axis steps tested on a node (with their
+ * predicates evaluated among the node's siblings when they depend on the
+ * position), and the rooted steps key(), id(), doc(), $var, tested by
+ * membership. Also the default priorities of single-step patterns.
+ *
+ * @module @tradik/xslt3/xslt/patterns/steps
+ */
+
+import { compileNode } from "../../xpath/eval/compiler.js";
+import {
+  attributesOf,
+  childrenOf,
+  parentOf,
+} from "../../xpath/eval/domNodes.js";
+import { compileNodeTest } from "../../xpath/eval/nodeTests.js";
+import { isPositionIndependent } from "../../xpath/eval/positional.js";
+import { compilePredicate } from "../../xpath/eval/predicates.js";
+import { namespaceOf } from "../../xpath/eval/staticContext.js";
+
+/** Node kinds an axis step can match, by axis. */
+const AXIS_KINDS = {
+  child: (node) => [1, 3, 4, 7, 8].includes(node?.nodeType),
+  attribute: (node) => node?.nodeType === 2,
+  namespace: (node) => node?.nodeType === 13,
+  self: (node) => typeof node?.nodeType === "number",
+};
+
+/** Index keys of kind tests. */
+const KIND_KEYS = {
+  TextTest: "k3",
+  CommentTest: "k8",
+  PITest: "k7",
+  DocumentTest: "k9",
+  NamespaceNodeTest: "k13",
+};
+
+/**
+ * The index key of an axis step.
+ * @param {object} step
+ * @param {object} sc
+ * @returns {string}
+ */
+export function stepKey(step, sc) {
+  const { nodeTest, axis } = step;
+  const attribute = axis === "attribute";
+  if (axis === "self") return "*";
+  if (axis === "namespace") return "k13";
+  if (nodeTest.type === "NameTest") {
+    const defaultNs = attribute ? "" : sc.defaultElementNamespace;
+    const uri = namespaceOf(nodeTest.name, sc, defaultNs);
+    return `${attribute ? "a" : "e"}{${uri}}${nodeTest.name.local}`;
+  }
+  if (nodeTest.type === "Wildcard") return attribute ? "k2" : "k1";
+  if (nodeTest.type === "ElementTest") return "k1";
+  if (nodeTest.type === "AttributeTest") return "k2";
+  return KIND_KEYS[nodeTest.type] ?? "*";
+}
+
+/**
+ * Compiles an axis step of a pattern.
+ * @param {object} step
+ * @param {object} env - `{cx, sc, vars}`
+ * @returns {{key: string, test: (node: *, xc: object) => boolean}}
+ */
+function compileAxisStep(step, env) {
+  // document-node() as a step without axis matches document nodes
+  const documentStep =
+    step.axis === "child" &&
+    step.nodeTest.type === "DocumentTest" &&
+    !env.text.startsWith("child::", step.start);
+
+  // the axis is child, attribute, namespace or (alone) self: see paths.js
+  const kindOk = documentStep ? AXIS_KINDS.self : AXIS_KINDS[step.axis];
+  const nodeTest = compileNodeTest(step.nodeTest, step.axis, env.sc);
+  const accepts = (node) => kindOk(node) && nodeTest(node);
+  const scope = { sc: env.sc, vars: env.vars };
+  const predicates = step.predicates.map((p) =>
+    compilePredicate(p, scope, compileNode),
+  );
+  const key = stepKey(step, env.sc);
+  if (predicates.length === 0) return { key, test: accepts };
+  const independent = step.predicates.every((p) =>
+    isPositionIndependent(p, env.sc),
+  );
+  const attribute = step.axis === "attribute";
+  return {
+    key,
+    test(node, xc) {
+      if (!accepts(node)) return false;
+      const ctx = env.cx.patternContext(node, xc, env.local);
+      if (independent) {
+        return predicates.every((predicate) => predicate([node], ctx).length);
+      }
+      const parent = parentOf(node);
+      let candidates = parent
+        ? (attribute ? attributesOf(parent) : childrenOf(parent)).filter(
+            accepts,
+          )
+        : [node];
+      for (const predicate of predicates) {
+        candidates = predicate(candidates, ctx);
+      }
+      return candidates.includes(node);
+    },
+  };
+}
+
+/**
+ * Compiles a step of a pattern.
+ * @param {object} step - AxisStep, or a FunctionCall/VarRef first step
+ * @param {object} env - `{cx, sc, vars}`
+ * @returns {{key: string, test: (node: *, xc: object) => boolean}}
+ */
+export function compileStep(step, env) {
+  if (step.type === "AxisStep") return compileAxisStep(step, env);
+  const run = env.cx.exprs.compileAst(step, env.sc, env.vars);
+  return {
+    key: "*",
+    test: (node, xc) =>
+      typeof node?.nodeType === "number" &&
+      run(env.cx.patternContext(node, xc, env.local)).includes(node),
+  };
+}
+
+/** Default priorities of kind tests without a name. */
+const KIND_PRIORITY = {
+  AnyKindTest: -0.5,
+  TextTest: -0.5,
+  CommentTest: -0.5,
+  NamespaceNodeTest: -0.5,
+};
+
+/**
+ * The default priority of a pattern made of one step.
+ * @param {object} step
+ * @returns {number}
+ */
+export function stepPriority(step) {
+  if (step.type !== "AxisStep" || step.predicates.length > 0) return 0.5;
+  const test = step.nodeTest;
+  switch (test.type) {
+    case "NameTest":
+      return 0;
+    case "Wildcard":
+      return test.prefix !== null || test.local !== null || test.uri !== null
+        ? -0.25
+        : -0.5;
+    case "PITest":
+      return test.target === null ? -0.5 : 0;
+    case "ElementTest":
+    case "AttributeTest":
+      if (test.name === null && test.typeName === null) return -0.5;
+      return test.name !== null && test.typeName !== null ? 0.25 : 0;
+    case "DocumentTest":
+      return test.elementTest === null
+        ? -0.5
+        : stepPriority({ ...step, nodeTest: test.elementTest });
+    default:
+      return KIND_PRIORITY[test.type] ?? 0;
+  }
+}

package/src/xslt/processor.js

@@ -0,0 +1,178 @@
+/**
+ * XSLTProcessor: the W3C/browser-style API over compileStylesheet, with
+ * the method names of the @tradik/xslt-processor (XSLT 1.0) package.
+ *
+ * @module @tradik/xslt3/xslt/processor
+ */
+
+import { serialize } from "../serialize/index.js";
+import { compileStylesheet } from "./api.js";
+
+/**
+ * @param {string|null} namespaceURI
+ * @param {string} localName
+ * @returns {string} Clark name
+ */
+const keyOf = (namespaceURI, localName) =>
+  `{${namespaceURI ?? ""}}${localName}`;
+
+/**
+ * A loader of the 1.0 package's API, which may return XML text, as a
+ * loader of documents.
+ * @param {Function} loader - `(uri, base) => Document|string|null`
+ * @param {(text: string, uri?: string) => Document} [parseXml]
+ * @returns {(uri: string, base?: string) => Document|null}
+ */
+function documentsFrom(loader, parseXml) {
+  return (uri, base) => {
+    const result = loader(uri, base);
+    if (typeof result !== "string") return result;
+    if (parseXml) return parseXml(result, uri);
+    return new globalThis.DOMParser().parseFromString(
+      result,
+      "application/xml",
+    );
+  };
+}
+
+/**
+ * Checks a loader given to a setter.
+ * @param {*} loader
+ * @param {string} method - Name of the setter, for the message
+ * @throws {TypeError} when it is neither a function nor null
+ */
+function checkLoader(loader, method) {
+  if (loader != null && typeof loader !== "function") {
+    throw new TypeError(`${method}: the loader must be a function or null`);
+  }
+}
+
+/** Applies an XSLT 3.0/2.0 stylesheet to documents. */
+export class XSLTProcessor {
+  /**
+   * @param {object} [options] - Options of compileStylesheet and
+   *   CompiledStylesheet.transform used for every transformation
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this.stylesheet = null;
+    /** @type {Map<string, *>} */
+    this.parameters = new Map();
+  }
+
+  /**
+   * Compiles a stylesheet.
+   * @param {Document|Element|string} style
+   */
+  importStylesheet(style) {
+    this.stylesheet = compileStylesheet(style, this.options);
+  }
+
+  /**
+   * Runs the imported stylesheet.
+   * @param {Node} source
+   * @returns {object} the transformation result
+   */
+  run(source) {
+    if (!this.stylesheet) throw new Error("No stylesheet imported");
+    return this.stylesheet.transform({
+      ...this.options,
+      source,
+      params: this.parameters,
+    });
+  }
+
+  /**
+   * @param {Node} source
+   * @returns {Document|DocumentFragment} the principal result
+   */
+  transformToDocument(source) {
+    return this.run(source).principal;
+  }
+
+  /**
+   * @param {Node} source
+   * @returns {string} the principal result serialized with its output
+   *   parameters (xsl:output, or the xsl:result-document that wrote it)
+   */
+  transformToString(source) {
+    const { principal, output } = this.run(source);
+    return serialize([principal].flat(), output);
+  }
+
+  /**
+   * Sets the loader of included and imported modules, used by the next
+   * importStylesheet().
+   * @param {((uri: string, base?: string) => Document|string)|null} loader
+   * @returns {XSLTProcessor} this
+   */
+  setStylesheetLoader(loader) {
+    checkLoader(loader, "setStylesheetLoader");
+    this.options = { ...this.options, loadStylesheet: loader ?? undefined };
+    return this;
+  }
+
+  /**
+   * Sets the loader of doc() and document(); it may return XML text.
+   * @param {((uri: string, base?: string) => Document|string|null)|null} loader
+   * @returns {XSLTProcessor} this
+   */
+  setDocumentLoader(loader) {
+    checkLoader(loader, "setDocumentLoader");
+    const documentLoader =
+      loader == null ? undefined : documentsFrom(loader, this.options.parseXml);
+    this.options = { ...this.options, documentLoader };
+    return this;
+  }
+
+  /**
+   * @param {Node} source
+   * @param {Document} output - Document that owns the fragment
+   * @returns {DocumentFragment} the principal result as a fragment
+   */
+  transformToFragment(source, output) {
+    const { principal } = this.run(source);
+    const fragment = output.createDocumentFragment();
+    for (const child of principal.childNodes) {
+      fragment.appendChild(output.importNode(child, true));
+    }
+    return fragment;
+  }
+
+  /**
+   * @param {string|null} namespaceURI
+   * @param {string} localName
+   * @param {*} value
+   */
+  setParameter(namespaceURI, localName, value) {
+    this.parameters.set(keyOf(namespaceURI, localName), value);
+  }
+
+  /**
+   * @param {string|null} namespaceURI
+   * @param {string} localName
+   * @returns {*} the value, "" when not set (as in browsers)
+   */
+  getParameter(namespaceURI, localName) {
+    return this.parameters.get(keyOf(namespaceURI, localName)) ?? "";
+  }
+
+  /**
+   * @param {string|null} namespaceURI
+   * @param {string} localName
+   */
+  removeParameter(namespaceURI, localName) {
+    this.parameters.delete(keyOf(namespaceURI, localName));
+  }
+
+  /** Removes every parameter. */
+  clearParameters() {
+    this.parameters.clear();
+  }
+
+  /** Removes the stylesheet and the parameters. */
+  reset() {
+    this.stylesheet = null;
+    this.parameters.clear();
+  }
+}

package/src/xslt/runtime/accumulatorFunctions.js

@@ -0,0 +1,48 @@
+/**
+ * accumulator-before() and accumulator-after() (XSLT 3.0 sections
+ * 18.2.6 and 18.2.7).
+ *
+ * @module @tradik/xslt3/xslt/runtime/accumulatorFunctions
+ */
+
+import { isNode } from "../../xdm/atomic.js";
+import { xsltError } from "../names.js";
+import { accumulatorValue } from "./accumulators.js";
+import { nameArgument } from "./availability.js";
+
+/**
+ * Implementation of both functions.
+ * @param {boolean} after
+ * @returns {(args: Array, context: object) => Array}
+ */
+const accumulatorFunction = (after) => (args, context) => {
+  const [[name]] = args;
+  const { uri, local } = nameArgument(name.value, context, "XTDE3340");
+  const key = `{${uri}}${local}`;
+  // accumulators are local to the package of the call (XSLT 3.0 3.5.5)
+  const owner = context.sc?.owner ?? context.xc.tx.stylesheet;
+  const accumulator = owner.accumulators.get(key);
+  if (!accumulator) {
+    throw xsltError("XTDE3340", `No accumulator ${name.value}`);
+  }
+  const item = context.contextItem;
+  if (item === undefined) {
+    throw xsltError("XTDE3350", "An accumulator function needs a context item");
+  }
+  if (!isNode(item) || item.nodeType === 2 || item.nodeType === 13) {
+    throw xsltError(
+      "XTTE3360",
+      "An accumulator function needs a context node other than an attribute",
+    );
+  }
+  return accumulatorValue(context.xc, key, item, after, accumulator);
+};
+
+/** Function definitions. */
+export const accumulatorFunctions = ["before", "after"].map((phase) => ({
+  local: `accumulator-${phase}`,
+  params: ["xs:string"],
+  returns: "item()*",
+  focus: true,
+  impl: accumulatorFunction(phase === "after"),
+}));