xslt-processor 1.1.5 → 1.2.0

package/umd/xpath/xpath.d.ts

@@ -1,5 +1,6 @@
 import { ExprContext } from './expr-context';
 import { BinaryExpr, FunctionCallExpr, LiteralExpr, LocationExpr, NumberExpr, PathExpr, PredicateExpr, StepExpr, TokenExpr, UnaryMinusExpr, UnionExpr, VariableExpr } from './expressions';
+import { Expression } from './expressions/expression';
 import { NodeTestAny } from './node-test-any';
 import { NodeTestComment } from './node-test-comment';
 import { NodeTestElementOrAttribute } from './node-test-element-or-attribute';
@@ -19,6 +20,12 @@ export declare class XPath {
     }[] | ((rel: any, slash: any, step: any) => any))[] | (number | {
         label: string;
         key: any;
+    } | {
+        label: string;
+        key: any;
+    }[] | ((nodeTest: any, axis?: string) => StepExpr))[] | (number | {
+        label: string;
+        key: any;
     } | {
         label: string;
     }[] | ((name: any, pareno: any, arg1: any, args: any) => FunctionCallExpr))[] | (number | {
@@ -45,9 +52,9 @@ export declare class XPath {
     makeLocationExpr7(rel: any, dslash: any, step: any): any;
     makeStepExpr1(dot: any): StepExpr;
     makeStepExpr2(ddot: any): StepExpr;
-    makeStepExpr3(axisname: any, axis: any, nodetest: any): StepExpr;
-    makeStepExpr4(at: any, nodetest: any): StepExpr;
-    makeStepExpr5(nodetest: any): StepExpr;
+    makeStepExpr3(axisname: any, axis: any, nodeTest: any): StepExpr;
+    makeStepExpr4(at: any, nodeTest: any): StepExpr;
+    makeStepExpr5(nodeTest: any, axis?: string): StepExpr;
     makeStepExpr6(step: any, predicate: any): any;
     makeAbbrevStep(abbrev: any): StepExpr;
     makeNodeTestExpr1(): NodeTestElementOrAttribute;
@@ -69,37 +76,45 @@ export declare class XPath {
     makeLiteralExpr(token: any): LiteralExpr;
     makeNumberExpr(token: any): NumberExpr;
     makeVariableReference(dollar: any, name: any): VariableExpr;
-    makeSimpleExpr(expr: any): LocationExpr | NumberExpr | VariableExpr;
+    /**
+     * Used before parsing for optimization of common simple cases. See
+     * the begin of xPathParse() for which they are.
+     * @param expression The XPath expression.
+     * @param axis The axis, if required. Default is 'child'.
+     * @returns An `Expression` object.
+     */
+    makeSimpleExpr(expression: string, axis?: string): Expression;
     makeSimpleExpr2(expr: any): LocationExpr;
     stackToString(stack: any[]): string;
     xPathCacheLookup(expr: any): any;
-    xPathCollectDescendants(nodelist: any, node: any, opt_tagName?: any): void;
-    xPathCollectDescendantsReverse(nodelist: any, node: any): void;
+    xPathCollectDescendants(nodeList: any, node: any, opt_tagName?: any): void;
+    xPathCollectDescendantsReverse(nodeList: any, node: any): void;
     xPathEval(select: string, context: ExprContext): any;
     /**
      * DGF - extract a tag name suitable for getElementsByTagName
      *
-     * @param nodetest                     the node test
+     * @param nodeTest                     the node test
      * @param ignoreNonElementNodesForNTA  if true, the node list returned when
      *                                     evaluating "node()" will not contain
      *                                     non-element nodes. This can boost
      *                                     performance. This is false by default.
      */
-    xPathExtractTagNameFromNodeTest(nodetest: any, ignoreNonElementNodesForNTA: any): string;
+    xPathExtractTagNameFromNodeTest(nodeTest: any, ignoreNonElementNodesForNTA: any): string;
     xPathMatchStack(stack: any, pattern: any): any;
     /**
      * The entry point for the parser.
-     * @param expr a string that contains an XPath expression.
+     * @param expression a string that contains an XPath expression.
+     * @param axis The XPath axis. Used when the match does not start with the parent.
      * @param xPathLog TODO
      * @returns an expression object that can be evaluated with an
      * expression context.
      */
-    xPathParse(expr: any, xPathLog?: (message: string) => void): any;
+    xPathParse(expression: string, axis?: string, xPathLog?: (message: string) => void): any;
     xPathParseInit(xPathLog: Function): void;
-    xPathReduce(stack: any, ahead: any, xpathLog?: (message: string) => void): any;
+    xPathReduce(stack: any, ahead: any, axis?: string, xpathLog?: (message: string) => void): any;
     xPathSort(context: ExprContext, sort: any[]): void;
     xPathSortByKey(v1: any, v2: any): number;
-    xPathStep(nodes: any[], steps: any[], step: any, input: any, ctx: ExprContext): void;
+    xPathStep(nodes: any[], steps: any[], step: any, input: any, context: ExprContext): void;
     xPathGrammarPrecedence(frame: any): number;
     xPathTokenPrecedence(tag: any): any;
 }

package/umd/xslt/xslt-options.d.ts

@@ -1,5 +1,6 @@
 import { XsltParameter } from "./xslt-parameter";
 export type XsltOptions = {
     escape: boolean;
+    selfClosingTags: boolean;
     parameters?: XsltParameter[];
 };

package/umd/xslt/xslt.d.ts

@@ -1,7 +1,6 @@
 import { XDocument, XNode } from '../dom';
 import { ExprContext, XPath } from '../xpath';
 import { XsltOptions } from './xslt-options';
-import { XsltParameter } from './xslt-parameter';
 /**
  * The main class for XSL-T processing. The implementation is NOT
  * complete; some xsl element are left out.
@@ -29,25 +28,24 @@ import { XsltParameter } from './xslt-parameter';
 export declare class Xslt {
     xPath: XPath;
     options: XsltOptions;
+    outputDocument: XDocument;
     outputMethod: string;
     outputOmitXmlDeclaration: string;
-    constructor(options?: XsltOptions);
+    constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
      * @param xmlDoc The input document root, as DOM node.
      * @param stylesheet The stylesheet document root, as DOM node.
-     * @param parameters Additional parameters to be set as variables.
      * @returns the processed document, as XML text in a string.
      */
-    xsltProcess(xmlDoc: XDocument, stylesheet: XDocument, parameters?: XsltParameter[]): string;
+    xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): string;
     /**
      * The main entry point of the XSL-T processor, as explained on the top of the file.
      * @param context The input document root, as XPath ExprContext.
      * @param template The stylesheet document root, as DOM node.
      * @param output the root of the generated output, as DOM node.
-     * @param _parameters Extra parameters.
      */
-    protected xsltProcessContext(context: ExprContext, template: XNode, output: XNode, _parameters: XsltParameter[]): void;
+    protected xsltProcessContext(context: ExprContext, template: XNode, output: XNode): void;
     /**
      * Implements `xsl:copy` for all node types.
      * @param {XNode} destination the node being copied to, part of output document
@@ -77,7 +75,7 @@ export declare class Xslt {
      * case. I.e. decides if this is a default value or a local
      * value. `xsl:variable` and `xsl:with-param` override; `xsl:param` doesn't.
      */
-    protected xsltVariable(input: ExprContext, template: any, override: boolean, _parameters: XsltParameter[]): void;
+    protected xsltVariable(input: ExprContext, template: any, override: boolean): void;
     /**
      * Implements xsl:choose and its child nodes xsl:when and
      * xsl:otherwise.
@@ -85,14 +83,14 @@ export declare class Xslt {
      * @param template The template.
      * @param output The output.
      */
-    protected xsltChoose(input: ExprContext, template: any, output: any, _parameters: XsltParameter[]): void;
+    protected xsltChoose(input: ExprContext, template: any, output: any): void;
     /**
      * Implements `xsl:for-each`.
      * @param input The Expression Context.
      * @param template The template.
      * @param output The output.
      */
-    protected xsltForEach(context: ExprContext, template: XNode, output: XNode, _parameters: XsltParameter[]): void;
+    protected xsltForEach(context: ExprContext, template: XNode, output: XNode): void;
     protected groupBy(xs: any, key: any): any;
     /**
      * Traverses the template node tree. Calls the main processing
@@ -102,7 +100,7 @@ export declare class Xslt {
      * @param template The XSL-T definition.
      * @param output The XML output.
      */
-    protected xsltChildNodes(context: ExprContext, template: any, output: XNode, _parameters: XsltParameter[]): void;
+    protected xsltChildNodes(context: ExprContext, template: XNode, output: XNode): void;
     /**
      * Passes template text to the output. The current template node does
      * not specify an XSL-T operation and therefore is appended to the
@@ -111,9 +109,8 @@ export declare class Xslt {
      * @param context The Expression Context.
      * @param template The XSLT stylesheet or transformation.
      * @param output The output.
-     * @param outputDocument The output document, if the case.
      */
-    protected xsltPassThrough(context: ExprContext, template: any, output: XNode, outputDocument: XDocument, _parameters?: XsltParameter[]): void;
+    protected xsltPassThrough(context: ExprContext, template: XNode, output: XNode): void;
     /**
      * Determines if a text node in the XSLT template document is to be
      * stripped according to XSLT whitespace stripping rules.
@@ -148,11 +145,30 @@ export declare class Xslt {
      * match.
      * @see [XSLT] section 5.2, paragraph 1
      * @param match TODO
-     * @param context TODO
-     * @returns TODO
+     * @param context The Expression Context.
+     * @param axis The XPath axis. Used when the match does not start with the parent.
+     * @returns {XNode[]} A list of the found nodes.
      */
-    protected xsltMatch(match: string, context: ExprContext): any;
+    protected xsltMatch(match: string, context: ExprContext, axis?: string): XNode[];
     private xsltLocationExpressionMatch;
+    /**
+     * Finds all the nodes through absolute xPath search.
+     * Returns only nodes that match either the context position node,
+     * or an ancestor.
+     * @param expression The Expression.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private absoluteXsltMatch;
+    /**
+     * Tries to find relative nodes from the actual context position.
+     * If found nodes are already in the context, or if they are children of
+     * nodes in the context, they are returned.
+     * @param expression The expression used.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private relativeXsltMatch;
     /**
      * Sets parameters defined by xsl:with-param child nodes of the
      * current template node, in the current input context. This happens
@@ -161,8 +177,6 @@ export declare class Xslt {
      * @param input TODO
      * @param template TODO
      */
-    protected xsltWithParam(input: ExprContext, template: any, _parameters: XsltParameter[]): void;
-    private absoluteXsltMatch;
-    private relativeXsltMatch;
+    protected xsltWithParam(input: ExprContext, template: any): void;
     protected isXsltElement(element: any, opt_wantedName?: string): boolean;
 }