chess-moments 0.14.0 → 0.14.2

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

@@ -0,0 +1,65 @@
+/**
+ * Always returns an array because there can be more than one next moment
+ */
+const getNextMoments = (moments, current) => {
+  try {
+    const next = [];
+    const sameDepth = moments[moments.indexOf(current) + 1];
+    if (sameDepth.move && sameDepth.depth === current.depth) {
+      next.push(sameDepth);
+    }
+
+    // If it's the first moment without move, add the next moment
+    if (current.index === 0 && !current.move) {
+      next.push(moments[1]);
+    }
+
+    // Split moments after the current index
+    const currentIndex = moments.indexOf(current);
+    const moves = moments.slice(currentIndex + 1).filter((m) => m.move);
+
+    // Add fullmove number to the current moment
+    current.fullmove = Number(current.fen.split(' ')[5]);
+
+    // Active color is white
+    if (current.fen.split(' ')[1] === 'w') {
+      for (const moment of moves) {
+        const activeColor = moment.fen.split(' ')[1];
+        const fullmove = Number(moment.fen.split(' ')[5]);
+
+        // Check if the next moment is a valid move for white
+        if (
+          moment.depth === current.depth + 1 &&
+          activeColor === 'b' &&
+          fullmove === current.fullmove
+        ) {
+          next.push(moment);
+        }
+      }
+    }
+
+    // Active color is black
+    if (current.fen.split(' ')[1] === 'b') {
+      for (const moment of moves) {
+        const activeColor = moment.fen.split(' ')[1];
+        const fullmove = Number(moment.fen.split(' ')[5]);
+
+        // Check if the next moment is a valid move for black
+        if (
+          moment.depth === current.depth + 1 &&
+          activeColor === 'w' &&
+          fullmove === current.fullmove + 1
+        ) {
+          next.push(moment);
+        }
+      }
+    }
+
+    // If no next moment is found, return an empty array
+    return next;
+  } catch {
+    return [];
+  }
+};
+
+module.exports = getNextMoments;

package/functions/extras/get-prev-moment.js

@@ -0,0 +1,66 @@
+/**
+ * Always returns an object because there can be only one previous moment
+ */
+const getPrevMoment = (moments, current) => {
+  try {
+    const sameDepth = moments[moments.indexOf(current) - 1];
+    if (sameDepth.move && sameDepth.depth === current.depth) {
+      return sameDepth;
+    }
+
+    // If it's the first moment with move, return the previous moment (starting position)
+    if (current.index === 1 && current.move) {
+      return moments[0];
+    }
+
+    // Split moments until the current index
+    const currentIndex = moments.indexOf(current);
+    const moves = moments.slice(0, currentIndex).filter((m) => m.move);
+
+    // Add fullmove number to the current moment
+    current.fullmove = Number(current.fen.split(' ')[5]);
+
+    // Active color is white
+    if (current.fen.split(' ')[1] === 'w') {
+      // Traverse moves in reverse order to optimize search
+      for (let i = moves.length - 1; i >= 0; i--) {
+        const moment = moves[i];
+        const activeColor = moment.fen.split(' ')[1];
+        const fullmove = Number(moment.fen.split(' ')[5]);
+
+        if (
+          moment.depth === current.depth - 1 &&
+          activeColor === 'b' &&
+          fullmove === current.fullmove - 1
+        ) {
+          return moment;
+        }
+      }
+    }
+
+    // Active color is black
+    if (current.fen.split(' ')[1] === 'b') {
+      // Traverse moves in reverse order to optimize search
+      for (let i = moves.length - 1; i >= 0; i--) {
+        const moment = moves[i];
+        const activeColor = moment.fen.split(' ')[1];
+        const fullmove = Number(moment.fen.split(' ')[5]);
+
+        if (
+          moment.depth === current.depth - 1 &&
+          activeColor === 'w' &&
+          fullmove === current.fullmove
+        ) {
+          return moment;
+        }
+      }
+    }
+
+    // If no previous moment is found, return an empty object
+    return {};
+  } catch {
+    return {};
+  }
+};
+
+module.exports = getPrevMoment;

package/functions/extras/index.js

