jaml-ui 0.21.2 → 0.21.4

package/dist/lib/hooks/useJamlFilter.d.ts

@@ -0,0 +1,48 @@
+export interface JamlClause {
+    type: string;
+    value: string;
+    label?: string;
+    antes?: number[];
+    score?: number;
+    edition?: string;
+    seal?: string;
+    enhancement?: string;
+    rank?: string;
+    suit?: string;
+    sources?: string[];
+}
+export interface JamlFilter {
+    name: string;
+    description: string;
+    author: string;
+    deck: string;
+    stake: string;
+    defaults: {
+        antes: number[];
+        packSlots: number[];
+        shopSlots: number[];
+        score: number;
+    };
+    must: JamlClause[];
+    should: JamlClause[];
+    mustNot: JamlClause[];
+}
+import { DECK_OPTIONS, STAKE_OPTIONS, ANTE_OPTIONS, SLOT_OPTIONS, CLAUSE_TYPES, SOURCE_OPTIONS, EDITION_OPTIONS, SEAL_OPTIONS, ENHANCEMENT_OPTIONS } from '@/lib/data/constants';
+export { DECK_OPTIONS, STAKE_OPTIONS, ANTE_OPTIONS, SLOT_OPTIONS, CLAUSE_TYPES, SOURCE_OPTIONS, EDITION_OPTIONS, SEAL_OPTIONS, ENHANCEMENT_OPTIONS };
+export declare function useJamlFilter(initialJaml?: string): {
+    filter: JamlFilter;
+    jamlText: string;
+    setFromJaml: (text: string) => void;
+    updateFilter: (updates: Partial<JamlFilter>) => void;
+    addClause: (bucket: "must" | "should" | "mustNot", clause: JamlClause) => void;
+    editClause: (bucket: "must" | "should" | "mustNot", index: number, clause: JamlClause) => void;
+    deleteClause: (bucket: "must" | "should" | "mustNot", index: number) => void;
+    editingClause: {
+        bucket: keyof Pick<JamlFilter, "must" | "should" | "mustNot">;
+        index: number | null;
+    } | null;
+    setEditingClause: import("react").Dispatch<import("react").SetStateAction<{
+        bucket: keyof Pick<JamlFilter, "must" | "should" | "mustNot">;
+        index: number | null;
+    } | null>>;
+};

package/dist/lib/hooks/useJamlFilter.js

