@truelab/truelogic 4.3.0-9 → 4.3.0

package/dist/types/src/entities/bonus/ui/BonusConfirmButtonBase/BonusConfirmButtonBase.d.ts

@@ -1,9 +1,17 @@
+import { PointerEventHandler } from 'react';
 type TProps = {
     onClick: (event: React.MouseEvent) => void;
     cashPrice: number;
     disabled: boolean;
     /** Bonus mode is selected: the spin becomes the confirm control and shows the price chip */
     isActive?: boolean;
+    /**
+     * The control is held — a pointer on it or Space down; the panel owns the hold (useHold), as it
+     * does for the spin this control stands in for. Not `:active`: Blink sets that for a touch too
+     * late for a quick tap to show it, and a hotkey never sets it at all (GTT-2754)
+     */
+    isPressed?: boolean;
+    onPointerDown?: PointerEventHandler<HTMLButtonElement>;
 };
-export declare const BonusConfirmButtonBase: ({ onClick, cashPrice, disabled, isActive }: TProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BonusConfirmButtonBase: ({ onClick, onPointerDown, cashPrice, disabled, isActive, isPressed, }: TProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/src/entities/bonus/ui/BonusConfirmButtonBase/BonusConfirmButtonBase.stories.d.ts

@@ -1,10 +1,12 @@
 declare const meta: {
     title: string;
-    component: ({ onClick, cashPrice, disabled, isActive }: {
+    component: ({ onClick, onPointerDown, cashPrice, disabled, isActive, isPressed, }: {
         onClick: (event: React.MouseEvent) => void;
         cashPrice: number;
         disabled: boolean;
         isActive?: boolean;
+        isPressed?: boolean;
+        onPointerDown?: import("react").PointerEventHandler<HTMLButtonElement>;
     }) => import("react/jsx-runtime").JSX.Element;
     decorators: import("@storybook/react-webpack5").Decorator[];
     parameters: {};
@@ -20,8 +22,12 @@ export declare const Variants: import("storybook/internal/csf").StoryAnnotations
     cashPrice: number;
     disabled: boolean;
     isActive?: boolean;
+    isPressed?: boolean;
+    onPointerDown?: import("react").PointerEventHandler<HTMLButtonElement>;
 }, {
     isActive?: boolean;
+    isPressed?: boolean;
+    onPointerDown?: import("react").PointerEventHandler<HTMLButtonElement>;
     onClick?: (event: React.MouseEvent) => void;
     cashPrice?: number;
     disabled?: boolean;

package/dist/types/src/features/play/ui/PanelPlay/PanelPlay.d.ts

@@ -5,6 +5,12 @@ type TPanelPlayProps = {
     ref: RefObject<HTMLButtonElement>;
     /** Rendered as `data-state` so e2e tests can tell play from stop/skip without guessing by `disabled` */
     state?: TPanelPlayState;
+    /**
+     * The spin is held — a pointer on the button or a hotkey down; the panel owns the hold (useHold).
+     * Not `:active`: Blink sets that for a touch too late for a quick tap to show, and On_tap must
+     * stay until the player lets go even once the round it started has disabled the button (GTT-2754)
+     */
+    isPressed?: boolean;
 } & ButtonHTMLAttributes<HTMLButtonElement>;
-export declare const PanelPlay: ({ onClick, className, disabled, state, ref, ...props }: TPanelPlayProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PanelPlay: ({ onPointerDown, className, disabled, state, isPressed, ref, ...props }: TPanelPlayProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/src/shared/lib/hooks/index.d.ts

@@ -4,7 +4,8 @@ export { useElementInViewPort } from './useElementInViewPort';
 export { useElementsBottomCssVar } from './useElementsBottomCssVar';
 export { useEnv } from './useEnv';
 export { useGameTime } from './useGameTime';
-export { useHoldDown } from './useHoldDown';
+export type { THoldSource } from './useHold';
+export { useHold } from './useHold';
 export { useOffline } from './useOffline';
 export { useOrientationChange } from './useOrientationChange';
 export { usePageVisibility } from './usePageVisibility';

package/dist/types/src/shared/lib/hooks/useHold.d.ts

@@ -0,0 +1,31 @@
+import { PointerEvent as ReactPointerEvent } from 'react';
+export type THoldSource = 'pointer' | 'key';
+type THoldOptions = {
+    /** The control is held while one of these keys is down (`KeyboardEvent.code`) */
+    keys?: readonly string[];
+    /** How long the control must stay held for `onHold` to fire; a control with no hold action omits it */
+    holdDelay?: number;
+    onPress?: (source: THoldSource) => void;
+    onHold?: (source: THoldSource) => void;
+    /**
+     * `isCancelled` — the hold ended without the player letting go: a pointercancel, a window blur,
+     * another press taking over, the hook getting disabled or unmounted. An action that lands on the
+     * release (like a click does) must skip those
+     */
+    onRelease?: (source: THoldSource, isCancelled: boolean) => void;
+    /** Turning it off releases a hold in progress: a lock (a modal) must not leave the action stuck on */
+    isEnabled?: boolean;
+};
+/**
+ * One held state for a control pressed with a pointer (attach `onPointerDown` to it) or with
+ * hotkeys. The press fires `onPress`, a hold of `holdDelay` fires `onHold`, the release — pointerup
+ * or pointercancel anywhere in the document, keyup, window blur — fires `onRelease`. The latest
+ * press owns the hold: a second finger or key takes over instead of piling up. `isHeld` paints the
+ * control; it comes from the events themselves, not from `:active`, which Blink sets for a touch
+ * too late for a quick tap to show.
+ */
+export declare const useHold: ({ keys, holdDelay, onPress, onHold, onRelease, isEnabled }: THoldOptions) => {
+    isHeld: boolean;
+    onPointerDown: (event: ReactPointerEvent<HTMLElement>) => void;
+};
+export {};

package/dist/types/src/shared/lib/hooks/useHold.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/shared/modules/menuInnerPage.d.ts

@@ -8,6 +8,13 @@ type TMenuInnerPageContext = {
     page: TMenuInnerPage | null;
     openPage: (page: TMenuInnerPage) => void;
     closePage: () => void;
+    /**
+     * A box over the header row for the toasts of a page, drawn there through a portal. Anything
+     * positioned inside the tab content, `fixed` included, travels with it: the tab scroll moves
+     * the content with a transform.
+     */
+    headerOverlay: HTMLElement | null;
+    setHeaderOverlay: (element: HTMLElement | null) => void;
 };
 type TProps = {
     children: ReactNode;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@truelab/truelogic",
-    "version": "4.3.0-9",
+    "version": "4.3.0",
     "description": "",
     "main": "./dist/truelogic.min.js",
     "types": "./dist/types/src/index.d.ts",
@@ -58,7 +58,11 @@
         "test:e2e:ui": "playwright test --project=sandbox --ui",
         "test:e2e:ui:game": "playwright test --project=game --ui",
         "test:e2e:report": "playwright show-report",
-        "test:e2e:typecheck": "tsc -p tests/e2e/tsconfig.json"
+        "test:e2e:typecheck": "tsc -p tests/e2e/tsconfig.json",
+        "email:install": "npm install --prefix ./email-letters",
+        "email:dev": "npm run dev --prefix ./email-letters",
+        "email:export": "npm run export --prefix ./email-letters",
+        "email:send-test": "npm run send-test --prefix ./email-letters --"
     },
     "browserslist": [
         "defaults and supports es6-module"

package/dist/types/src/shared/lib/hooks/useHoldDown.d.ts

@@ -1 +0,0 @@
-export declare const useHoldDown: (button: "Space" | "Enter", onKeyDown: () => void, onKeyUp: () => void, keyDownDelay?: number, isEnabled?: boolean) => void;