@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/functions/json/xmlToJson.js

@@ -0,0 +1,147 @@
+/**
+ * fn:xml-to-json (F&O 3.1 section 17.5.4): the XML representation of JSON
+ * (elements map, array, string, number, boolean and null in the fn
+ * namespace) to a JSON text. The input is checked against the rules of
+ * the schema for that representation (FOJS0006); comments, processing
+ * instructions and whitespace between elements are ignored.
+ *
+ * @module @tradik/xslt3/functions/json/xmlToJson
+ */
+
+import { formatDouble, parseDouble } from "../../xdm/numeric.js";
+import { normalizeWhitespace, parseBoolean } from "../../xdm/strings.js";
+import { readOptions } from "../options.js";
+import { define, FN_NAMESPACE, stringItem } from "../support.js";
+import { unescapeJsonChars } from "./jsonChars.js";
+import { escapeChar, escapeJsonString, needsEscape } from "./jsonStrings.js";
+import {
+  checkAttributes,
+  flag,
+  invalid,
+  members,
+  textOf,
+} from "./xmlRepresentation.js";
+
+/**
+ * A JSON string literal of a string or key.
+ * @param {string} text
+ * @param {boolean} escaped - The text holds JSON escape sequences, kept
+ * @returns {string}
+ */
+function quote(text, escaped) {
+  if (!escaped) return `"${escapeJsonString(text)}"`;
+  let result = "";
+  for (const { cp, escape } of unescapeJsonChars(text)) {
+    result +=
+      escape ?? (needsEscape(cp) ? escapeChar(cp) : String.fromCodePoint(cp));
+  }
+  return `"${result}"`;
+}
+
+/**
+ * Writes one element of the representation.
+ * @param {Element} element
+ * @param {boolean} inMap - The element is an entry of a map (needs a key)
+ * @param {string} indent - Line break and indentation, "" when not indenting
+ * @returns {string}
+ */
+function write(element, inMap, indent) {
+  if (element.namespaceURI !== FN_NAMESPACE) {
+    invalid(`element {${element.namespaceURI ?? ""}}${element.localName}`);
+  }
+  const name = element.localName;
+  checkAttributes(element);
+  if (inMap && !element.hasAttribute("key")) invalid("an entry without key");
+  flag(element, "escaped-key");
+  const inner = indent && `${indent}  `;
+  const list = (open, close, items) =>
+    items.length
+      ? `${open}${items.map((item) => inner + item).join(",")}${indent}${close}`
+      : `${open}${close}`;
+  switch (name) {
+    case "map": {
+      const keys = new Set();
+      const entries = members(element).map((child) => {
+        const escaped = flag(child, "escaped-key");
+        const raw = child.getAttribute("key") ?? "";
+        const key = escaped ? unescapeKey(raw) : raw;
+        if (keys.has(key)) invalid(`duplicate key "${key}"`);
+        keys.add(key);
+        const separator = indent ? ": " : ":";
+        return `${quote(raw, escaped)}${separator}${write(child, true, inner)}`;
+      });
+      return list("{", "}", entries);
+    }
+    case "array":
+      return list(
+        "[",
+        "]",
+        members(element).map((child) => write(child, false, inner)),
+      );
+    case "string":
+      return quote(textOf(element), flag(element, "escaped"));
+    case "number": {
+      const value = parseDouble(
+        normalizeWhitespace(textOf(element), "collapse"),
+      );
+      if (value === null || !Number.isFinite(value)) invalid("number");
+      return formatDouble(value);
+    }
+    case "boolean": {
+      const value = parseBoolean(
+        normalizeWhitespace(textOf(element), "collapse"),
+      );
+      if (value === null) invalid("boolean");
+      return String(value);
+    }
+    case "null":
+      if (/\S/.test(textOf(element))) invalid("content in <null>");
+      return "null";
+    default:
+      return invalid(`element <${name}>`);
+  }
+}
+
+/**
+ * The unescaped form of an escaped key, for duplicate detection.
+ * @param {string} key
+ * @returns {string}
+ */
+const unescapeKey = (key) =>
+  unescapeJsonChars(key)
+    .map(({ cp }) => String.fromCodePoint(cp))
+    .join("");
+
+/**
+ * fn:xml-to-json of a node.
+ * @param {Node} node - Document or element node
+ * @param {Array} [optionsArg]
+ * @returns {Array} an xs:string
+ */
+function xmlToJson(node, optionsArg) {
+  const { indent } = readOptions(
+    optionsArg?.[0],
+    { indent: { type: "xs:boolean", default: false } },
+    "FOJS0005",
+  );
+  let element = node;
+  // 11: a temporary tree (xsl:variable without "as") is a document node
+  if (node.nodeType === 9 || node.nodeType === 11) {
+    const children = members(node);
+    if (children.length !== 1) invalid("a document needs one element");
+    element = children[0];
+  } else if (node.nodeType !== 1) {
+    invalid("not an element or document node");
+  }
+  return [stringItem(write(element, false, indent ? "\n" : ""))];
+}
+
+/** Function definitions. */
+export const xmlToJsonFunctions = [
+  define("xml-to-json", ["node()?"], "xs:string?", ([input]) =>
+    input.length ? xmlToJson(input[0]) : [],
+  ),
+  define("xml-to-json", ["node()?", "map(*)"], "xs:string?", ([input, o]) =>
+    input.length ? xmlToJson(input[0], o) : [],
+  ),
+];

