kni 4.0.2 → 5.0.0

package/link.js

@@ -1,58 +1,56 @@
-'use strict';
+const link = story => {
+  const labels = Object.keys(story.states);
+  for (let i = 0; i < labels.length; i++) {
+    const label = labels[i];
+    const state = story.states[label];
 
-module.exports = link;
+    const link = linker(story, label, state);
 
-function link(story) {
-    var labels = Object.keys(story.states);
-    for (var i = 0; i < labels.length; i++) {
-        var label = labels[i];
-        var state = story.states[label];
+    if (state.label != null) {
+      state.label = link('label')(state.label);
+    }
+    if (state.next != null) {
+      state.next = link('next')(state.next);
+    }
+    if (state.branch != null) {
+      state.branch = link('branch')(state.branch);
+    }
+    if (state.question != null) {
+      state.question = state.question.map(link('question'));
+    }
+    if (state.answer != null) {
+      state.answer = state.answer.map(link('answer'));
+    }
+  }
+};
 
-        var link = linker(story, label, state);
+export default link;
 
-        if (state.label != null) {
-            state.label = link('label')(state.label);
-        }
-        if (state.next != null) {
-            state.next = link('next')(state.next);
+const linker = (story, context, state) => {
+  const parts = context.split('.');
+  const ancestry = [];
+  while (parts.length > 0) {
+    ancestry.push(parts.slice());
+    parts.pop();
+  }
+  ancestry.push([]);
+  return role => {
+    return label => {
+      if (label === 'RET' || label === 'ESC') {
+        return label;
+      }
+      for (let i = 0; i < ancestry.length; i++) {
+        let candidate = ancestry[i].slice();
+        candidate.push(label);
+        candidate = candidate.join('.');
+        if (story.states[candidate] != null) {
+          return candidate;
         }
-        if (state.branch != null) {
-            state.branch = link('branch')(state.branch);
-        }
-        if (state.question != null) {
-            state.question = state.question.map(link('question'));
-        }
-        if (state.answer != null) {
-            state.answer = state.answer.map(link('answer'));
-        }
-    }
-}
-
-function linker(story, context, state) {
-    var parts = context.split('.');
-    var ancestry = [];
-    while (parts.length > 0) {
-        ancestry.push(parts.slice());
-        parts.pop();
-    }
-    ancestry.push([]);
-    return function (role) {
-        return function (label) {
-            if (label === 'RET' || label === 'ESC') {
-                return label;
-            }
-            for (var i = 0; i < ancestry.length; i++) {
-                var candidate = ancestry[i].slice();
-                candidate.push(label);
-                candidate = candidate.join('.');
-                if (story.states[candidate] != null) {
-                    return candidate;
-                }
-            }
-            // istanbul ignore next
-            story.error('Could not link ' + role + ' label ' + JSON.stringify(label) + ' at position ' + state.position);
-            // istanbul ignore next
-            return label;
-        };
+      }
+      story.error(
+        `Could not link ${role} label ${JSON.stringify(label)} at position ${state.position}`
+      );
+      return label;
     };
-}
+  };
+};

package/outline-lexer.js

@@ -1,4 +1,4 @@
-'use strict';
+// @ts-check
 
 // Transforms a stream of lines with known indentation levels and leaders like
 // bullets, and transforms these into a stream of lines with start and stop
@@ -9,59 +9,86 @@
 
 // TODO remove the break emission feature
 
-module.exports = OutlineLexer;
+export default class OutlineLexer {
+  debug = typeof process === 'object' && process.env.DEBUG_OUTLINE_LEXER;
 
-var debug = typeof process === 'object' && process.env.DEBUG_OUTLINE_LEXER;
+  top = 0;
+  broken = false;
 
-function OutlineLexer(generator) {
+  /** @typedef {import('./scanner')} Scanner */
+
+  /** Outline lexer state object, which receives typed text tokens, along
+   * with the current scanner. It is expected to return a subsequent state
+   * object, which will be retained by the lexer, and receive the subsequent
+   * token.
+   *
+   * @typedef {object} State
+   * @prop {(type: string, text: string, sc: Scanner) => State} next
+   */
+
+  /**
+   * @param {State} generator
+   */
+  constructor(generator) {
     this.generator = generator;
-    this.top = 0;
     this.stack = [this.top];
-    this.broken = false;
-    this.debug = debug;
-}
+  }
 
-OutlineLexer.prototype.next = function next(line, scanner) {
-    // istanbul ignore if
+  /**
+   * @param {string} line
+   * @param {Scanner} scanner
+   * @returns {OutlineLexer}
+   */
+  next(line, scanner) {
     if (this.debug) {
-        console.error(
-            'OLL', scanner.position(),
-            JSON.stringify(line),
-            'indent', scanner.indent,
-            'leader', JSON.stringify(scanner.leader),
-            'stack', this.stack,
-            'top', this.top
-        );
+      console.error(
+        'OLL',
+        scanner.position(),
+        JSON.stringify(line),
+        'indent',
+        scanner.indent,
+        'leader',
+        JSON.stringify(scanner.leader),
+        'stack',
+        this.stack,
+        'top',
+        this.top
+      );
     }
     while (scanner.indent < this.top) {
-        this.generator = this.generator.next('stop', '', scanner);
-        this.stack.pop();
-        this.top = this.stack[this.stack.length - 1];
+      this.generator = this.generator.next('stop', '', scanner);
+      this.stack.pop();
+      this.top = this.stack[this.stack.length - 1];
     }
     if (scanner.leader.length !== 0 && scanner.indent > this.top) {
-        this.generator = this.generator.next('start', scanner.leader, scanner);
-        this.stack.push(scanner.indent);
-        this.top = scanner.indent;
-        this.broken = false;
+      this.generator = this.generator.next('start', scanner.leader, scanner);
+      this.stack.push(scanner.indent);
+      this.top = scanner.indent;
+      this.broken = false;
     } else if (scanner.leader.length !== 0 && scanner.indent === this.top) {
-        this.generator = this.generator.next('stop', '', scanner);
-        this.generator = this.generator.next('start', scanner.leader, scanner);
-        this.top = scanner.indent;
-        this.broken = false;
+      this.generator = this.generator.next('stop', '', scanner);
+      this.generator = this.generator.next('start', scanner.leader, scanner);
+      this.top = scanner.indent;
+      this.broken = false;
     }
     if (line.length) {
-        this.generator = this.generator.next('text', line, scanner);
+      this.generator = this.generator.next('text', line, scanner);
     } else if (!this.broken) {
-        this.broken = true;
-        this.generator = this.generator.next('break', '', scanner);
+      this.broken = true;
+      this.generator = this.generator.next('break', '', scanner);
     }
     return this;
-};
+  }
 
-OutlineLexer.prototype.return = function _return(scanner) {
-    for (var i = 0; i < this.stack.length; i++) {
-        this.generator = this.generator.next('stop', '', scanner);
+  /**
+   * @param {Scanner} scanner
+   * @returns {OutlineLexer}
+   */
+  return(scanner) {
+    for (let i = 0; i < this.stack.length; i++) {
+      this.generator = this.generator.next('stop', '', scanner);
     }
     this.stack.length = 0;
     return this;
-};
+  }
+}

package/package.json

@@ -1,56 +1,49 @@
 {
   "name": "kni",
-  "version": "4.0.2",
+  "version": "5.0.0",
   "description": "A text adventure language and runtime inspired by inkle/ink",
+  "type": "module",
   "bin": {
     "kni": "./kni.js"
   },
   "dependencies": {
     "pop-equals": "^1.0.0",
     "shon": "^4.0.0",
-    "system": "^1.0.6",
     "table": "^3.7.8",
     "tee": "^0.2.0",
     "xorshift": "^1.1.1"
   },
   "devDependencies": {
-    "eslint": "^2.7.0",
-    "istanbul": "^0.4.3",
-    "json-diff": "^0.3.1",
-    "opn": "^1.0.1"
+    "@babel/core": "^7.13.1",
+    "@babel/eslint-parser": "^7.13.4",
+    "@babel/plugin-syntax-class-properties": "^7.12.13",
+    "@babel/plugin-syntax-import-attributes": "^7.27.1",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@types/node": "^14.14.31",
+    "eslint": "^7.20.0",
+    "nyc": "^15.1.0",
+    "open": "^7.4.2",
+    "prettier": "^3.7.1",
+    "rimraf": "^3.0.2",
+    "rollup": "^4.53.3",
+    "strip-ansi": "^3.0.1",
+    "typescript": "^4.2.2"
   },
   "files": [
-    "console.js",
-    "describe.js",
-    "document.js",
-    "engine.js",
-    "evaluate.js",
-    "excerpt.js",
-    "grammar.js",
-    "html.js",
-    "inline-lexer.js",
-    "kni.js",
-    "kni.json",
-    "link.js",
-    "outline-lexer.js",
-    "parser.js",
-    "path.js",
-    "readline.js",
-    "scanner.js",
-    "scope.js",
-    "story.js",
-    "template.js",
-    "translate-json.js",
-    "verify.js",
-    "wrapper.js"
+    "*.js",
+    "!*-test.js",
+    "*.json",
+    "!.*.json"
   ],
   "scripts": {
-    "test": "npm ls -s && npm run lint && npm run cover -s",
+    "format": "prettier --write \"**/*.js\"",
+    "format:check": "prettier --check \"**/*.js\"",
     "lint": "eslint .",
-    "build": "node kni.js examples/archery.kni -j > examples/archery.json && bundle index.js > bundle.js",
-    "cover": "istanbul cover --report html --print node -- test.js && istanbul report text && npm run check-cover -s",
-    "check-cover": "istanbul check-coverage",
-    "view-cover": "opn ./coverage/index.html",
+    "lint-fix": "eslint . --fix",
+    "test": "node -- test.js",
+    "cover": "nyc npm test",
+    "check-cover": "nyc check-coverage",
+    "view-cover": "npm run cover && open ./coverage/index.html",
     "usage": "usage2json kni.usage > kni.json"
   },
   "translators": {

package/parser.js

@@ -1,29 +1,41 @@
-'use strict';
+// @ts-check
 
-module.exports = Parser;
+export default class Parser {
+  debug = typeof process === 'object' && process.env.DEBUG_PARSER;
 
-var debug = typeof process === 'object' && process.env.DEBUG_PARSER;
+  /** @typedef {import('./scanner')} Scanner */
 
-function Parser(generator) {
+  /**
+   * @typedef {object} State
+   * @prop {(type: string, space: string, text: string, sc: Scanner) => State} next
+   */
+
+  /**
+   * @param {State} generator
+   */
+  constructor(generator) {
     this.generator = generator;
-    this.debug = debug;
-}
+  }
 
-Parser.prototype.next = function next(type, space, text, scanner) {
-    var prior = this.generator.constructor.name;
+  /**
+   * @param {string} type
+   * @param {string} space
+   * @param {string} text
+   * @param {Scanner} scanner
+   * @returns {Parser}
+   */
+  next(type, space, text, scanner) {
+    const prior = this.generator.constructor.name;
     this.generator = this.generator.next(type, space, text, scanner);
-    // istanbul ignore if
-    if (!this.generator) {
-        throw new Error(prior + ' returned undefined next state given ' + type + '/' + text + ' at ' + scanner.position());
-    }
-    // istanbul ignore if
     if (this.debug) {
-        console.error(
-            'PAR',
-            scanner.position(),
-            type, JSON.stringify(text),
-            prior + '->' + this.generator.constructor.name
-        );
+      console.error(
+        'PAR',
+        scanner.position(),
+        type,
+        JSON.stringify(text),
+        `${prior}->${this.generator.constructor.name}`
+      );
     }
     return this;
-};
+  }
+}

package/path.js

@@ -1,46 +1,34 @@
-'use strict';
-
-exports.start = start;
-
-function start() {
-    return ['start'];
-}
-
-exports.toName = pathToName;
-
-function pathToName(path) {
-    var name = path[0];
-    var i;
-    for (i = 1; i < path.length - 1; i++) {
-        name += '.' + path[i];
-    }
-    var last = path[i];
-    if (path.length > 1 && last !== 0) {
-        name += '.' + last;
-    }
-    return name;
-}
-
-exports.next = nextPath;
-
-function nextPath(path) {
-    path = path.slice();
-    path[path.length - 1]++;
-    return path;
-}
-
-exports.firstChild = firstChildPath;
-
-function firstChildPath(path) {
-    path = path.slice();
-    path.push(1);
-    return path;
-}
-
-exports.zerothChild = zerothChildPath;
-
-function zerothChildPath(path) {
-    path = path.slice();
-    path.push(0);
-    return path;
-}
+export const start = () => {
+  return ['start'];
+};
+
+export const toName = path => {
+  let name = path[0];
+  let i;
+  for (i = 1; i < path.length - 1; i++) {
+    name += `.${path[i]}`;
+  }
+  const last = path[i];
+  if (path.length > 1 && last !== 0) {
+    name += `.${last}`;
+  }
+  return name;
+};
+
+export const next = path => {
+  path = path.slice();
+  path[path.length - 1]++;
+  return path;
+};
+
+export const firstChild = path => {
+  path = path.slice();
+  path.push(1);
+  return path;
+};
+
+export const zerothChild = path => {
+  path = path.slice();
+  path.push(0);
+  return path;
+};