@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/eval/functionItems.js

@@ -0,0 +1,194 @@
+/**
+ * Static function resolution and the function items of known functions:
+ * library functions (see functions/registry.js), constructor functions of
+ * the atomic types, and F&O functions without an implementation yet.
+ *
+ * @module @tradik/xslt3/xpath/eval/functionItems
+ */
+
+import { XPathError } from "../../errors.js";
+import { isStandardFunction, NS } from "../../functions/signatures.js";
+import { FunctionItem } from "../../items/function.js";
+import { QNameValue } from "../../xdm/qname.js";
+import { XS_NAMESPACE } from "../../xdm/types.js";
+import { parseSequenceType } from "../syntax/types.js";
+import { TokenStream } from "../syntax/tokenStream.js";
+import { coerce } from "./coercion.js";
+import { dynamicCallContext } from "./dynamicCall.js";
+import { compileSequenceType } from "./sequenceType.js";
+import { createStaticContext } from "./staticContext.js";
+import { compileCastTarget, LIST_TYPES } from "./typeExprs.js";
+
+/** Largest arity of a function reference to a variadic function. */
+const MAX_ARITY = 1000000;
+
+/** Static context in which definition types are read. */
+const BUILT_IN_CONTEXT = createStaticContext({}, null);
+
+/** @type {Map<string, object>} compiled sequence types by text */
+const typeCache = new Map();
+
+/**
+ * @param {string} text - A sequence type in XPath syntax
+ * @returns {import("./sequenceType.js").SequenceType}
+ */
+export function sequenceTypeOf(text) {
+  let type = typeCache.get(text);
+  if (!type) {
+    const tokens = new TokenStream(text);
+    type = compileSequenceType(parseSequenceType(tokens), BUILT_IN_CONTEXT);
+    if (tokens.peek().type !== "eof") tokens.fail("Unexpected token");
+    typeCache.set(text, type);
+  }
+  return type;
+}
+
+/**
+ * Signature of a definition at an arity (variadic definitions repeat their
+ * last parameter).
+ * @param {import("../../functions/registry.js").FunctionDefinition} definition
+ * @param {number} arity
+ * @returns {{params: object[], returns: object}}
+ */
+export function definitionSignature(definition, arity) {
+  const texts = definition.params;
+  const params = [];
+  for (let i = 0; i < arity; i++) {
+    params.push(sequenceTypeOf(texts[Math.min(i, texts.length - 1)]));
+  }
+  return { params, returns: sequenceTypeOf(definition.returns) };
+}
+
+/**
+ * A resolved static function: `call(args, ctx)` takes evaluated arguments
+ * and returns the result; `signature` gives the parameter types.
+ * @typedef {object} ResolvedFunction
+ * @property {QNameValue} name
+ * @property {number} arity
+ * @property {{params: object[], returns: object}} signature
+ * @property {boolean} focus - Depends on the focus
+ * @property {(args: Array<Array>, ctx: object) => Array} call
+ */
+
+/**
+ * Builds the call of a library function.
+ * @returns {ResolvedFunction}
+ */
+function libraryFunction(definition, name, arity, sc) {
+  const signature = definitionSignature(definition, arity);
+  const options = signature.params.map((_, i) => ({
+    what: `argument ${i + 1} of ${name}()`,
+    compatible: sc.backwardsCompatible,
+  }));
+  const call = definition.focus
+    ? (args, ctx) => {
+        const context = Object.create(ctx.dyn);
+        context.contextItem = ctx.item;
+        context.position = ctx.position;
+        context.size = ctx.size;
+        return definition.impl(
+          args.map((arg, i) => coerce(arg, signature.params[i], options[i])),
+          context,
+        );
+      }
+    : (args, ctx) =>
+        definition.impl(
+          args.map((arg, i) => coerce(arg, signature.params[i], options[i])),
+          ctx.dyn,
+        );
+  return { name, arity, signature, focus: Boolean(definition.focus), call };
+}
+
+/**
+ * Builds the call of a constructor function `xs:T($arg)`.
+ * @returns {ResolvedFunction|null} null when T has no constructor
+ */
+function constructorFunction(name, sc) {
+  let caster;
+  try {
+    caster = compileCastTarget(
+      { prefix: null, uri: XS_NAMESPACE, local: name.localName },
+      sc,
+    );
+  } catch {
+    return null;
+  }
+  const signature = {
+    params: [sequenceTypeOf("xs:anyAtomicType?")],
+    returns: sequenceTypeOf(
+      name.localName === "error"
+        ? "empty-sequence()"
+        : LIST_TYPES[name.localName]
+          ? `xs:${LIST_TYPES[name.localName]}*`
+          : `xs:${name.localName}?`,
+    ),
+  };
+  const what = { what: `argument of ${name}()` };
+  const call = ([arg]) => {
+    const values = coerce(arg, signature.params[0], what);
+    return values.length === 0 ? [] : caster(values[0]);
+  };
+  return { name, arity: 1, signature, focus: false, call };
+}
+
+/**
+ * Resolves a function by expanded name and arity.
+ * @param {string} uri
+ * @param {string} local
+ * @param {number} arity
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {ResolvedFunction}
+ * @throws {XPathError} XPST0017 when there is no such function
+ */
+export function resolveFunction(uri, local, arity, sc) {
+  if (arity > MAX_ARITY) {
+    throw new XPathError("FOAR0002", `Arity ${arity} is too large`);
+  }
+  const prefix = Object.keys(NS).find((key) => NS[key] === uri);
+  const name = new QNameValue(
+    uri,
+    local,
+    prefix ?? (uri === XS_NAMESPACE ? "xs" : ""),
+  );
+  const definition = sc.functions.lookup(uri, local, arity);
+  if (definition) return libraryFunction(definition, name, arity, sc);
+  const constructor =
+    uri === XS_NAMESPACE && arity === 1 ? constructorFunction(name, sc) : null;
+  if (constructor) return constructor;
+  if (isStandardFunction(uri, local, arity)) {
+    return {
+      name,
+      arity,
+      signature: null,
+      focus: false,
+      call: () => {
+        throw new XPathError(
+          "XPST0017",
+          `${local}#${arity} is not implemented`,
+        );
+      },
+    };
+  }
+  throw new XPathError(
+    "XPST0017",
+    `Unknown function Q{${uri}}${local}#${arity}`,
+  );
+}
+
+/**
+ * The function item of a resolved function; a focus-dependent function
+ * keeps the focus of `ctx`.
+ * @param {ResolvedFunction} resolved
+ * @param {import("./scope.js").Context} ctx
+ * @returns {FunctionItem}
+ */
+export function functionItemOf(resolved, ctx) {
+  if (resolved.signature === null) return resolved.call();
+  return new FunctionItem({
+    name: resolved.name,
+    arity: resolved.arity,
+    signature: resolved.signature,
+    invoke: (args) =>
+      resolved.call(args, { ...ctx, dyn: dynamicCallContext(ctx.dyn) }),
+  });
+}

