gorsee 0.2.3 → 0.2.5

package/dist-pkg/runtime/index.js

@@ -0,0 +1,59 @@
+export { Suspense } from "./suspense.js";
+export { render, hydrate } from "./client.js";
+export {
+  enterHydration,
+  exitHydration,
+  isHydrating,
+  getHydrationMismatches,
+  getHydrationDiagnostics,
+  resetHydrationDiagnostics
+} from "./hydration.js";
+export { renderToString, ssrJsx, ssrJsxs } from "./server.js";
+export { renderToStream, StreamSuspense, streamJsx, streamJsxs } from "./stream.js";
+export { EVENT_REPLAY_SCRIPT, replayEvents, stopEventCapture } from "./event-replay.js";
+export { Link } from "./link.js";
+export { Head } from "./head.js";
+export {
+  navigate,
+  onNavigate,
+  beforeNavigate,
+  getCurrentPath,
+  getRouterNavigationDiagnostics,
+  prefetch,
+  initRouter,
+  setLoadingElement
+} from "./router.js";
+export {
+  RUNTIME_DEVTOOLS_SCHEMA_VERSION,
+  createRuntimeDevtoolsSnapshot,
+  renderRuntimeDevtoolsHTML,
+  renderRuntimeDevtoolsOverlay
+} from "./devtools.js";
+export { useFormAction } from "./form.js";
+export {
+  Image,
+  getImageProps,
+  buildImageSrcSet,
+  getImageCandidateWidths,
+  isAllowedRemoteImage,
+  defaultImageLoader
+} from "./image.js";
+export {
+  typedLink,
+  typedNavigate,
+  typedPrefetch,
+  buildSearchParams,
+  buildTypedPath,
+  createTypedRoute,
+  extractRouteParamKeys
+} from "./typed-routes.js";
+export {
+  defineForm,
+  validateForm,
+  validateAction,
+  toFieldErrors,
+  fieldAttrs
+} from "./validated-form.js";
+export { island, isIsland } from "./island.js";
+export { hydrateIslands, registerIsland } from "./island-hydrator.js";
+export { createEventSource } from "./event-source.js";

package/dist-pkg/runtime/island-hydrator.d.ts

@@ -0,0 +1,12 @@
+type IslandLoader = () => Promise<{
+    default: (props: Record<string, unknown>) => unknown;
+}>;
+/** Register an island component loader by name. */
+export declare function registerIsland(name: string, loader: IslandLoader): void;
+/**
+ * Hydrate all island components on the page.
+ * Finds all elements with data-island attribute and hydrates each independently.
+ * Lazy islands use IntersectionObserver to defer until visible.
+ */
+export declare function hydrateIslands(): void;
+export {};

package/dist-pkg/runtime/island-hydrator.js

@@ -0,0 +1,49 @@
+import { enterHydration, exitHydration } from "./hydration.js";
+import { replayEvents } from "./event-replay.js";
+const islandRegistry = new Map;
+export function registerIsland(name, loader) {
+  islandRegistry.set(name, loader);
+}
+function parseIslandProps(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    console.warn(`[gorsee] Failed to parse island props: ${raw}`);
+    return {};
+  }
+}
+async function hydrateOne(el) {
+  const name = el.getAttribute("data-island");
+  if (!name)
+    return;
+  const loader = islandRegistry.get(name);
+  if (!loader) {
+    console.warn(`[gorsee] Island "${name}" not found in registry`);
+    return;
+  }
+  const component = (await loader()).default, rawProps = el.getAttribute("data-props") ?? "{}", props = parseIslandProps(rawProps);
+  enterHydration(el);
+  component(props);
+  exitHydration();
+  replayEvents(el);
+}
+export function hydrateIslands() {
+  const islands = document.querySelectorAll("[data-island]");
+  for (let i = 0;i < islands.length; i++) {
+    const el = islands[i];
+    if (el.hasAttribute("data-island-lazy") && typeof IntersectionObserver < "u")
+      observeLazy(el);
+    else
+      hydrateOne(el);
+  }
+}
+function observeLazy(el) {
+  const observer = new IntersectionObserver((entries) => {
+    for (const entry of entries)
+      if (entry.isIntersecting) {
+        observer.unobserve(el);
+        hydrateOne(el);
+      }
+  }, { rootMargin: "200px" });
+  observer.observe(el);
+}

