rune-lab 0.4.1 → 0.4.2-beta.10

package/dist/RuneProvider.svelte.d.ts

@@ -0,0 +1,30 @@
+import { SvelteComponentTyped } from "svelte";
+import type { PersistenceDriver } from "@rune-lab/kernel";
+/**
+ * Namespaced configuration for Rune Lab plugins.
+ * Keyed by plugin.id.
+ */
+export interface RuneLabConfig {
+    persistence?: PersistenceDriver;
+    /** Optional head management properties */
+    favicon?: string;
+    manageHead?: boolean;
+    icons?: "material" | "none";
+    /** Namespaced config for plugins */
+    [pluginId: string]: unknown;
+}
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {};
+    bindings?: string;
+};
+export type RuneProviderProps = typeof __propDef.props;
+export type RuneProviderEvents = typeof __propDef.events;
+export type RuneProviderSlots = typeof __propDef.slots;
+export default class RuneProvider extends SvelteComponentTyped<RuneProviderProps, RuneProviderEvents, RuneProviderSlots> {
+}
+export {};

package/dist/i18n/message-resolver.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Dynamic i18n Message Resolver Pattern
+ *
+ * Enables dynamic message function calls for config selectors.
+ * Creates a resolver that dynamically looks up and calls message functions.
+ */
+type MessageBundle = Record<string, (...args: unknown[]) => string>;
+interface MessageResolverConfig<T> {
+    /**
+     * Function to extract the message key from an option
+     * @example (currency) => currency.code // "USD"
+     */
+    keyExtractor: (option: T) => string;
+    /**
+     * Optional transformer for the key before message lookup
+     * @example (key) => key.toLowerCase() // "USD" -> "usd"
+     */
+    keyTransformer?: (key: string) => string;
+}
+/**
+ * Creates a message resolver function for dynamic i18n lookups
+ *
+ * @example
+ * ```typescript
+ * const getCurrencyLabel = createMessageResolver<Currency>(m, {
+ *   keyExtractor: (currency) => currency.code
+ * });
+ *
+ * getCurrencyLabel({ code: "EUR", symbol: "€" }); // "Euro"
+ * ```
+ */
+export declare function createMessageResolver<T>(messages: MessageBundle, config: MessageResolverConfig<T>): (option: T) => string;
+/**
+ * Type guard to check if a message key exists
+ */
+export declare function hasMessage(messages: MessageBundle, key: string): boolean;
+/**
+ * Batch resolver for multiple options at once
+ */
+export declare function batchResolveMessages<T>(messages: MessageBundle, options: T[], config: MessageResolverConfig<T>): Record<string, string>;
+export {};

package/dist/i18n/message-resolver.js

@@ -0,0 +1,47 @@
+// sdk/devtools/src/patterns/message-resolver.ts
+import { DEV } from "esm-env";
+/**
+ * Creates a message resolver function for dynamic i18n lookups
+ *
+ * @example
+ * ```typescript
+ * const getCurrencyLabel = createMessageResolver<Currency>(m, {
+ *   keyExtractor: (currency) => currency.code
+ * });
+ *
+ * getCurrencyLabel({ code: "EUR", symbol: "€" }); // "Euro"
+ * ```
+ */
+export function createMessageResolver(messages, config) {
+    return (option) => {
+        const key = config.keyExtractor(option);
+        const transformedKey = config.keyTransformer
+            ? config.keyTransformer(key)
+            : key;
+        const messageFn = messages[transformedKey];
+        if (!messageFn || typeof messageFn !== "function") {
+            if (DEV) {
+                console.warn(`[MessageResolver] Missing translation for key: "${transformedKey}"`);
+            }
+            return key; // Fallback to key
+        }
+        return messageFn();
+    };
+}
+/**
+ * Type guard to check if a message key exists
+ */
+export function hasMessage(messages, key) {
+    return key in messages && typeof messages[key] === "function";
+}
+/**
+ * Batch resolver for multiple options at once
+ */
+export function batchResolveMessages(messages, options, config) {
+    const resolver = createMessageResolver(messages, config);
+    return options.reduce((acc, option) => {
+        const key = config.keyExtractor(option);
+        acc[key] = resolver(option);
+        return acc;
+    }, {});
+}

