Merge branch 'core-update' into beta.3

Author: dpvc

mathjax3-ts/core/DOMAdaptor.ts

@@ -571,8 +571,9 @@ export abstract class AbstractDOMAdaptor<N, T, D> implements DOMAdaptor<N, T, D>
      * @override
      */
     public allClasses(node: N) {
-        const classes = this.getAttribute(node, 'class') || '';
-        return classes.replace(/  +/g, ' ').replace(/^ /, '').replace(/ $/, '').split(/ /);
+        const classes = this.getAttribute(node, 'class');
+        return (!classes ? [] as string[] :
+                classes.replace(/  +/g, ' ').replace(/^ /, '').replace(/ $/, '').split(/ /));
     }
 
     /**

mathjax3-ts/core/Handler.ts

@@ -21,7 +21,7 @@
  * @author [email protected] (Davide Cervone)
  */
 
-import {MathDocument, AbstractMathDocument} from './MathDocument.js';
+import {MathDocument, AbstractMathDocument, MathDocumentConstructor} from './MathDocument.js';
 import {OptionList} from '../util/Options.js';
 import {DOMAdaptor} from '../core/DOMAdaptor.js';
 
@@ -50,6 +50,12 @@ export interface Handler<N, T, D> {
      */
     priority: number;
 
+    /**
+     * The class implementing the MathDocument for this handler
+     *   (so it can be subclassed by extensions as needed)
+     */
+    documentClass: MathDocumentConstructor<N, T, D>;
+
     /**
      * Checks to see if the handler can process a given document
      *
@@ -62,11 +68,10 @@ export interface Handler<N, T, D> {
      * Creates a MathDocument for the given handler
      *
      * @param {any} document        The document to be handled
-     * @param {DOMAdaptor} adaptor  The DOM adaptor for managing HTML elements
      * @param {OptionList} options  The options for the handling of the document
      * @return {MathDocument}       The MathDocument object that manages the processing
      */
-    create(document: any, adaptor: DOMAdaptor<N, T, D>, options: OptionList): MathDocument<N, T, D>;
+    create(document: any, options: OptionList): MathDocument<N, T, D>;
 }
 
 /*****************************************************************/
@@ -104,6 +109,12 @@ export abstract class AbstractHandler<N, T, D> implements Handler<N, T, D> {
      */
     public priority: number;
 
+    /**
+     * The class implementing the MathDocument for this handler
+     *   (so it can be subclassed by extensions as needed)
+     */
+    public documentClass: MathDocumentConstructor<N, T, D> = DefaultMathDocument;
+
     /**
      * @param {number} priority  The priority to use for this handler
      *
@@ -132,7 +143,7 @@ export abstract class AbstractHandler<N, T, D> implements Handler<N, T, D> {
      * @override
      */
     public create(document: any, options: OptionList) {
-        return new DefaultMathDocument<N, T, D>(document, this.adaptor, options) as MathDocument<N, T, D>;
+        return new this.documentClass(document, this.adaptor, options) as MathDocument<N, T, D>;
     }
 
 }

mathjax3-ts/core/HandlerList.ts

