lettersoup 1.0.2 → 1.1.0

package/README.md

@@ -1,4 +1,4 @@
-# LetterSoup (Algorithm) (no Production now)
+# LetterSoup (Algorithm)
 
 Algorithm for make letterSoups (sopa de letras)
 
@@ -10,21 +10,51 @@ Algorithm for make letterSoups (sopa de letras)
 
 ## Import/Examples
 
-```Javascript
-import { WordSearch } from 'letterSoup'
+```javascript
+import { WordSearch } from 'lettersoup';
 
-const listWords = ['Doctor', 'Dog', 'Banana']
+const listWords = ['Doctor', 'Dog', 'Banana', 'Apple', 'Orange'];
 
-const {
-      getPuzzle,
-      getWords
-    } = new WordSearch(wordsArray)
+const wordSearch = new WordSearch(listWords);
 
-const puzzle = getPuzzle()
-const words = getWords()
+const puzzle = wordSearch.getPuzzle();
+const words = wordSearch.getWords();
+
+console.log('Puzzle:', puzzle);
+console.log('Words:', words);
 ```
 
 
+## API Reference
+
+### `new WordSearch(words: string[])`
+
+Creates a new instance of WordSearch.
+
+-   `words` (string[]): A list of words to be included in the letter soup.
+
+### `getPuzzle(): string[][]`
+
+Returns the generated letter soup as a 2D array of strings.
+
+### `getWords(): string[]`
+
+Returns the list of words that were included in the letter soup.
+
+### `getRemainingWords(): string[]`
+
+Returns the list of words that could not be placed in the letter soup.
+
+## Board Expansion
+
+The board is sized from the longest word plus a margin gap of `1` cell on every side, so every word geometrically fits in the puzzle. However, the placement heuristic walks the board coordinates in random order and tries to place a single word per visited coordinate, so a coordinate may lose its chance before the space around it is opened by other words.
+
+To fix that, the generator re-walks **all** coordinates over and over (re-shuffled on every pass) until a full pass places nothing — a fixed point. Only then, if words are still pending, the board is expanded by one extra row and one extra column and the process restarts.
+
+- Expansions are capped at `MAX_EXPANSIONS = 3` to avoid growing forever when a word truly cannot fit.
+- Words that still cannot be placed after the limit are returned by `getRemainingWords()`.
+- The puzzle is not filled with random letters: blank cells remain as separators.
+
 ## Run Locally
 
 Clone repository
@@ -66,8 +96,35 @@ To run tests, run the following command
   npm run test
 ```
 
