@adiakys/feeling-lucky 0.0.0-stage → 0.2.0

package/dist/room/room.d.ts

@@ -0,0 +1,74 @@
+import { type PropertyValues } from 'lit';
+import type { Dealer, Messages, Player, Prize, Win } from '../config/types';
+import { type RoomContext } from '../runtime/context';
+import { LuckyElement } from '../runtime/element';
+import '../games';
+import './certificate';
+import './lobby';
+import './theme';
+declare module '../engine/rig' {
+    interface Decisions {
+        locale: {
+            context: Record<string, never>;
+            value: string;
+        };
+    }
+}
+export interface RoomConfig {
+    prizes: Prize[];
+    player: Player | null;
+    logo?: string;
+    dealers?: Dealer[];
+    locale?: string;
+    messages: Record<string, Messages>;
+    onWin?: (win: Win) => void;
+    onClaim?: (win: Win) => Promise<void>;
+    developer: {
+        passwordHash?: string;
+    } | null;
+}
+export declare class Room extends LuckyElement {
+    config: RoomConfig;
+    origin: {
+        x: number;
+        y: number;
+    };
+    protected room: RoomContext;
+    private phase;
+    private view;
+    private lobbyPage;
+    private options;
+    private round;
+    private certificate;
+    private banner;
+    private celebrating;
+    private soundOn;
+    private developerLoaded;
+    private section?;
+    private lightsCanvas?;
+    private fxCanvas?;
+    private lightsFrame;
+    private dutyCheck;
+    private dutyClock;
+    private ambient;
+    private boost;
+    constructor();
+    private get theme();
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private get dealers();
+    private locale;
+    private context;
+    private go;
+    private finish;
+    private celebrate;
+    close(): void;
+    private toggleSound;
+    private onKey;
+    private startLights;
+    private stopLights;
+    private previousOverflow;
+    connectedCallback(): void;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/room/stage.d.ts

@@ -0,0 +1,18 @@
+import { type TemplateResult } from 'lit';
+import type { Translate } from '../runtime/i18n';
+import { LuckyElement } from '../runtime/element';
+export declare function stage(t: Translate, { state, rules, multiplier, dealer }: {
+    state: 'idle' | 'spinning' | 'won';
+    rules: string;
+    multiplier?: number;
+    dealer?: boolean;
+}, game: TemplateResult, overlay?: TemplateResult): TemplateResult<1>;
+export declare class Rules extends LuckyElement {
+    text: string;
+    private open;
+    private key;
+    private outside;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): TemplateResult<1>;
+}

package/dist/room/theme.d.ts

@@ -0,0 +1,15 @@
+import { type Theme } from '../engine/themes';
+import { LuckyElement } from '../runtime/element';
+export declare class ThemeScene extends LuckyElement {
+    theme: Theme;
+    private canvas?;
+    private raf;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    private start;
+    private ground;
+    private left;
+    private right;
+    private festoon;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/runtime/context.d.ts

@@ -0,0 +1,34 @@
+import type { TemplateResult } from 'lit';
+import type { Dealer, GameId, Player, Prize, Tier } from '../config/types';
+import type { Award, Board } from '../engine/awards';
+import type { Outcome } from '../engine/outcome';
+import type { Translate } from './i18n';
+export interface GameOptions {
+    bonus?: {
+        prizeId: string;
+        tier: Tier;
+        award: Award;
+    };
+}
+export interface RoomContext {
+    prizes: Prize[];
+    prizeIds: string[];
+    board: Board;
+    player: Player | null;
+    dealers: Dealer[];
+    locale: string;
+    locales: string[];
+    t: Translate;
+    prize: (id: string) => Prize;
+    icon: (id: string) => string;
+    name: (id: string) => string;
+    color: (id: string) => string;
+    award: (tier: Tier, award: Award) => string;
+    logo: (className?: string) => TemplateResult;
+    finish: (outcome: Outcome) => void;
+    go: (view: GameId | 'lobby', options?: GameOptions) => void;
+}
+export declare const roomContext: {
+    __context__: RoomContext;
+};
+export declare const defaultColor: (index: number) => string;

package/dist/runtime/element.d.ts

@@ -0,0 +1,15 @@
+import { LitElement } from 'lit';
+import { type RoomContext } from './context';
+import type { Signal } from './signal';
+export declare class LuckyElement extends LitElement {
+    protected room: RoomContext;
+    private timers;
+    private unsubscribes;
+    private watched;
+    protected createRenderRoot(): this;
+    protected t(key: string, params?: Record<string, string | number>): string;
+    protected watch(...signals: Signal<unknown>[]): void;
+    protected later(callback: () => void, delay: number): number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}

package/dist/runtime/fx.d.ts

@@ -0,0 +1,43 @@
+interface Particle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    type: 'strip' | 'spark' | 'flake';
+    gravity: number;
+    rotation: number;
+    spin: number;
+    flip: number;
+    flipSpeed: number;
+    width: number;
+    height: number;
+    color: string;
+    age: number;
+    life: number;
+}
+interface BurstOptions {
+    count?: number;
+    colors?: string[];
+    speed?: number;
+    spread?: number;
+    angle?: number;
+    type?: Particle['type'];
+    gravity?: number;
+    life?: number;
+}
+export declare const SPARKS: string[];
+export declare const fx: {
+    canvas: HTMLCanvasElement | null;
+    particles: Particle[];
+    confetti: string[] | undefined;
+    running: boolean;
+    last: number;
+    attach(canvas: HTMLCanvasElement | null): void;
+    burst(x: number, y: number, { count, colors, speed, spread, angle, type, gravity, life }?: BurstOptions): void;
+    fountain(duration: number): void;
+    cannons(duration: number): void;
+    frame(time: number): void;
+};
+export declare function shake(element: Element, force?: number): void;
+export declare function guilloche(cx: number, cy: number, scale?: number, layers?: number): string[];
+export {};

