Add capacitorjs runtime

node_modules/chevrotain/src/generate/generate.ts

@@ -0,0 +1,199 @@
+import { forEach, map } from "../utils/utils"
+import {
+  RepetitionMandatory,
+  Option,
+  RepetitionMandatoryWithSeparator,
+  RepetitionWithSeparator,
+  Terminal,
+  NonTerminal,
+  Alternation,
+  Alternative,
+  Repetition
+} from "../parse/grammar/gast/gast_public"
+import { IProduction, TokenType, Rule } from "../../api"
+
+/**
+ * Missing features
+ * 1. Rule arguments
+ * 2. Gates
+ * 3. embedded actions
+ */
+
+const NL = "\n"
+
+export function genUmdModule(options: { name: string; rules: Rule[] }): string {
+  return `
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(['chevrotain'], factory);
+    } else if (typeof module === 'object' && module.exports) {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like environments that support module.exports,
+        // like Node.
+        module.exports = factory(require('chevrotain'));
+    } else {
+        // Browser globals (root is window)
+        root.returnExports = factory(root.b);
+    }
+}(typeof self !== 'undefined' ? self : this, function (chevrotain) {
+
+${genClass(options)}
+    
+return {
+    ${options.name}: ${options.name} 
+}
+}));
+`
+}
+
+export function genWrapperFunction(options: {
+  name: string
+  rules: Rule[]
+}): string {
+  return `    
+${genClass(options)}
+return new ${options.name}(tokenVocabulary, config)    
+`
+}
+
+export function genClass(options: { name: string; rules: Rule[] }): string {
+  // TODO: how to pass the token vocabulary? Constructor? other?
+  let result = `
+function ${options.name}(tokenVocabulary, config) {
+    // invoke super constructor
+    // No support for embedded actions currently, so we can 'hardcode'
+    // The use of CstParser.
+    chevrotain.CstParser.call(this, tokenVocabulary, config)
+
+    const $ = this
+
+    ${genAllRules(options.rules)}
+
+    // very important to call this after all the rules have been defined.
+    // otherwise the parser may not work correctly as it will lack information
+    // derived during the self analysis phase.
+    this.performSelfAnalysis(this)
+}
+
+// inheritance as implemented in javascript in the previous decade... :(
+${options.name}.prototype = Object.create(chevrotain.CstParser.prototype)
+${options.name}.prototype.constructor = ${options.name}    
+    `
+
+  return result
+}
+
+export function genAllRules(rules: Rule[]): string {
+  let rulesText = map(rules, (currRule) => {
+    return genRule(currRule, 1)
+  })
+
+  return rulesText.join("\n")
+}
+
+export function genRule(prod: Rule, n: number): string {
+  let result = indent(n, `$.RULE("${prod.name}", function() {`) + NL
+  result += genDefinition(prod.definition, n + 1)
+  result += indent(n + 1, `})`) + NL
+  return result
+}
+
+export function genTerminal(prod: Terminal, n: number): string {
+  const name = prod.terminalType.name
+  // TODO: potential performance optimization, avoid tokenMap Dictionary access
+  return indent(n, `$.CONSUME${prod.idx}(this.tokensMap.${name})` + NL)
+}
+
+export function genNonTerminal(prod: NonTerminal, n: number): string {
+  return indent(n, `$.SUBRULE${prod.idx}($.${prod.nonTerminalName})` + NL)
+}
+
+export function genAlternation(prod: Alternation, n: number): string {
+  let result = indent(n, `$.OR${prod.idx}([`) + NL
+  const alts = map(prod.definition, (altDef) => genSingleAlt(altDef, n + 1))
+  result += alts.join("," + NL)
+  result += NL + indent(n, `])` + NL)
+  return result
+}
+
+export function genSingleAlt(prod: Alternative, n: number): string {
+  let result = indent(n, `{`) + NL
+
+  result += indent(n + 1, "ALT: function() {") + NL
+  result += genDefinition(prod.definition, n + 1)
+  result += indent(n + 1, `}`) + NL
+  result += indent(n, `}`)
+
+  return result
+}
+
+function genProd(prod: IProduction, n: number): string {
+  /* istanbul ignore else */
+  if (prod instanceof NonTerminal) {
+    return genNonTerminal(prod, n)
+  } else if (prod instanceof Option) {
+    return genDSLRule("OPTION", prod, n)
+  } else if (prod instanceof RepetitionMandatory) {
+    return genDSLRule("AT_LEAST_ONE", prod, n)
+  } else if (prod instanceof RepetitionMandatoryWithSeparator) {
+    return genDSLRule("AT_LEAST_ONE_SEP", prod, n)
+  } else if (prod instanceof RepetitionWithSeparator) {
+    return genDSLRule("MANY_SEP", prod, n)
+  } else if (prod instanceof Repetition) {
+    return genDSLRule("MANY", prod, n)
+  } else if (prod instanceof Alternation) {
+    return genAlternation(prod, n)
+  } else if (prod instanceof Terminal) {
+    return genTerminal(prod, n)
+  } else if (prod instanceof Alternative) {
+    return genDefinition(prod.definition, n)
+  } else {
+    throw Error("non exhaustive match")
+  }
+}
+
+function genDSLRule(
+  dslName,
+  prod: {
+    definition: IProduction[]
+    idx: number
+    separator?: TokenType
+  },
+  n: number
+): string {
+  let result = indent(n, `$.${dslName + prod.idx}(`)
+
+  if (prod.separator) {
+    result += "{" + NL
+    result +=
+      indent(n + 1, `SEP: this.tokensMap.${prod.separator.name}`) + "," + NL
+    result += `DEF: ${genDefFunction(prod.definition, n + 2)}` + NL
+    result += indent(n, "}") + NL
+  } else {
+    result += genDefFunction(prod.definition, n + 1)
+  }
+
+  result += indent(n, `)`) + NL
+  return result
+}
+
+function genDefFunction(definition: IProduction[], n: number): string {
+  let def = "function() {" + NL
+  def += genDefinition(definition, n)
+  def += indent(n, `}`) + NL
+  return def
+}
+
+function genDefinition(def: IProduction[], n: number): string {
+  let result = ""
+  forEach(def, (prod) => {
+    result += genProd(prod, n + 1)
+  })
+  return result
+}
+
+function indent(howMuch: number, text: string): string {
+  const spaces = Array(howMuch * 4 + 1).join(" ")
+  return spaces + text
+}

node_modules/chevrotain/src/generate/generate_public.ts

@@ -0,0 +1,36 @@
+import { Rule, IParserConfig, TokenVocabulary, BaseParser } from "../../api"
+import { genUmdModule, genWrapperFunction } from "./generate"
+
+export function generateParserFactory<T extends BaseParser>(options: {
+  name: string
+  rules: Rule[]
+  tokenVocabulary: TokenVocabulary
+}): (config?: IParserConfig) => T {
+  const wrapperText = genWrapperFunction({
+    name: options.name,
+    rules: options.rules
+  })
+
+  const constructorWrapper = new Function(
+    "tokenVocabulary",
+    "config",
+    "chevrotain",
+    wrapperText
+  )
+
+  return function (config) {
+    return constructorWrapper(
+      options.tokenVocabulary,
+      config,
+      // TODO: check how the require is transpiled/webpacked
+      require("../api")
+    )
+  }
+}
+
+export function generateParserModule(options: {
+  name: string
+  rules: Rule[]
+}): string {
+  return genUmdModule({ name: options.name, rules: options.rules })
+}