chore: implement various simplifications

src/common/__tests__/formatDuration.test.ts

@@ -17,7 +17,7 @@
 
 import { formatDuration } from "../formatDuration"
 
-describe("formatMilliseconds", () => {
+describe("formatDuration", () => {
   it("should correctly format well-formed durations", () => {
     const data = [
       {
@@ -38,8 +38,8 @@ describe("formatMilliseconds", () => {
       },
     ]
     for (let i = 0; i < data.length; i++) {
-      const datum = data[i]
-      expect(formatDuration(datum.input)).toEqual(datum.expected)
+      const { input, expected } = data[i]
+      expect(formatDuration(input)).toEqual(expected)
     }
   })
 

src/common/__tests__/rearrange.test.ts

@@ -38,9 +38,7 @@ describe("rearrange", () => {
   })
 
   it("should handle empty array and indices", () => {
-    const array: unknown[] = []
-    const indices: number[] = []
-    const result = rearrange(array, indices)
+    const result = rearrange([], [])
     expect(result).toEqual([])
   })
 

src/components/FileFormControl.tsx

@@ -102,12 +102,8 @@ export const FileFormControl = ({
   const onFileChangeHandler = async (
     event: React.ChangeEvent<HTMLInputElement>
   ) => {
-    let content = !isNil(event.target.files)
-      ? await event.target.files[0].text()
-      : ""
-    content = !isNil(contentPreprocessor)
-      ? contentPreprocessor(content)
-      : content
+    let content = (await event.target.files?.[0].text()) ?? ""
+    content = contentPreprocessor?.(content) ?? content
     const result = onFileChange(content)
     if (isNil(result) || result) {
       setFileContent(content)

src/model/Tetrimino.ts

@@ -17,7 +17,7 @@
 
 import { Block } from "./Block"
 import { Direction, MoveDirection, RotationDirection } from "./Direction"
-import { createOffsetedBlocks, mapAtomicNumberInto } from "./TetriminoHelper"
+import { createOffsetBlocks, mapAtomicNumberInto } from "./TetriminoHelper"
 import { TetriminoKind } from "./TetriminoKind"
 
 import type { TPosition } from "../common"
@@ -93,7 +93,7 @@ export class Tetrimino {
         this.position[0] + adjustPattern[i],
         this.position[1],
       ] as const
-      const newBlocks = createOffsetedBlocks(this.kind, newPos, direction)
+      const newBlocks = createOffsetBlocks(this.kind, newPos, direction)
       if (!newBlocks.some(collisionChecker)) {
         mapAtomicNumberInto(this.blocks, newBlocks)
         this.facingDirection = direction
@@ -118,7 +118,7 @@ export class Tetrimino {
     public position: TPosition,
     public facingDirection: Direction
   ) {
-    this.blocks = createOffsetedBlocks(kind, position, facingDirection)
+    this.blocks = createOffsetBlocks(kind, position, facingDirection)
   }
 }
 

src/model/TetriminoHelper.ts

@@ -418,7 +418,7 @@ export function getPositionByFirstBlock(
   return [position[0] - firstBlockCol, position[1] - firstBlockRow]
 }
 
-export function getInitialPositionByKind(
+export function getInitialPosition(
   kind: TetriminoKind,
   playAreaSize: ISize
 ): TPosition {
@@ -438,12 +438,12 @@ export function getInitialPositionByKind(
       length = 3
       break
     default:
-      throw new RangeError(`getInitialPositionByKind: invalid kind ${kind}`)
+      throw new RangeError(`getInitialPosition: invalid kind ${kind}`)
   }
   return [Math.floor((playAreaSize.width - length) / 2), 0]
 }
 
-export function createOffsetedBlocks(
+export function createOffsetBlocks(
   kind: TetriminoKind,
   offset: TPosition,
   direction: Direction = Direction.Up

src/model/__tests__/TetriminoHelper.test.ts

@@ -20,17 +20,17 @@ import { isEqual } from "lodash"
 import { Block } from "../Block"
 import { Direction } from "../Direction"
 import {
-  createOffsetedBlocks,
-  getInitialPositionByKind,
+  createOffsetBlocks,
+  getInitialPosition,
   mapAtomicNumberInto,
 } from "../TetriminoHelper"
 import { TetriminoKind } from "../TetriminoKind"
 
 const PlayAreaWidth = 18
 
-describe("createOffsetedBlocks", () => {
+describe("createOffsetBlocks", () => {
   it("should have correct behavior", () => {
-    const blks = createOffsetedBlocks(TetriminoKind.Cubic, [0, 0], Direction.Up)
+    const blks = createOffsetBlocks(TetriminoKind.Cubic, [0, 0], Direction.Up)
 
     const expectedPos = [
       [0, 0],
@@ -47,15 +47,15 @@ describe("createOffsetedBlocks", () => {
 
   it("should handle incorrect arguments gracefully", () => {
     expect(() => {
-      createOffsetedBlocks(TetriminoKind.Free, [0, 0], Direction.Down)
+      createOffsetBlocks(TetriminoKind.Free, [0, 0], Direction.Down)
     }).toThrowError(new RangeError("getBlocksMask: invalid kind 7"))
     expect(() => {
-      createOffsetedBlocks(TetriminoKind.Reserved, [0, 0], Direction.Down)
+      createOffsetBlocks(TetriminoKind.Reserved, [0, 0], Direction.Down)
     }).toThrowError(new RangeError("getBlocksMask: invalid kind 8"))
   })
 })
 
-describe("mapAtomicNumberForNewBlocks", () => {
+describe("mapAtomicNumberInto", () => {
   it("should have correct behavior", () => {
     const oldBlocks = [
       new Block(TetriminoKind.Cubic, [0, 0], 0, 0),
@@ -101,35 +101,35 @@ describe("mapAtomicNumberForNewBlocks", () => {
   })
 })
 
-describe("getInitialPositionByKind", () => {
+describe("getInitialPosition", () => {
   it("should have correct behavior", () => {
     const size = { height: NaN, width: PlayAreaWidth }
 
-    expect(getInitialPositionByKind(TetriminoKind.Cubic, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.Cubic, size)).toEqual([
       Math.floor((PlayAreaWidth - 2) / 2),
       0,
     ])
-    expect(getInitialPositionByKind(TetriminoKind.Linear, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.Linear, size)).toEqual([
       Math.floor((PlayAreaWidth - 4) / 2),
       0,
     ])
-    expect(getInitialPositionByKind(TetriminoKind.TeeShaped, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.TeeShaped, size)).toEqual([
       Math.floor((PlayAreaWidth - 3) / 2),
       0,
     ])
-    expect(getInitialPositionByKind(TetriminoKind.LShapedCis, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.LShapedCis, size)).toEqual([
       Math.floor((PlayAreaWidth - 3) / 2),
       0,
     ])
-    expect(getInitialPositionByKind(TetriminoKind.LShapedTrans, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.LShapedTrans, size)).toEqual([
       Math.floor((PlayAreaWidth - 3) / 2),
       0,
     ])
-    expect(getInitialPositionByKind(TetriminoKind.ZigZagCis, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.ZigZagCis, size)).toEqual([
       Math.floor((PlayAreaWidth - 3) / 2),
       0,
     ])
-    expect(getInitialPositionByKind(TetriminoKind.ZigZagTrans, size)).toEqual([
+    expect(getInitialPosition(TetriminoKind.ZigZagTrans, size)).toEqual([
       Math.floor((PlayAreaWidth - 3) / 2),
       0,
     ])
@@ -139,10 +139,10 @@ describe("getInitialPositionByKind", () => {
     const size = { height: NaN, width: PlayAreaWidth }
 
     expect(() => {
-      getInitialPositionByKind(TetriminoKind.Free, size)
+      getInitialPosition(TetriminoKind.Free, size)
     }).toThrowError(new RangeError("getInitialPositionByKind: invalid kind 7"))
     expect(() => {
-      getInitialPositionByKind(TetriminoKind.Reserved, size)
+      getInitialPosition(TetriminoKind.Reserved, size)
     }).toThrowError(new RangeError("getInitialPositionByKind: invalid kind 8"))
   })
 })

src/model/generation/internal/PatternGenerator.ts

@@ -22,7 +22,7 @@ import { Block } from "../../Block"
 import { Direction, RotationDirection } from "../../Direction"
 import { Tetrimino, repairBrokenTetriminos } from "../../Tetrimino"
 import {
-  getInitialPositionByKind,
+  getInitialPosition,
   getPositionByFirstBlock,
 } from "../../TetriminoHelper"
 import { TetriminoKind } from "../../TetriminoKind"
@@ -53,11 +53,13 @@ function spliceLast<T>(array: T[]): T {
   return elem
 }
 
+export type TProgressCallback = (progress: number) => void
+
 export class NoSolutionError extends Error {}
 
 export async function getPlayablePattern(
   gameMap: IMap,
-  progressCallback?: (content: TPosition) => void
+  progressCallback?: TProgressCallback
 ): Promise<Tetrimino[]> {
   const template = gameMap.map
   const atomicNumberMap = template.map((row) =>
@@ -102,7 +104,7 @@ async function getPossibleTetriminoPattern(
   freeBlockMap: boolean[][],
   atomicNumberMap: number[][],
   freeBlocksCount: number,
-  progressCallback?: (content: TPosition) => void
+  progressCallback?: TProgressCallback
 ): Promise<Tetrimino[]> {
   const settledTetriminos: Tetrimino[] = []
   const pairsRewindStack: TPropPair[][] = []
@@ -133,8 +135,7 @@ async function getPossibleTetriminoPattern(
     const firstBlockCoord = getFirstFreeBlockCoord(freeBlockMap)
     rewindingRequired = true
     while (currentPairs.length > 0) {
-      const pair = spliceRandom(currentPairs)
-      const [kind, direction] = pair
+      const [kind, direction] = spliceRandom(currentPairs)
       const tetrimino = new Tetrimino(
         kind,
         getPositionByFirstBlock(firstBlockCoord, kind, direction),
@@ -149,9 +150,9 @@ async function getPossibleTetriminoPattern(
         pairsRewindStack.push(currentPairs)
         tetrimino.blocks.forEach((b) => {
           freeBlockMap[b.position[1]][b.position[0]] = false
-          progressCallback?.(b.position)
         })
         freeBlocksCount -= tetrimino.blocks.length
+        progressCallback?.(freeBlocksCount)
         rewindingRequired = false
         break
       }
@@ -208,7 +209,7 @@ function primeTetriminos(tetriminos: Tetrimino[], playAreaSize: ISize) {
   // Move to initial position and rotate randomly
   tetriminos.forEach((tetrimino) => {
     const originalPos = tetrimino.position
-    const newPos = getInitialPositionByKind(tetrimino.kind, playAreaSize)
+    const newPos = getInitialPosition(tetrimino.kind, playAreaSize)
     const deltaX = newPos[0] - originalPos[0]
     const deltaY = newPos[1] - originalPos[1]