jaml-ui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pifreak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# jaml-ui
+
+Balatro rendering components, sprite metadata, and optional Motely helpers for React apps.
+
+## Package shape
+
+- `jaml-ui`
+  - React/client entry for rendered components and hooks
+- `jaml-ui/core`
+  - Pure asset helpers, sprite metadata, and decode utilities that do not depend on `motely-wasm`
+- `jaml-ui/motely`
+  - Optional plain `motely-wasm` helpers for decoding Motely item enums
+
+## Install
+
+```bash
+npm install jaml-ui react react-dom
+```
+
+If you want the Motely-specific helpers too:
+
+```bash
+npm install jaml-ui motely-wasm react react-dom
+```
+
+## Quick start
+
+```tsx
+"use client";
+
+import { JamlGameCard } from "jaml-ui";
+
+export function Example() {
+  return (
+    <JamlGameCard
+      type="joker"
+      card={{
+        name: "Blueprint",
+        edition: "Foil",
+        isEternal: true,
+        scale: 1.5,
+      }}
+    />
+  );
+}
+```
+
+## Asset handling
+
+By default, `jaml-ui` resolves its packaged sprite assets from the package `assets/` directory using `import.meta.url`.
+
+If you want to host the assets yourself, set a custom base URL once during app startup:
+
+```tsx
+"use client";
+
+import { setJamlAssetBaseUrl } from "jaml-ui";
+
+setJamlAssetBaseUrl("/vendor/jaml-ui/");
+```
+
+Reset back to packaged assets with:
+
+```ts
+import { clearJamlAssetBaseUrl } from "jaml-ui";
+
+clearJamlAssetBaseUrl();
+```
+
+## Core utilities
+
+```ts
+import { SPRITE_SHEETS, getSpriteData, resolveJamlAssetUrl } from "jaml-ui/core";
+
+const jokerSheetUrl = SPRITE_SHEETS.jokers.src;
+const blueprintSprite = getSpriteData("Blueprint");
+const vouchersUrl = resolveJamlAssetUrl("vouchers");
+```
+
+## Motely helpers
+
+```ts
+"use client";
+
+import { decodeMotelyItemName, motelyItemTypeName } from "jaml-ui/motely";
+
+const itemName = decodeMotelyItemName(0x5001);
+const enumKey = motelyItemTypeName(0x5001);
+```
+
+## Next.js notes
+
+- The root `jaml-ui` entry is client-oriented and preserves the `"use client"` boundary for component consumers.
+- Import pure helpers from `jaml-ui/core` when you want server-safe metadata and asset utilities.
+- If you are consuming `jaml-ui` from a local workspace package in a Next.js app, you may need:
+
+```ts
+// next.config.ts
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  transpilePackages: ["jaml-ui"],
+};
+
+export default nextConfig;
+```
+
+## Browser-first runtime direction
+
+`jaml-ui` is designed for browser/React consumers. The optional `jaml-ui/motely` entry targets plain `motely-wasm` and does not assume threaded WASM, SAB, or COEP setup.

package/dist/assets.d.ts

@@ -0,0 +1,18 @@
+export declare const JAML_ASSET_FILES: {
+    readonly deck: "8BitDeck.png";
+    readonly blinds: "BlindChips.png";
+    readonly boosters: "Boosters.png";
+    readonly editions: "Editions.png";
+    readonly enhancers: "Enhancers.png";
+    readonly jokers: "Jokers.png";
+    readonly tarots: "Tarots.png";
+    readonly vouchers: "Vouchers.png";
+    readonly stickers: "stickers.png";
+    readonly tags: "tags.png";
+};
+export type JamlAssetKey = keyof typeof JAML_ASSET_FILES;
+export type JamlAssetFile = (typeof JAML_ASSET_FILES)[JamlAssetKey];
+export declare function setJamlAssetBaseUrl(baseUrl: string | null | undefined): void;
+export declare function clearJamlAssetBaseUrl(): void;
+export declare function resolveJamlAssetUrl(asset: JamlAssetKey | JamlAssetFile): string;
+export declare function getDefaultJamlAssetUrlMap(): Readonly<Record<JamlAssetKey, string>>;

package/dist/assets.js

