chess-moments 1.0.0 → 1.1.1

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

@@ -0,0 +1,69 @@
+const { flatten, cloneDeep } = 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;
+  }
+
+  // Deep clone chess tree to avoid mutating the original
+  const clonedTree = cloneDeep(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 < clonedTree.length; lineIndex++) {
+    const line = clonedTree[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(clonedTree, 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/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/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": "1.0.0",
+  "version": "1.1.1",
   "description": "PGN parser that transforms PGN files into chess \"moments\"",
   "main": "index.js",
   "files": [