@bleedingdev/modern-js-renderer-solid 0.0.0-stage → 3.9.3-ultramodern.1

package/src/router-binding/matchContext.tsx

@@ -0,0 +1,15 @@
+import type { AnyRouteMatch } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+
+export type NearestMatchContextValue = readonly [
+  routeId: Solid.Accessor<string | undefined>,
+  match: Solid.Accessor<AnyRouteMatch | undefined>,
+];
+
+const defaultNearestMatchContext: NearestMatchContextValue = [
+  () => undefined,
+  () => undefined,
+];
+
+export const nearestMatchContext =
+  Solid.createContext<NearestMatchContextValue>(defaultNearestMatchContext);

package/src/router-binding/nonRouteComponentContext.tsx

@@ -0,0 +1,23 @@
+import type { JSX } from '@solidjs/web';
+import * as Solid from 'solid-js';
+
+export type NonRouteComponent =
+  | 'pendingComponent'
+  | 'errorComponent'
+  | 'notFoundComponent';
+
+// Solid 2's `useContext` throws for a default-less context with no mounted
+// provider, so default to `null` to keep the unset read falsy instead.
+export const nonRouteComponentContext =
+  process.env.NODE_ENV !== 'production'
+    ? /* @__PURE__ */ Solid.createContext<NonRouteComponent | null>(null)
+    : undefined;
+
+export function renderInNonRouteComponentContext(
+  render: () => JSX.Element,
+  component: NonRouteComponent,
+) {
+  // In Solid 2 the context object itself is the provider component.
+  const Context = nonRouteComponentContext!;
+  return <Context value={component}>{render()}</Context>;
+}

package/src/router-binding/not-found.tsx

@@ -0,0 +1,65 @@
+import type { JSX } from '@solidjs/web';
+import type { NotFoundError } from '@tanstack/router-core';
+import { isNotFound } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+import { CatchBoundary } from './CatchBoundary';
+import { useRouter } from './useRouter';
+
+// Solid wraps non-Error throws in an Error and stores the original thrown value
+// on `cause`, so component-thrown `notFound()` needs one extra unwrapping step.
+export function getNotFound(
+  error: unknown,
+): (NotFoundError & { isNotFound: true }) | undefined {
+  if (isNotFound(error)) {
+    return error as NotFoundError & { isNotFound: true };
+  }
+
+  if (isNotFound((error as any)?.cause)) {
+    return (error as any).cause as NotFoundError & { isNotFound: true };
+  }
+
+  return undefined;
+}
+
+export function CatchNotFound(props: {
+  fallback?: (error: NotFoundError) => JSX.Element;
+  onCatch?: (error: NotFoundError) => void;
+  children: JSX.Element;
+}) {
+  const router = useRouter();
+  // TODO: Some way for the user to programmatically reset the not-found boundary?
+  const pathname = Solid.createMemo(
+    () => router.stores.location.get().pathname,
+  );
+  const status = Solid.createMemo(() => router.stores.status.get());
+
+  return (
+    <CatchBoundary
+      getResetKey={() => `not-found-${pathname()}-${status()}`}
+      onCatch={error => {
+        const notFoundError = getNotFound(error);
+
+        if (notFoundError) {
+          props.onCatch?.(notFoundError);
+        } else {
+          throw error;
+        }
+      }}
+      errorComponent={({ error }) => {
+        const notFoundError = getNotFound(error);
+
+        if (notFoundError) {
+          return props.fallback?.(notFoundError);
+        } else {
+          throw error;
+        }
+      }}
+    >
+      {props.children}
+    </CatchBoundary>
+  );
+}
+
+export function DefaultGlobalNotFound() {
+  return <p>Not Found</p>;
+}