chess-moments 0.11.0 → 0.11.2

package/README.md

@@ -42,6 +42,11 @@ The `depth` key delimits between variants and subvariants played in the chess ga
 Returns a two level deep array of chess moments.
 The first level splits between variants and subvariants played in the chess game.
 
+### .train()
+
+Returns a two level deep array of chess moments.
+It is useful for hiding future moves in chess training.
+
 ## JSON output
 
 The basic PGN file `1. e4 e5 *` will generated the following chess moments in JSON format:

package/functions/split-by-move.js

@@ -0,0 +1,21 @@
+function splitByMoveIndex(inputData, current) {
+  const before = [];
+  const after = [];
+
+  inputData.forEach((innerArray) => {
+    // Check if every element in the inner array has an index less than moveIndex
+    if (innerArray.every((item) => item.index < current.index)) {
+      if (innerArray.length) {
+        before.push(innerArray);
+      }
+    } else {
+      if (innerArray.length) {
+        after.push(innerArray);
+      }
+    }
+  });
+
+  return { before, after };
+}
+
+module.exports = splitByMoveIndex;

package/functions/train.js

@@ -1,21 +1,55 @@
-const flat = require('./flat');
+const { flatten } = require('lodash');
+const splitByMoveIndex = require('./split-by-move');
+const tree = require('./tree');
 
-const train = (sloppyPgn, moveIndex) => {
-  const moments = flat(sloppyPgn);
+const train = (sloppyPgn, fen) => {
+  // Tree is an array of array depths
+  const moments = tree(sloppyPgn);
+
+  // Similar structure to the tree, but with only the training data
+  const training = [];
 
   // Remove sidelines (depth > 1) when no move index is specified
-  if (!moveIndex) {
-    return moments.filter((moment) => moment.depth === 1);
+  if (!fen) {
+    for (const innerArray of moments) {
+      const hasDepth = innerArray.filter((moment) => moment.depth === 1);
+      if (hasDepth.length) {
+        training.push(innerArray);
+      }
+    }
+    return training;
   }
 
+  // Get the current move from the move index
+  const current = flatten(moments).find((moment) => moment.fen === fen);
+
   // Split the moments into two groups
-  const before = moments.slice(0, moveIndex);
-  const after = moments.slice(moveIndex);
+  const { before, after } = splitByMoveIndex(moments, current);
+  for (const innerArray of before) {
+    training.push(innerArray);
+  }
 
-  // Remove sidelines after the specified move index with the move index depth
-  const filtered = after.filter((moment) => moment.depth <= moments[moveIndex].depth);
+  // Only future moves remaining
+  for (const innerArray of after) {
+    // Remove every inner array with a depth not equal than the depth of the move index
+    const filtered = innerArray.filter((moment) => {
+      return moment.depth === current.depth;
+    });
+
+    // Add hidden prop to filtered moves with index greater than the move index
+    filtered.forEach((moment) => {
+      if (moment.index > current.index) {
+        moment.hidden = true;
+        // Also remove comments and shapes for hidden moves
+        delete moment.comment;
+        delete moment.shapes;
+      }
+    });
+
+    training.push(filtered);
+  }
 
-  return before.concat(filtered);
+  return training;
 };
 
 module.exports = train;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chess-moments",
-  "version": "0.11.0",
-  "description": "PGN reader is a javascript chess library that transforms PGN files into chess moments",
+  "version": "0.11.2",
+  "description": "PGN parser that transforms PGN files into chess \"moments\"",
   "main": "dist/index.js",
   "files": [
     "index.js",