lettersoup 1.0.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.nvmrc

@@ -0,0 +1 @@
+v22.4.1

package/README.md

@@ -0,0 +1,62 @@
+# LetterSoup (Algorithm) (no Production now)
+
+Algorithm for make letterSoups (sopa de letras)
+
+
+## Import/Examples
+
+```Javascript
+import letterSoup from 'letterSoup'
+
+const listWords = ['Doctor', 'Dog', 'Banana']
+
+const result = letterSoup.generate(listWords)
+```
+
+
+## Run Locally
+
+Clone repository
+
+```bash
+  git clone https://github.com/FabianEscarate/letterSoup
+```
+
+Go to the project directory
+
+```bash
+  cd letterSoup
+```
+
+use current node version
+
+```bash
+  nvm use
+```
+
+Install dependencies
+
+```bash
+  npm install
+```
+
+Start the server
+
+```bash
+  npm start
+```
+
+
+## Running Tests
+
+To run tests, run the following command
+
+```bash
+  npm run test
+```
+
+
+## Authors
+
+- [@Fabian Escarate](https://www.github.com/FabianEscarate)
+

package/__tests__/index.test.ts

@@ -0,0 +1,36 @@
+import { WordSearch } from "../src"
+
+describe('letterSoup generator', () => {
+
+  const wordsArray = [
+    "tarjetas",
+    "Weaselling",
+    "Pinwales",
+    "populoso",
+    "participio",
+    "Cuddliest",
+    "Especias",
+    "teléfonos",
+    "epigráfico",
+    "hidrométrico",
+    "licitador",
+    "partición",
+    "miembros",
+    "nuestra",
+    "restituciones"
+  ]
+
+  test('should return a object when call generate function', () => {
+    const {
+      getPuzzle,
+      getWords
+    } = new WordSearch(wordsArray)
+
+    const listOfWord = getWords()
+    const puzzle = getPuzzle()
+
+    expect(puzzle).toBeDefined()
+    expect(listOfWord).toBeDefined()
+
+  })
+})

package/__tests__/utils/regex.test.ts

@@ -0,0 +1,80 @@
+import {
+  hasAnotherLetters,
+  generateRegexByGroupOfSpacesAndLetters, 
+  isWhiteSpace,
+  splitsGroupOfSpacesAndLetter,
+  chunkListCharactersByCriterial,
+  joinRegexStringWithPipe
+} from "../../src/utils/regex";
+
+
+describe('Regex Suite', () => {
+
+  test('should validate if line has letters', () => {
+    const lineWithLetters = '   sa   '
+    const lineWithOutLetters = '        '
+
+    expect(hasAnotherLetters(lineWithLetters)).toBeTruthy()
+    expect(hasAnotherLetters(lineWithOutLetters)).toBeFalsy()
+  })
+
+  test('should valid a empty string', () => {
+    const lineEmpty = '      '
+
+    expect(isWhiteSpace(lineEmpty)).toBeTruthy()
+  })
+
+  test('should valid a string with letters', () => {
+    const lineEmpty = 'asdf'
+
+    expect(!isWhiteSpace(lineEmpty)).toBeTruthy()
+  })
+
+  test('should return groups of space and letters', () => {
+    const lineGenerate = '       i    a    '.toUpperCase()
+
+    const splittedLine = splitsGroupOfSpacesAndLetter(lineGenerate)
+
+    if (!splittedLine) return
+
+    expect(splittedLine.length).toBe(5)
+    expect(splittedLine[1]).toBe('I')
+    expect(splittedLine[3]).toBe('A')
+  })
+
+  test('should join regex string with pipes', () => {
+    const firstRegex = '(^.{1,7}i.{4}a.{1,4}$)'
+    const secondRegex = '(^.{1,7}i.{1,4}$)'
+    const thirdRegex = '(^.{1,4}a.{1,4}$)'
+    const expectedStringRegex = '(^.{1,7}i.{4}a.{1,4}$)|(^.{1,7}i.{1,4}$)|(^.{1,4}a.{1,4}$)'
+
+    expect(
+      joinRegexStringWithPipe(
+        firstRegex,
+        secondRegex,
+        thirdRegex
+      )
+    ).toBe(expectedStringRegex)
+  })
+
+  test('should return chunked array', () => {
+    const groupToGenerate = ['       ', 'i', '    ', 'a', '    '] as RegExpMatchArray
+    const secondGroupToGenerate = ['s','      ', 'i', '    ', 'a', '   ', 'e'] as RegExpMatchArray
+
+    const chunkedArray = chunkListCharactersByCriterial(groupToGenerate)
+    const secondChunkedArray = chunkListCharactersByCriterial(secondGroupToGenerate)
+
+    expect(chunkedArray.length).toBe(2)
+    expect(secondChunkedArray.length).toBe(4)
+
+  })
+
+  test('should return regex expresion from expecific group of spaces and letters', () => {
+    const groupGenerate = ['       ', 'i', '    ', 'a', '    '] as RegExpMatchArray
+    const regexExpected = '/(^.{1,7}i.{4}a.{1,4}$)|(^.{1,7}i.{1,4}$)|(^.{1,4}a.{1,4}$)/gm'
+    const regexExpresionResult = generateRegexByGroupOfSpacesAndLetters(groupGenerate)
+
+    expect(regexExpresionResult.toString()).toBe(regexExpected)
+  })
+
+})

package/jest.config.js

@@ -0,0 +1,7 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+module.exports = {
+  testEnvironment: "node",
+  transform: {
+    "^.+.tsx?$": ["ts-jest",{}],
+  },
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "lettersoup",
+  "version": "1.0.0",
+  "description": "generate letterSoup",
+  "main": "src/index.ts",
+  "scripts": {
+    "start": "ts-node -e \"require('./src/index.ts').main()\"",
+    "test": "jest"
+  },
+  "keywords": [
+    "letterSoup",
+    "letters",
+    "search",
+    "searchword",
+    "word"
+  ],
+  "author": "Fabian Escarate",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  }
+}