package/src/xpath/eval/groupedChildren.js

@@ -0,0 +1,88 @@
+/**
+ * `//T[P]` with a positional predicate (`//item[last()]`, `//x[1]`):
+ * `descendant-or-self::node()/child::T[P]`, which cannot become
+ * `descendant::T[P]` (see positional.js) because P sees the position of a
+ * node among the T children of its parent.
+ *
+ * Instead of applying `child::T[P]` to every node of the tree (one context
+ * and one child walk per node, text nodes included), one descendant walk
+ * collects the T nodes, grouped by parent in document order; P filters
+ * each group as it would filter the children of that parent. A parent
+ * without T children gives nothing in both evaluations.
+ *
+ * @module @tradik/xslt3/xpath/eval/groupedChildren
+ */
+
+import { XPathError } from "../../errors.js";
+import { isNode } from "../../xdm/atomic.js";
+import { axisNodes } from "./descendantMemo.js";
+import { parentOf } from "./domNodes.js";
+import { compileNodeTest } from "./nodeTests.js";
+import { compilePredicate } from "./predicates.js";
+
+/**
+ * Whether a step is `descendant-or-self::node()` and the next one a child
+ * step: the pair `groupedChildren` evaluates (when the descendant shortcut
+ * of paths.js does not apply).
+ * @param {object} step
+ * @param {object|undefined} next
+ * @returns {boolean}
+ */
+export const isGroupedChildren = (step, next) =>
+  step.type === "AxisStep" &&
+  step.axis === "descendant-or-self" &&
+  step.nodeTest.type === "AnyKindTest" &&
+  step.predicates.length === 0 &&
+  next?.type === "AxisStep" &&
+  next.axis === "child";
+
+/**
+ * Compiles the child step of a `descendant-or-self::node()/child::T[P]`
+ * pair.
+ * @param {object} step - The child AxisStep
+ * @param {import("./scope.js").Scope} scope
+ * @param {Function} compile
+ * @returns {(input: Array, ctx: object) => Node[]} the nodes selected from
+ *   the input nodes, in document order without duplicates
+ */
+export function compileGroupedChildren(step, scope, compile) {
+  const test = compileNodeTest(step.nodeTest, "child", scope.sc);
+  const predicates = step.predicates.map((p) =>
+    compilePredicate(p, scope, compile),
+  );
+  return (input, ctx) => {
+    // Candidates in document order when there is one input node
+    const found = [];
+    for (const node of input) {
+      if (!isNode(node)) {
+        throw new XPathError(
+          "XPTY0019",
+          "The left operand of / must contain only nodes",
+        );
+      }
+      const nodes = axisNodes("descendant", node, test, Infinity, ctx.dyn);
+      for (const n of nodes) found.push(n);
+    }
+    const groups = new Map();
+    // Walks from nested input nodes overlap
+    const seen = input.length > 1 ? new Set() : null;
+    for (const node of found) {
+      if (seen) {
+        if (seen.has(node)) continue;
+        seen.add(node);
+      }
+      const parent = parentOf(node);
+      const group = groups.get(parent);
+      if (group) group.push(node);
+      else groups.set(parent, [node]);
+    }
+    const kept = new Set();
+    for (const group of groups.values()) {
+      let nodes = group;
+      for (const predicate of predicates) nodes = predicate(nodes, ctx);
+      for (const node of nodes) kept.add(node);
+    }
+    if (input.length > 1) return ctx.dyn.order.sort([...kept]);
+    return found.filter((node) => kept.has(node));
+  };
+}

