houdini-react 1.2.0-react.1 → 1.2.7

package/build/runtime-cjs/routing/lib/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/build/runtime-esm/client.d.ts

@@ -0,0 +1,3 @@
+import type { HoudiniClient } from '$houdini/runtime/client';
+declare const _default: HoudiniClient;
+export default _default;

package/build/runtime-esm/client.js

@@ -0,0 +1,4 @@
+var client_default = {};
+export {
+  client_default as default
+};

package/build/runtime-esm/clientPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ClientPlugin } from 'houdini';
+declare const plugin: () => ClientPlugin;
+export default plugin;

package/build/runtime-esm/clientPlugin.js

@@ -0,0 +1,17 @@
+const plugin = () => () => {
+  return {
+    beforeNetwork(ctx, { next }) {
+      next({
+        ...ctx,
+        cacheParams: {
+          ...ctx.fetchParams,
+          serverSideFallback: false
+        }
+      });
+    }
+  };
+};
+var clientPlugin_default = plugin;
+export {
+  clientPlugin_default as default
+};

package/build/runtime-esm/hooks/useDocumentHandle.d.ts

@@ -1,13 +1,13 @@
-import { DocumentStore } from '$houdini/runtime/client';
-import { type QueryArtifact, GraphQLObject, CursorHandlers, OffsetHandlers, PageInfo, FetchFn, QueryResult, DocumentArtifact } from '$houdini/runtime/lib/types';
-export declare function useDocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, observer, storeValue, }: {
+import type { DocumentStore } from '$houdini/runtime/client';
+import type { GraphQLObject, GraphQLVariables, CursorHandlers, OffsetHandlers, PageInfo, FetchFn, QueryResult, DocumentArtifact, QueryArtifact } from '$houdini/runtime/lib/types';
+export declare function useDocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, observer, storeValue, }: {
     artifact: DocumentArtifact;
     observer: DocumentStore<_Data, _Input>;
     storeValue: QueryResult<_Data, _Input>;
 }): DocumentHandle<_Artifact, _Data, _Input> & {
     fetch: FetchFn<_Data, _Input>;
 };
