@tschk/moonshine-react-router 0.3.4

package/README.md

@@ -0,0 +1,76 @@
+# `@tschk/moonshine-react-router`
+
+The `react-router` / `@remix-run/react` **client API reimplemented on
+moonshine**. It imports no react-router code and lists none as a dependency:
+`Link`, `NavLink`, `useNavigate` and friends are ordinary React components
+written against `@tschk/moonshine/router`.
+
+An existing app can alias the import and drop the dependency:
+
+```ts
+// bunfig.toml / tsconfig paths / bundler alias
+"react-router" -> "@tschk/moonshine-react-router"
+"@remix-run/react" -> "@tschk/moonshine-react-router"
+```
+
+```tsx
+import {
+  Link,
+  NavLink,
+  Outlet,
+  useNavigate,
+  useSearchParams,
+} from "@tschk/moonshine-react-router";
+import { json, redirect } from "@tschk/moonshine-react-router/server";
+```
+
+| Subpath        | Contents                                                |
+| -------------- | ------------------------------------------------------- |
+| `.`            | full client API (components + hooks + response helpers) |
+| `./link`       | `Link`, `NavLink`, `Navigate`                           |
+| `./navigation` | `useNavigate`, `useLocation`, `useParams`, …            |
+| `./outlet`     | `Outlet`, `OutletProvider`, `useOutletContext`          |
+| `./responses`  | `json`, `data`, `redirect`, `ErrorResponse`             |
+| `./server`     | response helpers + moonshine server handling            |
+| `./client`     | moonshine signals + resources                           |
+
+## Supported
+
+- `Link` — `to` as string or partial path, `replace`, `preventScrollReset`,
+  `reloadDocument`, `prefetch` (`"intent"` hover, `"render"`, `"viewport"`);
+  modifier-clicks, external URLs and non-`_self` targets fall through to the
+  browser. Navigation runs inside `startTransition`.
+- `NavLink` — `end`, `caseSensitive`, `className`/`style`/`children` as render
+  callbacks, `aria-current="page"`, default `.active` class.
+- `Navigate` — declarative redirect on mount.
+- `Outlet`, `OutletProvider`, `useOutlet`, `useOutletContext`.
+- `useNavigate` (path or numeric delta), `useLocation`, `useParams`,
+  `useSearchParams` (with setter), `useHref`, `useResolvedPath`,
+  `useNavigationType`.
+- `json`, `data`, `redirect`, `redirectDocument`, `replace`, `ErrorResponse`,
+  `isRouteErrorResponse`.
+
+## Not supported
+
+These need react-router's own data router or build plugin and are **not**
+provided — do not expect them to work by aliasing:
+
+- **Data APIs**: `useLoaderData`, `useActionData`, `useFetcher`,
+  `useRevalidator`, `useSubmit`, `useNavigation`, `useBlocker`,
+  `unstable_usePrompt`, `defer`/`Await`. There is no loader/action lifecycle in
+  moonshine; fetch in the component or on the moonshine server route.
+- **Route configuration**: `createBrowserRouter`, `RouterProvider`, `Routes`,
+  `Route`, `createRoutesFromElements`, nested route matching. Moonshine matches
+  a flat route table via `MoonshineRouter`; `<Outlet>` is fed explicitly by
+  `<OutletProvider>` rather than derived from nested config.
+- **Progressive enhancement**: `<Form>`, `<Scripts>`, `<Meta>`, `<Links>`,
+  `<ScrollRestoration>`, `<Await>`, `useFormAction`.
+- **History state**: `location.state`, `location.key` stability and
+  `useNavigationType` distinguishing PUSH/POP/REPLACE. `state` is always `null`
+  and `useNavigationType()` always returns `"POP"`.
+- **Error boundaries**: `useRouteError`, `errorElement`. `ErrorResponse` and
+  `isRouteErrorResponse` exist as value types only.
+- `useSearchParams` reads `window.location.search`; on the server it is empty
+  because moonshine's router signal carries the pathname only.
+
+See [Moonshine README](../../README.md).

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@tschk/moonshine-react-router",
+  "version": "0.3.4",
+  "description": "react-router / Remix client API reimplemented on moonshine — drop react-router, keep the imports",
+  "license": "ISC",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./client": "./src/client.ts",
+    "./server": "./src/server.ts",
+    "./navigation": "./src/navigation.ts",
+    "./link": "./src/link.ts",
+    "./outlet": "./src/outlet.ts",
+    "./responses": "./src/responses.ts",
+    "./aliases": "./src/aliases.ts"
+  },
+  "dependencies": {
+    "@tschk/moonshine": "^0.3.4",
+    "@tschk/moonshine-router": "^0.3.4"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "moonshine",
+    "react-router",
+    "remix",
+    "adapter"
+  ],
+  "scripts": {
+    "format": "bunx prettier --check .",
+    "lint": "bunx oxlint .",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test"
+  }
+}

