Merge pull request #1096 from mathjax/refactor/mappings

refactors and simplifies macro mappings

Author: zorkow

ts/input/tex/TokenMap.ts

@@ -156,7 +156,7 @@ export class RegExpMap extends AbstractTokenMap<string> {
    * @extends {AbstractTokenMap}
    * @param {string} name Name of the mapping.
    * @param {ParseMethod} parser The parser for the mappiong.
-   * @param {RegExp} regexp The regular expression.
+   * @param {RegExp} _regExp The regular expression.
    */
   constructor(name: string, parser: ParseMethod, private _regExp: RegExp) {
     super(name, parser);
@@ -271,6 +271,8 @@ export class DelimiterMap extends CharacterMap {
 }
 
 
+type ParseFunction = string | ParseMethod;
+
 /**
  * Maps macros that all bring their own parsing method.
  *
@@ -283,17 +285,26 @@ export class MacroMap extends AbstractParseMap<Macro> {
    * @constructor
    * @param {string} name Name of the mapping.
    * @param {JSON} json The JSON representation of the macro map.
-   * @param {{[key: string]: ParseMethod}} functionMap Collection of parse
-   *     functions for the single macros.
+   * @param {{[key: string]: ParseMethod}} functionMap Optionally a collection
+   *     of parse functions for the single macros. Kept for backward compatibility.
    */
   constructor(name: string,
-              json: {[index: string]: string | Args[]},
-              functionMap: {[key: string]: ParseMethod}) {
+              json: {[index: string]: ParseFunction | [ParseFunction, ...Args[]]},
+              functionMap: {[key: string]: ParseMethod} = {}) {
     super(name, null);
-    for (const key of Object.keys(json)) {
-      let value = json[key];
-      let [func, ...attrs] = (typeof(value) === 'string') ? [value] : value;
-      let character = new Macro(key, functionMap[func as string], attrs);
+    const getMethod = (func: ParseFunction) =>
+      (typeof func === 'string') ? functionMap[func] : func;
+    for (const [key, value] of Object.entries(json)) {
+      let func: ParseFunction;
+      let args: Args[];
+      if (Array.isArray(value)) {
+        func = getMethod(value[0]);
+        args = value.slice(1) as Args[];
+      } else {
+        func = getMethod(value);
+        args = [];
+      }
+      let character = new Macro(key, func, args);
       this.add(key, character);
     }
   }
@@ -365,13 +376,13 @@ export class EnvironmentMap extends MacroMap {
    * @param {string} name Name of the mapping.
    * @param {ParseMethod} parser The parser for the environments.
    * @param {JSON} json The JSON representation of the macro map.
-   * @param {{[key: string]: ParseMethod}} functionMap Collection of parse
-   *     functions for the single macros.
+   * @param {{[key: string]: ParseMethod}} functionMap Optionally a collection
+   *     of parse functions for the single macros. Kept for backward compatibility.
    */
   constructor(name: string,
               parser: ParseMethod,
-              json: {[index: string]: string | Args[]},
-              functionMap: {[key: string]: ParseMethod}) {
+              json: {[index: string]: ParseFunction | [ParseFunction, ...Args[]]},
+              functionMap: {[key: string]: ParseMethod} = {}) {
     super(name, json, functionMap);
     this.parser = parser;
   }

ts/input/tex/action/ActionConfiguration.ts

@@ -69,10 +69,10 @@ export const ActionMethods: {[key: string]: ParseMethod} = {
 }
 
 new CommandMap('action-macros', {
-  toggle:  'Toggle',
-  mathtip: 'Mathtip',
-  texttip: ['Macro', '\\mathtip{#1}{\\text{#2}}', 2]
-}, ActionMethods);
+  toggle:  ActionMethods.Toggle,
+  mathtip: ActionMethods.Mathtip,
+  texttip: [ActionMethods.Macro, '\\mathtip{#1}{\\text{#2}}', 2]
+});
 
 
 export const ActionConfiguration = Configuration.create(

ts/input/tex/ams/AmsConfiguration.ts

@@ -44,7 +44,7 @@ export class AmsTags extends AbstractTags { }
  * @param {ParserConfiguration} config The current configuration.
  */
 let init = function(config: ParserConfiguration) {
-  new CommandMap(NEW_OPS, {}, {});
+  new CommandMap(NEW_OPS, {});
   config.append(Configuration.local({handler: {macro: [NEW_OPS]},
                                     priority: -1}));
 };

ts/input/tex/ams/AmsMappings.ts

@@ -47,93 +47,93 @@ new sm.RegExpMap('AMSmath-operatorLetter', AmsMethods.operatorLetter, /[-*]/i);
  * Macros from the AMS Math package.
  */
 new sm.CommandMap('AMSmath-macros', {
-  mathring:   ['Accent', '02DA'],  // or 0x30A
-  nobreakspace: 'Tilde',
-  negmedspace:    ['Spacer', MATHSPACE.negativemediummathspace],
-  negthickspace:  ['Spacer', MATHSPACE.negativethickmathspace],
+  mathring:   [AmsMethods.Accent, '02DA'],  // or 0x30A
+  nobreakspace: AmsMethods.Tilde,
+  negmedspace:    [AmsMethods.Spacer, MATHSPACE.negativemediummathspace],
+  negthickspace:  [AmsMethods.Spacer, MATHSPACE.negativethickmathspace],
 
-  idotsint:   ['MultiIntegral', '\\int\\cdots\\int'],
+  idotsint:   [AmsMethods.MultiIntegral, '\\int\\cdots\\int'],
 
-  dddot:      ['Accent', '20DB'],
-  ddddot:     ['Accent', '20DC'],
+  dddot:      [AmsMethods.Accent, '20DB'],
+  ddddot:     [AmsMethods.Accent, '20DC'],
 
-  sideset:     'SideSet',
+  sideset:     AmsMethods.SideSet,
 
-  boxed:      ['Macro', '\\fbox{$\\displaystyle{#1}$}', 1],
+  boxed:      [AmsMethods.Macro, '\\fbox{$\\displaystyle{#1}$}', 1],
 
-  tag:         'HandleTag',
-  notag:       'HandleNoTag',
-  eqref:       ['HandleRef', true],
+  tag:         AmsMethods.HandleTag,
+  notag:       AmsMethods.HandleNoTag,
+  eqref:       [AmsMethods.HandleRef, true],
 
-  substack:   ['Macro', '\\begin{subarray}{c}#1\\end{subarray}', 1],
+  substack:   [AmsMethods.Macro, '\\begin{subarray}{c}#1\\end{subarray}', 1],
 
-  injlim:     ['NamedOp', 'inj lim'],
-  projlim:    ['NamedOp', 'proj lim'],
-  varliminf:  ['Macro', '\\mathop{\\underline{\\mmlToken{mi}{lim}}}'],
-  varlimsup:  ['Macro', '\\mathop{\\overline{\\mmlToken{mi}{lim}}}'],
-  varinjlim:  ['Macro', '\\mathop{\\underrightarrow{\\mmlToken{mi}{lim}}}'],
-  varprojlim: ['Macro', '\\mathop{\\underleftarrow{\\mmlToken{mi}{lim}}}'],
+  injlim:     [AmsMethods.NamedOp, 'inj lim'],
+  projlim:    [AmsMethods.NamedOp, 'proj lim'],
+  varliminf:  [AmsMethods.Macro, '\\mathop{\\underline{\\mmlToken{mi}{lim}}}'],
+  varlimsup:  [AmsMethods.Macro, '\\mathop{\\overline{\\mmlToken{mi}{lim}}}'],
+  varinjlim:  [AmsMethods.Macro, '\\mathop{\\underrightarrow{\\mmlToken{mi}{lim}}}'],
+  varprojlim: [AmsMethods.Macro, '\\mathop{\\underleftarrow{\\mmlToken{mi}{lim}}}'],
 
-  DeclareMathOperator: 'HandleDeclareOp',
-  operatorname:        'HandleOperatorName',
+  DeclareMathOperator: AmsMethods.HandleDeclareOp,
+  operatorname:        AmsMethods.HandleOperatorName,
 
-  genfrac:     'Genfrac',
-  frac:       ['Genfrac', '', '', '', ''],
-  tfrac:      ['Genfrac', '', '', '', '1'],
-  dfrac:      ['Genfrac', '', '', '', '0'],
-  binom:      ['Genfrac', '(', ')', '0', ''],
-  tbinom:     ['Genfrac', '(', ')', '0', '1'],
-  dbinom:     ['Genfrac', '(', ')', '0', '0'],
+  genfrac:     AmsMethods.Genfrac,
+  frac:       [AmsMethods.Genfrac, '', '', '', ''],
+  tfrac:      [AmsMethods.Genfrac, '', '', '', '1'],
+  dfrac:      [AmsMethods.Genfrac, '', '', '', '0'],
+  binom:      [AmsMethods.Genfrac, '(', ')', '0', ''],
+  tbinom:     [AmsMethods.Genfrac, '(', ')', '0', '1'],
+  dbinom:     [AmsMethods.Genfrac, '(', ')', '0', '0'],
 
-  cfrac:       'CFrac',
+  cfrac:       AmsMethods.CFrac,
 
-  shoveleft:  ['HandleShove', TexConstant.Align.LEFT],
-  shoveright: ['HandleShove', TexConstant.Align.RIGHT],
+  shoveleft:  [AmsMethods.HandleShove, TexConstant.Align.LEFT],
+  shoveright: [AmsMethods.HandleShove, TexConstant.Align.RIGHT],
 
-  xrightarrow: ['xArrow', 0x2192, 5, 10],
-  xleftarrow:  ['xArrow', 0x2190, 10, 5]
-}, AmsMethods);
+  xrightarrow: [AmsMethods.xArrow, 0x2192, 5, 10],
+  xleftarrow:  [AmsMethods.xArrow, 0x2190, 10, 5]
+});
 
 
 /**
  * Environments from the AMS Math package.
  */
 new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, {
-  'equation*':   ['Equation', null, false],
-  'eqnarray*':   ['EqnArray', null, false, true, 'rcl', 'bmt',
+  'equation*':   [AmsMethods.Equation, null, false],
+  'eqnarray*':   [AmsMethods.EqnArray, null, false, true, 'rcl', 'bmt',
                   ParseUtil.cols(0, MATHSPACE.thickmathspace), '.5em'],
-  align:         ['EqnArray', null, true, true,  'rl', 'bt', ParseUtil.cols(0, 2)],
-  'align*':      ['EqnArray', null, false, true, 'rl', 'bt', ParseUtil.cols(0, 2)],
-  multline:      ['Multline', null, true],
-  'multline*':   ['Multline', null, false],
-  split:         ['EqnArray', null, false, false, 'rl', 'bt', ParseUtil.cols(0)],
-  gather:        ['EqnArray', null, true, true,  'c', 'm'],
-  'gather*':     ['EqnArray', null, false, true, 'c', 'm'],
-
-  alignat:       ['AlignAt', null, true, true],
-  'alignat*':    ['AlignAt', null, false, true],
-  alignedat:     ['AlignAt', null, false, false],
-
-  aligned:       ['AmsEqnArray', null, null, null, 'rl', 'bt', ParseUtil.cols(0, 2), '.5em', 'D'],
-  gathered:      ['AmsEqnArray', null, null, null, 'c', 'm', null, '.5em', 'D'],
-
-  xalignat:      ['XalignAt', null, true, true],
-  'xalignat*':   ['XalignAt', null, false, true],
-  xxalignat:     ['XalignAt', null, false, false],
-  flalign:       ['FlalignArray', null, true, false, true, 'rlc', 'btm', 'auto auto fit'],
-  'flalign*':    ['FlalignArray', null, false, false, true, 'rlc', 'btm', 'auto auto fit'],
-
-  subarray:      ['Array', null, null, null, null, ParseUtil.cols(0), '0.1em', 'S', 1],
-  smallmatrix:   ['Array', null, null, null, 'c', ParseUtil.cols(1 / 3),
+  align:         [AmsMethods.EqnArray, null, true, true,  'rl', 'bt', ParseUtil.cols(0, 2)],
+  'align*':      [AmsMethods.EqnArray, null, false, true, 'rl', 'bt', ParseUtil.cols(0, 2)],
+  multline:      [AmsMethods.Multline, null, true],
+  'multline*':   [AmsMethods.Multline, null, false],
+  split:         [AmsMethods.EqnArray, null, false, false, 'rl', 'bt', ParseUtil.cols(0)],
+  gather:        [AmsMethods.EqnArray, null, true, true,  'c', 'm'],
+  'gather*':     [AmsMethods.EqnArray, null, false, true, 'c', 'm'],
+
+  alignat:       [AmsMethods.AlignAt, null, true, true],
+  'alignat*':    [AmsMethods.AlignAt, null, false, true],
+  alignedat:     [AmsMethods.AlignAt, null, false, false],
+
+  aligned:       [AmsMethods.AmsEqnArray, null, null, null, 'rl', 'bt', ParseUtil.cols(0, 2), '.5em', 'D'],
+  gathered:      [AmsMethods.AmsEqnArray, null, null, null, 'c', 'm', null, '.5em', 'D'],
+
+  xalignat:      [AmsMethods.XalignAt, null, true, true],
+  'xalignat*':   [AmsMethods.XalignAt, null, false, true],
+  xxalignat:     [AmsMethods.XalignAt, null, false, false],
+  flalign:       [AmsMethods.FlalignArray, null, true, false, true, 'rlc', 'btm', 'auto auto fit'],
+  'flalign*':    [AmsMethods.FlalignArray, null, false, false, true, 'rlc', 'btm', 'auto auto fit'],
+
+  subarray:      [AmsMethods.Array, null, null, null, null, ParseUtil.cols(0), '0.1em', 'S', 1],
+  smallmatrix:   [AmsMethods.Array, null, null, null, 'c', ParseUtil.cols(1 / 3),
                   '.2em', 'S', 1],
-  matrix:       ['Array', null, null, null, 'c'],
-  pmatrix:      ['Array', null, '(', ')', 'c'],
-  bmatrix:      ['Array', null, '[', ']', 'c'],
-  Bmatrix:      ['Array', null, '\\{', '\\}', 'c'],
-  vmatrix:      ['Array', null, '\\vert', '\\vert', 'c'],
-  Vmatrix:      ['Array', null, '\\Vert', '\\Vert', 'c'],
-  cases:        ['Array', null, '\\{', '.', 'll', null, '.2em', 'T']
-}, AmsMethods);
+  matrix:       [AmsMethods.Array, null, null, null, 'c'],
+  pmatrix:      [AmsMethods.Array, null, '(', ')', 'c'],
+  bmatrix:      [AmsMethods.Array, null, '[', ']', 'c'],
+  Bmatrix:      [AmsMethods.Array, null, '\\{', '\\}', 'c'],
+  vmatrix:      [AmsMethods.Array, null, '\\vert', '\\vert', 'c'],
+  Vmatrix:      [AmsMethods.Array, null, '\\Vert', '\\Vert', 'c'],
+  cases:        [AmsMethods.Array, null, '\\{', '.', 'll', null, '.2em', 'T']
+});
 
 
 /**
@@ -437,6 +437,6 @@ new sm.DelimiterMap('AMSsymbols-delimiter', ParseMethods.delimiter, {
  * Macros from the AMS Symbols package.
  */
 new sm.CommandMap('AMSsymbols-macros', {
-  implies:    ['Macro', '\\;\\Longrightarrow\\;'],
-  impliedby:  ['Macro', '\\;\\Longleftarrow\\;']
-}, AmsMethods);
+  implies:    [AmsMethods.Macro, '\\;\\Longrightarrow\\;'],
+  impliedby:  [AmsMethods.Macro, '\\;\\Longleftarrow\\;']
+});