package/src/functions/library.js

@@ -0,0 +1,47 @@
+/**
+ * The function modules of F&O 3.1 that need no evaluator, collected for
+ * the function registry. fn:concat, fn:string-join and fn:string-length
+ * are exported separately (`coreStringFunctions`) because the core library
+ * may define them.
+ *
+ * @module @tradik/xslt3/functions/library
+ */
+
+import { aggregateFunctions } from "./aggregates.js";
+import { dateTimeFunctions } from "./datetime.js";
+import { formatDateTimeFunctions } from "./format/formatDateTime.js";
+import { formatIntegerFunctions } from "./format/formatInteger.js";
+import { formatNumberFunctions } from "./format/formatNumber.js";
+import { mathFunctions } from "./math.js";
+import { numericFunctions } from "./numeric.js";
+import { parseIetfDateFunctions } from "./parseIetfDate.js";
+import { qnameFunctions } from "./qnames.js";
+import { analyzeStringFunctions } from "./regex/analyzeString.js";
+import { regexFunctions } from "./regex/regexFunctions.js";
+import { sequenceFunctions } from "./sequences.js";
+import { serializeFunctions } from "./serializeFunction.js";
+import { stringFunctions } from "./strings.js";
+import { stringMatchFunctions } from "./stringMatch.js";
+import { uriFunctions } from "./uri.js";
+
+export { coreStringFunctions } from "./stringsCore.js";
+
+/** @type {import("./support.js").FunctionDefinition[]} */
+export const libraryFunctions = [
+  ...stringFunctions,
+  ...stringMatchFunctions,
+  ...uriFunctions,
+  ...regexFunctions,
+  ...analyzeStringFunctions,
+  ...numericFunctions,
+  ...formatIntegerFunctions,
+  ...formatNumberFunctions,
+  ...mathFunctions,
+  ...dateTimeFunctions,
+  ...formatDateTimeFunctions,
+  ...parseIetfDateFunctions,
+  ...qnameFunctions,
+  ...sequenceFunctions,
+  ...aggregateFunctions,
+  ...serializeFunctions,
+];

package/src/functions/mapArrayEqual.js

