chess-moments 1.2.1 → 1.3.0

package/functions/extras/get-next-moments.js

@@ -1,4 +1,4 @@
-const { getMoveNumber } = require('../helpers');
+const { isNextFen } = require('../helpers');
 
 /**
  * Always returns an array because there can be more than one next moment
@@ -23,88 +23,41 @@ const getNextMoments = (moments, current) => {
     }
 
     // Last move of a sideline should not have any next moves
-    if (
-      !nextMoment?.move &&
-      current.depth >= nextMoment.depth &&
-      getMoveNumber(nextMoment.fen) <= getMoveNumber(current.fen)
-    ) {
+    if (!nextMoment?.move && current.depth >= nextMoment.depth) {
       return [];
     }
 
-    // Add the next moment if it has a move and is at the same depth
-    if (nextMoment.move && current.depth === nextMoment.depth) {
-      next.push(nextMoment);
-    }
-
-    // Return early if we have consecutive moves or no next next moment
-    if (!nextNextMoment || (nextMoment?.move && nextNextMoment?.move)) {
-      return next;
-    }
-
-    // Second to last move of a sideline should not have any next moves
+    // Return early if there are two consecutive moves at the same depth or if the next next move does not exist
     if (
-      nextMoment?.move &&
-      !nextNextMoment?.move &&
-      current.depth >= nextNextMoment.depth &&
-      getMoveNumber(nextNextMoment.fen) <= getMoveNumber(current.fen)
+      current.move &&
+      current.depth === nextMoment.depth &&
+      (!nextNextMoment || current.depth === nextNextMoment.depth)
     ) {
-      return next;
-    }
-
-    // Remove all next moments until depth equals current.depth when next moment does not have a move
-    if (!nextMoment?.move) {
-      const filteredMoments = moments.filter((moment, index) => {
-        return index <= nextIndex || moment.depth === current.depth;
-      });
-      moments = filteredMoments;
+      return [nextMoment];
     }
 
-    // Add fullmove number to the current moment
-    current.fullmove = Number(current.fen.split(' ')[5]);
-
-    // Active color after current move (who moves next)
-    const activeColorAfterCurrent = current.fen.split(' ')[1];
+    // Remove all moves before the current moment
+    moments = moments.filter((moment) => moment.index > current.index);
 
-    // Process moments in order and stop when we leave the current branch
+    // Remove all moments after the first moment that have a lower depth than the current moment
+    let filteredMoments = [];
     for (const moment of moments) {
-      // Skip moments that are at or before the current moment's index
-      if (moment.index <= current.index + 1) {
-        continue;
-      }
-      // Stop if we hit a moment with lower depth (we've left this branch)
       if (moment.depth < current.depth) {
         break;
       }
-      // Skip moments without moves
-      if (!moment.move) {
-        continue;
-      }
-      // Only consider moments at current depth or one level deeper
-      if (moment.depth > current.depth + 1) {
-        continue;
-      }
-
-      const activeColorAfterMoment = moment.fen.split(' ')[1];
-      const fullmove = Number(moment.fen.split(' ')[5]);
-
-      // Only consider moments within the valid move range
-      if (fullmove > current.fullmove + 1) {
-        continue;
-      }
-
-      // Check if this is a valid next move based on color and fullmove
-      const isValidWhiteMove =
-        activeColorAfterCurrent === 'w' &&
-        activeColorAfterMoment === 'b' &&
-        fullmove === current.fullmove;
+      filteredMoments.push(moment);
+    }
 
-      const isValidBlackMove =
-        activeColorAfterCurrent === 'b' &&
-        activeColorAfterMoment === 'w' &&
-        fullmove === current.fullmove + 1;
+    // If next moment does not have a move, remove all moments with the depth higher than current depth
+    if (!nextMoment.move) {
+      filteredMoments = filteredMoments.filter(
+        (moment) => moment.depth <= current.depth
+      );
+    }
 
-      // If the move is valid, add it to the next moments
-      if (isValidWhiteMove || isValidBlackMove) {
+    // Finally check for next moments from filtered moments
+    for (const moment of filteredMoments) {
+      if (moment.move && isNextFen(current.fen, moment.fen)) {
         next.push(moment);
       }
     }

package/functions/extras/index.js

@@ -4,6 +4,7 @@ const getNextMoments = require('./get-next-moments');
 const getPrevMoment = require('./get-prev-moment');
 const momentsToPgn = require('./moments-to-pgn');
 const moveTrainer = require('./move-trainer');
+const promoteMainline = require('./promote-mainline');
 
 module.exports = {
   addMomentToTree,
@@ -12,4 +13,5 @@ module.exports = {
   getPrevMoment,
   momentsToPgn,
   moveTrainer,
+  promoteMainline,
 };

package/functions/extras/promote-mainline.js

@@ -0,0 +1,117 @@
+const promoteMainline = (moments, current) => {
+  if (!current || current.depth === 1) return moments;
+
+  const currentDepth = current.depth;
+  const targetDepth = currentDepth - 1;
+
+  // Find sideline position marker
+  let sidelinePositionIndex = -1;
+  for (let i = 0; i < current.index; i++) {
+    if (moments[i].depth === currentDepth && !moments[i].move) {
+      sidelinePositionIndex = i;
+      break;
+    }
+  }
+  if (sidelinePositionIndex === -1) return moments;
+
+  // Find end of sideline window (end of a window = next position at the same depth OR first lower depth)
+  let sidelineEndIndex = moments.length;
+  for (let i = sidelinePositionIndex + 1; i < moments.length; i++) {
+    if (
+      (moments[i].depth === currentDepth && !moments[i].move) ||
+      moments[i].depth < currentDepth
+    ) {
+      sidelineEndIndex = i;
+      break;
+    }
+  }
+
+  // Find mainline move to replace
+  let targetMoveIndex = -1;
+  for (let i = sidelinePositionIndex - 1; i >= 0; i--) {
+    if (moments[i].depth === targetDepth && moments[i].move) {
+      targetMoveIndex = i;
+      break;
+    }
+  }
+  if (targetMoveIndex === -1) return moments;
+
+  // Find end of mainline segment to demote
+  let targetSegmentEndIndex = moments.length;
+  let seenTargetDepthMove = false;
+  for (let i = targetMoveIndex + 1; i < moments.length; i++) {
+    const moment = moments[i];
+
+    if (moment.depth === targetDepth && moment.move) {
+      seenTargetDepthMove = true;
+    }
+
+    if (moment.depth < targetDepth) {
+      targetSegmentEndIndex = i;
+      break;
+    }
+
+    if (moment.depth === targetDepth && !moment.move && seenTargetDepthMove) {
+      targetSegmentEndIndex = i;
+      break;
+    }
+  }
+
+  const demotedIndices = new Set([targetMoveIndex]);
+  const demotedMoves = [{ ...moments[targetMoveIndex], depth: currentDepth }];
+
+  for (let i = targetMoveIndex + 1; i < targetSegmentEndIndex; i++) {
+    if (moments[i].depth === targetDepth && moments[i].move) {
+      demotedIndices.add(i);
+      demotedMoves.push({ ...moments[i], depth: currentDepth });
+    }
+  }
+
+  // Rebuild the moments array by promoting the current move to the mainline depth,
+  // demoting the old mainline sequence into the sideline, preserving order of
+  // unaffected moves, and adjusting depths/indices accordingly.
+  const result = [];
+
+  for (let i = 0; i < targetMoveIndex; i++) {
+    result.push({ ...moments[i] });
+  }
+
+  result.push({ ...moments[current.index], depth: targetDepth });
+
+  for (let i = targetMoveIndex + 1; i < sidelinePositionIndex; i++) {
+    if (!demotedIndices.has(i)) {
+      result.push({ ...moments[i] });
+    }
+  }
+
+  result.push({ ...moments[sidelinePositionIndex] });
+  for (const move of demotedMoves) {
+    result.push(move);
+  }
+
+  for (let i = sidelinePositionIndex + 1; i < sidelineEndIndex; i++) {
+    if (i === current.index) continue;
+
+    const moment = moments[i];
+    if (moment.depth === currentDepth && moment.move) {
+      result.push({ ...moment, depth: targetDepth });
+    } else {
+      result.push({ ...moment });
+    }
+  }
+
+  for (let i = sidelineEndIndex; i < moments.length; i++) {
+    if (!demotedIndices.has(i)) {
+      result.push({ ...moments[i] });
+    }
+  }
+
+  // Reassign indices
+  result.forEach((m, i) => {
+    m.index = i;
+  });
+
+  return result;
+};
+
+module.exports = promoteMainline;

package/functions/helpers/index.js

@@ -2,6 +2,7 @@ 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 isNextFen = require('./is-next-fen');
 const prepareMoment = require('./prepare-moment');
 
 module.exports = {
@@ -9,5 +10,6 @@ module.exports = {
   getBrushColor,
   getMoveNumber,
   insertMomentIntoTree,
+  isNextFen,
   prepareMoment,
 };

package/functions/helpers/is-next-fen.js

@@ -0,0 +1,42 @@
+/**
+ * Determines if nextFen comes immediately after currentFen in a chess game
+ *
+ * @param {String} currentFen - The current FEN position
+ * @param {String} nextFen - The potential next FEN position
+ * @returns {Boolean} - True if nextFen comes immediately after currentFen
+ */
+const isNextFen = (currentFen, nextFen) => {
+  try {
+    // Parse FEN components
+    const currentParts = currentFen.split(' ');
+    const nextParts = nextFen.split(' ');
+
+    // Validate FEN format (should have 6 parts each)
+    if (currentParts.length !== 6 || nextParts.length !== 6) {
+      return false;
+    }
+
+    const currentActiveColor = currentParts[1]; // 'w' or 'b' - who moves in current position
+    const currentFullmove = Number(currentParts[5]);
+
+    const nextActiveColor = nextParts[1]; // 'w' or 'b' - who moves in next position
+    const nextFullmove = Number(nextParts[5]);
+
+    // Check if the active color and fullmove number progression is valid
+    if (currentActiveColor === 'w') {
+      // If white is to move in current position, then after white's move:
+      // - Black should be to move in next position
+      // - Fullmove number should remain the same
+      return nextActiveColor === 'b' && nextFullmove === currentFullmove;
+    } else {
+      // If black is to move in current position, then after black's move:
+      // - White should be to move in next position
+      // - Fullmove number should increment by 1
+      return nextActiveColor === 'w' && nextFullmove === currentFullmove + 1;
+    }
+  } catch (error) {
+    return false;
+  }
+};
+
+module.exports = isNextFen;

package/index.js

@@ -6,6 +6,7 @@ const {
   getPrevMoment,
   momentsToPgn,
   moveTrainer,
+  promoteMainline
 } = require('./functions/extras');
 
 module.exports = {
@@ -20,4 +21,5 @@ module.exports = {
   getPrevMoment,
   momentsToPgn,
   moveTrainer,
+  promoteMainline
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chess-moments",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "PGN parser that transforms PGN files into chess \"moments\"",
   "main": "index.js",
   "files": [