lettersoup 1.0.2 → 1.1.0

package/dist/utils/regex.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRegexByLine = exports.generateRegexByGroupOfSpacesAndLetters = exports.chunkListCharactersByCriterial = exports.joinRegexStringWithPipe = exports.splitsGroupOfSpacesAndLetter = exports.isWhiteSpace = exports.hasAnotherLetters = void 0;
+const hasAnotherLetters = (space) => /[A-Z]|Á|É|Í|Ó|Ú|Ñ/i.test(space);
+exports.hasAnotherLetters = hasAnotherLetters;
+const isWhiteSpace = (groupToText) => /\s+/.test(groupToText);
+exports.isWhiteSpace = isWhiteSpace;
+const splitsGroupOfSpacesAndLetter = (line) => {
+    return line.match(/\s+|\S+/g);
+};
+exports.splitsGroupOfSpacesAndLetter = splitsGroupOfSpacesAndLetter;
+const isFirstGroup = (index) => index === 0;
+const isLastGroup = (index, lengthGroup) => index === (lengthGroup - 1);
+const isBetweenGroup = (index, lengthGroup) => 0 < index && index < (lengthGroup - 1);
+const regexByListGroup = (groups) => 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) => {
+    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;
+};
+exports.chunkListCharactersByCriterial = chunkListCharactersByCriterial;
+const joinRegexStringWithPipe = (...stringRegex) => stringRegex.join('|');
+exports.joinRegexStringWithPipe = joinRegexStringWithPipe;
+const generateRegexByGroupOfSpacesAndLetters = (groups) => {
+    return new RegExp(joinRegexStringWithPipe(regexByListGroup(groups), ...chunkListCharactersByCriterial(groups).map(chunk => regexByListGroup(chunk))), 'gm');
+};
+exports.generateRegexByGroupOfSpacesAndLetters = generateRegexByGroupOfSpacesAndLetters;
+const generateRegexByLine = (line) => {
+    const splitedLine = splitsGroupOfSpacesAndLetter(line);
+    if (!splitedLine)
+        throw 'Error for split line';
+    return generateRegexByGroupOfSpacesAndLetters(splitedLine);
+};
+exports.generateRegexByLine = generateRegexByLine;

package/dist/utils/string.d.ts

@@ -0,0 +1,4 @@
+declare interface String {
+    capitalize: () => string;
+}
+declare function capitalize(this: String): string;

package/dist/utils/string.js

@@ -0,0 +1,5 @@
+"use strict";
+function capitalize() {
+    return `${this.charAt(0).toUpperCase()}${this.substring(1)}`;
+}
+String.prototype.capitalize = capitalize;

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "lettersoup",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "generate letterSoup",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc --project tsconfig.json",
-    "test": "jest"
+    "prebuild": "rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "lint": "eslint 'src/**/*.ts' '__tests__/**/*.ts'"
   },
   "keywords": [
     "letterSoup",
@@ -17,8 +23,15 @@
   ],
   "author": "Fabian Escarate",
   "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FabianEscarate/letterSoup"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "eslint": "^9.39.2",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.2",
     "ts-node": "^10.9.2",

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

@@ -1,33 +0,0 @@
-# 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

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

package/__tests__/index.test.ts

@@ -1,36 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

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

package/src/Entities/Cords.ts

@@ -1,127 +0,0 @@
-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

@@ -1,24 +0,0 @@
-
-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

@@ -1,59 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,40 +0,0 @@
-
-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

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