chess-moments 0.15.2 → 1.1.0

package/functions/extras/add-moment-to-tree.js

@@ -0,0 +1,66 @@
+const { flatten } = require('lodash');
+const { insertMomentIntoTree } = require('../helpers');
+
+const addMomentToTree = (tree, newMoment) => {
+  if (!newMoment || !newMoment.san || !newMoment.before) {
+    return tree;
+  }
+
+  const flat = flatten(tree);
+  // Check if moment FEN already exists in the tree
+  if (flat.some((moment) => moment.fen === newMoment.after)) {
+    return tree;
+  }
+
+  // Find the appropriate position to insert the moment
+  let point = null;
+
+  // Look for the position where this moment should be inserted
+  // by finding the moment with matching "before" FEN at any depth
+  for (let lineIndex = 0; lineIndex < tree.length; lineIndex++) {
+    const line = tree[lineIndex];
+
+    for (let momentIndex = 0; momentIndex < line.length; momentIndex++) {
+      const existingMoment = line[momentIndex];
+
+      // If we find a moment with the same "before" FEN, this is where we branch
+      if (existingMoment.fen === newMoment.before) {
+        // Check if there's already a move after this position in the same line
+        const nextMomentInLine = line[momentIndex + 1];
+
+        if (nextMomentInLine && nextMomentInLine.move) {
+          // There's already a move after this position, so create a new sideline
+          point = {
+            type: 'newLine',
+            afterLineIndex: lineIndex,
+            branchMomentIndex: momentIndex,
+          };
+        } else {
+          // No move after this position, so continue in the same line
+          point = { type: 'sameLine', lineIndex, momentIndex: momentIndex + 1 };
+        }
+        break;
+      }
+    }
+
+    // If we found an insertion point, no need to continue searching
+    if (point) {
+      break;
+    }
+  }
+
+  // Insert the moment into the tree
+  const newTree = insertMomentIntoTree(tree, point, newMoment);
+
+  // Reindex all moments
+  let globalIndex = 0;
+  for (const line of newTree) {
+    for (const moment of line) {
+      moment.index = globalIndex++;
+    }
+  }
+
+  return newTree;
+};
+
+module.exports = addMomentToTree;

package/functions/extras/index.js