package/dist-pkg/runtime/island.d.ts

@@ -0,0 +1,19 @@
+import type { GorseeRenderable } from "./renderable.js";
+export interface IslandOptions {
+    lazy?: boolean;
+}
+export declare const ISLAND_MARKER: unique symbol;
+interface IslandWrapper<P extends Record<string, unknown>> {
+    (props: P): GorseeRenderable;
+    [ISLAND_MARKER]: true;
+    componentName: string;
+    originalComponent: (props: P) => GorseeRenderable;
+    options: IslandOptions;
+}
+/**
+ * Wrap a component as an island -- only this component gets hydrated on the client.
+ * Static surrounding content stays as server-rendered HTML with zero JS.
+ */
+export declare function island<P extends Record<string, unknown>>(component: (props: P) => GorseeRenderable, options?: IslandOptions): IslandWrapper<P>;
+export declare function isIsland(fn: unknown): fn is IslandWrapper<Record<string, unknown>>;
+export {};

package/dist-pkg/runtime/island.js

@@ -0,0 +1,36 @@
+export const ISLAND_MARKER = Symbol("gorsee-island");
+function escapePropsForAttr(json) {
+  return json.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function island(component, options = {}) {
+  const name = component.name || "Anonymous", wrapper = function islandWrapper(props) {
+    const propsWithoutChildren = extractSerializableProps(props), serialized = escapePropsForAttr(JSON.stringify(propsWithoutChildren)), attrs = {
+      "data-island": name,
+      "data-props": serialized,
+      children: component(props)
+    };
+    if (options.lazy)
+      attrs["data-island-lazy"] = "true";
+    return { type: "div", props: attrs };
+  };
+  wrapper[ISLAND_MARKER] = !0;
+  wrapper.componentName = name;
+  wrapper.originalComponent = component;
+  wrapper.options = options;
+  return wrapper;
+}
+function extractSerializableProps(props) {
+  const result = {};
+  for (const key in props) {
+    if (key === "children")
+      continue;
+    const val = props[key];
+    if (typeof val === "function" || typeof val === "symbol")
+      continue;
+    result[key] = val;
+  }
+  return result;
+}
+export function isIsland(fn) {
+  return typeof fn === "function" && ISLAND_MARKER in fn;
+}

package/dist-pkg/runtime/jsx-runtime.d.ts

@@ -0,0 +1,12 @@
+import type { GorseeRenderable } from "./renderable.js";
+export type GorseeNode = Node | string | number | boolean | null | undefined | GorseeNode[];
+export type Component = (props: Record<string, unknown>) => GorseeRenderable;
+export declare const Fragment: unique symbol;
+export interface JSXElement {
+    type: string | Component | typeof Fragment;
+    props: Record<string, unknown>;
+    children: unknown[];
+}
+export declare function jsx(type: string | Component | typeof Fragment, props: Record<string, unknown> | null): Node | DocumentFragment;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;

package/dist-pkg/runtime/jsx-runtime.js

@@ -0,0 +1,173 @@
+import { createEffect } from "../reactive/effect.js";
+import { isHydrating, claimElement, claimText, pushCursor, popCursor } from "./hydration.js";
+import { isRenderableThunk, isSignal } from "./html-escape.js";
+export const Fragment = Symbol("Fragment");
+function isVNodeLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && "props" in value;
+}
+function createTextNode(value) {
+  return document.createTextNode(String(value ?? ""));
+}
+function bindProperty(el, key, value) {
+  if (key === "children" || key === "ref")
+    return;
+  if (key.startsWith("on:")) {
+    el.addEventListener(key.slice(3), value);
+    return;
+  }
+  if (key === "className" || key === "class") {
+    if (isSignal(value))
+      createEffect(() => {
+        el.className = String(value());
+      });
+    else if (!isHydrating())
+      el.className = String(value ?? "");
+    return;
+  }
+  if (key === "style" && typeof value === "object" && value !== null) {
+    const styles = value;
+    for (const [prop, val] of Object.entries(styles))
+      if (isSignal(val)) {
+        const p = prop;
+        createEffect(() => {
+          el.style.setProperty(p, String(val()));
+        });
+      } else if (!isHydrating())
+        el.style.setProperty(prop, String(val));
+    return;
+  }
+  if (isSignal(value))
+    createEffect(() => {
+      el.setAttribute(key, String(value()));
+    });
+  else if (!isHydrating()) {
+    if (typeof value === "boolean")
+      if (value)
+        el.setAttribute(key, "");
+      else
+        el.removeAttribute(key);
+    else if (value != null)
+      el.setAttribute(key, String(value));
+  }
+}
+function hydrateChild(parent, child) {
+  if (child == null || typeof child === "boolean")
+    return;
+  if (Array.isArray(child)) {
+    for (const c of child)
+      hydrateChild(parent, c);
+    return;
+  }
+  if (isVNodeLike(child)) {
+    jsx(child.type, child.props);
+    return;
+  }
+  if (typeof child === "function" && isSignal(child)) {
+    const textNode = claimText(String(child() ?? "")) ?? createTextNode(child());
+    if (!textNode.parentNode)
+      parent.appendChild(textNode);
+    createEffect(() => {
+      textNode.textContent = String(child() ?? "");
+    });
+    return;
+  }
+  if (isRenderableThunk(child)) {
+    hydrateChild(parent, child());
+    return;
+  }
+  if (typeof child === "object" && child instanceof Node)
+    return;
+  const textNode = claimText(String(child ?? "")) ?? createTextNode(child);
+  if (!textNode.parentNode)
+    parent.appendChild(textNode);
+}
+function insertChild(parent, child) {
+  if (child == null || typeof child === "boolean")
+    return;
+  if (Array.isArray(child)) {
+    for (const c of child)
+      insertChild(parent, c);
+    return;
+  }
+  if (isVNodeLike(child)) {
+    parent.appendChild(jsx(child.type, child.props));
+    return;
+  }
+  if (child instanceof Node) {
+    parent.appendChild(child);
+    return;
+  }
+  if (isSignal(child)) {
+    const textNode = createTextNode(child());
+    parent.appendChild(textNode);
+    createEffect(() => {
+      textNode.textContent = String(child() ?? "");
+    });
+    return;
+  }
+  if (isRenderableThunk(child)) {
+    insertChild(parent, child());
+    return;
+  }
+  parent.appendChild(createTextNode(child));
+}
+export function jsx(type, props) {
+  const allProps = props ?? {}, children = allProps.children, hydrating = isHydrating();
+  if (type === Fragment) {
+    if (hydrating) {
+      if (children != null)
+        hydrateChild(document.createDocumentFragment(), children);
+      return document.createDocumentFragment();
+    }
+    const frag = document.createDocumentFragment();
+    if (children != null)
+      insertChild(frag, children);
+    return frag;
+  }
+  if (typeof type === "function") {
+    const result = type(allProps);
+    if (result instanceof Node)
+      return result;
+    if (isVNodeLike(result))
+      return jsx(result.type, result.props);
+    if (isRenderableThunk(result)) {
+      const resolved = result();
+      if (hydrating) {
+        hydrateChild(document.createDocumentFragment(), resolved);
+        return document.createDocumentFragment();
+      }
+      const wrapper = document.createDocumentFragment();
+      insertChild(wrapper, resolved);
+      return wrapper;
+    }
+    if (hydrating) {
+      hydrateChild(document.createDocumentFragment(), result);
+      return document.createDocumentFragment();
+    }
+    const wrapper = document.createDocumentFragment();
+    insertChild(wrapper, result);
+    return wrapper;
+  }
+  if (hydrating) {
+    const el = claimElement(type);
+    if (el) {
+      for (const [key, value] of Object.entries(allProps))
+        if (key !== "children")
+          bindProperty(el, key, value);
+      if (children != null) {
+        pushCursor(el);
+        hydrateChild(el, children);
+        popCursor();
+      }
+      return el;
+    }
+  }
+  const el = document.createElement(type);
+  for (const [key, value] of Object.entries(allProps))
+    if (key !== "children")
+      bindProperty(el, key, value);
+  if (children != null)
+    insertChild(el, children);
+  return el;
+}
+export const jsxs = jsx, jsxDEV = jsx;