package/src/Entities/Cords.ts

@@ -0,0 +1,127 @@
+import { orientationEnum, orientationType } from "../Types"
+import { DimensionType } from "./Dimension"
+import Lines from "./Lines"
+import Matrix from "./Matrix"
+
+
+
+export class Cord {
+  cordX: number
+  cordY: number
+
+  constructor(cordX: number, cordY: number) {
+    this.cordX = cordX
+    this.cordY = cordY
+  }
+}
+
+export default class Cords {
+  private matrix: Matrix
+  private currentPosition?: Cord = undefined
+  private allCordsOfMatrix: Cord[]
+  constructor(matrix: Matrix) {
+    this.matrix = matrix
+    this.allCordsOfMatrix = this.getAllCordsOfMatrix(matrix.dimension.getDimension())
+  }
+
+  private getAllCordsOfMatrix = (dimensionMatrix: DimensionType) => {
+    const {
+      width,
+      height
+    } = dimensionMatrix
+
+    const result = []
+
+    for (let x = 0; x < height; x++)
+      for (let y = 0; y < width; y++)
+        result.push(new Cord(x, y))
+
+    return result
+  }
+
+  scrambleCordsOfMatrix = () => {
+    let scrambleCords = []
+    const cordsOfMatrix = this.allCordsOfMatrix
+    while (cordsOfMatrix.length > 0) {
+      scrambleCords.push(cordsOfMatrix.splice(Math.floor(Math.random() * cordsOfMatrix.length), 1)[0])
+    }
+    return scrambleCords
+  }
+
+  setCordPosition = (cord: Cord) => {
+    this.currentPosition = cord
+    this.matrix.setLines(new Lines(this.matrix))
+  }
+
+  getCordPosition = () => {
+    if (!this.currentPosition)
+      throw new Error("Undefined current cord position ");
+
+    return this.currentPosition
+  }
+
+  private horizontalCords = (): Cord[] => {
+    const result = []
+    const { width } = this.matrix.dimension.getDimension()
+    const { cordX } = this.matrix.cords.getCordPosition()
+
+    for (let i = 0; i < width; i++) {
+      result.push(new Cord(cordX,i))
+    }
+    return result
+  }
+
+  private verticalCords = (): Cord[] => {
+    const result = []
+    const { height } = this.matrix.dimension.getDimension()
+    const { cordY } = this.matrix.cords.getCordPosition()
+
+    for (let i = 0; i < height; i++) {
+      result.push(new Cord(i, cordY))
+    }
+    return result
+  }
+
+  private diagonalCords = (): Cord[] => {
+    const result = []
+    const { width, height } = this.matrix.dimension.getDimension()
+    const { cordX, cordY } = this.matrix.cords.getCordPosition()
+
+    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 Cord(x, y));
+      }
+    }
+    return result
+  }
+
+  private antiDiagonalCords = (): Cord[] => {
+    const result = []
+    const { width, height } = this.matrix.dimension.getDimension()
+    const { cordX, cordY } = this.matrix.cords.getCordPosition()
+
+    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 Cord(x, y))
+      }
+    }
+
+    return result.reverse()
+  }
+
+  getCordsFromCurrentPositionByOrientation = (orientation: orientationType): Cord[] => {
+    switch (orientation) {
+      case "horizontally":
+        return this.horizontalCords()
+      case "vertically":
+        return this.verticalCords()
+      case "diagonally":
+        return this.diagonalCords()
+      case "antidiagonally":
+        return this.antiDiagonalCords()
+    }
+  }
+
+}