package/src/xpath/eval/inline.js

@@ -0,0 +1,71 @@
+/**
+ * Compiler of inline function expressions (XPath 3.1 section 3.1.7): a
+ * closure over the variables in scope, with an absent focus in its body;
+ * arguments and result are converted to the declared types.
+ *
+ * @module @tradik/xslt3/xpath/eval/inline
+ */
+
+import { dynamicCallContext } from "./dynamicCall.js";
+import { XPathError } from "../../errors.js";
+import { FunctionItem } from "../../items/function.js";
+import { coerce } from "./coercion.js";
+import { bindVariable } from "./scope.js";
+import { ANY_SEQUENCE, compileSequenceType } from "./sequenceType.js";
+import { clark, namespaceOf } from "./staticContext.js";
+
+/** Compilers by node type. */
+export const inlineCompilers = {
+  InlineFunctionExpr(node, scope, compile) {
+    const { sc } = scope;
+    const keys = node.params.map((param) =>
+      clark(namespaceOf(param.name, sc, ""), param.name.local),
+    );
+    if (new Set(keys).size !== keys.length) {
+      throw new XPathError(
+        "XQST0039",
+        "Two parameters of an inline function have the same name",
+      );
+    }
+    const params = node.params.map((param) =>
+      param.sequenceType
+        ? compileSequenceType(param.sequenceType, sc)
+        : ANY_SEQUENCE,
+    );
+    const returns = node.returnType
+      ? compileSequenceType(node.returnType, sc)
+      : ANY_SEQUENCE;
+    let bodyScope = scope;
+    for (const key of keys) bodyScope = bindVariable(bodyScope, key);
+    const body = compile(node.body, bodyScope);
+    const arity = keys.length;
+    const argOptions = keys.map((_, i) => ({
+      what: `argument ${i + 1} of an inline function`,
+    }));
+    const resultOptions = { what: "result of an inline function" };
+    const signature = { params, returns };
+    return (ctx) => [
+      new FunctionItem({
+        arity,
+        signature,
+        invoke: (args) => {
+          let env = ctx.env;
+          for (let i = 0; i < arity; i++) {
+            env = {
+              value: coerce(args[i], params[i], argOptions[i]),
+              next: env,
+            };
+          }
+          const value = body({
+            item: undefined,
+            position: 0,
+            size: 0,
+            env,
+            dyn: dynamicCallContext(ctx.dyn),
+          });
+          return coerce(value, returns, resultOptions);
+        },
+      }),
+    ];
+  },
+};

package/src/xpath/eval/namespaceNodes.js

