@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/registry.js

@@ -0,0 +1,234 @@
+/**
+ * What the compiled stylesheet holds, filled during compilation and read
+ * at run time: global variable names, named templates, modes and their
+ * rules, attribute sets, keys and stylesheet functions.
+ *
+ * @module @tradik/xslt3/xslt/compiler/registry
+ */
+
+import { Mode } from "../patterns/modes.js";
+import { useStaticContext } from "../runtime/context.js";
+import { callFunction } from "../runtime/functionCall.js";
+import { attr, displayName, tokens, xsltError } from "../names.js";
+import { infoOf } from "./elementInfo.js";
+import { expandCharacterMaps } from "./outputDecl.js";
+import { StaticStage } from "./staticStage.js";
+
+/** Registries of a stylesheet. */
+export class CompilerRegistry extends StaticStage {
+  /** @param {object} options - See compileStylesheet */
+  constructor(options) {
+    super(options);
+    /** @type {Array<() => void>} checks run once everything is compiled */
+    this.deferred = [];
+    this.attributeSets = new Map();
+    /** @type {Map<string, object>} */
+    this.namedTemplates = new Map();
+    /** @type {Map<string, Mode>} */
+    this.modes = new Map();
+    this.allModeRules = [];
+    this.keys = new Map();
+    this.functionBodies = new Map();
+    this.declarationPrecedence = new WeakMap();
+    this.positions = 0;
+    this.globalKeys = [];
+    this.globalVars = null;
+  }
+
+  /** @param {string[]} keys - Clark names of the global variables */
+  setGlobals(keys) {
+    this.globalKeys = keys;
+    let vars = null;
+    for (const key of keys) vars = { key, next: vars };
+    this.globalVars = vars;
+  }
+
+  /** @returns {{vars: object|null}} the scope of top-level declarations */
+  globalScope() {
+    return { vars: this.globalVars };
+  }
+
+  /** @returns {number} the next declaration position */
+  nextPosition() {
+    return this.positions++;
+  }
+
+  /**
+   * @param {Element} element - A top-level declaration
+   * @returns {number} its import precedence
+   */
+  precedenceOf(element) {
+    return this.declarationPrecedence.get(element) ?? 0;
+  }
+
+  /**
+   * Registers a named template (the highest precedence wins).
+   * @param {string} key
+   * @param {object} template
+   */
+  addNamedTemplate(key, template) {
+    const current = this.namedTemplates.get(key);
+    if (current && current.precedence === template.precedence) {
+      throw xsltError("XTSE0660", `Two templates are named ${key}`);
+    }
+    if (!current || current.precedence < template.precedence) {
+      this.namedTemplates.set(key, template);
+    }
+  }
+
+  /**
+   * Gets or creates a mode.
+   * @param {string} name - Clark name, "" for the unnamed mode
+   * @returns {Mode}
+   */
+  mode(name) {
+    let mode = this.modes.get(name);
+    if (!mode) {
+      mode = new Mode(name);
+      for (const rule of this.allModeRules) mode.add({ ...rule });
+      this.modes.set(name, mode);
+    }
+    return mode;
+  }
+
+  /**
+   * Adds a template rule to a mode ("#all": every mode).
+   * @param {string} name
+   * @param {object} rule
+   */
+  addRule(name, rule) {
+    if (name === "#all") {
+      this.allModeRules.push(rule);
+      for (const mode of this.modes.values()) mode.add({ ...rule });
+    } else this.mode(name).add(rule);
+  }
+
+  /** Makes sure the unnamed mode exists. */
+  finishModes() {
+    this.mode("");
+  }
+
+  /**
+   * Resolves the mode attribute of xsl:apply-templates.
+   * @param {string|undefined} text
+   * @param {Element} element
+   * @returns {{current: boolean, name: string}}
+   */
+  modeRef(text, element) {
+    const token = text?.trim();
+    if (token === "#current") return { current: true, name: "" };
+    if (token === undefined || token === "#default") {
+      return { current: false, name: infoOf(element).defaultMode };
+    }
+    if (token === "#unnamed") return { current: false, name: "" };
+    if (tokens(token).length !== 1) {
+      throw xsltError("XTSE0550", `Invalid mode ${text}`);
+    }
+    const name = this.exprs.qname(token, element);
+    return { current: false, name: `{${name.uri}}${name.local}` };
+  }
+
+  /**
+   * Static checks of xsl:call-template once all templates are known.
+   * @param {string} key
+   * @param {{names: Set<string>}} params - Its xsl:with-param children
+   * @param {Element} element
+   */
+  checkCall(key, params, element) {
+    const template = this.namedTemplates.get(key);
+    if (!template) {
+      throw xsltError("XTSE0650", `No template named ${displayName(key)}`);
+    }
+    const declared = new Set(
+      template.params.filter((p) => !p.tunnel).map((p) => p.key),
+    );
+    for (const name of params.names) {
+      if (!declared.has(name) && infoOf(element).version >= 2) {
+        throw xsltError(
+          "XTSE0680",
+          `The template ${key} has no parameter ${name}`,
+        );
+      }
+    }
+    for (const param of template.params) {
+      if (param.required && !param.tunnel && !params.names.has(param.key)) {
+        throw xsltError("XTSE0690", `The parameter ${param.key} is required`);
+      }
+    }
+  }
+
+  /**
+   * The function library definition of a stylesheet function.
+   * @param {object} signature
+   * @returns {object}
+   */
+  functionDefinition(signature) {
+    // filled by compileFunction once every signature is known
+    const compiled = { params: [], body: [], convert: null };
+    this.functionBodies.set(signature.key, compiled);
+    return {
+      namespace: signature.uri,
+      local: signature.local,
+      params: Array(signature.arity).fill("item()*"),
+      returns: "item()*",
+      impl: (args, context) => callFunction(compiled, args, context),
+      // xsl:evaluate sees the public and final functions only
+      visibility:
+        attr(signature.declaration.element, "visibility")?.trim() ?? "private",
+    };
+  }
+
+  /**
+   * The XPath context in which a pattern's predicates are evaluated.
+   * @param {*} item - The node a step of the pattern tests
+   * @param {object} xc - XSLT context (its item is the item matched)
+   * @param {boolean} [local] - The pattern sees the local variables of xc
+   * @returns {object}
+   */
+  patternContext(item, xc, local = false) {
+    const dyn = Object.create(xc.tx.dyn);
+    dyn.xc = xc;
+    // no current output URI in patterns (XSLT 3.0 section 20.3.?)
+    dyn.dynamicCall = true;
+    useStaticContext(dyn, xc.tx.stylesheet.sc);
+    const env = local ? xc.env : xc.tx.globalEnv;
+    return { item, position: 1, size: 1, env, dyn };
+  }
+
+  /**
+   * The parameters of a named output definition.
+   * @param {string|null} name - Lexical QName, null for the unnamed one
+   * @param {Element} element - Element on which the name is written
+   * @param {object} [overrides] - Parameters that take precedence (those
+   *   of an xsl:result-document)
+   * @returns {object}
+   */
+  outputFor(name, element, overrides = {}) {
+    let output = this.outputs.get("") ?? {};
+    if (name !== null) {
+      const qname = this.exprs.qname(name, element, { code: "XTDE1460" });
+      output = this.outputs.get(`{${qname.uri}}${qname.local}`);
+      if (!output) throw xsltError("XTDE1460", `No output definition ${name}`);
+    }
+    const params = { ...output, ...overrides };
+    if (params["item-separator"] === "#absent") delete params["item-separator"];
+    // The default html-version is implementation-defined (XSLT 3.0 section
+    // 26.1): HTML 4.01, as in XSLT 1.0 and 2.0, for an XSLT 1.0 or 2.0
+    // principal stylesheet module, else HTML5.
+    if (
+      (params.method === undefined || params.method === "html") &&
+      params["html-version"] === undefined &&
+      params.version === undefined &&
+      infoOf(this.tree.root).version < 3
+    ) {
+      params["html-version"] = "4.01";
+    }
+    if (params["use-character-maps"]) {
+      params["use-character-maps"] = expandCharacterMaps(
+        params["use-character-maps"],
+        this.characterMaps,
+      );
+    }
+    return params;
+  }
+}

