@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/eval/subtype.js

@@ -0,0 +1,154 @@
+/**
+ * Subtype relationships of sequence types and item types (XPath 3.1
+ * section 2.5.6), used to match function items against function tests:
+ * parameters are contravariant, results covariant.
+ *
+ * Item types are compiled ones (see sequenceType.js).
+ *
+ * @module @tradik/xslt3/xpath/eval/subtype
+ */
+
+import { derivesFrom, types } from "../../xdm/types.js";
+
+/** Occurrences as the set of cardinalities they allow (0, 1, many). */
+const CARDINALITIES = { "": "1", "?": "01", "*": "01m", "+": "1m" };
+
+/**
+ * @param {string} a - Occurrence indicator
+ * @param {string} b - Occurrence indicator
+ * @returns {boolean} whether every cardinality of a is allowed by b
+ */
+function occurrenceSubsumed(a, b) {
+  return [...CARDINALITIES[a]].every((c) => CARDINALITIES[b].includes(c));
+}
+
+/**
+ * @param {{params: object[], returns: object}} a
+ * @param {{params: object[], returns: object}} b
+ * @returns {boolean} whether signature a is a subtype of signature b
+ */
+function signatureSubtype(a, b) {
+  return (
+    a.params.length === b.params.length &&
+    b.params.every((param, i) => isSubtype(param, a.params[i])) &&
+    isSubtype(a.returns, b.returns)
+  );
+}
+
+/**
+ * The function signature that a map or array type stands for (XPath 3.1
+ * 2.5.6.2: map(K, V) is a function(xs:anyAtomicType) as V?, array(T) a
+ * function(xs:integer) as T).
+ * @param {object} a - Map or array item type
+ * @returns {{params: object[], returns: object}}
+ */
+function functionView(a) {
+  const isMapType = a.kind === "anyMap" || a.kind === "map";
+  const param = {
+    itemType: {
+      kind: "atomic",
+      types: [isMapType ? types.anyAtomicType : types.integer],
+    },
+    occurrence: "",
+  };
+  let returns = ANY;
+  if (a.kind === "map") {
+    const { itemType, occurrence } = a.valueType;
+    returns = {
+      itemType,
+      occurrence:
+        occurrence === "" ? "?" : occurrence === "+" ? "*" : occurrence,
+    };
+  } else if (a.kind === "array") {
+    returns = a.memberType;
+  }
+  return { params: [param], returns };
+}
+
+const ANY = { itemType: { kind: "item" }, occurrence: "*" };
+
+/**
+ * Whether item type a is a subtype of item type b.
+ * @param {object} a
+ * @param {object} b
+ * @returns {boolean}
+ */
+export function itemSubtype(a, b) {
+  if (b.kind === "item") return true;
+  switch (a.kind) {
+    case "atomic":
+      return (
+        b.kind === "atomic" &&
+        a.types.every((t) => b.types.some((u) => derivesFrom(t, u)))
+      );
+    case "node":
+      return b.kind === "node" && nodeSubtype(a.test, b.test);
+    case "item":
+      return false;
+    default:
+      return functionSubtype(a, b);
+  }
+}
+
+/**
+ * Subtyping of kind tests: same kind and, where b names a node, the same
+ * name.
+ * @param {object} a - Compiled kind test
+ * @param {object} b - Compiled kind test
+ * @returns {boolean}
+ */
+function nodeSubtype(a, b) {
+  if (b.kind === null) return true;
+  if (a.kind !== b.kind) return false;
+  if (b.name !== null && a.name !== b.name) return false;
+  if (b.element) return Boolean(a.element) && nodeSubtype(a.element, b.element);
+  return true;
+}
+
+/**
+ * Subtyping among function, map and array types.
+ * @param {object} a
+ * @param {object} b
+ * @returns {boolean}
+ */
+function functionSubtype(a, b) {
+  switch (b.kind) {
+    case "anyFunction":
+      return true;
+    case "anyMap":
+      return a.kind === "anyMap" || a.kind === "map";
+    case "map":
+      return (
+        a.kind === "map" &&
+        itemSubtype(a.keyType, b.keyType) &&
+        isSubtype(a.valueType, b.valueType)
+      );
+    case "anyArray":
+      return a.kind === "anyArray" || a.kind === "array";
+    case "array":
+      return a.kind === "array" && isSubtype(a.memberType, b.memberType);
+    case "function":
+      return a.kind === "function"
+        ? signatureSubtype(a, b)
+        : a.kind !== "anyFunction" && signatureSubtype(functionView(a), b);
+    default:
+      return false;
+  }
+}
+
+/**
+ * Whether sequence type a is a subtype of sequence type b.
+ * @param {{itemType: object|null, occurrence: string}} a
+ * @param {{itemType: object|null, occurrence: string}} b
+ * @returns {boolean}
+ */
+export function isSubtype(a, b) {
+  if (a.itemType === null) {
+    return b.itemType === null || CARDINALITIES[b.occurrence].includes("0");
+  }
+  if (b.itemType === null) return false;
+  return (
+    occurrenceSubsumed(a.occurrence, b.occurrence) &&
+    itemSubtype(a.itemType, b.itemType)
+  );
+}

