kni 4.0.2 → 5.0.0

package/story.js

@@ -1,178 +1,187 @@
-'use strict';
+import * as Path from './path.js';
 
-var Path = require('./path');
-
-var constructors = {};
-
-module.exports = Story;
-
-function Story() {
+export default class Story {
+  constructor() {
     this.states = {};
     this.errors = [];
     Object.seal(this);
-}
-
-Story.constructors = constructors;
+  }
 
-Story.prototype.create = function create(path, type, arg, position) {
-    var name = Path.toName(path);
-    var Node = constructors[type];
-    // istanbul ignore if
+  create(path, type, arg, position) {
+    const name = Path.toName(path);
+    const Node = this.constructors[type];
     if (!Node) {
-        throw new Error('No node constructor for type: ' + type);
+      throw new Error(`No node constructor for type: ${type}`);
     }
-    var node = new Node(arg);
+    const node = new Node(arg);
     node.position = position;
     this.states[name] = node;
     return node;
-};
+  }
 
-// istanbul ignore next
-Story.prototype.error = function _error(error) {
+  error(error) {
     this.errors.push(error);
-};
-
-constructors.text = Text;
-function Text(text) {
-    this.type = 'text';
-    this.text = text;
-    this.lift = ' ';
-    this.drop = ' ';
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.echo = Echo;
-function Echo(expression) {
-    this.type = 'echo';
-    this.expression = expression;
-    this.lift = '';
-    this.drop = '';
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.option = Option;
-function Option(label) {
-    this.type = 'opt';
-    this.question = [];
-    this.answer = [];
-    this.keywords = null;
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.goto = Goto;
-function Goto(next) {
-    this.type = 'goto';
-    this.next = next;
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.call = Call;
-function Call(label) {
-    this.type = 'call';
-    this.label = label;
-    this.args = null;
-    this.next = 'RET';
-    this.branch = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.cue = Cue;
-function Cue(cue) {
-    this.type = 'cue';
-    this.cue = cue;
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.def = Def;
-function Def(locals) {
-    this.type = 'def';
-    this.locals = locals;
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.jump = Jump;
-function Jump(condition) {
-    this.type = 'jump';
-    this.condition = condition;
-    this.branch = 'RET';
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.switch = Switch;
-function Switch(expression) {
-    this.type = 'switch';
-    this.expression = expression;
-    this.variable = null;
-    this.value = 0;
-    this.mode = null;
-    this.branches = [];
-    this.weights = [];
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.move = Move;
-function Move() {
-    this.type = 'move';
-    this.source = null;
-    this.target = null;
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.break = Break;
-function Break() {
-    this.type = 'br';
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.paragraph = Paragraph;
-function Paragraph() {
-    this.type = 'par';
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.rule = Rule;
-function Rule() {
-    this.type = 'rule';
-    this.next = 'RET';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.ask = Ask;
-function Ask() {
-    this.type = 'ask';
-    this.position = null;
-    Object.seal(this);
-}
-
-constructors.read = Read;
-function Read(variable) {
-    this.type = 'read';
-    this.next = 'RET';
-    this.variable = variable;
-    this.cue = null;
-    this.position = null;
-    Object.seal(this);
+  }
+
+  constructors = {
+    text: class Text {
+      constructor(text) {
+        this.type = 'text';
+        this.text = text;
+        this.lift = ' ';
+        this.drop = ' ';
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    echo: class Echo {
+      constructor(expression) {
+        this.type = 'echo';
+        this.expression = expression;
+        this.lift = '';
+        this.drop = '';
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    option: class Option {
+      constructor(_label) {
+        this.type = 'opt';
+        this.question = [];
+        this.answer = [];
+        this.keywords = null;
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    goto: class Goto {
+      constructor(next) {
+        this.type = 'goto';
+        this.next = next;
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    call: class Call {
+      constructor(label) {
+        this.type = 'call';
+        this.label = label;
+        this.args = null;
+        this.next = 'RET';
+        this.branch = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    cue: class Cue {
+      constructor(cue) {
+        this.type = 'cue';
+        this.cue = cue;
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    def: class Def {
+      constructor(locals) {
+        this.type = 'def';
+        this.locals = locals;
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    jump: class Jump {
+      constructor(condition) {
+        this.type = 'jump';
+        this.condition = condition;
+        this.branch = 'RET';
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    switch: class Switch {
+      constructor(expression) {
+        this.type = 'switch';
+        this.expression = expression;
+        this.variable = null;
+        this.value = 0;
+        this.mode = null;
+        this.branches = [];
+        this.weights = [];
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    move: class Move {
+      constructor() {
+        this.type = 'move';
+        this.source = null;
+        this.target = null;
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    break: class Break {
+      constructor() {
+        this.type = 'br';
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    paragraph: class Paragraph {
+      constructor() {
+        this.type = 'par';
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    rule: class Rule {
+      constructor() {
+        this.type = 'rule';
+        this.next = 'RET';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    ask: class Ask {
+      constructor() {
+        this.type = 'ask';
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+
+    read: class Read {
+      constructor(variable) {
+        this.type = 'read';
+        this.next = 'RET';
+        this.variable = variable;
+        this.cue = null;
+        this.position = null;
+        Object.seal(this);
+      }
+    },
+  };
 }

package/test.js

@@ -0,0 +1,6 @@
+Error.stackTraceLimit = 1024;
+
+import './outline-lexer-test.js';
+import './inline-lexer-test.js';
+import './engine-test.js';
+import './kni-test.js';

package/translate-json.js

@@ -1,5 +1,3 @@
-'use strict';
-module.exports = translate;
-function translate(module) {
-    module.text = 'module.exports = ' + module.text;
-}
+export default module => {
+  module.text = `export default ${module.text}`;
+};

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "noEmit": true,
+
+    "module": "CommonJS",
+    "target": "es2020",
+
+    "strict": true
+  }
+}

package/verify.js

@@ -1,143 +1,147 @@
-'use strict';
-
-var xorshift = require('xorshift');
-var Engine = require('./engine');
-var Console = require('./console');
-var Scanner = require('./scanner');
-var OutlineLexer = require('./outline-lexer');
-var InlineLexer = require('./inline-lexer');
-var Parser = require('./parser');
-var Story = require('./story');
-var Path = require('./path');
-var grammar = require('./grammar');
-var link = require('./link');
-
-module.exports = verify;
-
-function verify(kni, trans, handler, kniscript) {
-    var lines = trans.split('\n');
-
-    // filter the transcript for given answers
-    var answers = [];
-    for (var i = 0; i < lines.length; i++) {
-        var line = lines[i];
-        if (line.lastIndexOf('>', 0) === 0) {
-            answers.push(line.slice(1).trim());
-        }
+import xorshift from 'xorshift';
+import Engine from './engine.js';
+import Console from './console.js';
+import Scanner from './scanner.js';
+import OutlineLexer from './outline-lexer.js';
+import InlineLexer from './inline-lexer.js';
+import Parser from './parser.js';
+import Story from './story.js';
+import * as Path from './path.js';
+import start from './grammar.js';
+import link from './link.js';
+
+const verify = (kni, trans, handler, kniscript) => {
+  const lines = trans.split('\n');
+
+  // filter the transcript for given answers
+  const answers = [];
+  for (const line of lines) {
+    if (line.lastIndexOf('>', 0) === 0) {
+      answers.push(line.slice(1).trim());
     }
+  }
 
-    var path = Path.start();
-    var base = [];
-
-    // build a story from the kni
-    var story = new Story();
-    var p = new Parser(grammar.start(story, path, base));
-    var il = new InlineLexer(p);
-    var ol = new OutlineLexer(il);
-    var s = new Scanner(ol, kniscript);
-
-    s.next(kni);
-    s.return();
-
-    link(story);
-
-    // istanbul ignore if
-    if (story.errors.length) {
-        var errors = '';
-        for (var i = 0; i < story.errors.length; i++) {
-            errors += story.errors[i] + '\n';
-        }
-
-        if (errors === trans) {
-            return {
-                pass: true,
-                expected: 'errors',
-                actual: 'errors',
-            };
-        }
-
-        for (var i = 0; i < story.errors.length; i++) {
-            console.error(story.errors[i]);
-        }
-        return {
-            pass: false,
-            expected: trans,
-            actual: errors,
-        };
+  const path = Path.start();
+  const base = [];
+
+  // build a story from the kni
+  const story = new Story();
+  const p = new Parser(start(story, path, base));
+  const il = new InlineLexer(p);
+  const ol = new OutlineLexer(il);
+  const s = new Scanner(ol, kniscript);
+
+  s.next(kni);
+  s.return();
+
+  link(story);
+
+  if (story.errors.length) {
+    let errors = '';
+    for (const err of story.errors) {
+      errors += `${err}\n`;
     }
 
-    var states = story.states;
-
-    // TODO support alternate seeds
-    var seed = 0;
-    // I rolled 4d64k this morning, for kni.js
-    var randomer = new xorshift.constructor([
-        37615 ^ seed,
-        54552 ^ seed,
-        59156 ^ seed,
-        24695 ^ seed
-    ]);
-
-    var writer = new StringWriter();
-    var render = new Console(writer);
-    var readline = new FakeReadline(writer, answers);
-    var engine = new Engine({
-        story: states,
-        start: 'start',
-        handler: handler,
-        render: render,
-        dialog: readline,
-        randomer: randomer
-    });
-    readline.engine = engine;
-    engine.reset();
-
-    var expected = trans.trim();
-    var actual = writer.string.trim();
+    if (errors === trans) {
+      return {
+        pass: true,
+        expected: 'errors',
+        actual: 'errors',
+      };
+    }
+
+    for (const err of story.errors) {
+      console.error(err);
+    }
     return {
-        pass: expected === actual,
-        expected: expected,
-        actual: actual
+      pass: false,
+      expected: trans,
+      actual: errors,
     };
-}
+  }
+
+  const states = story.states;
+
+  // TODO support alternate seeds
+  const seed = 0;
+  // I rolled 4d64k this morning, for kni.js
+  const randomer = new xorshift.constructor([
+    37615 ^ seed,
+    54552 ^ seed,
+    59156 ^ seed,
+    24695 ^ seed,
+  ]);
+
+  const writer = new StringWriter();
+  const render = new Console(writer);
+  const readline = new FakeReadline(writer, answers, kniscript);
+  const engine = new Engine({
+    story: states,
+    start: 'start',
+    handler: handler,
+    render: render,
+    dialog: readline,
+    randomer: randomer,
+  });
+  readline.engine = engine;
+  engine.reset();
+
+  const expected = trans.trim();
+  const actual = writer.string.trim();
+  return {
+    pass: expected === actual,
+    expected: expected,
+    actual: actual,
+  };
+};
 
-function FakeReadline(writer, answers) {
+export default verify;
+
+class FakeReadline {
+  constructor(writer, answers, kniscript) {
     this.writer = writer;
     this.answers = answers;
+    this.kniscript = kniscript;
     this.engine = null;
     this.history = [];
     Object.seal(this);
-}
+  }
 
-FakeReadline.prototype.ask = function ask(question) {
-    var answer = this.answers.shift();
-    // istanbul ignore if
+  ask(_question) {
+    const answer = this.answers.shift();
     if (answer == null) {
-        return;
+      return;
     }
-    this.writer.write(('> ' + answer).trim() + '\n');
+    this.writer.write(`${`> ${answer}`.trim()}\n`);
 
     if (answer === 'quit') {
+      // noop
     } else if (answer === 'replay') {
-        this.writer.write('\n');
-        this.engine.resume(this.engine.waypoint);
+      this.writer.write('\n');
+      this.engine.resume(this.engine.waypoint);
     } else if (answer === 'back') {
-        this.writer.write('\n');
-        this.engine.waypoint = this.history.pop();
-        this.engine.resume(this.engine.waypoint);
+      this.writer.write('\n');
+      this.engine.waypoint = this.history.pop();
+      this.engine.resume(this.engine.waypoint);
     } else {
-        this.history.push(this.engine.waypoint);
-        this.engine.answer(answer);
+      this.history.push(this.engine.waypoint);
+      this.engine.answer(answer);
     }
-};
+  }
 
-FakeReadline.prototype.close = function close() {
-};
+  close() {}
 
-function StringWriter() {
-    this.string = '';
+  meterFault() {
+    throw new Error(`meter fault in ${this.kniscript}`);
+  }
 }
 
-StringWriter.prototype.write = function write(string) {
+class StringWriter {
+  constructor() {
+    this.string = '';
+  }
+
+  write(string) {
     this.string += string;
-};
+  }
+}