@@ -0,0 +1,219 @@
+import { useState, useCallback, useMemo } from 'react';
+import { DECK_OPTIONS, STAKE_OPTIONS, ANTE_OPTIONS, SLOT_OPTIONS, CLAUSE_TYPES, SOURCE_OPTIONS, EDITION_OPTIONS, SEAL_OPTIONS, ENHANCEMENT_OPTIONS } from '@/lib/data/constants';
+export { DECK_OPTIONS, STAKE_OPTIONS, ANTE_OPTIONS, SLOT_OPTIONS, CLAUSE_TYPES, SOURCE_OPTIONS, EDITION_OPTIONS, SEAL_OPTIONS, ENHANCEMENT_OPTIONS };
+export function useJamlFilter(initialJaml) {
+    const [filter, setFilter] = useState(parseJamlToFilter(initialJaml || ''));
+    const [editingClause, setEditingClause] = useState(null);
+    // useEffect removed to restore previous UX behavior
+    // The JAML from server (Rules format) parses to empty clauses,
+    // causing the UI to lose state after load. we want to keep the initial state.
+    const jamlText = useMemo(() => filterToJaml(filter), [filter]);
+    const updateFilter = useCallback((updates) => {
+        setFilter(prev => ({ ...prev, ...updates }));
+    }, []);
+    const addClause = useCallback((bucket, clause) => {
+        setFilter(prev => ({
+            ...prev,
+            [bucket]: [...prev[bucket], clause]
+        }));
+    }, []);
+    const editClause = useCallback((bucket, index, clause) => {
+        setFilter(prev => ({
+            ...prev,
+            [bucket]: prev[bucket].map((c, i) => i === index ? clause : c)
+        }));
+    }, []);
+    const deleteClause = useCallback((bucket, index) => {
+        setFilter(prev => ({
+            ...prev,
+            [bucket]: prev[bucket].filter((_, i) => i !== index)
+        }));
+    }, []);
+    const setFromJaml = useCallback((text) => {
+        const newFilter = parseJamlToFilter(text);
+        setFilter(newFilter);
+    }, []);
+    return {
+        filter,
+        jamlText,
+        setFromJaml,
+        updateFilter,
+        addClause,
+        editClause,
+        deleteClause,
+        editingClause,
+        setEditingClause
+    };
+}
+function parseJamlToFilter(text) {
+    if (!text.trim())
+        return createBlankFilter();
+    try {
+        const filter = createBlankFilter();
+        // Reset arrays to empty since we are parsing fresh
+        filter.must = [];
+        filter.should = [];
+        filter.mustNot = [];
+        const lines = text.split('\n');
+        let currentSection = null;
+        let currentClause = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            // 1. Detect Section Headers
+            if (trimmed === 'must:') {
+                currentSection = 'must';
+                currentClause = null;
+                continue;
+            }
+            if (trimmed === 'should:') {
+                currentSection = 'should';
+                currentClause = null;
+                continue;
+            }
+            if (trimmed === 'mustNot:') {
+                currentSection = 'mustNot';
+                currentClause = null;
+                continue;
+            }
+            if (trimmed === 'defaults:') {
+                currentSection = 'defaults';
+                continue;
+            }
+            // 2. Detect Root Properties (indent 0)
+            const rootMatch = line.match(/^(\w+):\s*(.+)$/);
+            if (rootMatch && !line.startsWith(' ') && !line.startsWith('-')) {
+                const [_, key, val] = rootMatch;
+                if (['name', 'deck', 'stake', 'description', 'author'].includes(key)) {
+                    filter[key] = val.trim();
+                }
+                continue;
+            }
+            // 3. Handle Sections
+            if (currentSection) {
+                if (currentSection === 'defaults') {
+                    const propMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+                    if (propMatch) {
+                        const [_, key, val] = propMatch;
+                        if (key === 'antes')
+                            filter.defaults.antes = parseNumArray(val);
+                        if (key === 'packSlots')
+                            filter.defaults.packSlots = parseNumArray(val);
+                        if (key === 'shopSlots')
+                            filter.defaults.shopSlots = parseNumArray(val);
+                        if (key === 'score')
+                            filter.defaults.score = parseInt(val) || 0;
+                    }
+                }
+                else {
+                    // Start of new clause
+                    const typeMatch = trimmed.match(/^-\s*type:\s*(.+)$/);
+                    if (typeMatch) {
+                        currentClause = { type: typeMatch[1].trim(), value: '' };
+                        filter[currentSection].push(currentClause);
+                        continue;
+                    }
+                    // Properties of current clause
+                    if (currentClause) {
+                        const propMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+                        if (propMatch) {
+                            const [_, key, val] = propMatch;
+                            if (key === 'antes')
+                                currentClause.antes = parseNumArray(val);
+                            else if (key === 'sources')
+                                currentClause.sources = parseStringArray(val);
+                            else if (key === 'score')
+                                currentClause.score = parseInt(val) || 0;
+                            else
+                                currentClause[key] = val.trim();
+                        }
+                    }
+                }
+            }
+        }
+        return filter;
+    }
+    catch (e) {
+        console.warn('JAML Parse Error:', e);
+        return createBlankFilter();
+    }
+}
+function parseNumArray(str) {
+    return str.replace(/[\[\]]/g, '').split(',').map(s => parseInt(s.trim())).filter(n => !isNaN(n));
+}
+function parseStringArray(str) {
+    return str.replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(s => !!s);
+}
+function filterToJaml(filter) {
+    const lines = [];
+    lines.push(`name: ${filter.name}`);
+    lines.push(`description: ${filter.description || ''}`);
+    lines.push(`author: ${filter.author || ''}`);
+    lines.push(`deck: ${filter.deck}`);
+    lines.push(`stake: ${filter.stake}`);
+    lines.push('');
+    lines.push('defaults:');
+    lines.push(`  antes: [${filter.defaults.antes.join(', ')}]`);
+    lines.push(`  packSlots: [${filter.defaults.packSlots.join(', ')}]`);
+    lines.push(`  shopSlots: [${filter.defaults.shopSlots.join(', ')}]`);
+    lines.push(`  score: ${filter.defaults.score}`);
+    lines.push('');
+    if (filter.must.length > 0) {
+        lines.push('must:');
+        filter.must.forEach(clause => lines.push(...clauseToLines(clause, '  ')));
+    }
+    if (filter.should.length > 0) {
+        lines.push('should:');
+        filter.should.forEach(clause => lines.push(...clauseToLines(clause, '  ')));
+    }
+    if (filter.mustNot.length > 0) {
+        lines.push('mustNot:');
+        filter.mustNot.forEach(clause => lines.push(...clauseToLines(clause, '  ')));
+    }
+    return lines.join('\n');
+}
+function clauseToLines(clause, indent) {
+    const lines = [];
+    lines.push(`${indent}- type: ${clause.type}`);
+    lines.push(`${indent}  value: ${clause.value}`);
+    if (clause.label)
+        lines.push(`${indent}  label: ${clause.label}`);
+    if (clause.antes && clause.antes.length > 0)
+        lines.push(`${indent}  antes: [${clause.antes.join(', ')}]`);
+    if (clause.score)
+        lines.push(`${indent}  score: ${clause.score}`);
+    if (clause.edition)
+        lines.push(`${indent}  edition: ${clause.edition}`);
+    if (clause.seal)
+        lines.push(`${indent}  seal: ${clause.seal}`);
+    if (clause.enhancement)
+        lines.push(`${indent}  enhancement: ${clause.enhancement}`);
+    if (clause.rank)
+        lines.push(`${indent}  rank: ${clause.rank}`);
+    if (clause.suit)
+        lines.push(`${indent}  suit: ${clause.suit}`);
+    if (clause.sources && clause.sources.length > 0)
+        lines.push(`${indent}  sources: [${clause.sources.join(', ')}]`);
+    return lines;
+}
+function createBlankFilter() {
+    return {
+        name: 'New Filter',
+        description: '',
+        author: '',
+        deck: 'Erratic',
+        stake: 'White',
+        defaults: {
+            antes: [...ANTE_OPTIONS],
+            packSlots: [...SLOT_OPTIONS],
+            shopSlots: [...SLOT_OPTIONS],
+            score: 1
+        },
+        must: [],
+        should: [
+            { type: 'joker', value: 'Joker' }
+        ],
+        mustNot: []
+    };
+}