@@ -0,0 +1,41 @@
+/**
+ * fn:deep-equal for maps and arrays (F&O 3.1 section 14.2.1), the
+ * `deepEqualItem` hook that deepEqual.js calls for items that are neither
+ * atomic values nor nodes: maps are equal when they have the same keys
+ * (op:same-key) with deep-equal values, arrays when their members are
+ * deep-equal one by one. Other function items raise FOTY0015.
+ *
+ * @module @tradik/xslt3/functions/mapArrayEqual
+ */
+
+import { XPathError } from "../errors.js";
+import { itemKind } from "../xdm/atomic.js";
+import { deepEqualSequences } from "./deepEqual.js";
+
+/**
+ * Whether two items that are not both atomic values or nodes are
+ * deep-equal.
+ * @param {*} a
+ * @param {*} b
+ * @param {import("./deepEqual.js").DeepEqualOptions} options - Options of
+ *   deepEqualSequences, with this function as `deepEqualItem`
+ * @returns {boolean}
+ * @throws {XPathError} FOTY0015 for function items other than maps and
+ *   arrays
+ */
+export function deepEqualItem(a, b, options) {
+  const kind = itemKind(a);
+  if (kind === "function" || itemKind(b) === "function") {
+    throw new XPathError("FOTY0015", "deep-equal cannot compare functions");
+  }
+  if (kind !== itemKind(b) || a.size !== b.size) return false;
+  if (kind === "array") {
+    return a.members.every((member, i) =>
+      deepEqualSequences(member, b.members[i], options),
+    );
+  }
+  return [...a.entries.values()].every(({ key, value }) => {
+    const other = b.get(key);
+    return other !== undefined && deepEqualSequences(value, other, options);
+  });
+}

package/src/functions/maps.js