package/dist-pkg/runtime/link.d.ts

@@ -0,0 +1,16 @@
+import { type TypedRouteDefinition, type TypedRouteOptions, type TypedRouteParams } from "./typed-routes.js";
+import type { GorseeRenderable } from "./renderable.js";
+export interface LinkProps {
+    href: string | TypedRouteDefinition;
+    params?: TypedRouteParams;
+    search?: TypedRouteOptions["search"];
+    hash?: string;
+    children?: unknown;
+    class?: string;
+    className?: string;
+    prefetch?: boolean | "hover" | "viewport";
+    replace?: boolean;
+    target?: string;
+    [key: string]: unknown;
+}
+export declare function Link(props: LinkProps): GorseeRenderable;

package/dist-pkg/runtime/link.js

@@ -0,0 +1,47 @@
+import { navigate, prefetch } from "./router.js";
+import { resolveTypedRouteTarget } from "./typed-routes.js";
+function composeEventHandlers(first, second) {
+  if (!first)
+    return second;
+  if (!second)
+    return first;
+  return (event) => {
+    first(event);
+    second(event);
+  };
+}
+export function Link(props) {
+  const { href, params, search, hash, prefetch: prefetchMode, replace, children, ...rest } = props, resolvedHref = resolveTypedRouteTarget(href, { params, search, hash }), restProps = { ...rest }, onClick = restProps["on:click"], onMouseOver = restProps["on:mouseover"], onFocus = restProps["on:focus"];
+  delete restProps["on:click"];
+  delete restProps["on:mouseover"];
+  delete restProps["on:focus"];
+  delete restProps["data-g-prefetch"];
+  if (prefetchMode === !0 && typeof window < "u")
+    prefetch(resolvedHref);
+  const hoverPrefetchHandler = prefetchMode === "hover" ? () => prefetch(resolvedHref) : void 0;
+  return {
+    type: "a",
+    props: {
+      href: resolvedHref,
+      ...restProps,
+      ...prefetchMode === "viewport" ? { "data-g-prefetch": "viewport" } : {},
+      "on:click": (e) => {
+        if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0)
+          return;
+        const target = e.currentTarget?.target;
+        if (target && target !== "_self")
+          return;
+        e.preventDefault();
+        if (replace)
+          history.replaceState({ gorsee: !0 }, "", resolvedHref);
+        navigate(resolvedHref, !replace);
+        onClick?.(e);
+      },
+      ...prefetchMode === "hover" ? {
+        "on:mouseover": composeEventHandlers(onMouseOver, hoverPrefetchHandler),
+        "on:focus": composeEventHandlers(onFocus, hoverPrefetchHandler)
+      } : {},
+      children
+    }
+  };
+}

