rune-lab 0.3.1 → 0.4.1

package/.gitignore

@@ -0,0 +1,12 @@
+# all that start with a dot except .gitignore
+.*
+!.gitignore
+
+# lock files (from various package managers)
+*.lock
+
+# web-generated files
+node_modules
+dist
+lab
+build

package/README.md

@@ -1,5 +1,5 @@
 <h1 align="center">
-  <img src="https://raw.githubusercontent.com/Yrrrrrf/rune-lab/main/static/img/rune.png" alt="Rune Lab Icon" width="128" height="128" description="Icon representing the Svelte Runes system">
+  <img src="https://raw.githubusercontent.com/Yrrrrrf/rune-lab/main/src/sdk/ui/static/img/rune.png" alt="Rune Lab Icon" width="128" height="128" descripti``on="Icon representing the Svelte Runes system">
   <div align="center">Rune Lab</div>
 </h1>
 
@@ -69,12 +69,12 @@ Get your application shell running in less than 20 lines. Inside your
   import { cookieDriver } from "rune-lab";
 
   let { children } = $props();
-  
+
   // Example navigation
   const sections = [{ id: "main", title: "Main", items: [{ id: "home", label: "Home" }] }];
 </script>
 
-<RuneProvider 
+<RuneProvider
   app={{ name: "My App", version: "1.0.0" }}
   persistence={cookieDriver}
 >