package/src/xpath/eval/typeExprs.js

@@ -0,0 +1,147 @@
+/**
+ * Compilers of the expressions on sequence types: instance of, treat as,
+ * castable as and cast as (XPath 3.1 section 3.14), and the cast used by
+ * constructor functions.
+ *
+ * @module @tradik/xslt3/xpath/eval/typeExprs
+ */
+
+import { XPathError } from "../../errors.js";
+import { cast } from "../../xdm/cast.js";
+import { atomize } from "../../xdm/nodes.js";
+import { AtomicValue } from "../../xdm/atomic.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { derivesFrom, getType, types, XS_NAMESPACE } from "../../xdm/types.js";
+import { booleanItem } from "./atomics.js";
+import { compileSequenceType, matchesSequenceType } from "./sequenceType.js";
+import { namespaceOf } from "./staticContext.js";
+import { resolveAtomicType } from "./typeNames.js";
+
+const NOT_CASTABLE = new Set(["anyAtomicType", "anySimpleType", "NOTATION"]);
+
+/** List types and their item types. */
+export const LIST_TYPES = {
+  NMTOKENS: "NMTOKEN",
+  IDREFS: "IDREF",
+  ENTITIES: "ENTITY",
+};
+
+/**
+ * A compiled cast: an atomic value to the values of the target type (one
+ * value, or any number for a list type).
+ * @typedef {(value: import("../../xdm/atomic.js").AtomicValue) =>
+ *   import("../../xdm/atomic.js").AtomicValue[]} Caster
+ */
+
+/**
+ * Compiles the target type of a cast: an atomic type, xs:numeric or a
+ * built-in list type.
+ * @param {import("../syntax/ast.js").QName} name
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {Caster}
+ * @throws {XPathError} XPST0080 for a target type that cannot be cast to,
+ *   XPST0051 for an unknown one
+ */
+export function compileCastTarget(name, sc) {
+  const uri = namespaceOf(name, sc, sc.defaultElementNamespace);
+  if (uri === XS_NAMESPACE && NOT_CASTABLE.has(name.local)) {
+    throw new XPathError("XPST0080", `Cannot cast to xs:${name.local}`);
+  }
+  if (uri === XS_NAMESPACE && LIST_TYPES[name.local]) {
+    const itemType = getType(LIST_TYPES[name.local]);
+    return (value) =>
+      canonicalString(value)
+        .split(/[ \t\r\n]+/)
+        .filter(Boolean)
+        .map((token) => cast(new AtomicValue(types.string, token), itemType));
+  }
+  const members = resolveAtomicType(name, sc);
+  const options = {
+    resolveNamespace: (prefix) =>
+      prefix === "" ? sc.defaultElementNamespace : sc.namespaces.get(prefix),
+  };
+  if (members.length === 1) {
+    return (value) => [cast(value, members[0], options)];
+  }
+  return (value) => {
+    if (members.some((t) => derivesFrom(value.type, t))) return [value];
+    let failure;
+    for (const member of members) {
+      try {
+        return [cast(value, member, options)];
+      } catch (error) {
+        failure ??= error;
+      }
+    }
+    throw failure;
+  };
+}
+
+/**
+ * The single atomic operand of a cast.
+ * @param {Array} sequence
+ * @param {boolean} emptyAllowed
+ * @returns {import("../../xdm/atomic.js").AtomicValue|undefined}
+ * @throws {XPathError} XPTY0004 for an empty (when not allowed) or longer
+ *   sequence
+ */
+function castOperand(sequence, emptyAllowed) {
+  const values = atomize(sequence);
+  if (values.length === 1) return values[0];
+  if (values.length === 0 && emptyAllowed) return undefined;
+  throw new XPathError(
+    "XPTY0004",
+    `A cast needs one atomic value, not ${values.length}`,
+  );
+}
+
+/** Compilers by node type. */
+export const typeCompilers = {
+  InstanceOfExpr(node, scope, compile) {
+    const expr = compile(node.expr, scope);
+    const type = compileSequenceType(node.sequenceType, scope.sc);
+    return (ctx) => [booleanItem(matchesSequenceType(expr(ctx), type))];
+  },
+
+  TreatExpr(node, scope, compile) {
+    const expr = compile(node.expr, scope);
+    const type = compileSequenceType(node.sequenceType, scope.sc);
+    return (ctx) => {
+      const value = expr(ctx);
+      if (!matchesSequenceType(value, type)) {
+        throw new XPathError(
+          "XPDY0050",
+          "The value does not match the type of treat as",
+        );
+      }
+      return value;
+    };
+  },
+
+  CastExpr(node, scope, compile) {
+    const expr = compile(node.expr, scope);
+    const caster = compileCastTarget(node.targetType, scope.sc);
+    return (ctx) => {
+      const value = castOperand(expr(ctx), node.emptyAllowed);
+      return value === undefined ? [] : caster(value);
+    };
+  },
+
+  CastableExpr(node, scope, compile) {
+    const expr = compile(node.expr, scope);
+    const caster = compileCastTarget(node.targetType, scope.sc);
+    return (ctx) => {
+      const values = atomize(expr(ctx));
+      if (values.length !== 1) {
+        return [booleanItem(values.length === 0 && node.emptyAllowed)];
+      }
+      try {
+        caster(values[0]);
+        return [booleanItem(true)];
+      } catch (error) {
+        if (!(error instanceof XPathError)) throw error;
+        return [booleanItem(false)];
+      }
+    };
+  },
+};

