@netrojs/fnetro 0.1.2

package/dist/server.js

@@ -0,0 +1,720 @@
+// server.ts
+import { Hono } from "hono";
+import { jsx } from "hono/jsx";
+import { renderToString } from "hono/jsx/dom/server";
+
+// core.ts
+var RAW = /* @__PURE__ */ Symbol("raw");
+var IS_REACTIVE = /* @__PURE__ */ Symbol("isReactive");
+var IS_READONLY = /* @__PURE__ */ Symbol("isReadonly");
+var IS_REF = /* @__PURE__ */ Symbol("isRef");
+var MARK_RAW = /* @__PURE__ */ Symbol("markRaw");
+var targetMap = /* @__PURE__ */ new WeakMap();
+var activeEffect = null;
+var shouldTrack = true;
+var trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  shouldTrack = trackStack.pop() ?? true;
+}
+function track(target, key) {
+  if (!shouldTrack || !activeEffect) return;
+  let depsMap = targetMap.get(target);
+  if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+  let dep = depsMap.get(key);
+  if (!dep) depsMap.set(key, dep = /* @__PURE__ */ new Set());
+  trackEffect(activeEffect, dep);
+}
+function trackEffect(effect2, dep) {
+  if (!dep.has(effect2)) {
+    dep.add(effect2);
+    effect2.deps.push(dep);
+  }
+}
+function trigger(target, key, newVal, oldVal) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) return;
+  const effects = [];
+  const computedEffects = [];
+  depsMap.get(key)?.forEach((e) => {
+    if (e !== activeEffect) {
+      e.computed ? computedEffects.push(e) : effects.push(e);
+    }
+  });
+  [...computedEffects, ...effects].forEach((e) => {
+    if (e.active) e.scheduler ? e.scheduler() : e.run();
+  });
+}
+var ReactiveEffect = class {
+  constructor(fn, scheduler, scope) {
+    this.fn = fn;
+    this.scheduler = scheduler;
+    this.scope = scope;
+    scope?.effects.push(this);
+  }
+  deps = [];
+  active = true;
+  cleanup;
+  computed = false;
+  run() {
+    if (!this.active) return this.fn();
+    const prevEffect = activeEffect;
+    const prevShouldTrack = shouldTrack;
+    shouldTrack = true;
+    activeEffect = this;
+    this.cleanup?.();
+    this.cleanup = void 0;
+    this.deps.length = 0;
+    try {
+      const result = this.fn();
+      if (typeof result === "function") this.cleanup = result;
+      return result;
+    } finally {
+      activeEffect = prevEffect;
+      shouldTrack = prevShouldTrack;
+    }
+  }
+  stop() {
+    if (this.active) {
+      cleanupEffect(this);
+      this.active = false;
+    }
+  }
+};
+function cleanupEffect(e) {
+  e.deps.forEach((dep) => dep.delete(e));
+  e.deps.length = 0;
+}
+var activeScope;
+var EffectScope = class {
+  effects = [];
+  cleanups = [];
+  active = true;
+  run(fn) {
+    const prev = activeScope;
+    activeScope = this;
+    try {
+      return fn();
+    } finally {
+      activeScope = prev;
+    }
+  }
+  stop() {
+    if (this.active) {
+      this.effects.forEach((e) => e.stop());
+      this.cleanups.forEach((fn) => fn());
+      this.active = false;
+    }
+  }
+  onCleanup(fn) {
+    this.cleanups.push(fn);
+  }
+};
+function effectScope() {
+  return new EffectScope();
+}
+function effect(fn) {
+  const e = new ReactiveEffect(fn, void 0, activeScope);
+  e.run();
+  return () => e.stop();
+}
+function watchEffect(fn, opts) {
+  const e = new ReactiveEffect(fn, void 0, activeScope);
+  e.run();
+  return () => e.stop();
+}
+var refTarget = /* @__PURE__ */ Symbol("refTarget");
+var RefImpl = class {
+  constructor(value, shallow = false) {
+    this.shallow = shallow;
+    this._value = shallow ? value : toReactive(value);
+  }
+  [IS_REF] = true;
+  _value;
+  _subscribers = /* @__PURE__ */ new Set();
+  get value() {
+    track(this, refTarget);
+    this._subscribers.forEach((fn) => {
+    });
+    return this._value;
+  }
+  set value(next) {
+    const newVal = this.shallow ? next : toReactive(next);
+    if (!hasChanged(newVal, this._value)) return;
+    this._value = newVal;
+    trigger(this, refTarget, newVal, this._value);
+    this._subscribers.forEach((fn) => fn());
+  }
+  /** Subscribe for useSyncExternalStore */
+  subscribe(fn) {
+    this._subscribers.add(fn);
+    return () => this._subscribers.delete(fn);
+  }
+  peek() {
+    return this._value;
+  }
+};
+function ref(value) {
+  return isRef(value) ? value : new RefImpl(value);
+}
+function shallowRef(value) {
+  return new RefImpl(value, true);
+}
+function triggerRef(r) {
+  if (r instanceof RefImpl) {
+    trigger(r, refTarget);
+    r._subscribers.forEach((fn) => fn());
+  }
+}
+function isRef(r) {
+  return !!r && typeof r === "object" && r[IS_REF] === true;
+}
+function unref(r) {
+  return isRef(r) ? r.value : r;
+}
+function toRef(obj, key) {
+  const r = new RefImpl(void 0, false);
+  Object.defineProperty(r, "value", {
+    get() {
+      track(r, refTarget);
+      return obj[key];
+    },
+    set(v) {
+      obj[key] = v;
+      trigger(r, refTarget, v, obj[key]);
+    }
+  });
+  return r;
+}
+function toRefs(obj) {
+  const result = {};
+  for (const key in obj) result[key] = toRef(obj, key);
+  return result;
+}
+var ComputedRefImpl = class {
+  constructor(getter, setter) {
+    this.setter = setter;
+    this.effect = new ReactiveEffect(getter, () => {
+      if (!this._dirty) {
+        this._dirty = true;
+        trigger(this, refTarget);
+        this._subscribers.forEach((fn) => fn());
+      }
+    }, activeScope);
+    this.effect.computed = true;
+  }
+  [IS_REF] = true;
+  effect;
+  _value;
+  _dirty = true;
+  _subscribers = /* @__PURE__ */ new Set();
+  get value() {
+    track(this, refTarget);
+    if (this._dirty) {
+      this._dirty = false;
+      this._value = this.effect.run();
+    }
+    return this._value;
+  }
+  set value(v) {
+    this.setter?.(v);
+  }
+  subscribe(fn) {
+    this._subscribers.add(fn);
+    return () => this._subscribers.delete(fn);
+  }
+  peek() {
+    return this._value;
+  }
+};
+function computed(arg) {
+  if (typeof arg === "function") {
+    return new ComputedRefImpl(arg);
+  }
+  return new ComputedRefImpl(arg.get, arg.set);
+}
+var reactiveMap = /* @__PURE__ */ new WeakMap();
+var readonlyMap = /* @__PURE__ */ new WeakMap();
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+function toReactive(value) {
+  return value !== null && typeof value === "object" ? reactive(value) : value;
+}
+var arrayInstrumentations = {};
+["includes", "indexOf", "lastIndexOf"].forEach((method) => {
+  arrayInstrumentations[method] = function(...args) {
+    const arr = toRaw(this);
+    for (let i = 0; i < this.length; i++) track(arr, i);
+    let res = arr[method](...args);
+    if (res === -1 || res === false) res = arr[method](...args.map(toRaw));
+    return res;
+  };
+});
+["push", "pop", "shift", "unshift", "splice"].forEach((method) => {
+  arrayInstrumentations[method] = function(...args) {
+    pauseTracking();
+    const res = toRaw(this)[method].apply(this, args);
+    resetTracking();
+    return res;
+  };
+});
+function createHandler(shallow = false, readonly2 = false) {
+  return {
+    get(target, key, receiver) {
+      if (key === RAW) return target;
+      if (key === IS_REACTIVE) return !readonly2;
+      if (key === IS_READONLY) return readonly2;
+      if (key === MARK_RAW) return target[MARK_RAW];
+      const isArray = Array.isArray(target);
+      if (!readonly2 && isArray && hasOwn(arrayInstrumentations, key)) {
+        return Reflect.get(arrayInstrumentations, key, receiver);
+      }
+      const res = Reflect.get(target, key, receiver);
+      if (typeof key === "symbol" || key === "__proto__") return res;
+      if (!readonly2) track(target, key);
+      if (shallow) return res;
+      if (isRef(res)) return isArray ? res : res.value;
+      return res !== null && typeof res === "object" && !res[MARK_RAW] ? readonly2 ? readonlyProxy(res) : reactive(res) : res;
+    },
+    set(target, key, value, receiver) {
+      if (readonly2) {
+        console.warn(`[fnetro] Cannot set "${String(key)}" on readonly object`);
+        return true;
+      }
+      const oldVal = target[key];
+      const result = Reflect.set(target, key, value, receiver);
+      if (hasChanged(value, oldVal)) trigger(target, key, value, oldVal);
+      return result;
+    },
+    deleteProperty(target, key) {
+      if (readonly2) return true;
+      const hadKey = hasOwn(target, key);
+      const result = Reflect.deleteProperty(target, key);
+      if (hadKey && result) trigger(target, key);
+      return result;
+    },
+    has(target, key) {
+      const res = Reflect.has(target, key);
+      track(target, key);
+      return res;
+    },
+    ownKeys(target) {
+      track(target, Array.isArray(target) ? "length" : "__iterate__");
+      return Reflect.ownKeys(target);
+    }
+  };
+}
+function reactive(target) {
+  if (isReadonly(target)) return target;
+  if (target[MARK_RAW]) return target;
+  if (reactiveMap.has(target)) return reactiveMap.get(target);
+  const proxy = new Proxy(target, createHandler());
+  reactiveMap.set(target, proxy);
+  return proxy;
+}
+function shallowReactive(target) {
+  if (shallowReactiveMap.has(target)) return shallowReactiveMap.get(target);
+  const proxy = new Proxy(target, createHandler(true));
+  shallowReactiveMap.set(target, proxy);
+  return proxy;
+}
+function readonlyProxy(target) {
+  if (readonlyMap.has(target)) return readonlyMap.get(target);
+  const proxy = new Proxy(target, createHandler(false, true));
+  readonlyMap.set(target, proxy);
+  return proxy;
+}
+function readonly(target) {
+  return readonlyProxy(target);
+}
+function markRaw(value) {
+  ;
+  value[MARK_RAW] = true;
+  return value;
+}
+function toRaw(observed) {
+  const raw = observed?.[RAW];
+  return raw ? toRaw(raw) : observed;
+}
+function isReactive(value) {
+  if (isReadonly(value)) return isReactive(value[RAW]);
+  return !!(value && value[IS_REACTIVE]);
+}
+function isReadonly(value) {
+  return !!(value && value[IS_READONLY]);
+}
+function traverse(value, seen = /* @__PURE__ */ new Set()) {
+  if (!value || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  if (isRef(value)) {
+    traverse(value.value, seen);
+    return value;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((v) => traverse(v, seen));
+    return value;
+  }
+  for (const key in value) traverse(value[key], seen);
+  return value;
+}
+function normalizeSource(src) {
+  if (Array.isArray(src)) return () => src.map((s) => isRef(s) ? s.value : s());
+  if (isRef(src)) return () => src.value;
+  return src;
+}
+function watch(source, cb, opts = {}) {
+  const getter = opts.deep ? () => traverse(normalizeSource(source)()) : normalizeSource(source);
+  let oldVal = void 0;
+  let cleanupFn;
+  const cleanup = (fn) => {
+    cleanupFn = fn;
+  };
+  const job = () => {
+    if (!effect2.active) return;
+    cleanupFn?.();
+    cleanupFn = void 0;
+    const newVal = effect2.run();
+    if (opts.deep || hasChanged(newVal, oldVal)) {
+      cb(newVal, oldVal, cleanup);
+      oldVal = newVal;
+    }
+    if (opts.once) effect2.stop();
+  };
+  const effect2 = new ReactiveEffect(getter, job, activeScope);
+  if (opts.immediate) {
+    cleanupFn?.();
+    cleanupFn = void 0;
+    const val = effect2.run();
+    cb(val, oldVal, cleanup);
+    oldVal = val;
+  } else {
+    oldVal = effect2.run();
+  }
+  return () => effect2.stop();
+}
+var __hooks = {
+  useValue: (r) => isRef(r) ? r.value : r(),
+  useLocalRef: (init) => ref(init),
+  useLocalReactive: (init) => reactive(init)
+};
+function use(source) {
+  return __hooks.useValue(source);
+}
+function useLocalRef(init) {
+  return __hooks.useLocalRef(init);
+}
+function useLocalReactive(init) {
+  return __hooks.useLocalReactive(init);
+}
+function definePage(def) {
+  return { __type: "page", ...def };
+}
+function defineGroup(def) {
+  return { __type: "group", ...def };
+}
+function defineLayout(Component) {
+  return { __type: "layout", Component };
+}
+function defineMiddleware(handler) {
+  return { __type: "middleware", handler };
+}
+function defineApiRoute(path, register) {
+  return { __type: "api", path, register };
+}
+function resolveRoutes(routes, options = {}) {
+  const pages = [];
+  const apis = [];
+  for (const route of routes) {
+    if (route.__type === "api") {
+      apis.push({ ...route, path: (options.prefix ?? "") + route.path });
+    } else if (route.__type === "group") {
+      const prefix = (options.prefix ?? "") + route.prefix;
+      const mw = [...options.middleware ?? [], ...route.middleware ?? []];
+      const layout = route.layout !== void 0 ? route.layout : options.layout;
+      const sub = resolveRoutes(route.routes, { prefix, middleware: mw, layout });
+      pages.push(...sub.pages);
+      apis.push(...sub.apis);
+    } else {
+      const fullPath = (options.prefix ?? "") + route.path;
+      const layout = route.layout !== void 0 ? route.layout : options.layout;
+      const middleware = [...options.middleware ?? [], ...route.middleware ?? []];
+      pages.push({ fullPath, page: route, layout, middleware });
+    }
+  }
+  return { pages, apis };
+}
+var SPA_HEADER = "x-fnetro-spa";
+var STATE_KEY = "__FNETRO_STATE__";
+var PARAMS_KEY = "__FNETRO_PARAMS__";
+function hasChanged(a, b) {
+  return !Object.is(a, b);
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+// server.ts
+function compilePath(path) {
+  const keys = [];
+  const src = path.replace(/\[\.\.\.([^\]]+)\]/g, (_, k) => {
+    keys.push(k);
+    return "(.*)";
+  }).replace(/\[([^\]]+)\]/g, (_, k) => {
+    keys.push(k);
+    return "([^/]+)";
+  }).replace(/\*/g, "(.*)");
+  return { re: new RegExp(`^${src}$`), keys, original: path };
+}
+function matchPath(compiled, pathname) {
+  const m = pathname.match(compiled.re);
+  if (!m) return null;
+  const params = {};
+  compiled.keys.forEach((k, i) => {
+    params[k] = decodeURIComponent(m[i + 1]);
+  });
+  return params;
+}
+function buildShell(opts) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escHtml(opts.title)}</title>
+<link rel="stylesheet" href="/assets/style.css">
+</head>
+<body>
+<div id="fnetro-app">${opts.pageHtml}</div>
+<script>window.${STATE_KEY}=${opts.stateJson};window.${PARAMS_KEY}=${opts.paramsJson};</script>
+<script type="module" src="/assets/client.js"></script>
+</body>
+</html>`;
+}
+function escHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function renderInner(route, data, url, params, appLayout) {
+  const pageNode = jsx(route.page.Page, { ...data, url, params });
+  const layout = route.layout !== void 0 ? route.layout : appLayout;
+  const wrapped = layout ? jsx(layout.Component, { url, params, children: pageNode }) : pageNode;
+  return renderToString(wrapped);
+}
+async function renderFullPage(route, data, url, params, appLayout, title = "FNetro") {
+  const pageHtml = await renderInner(route, data, url, params, appLayout);
+  return buildShell({
+    title,
+    stateJson: JSON.stringify({ [url]: data }),
+    paramsJson: JSON.stringify(params),
+    pageHtml
+  });
+}
+function createFNetro(config) {
+  const app = new Hono();
+  app.use("/assets/*", async (c, next) => {
+    await next();
+  });
+  (config.middleware ?? []).forEach((mw) => app.use("*", mw));
+  const { pages, apis } = resolveRoutes(config.routes, {
+    layout: config.layout,
+    middleware: []
+  });
+  const compiled = pages.map((r) => ({
+    route: r,
+    compiled: compilePath(r.fullPath)
+  }));
+  apis.forEach((api) => {
+    const sub = new Hono();
+    api.register(sub, config.middleware ?? []);
+    app.route(api.path, sub);
+  });
+  app.all("*", async (c) => {
+    const url = new URL(c.req.url);
+    const pathname = url.pathname;
+    const isSPA = c.req.header(SPA_HEADER) === "1";
+    let matched = null;
+    for (const { route: route2, compiled: cp } of compiled) {
+      const params2 = matchPath(cp, pathname);
+      if (params2 !== null) {
+        matched = { route: route2, params: params2 };
+        break;
+      }
+    }
+    if (!matched) {
+      if (config.notFound) {
+        const html = await renderToString(jsx(config.notFound, {}));
+        return c.html(`<!DOCTYPE html><html><body>${html}</body></html>`, 404);
+      }
+      return c.text("Not Found", 404);
+    }
+    const { route, params } = matched;
+    const origParam = c.req.param.bind(c.req);
+    c.req.param = (key) => key ? params[key] ?? origParam(key) : { ...params, ...origParam() };
+    let earlyResponse;
+    const handlers = [...route.middleware];
+    let idx = 0;
+    const runMiddleware = async () => {
+      const mw = handlers[idx++];
+      if (!mw) return;
+      const res = await mw(c, runMiddleware);
+      if (res instanceof Response && !earlyResponse) earlyResponse = res;
+    };
+    await runMiddleware();
+    if (earlyResponse) return earlyResponse;
+    const data = route.page.loader ? await route.page.loader(c) : {};
+    const safeData = data ?? {};
+    if (isSPA) {
+      const html = await renderInner(route, safeData, pathname, params, config.layout);
+      return c.json({
+        html,
+        state: safeData,
+        params,
+        url: pathname
+      });
+    }
+    const fullHtml = await renderFullPage(route, safeData, pathname, params, config.layout);
+    return c.html(fullHtml);
+  });
+  return { app, handler: app.fetch };
+}
+function detectRuntime() {
+  if (typeof globalThis.Bun !== "undefined") return "bun";
+  if (typeof globalThis.Deno !== "undefined") return "deno";
+  if (typeof process !== "undefined" && process.versions?.node) return "node";
+  return "edge";
+}
+async function serve(opts) {
+  const runtime = opts.runtime ?? detectRuntime();
+  const port = opts.port ?? Number(globalThis.process?.env?.PORT ?? 3e3);
+  const hostname = opts.hostname ?? "0.0.0.0";
+  const staticDir = opts.staticDir ?? "./dist";
+  const addr = `http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`;
+  const logReady = () => console.log(`
+\u{1F525}  FNetro [${runtime}] ready  \u2192  ${addr}
+`);
+  switch (runtime) {
+    case "node": {
+      const [{ serve: nodeServe }, { serveStatic }] = await Promise.all([
+        import("@hono/node-server"),
+        import("@hono/node-server/serve-static")
+      ]);
+      opts.app.app.use("/assets/*", serveStatic({ root: staticDir }));
+      nodeServe({ fetch: opts.app.handler, port, hostname });
+      logReady();
+      break;
+    }
+    case "bun": {
+      ;
+      globalThis.Bun.serve({ fetch: opts.app.handler, port, hostname });
+      logReady();
+      break;
+    }
+    case "deno": {
+      ;
+      globalThis.Deno.serve({ port, hostname }, opts.app.handler);
+      logReady();
+      break;
+    }
+    default:
+      console.warn("[fnetro] serve() is a no-op on edge runtimes. Export `app.handler` instead.");
+  }
+}
+var NODE_BUILTINS = /^node:|^(assert|buffer|child_process|cluster|crypto|dgram|dns|domain|events|fs|http|https|module|net|os|path|perf_hooks|process|punycode|querystring|readline|repl|stream|string_decoder|sys|timers|tls|trace_events|tty|url|util|v8|vm|worker_threads|zlib)$/;
+function fnetroVitePlugin(opts = {}) {
+  const {
+    serverEntry = "app/server.ts",
+    clientEntry = "app/client.ts",
+    serverOutDir = "dist/server",
+    clientOutDir = "dist/assets",
+    serverExternal = []
+  } = opts;
+  let isServerBuild = true;
+  const sharedEsbuild = {
+    jsx: "automatic",
+    jsxImportSource: "hono/jsx"
+  };
+  const jsxPlugin = {
+    name: "fnetro:jsx",
+    config: () => ({ esbuild: sharedEsbuild })
+  };
+  const serverPlugin = {
+    name: "fnetro:server",
+    apply: "build",
+    enforce: "pre",
+    config() {
+      return {
+        build: {
+          outDir: serverOutDir,
+          ssr: true,
+          target: "node18",
+          lib: {
+            entry: serverEntry,
+            formats: ["es"],
+            fileName: "server"
+          },
+          rollupOptions: {
+            external: (id) => NODE_BUILTINS.test(id) || id === "@hono/node-server" || serverExternal.includes(id)
+          }
+        },
+        esbuild: sharedEsbuild
+      };
+    },
+    async closeBundle() {
+      console.log("\n\u26A1  FNetro: building client bundle\u2026\n");
+      const { build } = await import("vite");
+      await build({
+        configFile: false,
+        esbuild: sharedEsbuild,
+        build: {
+          outDir: clientOutDir,
+          lib: {
+            entry: clientEntry,
+            formats: ["es"],
+            fileName: "client"
+          },
+          rollupOptions: {
+            output: { entryFileNames: "[name].js" }
+          }
+        }
+      });
+      console.log("\n\u2705  FNetro: both bundles ready\n");
+    }
+  };
+  return [jsxPlugin, serverPlugin];
+}
+export {
+  SPA_HEADER,
+  STATE_KEY,
+  computed,
+  createFNetro,
+  defineApiRoute,
+  defineGroup,
+  defineLayout,
+  defineMiddleware,
+  definePage,
+  detectRuntime,
+  effect,
+  effectScope,
+  fnetroVitePlugin,
+  isReactive,
+  isReadonly,
+  isRef,
+  markRaw,
+  reactive,
+  readonly,
+  ref,
+  serve,
+  shallowReactive,
+  shallowRef,
+  toRaw,
+  toRef,
+  toRefs,
+  triggerRef,
+  unref,
+  use,
+  useLocalReactive,
+  useLocalRef,
+  watch,
+  watchEffect
+};