@@ -0,0 +1,152 @@
+/**
+ * Functions on maps (F&O 3.1 section 17.1), in the namespace
+ * http://www.w3.org/2005/xpath-functions/map.
+ *
+ * @module @tradik/xslt3/functions/maps
+ */
+
+import { XPathError } from "../errors.js";
+import { XdmArray } from "../items/array.js";
+import { XdmMap } from "../items/map.js";
+import { isArray, isMap } from "../xdm/atomic.js";
+import { booleanItem, integerItem, stringItem } from "../xpath/eval/atomics.js";
+import { NS } from "./signatures.js";
+
+const DUPLICATES = new Set([
+  "use-first",
+  "use-last",
+  "use-any",
+  "combine",
+  "reject",
+]);
+
+/**
+ * map:merge.
+ * @param {XdmMap[]} maps
+ * @param {XdmMap} [options]
+ * @returns {XdmMap}
+ */
+function merge(maps, options) {
+  const duplicates = options?.get(stringItem("duplicates"));
+  let policy = "use-first";
+  if (duplicates !== undefined) {
+    const value = duplicates[0]?.value;
+    if (duplicates.length !== 1 || typeof value !== "string") {
+      throw new XPathError("XPTY0004", "duplicates must be an xs:string");
+    }
+    if (!DUPLICATES.has(value)) {
+      throw new XPathError("FOJS0005", `Invalid duplicates option ${value}`);
+    }
+    policy = value;
+  }
+  const entries = new Map();
+  for (const map of maps) {
+    for (const [k, entry] of map.entries) {
+      const existing = entries.get(k);
+      if (!existing || policy === "use-last") entries.set(k, entry);
+      else if (policy === "reject") {
+        throw new XPathError("FOJS0003", "Duplicate key in map:merge");
+      } else if (policy === "combine") {
+        entries.set(k, {
+          key: existing.key,
+          value: [...existing.value, ...entry.value],
+        });
+      }
+    }
+  }
+  return new XdmMap(entries);
+}
+
+/**
+ * map:find: values of a key in maps nested in a sequence.
+ * @param {Array} sequence
+ * @param {*} key
+ * @param {Array[]} found - Values are appended
+ */
+function find(sequence, key, found) {
+  for (const item of sequence) {
+    if (isMap(item)) {
+      const value = item.get(key);
+      if (value !== undefined) found.push(value);
+      for (const entry of item.entries.values()) find(entry.value, key, found);
+    } else if (isArray(item)) {
+      for (const member of item.members) find(member, key, found);
+    }
+  }
+}
+
+/**
+ * @param {string} local
+ * @param {string[]} params
+ * @param {string} returns
+ * @param {Function} impl
+ * @returns {object} a definition in the map namespace
+ */
+const mapFunction = (local, params, returns, impl) => ({
+  namespace: NS.map,
+  local,
+  params,
+  returns,
+  impl,
+});
+
+/** Function definitions. */
+export const mapFunctions = [
+  mapFunction("size", ["map(*)"], "xs:integer", ([[map]]) => [
+    integerItem(map.size),
+  ]),
+  mapFunction("keys", ["map(*)"], "xs:anyAtomicType*", ([[map]]) => map.keys()),
+  mapFunction(
+    "contains",
+    ["map(*)", "xs:anyAtomicType"],
+    "xs:boolean",
+    ([[map], [key]]) => [booleanItem(map.has(key))],
+  ),
+  mapFunction(
+    "get",
+    ["map(*)", "xs:anyAtomicType"],
+    "item()*",
+    ([[map], [key]]) => map.get(key) ?? [],
+  ),
+  mapFunction(
+    "put",
+    ["map(*)", "xs:anyAtomicType", "item()*"],
+    "map(*)",
+    ([[map], [key], value]) => [map.put(key, value)],
+  ),
+  mapFunction(
+    "remove",
+    ["map(*)", "xs:anyAtomicType*"],
+    "map(*)",
+    ([[map], keys]) => [map.remove(keys)],
+  ),
+  mapFunction(
+    "entry",
+    ["xs:anyAtomicType", "item()*"],
+    "map(*)",
+    ([[key], value]) => [XdmMap.from([[key, value]])],
+  ),
+  mapFunction("merge", ["map(*)*"], "map(*)", ([maps]) => [merge(maps)]),
+  mapFunction("merge", ["map(*)*", "map(*)"], "map(*)", ([maps, [options]]) => [
+    merge(maps, options),
+  ]),
+  mapFunction(
+    "for-each",
+    ["map(*)", "function(xs:anyAtomicType, item()*) as item()*"],
+    "item()*",
+    ([[map], [f]]) =>
+      [...map.entries.values()].flatMap(({ key, value }) =>
+        f.invoke([[key], value]),
+      ),
+  ),
+  mapFunction(
+    "find",
+    ["item()*", "xs:anyAtomicType"],
+    "array(*)",
+    ([sequence, [key]]) => {
+      const found = [];
+      find(sequence, key, found);
+      return [new XdmArray(found)];
+    },
+  ),
+];

package/src/functions/math.js

@@ -0,0 +1,73 @@
+/**
+ * Trigonometric and exponential functions (F&O 3.1 section 4.8), in the
+ * namespace http://www.w3.org/2005/xpath-functions/math. They follow IEEE
+ * 754 (JS Math) except where F&O differs: math:pow(1, y) and
+ * math:pow(-1, ±INF) are 1.
+ *
+ * @module @tradik/xslt3/functions/math
+ */
+
+import { define, doubleItem, MATH_NAMESPACE, toDouble } from "./support.js";
+
+const D = "xs:double?";
+
+/**
+ * math:pow on JS numbers.
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ */
+export function pow(x, y) {
+  if (x === 1 || (x === -1 && !Number.isFinite(y) && !Number.isNaN(y))) {
+    return 1;
+  }
+  return x ** y;
+}
+
+/**
+ * Declares a math function of one optional xs:double.
+ * @param {string} local
+ * @param {(x: number) => number} apply
+ * @returns {import("./support.js").FunctionDefinition}
+ */
+const unary = (local, apply) =>
+  define(
+    local,
+    [D],
+    D,
+    ([arg]) => (arg.length === 0 ? [] : [doubleItem(apply(arg[0].value))]),
+    { namespace: MATH_NAMESPACE },
+  );
+
+/** @type {import("./support.js").FunctionDefinition[]} */
+export const mathFunctions = [
+  define("pi", [], "xs:double", () => [doubleItem(Math.PI)], {
+    namespace: MATH_NAMESPACE,
+  }),
+  unary("exp", Math.exp),
+  unary("exp10", (x) => 10 ** x),
+  unary("log", Math.log),
+  unary("log10", Math.log10),
+  unary("sqrt", Math.sqrt),
+  unary("sin", Math.sin),
+  unary("cos", Math.cos),
+  unary("tan", Math.tan),
+  unary("asin", Math.asin),
+  unary("acos", Math.acos),
+  unary("atan", Math.atan),
+  define(
+    "pow",
+    [D, "xs:numeric"],
+    D,
+    ([x, [y]]) =>
+      x.length === 0 ? [] : [doubleItem(pow(x[0].value, toDouble(y)))],
+    { namespace: MATH_NAMESPACE },
+  ),
+  define(
+    "atan2",
+    ["xs:double", "xs:double"],
+    "xs:double",
+    ([[y], [x]]) => [doubleItem(Math.atan2(y.value, x.value))],
+    { namespace: MATH_NAMESPACE },
+  ),
+];