package/dist/i18n/message-resolver.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from "vite-plus/test";
+// Mock esm-env before importing the module
+vi.mock("esm-env", () => ({ DEV: true }));
+import { batchResolveMessages, createMessageResolver, hasMessage, } from "./message-resolver.ts";
+describe("MessageResolver", () => {
+    const mockMessages = {
+        usd: () => "US Dollar",
+        eur: () => "Euro",
+        mxn: () => "Mexican Peso",
+        jpy: () => "Japanese Yen",
+    };
+    describe("createMessageResolver", () => {
+        it("should resolve a key via keyExtractor", () => {
+            const resolver = createMessageResolver(mockMessages, {
+                keyExtractor: (opt) => opt.code,
+                keyTransformer: (key) => key.toLowerCase(),
+            });
+            expect(resolver({ code: "USD" })).toBe("US Dollar");
+            expect(resolver({ code: "EUR" })).toBe("Euro");
+        });
+        it("should use untransformed key when no transformer provided", () => {
+            const resolver = createMessageResolver(mockMessages, {
+                keyExtractor: (opt) => opt.code,
+            });
+            // Without transformer, keys must match exactly
+            expect(resolver({ code: "usd" })).toBe("US Dollar");
+        });
+        it("should fall back to the raw key for missing translations", () => {
+            const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+            const resolver = createMessageResolver(mockMessages, {
+                keyExtractor: (opt) => opt.code,
+                keyTransformer: (key) => key.toLowerCase(),
+            });
+            const result = resolver({ code: "UNKNOWN" });
+            expect(result).toBe("UNKNOWN"); // falls back to original key
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Missing translation"));
+            warnSpy.mockRestore();
+        });
+    });
+    describe("hasMessage", () => {
+        it("should return true for existing keys", () => {
+            expect(hasMessage(mockMessages, "usd")).toBe(true);
+            expect(hasMessage(mockMessages, "eur")).toBe(true);
+        });
+        it("should return false for missing keys", () => {
+            expect(hasMessage(mockMessages, "UNKNOWN")).toBe(false);
+            expect(hasMessage(mockMessages, "")).toBe(false);
+        });
+    });
+    describe("batchResolveMessages", () => {
+        it("should resolve all options at once", () => {
+            const options = [{ code: "USD" }, { code: "EUR" }, { code: "MXN" }];
+            const result = batchResolveMessages(mockMessages, options, {
+                keyExtractor: (opt) => opt.code,
+                keyTransformer: (key) => key.toLowerCase(),
+            });
+            expect(result).toEqual({
+                USD: "US Dollar",
+                EUR: "Euro",
+                MXN: "Mexican Peso",
+            });
+        });
+        it("should include fallback values for missing keys", () => {
+            vi.spyOn(console, "warn").mockImplementation(() => { });
+            const options = [{ code: "USD" }, { code: "XYZ" }];
+            const result = batchResolveMessages(mockMessages, options, {
+                keyExtractor: (opt) => opt.code,
+                keyTransformer: (key) => key.toLowerCase(),
+            });
+            expect(result).toEqual({
+                USD: "US Dollar",
+                XYZ: "XYZ", // fallback
+            });
+            vi.restoreAllMocks();
+        });
+    });
+});

package/dist/kernel/src/actions/portal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Svelte action to teleport a DOM element to a different target (e.g. body)
+ */
+export declare function portal(node: HTMLElement, target?: string | HTMLElement): {
+    update(newTarget: string | HTMLElement): void;
+    destroy(): void;
+};

package/dist/kernel/src/actions/portal.js

@@ -0,0 +1,32 @@
+import { DEV } from "esm-env";
+/**
+ * Svelte action to teleport a DOM element to a different target (e.g. body)
+ */
+export function portal(node, target = "body") {
+    let targetNode;
+    let isTeleported = false;
+    function update(newTarget) {
+        if (typeof newTarget === "string") {
+            targetNode = document.querySelector(newTarget);
+            if (!targetNode && DEV) {
+                console.warn(`portal target selector "${newTarget}" not found in document.`);
+            }
+        }
+        else {
+            targetNode = newTarget;
+        }
+        if (targetNode) {
+            targetNode.appendChild(node);
+            isTeleported = true;
+        }
+    }
+    update(target);
+    return {
+        update,
+        destroy() {
+            if (isTeleported && node.parentNode) {
+                node.parentNode.removeChild(node);
+            }
+        },
+    };
+}

package/dist/kernel/src/actions/shortcut-listener.d.ts