@@ -1,9 +1,11 @@
+const addMomentToTree = require('./add-moment-to-tree');
 const getNextMoments = require('./get-next-moments');
 const getPrevMoment = require('./get-prev-moment');
 const momentsToPgn = require('./moments-to-pgn');
 const moveTrainer = require('./move-trainer');
 
 module.exports = {
+  addMomentToTree,
   getNextMoments,
   getPrevMoment,
   momentsToPgn,

package/functions/flat.js

@@ -1,18 +1,22 @@
 const makeMoments = require('./make-moments');
 
 const flat = (sloppyPgn) => {
-  const moments = makeMoments(sloppyPgn);
+  try {
+    const moments = makeMoments(sloppyPgn);
 
-  // flatten array and add index for every moment
-  const flatten = [].concat.apply([], moments);
+    // flatten array and add index for every moment
+    const flatten = [].concat.apply([], moments);
 
-  let index = 0;
-  for (const moment of flatten) {
-    moment.index = index;
-    index++;
-  }
+    let index = 0;
+    for (const moment of flatten) {
+      moment.index = index;
+      index++;
+    }
 
-  return flatten;
+    return flatten;
+  } catch {
+    return [];
+  }
 };
 
 module.exports = flat;

package/functions/helpers/index.js

@@ -1,9 +1,13 @@
 const getBrushCode = require('./get-brush-code');
 const getBrushColor = require('./get-brush-color');
 const getMoveNumber = require('./get-move-number');
+const insertMomentIntoTree = require('./insert-moment-into-tree');
+const prepareMoment = require('./prepare-moment');
 
 module.exports = {
   getBrushCode,
   getBrushColor,
   getMoveNumber,
+  insertMomentIntoTree,
+  prepareMoment,
 };

package/functions/helpers/insert-moment-into-tree.js

@@ -0,0 +1,97 @@
+const prepareMoment = require('./prepare-moment');
+
+/**
+ * Inserts a new moment into the tree at the specified point.
+ * This function handles both inserting into existing lines and creating new sidelines.
+ * @param {Array} tree - The current tree structure.
+ * @param {Object} point - The point in the tree where the moment will be inserted.
+ * @param {Object} newMoment - The new moment to be inserted, containing properties like san, fen, from, to.
+ * @returns {Array} Updated tree with the new moment inserted
+ */
+const insertMomentIntoTree = (tree, point, newMoment) => {
+  // Prepare the moment to be inserted with only the properties that match normal moments
+  const momentToInsert = prepareMoment(tree, point, newMoment);
+
+  // If no matching position found, always create a new line
+  if (!point) {
+    tree.push([momentToInsert]);
+    return tree;
+  }
+
+  // Insert into existing line
+  if (point.type === 'sameLine') {
+    tree[point.lineIndex].splice(point.momentIndex, 0, momentToInsert);
+    return tree;
+  }
+
+  // Create new sideline
+  if (point.type === 'newLine') {
+    // Check if we need to split the mainline to create proper structure
+    const originalMainline = tree[point.afterLineIndex];
+    const branchMomentIndex = point.branchMomentIndex;
+
+    // Find where to split: look for moves that come after the branch point sequence
+    let splitIndex = branchMomentIndex + 1;
+
+    // Skip the immediate next move(s) that continue from the branch point
+    // and find moves that should be in a separate continuation
+    while (splitIndex < originalMainline.length) {
+      const currentMoment = originalMainline[splitIndex];
+      if (currentMoment.move) {
+        // For now, assume the next move continues the sequence
+        // and the move after that should be separated
+        let nextMoveIndex = splitIndex + 1;
+        while (
+          nextMoveIndex < originalMainline.length &&
+          !originalMainline[nextMoveIndex].move
+        ) {
+          nextMoveIndex++;
+        }
+
+        if (nextMoveIndex < originalMainline.length) {
+          // There's another move after this one, split here for continuation
+          splitIndex = nextMoveIndex;
+          break;
+        }
+      }
+      splitIndex++;
+    }
+
+    if (splitIndex < originalMainline.length) {
+      // Split the mainline
+      const beforeSplit = originalMainline.slice(0, splitIndex);
+      const afterSplit = originalMainline.slice(splitIndex);
+
+      // Update the original mainline to keep the sequence up to the split
+      tree[point.afterLineIndex] = beforeSplit;
+
+      // Insert the sideline after the mainline
+      const sidelinePositionMarker = {
+        depth: momentToInsert.depth,
+        fen: newMoment.before,
+      };
+      const sidelineLine = [sidelinePositionMarker, momentToInsert];
+      tree.splice(point.afterLineIndex + 1, 0, sidelineLine);
+
+      // Insert the continuation line after the sideline
+      const continuationPositionMarker = {
+        depth: beforeSplit[0]?.depth || 1, // Use the depth of the line being continued
+        fen: beforeSplit[beforeSplit.length - 1].fen,
+      };
+      const continuationLine = [continuationPositionMarker, ...afterSplit];
+      tree.splice(point.afterLineIndex + 2, 0, continuationLine);
+    } else {
+      // No continuation needed, just add the sideline
+      const sidelinePositionMarker = {
+        depth: momentToInsert.depth,
+        fen: newMoment.before,
+      };
+      const sidelineLine = [sidelinePositionMarker, momentToInsert];
+      tree.splice(point.afterLineIndex + 1, 0, sidelineLine);
+    }
+  }
+
+  return tree;
+};
+
+module.exports = insertMomentIntoTree;

package/functions/helpers/prepare-moment.js

@@ -0,0 +1,34 @@
+/**
+ * Prepares a moment object for insertion into the tree.
+ * It ensures the moment has the correct properties and depth based on its position.
+ * @param {Array} tree - The current tree structure.
+ * @param {Object} point - The point in the tree where the moment will be inserted.
+ * @param {Object} newMoment - The new moment to be inserted, containing properties like san, fen, from, to.
+ * @returns {Object} Prepared moment object with depth and necessary properties
+ */
+const prepareMoment = (tree, point, newMoment) => {
+  let targetDepth = newMoment.depth || 1;
+
+  if (point) {
+    if (point.type === 'sameLine' && point.lineIndex !== undefined) {
+      // Use the depth of the line we're inserting into
+      targetDepth = tree[point.lineIndex]?.[0]?.depth || 1;
+    } else if (point.type === 'newLine') {
+      // For new sidelines, increment the depth from where we're branching
+      const branchingLine = tree[point.afterLineIndex];
+      const branchingMoment = branchingLine?.[point.branchMomentIndex];
+      const branchingDepth = branchingMoment?.depth || 1;
+      targetDepth = branchingDepth + 1;
+    }
+  }
+
+  return {
+    depth: targetDepth,
+    fen: newMoment.after,
+    move: newMoment.san,
+    from: newMoment.from,
+    to: newMoment.to,
+  };
+};
+
+module.exports = prepareMoment;

package/functions/make-moments.js

@@ -1,4 +1,4 @@
-const Chess = require('../chess');
+const { Chess } = require('chess.js');
 const fen = require('./fen');
 const parser = require('./parser');
 const pgn = require('./pgn');
@@ -8,12 +8,12 @@ const make = (sloppyPgn) => {
   const normalizedPgn = pgn.normalize(sloppyPgn);
 
   // load PGN and check headers for existing FEN
-  const chess = new Chess();
-  chess.load_pgn(normalizedPgn);
-  const header = chess.header();
+  const chess = new Chess(); // can throw if PGN is invalid
+  chess.loadPgn(normalizedPgn);
+  const headers = chess.getHeaders();
 
   const store = {
-    fen: fen.normalize(header.FEN) || fen.initial, // current FEN
+    fen: fen.normalize(headers.FEN) || fen.initial, // current FEN
     depth: 1, // current depth
   };
 
@@ -26,7 +26,7 @@ const make = (sloppyPgn) => {
     store.depth = depth;
 
     // parse current moves with the computed FEN
-    const moments = parser(chess, moves, store.fen, depth);
+    const moments = parser(moves, store.fen, depth);
 
     // set history for the current depth
     history.set(depth, fen.history(moments, history, depth));

package/functions/normalize-pgn.js

@@ -16,5 +16,8 @@ module.exports = (pgn) => {
     return match.replace(/\n/g, '\\n');
   });
 
+  // Merge adjacent comments delimited by {}
+  processedPgn = processedPgn.replace(/(\}\s*\{)+/g, ' ');
+
   return processedPgn;
 };

package/functions/parser.js

@@ -1,19 +1,18 @@
+const { Chess } = require('chess.js');
 const { initial } = require('./fen');
 const pgn = require('./pgn');
 const moment = require('./moment');
 
-module.exports = (chess, moves, fen = initial, depth = 1) => {
-  const loaded = chess.load_pgn(pgn.build(moves, fen));
-  if (!loaded) {
-    return [];
-  }
+module.exports = (moves, fen = initial, depth = 1) => {
+  const chess = new Chess();
+  chess.loadPgn(pgn.build(moves, fen)); // can throw if PGN is invalid
 
   const history = chess.history({ verbose: true });
   while (chess.undo()) {
     chess.undo();
   }
 
-  const comment = chess.get_comment();
+  const comment = chess.getComment();
   const first = moment.build({ depth, comment, fen: chess.fen() });
 
   const moments = history.map((item) => {
@@ -24,14 +23,14 @@ module.exports = (chess, moves, fen = initial, depth = 1) => {
       move: item.san,
       from: item.from,
       to: item.to,
-      comment: chess.get_comment(),
+      comment: chess.getComment(),
       fen: chess.fen(),
     });
   });
 
   // finally, add the first chess "moment" when needed
-  const header = chess.header();
-  if (header.FEN || fen === initial || first.comment || first.shapes) {
+  const headers = chess.getHeaders();
+  if (headers.FEN || fen === initial || first.comment || first.shapes) {
     moments.unshift(first);
   }
 

package/functions/previous-fen.js

@@ -20,21 +20,24 @@ const previousFen = (history, moves, currentDepth, previousDepth) => {
       return history.get(previousDepth)[0];
     }
 
-    // try the first candidate from the current depth
-    const candidate = history.get(currentDepth)[0];
-    if (matchesFen(moves, candidate)) {
-      return candidate;
-    }
+    const currentHistory = history.get(currentDepth);
+    if (Array.isArray(currentHistory) && currentHistory.length > 0) {
+      // try the first candidate from the current depth
+      const candidate = currentHistory[0];
+      if (matchesFen(moves, candidate)) {
+        return candidate;
+      }
 
-    // try the second candidate from the current depth
-    const second = history.get(currentDepth)[1];
-    if (matchesFen(moves, second)) {
-      return second;
+      // try the second candidate from the current depth
+      const second = currentHistory[1];
+      if (matchesFen(moves, second)) {
+        return second;
+      }
     }
 
     return previousFen(history, moves, currentDepth - 1, previousDepth);
   } catch (err) {
-    return false;
+    return '';
   }
 };
 

package/functions/tree.js

@@ -1,17 +1,21 @@
 const makeMoments = require('./make-moments');
 
 const tree = (sloppyPgn) => {
-  const moments = makeMoments(sloppyPgn);
+  try {
+    const moments = makeMoments(sloppyPgn);
 
-  let index = 0;
-  for (const lines of moments) {
-    for (const moment of lines) {
-      moment.index = index;
-      index++;
+    let index = 0;
+    for (const lines of moments) {
+      for (const moment of lines) {
+        moment.index = index;
+        index++;
+      }
     }
-  }
 
-  return moments;
+    return moments;
+  } catch {
+    return [];
+  }
 };
 
 module.exports = tree;

package/index.js

@@ -1,5 +1,6 @@
 const { fen, pgn, flat, tree, mainline } = require('./functions');
 const {
+  addMomentToTree,
   getNextMoments,
   getPrevMoment,
   momentsToPgn,
@@ -12,6 +13,7 @@ module.exports = {
   flat,
   tree,
   mainline,
+  addMomentToTree,
   getNextMoments,
   getPrevMoment,
   momentsToPgn,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chess-moments",
-  "version": "0.15.2",
+  "version": "1.1.0",
   "description": "PGN parser that transforms PGN files into chess \"moments\"",
   "main": "index.js",
   "files": [
@@ -24,7 +24,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "chess.js": "^0.11.0"
+    "chess.js": "^1.4.0"
   },
   "devDependencies": {
     "chai": "^4.3.7",

package/chess.js

@@ -1,15 +0,0 @@
-const isBrowser =
-  typeof window !== 'undefined' && typeof window.document !== 'undefined';
-const isNode = !isBrowser;
-
-let Chess;
-
-if (isNode) {
-  const chess = require('chess.js');
-  Chess = chess.Chess;
-} else {
-  Chess = require('chess.js');
-}
-
-module.exports = Chess;
-module.exports.Chess = Chess;