-export type DocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []> = {
+export type DocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables> = {
     data: _Data;
     partial: boolean;
 } & RefetchHandlers<_Artifact, _Data, _Input>;

package/build/runtime-esm/hooks/useDocumentHandle.js

@@ -1,9 +1,8 @@
 import { extractPageInfo } from "$houdini/runtime/lib/pageInfo";
 import { cursorHandlers, offsetHandlers } from "$houdini/runtime/lib/pagination";
-import {
-  ArtifactKind
-} from "$houdini/runtime/lib/types";
+import { ArtifactKind } from "$houdini/runtime/lib/types";
 import React from "react";
+import { useSession } from "../routing/components/Router";
 function useDocumentHandle({
   artifact,
   observer,
@@ -11,6 +10,7 @@ function useDocumentHandle({
 }) {
   const [forwardPending, setForwardPending] = React.useState(false);
   const [backwardPending, setBackwardPending] = React.useState(false);
+  const session = useSession();
   return React.useMemo(() => {
     const wrapLoad = (setLoading, fn) => {
       return async (value) => {
@@ -20,7 +20,10 @@ function useDocumentHandle({
         return result;
       };
     };
-    const fetchQuery = (args) => observer.send(args);
+    const fetchQuery = (args) => observer.send({
+      ...args,
+      session
+    });
     if (artifact.kind !== ArtifactKind.Query || !artifact.refetch?.paginated) {
       return {
         data: storeValue.data,
@@ -28,13 +31,11 @@ function useDocumentHandle({
         partial: storeValue.partial
       };
     }
-    const getSession = async () => ({});
     if (artifact.refetch.method === "cursor") {
       const handlers = cursorHandlers({
         artifact,
         getState: () => storeValue.data,
         getVariables: () => storeValue.variables,
-        storeName: artifact.name,
         fetch: fetchQuery,
         fetchUpdate: (args, updates) => {
           return observer.send({
@@ -43,10 +44,11 @@ function useDocumentHandle({
               disableSubscriptions: true,
               applyUpdates: updates,
               ...args?.cacheParams
-            }
+            },
+            session
           });
         },
-        getSession
+        getSession: async () => session
       });
       return {
         data: storeValue.data,
@@ -76,7 +78,7 @@ function useDocumentHandle({
             }
           });
         },
-        getSession: async () => ({})
+        getSession: async () => session
       });
       return {
         data: storeValue.data,
@@ -92,7 +94,7 @@ function useDocumentHandle({
       refetch: fetchQuery,
       partial: storeValue.partial
     };
-  }, [artifact, observer, storeValue, true, true]);
+  }, [artifact, observer, session, storeValue, true, true]);
 }
 export {
   useDocumentHandle

package/build/runtime-esm/hooks/useDocumentStore.d.ts

@@ -1,10 +1,11 @@
-import type { DocumentArtifact, QueryResult } from '$houdini/lib/types';
+import type { DocumentArtifact, GraphQLVariables, QueryResult } from '$houdini/lib/types';
 import type { DocumentStore, ObserveParams } from '$houdini/runtime/client';
-import { GraphQLObject } from 'houdini';
-export type UseDocumentStoreParams<_Artifact extends DocumentArtifact, _Data extends GraphQLObject> = {
+import type { GraphQLObject } from 'houdini';
+export type UseDocumentStoreParams<_Artifact extends DocumentArtifact, _Data extends GraphQLObject, _Input extends GraphQLVariables> = {
     artifact: _Artifact;
-} & Partial<ObserveParams<_Data>>;
-export declare function useDocumentStore<_Data extends GraphQLObject = GraphQLObject, _Input extends {} = {}, _Artifact extends DocumentArtifact = DocumentArtifact>({ artifact, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data>): [
+    observer?: DocumentStore<_Data, _Input>;
+} & Partial<ObserveParams<_Data, DocumentArtifact, _Input>>;
+export declare function useDocumentStore<_Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables, _Artifact extends DocumentArtifact = DocumentArtifact>({ artifact, observer: obs, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data, _Input>): [
     QueryResult<_Data, _Input>,
     DocumentStore<_Data, _Input>,
     (store: DocumentStore<_Data, _Input>) => void

package/build/runtime-esm/hooks/useDocumentStore.js

@@ -1,14 +1,15 @@
 import * as React from "react";
-import { useHoudiniClient } from "./useHoudiniClient";
+import { useClient } from "../routing";
 import { useIsMountedRef } from "./useIsMounted";
 function useDocumentStore({
   artifact,
+  observer: obs,
   ...observeParams
 }) {
-  const client = useHoudiniClient();
+  const client = useClient();
   const isMountedRef = useIsMountedRef();
   let [observer, setObserver] = React.useState(
-    () => client.observe({
+    () => obs ?? client.observe({
       artifact,
       ...observeParams
     })
@@ -25,7 +26,11 @@ function useDocumentStore({
     },
     [observer]
   );
-  const storeValue = React.useSyncExternalStore(subscribe, () => box.current);
+  const storeValue = React.useSyncExternalStore(
+    subscribe,
+    () => box.current,
+    () => box.current
+  );
   return [storeValue, observer, setObserver];
 }
 export {

package/build/runtime-esm/hooks/useDocumentSubscription.d.ts

@@ -1,9 +1,10 @@
-import type { DocumentArtifact, QueryResult } from '$houdini/lib/types';
+import type { DocumentArtifact, GraphQLVariables, QueryResult } from '$houdini/lib/types';
 import type { DocumentStore, SendParams } from '$houdini/runtime/client';
-import { GraphQLObject } from 'houdini';
+import type { GraphQLObject } from 'houdini';
 import { type UseDocumentStoreParams } from './useDocumentStore';
-export declare function useDocumentSubscription<_Artifact extends DocumentArtifact = DocumentArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = {}>({ artifact, variables, send, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data> & {
+export declare function useDocumentSubscription<_Artifact extends DocumentArtifact = DocumentArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables>({ artifact, variables, send, disabled, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data, _Input> & {
     variables: _Input;
+    disabled?: boolean;
     send?: Partial<SendParams>;
 }): [
     QueryResult<_Data, _Input> & {

package/build/runtime-esm/hooks/useDocumentSubscription.js

@@ -1,26 +1,33 @@
+import { useSession } from "../routing/components/Router";
 import useDeepCompareEffect from "./useDeepCompareEffect";
 import { useDocumentStore } from "./useDocumentStore";
 function useDocumentSubscription({
   artifact,
   variables,
   send,
+  disabled,
   ...observeParams
 }) {
   const [storeValue, observer, setObserver] = useDocumentStore({
     artifact,
     ...observeParams
   });
+  const session = useSession();
   useDeepCompareEffect(() => {
-    observer.send({
-      variables,
-      session: {},
-      metadata: {},
-      ...send
-    });
+    if (!disabled) {
+      observer.send({
+        variables,
+        session,
+        metadata: {},
+        ...send
+      });
+    }
     return () => {
-      observer.cleanup();
+      if (!disabled) {
+        observer.cleanup();
+      }
     };
-  }, [observer, variables ?? {}, send ?? {}]);
+  }, [disabled, session, observer, variables ?? {}, send ?? {}]);
   return [
     {
       parent: send?.stuff?.parentID,

package/build/runtime-esm/hooks/useFragment.d.ts

@@ -1,6 +1,6 @@
 import { fragmentKey } from '$houdini/runtime/lib/types';
-import type { GraphQLObject, FragmentArtifact } from '$houdini/runtime/lib/types';
-export declare function useFragment<_Data extends GraphQLObject, _ReferenceType extends {}, _Input extends {} = {}>(reference: _Data | {
+import type { GraphQLObject, GraphQLVariables, FragmentArtifact } from '$houdini/runtime/lib/types';
+export declare function useFragment<_Data extends GraphQLObject, _ReferenceType extends {}, _Input extends GraphQLVariables = GraphQLVariables>(reference: _Data | {
     [fragmentKey]: _ReferenceType;
 } | null, document: {
     artifact: FragmentArtifact;
@@ -12,4 +12,5 @@ export declare function fragmentReference<_Data extends GraphQLObject, _Input, _
 }): {
     variables: _Input;
     parent: string;
+    loading: boolean;
 };

package/build/runtime-esm/hooks/useFragment.js

@@ -5,7 +5,7 @@ import * as React from "react";
 import { useDeepCompareMemoize } from "./useDeepCompareEffect";
 import { useDocumentSubscription } from "./useDocumentSubscription";
 function useFragment(reference, document) {
-  const { parent, variables } = fragmentReference(
+  const { parent, variables, loading } = fragmentReference(
     reference,
     document
   );
@@ -14,20 +14,21 @@ function useFragment(reference, document) {
     cachedValue = cache.read({
       selection: document.artifact.selection,
       parent,
-      variables
+      variables,
+      loading
     }).data;
   }
-  const observeParams = {
+  const [storeValue] = useDocumentSubscription({
     artifact: document.artifact,
     variables,
     initialValue: cachedValue,
+    disabled: loading,
     send: {
       stuff: {
         parentID: parent
       }
     }
-  };
-  const [storeValue] = useDocumentSubscription(observeParams);
+  });
   const lastReference = React.useRef(null);
   return React.useMemo(() => {
     const parentChange = storeValue.parent !== parent || !deepEquals({ parent, variables }, lastReference.current);
@@ -47,14 +48,15 @@ function useFragment(reference, document) {
   ]);
 }
 function fragmentReference(reference, document) {
-  const { variables, parent } = reference?.[fragmentKey]?.[document.artifact.name] ?? {};
+  const { variables, parent } = reference?.[fragmentKey]?.values?.[document.artifact.name] ?? {};
   if (reference && fragmentKey in reference && (!variables || !parent)) {
     console.warn(
       `\u26A0\uFE0F Parent does not contain the information for this fragment. Something is wrong.
 Please ensure that you have passed a record that has ${document.artifact.name} mixed into it.`
     );
   }
-  return { variables, parent };
+  const loading = Boolean(reference?.[fragmentKey]?.loading);
+  return { variables, parent, loading };
 }
 export {
   fragmentReference,

package/build/runtime-esm/hooks/useFragmentHandle.d.ts

@@ -1,7 +1,6 @@
-import type { GraphQLObject, FragmentArtifact, QueryArtifact } from '$houdini/runtime/lib/types';
-import { fragmentKey } from '$houdini/runtime/lib/types';
+import type { GraphQLObject, FragmentArtifact, QueryArtifact, fragmentKey, GraphQLVariables } from '$houdini/runtime/lib/types';
 import { type DocumentHandle } from './useDocumentHandle';
-export declare function useFragmentHandle<_Artifact extends FragmentArtifact, _Data extends GraphQLObject, _ReferenceType extends {}, _PaginationArtifact extends QueryArtifact, _Input extends {} = {}>(reference: _Data | {
+export declare function useFragmentHandle<_Artifact extends FragmentArtifact, _Data extends GraphQLObject, _ReferenceType extends {}, _PaginationArtifact extends QueryArtifact, _Input extends GraphQLVariables = GraphQLVariables>(reference: _Data | {
     [fragmentKey]: _ReferenceType;
 } | null, document: {
     artifact: FragmentArtifact;

package/build/runtime-esm/hooks/useMutation.d.ts

@@ -1,10 +1,10 @@
-import type { MutationArtifact, GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
+import type { MutationArtifact, GraphQLObject, QueryResult, GraphQLVariables } from '$houdini/runtime/lib/types';
 export type MutationHandler<_Result, _Input, _Optimistic extends GraphQLObject> = (args: {
     variables: _Input;
     metadata?: App.Metadata;
     fetch?: typeof globalThis.fetch;
     optimisticResponse?: _Optimistic;
 }) => Promise<QueryResult<_Result, _Input>>;
-export declare function useMutation<_Result extends GraphQLObject, _Input extends {}, _Optimistic extends GraphQLObject>({ artifact, }: {
+export declare function useMutation<_Result extends GraphQLObject, _Input extends GraphQLVariables, _Optimistic extends GraphQLObject>({ artifact, }: {
     artifact: MutationArtifact;
 }): [boolean, MutationHandler<_Result, _Input, _Optimistic>];

package/build/runtime-esm/hooks/useMutation.js

@@ -1,9 +1,11 @@
+import { useSession } from "../routing/components/Router";
 import { useDocumentStore } from "./useDocumentStore";
 function useMutation({
   artifact
 }) {
   const [storeValue, observer] = useDocumentStore({ artifact });
   const pending = storeValue.fetching;
+  const session = useSession();
   const mutate = ({
     metadata,
     fetch,
@@ -12,7 +14,7 @@ function useMutation({
   }) => observer.send({
     variables,
     metadata,
-    session: {},
+    session,
     stuff: {
       ...mutationConfig
     }

package/build/runtime-esm/hooks/useQuery.d.ts

@@ -1,5 +1,5 @@
-import { type QueryArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
-import { UseQueryConfig } from './useQueryHandle';
-export declare function useQuery<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []>(document: {
+import type { GraphQLVariables, GraphQLObject, QueryArtifact } from '$houdini/runtime/lib/types';
+import type { UseQueryConfig } from './useQueryHandle';
+export declare function useQuery<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables>(document: {
     artifact: QueryArtifact;
 }, variables?: any, config?: UseQueryConfig): _Data;

package/build/runtime-esm/hooks/useQueryHandle.d.ts

@@ -1,6 +1,6 @@
-import { type QueryArtifact, GraphQLObject, CachePolicies } from '$houdini/runtime/lib/types';
-import { DocumentHandle } from './useDocumentHandle';
-export declare function useQueryHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []>({ artifact }: {
+import type { GraphQLObject, CachePolicies, QueryArtifact, GraphQLVariables } from '$houdini/runtime/lib/types';
+import type { DocumentHandle } from './useDocumentHandle';
+export declare function useQueryHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables>({ artifact }: {
     artifact: QueryArtifact;
 }, variables?: any, config?: UseQueryConfig): DocumentHandle<_Artifact, _Data, _Input>;
 export type UseQueryConfig = {

package/build/runtime-esm/hooks/useQueryHandle.js

@@ -1,13 +1,13 @@
+import { createLRUCache } from "$houdini/runtime/lib/lru";
 import React from "react";
-import { createCache } from "../lib/cache";
+import { useClient } from "../routing";
 import { useDocumentHandle } from "./useDocumentHandle";
-import { useHoudiniClient } from "./useHoudiniClient";
 import { useIsMountedRef } from "./useIsMounted";
-const promiseCache = createCache();
+const promiseCache = createLRUCache();
 function useQueryHandle({ artifact }, variables = null, config = {}) {
   const identifier = queryIdentifier({ artifact, variables, config });
   const suspenseValue = promiseCache.get(identifier);
-  const client = useHoudiniClient();
+  const client = useClient();
   const isMountedRef = useIsMountedRef();
   let [observer] = React.useState(
     client.observe({

package/build/runtime-esm/hooks/useSubscription.d.ts

@@ -1,4 +1,4 @@
-import { SubscriptionArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
-export declare function useSubscription<_Result extends GraphQLObject, _Input extends {}>(document: {
+import type { SubscriptionArtifact, GraphQLObject, GraphQLVariables } from '$houdini/runtime/lib/types';
+export declare function useSubscription<_Result extends GraphQLObject, _Input extends GraphQLVariables>(document: {
     artifact: SubscriptionArtifact;
 }, variables: _Input): import("houdini").GraphQLObject | null;

package/build/runtime-esm/hooks/useSubscriptionHandle.d.ts

@@ -1,5 +1,5 @@
-import { SubscriptionArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
-export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends {} | null> = {
+import type { SubscriptionArtifact, GraphQLObject, GraphQLVariables } from '$houdini/runtime/lib/types';
+export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends GraphQLVariables> = {
     data: _Result | null;
     errors: {
         message: string;
@@ -11,7 +11,7 @@ export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends {}
     unlisten: () => void;
     fetching: boolean;
 };
-export declare function useSubscriptionHandle<_Result extends GraphQLObject, _Input extends {}>({ artifact }: {
+export declare function useSubscriptionHandle<_Result extends GraphQLObject, _Input extends GraphQLVariables>({ artifact }: {
     artifact: SubscriptionArtifact;
 }, variables: _Input): {
     data: import("houdini").GraphQLObject | null;

package/build/runtime-esm/index.d.ts

@@ -1,2 +1,31 @@
+import type { Cache } from '$houdini/runtime/cache/cache';
+import { DocumentStore } from '$houdini/runtime/client';
+import { LRUCache } from '$houdini/runtime/lib/lru';
+import { GraphQLObject, GraphQLVariables, QueryArtifact } from '$houdini/runtime/lib/types';
+import React from 'react';
+import { PendingCache } from './routing/components/Router';
+import { SuspenseCache } from './routing/lib/cache';
 export * from './hooks';
-export { HoudiniProvider } from './context';
+export * from './routing';
+export declare function Router({ cache, intialURL, artifact_cache, component_cache, data_cache, pending_cache, last_variables, loaded_queries, loaded_artifacts, session, }: {
+    intialURL: string;
+    cache: Cache;
+    loaded_queries?: Record<string, {
+        data: GraphQLObject;
+        variables: GraphQLVariables;
+    }>;
+    loaded_artifacts?: Record<string, QueryArtifact>;
+    session?: App.Session;
+} & RouterCache): JSX.Element;
+type RouterCache = {
+    artifact_cache: SuspenseCache<QueryArtifact>;
+    component_cache: SuspenseCache<(props: any) => React.ReactElement>;
+    data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>;
+    last_variables: LRUCache<GraphQLVariables>;
+    pending_cache: PendingCache;
+};
+export declare function router_cache({ pending_queries, artifacts, components, }?: {
+    pending_queries?: string[];
+    artifacts?: Record<string, QueryArtifact>;
+    components?: Record<string, (props: any) => React.ReactElement>;
+}): RouterCache;

package/build/runtime-esm/index.js

@@ -1,5 +1,84 @@
+import React from "react";
+import client from "./client";
+import manifest from "./manifest";
+import { Router as RouterImpl, RouterContextProvider } from "./routing";
+import { suspense_cache } from "./routing/lib/cache";
 export * from "./hooks";
-import { HoudiniProvider } from "./context";
+export * from "./routing";
+function Router({
+  cache,
+  intialURL,
+  artifact_cache,
+  component_cache,
+  data_cache,
+  pending_cache,
+  last_variables,
+  loaded_queries,
+  loaded_artifacts,
+  session
+}) {
+  return /* @__PURE__ */ React.createElement(
+    RouterContextProvider,
+    {
+      client,
+      cache,
+      artifact_cache,
+      component_cache,
+      data_cache,
+      pending_cache,
+      last_variables,
+      session
+    },
+    /* @__PURE__ */ React.createElement(
+      RouterImpl,
+      {
+        intialURL,
+        manifest,
+        loaded_queries,
+        loaded_artifacts
+      }
+    )
+  );
+}
+function router_cache({
+  pending_queries = [],
+  artifacts = {},
+  components = {}
+} = {}) {
+  const result = {
+    artifact_cache: suspense_cache(),
+    component_cache: suspense_cache(),
+    data_cache: suspense_cache(),
+    pending_cache: suspense_cache(),
+    last_variables: suspense_cache()
+  };
+  for (const query of pending_queries) {
+    result.pending_cache.set(query, signal_promise());
+  }
+  for (const [name, artifact] of Object.entries(artifacts)) {
+    result.artifact_cache.set(name, artifact);
+  }
+  for (const [name, component] of Object.entries(components)) {
+    result.component_cache.set(name, component);
+  }
+  return result;
+}
+function signal_promise() {
+  let resolve = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    ...promise,
+    resolve,
+    reject
+  };
+}
 export {
-  HoudiniProvider
+  Router,
+  router_cache
 };

package/build/runtime-esm/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { RouterManifest } from './routing';
+declare const manifest: RouterManifest;
+export default manifest;

package/build/runtime-esm/manifest.js

@@ -0,0 +1,5 @@
+const manifest = {};
+var manifest_default = manifest;
+export {
+  manifest_default as default
+};

package/build/runtime-esm/routing/components/Link.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function Link({ href, children, style, ...props }: {
+    href: string;
+    children: React.ReactNode;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;

package/build/runtime-esm/routing/components/Link.js

@@ -0,0 +1,21 @@
+import React, { useTransition } from "react";
+import { useNavigationContext } from "./Router";
+function Link({
+  href,
+  children,
+  style,
+  ...props
+}) {
+  const { goto } = useNavigationContext();
+  const [pending, startTransition] = useTransition();
+  const click = (e) => {
+    e.preventDefault();
+    startTransition(() => {
+      goto(href);
+    });
+  };
+  return /* @__PURE__ */ React.createElement("a", { href, onClick: click, style, ...props }, children);
+}
+export {
+  Link
+};