scrabble-solver 2.15.9 → 2.15.10

package/packages/scrabble-solver/src/hooks/useOnWindowResize.ts

@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
 
-const useOnWindowResize = (onResize: (event: Event) => void) => {
+export const useOnWindowResize = (onResize: (event: Event) => void) => {
   useEffect(() => {
     window.addEventListener('resize', onResize);
 
@@ -9,5 +9,3 @@ const useOnWindowResize = (onResize: (event: Event) => void) => {
     };
   }, [onResize]);
 };
-
-export default useOnWindowResize;

package/packages/scrabble-solver/src/hooks/useViewportSize.ts

@@ -1,8 +1,8 @@
 import { useCallback, useState } from 'react';
 
-import useOnWindowResize from './useOnWindowResize';
+import { useOnWindowResize } from './useOnWindowResize';
 
-const useViewportSize = () => {
+export const useViewportSize = () => {
   const [viewportHeight, setViewportHeight] = useState(typeof window === 'undefined' ? 0 : window.innerHeight);
   const [viewportWidth, setViewportWidth] = useState(typeof window === 'undefined' ? 0 : window.innerWidth);
 
@@ -15,5 +15,3 @@ const useViewportSize = () => {
 
   return { viewportHeight, viewportWidth };
 };
-
-export default useViewportSize;

package/packages/scrabble-solver/src/i18n/i18n.ts

@@ -11,7 +11,7 @@ import romanian from './languages/romanian.json';
 import spanish from './languages/spanish.json';
 import turkish from './languages/turkish.json';
 
-const i18n: Record<Locale, Translations> = {
+export const i18n: Record<Locale, Translations> = {
   [Locale.DE_DE]: german,
   [Locale.EN_GB]: english,
   [Locale.EN_US]: english,
@@ -22,5 +22,3 @@ const i18n: Record<Locale, Translations> = {
   [Locale.RO_RO]: romanian,
   [Locale.TR_TR]: turkish,
 };
-
-export default i18n;

package/packages/scrabble-solver/src/i18n/index.ts

@@ -1,2 +1,2 @@
 export * from './constants';
-export { default } from './i18n';
+export { i18n } from './i18n';

package/packages/scrabble-solver/src/lib/arrayEquals.ts

@@ -1,5 +1,3 @@
-const arrayEquals = <T>(array1: T[], array2: T[]): boolean => {
+export const arrayEquals = <T>(array1: T[], array2: T[]): boolean => {
   return array1.length === array2.length && array1.every((value, index) => value === array2[index]);
 };
-
-export default arrayEquals;

package/packages/scrabble-solver/src/lib/createArray.ts

@@ -1,3 +1 @@
-const createArray = <T>(length: number): T[] => Array.from({ length });
-
-export default createArray;
+export const createArray = <T>(length: number): T[] => Array.from({ length });

package/packages/scrabble-solver/src/lib/createComparator.ts

@@ -1,9 +1,9 @@
 import { Comparator } from 'types';
 
-import createStringComparator from './createStringComparator';
-import numberComparator from './numberComparator';
+import { createStringComparator } from './createStringComparator';
+import { numberComparator } from './numberComparator';
 
-const createComparator = <T>(locale: string): Comparator<T> => {
+export const createComparator = <T>(locale: string): Comparator<T> => {
   const stringComparator = createStringComparator(locale);
 
   return (a: T, b: T): number => {
@@ -18,5 +18,3 @@ const createComparator = <T>(locale: string): Comparator<T> => {
     return 0;
   };
 };
-
-export default createComparator;

package/packages/scrabble-solver/src/lib/createGridOf.ts

@@ -1,11 +1,9 @@
-import createArray from './createArray';
+import { createArray } from './createArray';
 
-const createGridOf = <T>(width: number, height: number, getInitialValue: (x: number, y: number) => T): T[][] => {
+export const createGridOf = <T>(width: number, height: number, getInitialValue: (x: number, y: number) => T): T[][] => {
   return createArray(height).map((_row, y) => {
     return createArray(width).map((_cell, x) => {
       return getInitialValue(x, y);
     });
   });
 };
-
-export default createGridOf;

package/packages/scrabble-solver/src/lib/createKeyComparator.ts

@@ -1,9 +1,12 @@
 import { Comparator } from 'types';
 
-import createStringComparator from './createStringComparator';
-import numberComparator from './numberComparator';
+import { createStringComparator } from './createStringComparator';
+import { numberComparator } from './numberComparator';
 
-const createKeyComparator = <T extends Record<keyof T, unknown>>(key: keyof T, locale: string): Comparator<T> => {
+export const createKeyComparator = <T extends Record<keyof T, unknown>>(
+  key: keyof T,
+  locale: string,
+): Comparator<T> => {
   const stringComparator = createStringComparator(locale);
 
   return (a: T, b: T): number => {
@@ -21,5 +24,3 @@ const createKeyComparator = <T extends Record<keyof T, unknown>>(key: keyof T, l
     return 0;
   };
 };
-
-export default createKeyComparator;

package/packages/scrabble-solver/src/lib/createKeyboardNavigation.ts

@@ -1,6 +1,6 @@
 import { KeyboardEventHandler } from 'react';
 
-import noop from './noop';
+import { noop } from './noop';
 
 interface Parameters {
   onArrowDown?: KeyboardEventHandler<HTMLInputElement>;
@@ -14,7 +14,7 @@ interface Parameters {
   onSpace?: KeyboardEventHandler<HTMLInputElement>;
 }
 
-const createKeyboardNavigation = ({
+export const createKeyboardNavigation = ({
   onArrowDown = noop,
   onArrowLeft = noop,
   onArrowRight = noop,
@@ -44,5 +44,3 @@ const createKeyboardNavigation = ({
 
   return handleKeyDown;
 };
-
-export default createKeyboardNavigation;

package/packages/scrabble-solver/src/lib/createNullMovingComparator.test.ts

@@ -1,4 +1,4 @@
-import createNullMovingComparator from './createNullMovingComparator';
+import { createNullMovingComparator } from './createNullMovingComparator';
 
 describe('createNullMovingComparator', () => {
   it('Moves nulls left', () => {

package/packages/scrabble-solver/src/lib/createNullMovingComparator.ts

@@ -1,4 +1,4 @@
-const createNullMovingComparator = <T>(direction: 'left' | 'right') => {
+export const createNullMovingComparator = <T>(direction: 'left' | 'right') => {
   return (a: T | null, b: T | null): number => {
     if (a === b) {
       return 0;
@@ -15,5 +15,3 @@ const createNullMovingComparator = <T>(direction: 'left' | 'right') => {
     return 0;
   };
 };
-
-export default createNullMovingComparator;

package/packages/scrabble-solver/src/lib/createRegExp.ts

@@ -1,4 +1,4 @@
-const createRegExp = (input: string): RegExp => {
+export const createRegExp = (input: string): RegExp => {
   if (input.trim().length === 0) {
     return /.*/;
   }
@@ -9,5 +9,3 @@ const createRegExp = (input: string): RegExp => {
     return /.*/;
   }
 };
-
-export default createRegExp;

package/packages/scrabble-solver/src/lib/createStringComparator.ts

@@ -1,5 +1,7 @@
 import { Comparator } from 'types';
 
-const createStringComparator: (locale: string) => Comparator<string> = (locale) => (a, b) => a.localeCompare(b, locale);
-
-export default createStringComparator;
+export const createStringComparator: (locale: string) => Comparator<string> = (locale) => {
+  return (a, b) => {
+    return a.localeCompare(b, locale);
+  };
+};

package/packages/scrabble-solver/src/lib/detectLocale.ts

@@ -1,6 +1,6 @@
 import { Locale } from '@scrabble-solver/types';
 
-const detectLocale = (): Locale => {
+export const detectLocale = (): Locale => {
   const languages = window.navigator.languages;
 
   if (languages.includes('pl') || languages.includes('pl-PL')) {
@@ -25,5 +25,3 @@ const detectLocale = (): Locale => {
 
   return Locale.EN_US;
 };
-
-export default detectLocale;

package/packages/scrabble-solver/src/lib/extractCharacters.test.ts

@@ -2,7 +2,7 @@ import { getConfig } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { Game, Locale } from '@scrabble-solver/types';
 
-import extractCharacters from './extractCharacters';
+import { extractCharacters } from './extractCharacters';
 
 const tests = [
   { input: 'ab ', expected: ['a', 'b', BLANK] },

package/packages/scrabble-solver/src/lib/extractCharacters.ts

@@ -14,7 +14,7 @@ const transliteratePerLocale: Record<Locale, (word: string) => string> = {
   [Locale.TR_TR]: (word) => word,
 };
 
-const extractCharacters = (config: Config, value: string): string[] => {
+export const extractCharacters = (config: Config, value: string): string[] => {
   let index = 0;
   const characters: string[] = [];
   const localeTransliterate = transliteratePerLocale[config.locale];
@@ -38,5 +38,3 @@ const extractCharacters = (config: Config, value: string): string[] => {
 
   return characters;
 };
-
-export default extractCharacters;

package/packages/scrabble-solver/src/lib/extractCharactersByCase.test.ts

@@ -2,7 +2,7 @@ import { getConfig } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { Game, Locale } from '@scrabble-solver/types';
 
-import extractCharactersByCase from './extractCharactersByCase';
+import { extractCharactersByCase } from './extractCharactersByCase';
 
 const tests = [
   { input: 'ab ', expected: ['a', 'b', BLANK] },

package/packages/scrabble-solver/src/lib/extractCharactersByCase.ts

@@ -1,9 +1,9 @@
 import { BLANK } from '@scrabble-solver/constants';
 import { Config } from '@scrabble-solver/types';
 
-import isUpperCase from './isUpperCase';
+import { isUpperCase } from './isUpperCase';
 
-const extractCharactersByCase = (config: Config, value: string): string[] => {
+export const extractCharactersByCase = (config: Config, value: string): string[] => {
   let index = 0;
   const characters: string[] = [];
 
@@ -27,5 +27,3 @@ const extractCharactersByCase = (config: Config, value: string): string[] => {
 
   return characters;
 };
-
-export default extractCharactersByCase;

package/packages/scrabble-solver/src/lib/extractInputValue.ts

@@ -1,4 +1,4 @@
-const extractInputValue = (input: HTMLInputElement) => {
+export const extractInputValue = (input: HTMLInputElement) => {
   const value = input.value.toLocaleLowerCase();
 
   if (input.selectionStart === null || input.selectionEnd === null) {
@@ -13,5 +13,3 @@ const extractInputValue = (input: HTMLInputElement) => {
 
   return value;
 };
-
-export default extractInputValue;

package/packages/scrabble-solver/src/lib/findCell.ts

@@ -1,7 +1,5 @@
 import { Cell } from '@scrabble-solver/types';
 
-const findCell = (cells: Cell[], x: number, y: number): Cell | undefined => {
+export const findCell = (cells: Cell[], x: number, y: number): Cell | undefined => {
   return cells.find((cell) => cell.x === x && cell.y === y);
 };
-
-export default findCell;

package/packages/scrabble-solver/src/lib/getCellSize.ts

@@ -2,11 +2,9 @@ import { Config } from '@scrabble-solver/types';
 
 import { BOARD_CELL_BORDER_WIDTH, BOARD_TILE_SIZE_MAX } from 'parameters';
 
-const getCellSize = (config: Config, width: number, height: number): number => {
-  const maxWidth = (width - BOARD_CELL_BORDER_WIDTH) / config.boardSize - BOARD_CELL_BORDER_WIDTH;
-  const maxHeight = (height - BOARD_CELL_BORDER_WIDTH) / config.boardSize - BOARD_CELL_BORDER_WIDTH;
+export const getCellSize = (config: Config, width: number, height: number): number => {
+  const maxWidth = (width - BOARD_CELL_BORDER_WIDTH) / config.boardWidth - BOARD_CELL_BORDER_WIDTH;
+  const maxHeight = (height - BOARD_CELL_BORDER_WIDTH) / config.boardHeight - BOARD_CELL_BORDER_WIDTH;
   const cellSize = Math.min(maxWidth, maxHeight);
   return Math.floor(Math.min(cellSize, BOARD_TILE_SIZE_MAX));
 };
-
-export default getCellSize;

package/packages/scrabble-solver/src/lib/getCoordinate.ts

@@ -1,11 +1,9 @@
 const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 
-const getCoordinate = (index: number, type: 'letter' | 'number'): string => {
+export const getCoordinate = (index: number, type: 'letter' | 'number'): string => {
   if (type === 'number') {
     return String(index + 1);
   }
 
   return alphabet[index];
 };
-
-export default getCoordinate;

package/packages/scrabble-solver/src/lib/getCoordinates.ts

@@ -1,8 +1,8 @@
 import { Result, ShowCoordinates } from '@scrabble-solver/types';
 
-import getCoordinate from './getCoordinate';
+import { getCoordinate } from './getCoordinate';
 
-const getCoordinates = (result: Result, showCoordinates: ShowCoordinates): string => {
+export const getCoordinates = (result: Result, showCoordinates: ShowCoordinates): string => {
   if (showCoordinates === 'hidden') {
     return '';
   }
@@ -14,5 +14,3 @@ const getCoordinates = (result: Result, showCoordinates: ShowCoordinates): strin
 
   return isHorizontal ? `${y}${x}` : `${x}${y}`;
 };
-
-export default getCoordinates;

package/packages/scrabble-solver/src/lib/getRemainingTiles.ts

@@ -3,9 +3,14 @@ import { Board, Config } from '@scrabble-solver/types';
 
 import { RemainingTile } from 'types';
 
-import createKeyComparator from './createKeyComparator';
-
-const getRemainingTiles = (config: Config, board: Board, characters: string[], locale: string): RemainingTile[] => {
+import { createKeyComparator } from './createKeyComparator';
+
+export const getRemainingTiles = (
+  config: Config,
+  board: Board,
+  characters: string[],
+  locale: string,
+): RemainingTile[] => {
   const nonEmptyCells = board.rows.flat().filter((cell) => !cell.isEmpty);
   const letterCells = nonEmptyCells.filter((cell) => !cell.tile.isBlank);
   const remainingTiles = Object.fromEntries(config.tiles.map((tile) => [tile.character, { ...tile, usedCount: 0 }]));
@@ -40,5 +45,3 @@ const getRemainingTiles = (config: Config, board: Board, characters: string[], l
 
   return [...Object.values(remainingTiles).sort(comparator), blank];
 };
-
-export default getRemainingTiles;

package/packages/scrabble-solver/src/lib/getRemainingTilesCount.ts

@@ -1,7 +1,5 @@
 import { RemainingTile } from 'types';
 
-const getRemainingTilesCount = (remainingTiles: RemainingTile[]): number => {
+export const getRemainingTilesCount = (remainingTiles: RemainingTile[]): number => {
   return remainingTiles.reduce((sum, { count, usedCount }) => sum + count - usedCount, 0);
 };
-
-export default getRemainingTilesCount;

package/packages/scrabble-solver/src/lib/getRemainingTilesGroups.ts

@@ -2,10 +2,10 @@ import { BLANK, CONSONANTS, VOWELS } from '@scrabble-solver/constants';
 
 import { RemainingTile, RemainingTilesGroup } from 'types';
 
-import getRemainingTilesCount from './getRemainingTilesCount';
-import getTotalRemainingTilesCount from './getTotalRemainingTilesCount';
+import { getRemainingTilesCount } from './getRemainingTilesCount';
+import { getTotalRemainingTilesCount } from './getTotalRemainingTilesCount';
 
-const getRemainingTilesGroups = (remainingTiles: RemainingTile[]): RemainingTilesGroup[] => {
+export const getRemainingTilesGroups = (remainingTiles: RemainingTile[]): RemainingTilesGroup[] => {
   const consonants = remainingTiles.filter(isConsonant);
   const vowels = remainingTiles.filter(isVowel);
   const other = remainingTiles.filter(isOther);
@@ -62,5 +62,3 @@ const isBlank = (tile: RemainingTile): boolean => tile.character === BLANK;
 
 const isOther = (tile: RemainingTile) =>
   !isConsonant(tile) && !isVowel(tile) && !isBlank(tile) && !isTwoCharacter(tile);
-
-export default getRemainingTilesGroups;

package/packages/scrabble-solver/src/lib/getTileSizes.ts

@@ -6,10 +6,8 @@ interface TileSizes {
   tileSize: number;
 }
 
-const getTileSizes = (tileSize: number): TileSizes => ({
+export const getTileSizes = (tileSize: number): TileSizes => ({
   pointsFontSize: Math.max(Math.round(tileSize * 0.25), BOARD_TILE_FONT_SIZE_POINTS_MIN),
   tileFontSize: Math.max(Math.round(tileSize * 0.6), BOARD_TILE_FONT_SIZE_MIN),
   tileSize,
 });
-
-export default getTileSizes;

package/packages/scrabble-solver/src/lib/getTotalRemainingTilesCount.ts

@@ -1,7 +1,5 @@
 import { RemainingTile } from 'types';
 
-const getTotalRemainingTilesCount = (remainingTiles: RemainingTile[]): number => {
+export const getTotalRemainingTilesCount = (remainingTiles: RemainingTile[]): number => {
   return remainingTiles.reduce((sum, { count }) => sum + count, 0);
 };
-
-export default getTotalRemainingTilesCount;

package/packages/scrabble-solver/src/lib/groupResults.ts

@@ -2,10 +2,10 @@ import { Result } from '@scrabble-solver/types';
 
 import { CellFilterEntry, GroupedResults } from 'types';
 
-import createRegExp from './createRegExp';
-import resultMatchesCellFilter from './resultMatchesCellFilter';
+import { createRegExp } from './createRegExp';
+import { resultMatchesCellFilter } from './resultMatchesCellFilter';
 
-const groupResults = (
+export const groupResults = (
   results: Result[] | undefined,
   query: string,
   cellFilter: CellFilterEntry[],
@@ -33,5 +33,3 @@ const groupResults = (
 
   return { matching, other };
 };
-
-export default groupResults;

package/packages/scrabble-solver/src/lib/guessLocale.ts

@@ -1,12 +1,12 @@
 import { Locale } from '@scrabble-solver/types';
 
-const guessLocale = (): Locale => {
+export const guessLocale = (): Locale => {
   if (!globalThis.navigator) {
     return Locale.EN_US;
   }
 
   const locales = Object.values(Locale);
-  const exactMatch = locales.find((locale) => globalThis.navigator.language === locale);
+  const exactMatch = locales.find((locale) => globalThis.navigator.language === String(locale));
 
   if (exactMatch) {
     return exactMatch;
@@ -18,5 +18,3 @@ const guessLocale = (): Locale => {
 
   return partialMatch || Locale.EN_US;
 };
-
-export default guessLocale;

package/packages/scrabble-solver/src/lib/index.ts

@@ -1,39 +1,39 @@
-export { default as arrayEquals } from './arrayEquals';
-export { default as createArray } from './createArray';
-export { default as createComparator } from './createComparator';
-export { default as createGridOf } from './createGridOf';
-export { default as createKeyComparator } from './createKeyComparator';
-export { default as createKeyboardNavigation } from './createKeyboardNavigation';
-export { default as createNullMovingComparator } from './createNullMovingComparator';
-export { default as createRegExp } from './createRegExp';
-export { default as createStringComparator } from './createStringComparator';
-export { default as detectLocale } from './detectLocale';
-export { default as extractCharacters } from './extractCharacters';
-export { default as extractCharactersByCase } from './extractCharactersByCase';
-export { default as extractInputValue } from './extractInputValue';
-export { default as findCell } from './findCell';
-export { default as getCellSize } from './getCellSize';
-export { default as getCoordinate } from './getCoordinate';
-export { default as getCoordinates } from './getCoordinates';
-export { default as getRemainingTiles } from './getRemainingTiles';
-export { default as getRemainingTilesCount } from './getRemainingTilesCount';
-export { default as getRemainingTilesGroups } from './getRemainingTilesGroups';
-export { default as getTileSizes } from './getTileSizes';
-export { default as getTotalRemainingTilesCount } from './getTotalRemainingTilesCount';
-export { default as groupResults } from './groupResults';
-export { default as guessLocale } from './guessLocale';
-export { default as inverseDirection } from './inverseDirection';
-export { default as isCtrl } from './isCtrl';
-export { default as isMac } from './isMac';
-export { default as isRegExp } from './isRegExp';
-export { default as isStringArray } from './isStringArray';
-export { default as isUpperCase } from './isUpperCase';
-export { default as memoize } from './memoize';
-export { default as noop } from './noop';
-export { default as numberComparator } from './numberComparator';
-export { default as resultMatchesCellFilter } from './resultMatchesCellFilter';
-export { default as reverseComparator } from './reverseComparator';
-export { default as sortGroupedResults } from './sortGroupedResults';
-export { default as sortResults } from './sortResults';
-export { default as unorderedArraysEqual } from './unorderedArraysEqual';
-export { default as zipCharactersAndTiles } from './zipCharactersAndTiles';
+export { arrayEquals } from './arrayEquals';
+export { createArray } from './createArray';
+export { createComparator } from './createComparator';
+export { createGridOf } from './createGridOf';
+export { createKeyComparator } from './createKeyComparator';
+export { createKeyboardNavigation } from './createKeyboardNavigation';
+export { createNullMovingComparator } from './createNullMovingComparator';
+export { createRegExp } from './createRegExp';
+export { createStringComparator } from './createStringComparator';
+export { detectLocale } from './detectLocale';
+export { extractCharacters } from './extractCharacters';
+export { extractCharactersByCase } from './extractCharactersByCase';
+export { extractInputValue } from './extractInputValue';
+export { findCell } from './findCell';
+export { getCellSize } from './getCellSize';
+export { getCoordinate } from './getCoordinate';
+export { getCoordinates } from './getCoordinates';
+export { getRemainingTiles } from './getRemainingTiles';
+export { getRemainingTilesCount } from './getRemainingTilesCount';
+export { getRemainingTilesGroups } from './getRemainingTilesGroups';
+export { getTileSizes } from './getTileSizes';
+export { getTotalRemainingTilesCount } from './getTotalRemainingTilesCount';
+export { groupResults } from './groupResults';
+export { guessLocale } from './guessLocale';
+export { inverseDirection } from './inverseDirection';
+export { isCtrl } from './isCtrl';
+export { isMac } from './isMac';
+export { isRegExp } from './isRegExp';
+export { isStringArray } from './isStringArray';
+export { isUpperCase } from './isUpperCase';
+export { memoize } from './memoize';
+export { noop } from './noop';
+export { numberComparator } from './numberComparator';
+export { resultMatchesCellFilter } from './resultMatchesCellFilter';
+export { reverseComparator } from './reverseComparator';
+export { sortGroupedResults } from './sortGroupedResults';
+export { sortResults } from './sortResults';
+export { unorderedArraysEqual } from './unorderedArraysEqual';
+export { zipCharactersAndTiles } from './zipCharactersAndTiles';

package/packages/scrabble-solver/src/lib/inverseDirection.ts

@@ -1,5 +1,3 @@
-const inverseDirection = (direction: 'left' | 'right'): 'left' | 'right' => {
+export const inverseDirection = (direction: 'left' | 'right'): 'left' | 'right' => {
   return direction === 'left' ? 'right' : 'left';
 };
-
-export default inverseDirection;

package/packages/scrabble-solver/src/lib/isCtrl.ts

@@ -1,7 +1,5 @@
 import { KeyboardEvent } from 'react';
 
-const isCtrl = <T>(event: KeyboardEvent<T> | globalThis.KeyboardEvent): boolean => {
+export const isCtrl = <T>(event: KeyboardEvent<T> | globalThis.KeyboardEvent): boolean => {
   return event.ctrlKey || event.metaKey;
 };
-
-export default isCtrl;

package/packages/scrabble-solver/src/lib/isMac.ts

@@ -1,9 +1,8 @@
-const isMac = (): boolean => {
+export const isMac = (): boolean => {
   if (!globalThis.navigator) {
     return false;
   }
 
-  return globalThis.navigator.platform.toLowerCase().includes('mac');
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  return globalThis.navigator.platform.startsWith('Mac') || globalThis.navigator.platform === 'iPhone';
 };
-
-export default isMac;

package/packages/scrabble-solver/src/lib/isRegExp.ts

@@ -1,4 +1,4 @@
-const isRegExp = (value: string): boolean => {
+export const isRegExp = (value: string): boolean => {
   try {
     // eslint-disable-next-line no-new
     new RegExp(value);
@@ -7,5 +7,3 @@ const isRegExp = (value: string): boolean => {
     return false;
   }
 };
-
-export default isRegExp;

package/packages/scrabble-solver/src/lib/isStringArray.ts

@@ -1,5 +1,3 @@
-const isStringArray = (value: unknown): value is string[] => {
+export const isStringArray = (value: unknown): value is string[] => {
   return Array.isArray(value) && value.every((item) => typeof item === 'string');
 };
-
-export default isStringArray;

package/packages/scrabble-solver/src/lib/isUpperCase.ts

@@ -1,7 +1,5 @@
 import { Locale } from '@scrabble-solver/types';
 
-const isUpperCase = (locale: Locale, value: string): boolean => {
+export const isUpperCase = (locale: Locale, value: string): boolean => {
   return value === value.toLocaleUpperCase(locale);
 };
-
-export default isUpperCase;