@@ -0,0 +1,15 @@
+export interface ShortcutStoreLike {
+    entries: {
+        enabled?: boolean;
+        keys: string;
+        when?: () => boolean;
+        handler: (event: KeyboardEvent) => void;
+    }[];
+}
+/**
+ * Svelte Action to listen for shortcuts registered in shortcutStore.
+ * Applied to the root element of the layout.
+ */
+export declare function shortcutListener(_node: HTMLElement, shortcutStore: ShortcutStoreLike): {
+    destroy(): void;
+};

package/dist/kernel/src/actions/shortcut-listener.js

@@ -0,0 +1,34 @@
+import hotkeys from "hotkeys-js";
+import { untrack } from "svelte";
+/**
+ * Svelte Action to listen for shortcuts registered in shortcutStore.
+ * Applied to the root element of the layout.
+ */
+export function shortcutListener(_node, shortcutStore) {
+    // Use $effect to reactively sync shortcuts
+    const cleanup = $effect.root(() => {
+        $effect(() => {
+            // Unbind everything first to ensure clean state
+            hotkeys.unbind();
+            // We read entries here, so this effect re-runs when entries change.
+            for (const entry of shortcutStore.entries) {
+                // @ts-ignore: enabled might not be on the interface but we check it anyway
+                if (entry.enabled === false)
+                    continue;
+                hotkeys(entry.keys, "all", (event, _handler) => {
+                    // Check "when" predicate if it exists
+                    if (entry.when && !untrack(() => entry.when())) {
+                        return;
+                    }
+                    entry.handler(event);
+                });
+            }
+        });
+    });
+    return {
+        destroy() {
+            cleanup();
+            hotkeys.unbind();
+        },
+    };
+}

package/dist/kernel/src/context/app.svelte.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Application metadata interface
+ */
+export interface AppData {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    repository?: string;
+    license?: string;
+    homepage?: string;
+}
+/**
+ * App Store
+ * Manages application metadata and identity
+ */
+export declare class AppStore {
+    #private;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+    homepage: string;
+    customIcons: Record<string, string>;
+    /**
+     * Initialize app store with metadata.
+     */
+    init(data: Partial<AppData>): void;
+    /**
+     * @internal Test-only. Resets initialization guard.
+     */
+    __reset(): void;
+    /**
+     * Get full app information object
+     */
+    get info(): AppData;
+    /**
+     * Registers custom SVG icons to be available globally in the Icon component
+     */
+    registerIcons(icons: Record<string, string>): void;
+}
+export declare function createAppStore(): AppStore;
+export declare function getAppStore(): AppStore;

package/dist/kernel/src/context/app.svelte.js

@@ -0,0 +1,78 @@
+// src/kernel/src/context/app.svelte.ts
+import { getContext } from "svelte";
+import { RUNE_LAB_CONTEXT } from "./context.ts";
+import { DEV } from "esm-env";
+/**
+ * App Store
+ * Manages application metadata and identity
+ */
+export class AppStore {
+    // State
+    name = $state("Rune Lab");
+    version = $state("0.0.1");
+    description = $state("Modern toolkit for Svelte 5 Runes");
+    author = $state("Yrrrrrf");
+    repository = $state("https://github.com/Yrrrrrf/rune-lab");
+    license = $state("MIT");
+    homepage = $state("https://jsr.io/@yrrrrrf/rune-lab");
+    customIcons = $state({});
+    #initialized = false;
+    /**
+     * Initialize app store with metadata.
+     */
+    init(data) {
+        if (this.#initialized) {
+            if (DEV) {
+                console.warn("AppStore.init() called multiple times. Ignoring subsequent calls.", "Overwritten properties would have been:", data);
+            }
+            return;
+        }
+        if (data.name)
+            this.name = data.name;
+        if (data.version)
+            this.version = data.version;
+        if (data.description)
+            this.description = data.description;
+        if (data.author)
+            this.author = data.author;
+        if (data.repository)
+            this.repository = data.repository;
+        if (data.license)
+            this.license = data.license;
+        if (data.homepage)
+            this.homepage = data.homepage;
+        this.#initialized = true;
+    }
+    /**
+     * @internal Test-only. Resets initialization guard.
+     */
+    __reset() {
+        this.#initialized = false;
+    }
+    /**
+     * Get full app information object
+     */
+    get info() {
+        return {
+            name: this.name,
+            version: this.version,
+            description: this.description,
+            author: this.author,
+            repository: this.repository,
+            license: this.license,
+            homepage: this.homepage,
+        };
+    }
+    /**
+     * Registers custom SVG icons to be available globally in the Icon component
+     */
+    registerIcons(icons) {
+        this.customIcons = { ...this.customIcons, ...icons };
+    }
+}
+export function createAppStore() {
+    return new AppStore();
+}
+export function getAppStore() {
+    return getContext(RUNE_LAB_CONTEXT.app);
+}

