@scrabble-solver/scrabble-solver 2.10.7 → 2.10.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/scrabble-solver",
-  "version": "2.10.7",
+  "version": "2.10.9",
   "description": "Scrabble Solver 2 - App",
   "engines": {
     "node": ">=16"
@@ -28,20 +28,22 @@
     "start": "env-cmd next start -p 3333"
   },
   "dependencies": {
+    "@floating-ui/react": "^0.19.2",
     "@kamilmielnik/trie": "^2.0.1",
     "@popperjs/core": "^2.11.6",
     "@reduxjs/toolkit": "^1.9.3",
-    "@scrabble-solver/configs": "^2.10.7",
-    "@scrabble-solver/constants": "^2.10.7",
-    "@scrabble-solver/dictionaries": "^2.10.7",
-    "@scrabble-solver/logger": "^2.10.7",
-    "@scrabble-solver/solver": "^2.10.7",
-    "@scrabble-solver/types": "^2.10.7",
-    "@scrabble-solver/word-definitions": "^2.10.7",
+    "@scrabble-solver/configs": "^2.10.9",
+    "@scrabble-solver/constants": "^2.10.9",
+    "@scrabble-solver/dictionaries": "^2.10.9",
+    "@scrabble-solver/logger": "^2.10.9",
+    "@scrabble-solver/solver": "^2.10.9",
+    "@scrabble-solver/types": "^2.10.9",
+    "@scrabble-solver/word-definitions": "^2.10.9",
     "classnames": "^2.3.2",
     "include-media": "^2.0.0",
     "include-media-query-builder": "^1.1.0",
-    "next": "^13.1.6",
+    "merge-refs": "^1.1.2",
+    "next": "^13.2.1",
     "normalize.css": "^8.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
@@ -76,5 +78,5 @@
     "sass": "^1.58.3",
     "workbox-webpack-plugin": "^6.5.4"
   },
-  "gitHead": "4d40b64882d1b9866d70ebe6a239d7d018b0cd18"
+  "gitHead": "fc5ec3ca1e4ec2c9f0ef9ae302c030659f7ef583"
 }

package/src/components/Badge/Badge.module.scss

@@ -5,7 +5,7 @@
   padding: var(--spacing--xs) var(--spacing--m);
   border: var(--border);
   border-radius: var(--border--radius);
-  background-color: var(--color--background--overlay);
+  background-color: var(--color--background--element);
   line-height: var(--line-height);
   font-size: var(--font--size--m);
   font-weight: bold;

package/src/components/Board/Board.module.scss