package/src/xpath/eval/typeNames.js

@@ -0,0 +1,101 @@
+/**
+ * Resolution of the type names written in an expression: atomic and union
+ * types of sequence types and casts, and the type annotations of element()
+ * and attribute() tests. Without a schema the in-scope schema types are
+ * the built-in ones; nodes are untyped (elements xs:untyped, attributes
+ * xs:untypedAtomic).
+ *
+ * @module @tradik/xslt3/xpath/eval/typeNames
+ */
+
+import { XPathError } from "../../errors.js";
+import { getType, types, XS_NAMESPACE } from "../../xdm/types.js";
+import { namespaceOf } from "./staticContext.js";
+
+/** Members of the union type xs:numeric. */
+export const NUMERIC_MEMBERS = Object.freeze([
+  types.double,
+  types.float,
+  types.decimal,
+]);
+
+/** Built-in types that are neither atomic nor unions. */
+const COMPLEX_OR_SIMPLE = new Set(["anyType", "anySimpleType", "untyped"]);
+
+/**
+ * @param {import("../syntax/ast.js").QName} name
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {{uri: string, local: string}} the expanded type name (the
+ *   default element/type namespace applies)
+ */
+function expand(name, sc) {
+  return {
+    uri: namespaceOf(name, sc, sc.defaultElementNamespace),
+    local: name.local,
+  };
+}
+
+/**
+ * Looks up a built-in atomic type by local name.
+ * @param {string} local
+ * @returns {object|null}
+ */
+function builtIn(local) {
+  try {
+    return getType(local);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolves the name of a generalized atomic type (an atomic type or
+ * xs:numeric) to its member types.
+ * @param {import("../syntax/ast.js").QName} name
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {object[]} atomic type descriptors (several for a union)
+ * @throws {XPathError} XPST0051 when the name is not a known atomic or
+ *   union type, XPST0081 for an undeclared prefix
+ */
+export function resolveAtomicType(name, sc) {
+  const { uri, local } = expand(name, sc);
+  if (uri === XS_NAMESPACE) {
+    if (local === "numeric") return NUMERIC_MEMBERS;
+    const type = builtIn(local);
+    if (type) return [type];
+  }
+  throw new XPathError(
+    "XPST0051",
+    `${name.prefix ? `${name.prefix}:` : ""}${local} is not an atomic type`,
+  );
+}
+
+/**
+ * Whether a type is a known schema type (for the type annotation of an
+ * element() or attribute() test).
+ * @param {{uri: string, local: string}} name
+ * @returns {boolean}
+ */
+const isKnownType = ({ uri, local }) =>
+  uri === XS_NAMESPACE &&
+  (COMPLEX_OR_SIMPLE.has(local) || local === "numeric" || !!builtIn(local));
+
+/**
+ * Whether untyped nodes of a kind have, or derive from, a type annotation.
+ * @param {import("../syntax/ast.js").QName} name - Type in an element() or
+ *   attribute() test
+ * @param {"element"|"attribute"} kind
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {boolean} true when the nodes match the annotation
+ * @throws {XPathError} XPST0008 for an unknown type
+ */
+export function untypedMatches(name, kind, sc) {
+  const expanded = expand(name, sc);
+  if (!isKnownType(expanded)) {
+    throw new XPathError("XPST0008", `Unknown type ${name.local}`);
+  }
+  const { local } = expanded;
+  if (local === "anyType") return true;
+  if (kind === "element") return local === "untyped";
+  return ["anySimpleType", "anyAtomicType", "untypedAtomic"].includes(local);
+}

package/src/xpath/eval/uris.js

@@ -0,0 +1,21 @@
+/**
+ * URI resolution against a base URI (RFC 3986, through the WHATWG URL
+ * parser of the platform).
+ *
+ * @module @tradik/xslt3/xpath/eval/uris
+ */
+
+/**
+ * Resolves a URI against a base URI.
+ * @param {string} uri
+ * @param {string|undefined} base
+ * @returns {string} the absolute URI, or the URI unchanged when it cannot
+ *   be resolved
+ */
+export function resolveUri(uri, base) {
+  try {
+    return new globalThis.URL(uri, base).href;
+  } catch {
+    return uri;
+  }
+}

package/src/xpath/eval/values.js

@@ -0,0 +1,64 @@
+/**
+ * Conversion of JavaScript values to XDM sequences, for variable values
+ * and the context item given to the public API.
+ *
+ * | JavaScript | XDM |
+ * |---|---|
+ * | null, undefined | empty sequence |
+ * | string | xs:string |
+ * | number | xs:double |
+ * | bigint | xs:integer |
+ * | boolean | xs:boolean |
+ * | Date | xs:dateTime (UTC) |
+ * | Array | sequence of the converted elements (flattened) |
+ * | Map, plain object | map with xs:string keys (Map keys converted) |
+ * | DOM node, XDM item | itself |
+ *
+ * @module @tradik/xslt3/xpath/eval/values
+ */
+
+import { XdmMap } from "../../items/map.js";
+import { AtomicValue, ITEM_KIND } from "../../xdm/atomic.js";
+import { types } from "../../xdm/types.js";
+import { dateTimeOf } from "./dynamicContext.js";
+
+/**
+ * Converts a JS value used as a single atomic map key.
+ * @param {*} key
+ * @returns {AtomicValue}
+ */
+function keyOf(key) {
+  const [value] = toSequence(key);
+  return value instanceof AtomicValue
+    ? value
+    : new AtomicValue(types.string, String(key));
+}
+
+/**
+ * Converts a JS value to an XDM sequence.
+ * @param {*} value
+ * @returns {Array} the sequence
+ */
+export function toSequence(value) {
+  if (value === null || value === undefined) return [];
+  switch (typeof value) {
+    case "string":
+      return [new AtomicValue(types.string, value)];
+    case "number":
+      return [new AtomicValue(types.double, value)];
+    case "bigint":
+      return [new AtomicValue(types.integer, value)];
+    case "boolean":
+      return [new AtomicValue(types.boolean, value)];
+    default:
+      break;
+  }
+  if (Array.isArray(value)) return value.flatMap(toSequence);
+  if (value instanceof AtomicValue || value[ITEM_KIND]) return [value];
+  if (typeof value.nodeType === "number") return [value];
+  if (value instanceof Date) {
+    return [new AtomicValue(types.dateTime, dateTimeOf(value, 0))];
+  }
+  const entries = value instanceof Map ? [...value] : Object.entries(value);
+  return [XdmMap.from(entries.map(([k, v]) => [keyOf(k), toSequence(v)]))];
+}