package/dist/lib/hooks/useSeedAnalyzer.d.ts

@@ -0,0 +1,6 @@
+import { Analysis } from 'motely-wasm';
+export declare function useSeedAnalyzer(seed: string | null): {
+    data: Analysis.MotelyLegacyTextAnalyzer | null | undefined;
+    loading: boolean;
+    error: string | null;
+};

package/dist/lib/hooks/useSeedAnalyzer.js

@@ -0,0 +1,48 @@
+"use client";
+import { useState, useEffect } from 'react';
+import motely, { MotelyWasm } from 'motely-wasm';
+export function useSeedAnalyzer(seed) {
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!seed || seed === "LOCKED") {
+            setData(null);
+            return;
+        }
+        const abortController = new AbortController();
+        const runAnalysis = async () => {
+            setLoading(true);
+            setError(null);
+            try {
+                await motely.boot();
+                if (abortController.signal.aborted)
+                    return;
+                const jaml = `version: 1\nconfig:\n  deck: Erratic\n  stake: White\n`;
+                const rawResult = MotelyWasm.analyzeJamlSeeds(jaml, [seed]);
+                if (abortController.signal.aborted)
+                    return;
+                if (rawResult && rawResult.seeds.length > 0) {
+                    const result = rawResult.seeds[0];
+                    setData(result.analysis || null);
+                }
+                else {
+                    throw new Error("No analysis result returned");
+                }
+            }
+            catch (err) {
+                if (abortController.signal.aborted)
+                    return;
+                console.error("[useSeedAnalyzer] Analysis error:", err);
+                setError(err instanceof Error ? err.message : String(err));
+            }
+            finally {
+                if (!abortController.signal.aborted)
+                    setLoading(false);
+            }
+        };
+        runAnalysis();
+        return () => abortController.abort();
+    }, [seed]);
+    return { data, loading, error };
+}