package/src/functions/nodePaths.js

@@ -0,0 +1,181 @@
+/**
+ * Functions locating nodes and their namespaces (F&O 3.1 sections 13 and
+ * 10.2): fn:path, fn:base-uri, fn:document-uri, fn:resolve-QName,
+ * fn:in-scope-prefixes and fn:namespace-uri-for-prefix.
+ *
+ * @module @tradik/xslt3/functions/nodePaths
+ */
+
+import { XPathError } from "../errors.js";
+import { AtomicValue } from "../xdm/atomic.js";
+import { parseQName } from "../xdm/qname.js";
+import { types } from "../xdm/types.js";
+import { stringItem } from "../xpath/eval/atomics.js";
+import {
+  childrenOf,
+  nodeLocalName,
+  nodeNamespace,
+  parentOf,
+} from "../xpath/eval/domNodes.js";
+import { inScopeNamespaces } from "../xpath/eval/namespaceNodes.js";
+import { documentUriOf, nodeBaseUri } from "./baseUris.js";
+import { focusNode } from "./focus.js";
+
+export { nodeBaseUri };
+
+/** @param {Node} node @returns {boolean} */
+const isDocument = (node) => node.nodeType === 9 || node.nodeType === 11;
+
+/**
+ * @param {Node} node
+ * @param {(n: Node) => boolean} same - Siblings counted for the position
+ * @returns {number} 1-based position among the matching siblings
+ */
+function positionAmong(node, same) {
+  const parent = parentOf(node);
+  if (!parent) return 1;
+  return childrenOf(parent).filter(same).indexOf(node) + 1;
+}
+
+/**
+ * One step of fn:path.
+ * @param {Node} node
+ * @returns {string}
+ */
+function pathStep(node) {
+  const name = `Q{${nodeNamespace(node)}}${nodeLocalName(node)}`;
+  switch (node.nodeType) {
+    case 1:
+      return `${name}[${positionAmong(
+        node,
+        (n) =>
+          n.nodeType === 1 &&
+          `Q{${nodeNamespace(n)}}${nodeLocalName(n)}` === name,
+      )}]`;
+    case 2:
+      return node.namespaceURI ? `@${name}` : `@${nodeLocalName(node)}`;
+    case 7:
+      return `processing-instruction(${nodeLocalName(node)})[${positionAmong(
+        node,
+        (n) => n.nodeType === 7 && nodeLocalName(n) === nodeLocalName(node),
+      )}]`;
+    case 8:
+      return `comment()[${positionAmong(node, (n) => n.nodeType === 8)}]`;
+    case 13:
+      return node.localName
+        ? `namespace::${node.localName}`
+        : 'namespace::*[Q{http://www.w3.org/2005/xpath-functions}local-name()=""]';
+    default:
+      return `text()[${positionAmong(node, (n) => n.nodeType === 3 || n.nodeType === 4)}]`;
+  }
+}
+
+/**
+ * fn:path of a node.
+ * @param {Node} node
+ * @returns {string}
+ */
+function pathOf(node) {
+  const steps = [];
+  let current = node;
+  for (; parentOf(current); current = parentOf(current)) {
+    steps.unshift(pathStep(current));
+  }
+  if (isDocument(current)) return `/${steps.join("/")}`;
+  const root = "Q{http://www.w3.org/2005/xpath-functions}root()";
+  return steps.length ? `${root}/${steps.join("/")}` : root;
+}
+
+/** @param {string|undefined} uri @returns {Array} an optional xs:anyURI */
+const anyUri = (uri) =>
+  uri === undefined ? [] : [new AtomicValue(types.anyURI, uri)];
+
+/**
+ * fn:resolve-QName: a lexical QName resolved with the in-scope namespaces
+ * of an element.
+ * @param {Array<Array>} args
+ * @returns {Array} an optional xs:QName
+ * @throws {XPathError} FOCA0002 for an invalid lexical QName, FONS0004
+ *   for an undeclared prefix
+ */
+function resolveQName([name, [element]]) {
+  if (!name.length) return [];
+  const namespaces = inScopeNamespaces(element);
+  const resolve = (prefix) => namespaces.get(prefix) ?? (prefix ? null : "");
+  const qname = parseQName(name[0].value, resolve);
+  if (qname === null) {
+    throw new XPathError("FOCA0002", `"${name[0].value}" is not a QName`);
+  }
+  return [new AtomicValue(types.QName, qname)];
+}
+
+/** Function definitions. */
+export const nodePathFunctions = [
+  {
+    local: "path",
+    params: [],
+    returns: "xs:string?",
+    focus: true,
+    impl: (_, context) => [stringItem(pathOf(focusNode(context)))],
+  },
+  {
+    local: "path",
+    params: ["node()?"],
+    returns: "xs:string?",
+    impl: ([arg]) => (arg.length ? [stringItem(pathOf(arg[0]))] : []),
+  },
+  {
+    local: "base-uri",
+    params: [],
+    returns: "xs:anyURI?",
+    focus: true,
+    impl: (_, context) => anyUri(nodeBaseUri(focusNode(context))),
+  },
+  {
+    local: "base-uri",
+    params: ["node()?"],
+    returns: "xs:anyURI?",
+    impl: ([arg]) => (arg.length ? anyUri(nodeBaseUri(arg[0])) : []),
+  },
+  {
+    local: "document-uri",
+    params: [],
+    returns: "xs:anyURI?",
+    focus: true,
+    impl: (_, context) => {
+      const node = focusNode(context);
+      return isDocument(node) ? anyUri(documentUriOf(node)) : [];
+    },
+  },
+  {
+    local: "document-uri",
+    params: ["node()?"],
+    returns: "xs:anyURI?",
+    impl: ([arg]) =>
+      arg.length && isDocument(arg[0]) ? anyUri(documentUriOf(arg[0])) : [],
+  },
+  {
+    local: "resolve-QName",
+    params: ["xs:string?", "element()"],
+    returns: "xs:QName?",
+    impl: resolveQName,
+  },
+  {
+    local: "in-scope-prefixes",
+    params: ["element()"],
+    returns: "xs:string*",
+    impl: ([[element]]) =>
+      [...inScopeNamespaces(element)]
+        .filter(([, uri]) => uri !== "")
+        .map(([prefix]) => stringItem(prefix)),
+  },
+  {
+    local: "namespace-uri-for-prefix",
+    params: ["xs:string?", "element()"],
+    returns: "xs:anyURI?",
+    impl: ([prefix, [element]]) => {
+      const uri = inScopeNamespaces(element).get(prefix[0]?.value ?? "");
+      return uri ? anyUri(uri) : [];
+    },
+  },
+];