package/dist/kernel/src/context/context.d.ts

@@ -0,0 +1,15 @@
+export declare const RUNE_LAB_CONTEXT: {
+    app: symbol;
+    api: symbol;
+    toast: symbol;
+    theme: symbol;
+    language: symbol;
+    currency: symbol;
+    shortcut: symbol;
+    layout: symbol;
+    commands: symbol;
+    persistence: symbol;
+    cart: symbol;
+    session: symbol;
+    exchangeRate: symbol;
+};

package/dist/kernel/src/context/context.js

@@ -0,0 +1,16 @@
+// src/lib/context.ts
+export const RUNE_LAB_CONTEXT = {
+    app: Symbol("rl:app"),
+    api: Symbol("rl:api"),
+    toast: Symbol("rl:toast"),
+    theme: Symbol("rl:theme"),
+    language: Symbol("rl:language"),
+    currency: Symbol("rl:currency"),
+    shortcut: Symbol("rl:shortcut"),
+    layout: Symbol("rl:layout"),
+    commands: Symbol("rl:commands"),
+    persistence: Symbol("rl:persistence"),
+    cart: Symbol("rl:cart"),
+    session: Symbol("rl:session"),
+    exchangeRate: Symbol("rl:exchange-rate"),
+};

package/dist/kernel/src/context/stores.svelte.d.ts

@@ -0,0 +1,60 @@
+import type { ConfigStore } from "../persistence/createConfigStore.svelte.ts";
+import type { Command, Currency, Language, Theme, Toast, ToastType } from "./types.ts";
+import type { LayoutStore } from "../../../runes/layout/src/store.svelte.ts";
+import type { ShortcutStore } from "../../../runes/palettes/src/shortcuts/store.svelte.ts";
+/**
+ * Common store interfaces
+ */
+export interface ICommandStore {
+    commands: Command[];
+    register(command: Command): void;
+    unregister(id: string): void;
+    search(query: string, parentId?: string): Command[];
+}
+export interface IToastStore {
+    toasts: Toast[];
+    send(message: string, type?: ToastType, duration?: number): void;
+    success(msg: string): void;
+    error(msg: string): void;
+    warn(msg: string): void;
+    info(msg: string): void;
+    dismiss(id: string): void;
+}
+export interface ICurrencyStore extends ConfigStore<Currency> {
+    canConvert: boolean;
+    convertAmount(amount: number, fromCode: string, toCode?: string): number;
+    addCurrency(meta: Currency, dineroDef?: unknown): void;
+}
+/**
+ * Store context accessors
+ */
+export declare function getLayoutStore(): LayoutStore;
+export declare function getLanguageStore(): ConfigStore<Language>;
+export declare function getThemeStore(): ConfigStore<Theme>;
+export declare function getShortcutStore(): ShortcutStore;
+export declare function getCommandStore(): ICommandStore;
+export declare function getToastStore(): IToastStore;
+export declare function getCurrencyStore(): ICurrencyStore;
+/**
+ * Standard layout shortcuts
+ */
+export declare const LAYOUT_SHORTCUTS: {
+    readonly TOGGLE_NAV: {
+        readonly id: "layout:toggle-nav";
+        readonly keys: "ctrl+b";
+        readonly label: "Toggle Sidebar";
+        readonly category: "Layout";
+    };
+    readonly TOGGLE_DETAIL: {
+        readonly id: "layout:toggle-detail";
+        readonly keys: "ctrl+alt+b";
+        readonly label: "Toggle Detail Panel";
+        readonly category: "Layout";
+    };
+    readonly OPEN_SHORTCUTS: {
+        readonly id: "layout:open-shortcuts";
+        readonly keys: "ctrl+/";
+        readonly label: "Show Shortcuts";
+        readonly category: "Layout";
+    };
+};

package/dist/kernel/src/context/stores.svelte.js