@@ -0,0 +1,90 @@
+/**
+ * Namespace nodes (XDM 3.1 section 6.4), which DOMs do not have: objects
+ * with nodeType 13 made for the in-scope namespaces of an element, once
+ * per element so that they keep their identity.
+ *
+ * The in-scope namespaces come from the `xmlns` attributes of the element
+ * and its ancestors, the names of the element and its attributes (DOMs
+ * built with createElementNS may lack the declarations), and the xml
+ * prefix, which is always in scope.
+ *
+ * @module @tradik/xslt3/xpath/eval/namespaceNodes
+ */
+
+import { isNamespaceDeclaration, NODE_TYPES, parentOf } from "./domNodes.js";
+
+/** The namespace bound to the xml prefix. */
+export const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+
+/** A namespace node: prefix ("" for the default namespace) and URI. */
+export class NamespaceNode {
+  /**
+   * @param {Element} element - Parent element
+   * @param {string} prefix
+   * @param {string} uri
+   */
+  constructor(element, prefix, uri) {
+    this.ownerElement = element;
+    this.localName = prefix;
+    this.nodeName = prefix;
+    this.nodeValue = uri;
+    this.namespaceURI = null;
+    this.prefix = null;
+    this.childNodes = [];
+    Object.freeze(this);
+  }
+
+  /** @returns {number} 13, the nodeType of namespace nodes */
+  get nodeType() {
+    return NODE_TYPES.namespace;
+  }
+}
+
+/** @type {WeakMap<Element, NamespaceNode[]>} */
+const cache = new WeakMap();
+
+/**
+ * In-scope namespaces of an element as prefix → URI ("" URI: undeclared).
+ * @param {Element} element
+ * @returns {Map<string, string>}
+ */
+export function inScopeNamespaces(element) {
+  const chain = [];
+  for (let e = element; e && e.nodeType === 1; e = parentOf(e)) chain.push(e);
+  const bindings = new Map();
+  for (const e of chain.reverse()) {
+    for (const attribute of e.attributes) {
+      if (!isNamespaceDeclaration(attribute)) continue;
+      const name = attribute.name ?? attribute.nodeName;
+      const prefix = name === "xmlns" ? "" : name.slice(6);
+      bindings.set(prefix, attribute.value ?? attribute.nodeValue);
+    }
+  }
+  const declare = (node) => {
+    if (node.namespaceURI) bindings.set(node.prefix ?? "", node.namespaceURI);
+  };
+  declare(element);
+  for (const attribute of element.attributes) {
+    if (!isNamespaceDeclaration(attribute) && attribute.prefix) {
+      declare(attribute);
+    }
+  }
+  bindings.set("xml", XML_NAMESPACE);
+  return bindings;
+}
+
+/**
+ * @param {Element} element
+ * @returns {NamespaceNode[]} the namespace nodes of an element
+ */
+export function namespaceNodesOf(element) {
+  let nodes = cache.get(element);
+  if (!nodes) {
+    nodes = [];
+    for (const [prefix, uri] of inScopeNamespaces(element)) {
+      if (uri !== "") nodes.push(new NamespaceNode(element, prefix, uri));
+    }
+    cache.set(element, nodes);
+  }
+  return nodes;
+}

package/src/xpath/eval/nodeTests.js