package/src/Entities/Dimension.ts

@@ -0,0 +1,24 @@
+
+const MARGIN_PUZZLE = 1
+
+export type DimensionType = {
+  width: number,
+  height: number
+}
+
+export default class DimensionPuzzle {
+  private width: number
+  private height: number
+
+  constructor(length: number) {
+    this.width = MARGIN_PUZZLE + length + MARGIN_PUZZLE
+    this.height = MARGIN_PUZZLE + length + MARGIN_PUZZLE
+  }
+
+  getDimension(): DimensionType {
+    return {
+      width: this.width,
+      height: this.height
+    }
+  }
+}

package/src/Entities/Lines.ts

@@ -0,0 +1,59 @@
+import { orientationEnum, orientationType, regexValueByLineType } from "../Types";
+import { generateRegexByLine } from "../utils/regex";
+import Matrix from "./Matrix";
+
+export default class Lines {
+  horizontallyLine: string = ''
+  verticallyLine: string = ''
+  diagonallyDownLine: string = ''
+  diagonallyUpLine: string = ''
+
+  constructor(matrix?: Matrix) {
+    if (!matrix)
+      return
+
+    const {
+      cords: { getCordsFromCurrentPositionByOrientation },
+      getSlot
+    } = matrix
+
+    this.horizontallyLine = getCordsFromCurrentPositionByOrientation(orientationEnum.horizontally).map(cord => getSlot(cord.cordX, cord.cordY)).join('')
+    this.verticallyLine = getCordsFromCurrentPositionByOrientation(orientationEnum.vertically).map(cord => getSlot(cord.cordX, cord.cordY)).join('')
+    this.diagonallyDownLine = getCordsFromCurrentPositionByOrientation(orientationEnum.diagonally).map(cord => getSlot(cord.cordX, cord.cordY)).join('')
+    this.diagonallyUpLine = getCordsFromCurrentPositionByOrientation(orientationEnum.antidiagonally).map(cord => getSlot(cord.cordX, cord.cordY)).join('')
+  }
+
+  getLinesWithRegex = (): regexValueByLineType => {
+    const lines = {
+      horizontallyLine: this.horizontallyLine,
+      verticallyLine: this.verticallyLine,
+      diagonallyDownLine: this.diagonallyDownLine,
+      diagonallyUpLine: this.diagonallyUpLine
+    }
+
+    const regexForLines = Object.keys(lines).reduce((result, key) => {
+      const newObj = {} as any
+      newObj[`regex${key.capitalize()}`] = generateRegexByLine(lines[key as keyof typeof lines])
+      return {
+        ...result,
+        ...newObj
+      }
+    }, {} as regexValueByLineType)
+
+    return regexForLines
+  }
+
+  getLineByOrientation = (orientation: orientationType) => {
+    switch (orientation) {
+      case "horizontally":
+        return this.horizontallyLine
+      case "vertically":
+        return this.verticallyLine
+      case "diagonally":
+        return this.diagonallyDownLine
+      case "antidiagonally":
+        return this.diagonallyUpLine
+
+    }
+  }
+}

package/src/Entities/Matrix.ts