+## Contributing
+
+Contributions are always welcome!
+
+Please adhere to this project's `code of conduct`.
+
+### Pull Request Process
+
+1.  Ensure any install or build dependencies are removed before the end of the layer when doing a build.
+2.  Update the README.md with details of changes to the interface, this includes new environment variables, exposed ports, useful file locations and container parameters.
+3.  Increase the version numbers in any examples files and the README.md to the new version that this Pull Request would represent.
+4.  You may merge the Pull Request in once you have the sign-off of two other developers, or if you do not have permission to do that, you may request the second reviewer to merge it for you.
+
+### Bug Reports
+
+Please include the following information when reporting a bug:
+
+-   A clear and descriptive title.
+-   A detailed description of the bug.
+-   Steps to reproduce the bug.
+-   The expected behavior.
+-   The actual behavior.
+-   Screenshots or videos if possible.
+
 
 ## Authors
 
 - [@Fabian Escarate](https://www.github.com/FabianEscarate)
 
+## License
+
+[ISC](https://choosealicense.com/licenses/isc/)

package/dist/Entities/Cordenates.d.ts

@@ -0,0 +1,20 @@
+import { orientationType } from "../Types";
+import PlayBoard from "./PlayBoard";
+export declare class Cordenate {
+    cordX: number;
+    cordY: number;
+    constructor(cordX: number, cordY: number);
+}
+export default class Cordenates {
+    private board;
+    private allCordsOfMatrix;
+    constructor(_board: PlayBoard);
+    private getAllCordsOfMatrix;
+    scrambleCordsOfMatrix: () => Cordenate[];
+    getEmptySlots: () => Cordenate[];
+    private getHorizontalCordsByCordenate;
+    private getVerticalCordenatesByCordenate;
+    private getDiagonalCordenatesByCordenate;
+    private getAntiDiagonalCordenatesByCordenate;
+    getCordsByOrientationAndCordenate: (orientation: orientationType, currentCordenate: Cordenate) => Cordenate[];
+}

package/dist/Entities/Cordenates.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cordenate = void 0;
+class Cordenate {
+    constructor(cordX, cordY) {
+        this.cordX = cordX;
+        this.cordY = cordY;
+    }
+}
+exports.Cordenate = Cordenate;
+class Cordenates {
+    constructor(_board) {
+        this.getAllCordsOfMatrix = (dimensionMatrix) => {
+            const { width, height } = dimensionMatrix;
+            const result = [];
+            for (let x = 0; x < height; x++)
+                for (let y = 0; y < width; y++)
+                    result.push(new Cordenate(x, y));
+            return result;
+        };
+        this.scrambleCordsOfMatrix = () => {
+            let scrambleCords = [];
+            const cordsOfMatrix = this.allCordsOfMatrix.slice();
+            while (cordsOfMatrix.length > 0) {
+                scrambleCords.push(cordsOfMatrix.splice(Math.floor(Math.random() * cordsOfMatrix.length), 1)[0]);
+            }
+            return scrambleCords;
+        };
+        this.getEmptySlots = () => {
+            return this.allCordsOfMatrix.slice().filter((cord) => this.board.getPlayBoard()[cord.cordX][cord.cordY] === ' ');
+        };
+        this.getHorizontalCordsByCordenate = (cordenate) => {
+            const result = [];
+            const { width } = this.board.getDimension();
+            const { cordX } = cordenate;
+            for (let i = 0; i < width; i++) {
+                result.push(new Cordenate(cordX, i));
+            }
+            return result;
+        };
+        this.getVerticalCordenatesByCordenate = (cordenate) => {
+            const result = [];
+            const { height } = this.board.getDimension();
+            const { cordY } = cordenate;
+            for (let i = 0; i < height; i++) {
+                result.push(new Cordenate(i, cordY));
+            }
+            return result;
+        };
+        this.getDiagonalCordenatesByCordenate = (cordenate) => {
+            const result = [];
+            const { width, height } = this.board.getDimension();
+            const { cordX, cordY } = cordenate;
+            for (let x = Math.max(0, cordX - cordY); x < Math.min(height, height + cordX - cordY); x++) {
+                const y = x - (cordX - cordY);
+                if (0 <= y && y < width) {
+                    result.push(new Cordenate(x, y));
+                }
+            }
+            return result;
+        };
+        this.getAntiDiagonalCordenatesByCordenate = (cordenate) => {
+            const result = [];
+            const { width, height } = this.board.getDimension();
+            const { cordX, cordY } = cordenate;
+            for (let x = Math.max(0, cordX + cordY - width + 1); x < Math.min(height, cordX + cordY + 1); x++) {
+                const y = cordX + cordY - x;
+                if (0 <= y && y < width) {
+                    result.push(new Cordenate(x, y));
+                }
+            }
+            return result.reverse();
+        };
+        this.getCordsByOrientationAndCordenate = (orientation, currentCordenate) => {
+            switch (orientation) {
+                case "horizontally":
+                    return this.getHorizontalCordsByCordenate(currentCordenate);
+                case "vertically":
+                    return this.getVerticalCordenatesByCordenate(currentCordenate);
+                case "diagonally":
+                    return this.getDiagonalCordenatesByCordenate(currentCordenate);
+                case "antidiagonally":
+                    return this.getAntiDiagonalCordenatesByCordenate(currentCordenate);
+            }
+        };
+        this.board = _board;
+        this.allCordsOfMatrix = this.getAllCordsOfMatrix(_board.getDimension());
+    }
+}
+exports.default = Cordenates;

package/dist/Entities/CrossRow.d.ts

@@ -0,0 +1,14 @@
+import { orientationType, regexValueByLineType } from "../Types";
+import '../utils/string';
+import { Cordenate } from "./Cordenates";
+import PlayBoard from "./PlayBoard";
+export default class CrossRow {
+    private board;
+    private horizontallyRowCordenates;
+    private verticallyRowCordenates;
+    private diagonallyDownRowCordenates;
+    private diagonallyUpRowCordenates;
+    constructor(_board: PlayBoard, currentPosition: Cordenate);
+    getLinesWithRegex: () => regexValueByLineType;
+    getLineByOrientation: (orientation: orientationType) => string;
+}

package/dist/Entities/CrossRow.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Types_1 = require("../Types");
+const regex_1 = require("../utils/regex");
+require("../utils/string");
+class CrossRow {
+    constructor(_board, currentPosition) {
+        this.getLinesWithRegex = () => {
+            const lines = {
+                horizontallyLine: this.horizontallyRowCordenates.map(cord => this.board.getSlot(cord.cordX, cord.cordY)).join(''),
+                verticallyLine: this.verticallyRowCordenates.map(cord => this.board.getSlot(cord.cordX, cord.cordY)).join(''),
+                diagonallyDownLine: this.diagonallyDownRowCordenates.map(cord => this.board.getSlot(cord.cordX, cord.cordY)).join(''),
+                diagonallyUpLine: this.diagonallyUpRowCordenates.map(cord => this.board.getSlot(cord.cordX, cord.cordY)).join('')
+            };
+            const regexForLines = Object.keys(lines).reduce((result, key) => {
+                const newObj = {};
+                newObj[`regex${key.capitalize()}`] = (0, regex_1.generateRegexByLine)(lines[key]);
+                return Object.assign(Object.assign({}, result), newObj);
+            }, {});
+            return regexForLines;
+        };
+        this.getLineByOrientation = (orientation) => {
+            let selectedOrientation;
+            switch (orientation) {
+                case "horizontally":
+                    selectedOrientation = this.horizontallyRowCordenates;
+                case "vertically":
+                    selectedOrientation = this.verticallyRowCordenates;
+                case "diagonally":
+                    selectedOrientation = this.diagonallyDownRowCordenates;
+                case "antidiagonally":
+                    selectedOrientation = this.diagonallyUpRowCordenates;
+            }
+            return selectedOrientation.map(cord => this.board.getSlot(cord.cordX, cord.cordY)).join('');
+        };
+        const { cordenates: { getCordsByOrientationAndCordenate }, } = _board;
+        this.board = _board;
+        this.horizontallyRowCordenates = getCordsByOrientationAndCordenate(Types_1.orientationEnum.horizontally, currentPosition);
+        this.verticallyRowCordenates = getCordsByOrientationAndCordenate(Types_1.orientationEnum.vertically, currentPosition);
+        this.diagonallyDownRowCordenates = getCordsByOrientationAndCordenate(Types_1.orientationEnum.diagonally, currentPosition);
+        this.diagonallyUpRowCordenates = getCordsByOrientationAndCordenate(Types_1.orientationEnum.antidiagonally, currentPosition);
+    }
+}
+exports.default = CrossRow;

package/dist/Entities/DimensionBoard.d.ts

@@ -0,0 +1,11 @@
+export type DimensionType = {
+    width: number;
+    height: number;
+};
+export default class DimensionBoard {
+    private width;
+    private height;
+    constructor(length: number);
+    getDimension(): DimensionType;
+    incrementDimensions(): void;
+}

package/dist/Entities/DimensionBoard.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MARGIN_PUZZLE = 1;
+class DimensionBoard {
+    constructor(length) {
+        this.width = MARGIN_PUZZLE + length + MARGIN_PUZZLE;
+        this.height = MARGIN_PUZZLE + length + MARGIN_PUZZLE;
+    }
+    getDimension() {
+        return {
+            width: this.width,
+            height: this.height
+        };
+    }
+    incrementDimensions() {
+        this.width++;
+        this.height++;
+    }
+}
+exports.default = DimensionBoard;

package/dist/Entities/PlayBoard.d.ts

@@ -0,0 +1,12 @@
+import Cordenates from "./Cordenates";
+import DimensionBoard from "./DimensionBoard";
+export default class PlayBoard extends DimensionBoard {
+    cordenates: Cordenates;
+    private board;
+    constructor(length: number);
+    private generate;
+    setSlot: (cordX: number, cordY: number, letter: string) => void;
+    getSlot: (cordX: number, cordY: number) => string;
+    getPlayBoard: () => string[][];
+    expandBoard: () => void;
+}

package/dist/Entities/PlayBoard.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cordenates_1 = __importDefault(require("./Cordenates"));
+const DimensionBoard_1 = __importDefault(require("./DimensionBoard"));
+const BLANK_SPACE = ' ';
+class PlayBoard extends DimensionBoard_1.default {
+    constructor(length) {
+        super(length);
+        this.generate = () => {
+            const { width, height } = this.getDimension();
+            const board = Array(...Array(width * height)).reduce((resultValue, currentValue, index, array) => {
+                resultValue = [...resultValue, array.splice(0, width).map(index => BLANK_SPACE)];
+                return resultValue;
+            }, []);
+            return board;
+        };
+        this.setSlot = (cordX, cordY, letter) => { this.board[cordX][cordY] = letter; };
+        this.getSlot = (cordX, cordY) => this.board[cordX][cordY];
+        this.getPlayBoard = () => this.board;
+        this.expandBoard = () => {
+            this.incrementDimensions();
+            const { width, height } = this.getDimension();
+            const newBoard = Array.from({ length: height }, () => Array.from({ length: width }, () => BLANK_SPACE));
+            for (let i = 0; i < this.board.length; i++) {
+                for (let j = 0; j < this.board[i].length; j++) {
+                    newBoard[i][j] = this.board[i][j];
+                }
+            }
+            this.board = newBoard;
+            this.cordenates = new Cordenates_1.default(this);
+        };
+        this.board = this.generate();
+        this.cordenates = new Cordenates_1.default(this);
+    }
+}
+exports.default = PlayBoard;

package/dist/Entities/Word.d.ts

@@ -0,0 +1,15 @@
+import { wordListByLineType } from "../Types";
+import { Cordenate } from "./Cordenates";
+import CrossRow from "./CrossRow";
+import PlayBoard from "./PlayBoard";
+export default class Words {
+    private board;
+    private listOfWords;
+    constructor(_board: PlayBoard, listOfWords: string[]);
+    listWords: () => string[];
+    getRemainingWords: () => string[];
+    hasMoreWordsToPut: () => boolean;
+    removeWord: (word: string) => void;
+    putWordByRowCordenates: (word: string, rowCordenates: Cordenate[], padStart?: number) => void;
+    getPossibleWordsByLines: (lines: CrossRow) => wordListByLineType;
+}

package/dist/Entities/Word.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LETTERS = 'ABCDEFGHIJKLMNÑOPQRSTUVWXYZ';
+class Words {
+    constructor(_board, listOfWords) {
+        this.listWords = () => {
+            return this.listOfWords;
+        };
+        this.getRemainingWords = () => {
+            return this.listOfWords.slice();
+        };
+        this.hasMoreWordsToPut = () => {
+            return this.listOfWords.length > 0;
+        };
+        this.removeWord = (word) => {
+            this.listOfWords.splice(this.listOfWords.indexOf(word), 1);
+        };
+        this.putWordByRowCordenates = (word, rowCordenates, padStart = 0) => {
+            let wordIndex = 0;
+            rowCordenates.forEach((cordenate, rowIndex) => {
+                if (rowIndex >= padStart && wordIndex < word.length) {
+                    this.board.setSlot(cordenate.cordX, cordenate.cordY, word.charAt(wordIndex));
+                    wordIndex++;
+                }
+            });
+        };
+        this.getPossibleWordsByLines = (lines) => {
+            const linesWithSearhRegex = lines.getLinesWithRegex();
+            const wordsByLine = Object.keys(linesWithSearhRegex).reduce((result, key) => {
+                const newObj = {};
+                newObj[`match${key.capitalize()}`] = this.listOfWords.filter(word => word.match(linesWithSearhRegex[key]));
+                return Object.assign(Object.assign({}, result), newObj);
+            }, {});
+            return wordsByLine;
+        };
+        this.board = _board;
+        this.listOfWords = listOfWords.slice();
+    }
+}
+exports.default = Words;

package/dist/Types.d.ts

@@ -0,0 +1,33 @@
+export type puzzleType = string[][];
+export type orientationType = "horizontally" | "vertically" | "diagonally" | "antidiagonally";
+export type linesByCordsType = {
+    horizontallyLine: string;
+    verticallyLine: string;
+    diagonallyDownLine: string;
+    diagonallyUpLine: string;
+};
+export declare enum matchRegexLines {
+    matchRegexDiagonallyDownLine = "diagonally",
+    matchRegexDiagonallyUpLine = "antidiagonally",
+    matchRegexHorizontallyLine = "horizontally",
+    matchRegexVerticallyLine = "vertically"
+}
+export type regexValueByLine<Type> = {
+    [key in keyof Type as `regex${Capitalize<string & key>}`]: RegExp;
+};
+export type regexValueByLineType = regexValueByLine<linesByCordsType>;
+export declare enum orientationEnum {
+    horizontally = "horizontally",
+    vertically = "vertically",
+    diagonally = "diagonally",
+    antidiagonally = "antidiagonally"
+}
+export type wordListByLine<Type> = {
+    [key in keyof Type as `match${Capitalize<string & key>}`]: string[];
+};
+export type wordListByLineType = wordListByLine<regexValueByLineType>;
+export type interectionType = {
+    wordIndex: number;
+    lineIndex: number;
+};
+export type interectionsType = interectionType[];

package/dist/Types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orientationEnum = exports.matchRegexLines = void 0;
+var matchRegexLines;
+(function (matchRegexLines) {
+    matchRegexLines["matchRegexDiagonallyDownLine"] = "diagonally";
+    matchRegexLines["matchRegexDiagonallyUpLine"] = "antidiagonally";
+    matchRegexLines["matchRegexHorizontallyLine"] = "horizontally";
+    matchRegexLines["matchRegexVerticallyLine"] = "vertically";
+})(matchRegexLines || (exports.matchRegexLines = matchRegexLines = {}));
+var orientationEnum;
+(function (orientationEnum) {
+    orientationEnum["horizontally"] = "horizontally";
+    orientationEnum["vertically"] = "vertically";
+    orientationEnum["diagonally"] = "diagonally";
+    orientationEnum["antidiagonally"] = "antidiagonally";
+})(orientationEnum || (exports.orientationEnum = orientationEnum = {}));

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import './utils/string';
+export { LetterSoup } from "./letterSoup";

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LetterSoup = void 0;
+require("./utils/string");
+var letterSoup_1 = require("./letterSoup");
+Object.defineProperty(exports, "LetterSoup", { enumerable: true, get: function () { return letterSoup_1.LetterSoup; } });

package/dist/letterSoup.d.ts

@@ -0,0 +1,16 @@
+export declare class LetterSoup {
+    private listOfWord;
+    private playBoard;
+    private words;
+    constructor(listOfWords: string[]);
+    private generate;
+    private tryPutWords;
+    private canPutWordByCrossRow;
+    private pickRandomElement;
+    private selectAnyMatch;
+    private getIntersections;
+    private checkIntersections;
+    getPuzzle: () => string[][];
+    getWords: () => string[];
+    getRemainingWords: () => string[];
+}

package/dist/letterSoup.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LetterSoup = void 0;
+const CrossRow_1 = __importDefault(require("./Entities/CrossRow"));
+const PlayBoard_1 = __importDefault(require("./Entities/PlayBoard"));
+const Word_1 = __importDefault(require("./Entities/Word"));
+const Types_1 = require("./Types");
+const regex_1 = require("./utils/regex");
+const MAX_EXPANSIONS = 3;
+class LetterSoup {
+    constructor(listOfWords) {
+        this.tryPutWords = (cord) => {
+            const crossRows = new CrossRow_1.default(this.playBoard, cord);
+            const canPutWord = this.canPutWordByCrossRow(crossRows);
+            if (!canPutWord)
+                return false;
+            const { orientation, wordSelected } = this.selectAnyMatch(canPutWord);
+            const lineCordenates = this.playBoard.cordenates.getCordsByOrientationAndCordenate(orientation, cord);
+            const orientedRow = lineCordenates.map(cord => this.playBoard.getSlot(cord.cordX, cord.cordY)).join('');
+            const intersections = this.getIntersections(wordSelected, orientedRow);
+            const intersection = this.checkIntersections(intersections, wordSelected, orientedRow);
+            if (intersection) {
+                this.words.putWordByRowCordenates(wordSelected, lineCordenates, (intersection.lineIndex - intersection.wordIndex));
+            }
+            else {
+                this.words.putWordByRowCordenates(wordSelected, lineCordenates);
+            }
+            this.words.removeWord(wordSelected);
+            return true;
+        };
+        this.canPutWordByCrossRow = (crossRows) => {
+            const wordsForEveryOrientation = this.words.getPossibleWordsByLines(crossRows);
+            const { matchRegexDiagonallyDownLine, matchRegexDiagonallyUpLine, matchRegexHorizontallyLine, matchRegexVerticallyLine } = wordsForEveryOrientation;
+            const canPutWord = [
+                matchRegexDiagonallyDownLine.length > 0,
+                matchRegexDiagonallyUpLine.length > 0,
+                matchRegexHorizontallyLine.length > 0,
+                matchRegexVerticallyLine.length > 0
+            ].some(Boolean);
+            if (!canPutWord)
+                return false;
+            return wordsForEveryOrientation;
+        };
+        this.pickRandomElement = (listOfElements) => {
+            return listOfElements[Math.floor(Math.random() * listOfElements.length)];
+        };
+        this.selectAnyMatch = (lineMatches) => {
+            const matchKeyToScramble = Object.keys(lineMatches)
+                .filter(keyLineMatch => lineMatches[keyLineMatch].length > 0);
+            const randomSelection = this.pickRandomElement(matchKeyToScramble);
+            return {
+                orientation: Types_1.matchRegexLines[randomSelection],
+                wordSelected: this.pickRandomElement(lineMatches[randomSelection]),
+            };
+        };
+        this.getIntersections = (word, line) => {
+            const listOfIntersections = [];
+            Array.from(word).forEach((wordLetter, wordIndex) => {
+                Array.from(line).forEach((lineLetter, lineIndex) => {
+                    if (wordLetter === lineLetter)
+                        listOfIntersections.push({
+                            lineIndex,
+                            wordIndex
+                        });
+                });
+            });
+            return listOfIntersections;
+        };
+        this.checkIntersections = (intersections, word, line) => {
+            if (intersections.length === 1)
+                return intersections[0];
+            if (intersections.length > 1) {
+                // console.warn('have more of one intersection')
+                const lengthLine = line.length;
+                const lengthWord = word.length;
+                return intersections.filter(intersection => {
+                    const diffIntersection = (intersection.lineIndex - intersection.wordIndex);
+                    if ((diffIntersection + lengthWord) > lengthLine || diffIntersection < 0) {
+                        return false;
+                    }
+                    const subStrLine = line.substring(diffIntersection, (diffIntersection + lengthWord));
+                    const regex = (0, regex_1.generateRegexByLine)(subStrLine);
+                    if (!regex.test(word)) {
+                        return false;
+                    }
+                    return true;
+                })[0];
+            }
+        };
+        this.getPuzzle = () => this.playBoard.getPlayBoard();
+        this.getWords = () => this.listOfWord;
+        this.getRemainingWords = () => this.words.getRemainingWords();
+        this.listOfWord = listOfWords.map(word => word.toUpperCase());
+        const maxWordLegth = Math.max(...listOfWords.map(word => word.length));
+        this.playBoard = new PlayBoard_1.default(maxWordLegth);
+        this.words = new Word_1.default(this.playBoard, this.listOfWord);
+        this.generate();
+    }
+    generate() {
+        let expansions = 0;
+        let isExpandable = true;
+        while (this.words.hasMoreWordsToPut() && isExpandable) {
+            let hasProgress = true;
+            while (hasProgress && this.words.hasMoreWordsToPut()) {
+                hasProgress = false;
+                const scrambleCordenates = this.playBoard.cordenates.scrambleCordsOfMatrix();
+                for (const currentCordenate of scrambleCordenates) {
+                    if (this.tryPutWords(currentCordenate))
+                        hasProgress = true;
+                }
+            }
+            if (!this.words.hasMoreWordsToPut())
+                return;
+            if (expansions >= MAX_EXPANSIONS) {
+                isExpandable = false;
+            }
+            else {
+                this.playBoard.expandBoard();
+                expansions++;
+            }
+        }
+    }
+}
+exports.LetterSoup = LetterSoup;

package/dist/utils/regex.d.ts

@@ -0,0 +1,8 @@
+declare const hasAnotherLetters: (space: string) => boolean;
+declare const isWhiteSpace: (groupToText: string) => boolean;
+declare const splitsGroupOfSpacesAndLetter: (line: string) => RegExpMatchArray;
+declare const chunkListCharactersByCriterial: (groups: RegExpMatchArray) => string[][];
+declare const joinRegexStringWithPipe: (...stringRegex: string[]) => string;
+declare const generateRegexByGroupOfSpacesAndLetters: (groups: RegExpMatchArray) => RegExp;
+declare const generateRegexByLine: (line: string) => RegExp;
+export { hasAnotherLetters, isWhiteSpace, splitsGroupOfSpacesAndLetter, joinRegexStringWithPipe, chunkListCharactersByCriterial, generateRegexByGroupOfSpacesAndLetters, generateRegexByLine };