package/src/xslt/compiler/staticStage.js

@@ -0,0 +1,197 @@
+/**
+ * The static stage of compilation (XSLT 3.0 section 3.13): stylesheet
+ * modules loaded, elements kept or dropped by use-when, static variables
+ * and parameters evaluated in document order, shadow attributes
+ * replaced by their values.
+ *
+ * @module @tradik/xslt3/xslt/compiler/staticStage
+ */
+
+import { toSequence } from "../../xpath/eval/values.js";
+import { stringItem } from "../../xpath/eval/atomics.js";
+import {
+  attr,
+  clarkOf,
+  isXsl,
+  resolveQName,
+  setShadowAttributes,
+  XSL_NS,
+  xsltError,
+} from "../names.js";
+import { significantChildren } from "./children.js";
+import { forgetInfo, infoOf } from "./elementInfo.js";
+import {
+  isModuleReference,
+  loadModuleDocument,
+  preloadModule,
+} from "./moduleLoading.js";
+import { declareConsistently } from "./staticVariables.js";
+import { evaluateStatic, evaluateStaticAvt, useWhen } from "./useWhen.js";
+
+/**
+ * @param {Element} element
+ * @returns {boolean} whether an element declares a static variable or
+ *   parameter
+ */
+const isStaticDeclaration = (element) =>
+  (isXsl(element, "variable") || isXsl(element, "param")) &&
+  ["yes", "true", "1"].includes(attr(element, "static")?.trim()) &&
+  (isXsl(element.parentNode, "stylesheet") ||
+    isXsl(element.parentNode, "transform") ||
+    isXsl(element.parentNode, "package"));
+
+/** Module loading and the static stage. */
+export class StaticStage {
+  /**
+   * @param {object} options - See compileStylesheet: `loadStylesheet`,
+   *   `parse`, `staticParams` (Map of Clark names to values)
+   */
+  constructor(options) {
+    this.options = options;
+    /** @type {Map<string, Array>} static variables by Clark name */
+    this.statics = new Map();
+    /** @type {Map<string, Document>} stylesheet modules by URI */
+    this.moduleDocuments = new Map();
+    this.childCache = new WeakMap();
+    this.includedCache = new WeakMap();
+    /** @type {Map<string, Document|Element>} loaded modules by URI */
+    this.loadedModules = new Map();
+    /** @type {Map<string, object>} static declarations by Clark name */
+    this.staticDeclarations = new Map();
+    /** @type {number[]} the xsl:import elements being loaded, outermost first */
+    this.importPath = [];
+    this.imports = 0;
+    /** @type {Set<string>} modules being loaded ahead (cycles) */
+    this.preloading = new Set();
+    // static expressions parse XML and build nodes with the XML parser
+    const parse = (text) => options.parse(text);
+    this.resources = {
+      xmlParser: parse,
+      createDocument: () => {
+        const document = parse("<x/>");
+        document.removeChild(document.documentElement);
+        return document;
+      },
+    };
+  }
+
+  /**
+   * @param {Element} element
+   * @returns {Array<Element|object>} the significant children
+   */
+  children(element) {
+    let children = this.childCache.get(element);
+    if (!children) {
+      children = significantChildren(element, (child) => this.included(child));
+      this.childCache.set(element, children);
+    }
+    return children;
+  }
+
+  /**
+   * Whether use-when keeps an element; a kept element has its shadow
+   * attributes evaluated, and a static declaration is evaluated.
+   * @param {Element} element
+   * @returns {boolean}
+   */
+  included(element) {
+    let included = this.includedCache.get(element);
+    if (included === undefined) {
+      // a shadow use-when (_use-when) is evaluated before the condition
+      const early = element.hasAttribute?.("_use-when");
+      if (early) this.applyShadows(element);
+      included = useWhen(element, this.statics, this.resources);
+      this.includedCache.set(element, included);
+      if (included) {
+        if (!early) this.applyShadows(element);
+        if (isStaticDeclaration(element)) this.declareStatic(element);
+        if (isModuleReference(element)) this.preload(element);
+      }
+    }
+    return included;
+  }
+
+  /**
+   * Evaluates the shadow attributes (`_name`) of an XSLT element.
+   * @param {Element} element
+   */
+  applyShadows(element) {
+    if (element.namespaceURI !== XSL_NS) return;
+    const values = new Map();
+    for (const attribute of element.attributes) {
+      const name = attribute.name;
+      if (!name.startsWith("_") || attribute.namespaceURI) continue;
+      const value = evaluateStaticAvt(
+        attribute.value,
+        element,
+        this.statics,
+        this.resources,
+      );
+      values.set(name.slice(1), value);
+    }
+    if (values.size > 0) {
+      setShadowAttributes(element, values);
+      forgetInfo(element);
+    }
+  }
+
+  /**
+   * Evaluates a static variable or parameter.
+   * @param {Element} element
+   */
+  declareStatic(element) {
+    const name = attr(element, "name");
+    if (name === undefined) {
+      throw xsltError("XTSE0010", "A static variable needs a name");
+    }
+    if (this.children(element).length > 0) {
+      throw xsltError(
+        attr(element, "select") === undefined ? "XTSE0010" : "XTSE0620",
+        "A static variable has no content",
+      );
+    }
+    if (
+      isXsl(element, "param") &&
+      ["yes", "true", "1"].includes(attr(element, "required")?.trim()) &&
+      attr(element, "select") !== undefined
+    ) {
+      throw xsltError("XTSE0010", "A required static parameter has no select");
+    }
+    const key = clarkOf(resolveQName(name, infoOf(element).namespaces));
+    const supplied = this.options.staticParams?.get?.(key);
+    const select = attr(element, "select");
+    let value;
+    if (isXsl(element, "param") && supplied !== undefined) {
+      value = toSequence(supplied);
+    } else if (select !== undefined) {
+      value = evaluateStatic(select, element, this.statics, this.resources);
+    } else {
+      // no select, no content: "" without "as", else the empty sequence
+      value = attr(element, "as") === undefined ? [stringItem("")] : [];
+    }
+    declareConsistently(this, key, {
+      element,
+      value,
+      path: [...this.importPath],
+    });
+  }
+
+  /**
+   * Loads the module of an xsl:import or xsl:include as soon as it is
+   * met (see moduleLoading.js).
+   * @param {Element} element
+   */
+  preload(element) {
+    preloadModule(this, element);
+  }
+
+  /**
+   * Loads an included or imported module (see moduleLoading.js).
+   * @param {string} uri - Absolute URI
+   * @param {string} [base] - Base URI it was resolved against
+   * @returns {Document|Element}
+   */
+  loadModule(uri, base) {
+    return loadModuleDocument(this, uri, base);
+  }
+}