@@ -0,0 +1,43 @@
+import { puzzleType } from "../Types";
+import Cords, { Cord } from "./Cords";
+import DimensionPuzzle from "./Dimension";
+import Lines from "./Lines";
+
+const BLANK_SPACE = ' '
+
+export default class Matrix {
+  dimension: DimensionPuzzle
+  cords: Cords
+  lines: Lines
+  private matrix: string[][]
+
+  constructor(length: number) {
+    this.dimension = new DimensionPuzzle(length)
+    this.matrix = this.generate()
+    this.cords = new Cords(this)
+    this.lines = new Lines()
+
+  }
+
+  private generate = () => {
+    const {
+      width,
+      height
+    } = this.dimension.getDimension()
+
+    const matrix: puzzleType = Array(...Array(width * height)).reduce((resultValue, currentValue, index, array) => {
+      resultValue = [...resultValue, array.splice(0, width).map(index => BLANK_SPACE)]
+      return resultValue
+    }, [])
+
+    return matrix
+  }
+
+  setSlot = (cordX: number, cordY: number, letter: string) => { this.matrix[cordX][cordY] = letter }
+
+  getSlot = (cordX: number, cordY: number) => this.matrix[cordX][cordY]
+
+  setLines = (lines: Lines) => { this.lines = lines }
+
+  getMatrix = () => this.matrix
+}

package/src/Entities/Word.ts

@@ -0,0 +1,115 @@
+import { orientationType, wordListByLineType } from "../Types"
+import { Cord } from "./Cords"
+import Matrix from "./Matrix"
+
+const LETTERS = 'ABCDEFGHIJKLMNÑOPQRSTUVWXYZ'
+
+export default class Words {
+  private matrix: Matrix
+  private listOfWords: string[]
+
+  constructor(matrix: Matrix, listOfWords: string[]) {
+    this.matrix = matrix
+    this.listOfWords = listOfWords.slice()
+  }
+
+  removeWord = (word: string) => {
+    this.listOfWords.splice(this.listOfWords.indexOf(word), 1)
+  }
+
+  private putWordHorizontally = (word: string, padStart: number = 0) => {
+    const { width } = this.matrix.dimension.getDimension()
+
+    const { cordX } = this.matrix.cords.getCordPosition()
+    let wordIndex = 0
+    for (let horizontalIndex = 0; horizontalIndex < width; horizontalIndex++) {
+      if (horizontalIndex >= padStart && wordIndex < word.length) {
+        this.matrix.setSlot(cordX, horizontalIndex, word.charAt(wordIndex))
+        wordIndex++
+      }
+    }
+  }
+
+  private putWordVertically = (word: string, padStart: number = 0) => {
+    const { height } = this.matrix.dimension.getDimension()
+
+    const { cordY } = this.matrix.cords.getCordPosition()
+    let wordIndex = 0
+    for (let verticalIndex = 0; verticalIndex < height; verticalIndex++) {
+      if (verticalIndex >= padStart && wordIndex < word.length) {
+        this.matrix.setSlot(verticalIndex, cordY, word.charAt(wordIndex))
+        wordIndex++
+      }
+    }
+  }
+
+  private putWordDiagonally = (word: string, padStart: number = 0) => {
+    const { height, width } = this.matrix.dimension.getDimension()
+    const { cordX, cordY } = this.matrix.cords.getCordPosition()
+
+    let wordIndex = 0
+    let spaceToStart = padStart
+    for (let i = Math.max(0, cordX - cordY); i < Math.min(height, height + cordX - cordY); i++) {
+      const j = i - (cordX - cordY);
+      if (0 <= j && j < width) {
+        if (spaceToStart > 0) {
+          spaceToStart--
+          continue
+        }
+        this.matrix.setSlot(i, j, wordIndex < word.length ? word.charAt(wordIndex) : this.matrix.getSlot(i, j))
+        wordIndex++
+      }
+    }
+  }
+
+  private putWordAntiDiagonally = (word: string, padStart: number = 0) => {
+    const { height, width } = this.matrix.dimension.getDimension()
+    const { cordX, cordY } = this.matrix.cords.getCordPosition()
+
+    let wordIndex = 0
+    let spaceToStart = padStart
+    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) {
+        if (spaceToStart > 0) {
+          spaceToStart--
+          continue
+        }
+        this.matrix.setSlot(x, y, wordIndex < word.length ? word.charAt(wordIndex) : this.matrix.getSlot(x, y))
+        wordIndex++
+      }
+    }
+  }
+
+  putWord = (word: string, orientation: orientationType, padStart: number = 0) => {
+    switch (orientation) {
+      case "diagonally":
+        this.putWordDiagonally(word, padStart)
+        break;
+      case "vertically":
+        this.putWordVertically(word, padStart)
+        break;
+      case "horizontally":
+        this.putWordHorizontally(word, padStart)
+        break;
+      case "antidiagonally":
+        this.putWordAntiDiagonally(word, padStart)
+        break;
+    }
+  }
+
+  getWordsEveryOrientation = (): wordListByLineType => {
+    const linesWithSearhRegex = this.matrix.lines.getLinesWithRegex()
+
+    const wordsByLine = Object.keys(linesWithSearhRegex).reduce((result, key) => {
+      const newObj = {} as any
+      newObj[`match${key.capitalize()}`] = this.listOfWords.filter(word => word.match(linesWithSearhRegex[key as keyof typeof linesWithSearhRegex]) as string[])
+      return {
+        ...result,
+        ...newObj
+      }
+    }, {} as wordListByLineType)
+
+    return wordsByLine
+  }
+}

