rune-lab 0.4.2-beta.2 → 0.4.2-beta.3

package/package.json

@@ -1,5 +1,32 @@
 {
   "name": "rune-lab",
-  "version": "0.4.2-beta.2",
-  "packageManager": "pnpm@10.33.0"
+  "version": "0.4.2-beta.3",
+  "description": "Modern toolkit for Svelte 5 Runes applications.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Yrrrrrf/rune-lab.git"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/mod.d.ts",
+      "default": "./src/mod.js"
+    }
+  },
+  "peerDependencies": {
+    "svelte": "^5.55.0",
+    "@sveltejs/kit": "^2.55.0",
+    "@inlang/paraglide-js": "^2.15.1",
+    "hotkeys-js": "^4.0.2",
+    "dinero.js": "^2.0.2",
+    "esm-env": "^1.2.2"
+  },
+  "keywords": [
+    "svelte",
+    "svelte-5",
+    "runes",
+    "ui",
+    "components"
+  ]
 }

package/src/RuneProvider.svelte.d.ts

@@ -0,0 +1,32 @@
+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: {};
+};
+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/src/{lib/i18n/message-resolver.ts → i18n/message-resolver.d.ts}

@@ -1,29 +1,22 @@
-// sdk/devtools/src/patterns/message-resolver.ts
-import { DEV } from "esm-env";
-
 /**
  * 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
  *
@@ -36,54 +29,23 @@ interface MessageResolverConfig<T> {
  * getCurrencyLabel({ code: "EUR", symbol: "€" }); // "Euro"
  * ```
  */
-export function createMessageResolver<T>(
+export declare function createMessageResolver<T>(
   messages: MessageBundle,
   config: MessageResolverConfig<T>,
-) {
-  return (option: T): string => {
-    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();
-  };
-}
-
+): (option: T) => string;
 /**
  * Type guard to check if a message key exists
  */
-export function hasMessage(messages: MessageBundle, key: string): boolean {
-  return key in messages && typeof messages[key] === "function";
-}
-
+export declare function hasMessage(
+  messages: MessageBundle,
+  key: string,
+): boolean;
 /**
  * Batch resolver for multiple options at once
  */
-export function batchResolveMessages<T>(
+export declare function batchResolveMessages<T>(
   messages: MessageBundle,
   options: T[],
   config: MessageResolverConfig<T>,
-): Record<string, string> {
-  const resolver = createMessageResolver(messages, config);
-
-  return options.reduce(
-    (acc, option) => {
-      const key = config.keyExtractor(option);
-      acc[key] = resolver(option);
-      return acc;
-    },
-    {} as Record<string, string>,
-  );
-}
+): Record<string, string>;
+export {};

package/src/i18n/message-resolver.js

@@ -0,0 +1,49 @@
+// 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/src/{lib/i18n/message-resolver.test.ts → i18n/message-resolver.test.js}

@@ -1,14 +1,11 @@
 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",
@@ -16,87 +13,70 @@ describe("MessageResolver", () => {
     mxn: () => "Mexican Peso",
     jpy: () => "Japanese Yen",
   };
-
   describe("createMessageResolver", () => {
     it("should resolve a key via keyExtractor", () => {
-      const resolver = createMessageResolver<{ code: string }>(mockMessages, {
+      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<{ code: string }>(mockMessages, {
+      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<{ code: string }>(mockMessages, {
+      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/src/kernel/src/actions/portal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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/src/{lib/kernel/src/actions/portal.ts → kernel/src/actions/portal.js}

@@ -1,16 +1,11 @@
 import { DEV } from "esm-env";
-
 /**
  * Svelte action to teleport a DOM element to a different target (e.g. body)
  */
-export function portal(
-  node: HTMLElement,
-  target: string | HTMLElement = "body",
-): { update(newTarget: string | HTMLElement): void; destroy(): void } {
-  let targetNode: HTMLElement | null;
+export function portal(node, target = "body") {
+  let targetNode;
   let isTeleported = false;
-
-  function update(newTarget: string | HTMLElement) {
+  function update(newTarget) {
     if (typeof newTarget === "string") {
       targetNode = document.querySelector(newTarget);
       if (!targetNode && DEV) {
@@ -21,15 +16,12 @@ export function portal(
     } else {
       targetNode = newTarget;
     }
-
     if (targetNode) {
       targetNode.appendChild(node);
       isTeleported = true;
     }
   }
-
   update(target);
-
   return {
     update,
     destroy() {

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

@@ -0,0 +1,18 @@
+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/src/{lib/kernel/src/actions/shortcut-listener.ts → kernel/src/actions/shortcut-listener.js}

@@ -1,46 +1,31 @@
 import hotkeys from "hotkeys-js";
 import { untrack } from "svelte";
-
-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 function shortcutListener(
-  _node: HTMLElement,
-  shortcutStore: ShortcutStoreLike,
-): { destroy(): void } {
+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;
-
+        if (entry.enabled === false) {
+          continue;
+        }
         hotkeys(entry.keys, "all", (event, _handler) => {
           // Check "when" predicate if it exists
-          if (entry.when && !untrack(() => entry.when!())) {
+          if (entry.when && !untrack(() => entry.when())) {
             return;
           }
-
           entry.handler(event);
         });
       }
     });
   });
-
   return {
     destroy() {
       cleanup();

package/src/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/src/kernel/src/context/app.svelte.js

@@ -0,0 +1,89 @@
+// 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/src/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/src/{lib/kernel/src/context/context.ts → kernel/src/context/context.js}

@@ -1,20 +1,5 @@
 // src/lib/context.ts
-
-export 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;
-} = {
+export const RUNE_LAB_CONTEXT = {
   app: Symbol("rl:app"),
   api: Symbol("rl:api"),
   toast: Symbol("rl:toast"),
@@ -28,4 +13,4 @@ export const RUNE_LAB_CONTEXT: {
   cart: Symbol("rl:cart"),
   session: Symbol("rl:session"),
   exchangeRate: Symbol("rl:exchange-rate"),
-} as const;
+};

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

@@ -0,0 +1,67 @@
+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";
+  };
+};