@@ -0,0 +1,164 @@
+/**
+ * Node tests (XPath 3.1 section 3.3.2.2) and kind tests (section 2.5.5.3)
+ * compiled to predicates on DOM nodes.
+ *
+ * @module @tradik/xslt3/xpath/eval/nodeTests
+ */
+
+import { XPathError } from "../../errors.js";
+import {
+  childrenOf,
+  isXdmNode,
+  nodeLocalName,
+  nodeNamespace,
+} from "./domNodes.js";
+import { clark, namespaceOf } from "./staticContext.js";
+import { untypedMatches } from "./typeNames.js";
+
+/**
+ * A compiled kind test.
+ * @typedef {object} KindTest
+ * @property {string|null} kind - XDM node kind, null for node()
+ * @property {string|null} name - Clark name required, null for any
+ * @property {(node: Node) => boolean} matches - Applies to nodes only
+ */
+
+/** nodeType of the principal node kind of an axis. */
+const principal = (axis) =>
+  axis === "attribute" ? 2 : axis === "namespace" ? 13 : 1;
+
+/**
+ * @param {Node} node
+ * @returns {string} Clark name of a node
+ */
+const nodeName = (node) => clark(nodeNamespace(node), nodeLocalName(node));
+
+/**
+ * Element or attribute test with an optional name and type.
+ * @param {object} test - ElementTest or AttributeTest
+ * @param {"element"|"attribute"} kind
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {KindTest}
+ */
+function namedKindTest(test, kind, sc) {
+  const nodeType = kind === "element" ? 1 : 2;
+  const defaultNs = kind === "element" ? sc.defaultElementNamespace : "";
+  const name = test.name
+    ? clark(namespaceOf(test.name, sc, defaultNs), test.name.local)
+    : null;
+  const typed = test.typeName ? untypedMatches(test.typeName, kind, sc) : true;
+  return {
+    kind,
+    name,
+    matches: (node) =>
+      typed &&
+      node.nodeType === nodeType &&
+      (name === null || nodeName(node) === name),
+  };
+}
+
+/** Kind test compilers by node type. */
+const kindTests = {
+  AnyKindTest: () => ({ kind: null, name: null, matches: () => true }),
+  TextTest: () => ({
+    kind: "text",
+    name: null,
+    matches: (node) => node.nodeType === 3 || node.nodeType === 4,
+  }),
+  CommentTest: () => ({
+    kind: "comment",
+    name: null,
+    matches: (node) => node.nodeType === 8,
+  }),
+  NamespaceNodeTest: () => ({
+    kind: "namespace",
+    name: null,
+    matches: (node) => node.nodeType === 13,
+  }),
+  PITest: (test) => ({
+    kind: "processing-instruction",
+    name: test.target === null ? null : clark("", test.target),
+    matches: (node) =>
+      node.nodeType === 7 &&
+      (test.target === null || nodeLocalName(node) === test.target),
+  }),
+  ElementTest: (test, sc) => namedKindTest(test, "element", sc),
+  AttributeTest: (test, sc) => namedKindTest(test, "attribute", sc),
+  SchemaElementTest: (test, sc) => {
+    namespaceOf(test.name, sc, sc.defaultElementNamespace);
+    throw new XPathError(
+      "XPST0008",
+      `No element declaration for schema-element(${test.name.local})`,
+    );
+  },
+  SchemaAttributeTest: (test, sc) => {
+    namespaceOf(test.name, sc, "");
+    throw new XPathError(
+      "XPST0008",
+      `No attribute declaration for schema-attribute(${test.name.local})`,
+    );
+  },
+  DocumentTest: (test, sc) => {
+    const element = test.elementTest && compileKindTest(test.elementTest, sc);
+    const matches = (node) => {
+      if (node.nodeType !== 9 && node.nodeType !== 11) return false;
+      if (!element) return true;
+      const children = childrenOf(node);
+      const elements = children.filter((child) => child.nodeType === 1);
+      const others = children.every(
+        (child) =>
+          child.nodeType === 1 || child.nodeType === 7 || child.nodeType === 8,
+      );
+      return elements.length === 1 && others && element.matches(elements[0]);
+    };
+    return { kind: "document", name: null, element, matches };
+  },
+};
+
+/**
+ * @param {import("../syntax/typeAst.js").KindTest} test
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {KindTest}
+ * @throws {XPathError} XPST0008 for schema-element(), schema-attribute()
+ *   and unknown type names, XPST0081 for undeclared prefixes
+ */
+export function compileKindTest(test, sc) {
+  return kindTests[test.type](test, sc);
+}
+
+/**
+ * Compiles the node test of an axis step.
+ * @param {import("../syntax/typeAst.js").NodeTest} test
+ * @param {string} axis
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {(node: Node) => boolean} the test, false for the nodes that
+ *   are not XDM nodes
+ */
+export function compileNodeTest(test, axis, sc) {
+  const nodeType = principal(axis);
+  if (test.type === "NameTest") {
+    const defaultNs = nodeType === 1 ? sc.defaultElementNamespace : "";
+    const uri = namespaceOf(test.name, sc, defaultNs);
+    const local = test.name.local;
+    // nodeLocalName() of the principal node kinds, without a second read
+    // of nodeType
+    const matches = (node) =>
+      node.nodeType === nodeType &&
+      (node.localName ?? node.nodeName) === local &&
+      nodeNamespace(node) === uri;
+    // The name, for axes that can look a node up by name (attribute)
+    matches.qname = { uri, local };
+    return matches;
+  }
+  if (test.type === "Wildcard") {
+    const uri = test.prefix !== null ? namespaceOf(test, sc, "") : test.uri;
+    const { local } = test;
+    return (node) =>
+      node.nodeType === nodeType &&
+      (local === null || nodeLocalName(node) === local) &&
+      (uri === null || nodeNamespace(node) === uri);
+  }
+  // node() on an axis: any XDM node, not a document type node
+  if (test.type === "AnyKindTest") return isXdmNode;
+  return compileKindTest(test, sc).matches;
+}