package/dist-pkg/runtime/project.d.ts

@@ -0,0 +1,37 @@
+export interface ProjectPathOverrides extends Partial<ProjectPaths> {
+}
+export interface RuntimeOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    pathOverrides?: ProjectPathOverrides;
+}
+export interface ProjectPaths {
+    cwd: string;
+    routesDir: string;
+    publicDir: string;
+    distDir: string;
+    clientDir: string;
+    serverDir: string;
+    gorseeDir: string;
+    sharedDir: string;
+    middlewareDir: string;
+    migrationsDir: string;
+    docsDir: string;
+    dataFile: string;
+    appConfigFile: string;
+}
+export interface ProjectContext {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    paths: ProjectPaths;
+}
+export interface RuntimeEnvConfig {
+    port: number;
+    logLevel: "info" | "debug";
+    rateLimit: number;
+    rateWindow: string;
+    isProduction: boolean;
+}
+export declare function resolveProjectPaths(cwd: string, overrides?: ProjectPathOverrides): ProjectPaths;
+export declare function createProjectContext(options?: RuntimeOptions): ProjectContext;
+export declare function resolveRuntimeEnv(env: NodeJS.ProcessEnv): RuntimeEnvConfig;

package/dist-pkg/runtime/project.js

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+export function resolveProjectPaths(cwd, overrides = {}) {
+  const gorseeDir = join(cwd, ".gorsee"), distDir = join(cwd, "dist");
+  return { ...{
+    cwd,
+    routesDir: join(cwd, "routes"),
+    publicDir: join(cwd, "public"),
+    distDir,
+    clientDir: join(distDir, "client"),
+    serverDir: join(distDir, "server"),
+    gorseeDir,
+    sharedDir: join(cwd, "shared"),
+    middlewareDir: join(cwd, "middleware"),
+    migrationsDir: join(cwd, "migrations"),
+    docsDir: join(cwd, "docs"),
+    dataFile: join(cwd, "data.sqlite"),
+    appConfigFile: join(cwd, "app.config.ts")
+  }, ...overrides, cwd };
+}
+export function createProjectContext(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return {
+    cwd,
+    env: options.env ?? process.env,
+    paths: resolveProjectPaths(cwd, options.pathOverrides)
+  };
+}
+export function resolveRuntimeEnv(env) {
+  return {
+    port: Number(env.PORT || "3000"),
+    logLevel: env.LOG_LEVEL === "debug" ? "debug" : "info",
+    rateLimit: Number(env.RATE_LIMIT) || 1000,
+    rateWindow: env.RATE_WINDOW || "1m",
+    isProduction: env.NODE_ENV === "production"
+  };
+}