package/dist/lib/jaml/jamlCompletion.d.ts

@@ -0,0 +1,12 @@
+export interface CompletionData {
+    text: string;
+    displayText: string;
+    type: 'keyword' | 'value';
+}
+export interface YamlCompletionContext {
+    key?: string;
+    indent: number;
+}
+export declare class JamlCompletionService {
+    static getCompletions(currentValue: string): CompletionData[];
+}

package/dist/lib/jaml/jamlCompletion.js

@@ -0,0 +1,13 @@
+import { JAML_KEYWORDS } from './jamlData';
+export class JamlCompletionService {
+    static getCompletions(currentValue) {
+        const lower = currentValue.toLowerCase();
+        return JAML_KEYWORDS
+            .filter(k => k.toLowerCase().includes(lower))
+            .map(k => ({
+            text: k,
+            displayText: k,
+            type: 'keyword'
+        }));
+    }
+}

package/dist/lib/jaml/jamlData.d.ts

@@ -0,0 +1,3 @@
+export declare const CLAUSE_TYPES: string[];
+export declare const ARRAY_KEYS: string[];
+export declare const JAML_KEYWORDS: string[];

package/dist/lib/jaml/jamlData.js

@@ -0,0 +1,8 @@
+export const CLAUSE_TYPES = [
+    'joker', 'soulJoker', 'voucher', 'tarotCard', 'planetCard',
+    'spectralCard', 'standardCard', 'tag', 'boss', 'event'
+];
+export const ARRAY_KEYS = ['antes', 'tags', 'labels'];
+export const JAML_KEYWORDS = [
+    'must', 'should', 'mustNot', 'any', 'Any', ...CLAUSE_TYPES, ...ARRAY_KEYS
+];

package/dist/lib/jaml/jamlObjectives.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JAML Objectives Parser
+ *
+ * Extracts display-ready objective names from a JAML config string
+ * using the existing useJamlFilter parser — no hand-rolled regex.
+ *
+ * This is the ONLY place JAML → objective extraction should happen.
+ */
+/**
+ * Parse a JAML config string and extract objectives (must-clause values).
+ * Returns an array of human-readable objective names.
+ */
+export declare function parseJamlToObjectives(jamlConfig: string): string[];

package/dist/lib/jaml/jamlObjectives.js