@@ -0,0 +1,66 @@
+export const JAML_ASSET_FILES = {
+    deck: "8BitDeck.png",
+    blinds: "BlindChips.png",
+    boosters: "Boosters.png",
+    editions: "Editions.png",
+    enhancers: "Enhancers.png",
+    jokers: "Jokers.png",
+    tarots: "Tarots.png",
+    vouchers: "Vouchers.png",
+    stickers: "stickers.png",
+    tags: "tags.png",
+};
+const assetKeyByFileName = Object.fromEntries(Object.entries(JAML_ASSET_FILES).map(([key, fileName]) => [fileName, key]));
+const defaultAssetUrls = {
+    deck: new URL("../assets/8BitDeck.png", import.meta.url).href,
+    blinds: new URL("../assets/BlindChips.png", import.meta.url).href,
+    boosters: new URL("../assets/Boosters.png", import.meta.url).href,
+    editions: new URL("../assets/Editions.png", import.meta.url).href,
+    enhancers: new URL("../assets/Enhancers.png", import.meta.url).href,
+    jokers: new URL("../assets/Jokers.png", import.meta.url).href,
+    tarots: new URL("../assets/Tarots.png", import.meta.url).href,
+    vouchers: new URL("../assets/Vouchers.png", import.meta.url).href,
+    stickers: new URL("../assets/stickers.png", import.meta.url).href,
+    tags: new URL("../assets/tags.png", import.meta.url).href,
+};
+let customAssetBaseUrl = null;
+function normalizeBaseUrl(baseUrl) {
+    const trimmed = baseUrl.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Jaml asset base URL must not be empty.");
+    }
+    return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+function joinAssetUrl(baseUrl, fileName) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(normalized) || normalized.startsWith("//")) {
+        return new URL(fileName, normalized).href;
+    }
+    return `${normalized}${fileName}`;
+}
+export function setJamlAssetBaseUrl(baseUrl) {
+    if (baseUrl == null) {
+        customAssetBaseUrl = null;
+        return;
+    }
+    const trimmed = baseUrl.trim();
+    customAssetBaseUrl = trimmed.length === 0 ? null : normalizeBaseUrl(trimmed);
+}
+export function clearJamlAssetBaseUrl() {
+    customAssetBaseUrl = null;
+}
+export function resolveJamlAssetUrl(asset) {
+    const assetKey = asset in JAML_ASSET_FILES
+        ? asset
+        : assetKeyByFileName[asset];
+    if (!assetKey) {
+        throw new Error(`Unknown Jaml asset '${asset}'.`);
+    }
+    if (customAssetBaseUrl) {
+        return joinAssetUrl(customAssetBaseUrl, JAML_ASSET_FILES[assetKey]);
+    }
+    return defaultAssetUrls[assetKey];
+}
+export function getDefaultJamlAssetUrlMap() {
+    return defaultAssetUrls;
+}

