@emkodev/emroute 1.6.1 → 1.6.3

package/dist/src/widget/widget.registry.js

@@ -0,0 +1,42 @@
+/**
+ * Widget Registry
+ *
+ * Canonical registry where all widgets live. Used by all renderers:
+ * - SSR HTML: resolves widgets by name, calls getData() + renderHTML()
+ * - SSR Markdown: resolves widgets by name, calls getData() + renderMarkdown()
+ * - SPA: registers custom elements for each widget
+ *
+ * Pages are NOT in this registry — they live in the routes manifest.
+ */
+export class WidgetRegistry {
+    widgets = new Map();
+    /** Register a widget by its name. */
+    add(widget) {
+        this.widgets.set(widget.name, widget);
+    }
+    /** Look up a widget by name. */
+    get(name) {
+        return this.widgets.get(name);
+    }
+    /** Iterate all registered widgets. */
+    [Symbol.iterator]() {
+        return this.widgets.values();
+    }
+    /** Emit a WidgetsManifest from registered widgets. */
+    toManifest() {
+        const widgets = [];
+        const moduleLoaders = {};
+        for (const [name, widget] of this.widgets) {
+            const entry = {
+                name,
+                modulePath: name,
+                tagName: `widget-${name}`,
+                files: widget.files,
+            };
+            widgets.push(entry);
+            moduleLoaders[name] = () => Promise.resolve({ default: widget.constructor });
+        }
+        return { widgets, moduleLoaders };
+    }
+}
+//# sourceMappingURL=widget.registry.js.map

package/dist/src/widget/widget.registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget.registry.js","sourceRoot":"","sources":["../../../src/widget/widget.registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,MAAM,OAAO,cAAc;IACjB,OAAO,GAAG,IAAI,GAAG,EAA2B,CAAC;IAErD,qCAAqC;IACrC,GAAG,CAAC,MAAuB;QACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACxC,CAAC;IAED,gCAAgC;IAChC,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,sCAAsC;IACtC,CAAC,MAAM,CAAC,QAAQ,CAAC;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;IAC/B,CAAC;IAED,sDAAsD;IACtD,UAAU;QACR,MAAM,OAAO,GAA0B,EAAE,CAAC;QAC1C,MAAM,aAAa,GAA2C,EAAE,CAAC;QAEjE,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC1C,MAAM,KAAK,GAAwB;gBACjC,IAAI;gBACJ,UAAU,EAAE,IAAI;gBAChB,OAAO,EAAE,UAAU,IAAI,EAAE;gBACzB,KAAK,EAAE,MAAM,CAAC,KAAK;aACpB,CAAC;YACF,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACpB,aAAa,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/E,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;IACpC,CAAC;CACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@emkodev/emroute",
-  "version": "1.6.1",
-  "description": "File-based router with triple rendering (SPA, SSR HTML, SSR Markdown). Zero dependencies.",
+  "version": "1.6.3",
+  "description": "File-based (but storage-agnostic) router with triple rendering (SPA, SSR HTML, SSR Markdown). Zero dependencies.",
   "license": "BSD-3-Clause",
   "author": "emko.dev",
   "type": "module",
@@ -13,6 +13,8 @@
     "file-based",
     "framework",
     "bun",
+    "deno",
+    "node",
     "typescript",
     "markdown"
   ],
@@ -24,20 +26,75 @@
     "src/",
     "server/*.ts",
     "runtime/",