@@ -75,8 +75,8 @@ export class HandlerList<N, T, D> extends PrioritizedList<Handler<N, T, D>>  {
      * @param {OptionList} options  The options for the handler
      * @return {MathDocument}       The MathDocument created by the handler for this document
      */
-    public document(document: any, adaptor: DOMAdaptor<N, T, D>, options: OptionList = null) {
-        return this.handlesDocument(document).create(document, adaptor, options);
+    public document(document: any, options: OptionList = null) {
+        return this.handlesDocument(document).create(document, options);
     }
 
 }

mathjax3-ts/core/InputJax.ts

@@ -23,6 +23,7 @@
 
 import {MathItem, ProtoItem} from './MathItem.js';
 import {MmlNode} from './MmlTree/MmlNode.js';
+import {MmlFactory} from './MmlTree/MmlFactory.js';
 import {userOptions, defaultOptions, OptionList} from '../util/Options.js';
 import {FunctionList} from '../util/FunctionList.js';
 import {DOMAdaptor} from '../core/DOMAdaptor.js';
@@ -63,11 +64,21 @@ export interface InputJax<N, T, D> {
      */
     adaptor: DOMAdaptor<N, T, D>;
 
+    /**
+     * The MmlFactory for this input jax
+     */
+    mmlFactory: MmlFactory;
+
     /**
      * @param {DOMAdaptor}  The adaptor to use in this jax
      */
     setAdaptor(adaptor: DOMAdaptor<N, T, D>): void;
 
+    /**
+     * @param {MmlFactory}  The MmlFactory to use in this jax
+     */
+    setMmlFactory(mmlFactory: MmlFactory): void;
+
     /**
      * Finds the math within the DOM or the list of strings
      *
@@ -104,6 +115,7 @@ export abstract class AbstractInputJax<N, T, D> implements InputJax<N, T, D> {
     public preFilters: FunctionList;
     public postFilters: FunctionList;
     public adaptor: DOMAdaptor<N, T, D> = null;  // set by the handler
+    public mmlFactory: MmlFactory = null;        // set by the handler
 
     /**
      * @param {OptionList} options  The options to applyt to this input jax
@@ -131,6 +143,13 @@ export abstract class AbstractInputJax<N, T, D> implements InputJax<N, T, D> {
         this.adaptor = adaptor;
     }
 
+    /**
+     * @override
+     */
+    public setMmlFactory(mmlFactory: MmlFactory) {
+        this.mmlFactory = mmlFactory;
+    }
+
     /**
      * @return {boolean}  True means find math in string array, false means in DOM element
      */

mathjax3-ts/core/MathDocument.ts

@@ -29,6 +29,7 @@ import {MathItem, AbstractMathItem} from './MathItem.js';
 import {MmlNode, TextNode} from './MmlTree/MmlNode.js';
 import {MmlFactory} from '../core/MmlTree/MmlFactory.js';
 import {DOMAdaptor} from '../core/DOMAdaptor.js';
+import {BitField, BitFieldClass} from '../util/BitField.js';
 
 /*****************************************************************/
 /**
@@ -79,7 +80,7 @@ export interface MathDocument<N, T, D> {
      *  asynchronous operations are used), the ones that have already been
      *  completed won't be performed again.
      */
-    processed: {[name: string]: boolean};
+    processed: BitField;
 
     /**
      * An array of input jax to run on the document
@@ -96,6 +97,11 @@ export interface MathDocument<N, T, D> {
      */
     adaptor: DOMAdaptor<N, T, D>;
 
+    /**
+     * The MmlFactory to be used for input jax and error processing
+     */
+    mmlFactory: MmlFactory;
+
     /**
      * Locates the math in the document and constructs the MathList
      *  for the document.
@@ -178,19 +184,6 @@ export interface MathDocument<N, T, D> {
 }
 
 /*****************************************************************/
-/**
- *  The booleans used to keep track of what processing has been
- *  performed.
- */
-
-export type MathProcessed = {
-    findMath: boolean;
-    compile: boolean;
-    getMetrics: boolean;
-    typeset: boolean;
-    updateDocument: boolean;
-    [name: string]: boolean;
-};
 
 /**
  * Defaults used when input jax isn't specified
@@ -233,9 +226,14 @@ class DefaultOutputJax<N, T, D> extends AbstractOutputJax<N, T, D> {
  * @template D  The Document class
  */
 class DefaultMathList<N, T, D> extends AbstractMathList<N, T, D> {}
-
-let errorFactory = new MmlFactory();
-
+/**
+ * Default for the Mathitem when one isn't specified
+ *
+ * @template N  The HTMLElement node class
+ * @template T  The Text node class
+ * @template D  The Document class
+ */
+class DefaultMathItem<N, T, D> extends AbstractMathItem<N, T, D> {}
 
 /*****************************************************************/
 /**
@@ -251,7 +249,9 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
     public static OPTIONS: OptionList = {
         OutputJax: null,           // instance of an OutputJax for the document
         InputJax: null,            // instance of an InputJax or an array of them
-        MathList: DefaultMathList, // instance of a MathList to use for the document
+        MmlFactory: null,          // instance of a MmlFactory for this document
+        MathList: DefaultMathList, // constructor for a MathList to use for the document
+        MathItem: DefaultMathItem, // constructor for a MathItem to use for the MathList
         compileError: (doc: AbstractMathDocument<any, any, any>, math: MathItem<any, any, any>, err: Error) => {
             doc.compileError(math, err);
         },
@@ -261,32 +261,33 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
     };
     public static STATE = AbstractMathItem.STATE;
 
+    /**
+     * A bit-field for the actions that heve been processed
+     */
+    public static ProcessBits = BitFieldClass('findMath', 'compile', 'getMetrics', 'typeset', 'updateDocument');
+
     public document: D;
     public options: OptionList;
     public math: MathList<N, T, D>;
-    public processed: MathProcessed;
+    public processed: BitField;
     public inputJax: InputJax<N, T, D>[];
     public outputJax: OutputJax<N, T, D>;
     public adaptor: DOMAdaptor<N, T, D>;
+    public mmlFactory: MmlFactory;
 
 
     /**
-     * @param {any} document        The document (HTML string, parsed DOM, etc.) to be processed
-     * @param {OptionList} options  The options for this document
+     * @param {any} document           The document (HTML string, parsed DOM, etc.) to be processed
+     * @param {DOMAdaptor} adaptor     The DOM adaptor for this document
+     * @param {OptionList} options     The options for this document
      * @constructor
      */
     constructor (document: any, adaptor: DOMAdaptor<N, T, D>, options: OptionList) {
         let CLASS = this.constructor as typeof AbstractMathDocument;
         this.document = document;
         this.options = userOptions(defaultOptions({}, CLASS.OPTIONS), options);
         this.math = new (this.options['MathList'] || DefaultMathList)();
-        this.processed = {
-            findMath: false,
-            compile: false,
-            typeset: false,
-            getMetrics: false,
-            updateDocument: false
-        };
+        this.processed = new AbstractMathDocument.ProcessBits();
         this.outputJax = this.options['OutputJax'] || new DefaultOutputJax<N, T, D>();
         let inputJax = this.options['InputJax'] || [new DefaultInputJax<N, T, D>()];
         if (!Array.isArray(inputJax)) {
@@ -299,6 +300,11 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
         this.adaptor = adaptor;
         this.outputJax.setAdaptor(adaptor);
         this.inputJax.map(jax => jax.setAdaptor(adaptor));
+        //
+        // Pass the MmlFactory to the jax
+        //
+        this.mmlFactory = this.options['MmlFactory'] || new MmlFactory();
+        this.inputJax.map(jax => jax.setMmlFactory(this.mmlFactory));
     }
 
     /**
@@ -312,15 +318,15 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
      * @override
      */
     public findMath(options: OptionList = null) {
-        this.processed.findMath = true;
+        this.processed.set('findMath');
         return this;
     }
 
     /**
      * @override
      */
     public compile() {
-        if (!this.processed.compile) {
+        if (!this.processed.isSet('compile')) {
             for (const math of this.math) {
                 try {
                     math.compile(this);
@@ -332,7 +338,7 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
                     math.inputData['error'] = err;
                 }
             }
-            this.processed.compile = true;
+            this.processed.set('compile');
         }
         return this;
     }
@@ -344,10 +350,10 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
      * @param {Error} err      The Error object for the error
      */
     public compileError(math: MathItem<N, T, D>, err: Error) {
-        math.root = errorFactory.create('math', {'data-mjx-error': err.message}, [
-            errorFactory.create('merror', null, [
-                errorFactory.create('mtext', null, [
-                    (errorFactory.create('text') as TextNode).setText('Math input error')
+        math.root = this.mmlFactory.create('math', {'data-mjx-error': err.message}, [
+            this.mmlFactory.create('merror', null, [
+                this.mmlFactory.create('mtext', null, [
+                    (this.mmlFactory.create('text') as TextNode).setText('Math input error')
                 ])
             ])
         ]);
@@ -360,7 +366,7 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
      * @override
      */
     public typeset() {
-        if (!this.processed.typeset) {
+        if (!this.processed.isSet('typeset')) {
             for (const math of this.math) {
                 try {
                     math.typeset(this);
@@ -372,7 +378,7 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
                     math.outputData['error'] = err;
                 }
             }
-            this.processed.typeset = true;
+            this.processed.set('typeset');
         }
         return this;
     }
@@ -393,9 +399,9 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
      * @override
      */
     public getMetrics() {
-        if (!this.processed.getMetrics) {
+        if (!this.processed.isSet('getMetrics')) {
             this.outputJax.getMetrics(this);
-            this.processed.getMetrics = true;
+            this.processed.set('getMetrics');
         }
         return this;
     }
@@ -404,11 +410,11 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
      * @override
      */
     public updateDocument() {
-        if (!this.processed.updateDocument) {
+        if (!this.processed.isSet('updateDocument')) {
             for (const math of this.math.reversed()) {
                 math.updateDocument(this);
             }
-            this.processed.updateDocument = true;
+            this.processed.set('updateDocument');
         }
         return this;
     }
@@ -428,14 +434,14 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
             math.state(state, restore);
         }
         if (state < STATE.INSERTED) {
-            this.processed.updateDocument = false;
+            this.processed.clear('updateDocument');
         }
         if (state < STATE.TYPESET) {
-            this.processed.typeset = false;
-            this.processed.getMetrics = false;
+            this.processed.clear('typeset');
+            this.processed.clear('getMetrics');
         }
         if (state < STATE.COMPILED) {
-            this.processed.compile = false;
+            this.processed.clear('compile');
         }
         return this;
     }
@@ -444,9 +450,7 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
      * @override
      */
     public reset() {
-        for (const key of Object.keys(this.processed)) {
-            this.processed[key] = false;
-        }
+        this.processed.reset();
         return this;
     }
 
@@ -470,3 +474,10 @@ export abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T
 }
 
 let STATE = AbstractMathDocument.STATE;
+
+/**
+ * The constructor type for a MathDocument
+ */
+export type MathDocumentConstructor<N, T, D> = {
+    new (document: any, adaptor: DOMAdaptor<N, T, D>, options: OptionList): AbstractMathDocument<N, T, D>;
+};