xslt-processor 3.4.0 → 4.1.0

package/umd/xslt/xslt.d.ts

@@ -1,275 +0,0 @@
-import { XDocument, XNode, XmlParser } from '../dom';
-import { ExprContext, XPath } from '../xpath';
-import { XsltOptions } from './xslt-options';
-import { XsltDecimalFormatSettings } from './xslt-decimal-format-settings';
-import { MatchResolver } from '../xpath/match-resolver';
-/**
- * The main class for XSL-T processing. The implementation is NOT
- * complete; some xsl element are left out.
- *
- * References:
- *
- * [XSLT] XSL-T Specification
- * <http://www.w3.org/TR/1999/REC-xslt-19991116>.
- *
- * [ECMA] ECMAScript Language Specification
- * <http://www.ecma-international.org/publications/standards/Ecma-262.htm>.
- *
- * The XSL processor API has one entry point, the function
- * `xsltProcess()`. It receives as arguments the starting point in the
- * input document as an XPath expression context, the DOM root node of
- * the XSL-T stylesheet, and a DOM node that receives the output.
- *
- * NOTE: Actually, XSL-T processing according to the specification is
- * defined as operation on text documents, not as operation on DOM
- * trees. So, strictly speaking, this implementation is not an XSL-T
- * processor, but the processing engine that needs to be complemented
- * by an XML parser and serializer in order to be complete. Those two
- * are found in the `dom` folder.
- */
-export declare class Xslt {
-    xPath: XPath;
-    xmlParser: XmlParser;
-    matchResolver: MatchResolver;
-    options: XsltOptions;
-    decimalFormatSettings: XsltDecimalFormatSettings;
-    outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
-    outputOmitXmlDeclaration: string;
-    version: string;
-    firstTemplateRan: boolean;
-    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.
-     * @returns the processed document, as XML text in a string.
-     */
-    xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): Promise<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 If set, the output where the transformation should occur.
-     */
-    protected xsltProcessContext(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:apply-templates`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output. Only used if there's no corresponding output node already defined.
-     * @protected
-     */
-    protected xsltApplyTemplates(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:attribute`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output. Only used if there's no corresponding output node already defined.
-     * @protected
-     */
-    protected xsltAttribute(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:call-template`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output, used when a fragment is passed by a previous step.
-     */
-    protected xsltCallTemplate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:choose`, its child nodes `xsl:when`, and
-     * `xsl:otherwise`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output. Only used if there's no corresponding output node already defined.
-     */
-    protected xsltChoose(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:copy` for all node types.
-     * @param {XNode} destination the node being copied to, part of output document.
-     * @param {XNode} source the node being copied, part in input document.
-     * @returns {XNode|null} If an element node was created, the element node. Otherwise, null.
-     */
-    protected xsltCopy(destination: XNode, source: XNode): XNode;
-    /**
-     * Implements `xsl:comment`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output. Only used if there's no corresponding output node already defined.
-     */
-    protected xsltComment(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:copy-of` for node-set values of the select
-     * expression. Recurses down the source node tree, which is part of
-     * the input document.
-     * @param {XNode} destination the node being copied to, part of output document.
-     * @param {XNode} source the node being copied, part in input document.
-     */
-    protected xsltCopyOf(destination: XNode, source: XNode): void;
-    /**
-     * Implements `xsl:decimal-format`, registering the settings in this instance
-     * and the current context.
-     * @param context The Expression Context.
-     * @param template The template.
-     */
-    protected xsltDecimalFormat(context: ExprContext, template: XNode): void;
-    /**
-     * Implements `xsl:element`.
-     * @param context The Expression Context.
-     * @param template The template.
-     */
-    protected xsltElement(context: ExprContext, template: XNode): Promise<void>;
-    /**
-     * Implements `xsl:for-each`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output.
-     */
-    protected xsltForEach(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:if`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output.
-     */
-    protected xsltIf(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `<xsl:import>`. For now the code is nearly identical to `<xsl:include>`, but there's
-     * no precedence evaluation implemented yet.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output.
-     */
-    protected xsltImport(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:include`.
-     * @param context The Expression Context.
-     * @param template The template.
-     * @param output The output.
-     */
-    protected xsltInclude(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * Implements `xsl:key`.
-     * @param context The Expression Context.
-     * @param template The template.
-     */
-    protected xsltKey(context: ExprContext, template: XNode): void;
-    /**
-     * Orders the current node list in the input context according to the
-     * sort order specified by xsl:sort child nodes of the current
-     * template node. This happens before the operation specified by the
-     * current template node is executed.
-     * @param context The expression context.
-     * @param template The template node.
-     * @todo case-order is not implemented.
-     */
-    protected xsltSort(context: ExprContext, template: XNode): void;
-    /**
-     * Implements `xsl:template`.
-     * @param context The Expression Context.
-     * @param template The `<xsl:template>` node.
-     * @param output The output. In general, a fragment that will be used by
-     *               the caller.
-     */
-    protected xsltTemplate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    protected xsltText(context: ExprContext, template: XNode, output?: XNode): void;
-    /**
-     * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
-     * validations.
-     * @param context The Expression Context.
-     * @param template The `<xsl:stylesheet>` or `<xsl:transform>` node.
-     * @param output The output. In general, a fragment that will be used by
-     *               the caller.
-     */
-    protected xsltTransformOrStylesheet(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    protected xsltValueOf(context: ExprContext, template: XNode, output?: XNode): void;
-    /**
-     * Evaluates a variable or parameter and set it in the current input
-     * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
-     *
-     * @param context The expression context.
-     * @param template The template node.
-     * @param override flag that defines if the value computed here
-     * overrides the one already in the input context if that is the
-     * 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(context: ExprContext, template: XNode, override: boolean): Promise<void>;
-    /**
-     * Traverses the template node tree. Calls the main processing
-     * function with the current input context for every child node of the
-     * current template node.
-     * @param context Normally the Expression Context.
-     * @param template The XSL-T definition.
-     * @param output If set, the output where the transformation should occur.
-     */
-    protected xsltChildNodes(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
-    /**
-     * This logic is used in two different places:
-     * - `xsltPassThrough`, if the template asks this library to write a text node;
-     * - `xsltProcessContext`, `apply-templates` operation, when the current node is text.
-     *
-     * Text nodes always require a parent, and they never have children.
-     * @param context The Expression Context.
-     * @param template The template, that contains the node value to be written.
-     * @param output The output.
-     */
-    private commonLogicTextNode;
-    /**
-     * Passes template text to the output. The current template node does
-     * not specify an XSL-T operation and therefore is appended to the
-     * output with all its attributes. Then continues traversing the
-     * template node tree.
-     * @param context The Expression Context.
-     * @param template The XSLT stylesheet or transformation.
-     * @param output The output.
-     */
-    protected xsltPassThrough(context: ExprContext, template: XNode, output: XNode): Promise<void>;
-    /**
-     * Determines if a text node in the XSLT template document is to be
-     * stripped according to XSLT whitespace stripping rules.
-     * @see [XSLT], section 3.4.
-     * @param template The XSLT template.
-     * @returns TODO
-     * @todo Whitespace stripping on the input document is
-     * currently not implemented.
-     */
-    protected xsltPassText(template: XNode): boolean;
-    protected findAttributeInContext(attributeName: string, context: ExprContext): XNode;
-    /**
-     * Evaluates an XSL-T attribute value template. Attribute value
-     * templates are attributes on XSL-T elements that contain XPath
-     * expressions in braces {}. The XSL-T expressions are evaluated in
-     * the current input context.
-     * @param value TODO
-     * @param context TODO
-     * @returns TODO
-     */
-    protected xsltAttributeValue(value: any, context: ExprContext): any;
-    /**
-     * Evaluates an XPath expression in the current input context as a
-     * match.
-     * @see [XSLT] section 5.2, paragraph 1
-     * @param match 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, axis?: string): XNode[];
-    /**
-     * Sets parameters defined by xsl:with-param child nodes of the
-     * current template node, in the current input context. This happens
-     * before the operation specified by the current template node is
-     * executed.
-     * @param context The Expression Context.
-     * @param template The template node.
-     */
-    protected xsltWithParam(context: ExprContext, template: XNode): Promise<void>;
-    /**
-     * Test if the given element is an XSLT element, optionally the one with the given name.
-     * @param {XNode} element The element.
-     * @param {string} opt_wantedName The name for comparison.
-     * @returns True, if element is an XSL node. False otherwise.
-     */
-    protected isXsltElement(element: XNode, opt_wantedName?: string): boolean;
-}