package/src/Types.ts

@@ -0,0 +1,40 @@
+
+export type puzzleType = string[][]
+export type orientationType = "horizontally" | "vertically" | "diagonally" | "antidiagonally"
+export type linesByCordsType = {
+  horizontallyLine: string;
+  verticallyLine: string;
+  diagonallyDownLine: string;
+  diagonallyUpLine: string;
+}
+
+export 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 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/src/index.ts

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

package/src/letterSoup.ts

@@ -0,0 +1,130 @@
+import { Cord } from "./Entities/Cords"
+import Matrix from "./Entities/Matrix"
+import Words from "./Entities/Word"
+import { interectionsType, matchRegexLines, wordListByLineType } from "./Types"
+import { generateRegexByLine } from "./utils/regex"
+
+export class WordSearch {
+  private listOfWord: string[]
+  private puzzle: Matrix
+  private words: Words
+
+  constructor(listOfWords: string[]) {
+    this.listOfWord = listOfWords.map(word => word.toUpperCase())
+    const maxWordLegth = Math.max(...listOfWords.map(word => word.length))
+    this.puzzle = new Matrix(maxWordLegth)
+    this.words = new Words(this.puzzle, this.listOfWord)
+
+    this.generate()
+  }
+
+  private generate() {
+    const cordsPuzzle = this.puzzle.cords.scrambleCordsOfMatrix()
+
+    for (const cord of cordsPuzzle) {
+      const canPutWord = this.canPutWordInCurrentPosition(cord)
+
+      if (canPutWord) {
+        const {
+          orientation,
+          line,
+          wordSelected
+        } = this.selectAnyMatch(canPutWord)
+
+        const intersections = this.getIntersections(wordSelected, line)
+        const intersection = this.checkIntersections(intersections, wordSelected, line)
+
+        if (intersection) {
+          this.words.putWord(wordSelected, orientation, (intersection.lineIndex - intersection.wordIndex))
+        } else {
+          this.words.putWord(wordSelected, orientation)
+        }
+        this.words.removeWord(wordSelected)
+      }
+    }
+  }
+
+  private canPutWordInCurrentPosition = (cord: Cord) => {
+    this.puzzle.cords.setCordPosition(cord)
+    const wordsForEveryOrientation = this.words.getWordsEveryOrientation()
+    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
+  }
+
+  private pickRandomElement = <T>(listOfElements: T[]): T => {
+    return listOfElements[Math.floor(Math.random() * listOfElements.length)]
+  }
+
+  private selectAnyMatch = (lineMatches: wordListByLineType) => {
+    const matchKeyToScramble = Object.keys(lineMatches)
+      .filter(
+        keyLineMatch => lineMatches[keyLineMatch as keyof wordListByLineType].length > 0
+      )
+
+    const randomSelection = this.pickRandomElement(matchKeyToScramble) as keyof wordListByLineType
+
+    return {
+      orientation: matchRegexLines[randomSelection],
+      line: this.puzzle.lines.getLineByOrientation(matchRegexLines[randomSelection]),
+      wordSelected: this.pickRandomElement(lineMatches[randomSelection]),
+    }
+  }
+
+  private getIntersections = (word: string, line: string): interectionsType => {
+    const listOfIntersections = [] as interectionsType
+    Array.from(word).forEach((wordLetter, wordIndex) => {
+      Array.from(line).forEach((lineLetter, lineIndex) => {
+        if (wordLetter === lineLetter)
+          listOfIntersections.push({
+            lineIndex,
+            wordIndex
+          })
+      })
+    })
+
+    return listOfIntersections
+  }
+
+  private checkIntersections = (intersections: interectionsType, word: string, line: string) => {
+
+    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 = generateRegexByLine(subStrLine)
+        if (!regex.test(word)) {
+          return false
+        }
+        return true
+      })[0]
+    }
+  }
+
+  getPuzzle = () => this.puzzle.getMatrix()
+
+  getWords = () => this.listOfWord
+}
+

