sudoku-pro 1.0.10 → 1.0.11

package/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+
+const { generateSudoku, printSudoku, waitForHint } = require("./sudoku-pro.js");
+
+const difficulty = (process.argv[2] || "m").toLowerCase();
+const { sudoku, solvedSudoku } = generateSudoku(difficulty);
+
+printSudoku(sudoku);
+waitForHint(sudoku, solvedSudoku);

package/esm.mjs

@@ -0,0 +1,12 @@
+import cjs from "./sudoku-pro.js";
+
+// Re-export as named exports (frontend-friendly)
+export const generateSudoku = cjs.generateSudoku;
+export const printSudoku = cjs.printSudoku;
+export const solveSudoku = cjs.solveSudoku;
+export const printSudokuWithAnswers = cjs.printSudokuWithAnswers;
+export const getHint = cjs.getHint;
+export const waitForHint = cjs.waitForHint;
+
+// Optional default export too (nice for interop)
+export default cjs;

package/package.json

@@ -1,59 +1,66 @@
 {
   "name": "sudoku-pro",
-  "version": "1.0.10",
-  "description": "sudoku-pro humbly presents itself as your go-to toolkit for generating, solving, and printing Sudoku puzzles spanning different difficulty levels. Powered by the reliable backtracking algorithm, it aspires to offer enthusiasts and learners alike a simple yet effective platform to engage with Sudoku puzzles. With Sudoku-Pro, embark on a journey of brain-teasing challenges or delve into educational endeavors with ease. This humble interface aims to make Sudoku puzzle creation and enjoyment accessible to all, ensuring a delightful experience for users of varying skill levels. Join us in exploring the possibilities of Sudoku puzzles while we humbly accompany you on your puzzle-solving adventures.",
-  "changelog": {
-    "1.0.6": "generateSudoku, printSudoku, solveSudoku",
-    "1.0.7": "getHint function added",
-    "1.0.8": "fixed the bug which cause issue while generating hard sudoku",
-    "1.0.10": "streamlined the code with concise logic, added very hard sudoku level"
-  },
-  "main": "sudoku-pro.js",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/concurdev/sudoku-pro.git"
+  "version": "1.0.11",
+  "description": "Sudoku generator, solver, and CLI tool. Works in terminal and frontend apps with a clean library-first design.",
+  "license": "MIT",
+  "author": "Ashish Vashisht",
+
+  "main": "./sudoku-pro.js",
+
+  "exports": {
+    ".": {
+      "import": "./esm.mjs",
+      "require": "./sudoku-pro.js"
+    }
   },
-  "scripts": {
-    "easy": "node sudoku-pro e",
-    "medium": "node sudoku-pro m",
-    "hard": "node sudoku-pro h",
-    "very": "node sudoku-pro v"
+
+  "bin": {
+    "sudoku-pro": "./cli.js"
   },
+
   "files": [
-    "sudoku-pro.js"
+    "sudoku-pro.js",
+    "esm.mjs",
+    "cli.js",
+    "README.md",
+    "LICENSE"
   ],
+
+  "scripts": {
+    "easy": "node cli.js e",
+    "medium": "node cli.js m",
+    "hard": "node cli.js h",
+    "very": "node cli.js v",
+    "test": "node -e \"const { generateSudoku } = require('./sudoku-pro'); const g = generateSudoku('m'); console.log(g.sudoku.length === 9 ? 'ok' : 'fail')\""
+  },
+
   "keywords": [
-    "Sudoku",
-    "Sudoku Algorithm",
-    "Sudoku Generator",
-    "Sudoku Solver",
-    "Sudoku Teaser",
-    "Sudoku Puzzle",
-    "Sudoku Engine",
-    "Sudoku Difficulty",
-    "Sudoku Logic",
-    "Easy Sudoku",
-    "Medium Sudoku",
-    "Hard Sudoku",
-    "Very hard Sudoku",
-    "Brain Teaser",
-    "Puzzle",
-    "Puzzle Game",
-    "Game",
-    "Board Game",
-    "Logic Game",
-    "Numbers Game",
-    "Recreational Mathematics",
-    "Backtracking"
+    "sudoku",
+    "sudoku-generator",
+    "sudoku-solver",
+    "sudoku-cli",
+    "puzzle",
+    "game",
+    "logic-game",
+    "backtracking",
+    "board-game",
+    "brain-teaser"
   ],
-  "author": "Ashish Vashisht",
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
+
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/concurdev/sudoku-pro.git"
   },
+
   "bugs": {
     "url": "https://github.com/concurdev/sudoku-pro/issues"
   },
+
   "homepage": "https://github.com/concurdev/sudoku-pro#readme",
-  "devDependencies": {}
+
+  "engines": {
+    "node": ">=14"
+  },
+
+  "sideEffects": false
 }