ts/input/tex/amscd/AmsCdMappings.ts

@@ -28,11 +28,11 @@ import AmsCdMethods from './AmsCdMethods.js';
 
 
 new tm.EnvironmentMap('amscd_environment', ParseMethods.environment,
-                      {CD: 'CD'}, AmsCdMethods);
+                      {CD: AmsCdMethods.CD});
 
 new tm.CommandMap('amscd_macros', {
-  minCDarrowwidth: 'minCDarrowwidth',
-  minCDarrowheight: 'minCDarrowheight',
-}, AmsCdMethods);
+  minCDarrowwidth: AmsCdMethods.minCDarrowwidth,
+  minCDarrowheight: AmsCdMethods.minCDarrowheight,
+});
 
-new tm.MacroMap('amscd_special', {'@': 'arrow'}, AmsCdMethods);
+new tm.MacroMap('amscd_special', {'@': AmsCdMethods.arrow});

ts/input/tex/autoload/AutoloadConfiguration.ts

@@ -123,8 +123,8 @@ function configAutoload(config: ParserConfiguration, jax: TeX<any, any, any>) {
 /**
  * The command and environment maps for the macros that autoload extensions
  */
-const AutoloadMacros = new CommandMap('autoload-macros', {}, {});
-const AutoloadEnvironments = new CommandMap('autoload-environments', {}, {});
+const AutoloadMacros = new CommandMap('autoload-macros', {});
+const AutoloadEnvironments = new CommandMap('autoload-environments', {});
 
 
 /**