@@ -232,7 +232,7 @@ register them inside an `$effect` returning a cleanup function**:
 ```svelte
 <script lang="ts">
   import { getShortcutStore, getToastStore } from "rune-lab";
-  
+
   const shortcuts = getShortcutStore();
   const toasts = getToastStore();
 

package/deno.json

@@ -0,0 +1,50 @@
+{
+  "name": "@yrrrrrf/rune-lab",
+  "version": "0.4.1",
+  "description": "Modern toolkit for Svelte 5 Runes applications.",
+  "type": "module",
+  "license": "MIT",
+  "readme": "./README.md",
+  "author": "Fernando Bryan Reza Campos",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Yrrrrrf/rune-lab.git"
+  },
+  "exports": {
+    ".": "./src/mod.ts"
+  },
+  "nodeModulesDir": "manual",
+  "workspace": [
+    "./src/kernel",
+    "./src/runes/layout",
+    "./src/runes/palettes",
+    "./src/runes/plugins/money"
+  ],
+  "tasks": {
+    "i18n": "paraglide-js compile --project ./src/i18n/project.inlang --outdir ./src/i18n/paraglide"
+  },
+  "imports": {
+    "@rune-lab/core": "./src/mod.ts",
+    "@rune-lab/i18n/": "./src/i18n/",
+    "typescript": "npm:typescript@5.9.3",
+    "@tailwindcss/vite": "npm:@tailwindcss/vite",
+    "esm-env": "npm:esm-env",
+    "vite": "npm:vite",
+    "vite-plus": "npm:vite-plus",
+    "daisyui/": "npm:daisyui/",
+    "hotkeys-js": "npm:hotkeys-js",
+    "@inlang/paraglide-js": "npm:@inlang/paraglide-js",
+    "svelte": "npm:svelte",
+    "@sveltejs/kit": "npm:@sveltejs/kit",
+    "@sveltejs/vite-plugin-svelte": "npm:@sveltejs/vite-plugin-svelte",
+    "@sveltejs/adapter-static": "npm:@sveltejs/adapter-static",
+    "jsdom": "npm:jsdom",
+    "@testing-library/jest-dom": "npm:@testing-library/jest-dom"
+  },
+  "exclude": [
+    "scripts/**",
+    "dist/**",
+    ".old/**",
+    "**/*.test.ts"
+  ]
+}

package/justfile

@@ -0,0 +1,5 @@
+set shell := ["bash", "-cu"]
+
+import 'scripts/dev.just'
+import 'scripts/ci.just'
+import 'scripts/deploy.just'

package/package.json

@@ -1,82 +1,5 @@
 {
   "name": "rune-lab",
-  "version": "0.3.1",
-  "description": "Modern toolkit for Svelte 5 Runes applications.",
-  "type": "module",
-  "license": "MIT",
-  "author": "Fernando Bryan Reza Campos",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Yrrrrrf/rune-lab.git"
-  },
-  "scripts": {
-    "dev:ui": "bun run --cwd src/sdk/ui dev",
-    "build:ui": "bun run --cwd src/sdk/ui build",
-    "compile:i18n": "paraglide-js compile --project ./src/sdk/ui/src/i18n/project.inlang --outdir ./src/sdk/ui/src/lib/paraglide",
-    "build:index": "bun run scripts/build-index.js"
-  },
-  "workspaces": [
-    "src/sdk/*"
-  ],
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "svelte": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./ui": {
-      "types": "./dist/ui/index.d.ts",
-      "svelte": "./dist/ui/index.js",
-      "default": "./dist/ui/index.js"
-    },
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "default": "./dist/core/index.js"
-    },
-    "./state": {
-      "types": "./dist/state/index.d.ts",
-      "default": "./dist/state/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "peerDependencies": {
-    "svelte": "^5.54.1",
-    "tailwindcss": "^4.2.2",
-    "daisyui": "^5.5.19",
-    "dinero.js": "npm:dinero.js@^2.0.2",
-    "better-auth": "^1.5.5"
-  },
-  "peerDependenciesMeta": {
-    "better-auth": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "gwa": "^0.0.1",
-    "hotkeys-js": "npm:hotkeys-js@^4.0.2"
-  },
-  "devDependencies": {
-    "@inlang/paraglide-js": "npm:@inlang/paraglide-js@^2.15.1",
-    "@internal/core": "0.2.0",
-    "@internal/state": "0.2.0",
-    "@internal/ui": "0.2.0",
-    "@sveltejs/adapter-static": "npm:@sveltejs/adapter-static@^3.0.10",
-    "@sveltejs/kit": "npm:@sveltejs/kit@^2.55.0",
-    "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "npm:@sveltejs/vite-plugin-svelte@^7.0.0",
-    "@tailwindcss/forms": "npm:@tailwindcss/forms@^0.5.11",
-    "@tailwindcss/typography": "npm:@tailwindcss/typography@^0.5.19",
-    "@tailwindcss/vite": "npm:@tailwindcss/vite@^4.2.2",
-    "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/svelte": "^5.3.1",
-    "jsdom": "^29.0.1",
-    "publint": "^0.3.18",
-    "svelte-check": "npm:svelte-check@^4.4.5",
-    "typescript": "npm:typescript@^5.9.3",
-    "vite": "npm:vite@^8.0.1",
-    "vitest": "^4.1.0"
-  }
-}
+  "version": "0.4.1",
+  "packageManager": "pnpm@10.33.0"
+}

package/scripts/build_pkg.ts

@@ -0,0 +1,51 @@
+// scripts/build_pkg.ts
+import denoConfig from "../deno.json" with { type: "json" };
+
+// ── 1. Restructure: move dist/* → dist/src/ ──────────────────────────────────
+await Deno.mkdir("./dist/src", { recursive: true });
+for await (const entry of Deno.readDir("./dist")) {
+  if (entry.name === "src") continue;
+  await Deno.rename(`./dist/${entry.name}`, `./dist/src/${entry.name}`);
+}
+
+// Clean up any stray deno.ts artifact
+try {
+  await Deno.remove("./dist/src/deno.ts");
+} catch { /* already gone */ }
+
+// ── 2. Generate dist/deno.json (standalone — no workspace members) ────────────
+const denoDistConfig = {
+  name: denoConfig.name,
+  version: denoConfig.version,
+  description: denoConfig.description,
+  license: denoConfig.license,
+  exports: { ".": "./src/mod.ts" },
+  repository: denoConfig.repository,
+};
+await Deno.writeTextFile(
+  "./dist/deno.json",
+  JSON.stringify(denoDistConfig, null, 2),
+);
+
+// ── 3. Generate dist/package.json (derived from deno.json) ───────────────────
+const pkg = {
+  name: "rune-lab",
+  version: denoConfig.version,
+  description: denoConfig.description,
+  type: "module",
+  exports: { ".": "./src/mod.ts" },
+  license: denoConfig.license,
+  repository: denoConfig.repository,
+  peerDependencies: {
+    "svelte": "^5.0.0",
+    "@inlang/paraglide-js": "^2.0.0",
+  },
+  keywords: ["svelte", "svelte-5", "runes", "ui", "components"],
+};
+await Deno.writeTextFile("./dist/package.json", JSON.stringify(pkg, null, 2));
+
+// ── 4. Copy metadata ──────────────────────────────────────────────────────────
+await Deno.copyFile("README.md", "./dist/README.md");
+await Deno.copyFile("LICENSE", "./dist/LICENSE");
+
+console.log(`dist/ (v${denoConfig.version})`);

package/scripts/ci.just

@@ -0,0 +1,26 @@
+[doc('Format Client code')]
+[group('CI')]
+fmt:
+    deno fmt .
+    @echo "✓ Client code formatted"
+
+[doc('Lint Client code')]
+[group('CI')]
+lint:
+    deno lint .
+    @echo "✓ Client code linted"
+
+[doc('Type-check Client workspace')]
+[group('CI')]
+typecheck:
+    # check ts types with strict deno.ns
+    deno check .
+    # check svelte types
+    deno run -A npm:svelte-check
+    # todo: Maybe change this to a vp command
+    @echo "✓ Client type-checked"
+
+[doc('Full client quality gate')]
+[group('CI')]
+quality: fmt lint typecheck
+    @echo "✓ Client quality checks passed"

package/scripts/deploy.just

@@ -0,0 +1,21 @@
+[doc('Build Client')]
+[group('Build')]
+build:
+    # * Clean up previous build
+    rm -rf dist/
+    # * Build library using vite-plus
+    vp build
+    # * Build ESM package
+    deno run -A scripts/build_pkg.ts
+    @echo "✓ build done"
+
+[doc('Publish to jsr')]
+[group('Deploy')]
+deploy: build
+    # * Format build output
+    deno fmt --no-config dist
+    # # * Build npm package
+    # deno task build:npm
+    # # * Publish to jsr
+    # deno publish
+    @echo "✓ deploy done"

package/scripts/dev.just

@@ -0,0 +1,4 @@
+[doc('Test the client (runs once)')]
+[group('Dev')]
+test *args:
+    vp test

package/scripts/inject.just

@@ -0,0 +1,72 @@
+# inject.just — surgical local rune-lab injection
+#
+# ⚠  IMPORTANT: `just -f` changes cwd to the justfile's directory.
+#    Never pass `.` as dest — pass $PWD or an absolute path instead.
+#
+# Usage:
+#   just -f ~/rune-lab/scripts/inject.just inject $PWD
+#   just -f ~/rune-lab/scripts/inject.just inject /absolute/path/to/project
+#   just -f ~/rune-lab/scripts/inject.just inject-clean $PWD
+#
+# Recipes:
+#   inject        — build rune-lab, then hot-swap node_modules/rune-lab
+#   inject-clean  — full dep reset (yog reborn --deep), then inject
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Hot-swap: rebuild rune-lab and inject into <dest>/node_modules/rune-lab
+inject dest: _build-for-inject
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    dest_abs="{{ dest }}"
+
+    # Reject relative paths — they resolve to rune-lab's own dir, not the caller's
+    if [[ "$dest_abs" != /* ]]; then
+        echo "❌  dest must be an absolute path."
+        echo "    Call with:  just -f ... inject \$PWD"
+        echo "    Got:        $dest_abs"
+        exit 1
+    fi
+
+    if [ ! -d "$dest_abs/node_modules" ]; then
+        echo "❌  No node_modules/ found in $dest_abs"
+        echo "    Run your package manager's install first, then retry."
+        exit 1
+    fi
+
+    echo "🗑  Removing stale $dest_abs/node_modules/rune-lab..."
+    rm -rf "$dest_abs/node_modules/rune-lab"
+
+    echo "📦 Copying local dist into $dest_abs/node_modules/rune-lab..."
+    mkdir -p "$dest_abs/node_modules/rune-lab"
+    cp -r "{{ justfile_directory() }}/../dist"         "$dest_abs/node_modules/rune-lab/dist"
+    cp    "{{ justfile_directory() }}/../package.json" "$dest_abs/node_modules/rune-lab/package.json"
+
+    echo "✅  Done! node_modules/rune-lab → $(du -sh $dest_abs/node_modules/rune-lab | cut -f1)"
+    echo "    Source:  {{ justfile_directory() }}/../dist"
+    echo "    Target:  $dest_abs/node_modules/rune-lab"
+
+# Full reset: nuke deps in <dest>, reinstall, then hot-swap rune-lab
+inject-clean dest: _build-for-inject
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    dest_abs="{{ dest }}"
+
+    if [[ "$dest_abs" != /* ]]; then
+        echo "❌  dest must be an absolute path. Call with: just -f ... inject-clean \$PWD"
+        exit 1
+    fi
+
+    echo "💀 Running yog reborn --deep in $dest_abs..."
+    (cd "$dest_abs" && yog reborn --deep)
+
+    just -f "{{ justfile_directory() }}/inject.just" inject "$dest_abs"
+
+# ── Internal ──────────────────────────────────────────────────────────────────
+
+[private]
+_build-for-inject:
+    @echo "🔨 Building rune-lab from {{ justfile_directory() }}/.."
+    just --justfile "{{ justfile_directory() }}/../justfile" --working-directory "{{ justfile_directory() }}/.." build
+    @echo "✅  rune-lab built."

package/src/RuneProvider.svelte

@@ -0,0 +1,105 @@
+<script lang="ts">
+  import { setContext, untrack, type Snippet, onMount, type Component } from "svelte";
+  import {
+    RUNE_LAB_CONTEXT,
+    localStorageDriver,
+    initializeStores,
+    defineRune,
+  } from "@rune-lab/kernel";
+  import type { PersistenceDriver, RunePlugin } 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;
+  }
+
+  let { children, config = {}, plugins = [] } = $props<{
+    children: Snippet;
+    config?: RuneLabConfig;
+    plugins?: RunePlugin[];
+  }>();
+
+  const initialPlugins = untrack(() => plugins);
+  const initialPersistence = untrack(() => config.persistence ?? localStorageDriver);
+
+  // 1. Register all plugins
+  // Note: defineRune maps each slot into the STORE_REGISTRY
+  untrack(() => {
+    for (const plugin of initialPlugins) {
+      defineRune(plugin);
+    }
+  });
+
+  // 2. Initialize all stores via the registry's topological sort
+  const stores = initializeStores(
+    initialPlugins,
+    untrack(() => config as Record<string, unknown>),
+    initialPersistence
+  );
+
+  // 3. Provide all stores as context
+  // We iterate ALL registered plugins to find the context keys for their slots
+  for (const plugin of initialPlugins) {
+    for (const slot of plugin.stores) {
+      const store = stores.get(slot.id);
+      if (store) {
+        setContext(slot.contextKey, store);
+      }
+    }
+  }
+
+  // Also provide the persistence driver itself
+  setContext(RUNE_LAB_CONTEXT.persistence, initialPersistence);
+
+  // 4. Collect all overlays
+  const allOverlays = $derived(plugins.flatMap(p => p.overlays ?? []) as Component<Record<never, never>>[]);
+
+  // ── Initialization for layout ──────────────────────────
+  const appStore = stores.get("app") as any;
+  const layoutStore = stores.get("layout") as any;
+
+  onMount(() => {
+    if (layoutStore) layoutStore.init();
+  });
+
+  // Meta tags derived from app store state
+  const metaTags = $derived(appStore ? [
+    { name: "description", content: appStore.description },
+    { name: "author", content: appStore.author },
+  ] : []);
+</script>
+
+<svelte:head>
+  {#if config.manageHead !== false && appStore}
+    <title>{appStore.name}</title>
+    {#if config.favicon}
+      <link rel="icon" href={config.favicon} />
+    {/if}
+    {#each metaTags as meta}
+      <meta name={meta.name} content={meta.content} />
+    {/each}
+    {#if config.icons === "material"}
+      <link
+        rel="stylesheet"
+        href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200"
+      />
+    {/if}
+  {/if}
+</svelte:head>
+
+<!-- Plugin Overlays -->
+{#each allOverlays as Overlay}
+  <Overlay />
+{/each}
+
+<!-- Render Children -->
+{@render children()}

package/src/i18n/message-resolver.test.ts

@@ -0,0 +1,103 @@
+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<{ code: string }>(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, {
+        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, {
+        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/i18n/message-resolver.ts

@@ -0,0 +1,89 @@
+// 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
+ *
+ * @example
+ * ```typescript
+ * const getCurrencyLabel = createMessageResolver<Currency>(m, {
+ *   keyExtractor: (currency) => currency.code
+ * });
+ *
+ * getCurrencyLabel({ code: "EUR", symbol: "€" }); // "Euro"
+ * ```
+ */
+export 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();
+  };
+}
+
+/**
+ * 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";
+}
+
+/**
+ * Batch resolver for multiple options at once
+ */
+export 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>,
+  );
+}