package/dist/components/CardList.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export interface CardListProps {
+    title: string;
+    subtitle?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function CardList({ title, subtitle, children, className }: CardListProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/CardList.js

@@ -0,0 +1,5 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function CardList({ title, subtitle, children, className = "" }) {
+    return (_jsxs("div", { className: className, children: [_jsxs("div", { style: { marginBottom: 4 }, children: [_jsx("span", { style: { fontWeight: 600, fontSize: 12 }, children: title }), subtitle && _jsx("span", { style: { fontSize: 10, opacity: 0.6, marginLeft: 4 }, children: subtitle })] }), _jsx("div", { style: { display: "flex", gap: 4, overflowX: "auto", paddingBottom: 4 }, children: children })] }));
+}

package/dist/components/GameCard.d.ts

@@ -0,0 +1,52 @@
+export interface JamlGameCardProps {
+    card: {
+        name: string;
+        edition?: "Foil" | "Holographic" | "Polychrome" | "Negative";
+        isEternal?: boolean;
+        isPerishable?: boolean;
+        isRental?: boolean;
+        rank?: string;
+        suit?: string;
+        enhancements?: string[];
+        seal?: string;
+        scale?: number;
+    };
+    type: "joker" | "consumable" | "playing";
+    className?: string;
+}
+export type AnalyzerShopItem = {
+    id: string;
+    name: string;
+    value?: number;
+};
+export type AnalyzerResolvedItem = {
+    kind: "voucher";
+    voucherName: string;
+} | {
+    kind: "joker" | "consumable" | "playing";
+    card: JamlGameCardProps["card"];
+    type: JamlGameCardProps["type"];
+} | {
+    kind: "unknown";
+    label: string;
+};
+export declare function resolveAnalyzerShopItem(item: AnalyzerShopItem, scale?: number): AnalyzerResolvedItem;
+export declare function JamlGameCard({ card, type, className }: JamlGameCardProps): import("react/jsx-runtime").JSX.Element;
+export interface VoucherProps {
+    voucherName: string;
+    scale?: number;
+    className?: string;
+}
+export declare function JamlVoucher({ voucherName, scale, className }: VoucherProps): import("react/jsx-runtime").JSX.Element | null;
+export interface TagProps {
+    tagName: string;
+    scale?: number;
+    className?: string;
+}
+export declare function JamlTag({ tagName, scale, className }: TagProps): import("react/jsx-runtime").JSX.Element | null;
+export interface BossProps {
+    bossName: string;
+    scale?: number;
+    className?: string;
+}
+export declare function JamlBoss({ bossName, scale, className }: BossProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/GameCard.js

@@ -0,0 +1,351 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Layer } from "../render/Layer.js";
+import { JamlCardRenderer } from "../render/CanvasRenderer.js";
+import { JOKERS, JOKER_FACES, TAROTS_AND_PLANETS, CONSUMABLE_FACES, TAGS, VOUCHERS, BOSSES, EDITION_MAP, SPRITE_SHEETS, STICKER_MAP, } from "../sprites/spriteData.js";
+import { BalatroItemCategory, isPackedItemValid, packedItemCategory } from "../decode/packedBalatroItem.js";
+import { getEnhancerPosition, getSealPosition, getStandardCardPosition } from "../utils/gameCardUtils.js";
+function normalizeCardRank(raw) {
+    const value = raw.trim().toUpperCase();
+    if (value === "A" || value === "ACE")
+        return "Ace";
+    if (value === "K" || value === "KING")
+        return "King";
+    if (value === "Q" || value === "QUEEN")
+        return "Queen";
+    if (value === "J" || value === "JACK")
+        return "Jack";
+    return raw.trim();
+}
+function normalizeCardSuit(raw) {
+    const value = raw.trim().toLowerCase();
+    if (value === "heart" || value === "hearts")
+        return "Hearts";
+    if (value === "club" || value === "clubs")
+        return "Clubs";
+    if (value === "diamond" || value === "diamonds")
+        return "Diamonds";
+    if (value === "spade" || value === "spades")
+        return "Spades";
+    return raw.trim();
+}
+function parsePlayingCardName(name) {
+    const trimmed = name.trim();
+    const ofMatch = /^(A|K|Q|J|10|[2-9]|Ace|King|Queen|Jack)\s+of\s+(Hearts|Clubs|Diamonds|Spades)$/i.exec(trimmed);
+    if (ofMatch) {
+        return {
+            rank: normalizeCardRank(ofMatch[1]),
+            suit: normalizeCardSuit(ofMatch[2]),
+        };
+    }
+    const shortMatch = /^(A|K|Q|J|10|[2-9])\s*([HCDS])$/i.exec(trimmed);
+    if (shortMatch) {
+        const suitMap = {
+            H: "Hearts",
+            C: "Clubs",
+            D: "Diamonds",
+            S: "Spades",
+        };
+        return {
+            rank: normalizeCardRank(shortMatch[1]),
+            suit: suitMap[shortMatch[2].toUpperCase()],
+        };
+    }
+    return null;
+}
+const MODIFIER_PREFIXES = [
+    "Eternal",
+    "Perishable",
+    "Rental",
+    "Foil",
+    "Holographic",
+    "Polychrome",
+    "Negative",
+    "Bonus",
+    "Mult",
+    "Wild",
+    "Glass",
+    "Steel",
+    "Stone",
+    "Gold",
+    "Lucky",
+    "Gold Seal",
+    "Red Seal",
+    "Blue Seal",
+    "Purple Seal",
+];
+function stripModifiers(name) {
+    let remaining = name;
+    let edition;
+    let isEternal = false;
+    let isPerishable = false;
+    let isRental = false;
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const prefix of MODIFIER_PREFIXES) {
+            if (remaining.startsWith(prefix + " ")) {
+                const stripped = remaining.slice(prefix.length + 1);
+                if (prefix === "Foil" || prefix === "Holographic" || prefix === "Polychrome" || prefix === "Negative") {
+                    edition = prefix;
+                }
+                else if (prefix === "Eternal") {
+                    isEternal = true;
+                }
+                else if (prefix === "Perishable") {
+                    isPerishable = true;
+                }
+                else if (prefix === "Rental") {
+                    isRental = true;
+                }
+                remaining = stripped;
+                changed = true;
+                break;
+            }
+        }
+    }
+    return { baseName: remaining, edition, isEternal, isPerishable, isRental };
+}
+function resolvePackedAnalyzerItem(item, scale) {
+    if (typeof item.value !== "number" || !Number.isFinite(item.value) || !isPackedItemValid(item.value)) {
+        return null;
+    }
+    const displayName = String(item.name || "").trim();
+    const { baseName, edition, isEternal, isPerishable, isRental } = stripModifiers(displayName);
+    const category = packedItemCategory(item.value);
+    if (category === BalatroItemCategory.Joker) {
+        const jokerName = JOKERS.some((joker) => joker.name === baseName) ? baseName : displayName;
+        if (JOKERS.some((joker) => joker.name === jokerName)) {
+            return { kind: "joker", type: "joker", card: { name: jokerName, edition, isEternal, isPerishable, isRental, scale } };
+        }
+    }
+    if (category === BalatroItemCategory.Tarot ||
+        category === BalatroItemCategory.Planet ||
+        category === BalatroItemCategory.Spectral) {
+        const consumableName = TAROTS_AND_PLANETS.some((consumable) => consumable.name === baseName) ? baseName : displayName;
+        if (TAROTS_AND_PLANETS.some((consumable) => consumable.name === consumableName)) {
+            return { kind: "consumable", type: "consumable", card: { name: consumableName, edition, scale } };
+        }
+    }
+    if (baseName !== displayName) {
+        if (JOKERS.some((joker) => joker.name === baseName)) {
+            return { kind: "joker", type: "joker", card: { name: baseName, edition, isEternal, isPerishable, isRental, scale } };
+        }
+        if (TAROTS_AND_PLANETS.some((consumable) => consumable.name === baseName)) {
+            return { kind: "consumable", type: "consumable", card: { name: baseName, edition, scale } };
+        }
+        if (VOUCHERS.some((voucher) => voucher.name === baseName)) {
+            return { kind: "voucher", voucherName: baseName };
+        }
+    }
+    const playingCard = parsePlayingCardName(displayName) ?? parsePlayingCardName(baseName);
+    if (playingCard) {
+        return {
+            kind: "playing",
+            type: "playing",
+            card: {
+                name: displayName,
+                rank: playingCard.rank,
+                suit: playingCard.suit,
+                scale,
+            },
+        };
+    }
+    return { kind: "unknown", label: displayName };
+}
+export function resolveAnalyzerShopItem(item, scale = 1) {
+    const displayName = String(item.name || "").trim();
+    if (!displayName) {
+        return { kind: "unknown", label: String(item.id || "").trim() || "Unknown Item" };
+    }
+    const packedResolved = resolvePackedAnalyzerItem(item, scale);
+    if (packedResolved && packedResolved.kind !== "unknown") {
+        return packedResolved;
+    }
+    if (VOUCHERS.some((voucher) => voucher.name === displayName)) {
+        return { kind: "voucher", voucherName: displayName };
+    }
+    if (JOKERS.some((joker) => joker.name === displayName)) {
+        return { kind: "joker", type: "joker", card: { name: displayName, scale } };
+    }
+    if (TAROTS_AND_PLANETS.some((consumable) => consumable.name === displayName)) {
+        return { kind: "consumable", type: "consumable", card: { name: displayName, scale } };
+    }
+    const { baseName, edition, isEternal, isPerishable, isRental } = stripModifiers(displayName);
+    if (baseName !== displayName) {
+        if (JOKERS.some((joker) => joker.name === baseName)) {
+            return { kind: "joker", type: "joker", card: { name: baseName, edition, isEternal, isPerishable, isRental, scale } };
+        }
+        if (TAROTS_AND_PLANETS.some((consumable) => consumable.name === baseName)) {
+            return { kind: "consumable", type: "consumable", card: { name: baseName, edition, scale } };
+        }
+        if (VOUCHERS.some((voucher) => voucher.name === baseName)) {
+            return { kind: "voucher", voucherName: baseName };
+        }
+    }
+    const playingCard = parsePlayingCardName(displayName) ?? parsePlayingCardName(baseName);
+    if (playingCard) {
+        return {
+            kind: "playing",
+            type: "playing",
+            card: {
+                name: displayName,
+                rank: playingCard.rank,
+                suit: playingCard.suit,
+                scale,
+            },
+        };
+    }
+    return packedResolved ?? { kind: "unknown", label: displayName };
+}
+export function JamlGameCard({ card, type, className = "" }) {
+    const { name, edition, isEternal, isPerishable, isRental, rank, suit, enhancements, seal, scale = 1 } = card;
+    const layers = [];
+    if (type === "joker") {
+        const jokerData = JOKERS.find((j) => j.name === name);
+        if (jokerData)
+            layers.push(new Layer({ ...jokerData, source: SPRITE_SHEETS.jokers.src, order: 0, columns: SPRITE_SHEETS.jokers.columns, rows: SPRITE_SHEETS.jokers.rows }));
+        const face = JOKER_FACES.find((j) => j.name === name);
+        if (face)
+            layers.push(new Layer({ ...face, source: SPRITE_SHEETS.jokers.src, order: 1, columns: SPRITE_SHEETS.jokers.columns, rows: SPRITE_SHEETS.jokers.rows }));
+    }
+    else if (type === "consumable") {
+        const consumable = TAROTS_AND_PLANETS.find((t) => t.name === name);
+        if (consumable)
+            layers.push(new Layer({ ...consumable, order: 0, source: SPRITE_SHEETS.tarots.src, rows: SPRITE_SHEETS.tarots.rows, columns: SPRITE_SHEETS.tarots.columns }));
+        const face = CONSUMABLE_FACES.find((t) => t.name === name);
+        if (face)
+            layers.push(new Layer({
+                ...face,
+                order: 1,
+                source: SPRITE_SHEETS.enhancers.src,
+                rows: SPRITE_SHEETS.enhancers.rows,
+                columns: SPRITE_SHEETS.enhancers.columns,
+                animated: face.animated,
+            }));
+    }
+    else if (rank && suit) {
+        layers.push(new Layer({
+            pos: getEnhancerPosition(enhancements ?? []),
+            name: "background",
+            order: 0,
+            source: SPRITE_SHEETS.enhancers.src,
+            rows: SPRITE_SHEETS.enhancers.rows,
+            columns: SPRITE_SHEETS.enhancers.columns,
+        }));
+        layers.push(new Layer({
+            pos: getStandardCardPosition(rank, suit),
+            name,
+            order: 1,
+            source: SPRITE_SHEETS.deck.src,
+            rows: SPRITE_SHEETS.deck.rows,
+            columns: SPRITE_SHEETS.deck.columns,
+        }));
+    }
+    if (edition) {
+        const index = EDITION_MAP[edition];
+        if (index !== undefined) {
+            layers.push(new Layer({
+                pos: { x: index, y: 0 },
+                name: edition,
+                order: 2,
+                source: SPRITE_SHEETS.editions.src,
+                rows: SPRITE_SHEETS.editions.rows,
+                columns: SPRITE_SHEETS.editions.columns,
+            }));
+        }
+    }
+    if (isEternal) {
+        layers.push(new Layer({
+            pos: STICKER_MAP["Eternal"],
+            name: "Eternal",
+            order: 3,
+            source: SPRITE_SHEETS.stickers.src,
+            rows: SPRITE_SHEETS.stickers.rows,
+            columns: SPRITE_SHEETS.stickers.columns,
+        }));
+    }
+    if (isPerishable) {
+        layers.push(new Layer({
+            pos: STICKER_MAP["Perishable"],
+            name: "Perishable",
+            order: 4,
+            source: SPRITE_SHEETS.stickers.src,
+            rows: SPRITE_SHEETS.stickers.rows,
+            columns: SPRITE_SHEETS.stickers.columns,
+        }));
+    }
+    if (isRental) {
+        layers.push(new Layer({
+            pos: STICKER_MAP["Rental"],
+            name: "Rental",
+            order: 5,
+            source: SPRITE_SHEETS.stickers.src,
+            rows: SPRITE_SHEETS.stickers.rows,
+            columns: SPRITE_SHEETS.stickers.columns,
+        }));
+    }
+    if (seal) {
+        const sealPos = getSealPosition(seal);
+        if (sealPos) {
+            layers.push(new Layer({
+                pos: sealPos,
+                name: seal,
+                order: 6,
+                source: SPRITE_SHEETS.enhancers.src,
+                rows: SPRITE_SHEETS.enhancers.rows,
+                columns: SPRITE_SHEETS.enhancers.columns,
+            }));
+        }
+    }
+    const wrapperStyle = { width: `${71 * scale}px` };
+    return (_jsx("div", { style: wrapperStyle, className: className, children: _jsx(JamlCardRenderer, { invert: edition === "Negative", layers: layers }) }));
+}
+export function JamlVoucher({ voucherName, scale = 1, className = "" }) {
+    const voucherData = VOUCHERS.find((v) => v.name === voucherName);
+    if (!voucherData)
+        return null;
+    const layers = [
+        new Layer({
+            ...voucherData,
+            order: 0,
+            source: SPRITE_SHEETS.vouchers.src,
+            rows: SPRITE_SHEETS.vouchers.rows,
+            columns: SPRITE_SHEETS.vouchers.columns,
+        }),
+    ];
+    const wrapperStyle = { width: `${71 * scale}px` };
+    return (_jsx("div", { style: wrapperStyle, className: className, children: _jsx(JamlCardRenderer, { layers: layers }) }));
+}
+export function JamlTag({ tagName, scale = 1, className = "" }) {
+    const tagData = TAGS.find((t) => t.name === tagName);
+    if (!tagData)
+        return null;
+    const layers = [
+        new Layer({
+            ...tagData,
+            order: 0,
+            source: SPRITE_SHEETS.tags.src,
+            rows: SPRITE_SHEETS.tags.rows,
+            columns: SPRITE_SHEETS.tags.columns,
+        }),
+    ];
+    const wrapperStyle = { width: `${71 * scale}px` };
+    return (_jsx("div", { style: wrapperStyle, className: className, children: _jsx(JamlCardRenderer, { layers: layers }) }));
+}
+export function JamlBoss({ bossName, scale = 1, className = "" }) {
+    const bossData = BOSSES.find((b) => b.name === bossName);
+    if (!bossData)
+        return null;
+    const layers = [
+        new Layer({
+            ...bossData,
+            order: 0,
+            source: SPRITE_SHEETS.blinds.src,
+            rows: SPRITE_SHEETS.blinds.rows,
+            columns: SPRITE_SHEETS.blinds.columns,
+        }),
+    ];
+    const wrapperStyle = { width: `${71 * scale}px` };
+    return (_jsx("div", { style: wrapperStyle, className: className, children: _jsx(JamlCardRenderer, { layers: layers }) }));
+}

package/dist/components/PlayingCard.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export type CardSuit = 'Hearts' | 'Diamonds' | 'Clubs' | 'Spades' | 'hearts' | 'diamonds' | 'clubs' | 'spades';
+export type CardRank = 'Ace' | 'King' | 'Queen' | 'Jack' | '10' | '9' | '8' | '7' | '6' | '5' | '4' | '3' | '2' | 'A' | 'K' | 'Q' | 'J';
+export type CardEnhancement = 'bonus' | 'mult' | 'wild' | 'glass' | 'steel' | 'stone' | 'gold' | 'lucky' | null;
+export type CardSeal = 'gold' | 'red' | 'blue' | 'purple' | null;
+export type CardEdition = 'Foil' | 'Holographic' | 'Polychrome' | 'Negative' | null;
+interface RealPlayingCardProps {
+    suit: CardSuit;
+    rank: CardRank;
+    enhancement?: CardEnhancement;
+    seal?: CardSeal;
+    edition?: CardEdition;
+    className?: string;
+    size?: number;
+    style?: React.CSSProperties;
+}
+export declare function RealPlayingCard({ suit, rank, enhancement, seal, edition, className, size, style }: RealPlayingCardProps): import("react/jsx-runtime").JSX.Element | null;
+export {};