package/dist/runtime/i18n.d.ts

@@ -0,0 +1,8 @@
+import type { Messages } from '../config/types';
+export declare const pageLocale: import("./signal").Signal<string>;
+export declare function watchPageLocale(): void;
+export declare const localeChain: (locale: string) => string[];
+export declare const localeLoaded: (locale: string) => boolean;
+export declare const loadLocale: (locale: string) => Promise<void>;
+export type Translate = (key: string, params?: Record<string, string | number>) => string;
+export declare function translator(locale: string, custom?: Record<string, Messages>): Translate;

package/dist/runtime/icons.d.ts

@@ -0,0 +1,2 @@
+import type { IconNode } from 'lucide';
+export declare function icon(node: IconNode, className?: string): import("lit-html").TemplateResult<2>;

package/dist/runtime/motion.d.ts

@@ -0,0 +1,2 @@
+export declare const reducedMotion: () => boolean;
+export declare const wait: (ms: number) => Promise<unknown>;

package/dist/runtime/signal.d.ts

@@ -0,0 +1,6 @@
+export interface Signal<T> {
+    value: T;
+    subscribe(listener: () => void): () => void;
+    notify(): void;
+}
+export declare function signal<T>(initial: T): Signal<T>;

package/dist/runtime/sound.d.ts

@@ -0,0 +1,11 @@
+export type SoundName = 'tick' | 'reel' | 'stop' | 'whoosh' | 'bounce' | 'chime' | 'win' | 'jackpot' | 'stamp' | 'scratch' | 'lever' | 'ambient' | 'thunder' | 'dealer';
+export declare const sound: {
+    enabled: boolean;
+    context: AudioContext | null;
+    output: GainNode | null;
+    last: Partial<Record<SoundName, number>>;
+    enable(on: boolean): void;
+    partial(frequency: number, start: number, duration: number, amplitude: number): OscillatorNode;
+    noise(start: number, duration: number, amplitude: number, from: number, to?: number, q?: number): void;
+    play(name: SoundName, pitch?: number, volume?: number): void;
+};

package/dist/signal-CAveEGrG.js

@@ -0,0 +1,19 @@
+// src/runtime/signal.ts
+function e(e) {
+	let t = e, n = /* @__PURE__ */ new Set();
+	return {
+		get value() {
+			return t;
+		},
+		set value(e) {
+			Object.is(e, t) || (t = e, this.notify());
+		},
+		subscribe(e) {
+			return n.add(e), () => n.delete(e);
+		},
+		notify() {
+			n.forEach((e) => e());
+		}
+	};
+}
+export { e as t };

package/dist/styles/index.d.ts

@@ -0,0 +1 @@
+export declare const ROOM_CSS: string;

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@adiakys/feeling-lucky",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "A casino room for any web app: classic casino games that award the prizes you configure.",
+  "keywords": [
+    "casino",
+    "games",
+    "prizes",
+    "gamification",
+    "web-components",
+    "lit"
+  ],
+  "homepage": "https://github.com/Adiakys/feeling-lucky#readme",
+  "bugs": {
+    "url": "https://github.com/Adiakys/feeling-lucky/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Adiakys/feeling-lucky.git"
+  },
+  "license": "GPL-3.0-or-later",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/feeling-lucky.js",
+  "module": "./dist/feeling-lucky.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/feeling-lucky.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite playground",
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:e2e": "playwright test",
+    "typecheck": "tsc --noEmit",
+    "prepare": "npm run build",
+    "build:demo": "vite build --config vite.demo.config.ts"
+  },
+  "devDependencies": {
+    "@lit/context": "^1.1.6",
+    "@playwright/test": "^1.49.1",
+    "happy-dom": "^21.0.4",
+    "lit": "^3.3.3",
+    "lucide": "^1.61.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}