jaml-ui 0.21.3 → 0.21.5

package/dist/hooks/useSearch.js

@@ -1,9 +1,5 @@
 "use client";
 import { useState, useCallback, useRef, useEffect } from "react";
-import SearchWorker from "./searchWorker.js?worker&inline";
-function createWorker() {
-    return new SearchWorker();
-}
 const INITIAL_STATE = {
     results: [],
     totalSearched: 0n,
@@ -13,15 +9,107 @@ const INITIAL_STATE = {
     seedsPerSecond: 0,
     tallyLabels: [],
 };
-export function useSearch() {
+const SEARCH_WORKER_CODE = `
+let MotelyWasm = null;
+let MotelyWasmEvents = null;
+let activeSearch = null;
+
+self.addEventListener('message', async function(e) {
+  const msg = e.data;
+
+  if (msg.type === 'init') {
+    try {
+      const mod = await import(msg.url);
+      await mod.default.boot();
+      MotelyWasm = mod.MotelyWasm;
+      MotelyWasmEvents = mod.MotelyWasmEvents;
+      self.postMessage({ type: 'ready' });
+    } catch (err) {
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+    return;
+  }
+
+  if (msg.type === 'start') {
+    if (!MotelyWasm) { self.postMessage({ type: 'error', message: 'Not initialized' }); return; }
+    const validation = MotelyWasm.validateJaml(msg.jaml);
+    if (validation !== 'valid') { self.postMessage({ type: 'error', message: validation }); return; }
+
+    function cleanup() {
+      MotelyWasmEvents.notifyResult = () => {};
+      MotelyWasmEvents.notifyProgress = () => {};
+      MotelyWasmEvents.notifyComplete = () => {};
+      activeSearch = null;
+    }
+
+    MotelyWasmEvents.notifyResult = function(seed, score, tallyColumns) {
+      self.postMessage({ type: 'result', seed, score, tallyColumns: Array.from(tallyColumns) });
+    };
+    MotelyWasmEvents.notifyProgress = function(searched, matching) {
+      self.postMessage({ type: 'progress', searched: searched.toString(), matching: matching.toString() });
+    };
+    MotelyWasmEvents.notifyComplete = function(status, searched, matched) {
+      cleanup();
+      self.postMessage({ type: 'complete', status, searched: searched.toString(), matched: matched.toString() });
+    };
+
+    try {
+      const mode = msg.mode || 'random';
+
+      if (mode === 'random') {
+        activeSearch = MotelyWasm.startRandomSearch(msg.jaml, msg.count);
+      } else if (mode === 'aesthetic') {
+        activeSearch = MotelyWasm.startAestheticSearch(msg.jaml, msg.aesthetic);
+      } else if (mode === 'seedList') {
+        activeSearch = MotelyWasm.startSeedListSearch(msg.jaml, msg.seeds);
+      } else if (mode === 'keyword') {
+        activeSearch = MotelyWasm.startKeywordSearch(msg.jaml, msg.keywords, msg.padding || '');
+      } else if (mode === 'sequential') {
+        activeSearch = MotelyWasm.startSequentialSearch(msg.jaml, msg.batchCharCount, BigInt(msg.startBatch), BigInt(msg.endBatch));
+      } else {
+        self.postMessage({ type: 'error', message: 'Unknown search mode: ' + mode });
+        cleanup();
+        return;
+      }
+    } catch (err) {
+      cleanup();
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+    return;
+  }
+
+  if (msg.type === 'stop') {
+    if (activeSearch) { activeSearch.cancel(); activeSearch = null; }
+    self.postMessage({ type: 'cancelled' });
+  }
+
+  if (msg.type === 'get_tally_labels') {
+    if (!MotelyWasm) { self.postMessage({ type: 'error', message: 'Not initialized' }); return; }
+    try {
+      const labels = MotelyWasm.getTallyLabels(msg.jaml);
+      self.postMessage({ type: 'tally_labels', labels: Array.from(labels) });
+    } catch (err) {
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+  }
+});
+`;
+function createWorker() {
+    const blob = new Blob([SEARCH_WORKER_CODE], { type: "application/javascript" });
+    return new Worker(URL.createObjectURL(blob), { type: "module" });
+}
+export function useSearch(motelyWasmUrl) {
     const [state, setState] = useState(INITIAL_STATE);
     const workerRef = useRef(null);
-    const readyRef = useRef(true); // Worker is ready implicitly since boot is handled by import
+    const readyRef = useRef(false); // Worker is NOT implicitly ready, must wait for 'ready' message
     const speedRef = useRef({ lastSearched: 0n, lastTime: 0, ema: 0 });
     useEffect(() => {
         setState((s) => ({ ...s, status: "idle" }));
         const worker = createWorker();
         workerRef.current = worker;
+        if (motelyWasmUrl) {
+            worker.postMessage({ type: 'init', url: motelyWasmUrl });
+        }
         worker.onmessage = (e) => {
             const msg = e.data;
             if (msg.type === "ready") {
@@ -83,7 +171,7 @@ export function useSearch() {
             worker.terminate();
             workerRef.current = null;
         };
-    }, []);
+    }, [motelyWasmUrl]);
     const sendStart = useCallback((payload) => {
         const worker = workerRef.current;
         if (!worker)
@@ -117,6 +205,21 @@ export function useSearch() {
     const startKeyword = useCallback((jaml, keywords, padding) => {
         sendStart({ type: "start", mode: "keyword", jaml, keywords, padding });
     }, [sendStart]);
+    const startSequential = useCallback((jaml, startSeed, endSeed) => {
+        // Sequential search: single-threaded, deterministic order.
+        // batchCharCount = length of start seed, startBatch/endBatch = numeric range.
+        const charCount = startSeed.length || 1;
+        const startNum = parseInt(startSeed, 36) || 0;
+        const endNum = endSeed ? parseInt(endSeed, 36) : startNum + 10_000_000;
+        sendStart({
+            type: "start",
+            mode: "sequential",
+            jaml,
+            batchCharCount: charCount,
+            startBatch: startNum.toString(),
+            endBatch: endNum.toString(),
+        });
+    }, [sendStart]);
     const cancel = useCallback(() => {
         workerRef.current?.postMessage({ type: "stop" });
     }, []);
@@ -126,5 +229,5 @@ export function useSearch() {
     const fetchTallyLabels = useCallback((jaml) => {
         workerRef.current?.postMessage({ type: "get_tally_labels", jaml });
     }, []);
-    return { ...state, start, startAesthetic, startSeedList, startKeyword, cancel, clearError, fetchTallyLabels };
+    return { ...state, start, startAesthetic, startSeedList, startKeyword, startSequential, cancel, clearError, fetchTallyLabels };
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { JAML_ASSET_FILES, clearJamlAssetBaseUrl, getDefaultJamlAssetUrlMap, resolveJamlAssetUrl, setJamlAssetBaseUrl, type JamlAssetFile, type JamlAssetKey, } from "./assets.js";
+export { JAML_ASSET_FILES, resolveJamlAssetUrl, setJamlAssetBaseUrl, type JamlAssetFile, type JamlAssetKey, } from "./assets.js";
 export { Layer, type LayerOptions } from "./render/Layer.js";
 export { JamlCardRenderer, type JamlCardRendererProps } from "./render/CanvasRenderer.js";
 export { JamlGameCard, JamlVoucher, JamlTag, JamlBoss, resolveAnalyzerShopItem, type JamlGameCardProps, type AnalyzerShopItem, type AnalyzerResolvedItem, } from "./components/GameCard.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 "use client";
-export { JAML_ASSET_FILES, clearJamlAssetBaseUrl, getDefaultJamlAssetUrlMap, resolveJamlAssetUrl, setJamlAssetBaseUrl, } from "./assets.js";
+export { JAML_ASSET_FILES, resolveJamlAssetUrl, setJamlAssetBaseUrl, } from "./assets.js";
 export { Layer } from "./render/Layer.js";
 export { JamlCardRenderer } from "./render/CanvasRenderer.js";
 export { JamlGameCard, JamlVoucher, JamlTag, JamlBoss, resolveAnalyzerShopItem, } from "./components/GameCard.js";

package/dist/lib/SpriteMapper.d.ts

@@ -0,0 +1,10 @@
+interface SpritePos {
+    x: number;
+    y: number;
+}
+export interface SpriteData {
+    pos: SpritePos;
+    type: 'Jokers' | 'Tarots' | 'Vouchers' | 'Boosters' | 'Enhancers' | 'Editions' | 'BlindChips' | 'Shop' | 'tags';
+}
+export declare function getSpriteData(name: string): SpriteData;
+export {};

package/dist/lib/SpriteMapper.js

@@ -0,0 +1,48 @@
+import { jokers, tarotsAndPlanets, vouchers, boosterPacks, jokerFaces, consumablesFaces, bosses, tags } from './const';
+// Consolidate all item arrays into a single map for O(1) lookup
+const ITEM_MAP = new Map();
+function addToMap(items, type) {
+    items.forEach(item => {
+        if (item.name && item.pos) {
+            const data = { pos: item.pos, type };
+            ITEM_MAP.set(item.name, data);
+            ITEM_MAP.set(item.name.toLowerCase(), data);
+            ITEM_MAP.set(item.name.replace(/ /g, ''), data);
+            ITEM_MAP.set(item.name.replace(/ /g, '').toLowerCase(), data);
+        }
+    });
+}
+// Populate the map with explicit types
+addToMap(jokers, 'Jokers');
+addToMap(tarotsAndPlanets, 'Tarots');
+addToMap(vouchers, 'Vouchers');
+addToMap(boosterPacks, 'Boosters');
+addToMap(bosses, 'BlindChips');
+addToMap(tags, 'tags');
+// Explicit overrides/faces
+addToMap(jokerFaces, 'Jokers');
+addToMap(consumablesFaces, 'Tarots');
+export function getSpriteData(name) {
+    // 1. Try stripping common prefixes used by some analyzers (e.g., "Planet | Venus")
+    const cleanedName = name.replace(/^(Joker|Tarot|Planet|Voucher|Pack|Edition|Tag) [|:] /i, "").trim();
+    // 2. Precise lookup
+    if (ITEM_MAP.has(cleanedName))
+        return ITEM_MAP.get(cleanedName);
+    if (ITEM_MAP.has(name))
+        return ITEM_MAP.get(name);
+    // 3. Normalized lookups
+    const variants = [
+        cleanedName.toLowerCase(),
+        cleanedName.replace(/ /g, ''),
+        cleanedName.replace(/ /g, '').toLowerCase(),
+        name.toLowerCase(),
+        name.replace(/ /g, ''),
+        name.replace(/ /g, '').toLowerCase()
+    ];
+    for (const v of variants) {
+        if (ITEM_MAP.has(v))
+            return ITEM_MAP.get(v);
+    }
+    // Default Fallback
+    return { pos: { x: 0, y: 0 }, type: 'Jokers' };
+}

package/dist/lib/cardParser.d.ts

@@ -0,0 +1,8 @@
+export interface ParsedCard {
+    rank: string;
+    suit: string;
+    enhancement: string | null;
+    seal: string | null;
+    edition: string | null;
+}
+export declare function parseCardToken(item: any): ParsedCard | null;

package/dist/lib/cardParser.js

@@ -0,0 +1,65 @@
+const ENHANCEMENTS = ["Bonus", "Mult", "Wild", "Lucky", "Glass", "Steel", "Stone", "Gold"];
+const SEALS = ["Gold", "Purple", "Red", "Blue"];
+const EDITIONS = ["Foil", "Holographic", "Polychrome", "Negative"];
+const RANKS = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"];
+const SUITS = ["Hearts", "Clubs", "Diamonds", "Spades"];
+// Internal Balatro short codes
+const RANK_MAP = {
+    "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8", "9": "9", "10": "10",
+    "T": "10", "J": "Jack", "Q": "Queen", "K": "King", "A": "Ace"
+};
+const SUIT_MAP = {
+    "H": "Hearts", "C": "Clubs", "D": "Diamonds", "S": "Spades"
+};
+export function parseCardToken(item) {
+    if (!item)
+        return null;
+    // 1. If it's already an object with rank/suit
+    if (typeof item === 'object' && (item.rank || item.base)) {
+        let rank = item.rank || item.base?.[2] || item.base?.[0]; // Handle different analyzer versions
+        let suit = item.suit || item.base?.[0];
+        // Normalize
+        rank = RANK_MAP[rank] || rank;
+        suit = SUIT_MAP[suit] || suit;
+        if (suit && !suit.endsWith('s'))
+            suit += 's';
+        return {
+            rank: rank || "Ace",
+            suit: suit || "Spades",
+            enhancement: item.enhancement || item.modifier || null,
+            seal: item.seal || null,
+            edition: item.edition || null
+        };
+    }
+    // 2. If it's a string token
+    if (typeof item === 'string') {
+        const str = item.trim();
+        // Handle rank_suit format e.g. "2_C"
+        if (str.includes('_')) {
+            const [r, s] = str.split('_');
+            const rank = RANK_MAP[r.toUpperCase()] || r;
+            const suit = SUIT_MAP[s.toUpperCase()] || s;
+            return { rank, suit, enhancement: null, seal: null, edition: null };
+        }
+        // Handle "Rank of Suit" format
+        const parts = str.toLowerCase().split(' ');
+        const ofIndex = parts.indexOf('of');
+        if (ofIndex > 0 && ofIndex < parts.length - 1) {
+            let rank = parts[ofIndex - 1];
+            let suit = parts[ofIndex + 1];
+            // Normalize
+            rank = rank.charAt(0).toUpperCase() + rank.slice(1);
+            suit = suit.charAt(0).toUpperCase() + suit.slice(1);
+            if (!suit.endsWith('s'))
+                suit += 's';
+            return {
+                rank: RANK_MAP[rank.toUpperCase()] || rank,
+                suit: SUIT_MAP[suit.toUpperCase()] || suit,
+                enhancement: parts.find(p => ENHANCEMENTS.some(e => e.toLowerCase() === p)) || null,
+                seal: parts.find(p => SEALS.some(s => s.toLowerCase() === p)) || null,
+                edition: parts.find(p => EDITIONS.some(e => e.toLowerCase() === p)) || null
+            };
+        }
+    }
+    return null;
+}

package/dist/lib/classes/BuyMetaData.d.ts

@@ -0,0 +1,11 @@
+export interface BuyMetaData {
+    name?: string;
+    ante?: number;
+    blind?: string;
+    card?: {
+        type?: string;
+        base?: string | string[];
+        [key: string]: any;
+    };
+    [key: string]: any;
+}

package/dist/lib/classes/BuyMetaData.js

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

package/dist/lib/config.d.ts

@@ -0,0 +1,13 @@
+export declare const ritualConfig: {
+    title: string;
+    tagline: string;
+    id: string;
+    defaultObjective: string;
+    /**
+     * The Weepoch (Jan 30, 2026)
+     * This is the canonical start date for Day 1.
+     */
+    epochDate: string;
+    readonly epoch: number;
+};
+export declare const EPOCH: number;

package/dist/lib/config.js

@@ -0,0 +1,15 @@
+export const ritualConfig = {
+    title: "The Daily Wee",
+    tagline: "A curated daily Balatro ritual",
+    id: "TheDailyWee",
+    defaultObjective: "Wee Joker",
+    /**
+     * The Weepoch (Jan 30, 2026)
+     * This is the canonical start date for Day 1.
+     */
+    epochDate: "2026-02-02T00:00:00Z",
+    get epoch() {
+        return new Date(this.epochDate).getTime();
+    }
+};
+export const EPOCH = ritualConfig.epoch;

package/dist/lib/const.d.ts

@@ -0,0 +1,61 @@
+import type { ReactNode } from "react";
+import type { BuyMetaData } from "./classes/BuyMetaData.ts";
+export declare const jokers: any;
+export declare const jokerFaces: any;
+export declare const consumablesFaces: any;
+export declare const boosterPacks: any;
+export declare const tarotsAndPlanets: any;
+export declare const tags: any;
+export declare const vouchers: any;
+export declare const bosses: any;
+export declare const editionMap: any;
+export declare const stickerMap: any;
+export declare const options: any;
+export declare const blinds: any;
+export declare const blindsCamelCase: string[];
+export declare const SeedsWithLegendary: Array<string>;
+export declare const popularSeeds: Array<string>;
+export interface AnalyzeOptions {
+    showCardSpoilers: boolean;
+    buys: {
+        [key: string]: BuyMetaData;
+    };
+    sells: {
+        [key: string]: BuyMetaData;
+    };
+    updates: Array<{
+        [key: string]: any;
+    }>;
+    unlocks: Array<string>;
+    events: Array<Event>;
+}
+export interface BuyWrapperProps {
+    children: ReactNode;
+    bottomOffset?: number;
+    topOffset?: number;
+    metaData?: BuyMetaData;
+    horizontal?: boolean;
+}
+export declare enum LOCATIONS {
+    SHOP = "SHOP",
+    PACK = "PACK",
+    MISC = "MISC",
+    VOUCHER = "VOUCHER"
+}
+export declare enum LOCATION_TYPES {
+    SHOP = "SHOP",
+    PACK = "PACK",
+    CARD = "CARD"
+}
+export interface CardEvent {
+    name: string;
+    ante: number;
+    blind: string;
+}
+export declare const EVENT_UNLOCKS: {
+    name: string;
+    condition: string;
+}[];
+export declare const tagDescriptions: {
+    [key: string]: string;
+};