package/sudoku-pro.js

@@ -1,10 +1,9 @@
-const readline = require("readline");
+"use strict";
 
-// Get the difficulty level
-const args = process.argv.slice(2);
+// NOTE: No top-level require("readline").
+// This file is safe to import in frontend bundlers.
 
 function shuffle(array) {
-  // Fisher-Yates shuffle algorithm
   for (let i = array.length - 1; i > 0; i--) {
     const j = Math.floor(Math.random() * (i + 1));
     [array[i], array[j]] = [array[j], array[i]];
@@ -15,7 +14,7 @@ function shuffle(array) {
 function generateSudoku(difficulty) {
   const sudoku = Array.from({ length: 9 }, () => Array(9).fill(0));
 
-  // Fill the diagonal blocks (3x3 sub-grids) with valid numbers
+  // Fill diagonal blocks
   for (let i = 0; i < 9; i += 3) {
     const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];
     shuffle(nums);
@@ -27,23 +26,23 @@ function generateSudoku(difficulty) {
   }
 
   // Solve the puzzle
-  const solvedSudoku = JSON.parse(JSON.stringify(sudoku)); // Create a deep copy for later use
+  const solvedSudoku = JSON.parse(JSON.stringify(sudoku));
   solveSudoku(solvedSudoku);
 
-  // Determine the number of cells to remove based on difficulty level
+  // Determine the number of cells to remove
   let numToRemove;
   switch (difficulty) {
     case "e":
-      numToRemove = ensureNumToRemoveInRange(20, 20); // Easy difficulty
+      numToRemove = ensureNumToRemoveInRange(20, 20);
       break;
     case "m":
-      numToRemove = ensureNumToRemoveInRange(25, 50); // Medium difficulty
+      numToRemove = ensureNumToRemoveInRange(25, 50);
       break;
     case "h":
-      numToRemove = ensureNumToRemoveInRange(30, 60); // Hard difficulty
+      numToRemove = ensureNumToRemoveInRange(30, 60);
       break;
     case "v":
-      numToRemove = ensureNumToRemoveInRange(35, 75); // Very hard difficulty
+      numToRemove = ensureNumToRemoveInRange(35, 75);
       break;
     default:
       throw new Error(
@@ -51,17 +50,15 @@ function generateSudoku(difficulty) {
       );
   }
 
-  // Create a copy of the solved Sudoku to remove cells from
   const sudokuCopy = JSON.parse(JSON.stringify(solvedSudoku));
 
-  // Remove some numbers to create the puzzle
   for (let i = 0; i < numToRemove; i++) {
     const row = Math.floor(Math.random() * 9);
     const col = Math.floor(Math.random() * 9);
     if (sudokuCopy[row][col] !== 0) {
       sudokuCopy[row][col] = 0;
     } else {
-      i--; // Try again if the cell is already empty
+      i--;
     }
   }
 
@@ -72,87 +69,61 @@ function ensureNumToRemoveInRange(lowerBound, upperBound) {
   let numToRemove;
   do {
     numToRemove = Math.floor(Math.random() * lowerBound) + upperBound;
-  } while (numToRemove > 81); // Ensure numToRemove is within the range 0-81
+  } while (numToRemove > 81);
   return numToRemove;
 }
 
 function solveSudoku(sudoku) {
   const emptyCell = findEmptyCell(sudoku);
-  if (!emptyCell) {
-    return true; // Puzzle solved successfully
-  }
+  if (!emptyCell) return true;
 
   const [row, col] = emptyCell;
   for (let num = 1; num <= 9; num++) {
     if (isValidMove(sudoku, row, col, num)) {
       sudoku[row][col] = num;
-      if (solveSudoku(sudoku)) {
-        return true;
-      }
-      sudoku[row][col] = 0; // Undo the assignment
+      if (solveSudoku(sudoku)) return true;
+      sudoku[row][col] = 0;
     }
   }
-
-  return false; // No solution found, backtrack
+  return false;
 }
 
 function findEmptyCell(sudoku) {
-  // Function to find an empty cell in the Sudoku grid
   for (let row = 0; row < 9; row++) {
     for (let col = 0; col < 9; col++) {
-      if (sudoku[row][col] === 0) {
-        return [row, col];
-      }
+      if (sudoku[row][col] === 0) return [row, col];
     }
   }
-  return null; // No empty cell found
+  return null;
 }
 
 function isValidMove(sudoku, row, col, num) {
-  // Check if assigning num to the cell at (row, col) is a valid move
-  // Check row
   for (let i = 0; i < 9; i++) {
-    if (sudoku[row][i] === num) {
-      return false; // Number already exists in the row
-    }
+    if (sudoku[row][i] === num) return false;
   }
-
-  // Check column
   for (let i = 0; i < 9; i++) {
-    if (sudoku[i][col] === num) {
-      return false; // Number already exists in the column
-    }
+    if (sudoku[i][col] === num) return false;
   }
 
-  // Check 3x3 subgrid
   const startRow = Math.floor(row / 3) * 3;
   const startCol = Math.floor(col / 3) * 3;
   for (let i = 0; i < 3; i++) {
     for (let j = 0; j < 3; j++) {
-      if (sudoku[startRow + i][startCol + j] === num) {
-        return false; // Number already exists in the subgrid
-      }
+      if (sudoku[startRow + i][startCol + j] === num) return false;
     }
   }
-
-  return true; // Valid move
+  return true;
 }
 
 function printSudoku(sudoku) {
   console.log("Sudoku Puzzle:");
   console.log("-------------------------");
   sudoku.forEach((row, rowIndex) => {
-    if (rowIndex % 3 === 0 && rowIndex !== 0) {
-      console.log("------|-------|-------");
-    }
+    if (rowIndex % 3 === 0 && rowIndex !== 0) console.log("------|-------|-------");
     row.forEach((cell, cellIndex) => {
-      if (cellIndex % 3 === 0 && cellIndex !== 0) {
-        process.stdout.write("| ");
-      }
+      if (cellIndex % 3 === 0 && cellIndex !== 0) process.stdout.write("| ");
       process.stdout.write(String(cell || ".") + " ");
-      if (cellIndex === 8) {
-        console.log();
-      }
+      if (cellIndex === 8) console.log();
     });
   });
   console.log("-------------------------");
@@ -162,78 +133,82 @@ function printSudokuWithAnswers(sudoku) {
   console.log("Sudoku Puzzle with Answers:");
   console.log("-------------------------");
   sudoku.forEach((row, rowIndex) => {
-    if (rowIndex % 3 === 0 && rowIndex !== 0) {
-      console.log("------|-------|-------");
-    }
+    if (rowIndex % 3 === 0 && rowIndex !== 0) console.log("------|-------|-------");
     row.forEach((cell, cellIndex) => {
-      if (cellIndex % 3 === 0 && cellIndex !== 0) {
-        process.stdout.write("| ");
-      }
+      if (cellIndex % 3 === 0 && cellIndex !== 0) process.stdout.write("| ");
       process.stdout.write(String(cell) + " ");
-      if (cellIndex === 8) {
-        console.log();
-      }
+      if (cellIndex === 8) console.log();
     });
   });
   console.log("-------------------------");
 }
 
-function getHint(sudoku, solvedSudoku) {
+/**
+ * Browser-friendly hint:
+ * - same logic (fill a random empty cell)
+ * - DOES NOT console.log by default
+ * - Returns {row,col,value} or null
+ *
+ * If you want old behavior (printing), pass { log: true }.
+ */
+function getHint(sudoku, solvedSudoku, opts = {}) {
   const emptyCells = [];
   for (let i = 0; i < 9; i++) {
     for (let j = 0; j < 9; j++) {
-      if (sudoku[i][j] === 0) {
-        emptyCells.push([i, j]);
-      }
+      if (sudoku[i][j] === 0) emptyCells.push([i, j]);
     }
   }
   if (emptyCells.length === 0) {
-    console.log("No empty cells left to provide a hint.");
-    return;
+    if (opts.log) console.log("No empty cells left to provide a hint.");
+    return null;
   }
+
   const randomIndex = Math.floor(Math.random() * emptyCells.length);
   const [row, col] = emptyCells[randomIndex];
-  sudoku[row][col] = solvedSudoku[row][col];
-  console.log(
-    `Hint: The number at row ${row + 1}, column ${col + 1} is ${
-      solvedSudoku[row][col]
-    }`
-  );
+  const value = solvedSudoku[row][col];
+  sudoku[row][col] = value;
+
+  if (opts.log) {
+    console.log(`Hint: The number at row ${row + 1}, column ${col + 1} is ${value}`);
+  }
+
+  return { row, col, value };
 }
 
+/**
+ * Terminal-only function. Safe for bundlers because it loads readline dynamically.
+ * If you call it in the browser, it throws a clean error.
+ */
 function waitForHint(sudoku, solvedSudoku) {
+  if (typeof process === "undefined" || !process.stdin) {
+    throw new Error("waitForHint() is terminal-only (Node.js). Use getHint() in the browser.");
+  }
+
+  // Lazy require so browser builds don't crash
+  // eslint-disable-next-line global-require
+  const readline = require("readline");
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
   });
 
-  rl.question(
-    "Press 'h' for a hint or 'c' for the complete solution: ",
-    (answer) => {
-      if (answer.trim().toLowerCase() === "h") {
-        getHint(sudoku, solvedSudoku);
-        printSudoku(sudoku);
-      } else if (answer.trim().toLowerCase() === "c") {
-        printSudokuWithAnswers(solvedSudoku);
-        process.exit();
-      } else {
-        console.log(
-          "Invalid input. Please press 'h' for a hint or 'c' for the complete solution."
-        );
-      }
-      rl.close();
-      waitForHint(sudoku, solvedSudoku); // Ask again for hint or complete solution
+  rl.question("Press 'h' for a hint or 'c' for the complete solution: ", (answer) => {
+    const a = answer.trim().toLowerCase();
+    if (a === "h") {
+      getHint(sudoku, solvedSudoku, { log: true });
+      printSudoku(sudoku);
+    } else if (a === "c") {
+      printSudokuWithAnswers(solvedSudoku);
+      process.exit(0);
+    } else {
+      console.log("Invalid input. Please press 'h' for a hint or 'c' for the complete solution.");
     }
-  );
+    rl.close();
+    waitForHint(sudoku, solvedSudoku);
+  });
 }
 
-const difficulty = args[0]; // Get the difficulty level from command line arguments
-
-const { sudoku, solvedSudoku } = generateSudoku(difficulty);
-printSudoku(sudoku);
-
-waitForHint(sudoku, solvedSudoku);
-
 module.exports = {
   generateSudoku,
   printSudoku,