package/src/aliases.ts

@@ -0,0 +1,58 @@
+/**
+ * Drop-in mapping from the react-router specifiers onto this package.
+ *
+ * An existing app keeps its imports — the bundler rewrites the specifier, so no
+ * source changes are needed.
+ *
+ * ```ts
+ * import { moonshineReactRouterPlugin } from "@tschk/moonshine-react-router/aliases";
+ * await Bun.build({ entrypoints: ["./app.tsx"], plugins: [moonshineReactRouterPlugin()] });
+ * ```
+ */
+import { join } from "node:path";
+import type { BunPlugin } from "bun";
+
+/** Bare specifier each replaced package is served by. */
+export const reactRouterAliases: Readonly<Record<string, string>> = {
+  "react-router": "@tschk/moonshine-react-router",
+  "react-router-dom": "@tschk/moonshine-react-router",
+  "@remix-run/react": "@tschk/moonshine-react-router",
+};
+
+/** File in this package backing each alias, relative to `src/`. */
+const files: Readonly<Record<string, string>> = {
+  "react-router": "index.ts",
+  "react-router-dom": "index.ts",
+  "@remix-run/react": "index.ts",
+};
+
+/**
+ * `compilerOptions.paths` block for an app's tsconfig, so the type checker
+ * follows the same mapping the bundler applies.
+ */
+export function tsconfigPaths(): Record<string, string[]> {
+  return Object.fromEntries(
+    Object.entries(reactRouterAliases).map(([from, to]) => [from, [to]]),
+  );
+}
+
+/** Absolute path this package serves `specifier` from, if it is aliased. */
+export function resolveAlias(specifier: string): string | undefined {
+  const file = files[specifier];
+  return file === undefined ? undefined : join(import.meta.dir, file);
+}
+
+const filter = /^(react-router|react-router-dom|@remix-run\/react)$/;
+
+/** Bun bundler/runtime plugin rewriting react-router imports to this package. */
+export function moonshineReactRouterPlugin(): BunPlugin {
+  return {
+    name: "moonshine-react-router-aliases",
+    setup(build) {
+      build.onResolve({ filter }, (args) => {
+        const path = resolveAlias(args.path);
+        return path === undefined ? undefined : { path };
+      });
+    },
+  };
+}

package/src/client.ts

@@ -0,0 +1,12 @@
+"use client";
+
+/**
+ * Moonshine signal + resource surface for react-router apps.
+ */
+export * from "@tschk/moonshine/host-react";
+
+export {
+  createIslandSignal,
+  createResource,
+  useResource,
+} from "@tschk/moonshine/host-react";

package/src/index.ts

@@ -0,0 +1,51 @@
+"use client";
+
+/**
+ * @tschk/moonshine-react-router
+ *
+ * The `react-router` / `@remix-run/react` client API reimplemented on
+ * moonshine's router. Alias `react-router` to this package to drop the
+ * dependency.
+ */
+export { Link, NavLink, Navigate, default as LinkDefault } from "./link";
+export type {
+  LinkProps,
+  NavLinkProps,
+  NavLinkRenderState,
+  NavigateProps,
+} from "./link";
+
+export {
+  useHref,
+  useLocation,
+  useNavigate,
+  useNavigationType,
+  useParams,
+  useResolvedPath,
+  useSearchParams,
+} from "./navigation";
+export type {
+  NavigateFunction,
+  NavigateOptions,
+  NavigationType,
+  SetURLSearchParams,
+} from "./navigation";
+
+export { Outlet, OutletProvider, useOutlet, useOutletContext } from "./outlet";
+export type {
+  OutletContextValue,
+  OutletProps,
+  OutletProviderProps,
+} from "./outlet";
+
+export type { Location, To } from "./location";
+
+export {
+  ErrorResponse,
+  data,
+  isRouteErrorResponse,
+  json,
+  redirect,
+  redirectDocument,
+  replace,
+} from "./responses";