@@ -0,0 +1,97 @@
+/**
+ * JAML Objectives Parser
+ *
+ * Extracts display-ready objective names from a JAML config string
+ * using the existing useJamlFilter parser — no hand-rolled regex.
+ *
+ * This is the ONLY place JAML → objective extraction should happen.
+ */
+/**
+ * Parse a JAML config string and extract objectives (must-clause values).
+ * Returns an array of human-readable objective names.
+ */
+export function parseJamlToObjectives(jamlConfig) {
+    if (!jamlConfig.trim())
+        return [];
+    const objectives = [];
+    const lines = jamlConfig.split('\n');
+    let inMustBlock = false;
+    let currentClause = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        // Section headers
+        if (trimmed === 'must:') {
+            inMustBlock = true;
+            currentClause = null;
+            continue;
+        }
+        if (trimmed === 'should:' || trimmed === 'mustNot:' || trimmed === 'defaults:') {
+            // Flush current clause before leaving must block
+            if (inMustBlock && currentClause) {
+                const name = currentClause.label || currentClause.value;
+                if (name)
+                    objectives.push(name);
+            }
+            inMustBlock = false;
+            currentClause = null;
+            continue;
+        }
+        if (!inMustBlock)
+            continue;
+        // New clause (starts with -)
+        if (trimmed.startsWith('-')) {
+            // Flush previous clause
+            if (currentClause) {
+                const name = currentClause.label || currentClause.value;
+                if (name)
+                    objectives.push(name);
+            }
+            currentClause = {};
+            // Parse inline key:value on same line as dash
+            const inlineMatch = trimmed.match(/^-\s*(\w+):\s*(.+)$/);
+            if (inlineMatch) {
+                const [, key, val] = inlineMatch;
+                if (key === 'type')
+                    currentClause.type = val.trim();
+                else if (key === 'value')
+                    currentClause.value = val.trim();
+                else if (key === 'label')
+                    currentClause.label = val.trim();
+                else {
+                    // Shorthand: `- joker: Blueprint` means type=joker, value=Blueprint
+                    currentClause.type = key;
+                    currentClause.value = val.trim();
+                }
+            }
+            continue;
+        }
+        // Properties of current clause (indented, no dash)
+        if (currentClause) {
+            const propMatch = trimmed.match(/^(\w+):\s*(.+)$/);
+            if (propMatch) {
+                const [, key, val] = propMatch;
+                if (key === 'value')
+                    currentClause.value = val.trim();
+                else if (key === 'label')
+                    currentClause.label = val.trim();
+                else if (key === 'type')
+                    currentClause.type = val.trim();
+                else if (!currentClause.value && key !== 'antes' && key !== 'score' && key !== 'sources' && key !== 'edition' && key !== 'seal' && key !== 'enhancement') {
+                    // Shorthand values like `joker: Blueprint` inside a clause
+                    // Only use as value if we don't already have one
+                    currentClause.type = currentClause.type || key;
+                    currentClause.value = val.trim();
+                }
+            }
+        }
+    }
+    // Flush final clause
+    if (inMustBlock && currentClause) {
+        const name = currentClause.label || currentClause.value;
+        if (name)
+            objectives.push(name);
+    }
+    return objectives;
+}

package/dist/lib/jaml/jamlParser.d.ts

@@ -0,0 +1,14 @@
+export interface HighlightingRules {
+    highPriority: Set<string>;
+    mediumPriority: Set<string>;
+}
+/**
+ * Simple regex-based JAML parser for extracting highlighting rules.
+ * Handles basic YAML structure:
+ * Must:
+ *   - joker: WeeJoker
+ * Should:
+ *   - joker: HangingChad
+ */
+export declare function parseJamlHighlights(jamlContent: string | null): HighlightingRules;
+export declare function normalizeName(name: string): string;

package/dist/lib/jaml/jamlParser.js

@@ -0,0 +1,47 @@
+/**
+ * Simple regex-based JAML parser for extracting highlighting rules.
+ * Handles basic YAML structure:
+ * Must:
+ *   - joker: WeeJoker
+ * Should:
+ *   - joker: HangingChad
+ */
+export function parseJamlHighlights(jamlContent) {
+    const rules = {
+        highPriority: new Set(),
+        mediumPriority: new Set()
+    };
+    if (!jamlContent)
+        return rules;
+    const lines = jamlContent.split('\n');
+    let currentSection = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('Must:')) {
+            currentSection = 'Must';
+            continue;
+        }
+        if (trimmed.startsWith('Should:')) {
+            currentSection = 'Should';
+            continue;
+        }
+        // Look for "- joker: Name" or "- souljoker: Name"
+        const jokerMatch = trimmed.match(/- (?:joker|souljoker): (.+)/);
+        if (jokerMatch) {
+            const name = jokerMatch[1].trim();
+            // Normalize: "WeeJoker" -> "Wee Joker" if needed? 
+            // Blueprint output usually has spaces "Wee Joker". 
+            // JAML uses "WeeJoker".
+            // We'll normalize by removing spaces for comparison.
+            const normalized = name.replace(/\s+/g, '').toLowerCase();
+            if (currentSection === 'Must')
+                rules.highPriority.add(normalized);
+            if (currentSection === 'Should')
+                rules.mediumPriority.add(normalized);
+        }
+    }
+    return rules;
+}
+export function normalizeName(name) {
+    return name.replace(/\s+/g, '').toLowerCase();
+}

package/dist/lib/jaml/jamlPresets.d.ts

@@ -0,0 +1,8 @@
+export interface JamlPreset {
+    id: string;
+    label: string;
+    description: string;
+    jaml: string;
+    icon?: string;
+}
+export declare const JAML_PRESETS: JamlPreset[];