package/src/xslt/compiler/staticVariables.js

@@ -0,0 +1,93 @@
+/**
+ * Static variables declared more than once (XSLT 3.0 section 9.7): a
+ * declaration that comes later in stylesheet tree order than one of
+ * lower import precedence must be consistent with it (the same value),
+ * else XTSE3450; one of lower precedence than an earlier declaration is
+ * left out. The precedence of declarations met in tree order is told by
+ * their import paths: a declaration inside an import of the module of
+ * another has the lower precedence.
+ *
+ * @module @tradik/xslt3/xslt/compiler/staticVariables
+ */
+
+import { isAtomic } from "../../xdm/atomic.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { xsltError } from "../names.js";
+
+/**
+ * A static declaration.
+ * @typedef {object} StaticDeclaration
+ * @property {Element} element
+ * @property {Array} value
+ * @property {number[]} path - The xsl:import elements it is inside
+ */
+
+/**
+ * @param {number[]} outer
+ * @param {number[]} inner
+ * @returns {boolean} whether `outer` is a prefix of `inner`
+ */
+const isPrefix = (outer, inner) =>
+  outer.length <= inner.length && outer.every((step, i) => inner[i] === step);
+
+/**
+ * Whether two declarations are consistent: the same kind (variable or
+ * param), type and value.
+ * @param {StaticDeclaration} a
+ * @param {StaticDeclaration} b
+ * @returns {boolean}
+ */
+const consistent = (a, b) =>
+  a.element.localName === b.element.localName &&
+  a.element.getAttribute("as")?.trim() ===
+    b.element.getAttribute("as")?.trim() &&
+  sameValue(a.value, b.value);
+
+/**
+ * @param {Array} a
+ * @param {Array} b
+ * @returns {boolean} whether two values are the same
+ */
+function sameValue(a, b) {
+  return (
+    a.length === b.length &&
+    a.every((item, i) => {
+      const other = b[i];
+      if (!isAtomic(item) || !isAtomic(other)) return item === other;
+      return (
+        item.type === other.type &&
+        canonicalString(item) === canonicalString(other)
+      );
+    })
+  );
+}
+
+/**
+ * Records a static variable, checked against an earlier declaration of
+ * the name.
+ * @param {{statics: Map, staticDeclarations: Map}} stage - The static
+ *   stage (values and declarations by Clark name)
+ * @param {string} key - Clark name
+ * @param {StaticDeclaration} declaration
+ * @throws {import("../../errors.js").XPathError} XTSE3450
+ */
+export function declareConsistently(stage, key, declaration) {
+  const earlier = stage.staticDeclarations.get(key);
+  if (earlier && earlier.element === declaration.element) return;
+  if (earlier && earlier.path.length !== declaration.path.length) {
+    // the earlier one is outside the import holding this one: it wins
+    if (isPrefix(earlier.path, declaration.path)) return;
+  }
+  if (
+    earlier &&
+    !isPrefix(earlier.path, declaration.path) &&
+    !consistent(earlier, declaration)
+  ) {
+    throw xsltError(
+      "XTSE3450",
+      `The static variable ${key} is declared with another value`,
+    );
+  }
+  stage.staticDeclarations.set(key, declaration);
+  stage.statics.set(key, declaration.value);
+}