package/src/link.ts

@@ -0,0 +1,210 @@
+"use client";
+
+/**
+ * `<Link>`, `<NavLink>` and `<Navigate>` on the moonshine router.
+ *
+ * ```tsx
+ * import { Link, NavLink } from "@tschk/moonshine-react-router";
+ * ```
+ */
+import {
+  createElement,
+  useCallback,
+  useEffect,
+  useRef,
+  useTransition,
+  type AnchorHTMLAttributes,
+  type MouseEvent,
+  type ReactNode,
+} from "react";
+import { navigate } from "@tschk/moonshine/router";
+import { toHref, type To } from "./location";
+import { useLocation } from "./navigation";
+
+export type LinkProps = Omit<
+  AnchorHTMLAttributes<HTMLAnchorElement>,
+  "href"
+> & {
+  to: To;
+  replace?: boolean;
+  preventScrollReset?: boolean;
+  /** Accepted for source compatibility; history state is not tracked. */
+  state?: unknown;
+  reloadDocument?: boolean;
+  /** `"intent"` warms the URL on hover, `"render"` on mount. */
+  prefetch?: "none" | "intent" | "render" | "viewport";
+  children?: ReactNode;
+};
+
+function isExternal(href: string, target?: string): boolean {
+  if (target && target !== "_self") return true;
+  return (
+    /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(href) ||
+    href.startsWith("//") ||
+    href.startsWith("#")
+  );
+}
+
+const prefetched = new Set<string>();
+
+function prefetchOnce(url: string): void {
+  if (prefetched.has(url) || typeof document === "undefined") return;
+  prefetched.add(url);
+  const tag = document.createElement("link");
+  tag.rel = "prefetch";
+  tag.href = url;
+  document.head.append(tag);
+}
+
+export function Link({
+  to,
+  replace,
+  preventScrollReset,
+  state: _state,
+  reloadDocument,
+  prefetch = "intent",
+  children,
+  onClick,
+  onMouseEnter,
+  ...rest
+}: LinkProps): ReactNode {
+  const href = toHref(to);
+  const external = isExternal(href, rest.target);
+  const ref = useRef<HTMLAnchorElement>(null);
+  // Navigation runs in a transition so a slow subtree cannot block the click.
+  const [, startTransition] = useTransition();
+  const inert = external || reloadDocument === true || prefetch === "none";
+
+  const warm = useCallback(() => {
+    if (!inert) prefetchOnce(href);
+  }, [inert, href]);
+
+  useEffect(() => {
+    if (inert) return;
+    if (prefetch === "render") {
+      warm();
+      return;
+    }
+    const node = ref.current;
+    if (
+      !node ||
+      prefetch !== "viewport" ||
+      typeof IntersectionObserver === "undefined"
+    ) {
+      return;
+    }
+    const observer = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.isIntersecting) {
+          warm();
+          observer.disconnect();
+        }
+      }
+    });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [warm, prefetch, inert]);
+
+  return createElement(
+    "a",
+    {
+      ...rest,
+      ref,
+      href,
+      onMouseEnter: (event: MouseEvent<HTMLAnchorElement>) => {
+        onMouseEnter?.(event);
+        if (prefetch === "intent") warm();
+      },
+      onClick: (event: MouseEvent<HTMLAnchorElement>) => {
+        onClick?.(event);
+        if (
+          event.defaultPrevented ||
+          event.button !== 0 ||
+          event.metaKey ||
+          event.altKey ||
+          event.ctrlKey ||
+          event.shiftKey ||
+          external ||
+          reloadDocument === true
+        ) {
+          return;
+        }
+        event.preventDefault();
+        startTransition(() => {
+          navigate(href, { replace });
+          if (preventScrollReset !== true) globalThis.scrollTo?.(0, 0);
+        });
+      },
+    },
+    children,
+  );
+}
+
+export type NavLinkRenderState = { isActive: boolean; isPending: boolean };
+
+export type NavLinkProps = Omit<
+  LinkProps,
+  "className" | "style" | "children"
+> & {
+  end?: boolean;
+  caseSensitive?: boolean;
+  className?: string | ((state: NavLinkRenderState) => string | undefined);
+  style?: Record<string, unknown> | ((state: NavLinkRenderState) => never);
+  children?: ReactNode | ((state: NavLinkRenderState) => ReactNode);
+};
+
+function pathnameOf(href: string): string {
+  const cut = href.search(/[?#]/);
+  return cut === -1 ? href : href.slice(0, cut);
+}
+
+export function NavLink({
+  end,
+  caseSensitive,
+  className,
+  style,
+  children,
+  ...rest
+}: NavLinkProps): ReactNode {
+  const { pathname } = useLocation();
+  const target = pathnameOf(toHref(rest.to));
+  const [a, b] = caseSensitive
+    ? [pathname, target]
+    : [pathname.toLowerCase(), target.toLowerCase()];
+  const isActive = end
+    ? a === b || a === `${b}/`
+    : a === b || a.startsWith(b.endsWith("/") ? b : `${b}/`);
+  // Moonshine navigations resolve synchronously, so nothing is ever pending.
+  const state: NavLinkRenderState = { isActive, isPending: false };
+
+  return createElement(
+    Link,
+    {
+      ...rest,
+      "aria-current": isActive ? "page" : undefined,
+      className:
+        typeof className === "function"
+          ? className(state)
+          : (className ?? (isActive ? "active" : undefined)),
+      style: (typeof style === "function" ? style(state) : style) as never,
+    } as LinkProps,
+    typeof children === "function" ? children(state) : children,
+  );
+}
+
+export type NavigateProps = {
+  to: To;
+  replace?: boolean;
+  state?: unknown;
+};
+
+/** Redirects on mount, the declarative form of `useNavigate()`. */
+export function Navigate({ to, replace }: NavigateProps): null {
+  const href = toHref(to);
+  useEffect(() => {
+    navigate(href, { replace });
+  }, [href, replace]);
+  return null;
+}
+
+export default Link;

package/src/location.ts

@@ -0,0 +1,64 @@
+"use client";
+
+/**
+ * Location shape shared by the react-router hooks.
+ *
+ * Moonshine's router signal carries the pathname only, so `search` and `hash`
+ * are read back from `window.location` on each render.
+ */
+import { useMemo, useReducer } from "react";
+import { useLocation as useMoonshineLocation } from "@tschk/moonshine/router";
+
+export type Location<S = unknown> = {
+  pathname: string;
+  search: string;
+  hash: string;
+  state: S | null;
+  key: string;
+};
+
+export type To = string | { pathname?: string; search?: string; hash?: string };
+
+/** Normalises a `To` into a single URL string. */
+export function toHref(to: To): string {
+  if (typeof to === "string") return to;
+  const search = to.search
+    ? to.search.startsWith("?")
+      ? to.search
+      : `?${to.search}`
+    : "";
+  const hash = to.hash
+    ? to.hash.startsWith("#")
+      ? to.hash
+      : `#${to.hash}`
+    : "";
+  return `${to.pathname ?? ""}${search}${hash}`;
+}
+
+function browserPart(part: "search" | "hash"): string {
+  if (typeof window === "undefined") return "";
+  return window.location[part];
+}
+
+/** Forces a re-render; used after navigations that only change the query. */
+export function useRerender(): () => void {
+  const [, bump] = useReducer((n: number) => n + 1, 0);
+  return bump;
+}
+
+export function useLocationObject(): Location {
+  const pathname = useMoonshineLocation();
+  const search = browserPart("search");
+  const hash = browserPart("hash");
+  return useMemo(
+    () => ({
+      pathname,
+      search,
+      hash,
+      // History state is not tracked by the moonshine router.
+      state: null,
+      key: `${pathname}${search}${hash}`,
+    }),
+    [pathname, search, hash],
+  );
+}

package/src/navigation.ts

@@ -0,0 +1,138 @@
+"use client";
+
+/**
+ * `react-router` navigation hooks implemented on the moonshine router.
+ *
+ * ```ts
+ * import { useNavigate, useLocation } from "@tschk/moonshine-react-router";
+ * ```
+ */
+import { useCallback, useMemo } from "react";
+import {
+  navigate,
+  useParams as useMoonshineParams,
+} from "@tschk/moonshine/router";
+import {
+  toHref,
+  useLocationObject,
+  useRerender,
+  type Location,
+  type To,
+} from "./location";
+
+export type NavigateOptions = {
+  replace?: boolean;
+  /** Accepted for source compatibility; history state is not tracked. */
+  state?: unknown;
+  preventScrollReset?: boolean;
+};
+
+export type NavigateFunction = {
+  (to: To, options?: NavigateOptions): void;
+  (delta: number): void;
+};
+
+export function useLocation(): Location {
+  return useLocationObject();
+}
+
+export function useNavigate(): NavigateFunction {
+  const rerender = useRerender();
+  return useCallback(
+    (to: To | number, options?: NavigateOptions) => {
+      if (typeof to === "number") {
+        globalThis.history?.go(to);
+        return;
+      }
+      navigate(toHref(to), { replace: options?.replace });
+      if (options?.preventScrollReset !== true) globalThis.scrollTo?.(0, 0);
+      rerender();
+    },
+    [rerender],
+  ) as NavigateFunction;
+}
+
+export function useParams<
+  T extends Record<string, string> = Record<string, string>,
+>(): T {
+  return useMoonshineParams() as T;
+}
+
+export type SetURLSearchParams = (
+  next:
+    | URLSearchParams
+    | Record<string, string>
+    | ((current: URLSearchParams) => URLSearchParams),
+  options?: NavigateOptions,
+) => void;
+
+export function useSearchParams(): [URLSearchParams, SetURLSearchParams] {
+  const location = useLocationObject();
+  const rerender = useRerender();
+  const params = useMemo(
+    () => new URLSearchParams(location.search),
+    [location.search],
+  );
+
+  const setSearchParams = useCallback<SetURLSearchParams>(
+    (next, options) => {
+      const resolved =
+        typeof next === "function"
+          ? next(new URLSearchParams(location.search))
+          : next instanceof URLSearchParams
+            ? next
+            : new URLSearchParams(next);
+      const query = resolved.toString();
+      navigate(`${location.pathname}${query ? `?${query}` : ""}`, {
+        replace: options?.replace,
+      });
+      // A query-only navigation leaves the pathname signal unchanged.
+      rerender();
+    },
+    [location.pathname, location.search, rerender],
+  );
+
+  return [params, setSearchParams];
+}
+
+/** react-router resolves relative `to` values against the current pathname. */
+export function useResolvedPath(to: To): Location {
+  const { pathname } = useLocationObject();
+  const href = toHref(to);
+  return useMemo(() => {
+    const base = href.startsWith("/")
+      ? href
+      : new URL(
+          href,
+          `http://x${pathname.endsWith("/") ? pathname : `${pathname}/`}`,
+        )
+          .toString()
+          .slice("http://x".length);
+    const hashAt = base.indexOf("#");
+    const withoutHash = hashAt === -1 ? base : base.slice(0, hashAt);
+    const hash = hashAt === -1 ? "" : base.slice(hashAt);
+    const queryAt = withoutHash.indexOf("?");
+    return {
+      pathname: queryAt === -1 ? withoutHash : withoutHash.slice(0, queryAt),
+      search: queryAt === -1 ? "" : withoutHash.slice(queryAt),
+      hash,
+      state: null,
+      key: base,
+    };
+  }, [href, pathname]);
+}
+
+export function useHref(to: To): string {
+  const resolved = useResolvedPath(to);
+  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+}
+
+export type NavigationType = "POP" | "PUSH" | "REPLACE";
+
+/**
+ * Moonshine does not record how the current entry was reached, so this always
+ * reports `POP`.
+ */
+export function useNavigationType(): NavigationType {
+  return "POP";
+}

package/src/outlet.ts

@@ -0,0 +1,71 @@
+"use client";
+
+/**
+ * `<Outlet>` for nested layouts.
+ *
+ * Moonshine's router matches a flat route table, so the child element is
+ * supplied explicitly by the layout instead of being derived from a nested
+ * route config.
+ *
+ * ```tsx
+ * <OutletProvider value={<Page />}>
+ *   <Layout />
+ * </OutletProvider>
+ * ```
+ */
+import {
+  createContext,
+  createElement,
+  useContext,
+  type ReactNode,
+} from "react";
+
+export type OutletContextValue = {
+  element: ReactNode;
+  context: unknown;
+};
+
+const OutletContext = createContext<OutletContextValue>({
+  element: null,
+  context: undefined,
+});
+
+export type OutletProviderProps = {
+  /** The child route element rendered where `<Outlet />` appears. */
+  value: ReactNode;
+  /** Value returned by `useOutletContext()` inside the child. */
+  context?: unknown;
+  children?: ReactNode;
+};
+
+export function OutletProvider({
+  value,
+  context,
+  children,
+}: OutletProviderProps): ReactNode {
+  return createElement(
+    OutletContext.Provider,
+    { value: { element: value, context } },
+    children,
+  );
+}
+
+export type OutletProps = { context?: unknown };
+
+export function Outlet({ context }: OutletProps = {}): ReactNode {
+  const outlet = useContext(OutletContext);
+  if (context === undefined) return outlet.element;
+  return createElement(
+    OutletContext.Provider,
+    { value: { element: outlet.element, context } },
+    outlet.element,
+  );
+}
+
+export function useOutlet(): ReactNode {
+  return useContext(OutletContext).element;
+}
+
+export function useOutletContext<T = unknown>(): T {
+  return useContext(OutletContext).context as T;
+}

package/src/responses.ts

@@ -0,0 +1,77 @@
+/**
+ * Loader/action return helpers. These are plain `Response` builders in
+ * react-router, so they carry over unchanged.
+ *
+ * ```ts
+ * export async function loader() {
+ *   return json({ ok: true });
+ * }
+ * ```
+ */
+/** JSON response for a loader or action. */
+export function json<T>(data: T, init: ResponseInit | number = {}): Response {
+  const options = typeof init === "number" ? { status: init } : init;
+  const headers = new Headers(options.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(data), { ...options, headers });
+}
+
+/** `data()` in react-router v7 — payload plus response init, no serialisation. */
+export function data<T>(
+  value: T,
+  init: ResponseInit | number = {},
+): { type: "DataWithResponseInit"; data: T; init: ResponseInit } {
+  return {
+    type: "DataWithResponseInit",
+    data: value,
+    init: typeof init === "number" ? { status: init } : init,
+  };
+}
+
+/** 302 (or given status) redirect response. */
+export function redirect(
+  url: string,
+  init: ResponseInit | number = 302,
+): Response {
+  const options = typeof init === "number" ? { status: init } : init;
+  const headers = new Headers(options.headers);
+  headers.set("location", url);
+  return new Response(null, {
+    ...options,
+    status: options.status ?? 302,
+    headers,
+  });
+}
+
+/** 301 redirect. */
+export function redirectDocument(url: string): Response {
+  const response = redirect(url, 302);
+  response.headers.set("x-remix-reload-document", "true");
+  return response;
+}
+
+export function replace(
+  url: string,
+  init: ResponseInit | number = 302,
+): Response {
+  const response = redirect(url, init);
+  response.headers.set("x-remix-replace", "true");
+  return response;
+}
+
+export class ErrorResponse extends Error {
+  constructor(
+    readonly status: number,
+    readonly statusText: string,
+    readonly data: unknown,
+  ) {
+    super(`${status} ${statusText}`);
+    this.name = "ErrorResponse";
+  }
+}
+
+export function isRouteErrorResponse(error: unknown): error is ErrorResponse {
+  return error instanceof ErrorResponse;
+}

package/src/server.ts

@@ -0,0 +1,26 @@
+/**
+ * Server surface for react-router apps on moonshine: the loader/action
+ * response helpers plus moonshine's request handling.
+ */
+export {
+  ErrorResponse,
+  data,
+  isRouteErrorResponse,
+  json,
+  redirect,
+  redirectDocument,
+  replace,
+} from "./responses";
+
+export {
+  createMoonshineServer,
+  definePage,
+  handleMoonshineRequest,
+  resolvePage,
+  toMoonshineRequest,
+} from "@tschk/moonshine/server";
+export type {
+  MoonshinePageModule,
+  MoonshineRequest,
+  MoonshineServer,
+} from "@tschk/moonshine/server";