package/src/utils/regex.ts

@@ -0,0 +1,68 @@
+
+const hasAnotherLetters = (space: string) => /[A-Z]|Á|É|Í|Ó|Ú|Ñ/i.test(space)
+const isWhiteSpace = (groupToText: string) => /\s+/.test(groupToText)
+const splitsGroupOfSpacesAndLetter = (line: string): RegExpMatchArray => {
+  return line.match(/\s+|\S+/g) as RegExpMatchArray
+}
+const isFirstGroup = (index: number) => index === 0
+const isLastGroup = (index: number, lengthGroup: number) =>
+  index === (lengthGroup - 1)
+const isBetweenGroup = (index: number, lengthGroup: number) =>
+  0 < index && index < (lengthGroup - 1)
+const regexByListGroup = (groups: RegExpMatchArray | string[]) =>
+  groups.reduce((regex, group, index, groups) => {
+
+    if (isFirstGroup(index))
+      regex += '(^'
+    if (isWhiteSpace(group) && isBetweenGroup(index, groups.length))
+      regex += `.{${group.length}}`
+    else if (isWhiteSpace(group))
+      regex += `.{1,${group.length}}`
+    if (!isWhiteSpace(group))
+      regex += `${group}`
+    if (isLastGroup(index, groups.length))
+      regex += '$)'
+
+    return regex
+  }, '')
+
+const chunkListCharactersByCriterial = (groups: RegExpMatchArray) => {
+  let chunked = []
+  while (groups.length > 0) {
+    const criterial = isWhiteSpace(groups[0]) ? 3 : 2
+    chunked.push(groups.slice(0, criterial))
+    groups.splice(0, groups.length <= criterial ? criterial : criterial - 1)
+  }
+  return chunked
+}
+
+const joinRegexStringWithPipe = (...stringRegex: string[]) =>
+  stringRegex.join('|')
+
+const generateRegexByGroupOfSpacesAndLetters = (groups: RegExpMatchArray) => {
+  return new RegExp(
+    joinRegexStringWithPipe(
+      regexByListGroup(groups),
+      ...chunkListCharactersByCriterial(groups).map(chunk => regexByListGroup(chunk))
+    ),
+    'gm'
+  )
+}
+
+const generateRegexByLine = (line: string) => {
+  const splitedLine = splitsGroupOfSpacesAndLetter(line)
+  if (!splitedLine)
+    throw 'Error for split line'
+
+  return generateRegexByGroupOfSpacesAndLetters(splitedLine)
+}
+
+export {
+  hasAnotherLetters,
+  isWhiteSpace,
+  splitsGroupOfSpacesAndLetter,
+  joinRegexStringWithPipe,
+  chunkListCharactersByCriterial,
+  generateRegexByGroupOfSpacesAndLetters,
+  generateRegexByLine
+}

package/src/utils/string.ts

@@ -0,0 +1,10 @@
+
+declare interface String {
+  capitalize:() => string
+}
+
+function capitalize(this: String): string {
+  return `${this.charAt(0).toUpperCase()}${this.substring(1)}`
+}
+
+String.prototype.capitalize = capitalize

package/tsconfig.json

@@ -0,0 +1,108 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}