@adiakys/feeling-lucky 0.0.0-stage → 0.2.0

package/dist/games/roulette/roulette.d.ts

@@ -0,0 +1,63 @@
+import type { GameOptions } from '../../runtime/context';
+import { LuckyElement } from '../../runtime/element';
+import './table';
+import './track';
+export declare class Roulette extends LuckyElement {
+    options: GameOptions;
+    private state;
+    private result;
+    private bets;
+    private chosen;
+    private winning;
+    private shownCall;
+    private surface;
+    private shownSurface;
+    private plays;
+    private history;
+    private lastThrown;
+    private struck;
+    private medallions;
+    private root?;
+    private board?;
+    private sky?;
+    private dark?;
+    private boost;
+    private storm;
+    private call;
+    private callChange;
+    private surfaceChange;
+    private rotorAngle;
+    private ballAngle;
+    private ballRadius;
+    private raf;
+    private previous;
+    private spin;
+    private bolts;
+    private storming;
+    private darkness;
+    private get used();
+    private get struckResult();
+    protected willUpdate(): void;
+    protected firstUpdated(): void;
+    disconnectedCallback(): void;
+    private draw;
+    private frame;
+    private drawSky;
+    private setMedallion;
+    private setCall;
+    private setSurface;
+    private roll;
+    private strike;
+    private layout;
+    private placeChips;
+    private announce;
+    private restore;
+    private clearChips;
+    private undo;
+    private rebet;
+    private clearStorm;
+    private launch;
+    private throwBall;
+    private land;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/roulette/table.d.ts

@@ -0,0 +1,19 @@
+import { type PropertyValues } from 'lit';
+import { type RouletteBet } from '../../engine/roulette';
+import { LuckyElement } from '../../runtime/element';
+export declare class RouletteTable extends LuckyElement {
+    bets: RouletteBet[];
+    locked: boolean;
+    result: number | null;
+    winning: string | null;
+    struck: number[];
+    strikeLabel: string;
+    private hovered;
+    private labels;
+    private labelsOf?;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private label;
+    private choose;
+    private stacks;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/roulette/track.d.ts

@@ -0,0 +1,18 @@
+import { type PropertyValues } from 'lit';
+import { type RouletteAnnounced } from '../../engine/roulette';
+import { LuckyElement } from '../../runtime/element';
+export type Play = {
+    name: RouletteAnnounced;
+    prizeId: string;
+};
+export declare class RouletteTrack extends LuckyElement {
+    plays: Play[];
+    chipsLeft: number;
+    locked: boolean;
+    result: number | null;
+    struck: number[];
+    private hovered;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private choose;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/roulette/wheel.d.ts

@@ -0,0 +1,9 @@
+import { LuckyElement } from '../../runtime/element';
+export declare const polar: (radius: number, degrees: number) => readonly [number, number];
+export declare class RouletteWheel extends LuckyElement {
+    prefix: string;
+    ball: boolean;
+    struck?: number[];
+    rootClass: string;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/scratch/covers.d.ts

@@ -0,0 +1,3 @@
+export type Cover = 'coin' | 'bundle' | 'boat' | 'flipflop' | 'beach';
+export declare function coverArt(prizeLabel: string): Record<Cover, string>;
+export declare function loadCovers(art: Record<Cover, string>): Promise<Record<Cover, HTMLImageElement>>;

package/dist/games/scratch/double.d.ts

@@ -0,0 +1,3 @@
+import type { NumbersTicket } from '../../engine/scratch';
+import type { RoomContext } from '../../runtime/context';
+export declare function ticketDouble(room: RoomContext, ticket: NumbersTicket, matched: boolean, serial: string): import("lit-html").TemplateResult<1>;

package/dist/games/scratch/forever.d.ts

@@ -0,0 +1,3 @@
+import type { NumbersTicket } from '../../engine/scratch';
+import type { RoomContext } from '../../runtime/context';
+export declare function ticketForever(room: RoomContext, ticket: NumbersTicket, matched: boolean, serial: string): import("lit-html").TemplateResult<1>;

package/dist/games/scratch/scratch.d.ts

@@ -0,0 +1,39 @@
+import type { GameOptions } from '../../runtime/context';
+import { LuckyElement } from '../../runtime/element';
+export declare class Scratch extends LuckyElement {
+    options: GameOptions;
+    private boost;
+    private kind;
+    private tier;
+    private card?;
+    private serial;
+    private revealed;
+    private state;
+    private ticket?;
+    private covers?;
+    private last;
+    private strokes;
+    private print;
+    protected willUpdate(): void;
+    private get spots();
+    private get done();
+    private inLine;
+    private get hit();
+    private get matched();
+    private paint;
+    private ready;
+    private cleared;
+    private scratched;
+    private reveal;
+    private finish;
+    private foilOf;
+    private scratch;
+    private start;
+    private stop;
+    private foils;
+    private revealAll;
+    private newTicket;
+    firstUpdated(): Promise<void>;
+    private classic;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/slot/breakaway.d.ts

@@ -0,0 +1,32 @@
+import type { GameOptions } from '../../runtime/context';
+import { LuckyElement } from '../../runtime/element';
+export declare class Breakaway extends LuckyElement {
+    options: GameOptions;
+    private phase;
+    private cleared;
+    private runner;
+    private chosen;
+    private defenders;
+    private aim;
+    private keeper;
+    private field?;
+    private boost;
+    private tackle;
+    private get steps();
+    private get collected();
+    private get shooting();
+    private open;
+    private label;
+    private kickOff;
+    private step;
+    private advance;
+    private tackled;
+    private win;
+    private cashOut;
+    private shoot;
+    private again;
+    private get hint();
+    private onSquareKey;
+    private shot;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/slot/machine.d.ts

@@ -0,0 +1,18 @@
+import { type TemplateResult } from 'lit';
+import type { SlotSymbol } from '../../engine/slot';
+import { LuckyElement } from '../../runtime/element';
+export declare class SlotMachine extends LuckyElement {
+    strips: SlotSymbol[][];
+    mini: boolean;
+    state: 'idle' | 'spinning' | 'won';
+    rootClass: string;
+    tray?: TemplateResult;
+    private symbol;
+    private pull;
+    render(): TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'fl-slot-machine': SlotMachine;
+    }
+}

package/dist/games/slot/slot.d.ts

@@ -0,0 +1,32 @@
+import { type PropertyValues } from 'lit';
+import type { GameOptions } from '../../runtime/context';
+import { LuckyElement } from '../../runtime/element';
+import './machine';
+export declare class Slot extends LuckyElement {
+    options: GameOptions;
+    private state;
+    private readout;
+    private strips;
+    private machine?;
+    private boost;
+    private stripsOf;
+    private reels;
+    private raf;
+    private previous;
+    private ticker;
+    private tier;
+    private prizeId;
+    private line;
+    private suspense;
+    private get size();
+    private reelElements;
+    private draw;
+    willUpdate(changed: PropertyValues): void;
+    updated(changed: PropertyValues): void;
+    private pull;
+    private spin;
+    private frame;
+    private settle;
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/slot/takeoff.d.ts

@@ -0,0 +1,28 @@
+import type { GameOptions } from '../../runtime/context';
+import { LuckyElement } from '../../runtime/element';
+export declare class Takeoff extends LuckyElement {
+    options: GameOptions;
+    private phase;
+    private multiplier;
+    private cashed;
+    private canvas?;
+    private boost;
+    private christmas;
+    private tier;
+    private crash;
+    private start;
+    private goneAt;
+    private raf;
+    private won;
+    private get steps();
+    private get reached();
+    private label;
+    private takeOff;
+    private cashOut;
+    private frame;
+    private draw;
+    private again;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/wheel/coin.d.ts

@@ -0,0 +1,19 @@
+import type { Tier } from '../../config/types';
+import { type Award } from '../../engine/awards';
+import { LuckyElement } from '../../runtime/element';
+export type CoinFace = {
+    tier: Tier;
+    award: Award;
+};
+export declare class WheelCoin extends LuckyElement {
+    won: CoinFace;
+    other: CoinFace;
+    prizeId: string;
+    private flipping;
+    private coin?;
+    private shadow?;
+    private goldWins;
+    private flip;
+    private label;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/wheel/face.d.ts

@@ -0,0 +1,18 @@
+import { type WheelSegment } from '../../engine/wheel';
+import { LuckyElement } from '../../runtime/element';
+export declare class WheelFace extends LuckyElement {
+    rootClass: string;
+    prefix: string;
+    boosted: number[];
+    boostLabel: string;
+    private winPath;
+    rotor?: SVGGElement;
+    get segments(): WheelSegment[];
+    highlight(index: number | null): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'fl-wheel-face': WheelFace;
+    }
+}

package/dist/games/wheel/hunt.d.ts

@@ -0,0 +1,15 @@
+import { type PropertyValues } from 'lit';
+import type { PrizeTier } from '../../config/types';
+import type { Award } from '../../engine/awards';
+import { LuckyElement } from '../../runtime/element';
+export declare class WheelHunt extends LuckyElement {
+    won: {
+        tier: PrizeTier;
+        award: Award;
+    };
+    private tiles;
+    private picked;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private choose;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/games/wheel/wheel.d.ts

@@ -0,0 +1,64 @@
+import type { GameOptions } from '../../runtime/context';
+import { LuckyElement } from '../../runtime/element';
+import './coin';
+import './face';
+import './hunt';
+export declare class Wheel extends LuckyElement {
+    options: GameOptions;
+    private state;
+    private prizeId;
+    private topSet;
+    private topBlur;
+    private bonus;
+    private grabbed;
+    private zoomed;
+    private boosted;
+    private face?;
+    private wrap?;
+    private pointer?;
+    private strip?;
+    private boostStrip?;
+    private boost;
+    private boosterDay;
+    private angle;
+    private velocity;
+    private direction;
+    private phase;
+    private freeSince;
+    private brake;
+    private target;
+    private tier;
+    private lastIndex;
+    private lastTick;
+    private raf;
+    private previous;
+    private top;
+    private boostTop;
+    private prize;
+    private get segments();
+    private get keys();
+    private segmentLabel;
+    private indexAt;
+    private draw;
+    private planBrake;
+    private frame;
+    private settleTop;
+    private stopBoost;
+    private settleBoost;
+    private spin;
+    private land;
+    private bonusWon;
+    private drag;
+    private pointerAngle;
+    private zoom;
+    private fingers;
+    private pinch;
+    private spread;
+    private grab;
+    private move;
+    private release;
+    firstUpdated(): Promise<void>;
+    disconnectedCallback(): void;
+    private overlay;
+    render(): import("lit-html").TemplateResult<1>;
+}