@@ -1,3 +1,5 @@
+@import 'styles/animations';
+
 .board {
   display: table;
   box-shadow: var(--box-shadow);
@@ -7,3 +9,15 @@
 .row {
   display: table-row;
 }
+
+.actions {
+  position: absolute;
+  z-index: var(--z-index--actions);
+  width: max-content;
+  height: max-content;
+  animation: var(--transition--duration) var(--transition--easing) hide;
+
+  &.shown {
+    animation: var(--transition--duration) var(--transition--easing) show;
+  }
+}

package/src/components/Board/Board.tsx

@@ -1,36 +1,134 @@
-import { FunctionComponent, Ref } from 'react';
+import { autoUpdate, FloatingPortal, offset, shift, useFloating, useMergeRefs } from '@floating-ui/react';
+import classNames from 'classnames';
+import { CSSProperties, FocusEventHandler, FunctionComponent, useState } from 'react';
+import { useDispatch } from 'react-redux';
+import { useMeasure } from 'react-use';
 
-import { selectBoard, selectRowsWithCandidate, useTypedSelector } from 'state';
+import { BOARD_CELL_ACTIONS_OFFSET, TRANSITION } from 'parameters';
+import { boardSlice, cellFilterSlice, selectBoard, selectRowsWithCandidate, useTypedSelector } from 'state';
 
+import styles from './Board.module.scss';
 import BoardPure from './BoardPure';
+import { Actions } from './components';
 import { useGrid } from './hooks';
 
 interface Props {
   cellSize: number;
   className?: string;
-  innerRef?: Ref<HTMLDivElement>;
 }
 
-const Board: FunctionComponent<Props> = ({ cellSize, className, innerRef }) => {
+const Board: FunctionComponent<Props> = ({ cellSize, className }) => {
+  const dispatch = useDispatch();
   const rows = useTypedSelector(selectRowsWithCandidate);
   const board = useTypedSelector(selectBoard);
-  const [{ direction, refs }, { onChange, onDirectionToggle, onFocus, onKeyDown, onPaste }] = useGrid(rows);
+  const [actionsMeasureRef, { width: actionsWidth }] = useMeasure<HTMLDivElement>();
+  const [{ activeIndex, direction, inputRefs }, { onChange, onDirectionToggle, onFocus, onKeyDown, onPaste }] =
+    useGrid(rows);
+  const inputRef = inputRefs[activeIndex.y][activeIndex.x];
+  const cell = rows[activeIndex.y][activeIndex.x];
+  const [showActions, setShowActions] = useState(false);
+  const [transition, setTransition] = useState<CSSProperties['transition']>(TRANSITION);
+
+  const { x, y, strategy, refs } = useFloating({
+    middleware: [
+      offset({
+        mainAxis: -BOARD_CELL_ACTIONS_OFFSET,
+        alignmentAxis: BOARD_CELL_ACTIONS_OFFSET - actionsWidth,
+      }),
+      shift(),
+    ],
+    placement: 'top-end',
+    whileElementsMounted: autoUpdate,
+  });
+
+  const actionsRef = useMergeRefs([actionsMeasureRef, refs.setFloating]);
+
+  const handleBlur: FocusEventHandler = (event) => {
+    const eventComesFromActions = refs.floating.current?.contains(event.relatedTarget);
+    const eventComesFromBoard = event.currentTarget.contains(event.relatedTarget);
+    const isLocalEvent = eventComesFromActions || eventComesFromBoard;
+
+    if (!isLocalEvent) {
+      setShowActions(false);
+    }
+  };
+
+  const handleDirectionToggle = () => {
+    inputRef.current?.focus();
+    onDirectionToggle();
+  };
+
+  const handleFocus: typeof onFocus = (newX, newY) => {
+    const isFirstFocus = !showActions;
+    const originalTransition = refs.floating.current?.style.transition || '';
+    const newInputRef = inputRefs[newY][newX].current;
+    const newTileElement = newInputRef?.parentElement || null;
+
+    if (isFirstFocus) {
+      setTransition('none');
+    }
+
+    refs.setReference(newTileElement);
+    onFocus(newX, newY);
+    setShowActions(true);
+
+    if (isFirstFocus) {
+      setTimeout(() => {
+        setTransition(originalTransition);
+      }, 0);
+    }
+  };
+
+  const handleToggleBlank = () => {
+    inputRef.current?.focus();
+    dispatch(boardSlice.actions.toggleCellIsBlank(cell));
+  };
+
+  const handleToggleFilterCell = () => {
+    inputRef.current?.focus();
+    dispatch(cellFilterSlice.actions.toggle(cell));
+  };
 
   return (
-    <BoardPure
-      className={className}
-      cellSize={cellSize}
-      center={board.center}
-      direction={direction}
-      innerRef={innerRef}
-      refs={refs}
-      rows={rows}
-      onChange={onChange}
-      onDirectionToggle={onDirectionToggle}
-      onFocus={onFocus}
-      onKeyDown={onKeyDown}
-      onPaste={onPaste}
-    />
+    <>
+      <BoardPure
+        className={className}
+        cellSize={cellSize}
+        center={board.center}
+        inputRefs={inputRefs}
+        rows={rows}
+        onBlur={handleBlur}
+        onChange={onChange}
+        onFocus={handleFocus}
+        onKeyDown={onKeyDown}
+        onPaste={onPaste}
+      />
+
+      <FloatingPortal>
+        <Actions
+          cell={cell}
+          className={classNames(styles.actions, {
+            [styles.shown]: showActions,
+          })}
+          disabled={!showActions}
+          direction={direction}
+          ref={actionsRef}
+          style={{
+            position: strategy,
+            top: y ?? 0,
+            left: x ?? 0,
+            transition,
+            opacity: showActions ? 1 : 0,
+            pointerEvents: showActions ? 'auto' : 'none',
+            userSelect: showActions ? 'auto' : 'none',
+            visibility: x === null || y === null ? 'hidden' : 'visible',
+          }}
+          onDirectionToggle={handleDirectionToggle}
+          onToggleBlank={handleToggleBlank}
+          onToggleFilterCell={handleToggleFilterCell}
+        />
+      </FloatingPortal>
+    </>
   );
 };
 

package/src/components/Board/BoardPure.tsx

@@ -3,15 +3,13 @@ import classNames from 'classnames';
 import {
   ChangeEventHandler,
   ClipboardEventHandler,
+  FocusEventHandler,
   FunctionComponent,
   KeyboardEventHandler,
   memo,
-  Ref,
   RefObject,
 } from 'react';
 
-import { Direction } from 'types';
-
 import styles from './Board.module.scss';
 import { Cell } from './components';
 
@@ -19,12 +17,10 @@ interface Props {
   className?: string;
   cellSize: number;
   center: CellModel;
-  direction: Direction;
-  innerRef?: Ref<HTMLDivElement>;
-  refs: RefObject<HTMLInputElement>[][];
+  inputRefs: RefObject<HTMLInputElement>[][];
   rows: CellModel[][];
+  onBlur: FocusEventHandler;
   onChange: ChangeEventHandler<HTMLInputElement>;
-  onDirectionToggle: () => void;
   onFocus: (x: number, y: number) => void;
   onKeyDown: KeyboardEventHandler<HTMLInputElement>;
   onPaste: ClipboardEventHandler<HTMLInputElement>;
@@ -34,32 +30,28 @@ const BoardPure: FunctionComponent<Props> = ({
   className,
   cellSize,
   center,
-  direction,
-  innerRef,
-  refs,
+  inputRefs,
   rows,
+  onBlur,
   onChange,
-  onDirectionToggle,
   onFocus,
   onKeyDown,
   onPaste,
 }) => (
-  <div className={classNames(styles.board, className)} ref={innerRef} onKeyDown={onKeyDown} onPaste={onPaste}>
+  <div className={classNames(styles.board, className)} onBlur={onBlur} onKeyDown={onKeyDown} onPaste={onPaste}>
     {rows.map((cells, y) => (
       <div className={styles.row} key={y}>
         {cells.map((cell, x) => (
           <Cell
             className={styles.cell}
             cell={cell}
-            direction={direction}
-            inputRef={refs[y][x]}
+            inputRef={inputRefs[y][x]}
             isBottom={y === rows.length - 1}
             isCenter={center.x === x && center.y === y}
             isRight={x === cells.length - 1}
             key={x}
             size={cellSize}
             onChange={onChange}
-            onDirectionToggle={onDirectionToggle}
             onFocus={onFocus}
           />
         ))}

package/src/components/Board/components/Actions/Actions.module.scss

@@ -0,0 +1,64 @@
+@import 'styles/mixins';
+
+.actions {
+  display: flex;
+  box-shadow: var(--box-shadow);
+  border-radius: var(--border--radius);
+  transition: var(--transition);
+}
+
+.action {
+  padding: var(--spacing--m);
+  box-shadow: none !important;
+
+  & + & {
+    [dir='ltr'] & {
+      border-left: none;
+    }
+
+    [dir='rtl'] & {
+      border-right: none;
+    }
+  }
+
+  [dir='ltr'] & {
+    &:first-child {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+    }
+
+    &:last-child {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+    }
+  }
+
+  [dir='rtl'] & {
+    &:first-child {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+    }
+
+    &:last-child {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+    }
+  }
+
+  &:active,
+  &:hover {
+    color: var(--color--foreground);
+  }
+}
+
+.toggleDirection {
+  transition: var(--transition);
+
+  &.right {
+    transform: rotate(-90deg);
+
+    [dir='rtl'] & {
+      transform: rotate(90deg);
+    }
+  }
+}

package/src/components/Board/components/Actions/Actions.tsx

@@ -0,0 +1,68 @@
+import { EMPTY_CELL } from '@scrabble-solver/constants';
+import { Cell } from '@scrabble-solver/types';
+import classNames from 'classnames';
+import { forwardRef, HTMLProps, MouseEventHandler } from 'react';
+
+import { ArrowDown, Flag, FlagFill, Square, SquareFill } from 'icons';
+import { selectCellIsFiltered, useTranslate, useTypedSelector } from 'state';
+
+import Button from '../../../Button';
+
+import styles from './Actions.module.scss';
+
+interface Props extends HTMLProps<HTMLDivElement> {
+  cell: Cell;
+  direction: 'horizontal' | 'vertical';
+  onDirectionToggle: MouseEventHandler<HTMLButtonElement>;
+  onToggleBlank: MouseEventHandler<HTMLButtonElement>;
+  onToggleFilterCell: MouseEventHandler<HTMLButtonElement>;
+}
+
+const Actions = forwardRef<HTMLDivElement, Props>(
+  ({ cell, className, direction, disabled, onDirectionToggle, onToggleBlank, onToggleFilterCell, ...props }, ref) => {
+    const translate = useTranslate();
+    const isFiltered = useTypedSelector((state) => selectCellIsFiltered(state, cell));
+    const isBlank = cell.tile.isBlank;
+    const isEmpty = cell.tile.character === EMPTY_CELL;
+
+    return (
+      <div className={classNames(styles.actions, className)} ref={ref} {...props}>
+        <Button
+          aria-label={translate('cell.toggle-direction')}
+          className={styles.action}
+          Icon={ArrowDown}
+          iconClassName={classNames(styles.toggleDirection, {
+            [styles.right]: direction === 'horizontal',
+          })}
+          tabIndex={disabled ? -1 : undefined}
+          tooltip={translate('cell.toggle-direction')}
+          onClick={onDirectionToggle}
+        />
+
+        {isEmpty && (
+          <Button
+            aria-label={translate('cell.filter-cell')}
+            className={classNames(styles.action)}
+            Icon={isFiltered ? Flag : FlagFill}
+            tabIndex={disabled ? -1 : undefined}
+            tooltip={translate('cell.filter-cell')}
+            onClick={onToggleFilterCell}
+          />
+        )}
+
+        {!isEmpty && (
+          <Button
+            aria-label={isBlank ? translate('cell.set-not-blank') : translate('cell.set-blank')}
+            className={styles.action}
+            Icon={isBlank ? SquareFill : Square}
+            tabIndex={disabled ? -1 : undefined}
+            tooltip={isBlank ? translate('cell.set-not-blank') : translate('cell.set-blank')}
+            onClick={onToggleBlank}
+          />
+        )}
+      </div>
+    );
+  },
+);
+
+export default Actions;

package/src/components/Board/components/Actions/index.ts

@@ -0,0 +1 @@
+export { default } from './Actions';