@@ -0,0 +1,11 @@
+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 = {
+  getNextMoments,
+  getPrevMoment,
+  momentsToPgn,
+  moveTrainer,
+};

package/functions/extras/moments-to-pgn.js

@@ -0,0 +1,158 @@
+const fen = require('../fen');
+const { getBrushCode } = require('../helpers');
+
+/**
+ * Converts chess moments back to PGN format
+ * @param {Array} moments - Array of chess moment objects
+ * @returns {String} PGN string
+ */
+const momentsToPgn = (moments) => {
+  if (!Array.isArray(moments) || moments.length === 0) {
+    return '';
+  }
+
+  let pgn = '';
+  let currentDepth = 1;
+  let variationStack = [];
+
+  // Check if we need to add FEN headers for non-standard starting position
+  const initialMoment = moments[0];
+  if (initialMoment && initialMoment.fen && initialMoment.fen !== fen.initial) {
+    pgn += `[SetUp "1"]\n`;
+    pgn += `[FEN "${initialMoment.fen}"]\n\n`;
+  }
+
+  for (let i = 0; i < moments.length; i++) {
+    const moment = moments[i];
+    const depth = moment.depth || 1;
+
+    // Handle moments without moves (initial position or variation breaks)
+    if (!moment.move) {
+      // If this is a variation marker (depth > 1) and not the initial position
+      if (depth > 1 && i > 0) {
+        // Check if we need to start a new variation at the same depth
+        if (depth === currentDepth) {
+          // Close current variation and start a new one at the same level
+          pgn += ') (';
+        } else if (depth > currentDepth) {
+          // Starting a new variation at a deeper level
+          variationStack.push(currentDepth);
+          pgn += ' (';
+          currentDepth = depth;
+        }
+      }
+
+      // Add initial comment if present
+      if (moment.comment) {
+        pgn += `{${moment.comment}} `;
+      }
+      continue;
+    }
+
+    // Determine who made this move and what move number it is from the FEN
+    const fenParts = moment.fen.split(' ');
+    const activeColorAfterMove = fenParts[1]; // 'w' or 'b' - who moves next
+    const fullmoveNumber = parseInt(fenParts[5]);
+
+    // If black is to move after this move, then white made this move
+    const moveWasByWhite = activeColorAfterMove === 'b';
+    // For white moves, the move number is the fullmove number
+    // For black moves, the move number is fullmove number - 1 (since fullmove increments after black's move)
+    const moveNumber = moveWasByWhite ? fullmoveNumber : fullmoveNumber - 1;
+
+    // Handle depth changes (variations)
+    if (depth > currentDepth) {
+      // Starting a new variation
+      variationStack.push(currentDepth);
+      pgn += ' (';
+      currentDepth = depth;
+    } else if (depth < currentDepth) {
+      // Ending variation(s) - close as many as needed to get to the right depth
+      while (currentDepth > depth) {
+        variationStack.pop();
+        pgn += ')';
+        currentDepth--;
+      }
+      if (pgn.endsWith(')')) {
+        pgn += ' ';
+      }
+    }
+
+    // Add move number for white moves or when starting a variation
+    if (moveWasByWhite || (depth > 1 && pgn.endsWith('('))) {
+      pgn += `${moveNumber}.`;
+      if (!moveWasByWhite) {
+        pgn += '..';
+      }
+      pgn += ' ';
+    }
+
+    // Add the move
+    pgn += moment.move;
+
+    // Add comment if present
+    if (moment.comment) {
+      pgn += ` {${moment.comment}}`;
+    }
+
+    // Add shapes if present
+    if (moment.shapes && moment.shapes.length > 0) {
+      let shapesComment = '';
+      const squareHighlights = moment.shapes.filter(
+        (s) => !s.dest || s.dest === ']'
+      );
+      const arrows = moment.shapes.filter((s) => s.dest && s.dest !== ']');
+
+      if (squareHighlights.length > 0) {
+        const coloredSquares = squareHighlights
+          .map((s) => {
+            const colorCode = getBrushCode(s.brush);
+            return `${colorCode}${s.orig}`;
+          })
+          .join(',');
+        shapesComment += `[%csl ${coloredSquares}]`;
+      }
+
+      if (arrows.length > 0) {
+        const coloredArrows = arrows
+          .map((s) => {
+            const colorCode = getBrushCode(s.brush);
+            return `${colorCode}${s.orig}${s.dest}`;
+          })
+          .join(',');
+        if (shapesComment) shapesComment += ' ';
+        shapesComment += `[%cal ${coloredArrows}]`;
+      }
+
+      if (shapesComment) {
+        if (moment.comment) {
+          // If there's already a comment, add shapes to it
+          pgn = pgn.replace(/\{([^}]*)\}$/, `{$1 ${shapesComment}}`);
+        } else {
+          pgn += ` {${shapesComment}}`;
+        }
+      }
+    }
+
+    // Add space after move if not the last move
+    if (i < moments.length - 1) {
+      const nextMoment = moments[i + 1];
+      if (nextMoment && nextMoment.move) {
+        pgn += ' ';
+      }
+    }
+  }
+
+  // Close any remaining variations
+  while (variationStack.length > 0) {
+    variationStack.pop();
+    pgn += ')';
+  }
+
+  // Add default result
+  pgn += ' *';
+
+  return pgn.trim();
+};
+
+module.exports = momentsToPgn;