package/dist/lib/jaml/jamlPresets.js

@@ -0,0 +1,61 @@
+export const JAML_PRESETS = [
+    {
+        id: 'soul-hunter',
+        label: 'Soul Hunter',
+        description: 'Find a Spectral Soul card in early Antes.',
+        jaml: `# The Soul Hunter
+name: Soul Hunter
+deck: Red
+stake: White
+
+must:
+  - spectralCard: The Soul
+    antes: [1, 2, 3]
+`
+    },
+    {
+        id: 'negative-blueprint',
+        label: 'Negative Blueprint',
+        description: 'Find a Negative Blueprint early.',
+        jaml: `# Negative Blueprint
+name: Negative Blueprint
+deck: Red
+stake: White
+
+must:
+  - joker: Blueprint
+    edition: Negative
+    antes: [1, 2, 3, 4]
+`
+    },
+    {
+        id: 'mega-tags',
+        label: 'Mega Tags',
+        description: 'Find a lot of Investment and Double Tags.',
+        jaml: `# Mega Tags
+name: Mega Tags
+deck: Red
+stake: White
+
+must:
+  - tag: Double Tag
+    antes: [1, 2]
+  - tag: Investment Tag
+    antes: [1, 2]
+`
+    },
+    {
+        id: 'black-hole',
+        label: 'Black Hole',
+        description: 'Find the elusive Black Hole spectral card.',
+        jaml: `# Black Hole
+name: Black Hole
+deck: Red
+stake: White
+
+must:
+  - spectralCard: Black Hole
+    antes: [1, 2, 3, 4]
+`
+    }
+];

package/dist/lib/jaml/jamlSchema.d.ts

@@ -0,0 +1,54 @@
+/**
+ * JAML Schema Bridge
+ *
+ * Derives all JAML schema constants from motely-wasm/jaml.schema.json.
+ * All JAML-aware files import from here — single swap point if the API changes.
+ */
+export declare const JAML_SCHEMA_VERSION: string;
+/** The raw JSON schema object. */
+export declare const jamlSchema: any;
+/** Root-level metadata keys (name, author, deck, etc.) */
+export declare const METADATA_KEYS: readonly string[];
+/** Section keys that contain clause arrays. */
+export declare const SECTION_KEYS: readonly string[];
+/** Clause type keys — the primary discriminators (joker, voucher, tarot, etc.). */
+export declare const CLAUSE_TYPE_KEYS: readonly string[];
+/** Property keys available inside a clause. */
+export declare const PROPERTY_KEYS: readonly string[];
+/** Source-configuration keys (shopItems, boosterPacks, etc.). */
+export declare const SOURCE_KEYS: readonly string[];
+/**
+ * Get the valid enum values for a given JAML key.
+ * Checks top-level properties first, then falls back to clause properties.
+ */
+export declare function getValidValuesForKey(key: string): readonly string[] | null;
+/**
+ * Get the available properties for a given clause type.
+ * Returns all clause property keys (the type system doesn't restrict per-type in JSON schema v7).
+ */
+export declare function getAvailablePropsForType(_clauseType: string): readonly string[];
+/**
+ * Check if a property is invalid for a clause type.
+ * In the v7 schema, all properties are available on all clause types.
+ */
+export declare function isInvalidPropForType(_prop: string, _clauseType: string): boolean;
+/**
+ * Check if a value is invalid for a property.
+ */
+export declare function isInvalidValueForProp(value: string, prop: string): boolean;
+export interface ValidationState {
+    errors: string[];
+    warnings: string[];
+}
+export declare const DECK_VALUES: readonly string[];
+export declare const STAKE_VALUES: readonly string[];
+export declare const EDITION_VALUES: readonly string[];
+export declare const SEAL_VALUES: readonly string[];
+export declare const ENHANCEMENT_VALUES: readonly string[];
+export declare const RANK_VALUES: readonly string[];
+export declare const SUIT_VALUES: readonly string[];
+export declare const STICKER_VALUES: readonly string[];
+/**
+ * All JAML keywords — sections, metadata keys, clause types, and property keys.
+ */
+export declare const ALL_JAML_KEYWORDS: string[];