package/dist-pkg/runtime/renderable.d.ts

@@ -0,0 +1,6 @@
+export type GorseePrimitive = string | number | boolean | null | undefined;
+export type GorseeVNodeLike = {
+    type: string | symbol | ((props: Record<string, unknown>) => GorseeRenderable);
+    props: Record<string, unknown>;
+};
+export type GorseeRenderable = Node | DocumentFragment | GorseePrimitive | GorseeVNodeLike | GorseeRenderable[] | (() => unknown);

package/dist-pkg/runtime/router.d.ts

@@ -0,0 +1,47 @@
+type NavigateCallback = (url: string) => void;
+type BeforeNavigateCallback = (url: string) => boolean | void;
+type PreservedControlState = {
+    key: string;
+    mode: "value" | "checked";
+    value: string | boolean;
+};
+type HMRUpdate = {
+    kind: "full-reload" | "route-refresh" | "css-update";
+    changedPath: string;
+    timestamp: number;
+    reason?: string;
+    routePaths?: string[];
+    entryScripts?: string[];
+    refreshCurrentRoute?: boolean;
+};
+export interface RouterNavigationDiagnostics {
+    currentPath: string;
+    navigating: boolean;
+    pendingPopScrollY: number | null;
+    latestNavigationToken: number;
+    activeNavigation: {
+        url: string;
+        pushState: boolean;
+    } | null;
+}
+export interface NavigationSnapshot {
+    focusKey?: string;
+    controls: PreservedControlState[];
+}
+export declare function createHTMLFragment(html: string): DocumentFragment;
+export declare function replaceHTMLFragment(container: Element, html: string): void;
+export declare function captureNavigationSnapshot(container: Element): NavigationSnapshot;
+export declare function restoreNavigationSnapshot(container: Element, snapshot: NavigationSnapshot): void;
+/** Set a loading indicator element to show during navigation */
+export declare function setLoadingElement(el: HTMLElement): void;
+export declare function onNavigate(fn: NavigateCallback): () => void;
+export declare function beforeNavigate(fn: BeforeNavigateCallback): () => void;
+export declare function getCurrentPath(): string;
+export declare function getRouterNavigationDiagnostics(): RouterNavigationDiagnostics;
+export declare function setCurrentRouteScript(script: string | null | undefined): void;
+export declare function navigate(url: string, pushState?: boolean): Promise<void>;
+export declare function refreshCurrentRoute(): Promise<void>;
+export declare function applyHMRUpdate(update: HMRUpdate): Promise<void>;
+export declare function prefetch(url: string): void;
+export declare function initRouter(): void;
+export {};