@@ -0,0 +1,49 @@
+import { getContext } from "svelte";
+import { RUNE_LAB_CONTEXT } from "./context.ts";
+/**
+ * Store context accessors
+ */
+export function getLayoutStore() {
+    return getContext(RUNE_LAB_CONTEXT.layout);
+}
+export function getLanguageStore() {
+    return getContext(RUNE_LAB_CONTEXT.language);
+}
+export function getThemeStore() {
+    return getContext(RUNE_LAB_CONTEXT.theme);
+}
+export function getShortcutStore() {
+    return getContext(RUNE_LAB_CONTEXT.shortcut);
+}
+export function getCommandStore() {
+    return getContext(RUNE_LAB_CONTEXT.commands);
+}
+export function getToastStore() {
+    return getContext(RUNE_LAB_CONTEXT.toast);
+}
+export function getCurrencyStore() {
+    return getContext(RUNE_LAB_CONTEXT.currency);
+}
+/**
+ * Standard layout shortcuts
+ */
+export const LAYOUT_SHORTCUTS = {
+    TOGGLE_NAV: {
+        id: "layout:toggle-nav",
+        keys: "ctrl+b",
+        label: "Toggle Sidebar",
+        category: "Layout",
+    },
+    TOGGLE_DETAIL: {
+        id: "layout:toggle-detail",
+        keys: "ctrl+alt+b",
+        label: "Toggle Detail Panel",
+        category: "Layout",
+    },
+    OPEN_SHORTCUTS: {
+        id: "layout:open-shortcuts",
+        keys: "ctrl+/",
+        label: "Show Shortcuts",
+        category: "Layout",
+    },
+};

package/dist/kernel/src/context/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Layout configuration
+ */
+export interface LayoutZone {
+    id: string;
+    component?: unknown;
+    storeKey?: string;
+    width?: string;
+    collapsible?: boolean;
+    conditional?: string;
+    minWidth?: string;
+    position?: "start" | "end";
+}
+export type LayoutConfig = LayoutZone[];
+/**
+ * Currency
+ */
+export interface Currency {
+    code: string;
+    symbol: string;
+    decimals: number;
+}
+/**
+ * Navigation & Workspace items
+ */
+export interface WorkspaceItem {
+    id: string;
+    icon: string;
+    label: string;
+    badge?: string | number;
+    href?: string;
+    onClick?: () => void;
+}
+export interface NavigationItem {
+    id: string;
+    label: string;
+    icon?: string;
+    href?: string;
+    badge?: string | number;
+    isActive?: boolean;
+    onClick?: () => void;
+    children?: NavigationItem[];
+}
+export interface NavigationSection {
+    id: string;
+    title: string;
+    items: NavigationItem[];
+}
+/**
+ * i18n
+ */
+export interface Language {
+    code: string;
+    flag?: string;
+}
+/**
+ * Theme
+ */
+export interface Theme {
+    name: string;
+    icon?: string;
+}
+/**
+ * Shortcuts
+ */
+export interface ShortcutConfig {
+    id: string;
+    keys: string;
+    handler: (event: KeyboardEvent) => void;
+    when?: () => boolean;
+    label?: string;
+    category?: string;
+    scope?: "global" | "layout" | `panel:${string}`;
+}
+export interface ShortcutEntry extends ShortcutConfig {
+    enabled?: boolean;
+}
+/**
+ * Commands
+ */
+export interface Command {
+    id: string;
+    label: string;
+    category?: string;
+    icon?: string;
+    action?: () => void;
+    children?: Command[];
+}
+/**
+ * Toasts
+ */
+export type ToastType = "info" | "success" | "warning" | "error";
+export interface Toast {
+    id: string;
+    message: string;
+    type: ToastType;
+    duration?: number;
+}

package/dist/kernel/src/context/types.js

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

package/dist/kernel/src/context/useRuneLab.d.ts

@@ -0,0 +1,16 @@
+import { getAppStore, getCommandStore, getCurrencyStore, getLanguageStore, getLayoutStore, getShortcutStore, getThemeStore, getToastStore } from "../../../mod.ts";
+export interface RuneLabContext {
+    app: ReturnType<typeof getAppStore>;
+    toast: ReturnType<typeof getToastStore>;
+    theme: ReturnType<typeof getThemeStore>;
+    language: ReturnType<typeof getLanguageStore>;
+    currency: ReturnType<typeof getCurrencyStore>;
+    shortcut: ReturnType<typeof getShortcutStore>;
+    layout: ReturnType<typeof getLayoutStore>;
+    commands: ReturnType<typeof getCommandStore>;
+}
+/**
+ * Retrieves all Rune Lab stores from the Svelte context tree.
+ * Must be called during component initialization (in the `<script>` block).
+ */
+export declare function useRuneLab(): RuneLabContext;