package/functions/{train.js → extras/move-trainer.js}

@@ -1,8 +1,8 @@
 const { flatten } = require('lodash');
-const splitByMoveIndex = require('./split-by-move');
-const tree = require('./tree');
+const splitByMoveIndex = require('../split-by-move');
+const tree = require('../tree');
 
-const train = (sloppyPgn, fen) => {
+const moveTrainer = (sloppyPgn, fen) => {
   // Tree is an array of array depths
   const moments = tree(sloppyPgn);
 
@@ -52,4 +52,4 @@ const train = (sloppyPgn, fen) => {
   return training;
 };
 
-module.exports = train;
+module.exports = moveTrainer;

package/functions/helpers/get-brush-code.js

@@ -0,0 +1,14 @@
+/**
+ * Convert brush color name to PGN color code
+ */
+const getBrushCode = (brush) => {
+  const brushCodes = {
+    green: 'G',
+    red: 'R',
+    blue: 'B',
+    yellow: 'Y',
+  };
+  return brushCodes[brush] || 'G';
+};
+
+module.exports = getBrushCode;

package/functions/helpers/get-brush-color.js

@@ -0,0 +1,15 @@
+/**
+ * Convert PGN color code to brush color name
+ */
+const getBrushColor = (letter) => {
+  const brushes = {
+    R: 'red',
+    Y: 'yellow',
+    G: 'green',
+    B: 'blue',
+  };
+
+  return brushes[letter] || 'green';
+};
+
+module.exports = getBrushColor;

package/functions/helpers/index.js

@@ -0,0 +1,7 @@
+const getBrushCode = require('./get-brush-code');
+const getBrushColor = require('./get-brush-color');
+
+module.exports = {
+  getBrushCode,
+  getBrushColor,
+};

package/functions/index.js

@@ -8,7 +8,6 @@ const prepare = require('./prepare');
 const prettify = require('./prettify');
 const shape = require('./shape');
 const split = require('./split');
-const train = require('./train');
 const tree = require('./tree');
 
 module.exports = {
@@ -22,6 +21,5 @@ module.exports = {
   prettify,
   shape,
   split,
-  train,
   tree,
 };

package/index.js

@@ -1,17 +1,18 @@
-const { fen, pgn, flat, train, tree } = require('./functions');
+const { fen, pgn, flat, tree } = require('./functions');
 const {
   getNextMoments,
   getPrevMoment,
   momentsToPgn,
+  moveTrainer,
 } = require('./functions/extras');
 
 module.exports = {
   fen,
   pgn,
   flat,
-  train,
   tree,
   getNextMoments,
   getPrevMoment,
   momentsToPgn,
+  moveTrainer,
 };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "chess-moments",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "PGN parser that transforms PGN files into chess \"moments\"",
   "main": "dist/index.js",
   "files": [
     "index.js",
     "chess.js",
-    "functions/*.js"
+    "functions/**/*.js"
   ],
   "scripts": {
     "test": "mocha",