+    "dist/",
     "LICENSE",
     "README.md"
   ],
   "exports": {
-    ".": "./src/index.ts",
-    "./spa": "./src/renderer/spa/mod.ts",
-    "./overlay": "./src/overlay/mod.ts",
-    "./ssr/html": "./src/renderer/ssr/html.renderer.ts",
-    "./ssr/md": "./src/renderer/ssr/md.renderer.ts",
-    "./server": "./server/emroute.server.ts",
-    "./runtime": "./runtime/abstract.runtime.ts",
-    "./runtime/sitemap": "./runtime/sitemap.generator.ts",
-    "./runtime/bun/fs": "./runtime/bun/fs/bun-fs.runtime.ts",
-    "./runtime/bun/sqlite": "./runtime/bun/sqlite/bun-sqlite.runtime.ts"
+    ".": {
+      "bun": "./src/index.ts",
+      "deno": "./src/index.ts",
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./spa": {
+      "bun": "./src/renderer/spa/mod.ts",
+      "deno": "./src/renderer/spa/mod.ts",
+      "types": "./dist/src/renderer/spa/mod.d.ts",
+      "default": "./dist/src/renderer/spa/mod.js"
+    },
+    "./overlay": {
+      "bun": "./src/overlay/mod.ts",
+      "deno": "./src/overlay/mod.ts",
+      "types": "./dist/src/overlay/mod.d.ts",
+      "default": "./dist/src/overlay/mod.js"
+    },
+    "./ssr/html": {
+      "bun": "./src/renderer/ssr/html.renderer.ts",
+      "deno": "./src/renderer/ssr/html.renderer.ts",
+      "types": "./dist/src/renderer/ssr/html.renderer.d.ts",
+      "default": "./dist/src/renderer/ssr/html.renderer.js"
+    },
+    "./ssr/md": {
+      "bun": "./src/renderer/ssr/md.renderer.ts",
+      "deno": "./src/renderer/ssr/md.renderer.ts",
+      "types": "./dist/src/renderer/ssr/md.renderer.d.ts",
+      "default": "./dist/src/renderer/ssr/md.renderer.js"
+    },
+    "./server": {
+      "bun": "./server/emroute.server.ts",
+      "deno": "./server/emroute.server.ts",
+      "types": "./dist/server/emroute.server.d.ts",
+      "default": "./dist/server/emroute.server.js"
+    },
+    "./runtime": {
+      "bun": "./runtime/abstract.runtime.ts",
+      "deno": "./runtime/abstract.runtime.ts",
+      "types": "./dist/runtime/abstract.runtime.d.ts",
+      "default": "./dist/runtime/abstract.runtime.js"
+    },
+    "./runtime/sitemap": {
+      "bun": "./runtime/sitemap.generator.ts",
+      "deno": "./runtime/sitemap.generator.ts",
+      "types": "./dist/runtime/sitemap.generator.d.ts",
+      "default": "./dist/runtime/sitemap.generator.js"
+    },
+    "./runtime/bun/fs": {
+      "bun": "./runtime/bun/fs/bun-fs.runtime.ts",
+      "types": "./dist/runtime/bun/fs/bun-fs.runtime.d.ts",
+      "default": "./dist/runtime/bun/fs/bun-fs.runtime.js"
+    },
+    "./runtime/bun/sqlite": {
+      "bun": "./runtime/bun/sqlite/bun-sqlite.runtime.ts",
+      "types": "./dist/runtime/bun/sqlite/bun-sqlite.runtime.d.ts",
+      "default": "./dist/runtime/bun/sqlite/bun-sqlite.runtime.js"
+    },
+    "./runtime/universal/fs": {
+      "bun": "./runtime/universal/fs/universal-fs.runtime.ts",
+      "deno": "./runtime/universal/fs/universal-fs.runtime.ts",
+      "types": "./dist/runtime/universal/fs/universal-fs.runtime.d.ts",
+      "default": "./dist/runtime/universal/fs/universal-fs.runtime.js"
+    }
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -45,9 +102,12 @@
     "esbuild": "^0.27.3",
     "eslint": "^10.0.2",
     "playwright": "^1.58.2",
+    "typescript": "^5.9.3",
     "typescript-eslint": "^8.56.1"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
     "check": "bun x tsc --noEmit",
     "test": "bun test test/unit",
     "test:unit": "bun test test/unit",

package/runtime/universal/fs/universal-fs.runtime.ts

@@ -0,0 +1,253 @@
+import { readFile, writeFile, stat, readdir, mkdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import {
+  CONTENT_TYPES,
+  DEFAULT_ROUTES_DIR,
+  DEFAULT_WIDGETS_DIR,
+  EMROUTE_EXTERNALS,
+  type FetchParams,
+  type FetchReturn,
+  ROUTES_MANIFEST_PATH,
+  Runtime,
+  type RuntimeConfig,
+  WIDGETS_MANIFEST_PATH,
+} from '../../abstract.runtime.ts';
+import { createManifestPlugin } from '../../../server/esbuild-manifest.plugin.ts';
+import { createRuntimeLoaderPlugin } from '../../bun/esbuild-runtime-loader.plugin.ts';
+import { generateMainTs } from '../../../server/codegen.util.ts';
+
+/**
+ * Filesystem runtime using only `node:` APIs and esbuild. Works on Node,
+ * Deno, and Bun without platform-specific dependencies.
+ *
+ * Not recommended for production — `node:fs/promises` has higher overhead
+ * than platform-native alternatives (e.g. `Bun.file()`). Use
+ * {@link BunFsRuntime} on Bun for better I/O performance.
+ */
+export class UniversalFsRuntime extends Runtime {
+  private readonly root: string;
+
+  constructor(root: string, config: RuntimeConfig = {}) {
+    if (config.entryPoint && !config.bundlePaths) {
+      config.bundlePaths = { emroute: '/emroute.js', app: '/app.js' };
+    }
+    super(config);
+    const abs = resolve(root);
+    this.root = abs.endsWith('/') ? abs.slice(0, -1) : abs;
+  }
+
+  handle(
+    resource: FetchParams[0],
+    init?: FetchParams[1],
+  ): FetchReturn {
+    const [pathname, method, body] = this.parse(resource, init);
+    const path = `${this.root}${pathname}`;
+
+    switch (method) {
+      case 'PUT':
+        return this.write(path, body);
+      default:
+        return this.read(path);
+    }
+  }
+
+  query(
+    resource: FetchParams[0],
+    options: FetchParams[1] & { as: 'text' },
+  ): Promise<string>;
+  query(
+    resource: FetchParams[0],
+    options?: FetchParams[1],
+  ): FetchReturn;
+  query(
+    resource: FetchParams[0],
+    options?: FetchParams[1] & { as?: 'text' },
+  ): Promise<Response | string> {
+    if (options?.as === 'text') {
+      const pathname = this.parsePath(resource);
+      return readFile(`${this.root}${pathname}`, 'utf-8');
+    }
+    return this.handle(resource, options);
+  }
+
+  private parsePath(resource: FetchParams[0]): string {
+    if (typeof resource === 'string') return decodeURIComponent(resource);
+    if (resource instanceof URL) return decodeURIComponent(resource.pathname);
+    return decodeURIComponent(new URL(resource.url).pathname);
+  }
+
+  private parse(
+    resource: FetchParams[0],
+    init?: RequestInit,
+  ): [string, string, BodyInit | null] {
+    const pathname = this.parsePath(resource);
+    if (typeof resource === 'string' || resource instanceof URL) {
+      return [pathname, init?.method ?? 'GET', init?.body ?? null];
+    }
+    return [
+      pathname,
+      init?.method ?? resource.method,
+      init?.body ?? resource.body,
+    ];
+  }
+
+  private async read(path: string): Promise<Response> {
+    try {
+      const info = await stat(path);
+
+      if (info.isDirectory()) {
+        return this.list(path);
+      }
+
+      const content = new Uint8Array(await readFile(path));
+      const ext = path.slice(path.lastIndexOf('.')).toLowerCase();
+      const headers: HeadersInit = {
+        'Content-Type': CONTENT_TYPES.get(ext) ?? 'application/octet-stream',
+        'Content-Length': content.byteLength.toString(),
+      };
+
+      if (info.mtime) {
+        headers['Last-Modified'] = info.mtime.toUTCString();
+      }
+
+      return new Response(content, { status: 200, headers });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        const pathname = path.slice(this.root.length);
+        if (pathname === ROUTES_MANIFEST_PATH) return this.resolveRoutesManifest();
+        if (pathname === WIDGETS_MANIFEST_PATH) return this.resolveWidgetsManifest();
+        return new Response('Not Found', { status: 404 });
+      }
+      return new Response(`Internal Error: ${error}`, { status: 500 });
+    }
+  }
+
+  private async list(path: string): Promise<Response> {
+    const entries: string[] = [];
+    const dirents = await readdir(path, { withFileTypes: true });
+    for (const entry of dirents) {
+      entries.push(entry.name + (entry.isDirectory() ? '/' : ''));
+    }
+    return Response.json(entries);
+  }
+
+  private async write(path: string, body: BodyInit | null): Promise<Response> {
+    try {
+      const content = body
+        ? new Uint8Array(await new Response(body).arrayBuffer())
+        : new Uint8Array();
+      const dir = path.slice(0, path.lastIndexOf('/'));
+      if (dir) await mkdir(dir, { recursive: true });
+      await writeFile(path, content);
+      return new Response(null, { status: 204 });
+    } catch (error) {
+      return new Response(`Write failed: ${error}`, { status: 500 });
+    }
+  }
+
+  override loadModule(path: string): Promise<unknown> {
+    return import(this.root + path);
+  }
+
+  // ── Bundling ─────────────────────────────────────────────────────────
+
+  override async bundle(): Promise<void> {
+    if (this.config.spa === 'none') return;
+    const paths = this.config.bundlePaths;
+    if (!paths) return;
+
+    const esbuild = await UniversalFsRuntime.esbuild();
+    const builds: Promise<{ outputFiles: { path: string; contents: Uint8Array }[] }>[] = [];
+    const shared = { bundle: true, write: false, format: 'esm' as const, platform: 'browser' as const };
+    const runtimeLoader = createRuntimeLoaderPlugin({ runtime: this, root: this.root });
+
+    // Emroute SPA bundle — resolve from consumer's node_modules (no runtime loader needed)
+    const consumerRequire = createRequire(this.root + '/');
+    const spaEntry = consumerRequire.resolve('@emkodev/emroute/spa');
+    builds.push(esbuild.build({
+      ...shared,
+      entryPoints: [spaEntry],
+      outfile: `${this.root}${paths.emroute}`,
+    }));
+
+    // App bundle — generate main.ts if absent, virtual plugin resolves manifests
+    if (this.config.entryPoint) {
+      if ((await this.query(this.config.entryPoint)).status === 404) {
+        const hasRoutes = (await this.query((this.config.routesDir ?? DEFAULT_ROUTES_DIR) + '/')).status !== 404;
+        const hasWidgets = (await this.query((this.config.widgetsDir ?? DEFAULT_WIDGETS_DIR) + '/')).status !== 404;
+        const code = generateMainTs('root', hasRoutes, hasWidgets, '@emkodev/emroute');
+        await this.command(this.config.entryPoint, { body: code });
+      }
+      const manifestPlugin = createManifestPlugin({
+        runtime: this,
+        basePath: '/html',
+        resolveDir: this.root,
+      });
+      builds.push(esbuild.build({
+        ...shared,
+        entryPoints: [`${this.root}${this.config.entryPoint}`],
+        outfile: `${this.root}${paths.app}`,
+        external: [...EMROUTE_EXTERNALS],
+        plugins: [manifestPlugin, runtimeLoader],
+      }));
+    }
+
+    // Widgets bundle
+    if (paths.widgets) {
+      const widgetsTsPath = paths.widgets.replace('.js', '.ts');
+      if ((await this.query(widgetsTsPath)).status !== 404) {
+        builds.push(esbuild.build({
+          ...shared,
+          entryPoints: [`${this.root}${widgetsTsPath}`],
+          outfile: `${this.root}${paths.widgets}`,
+          external: [...EMROUTE_EXTERNALS],
+          plugins: [runtimeLoader],
+        }));
+      }
+    }
+
+    const results = await Promise.all(builds);
+
+    // Write all output files through the runtime
+    for (const result of results) {
+      for (const file of result.outputFiles) {
+        const runtimePath = file.path.startsWith(this.root)
+          ? file.path.slice(this.root.length)
+          : '/' + file.path;
+        await this.command(runtimePath, { body: file.contents as unknown as BodyInit });
+      }
+    }
+
+    await this.writeShell(paths);
+
+    await esbuild.stop();
+    UniversalFsRuntime._esbuild = null;
+  }
+
+  // ── Transpile / esbuild ───────────────────────────────────────────────
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private static _esbuild: any = null;
+
+  private static async esbuild() {
+    if (!UniversalFsRuntime._esbuild) {
+      const consumerRequire = createRequire(process.cwd() + '/');
+      UniversalFsRuntime._esbuild = consumerRequire('esbuild');
+    }
+    return UniversalFsRuntime._esbuild;
+  }
+
+  static override async transpile(source: string): Promise<string> {
+    const esbuild = await UniversalFsRuntime.esbuild();
+    const result = await esbuild.transform(source, { loader: 'ts' });
+    return result.code;
+  }
+
+  static override async stopBundler(): Promise<void> {
+    if (UniversalFsRuntime._esbuild) {
+      await UniversalFsRuntime._esbuild.stop();
+      UniversalFsRuntime._esbuild = null;
+    }
+  }
+}