effective-rsc 0.1.0

package/dist/client/react-dom-renderer.js

@@ -0,0 +1,101 @@
+import { jsx } from "react/jsx-runtime";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Component, StrictMode, useLayoutEffect, useState } from "react";
+import { hydrateRoot } from "react-dom/client";
+import { BrowserEffectRunner } from "./browser-effect-runner.js";
+import { BrowserRenderer } from "./browser-renderer.js";
+import { BrowserFailureScreen } from "./browser-screen.js";
+import { RouteTree } from "./route-tree.js";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class ReactDOMHydrationError extends Schema.TaggedError()('ReactDOMHydrationError', {
+    cause: Schema.Defect()
+}) {
+}
+class BrowserErrorBoundary extends Component {
+    state = {
+        _tag: 'Ready'
+    };
+    static getDerivedStateFromError() {
+        return {
+            _tag: 'Failed'
+        };
+    }
+    componentDidCatch(error, info) {
+        this.props.onError(error, info);
+    }
+    render() {
+        if (this.state._tag === 'Failed') {
+            return /*#__PURE__*/ jsx(BrowserFailureScreen, {});
+        }
+        return this.props.children;
+    }
+}
+class ReactDOMRenderer extends Context.Service()('ersc/client/ReactDOMRenderer', {
+    make: Effect.gen(function*() {
+        const browserRenderer = yield* BrowserRenderer;
+        const run = yield* BrowserEffectRunner;
+        const hydrate = Effect.fnUntraced(function*(container, initialPayload) {
+            const browserRendererReady = Promise.withResolvers();
+            const reportError = (error, info)=>{
+                void run(Effect.logError('Uncaught client render error.', error, info.componentStack));
+            };
+            function Root() {
+                const [render, setRender] = useState(()=>({
+                        _tag: 'Initial',
+                        routeTree: initialPayload.routeTree
+                    }));
+                useLayoutEffect(()=>{
+                    browserRenderer.initialize(initialPayload.routeTree, setRender);
+                    browserRendererReady.resolve();
+                }, []);
+                useLayoutEffect(()=>{
+                    browserRenderer.commit(render);
+                }, [
+                    render
+                ]);
+                return /*#__PURE__*/ jsx(BrowserErrorBoundary, {
+                    onError: reportError,
+                    children: /*#__PURE__*/ jsx(RouteTree, {
+                        root: render.routeTree
+                    })
+                });
+            }
+            yield* Effect.acquireRelease(Effect["try"]({
+                try: ()=>hydrateRoot(container, /*#__PURE__*/ jsx(StrictMode, {
+                        children: /*#__PURE__*/ jsx(Root, {})
+                    }), {
+                        formState: initialPayload.formState
+                    }),
+                catch: (cause)=>new ReactDOMHydrationError({
+                        cause
+                    })
+            }), (root)=>Effect.sync(()=>root.unmount()));
+            yield* Effect.promise(()=>browserRendererReady.promise);
+        });
+        return {
+            hydrate
+        };
+    })
+}) {
+    static layer = Layer.effect(this, this.make);
+}
+
+export { ReactDOMHydrationError, ReactDOMRenderer };
+
+//# sourceMappingURL=react-dom-renderer.js.map

package/dist/client/react-dom-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client/react-dom-renderer.js","sources":["../../src/client/react-dom-renderer.tsx"],"sourcesContent":["import { Context, Effect, Layer, Schema } from 'effect';\nimport {\n  Component,\n  type ErrorInfo,\n  type ReactNode,\n  StrictMode,\n  useLayoutEffect,\n  useState,\n} from 'react';\nimport { hydrateRoot } from 'react-dom/client';\n\nimport type { FlightPayload } from '../rsc/flight';\nimport { BrowserEffectRunner } from './browser-effect-runner';\nimport { type BrowserRender, BrowserRenderer } from './browser-renderer';\nimport { BrowserFailureScreen } from './browser-screen';\nimport { RouteTree } from './route-tree';\n\nexport class ReactDOMHydrationError extends Schema.TaggedError<ReactDOMHydrationError>()(\n  'ReactDOMHydrationError',\n  { cause: Schema.Defect() },\n) {}\n\ntype BrowserErrorBoundaryState = { readonly _tag: 'Ready' } | { readonly _tag: 'Failed' };\ntype BrowserErrorBoundaryProps = {\n  readonly children: ReactNode;\n  readonly onError: (error: unknown, info: ErrorInfo) => void;\n};\n\nclass BrowserErrorBoundary extends Component<BrowserErrorBoundaryProps, BrowserErrorBoundaryState> {\n  override readonly state: BrowserErrorBoundaryState = { _tag: 'Ready' };\n\n  static getDerivedStateFromError(): BrowserErrorBoundaryState {\n    return { _tag: 'Failed' };\n  }\n\n  override componentDidCatch(error: unknown, info: ErrorInfo) {\n    this.props.onError(error, info);\n  }\n\n  override render() {\n    if (this.state._tag === 'Failed') {\n      return <BrowserFailureScreen />;\n    }\n\n    return this.props.children;\n  }\n}\n\nexport class ReactDOMRenderer extends Context.Service<ReactDOMRenderer>()(\n  'ersc/client/ReactDOMRenderer',\n  {\n    make: Effect.gen(function* () {\n      const browserRenderer = yield* BrowserRenderer;\n      const run = yield* BrowserEffectRunner;\n\n      const hydrate = Effect.fnUntraced(function* (\n        container: Element | Document,\n        initialPayload: FlightPayload,\n      ) {\n        const browserRendererReady = Promise.withResolvers<void>();\n        const reportError = (error: unknown, info: ErrorInfo) => {\n          void run(Effect.logError('Uncaught client render error.', error, info.componentStack));\n        };\n\n        function Root() {\n          const [render, setRender] = useState<BrowserRender>(() => ({\n            _tag: 'Initial',\n            routeTree: initialPayload.routeTree,\n          }));\n\n          useLayoutEffect(() => {\n            browserRenderer.initialize(initialPayload.routeTree, setRender);\n            browserRendererReady.resolve();\n          }, []);\n\n          useLayoutEffect(() => {\n            browserRenderer.commit(render);\n          }, [render]);\n\n          return (\n            <BrowserErrorBoundary onError={reportError}>\n              <RouteTree root={render.routeTree} />\n            </BrowserErrorBoundary>\n          );\n        }\n\n        yield* Effect.acquireRelease(\n          Effect.try({\n            try: () =>\n              hydrateRoot(\n                container,\n                <StrictMode>\n                  <Root />\n                </StrictMode>,\n                { formState: initialPayload.formState },\n              ),\n            catch: (cause) => new ReactDOMHydrationError({ cause }),\n          }),\n          (root) => Effect.sync(() => root.unmount()),\n        );\n        yield* Effect.promise(() => browserRendererReady.promise);\n      });\n\n      return { hydrate };\n    }),\n  },\n) {\n  static readonly layer = Layer.effect(this, this.make);\n}\n"],"names":["Context","Effect","Layer","Schema","Component","StrictMode","useLayoutEffect","useState","hydrateRoot","BrowserEffectRunner","BrowserRenderer","BrowserFailureScreen","RouteTree","ReactDOMHydrationError","BrowserErrorBoundary","error","info","ReactDOMRenderer","browserRenderer","run","hydrate","container","initialPayload","browserRendererReady","Promise","reportError","Root","render","setRender","cause","root"],"mappings":";;;;;;;;;;;;;;;;;;AAAwD;AAQzC;AACgC;AAGe;AACW;AACjB;AACf;AAElC,MAAMa,sBAAsBA,SAASV,kBAAkB,GAC5D,0BACA;IAAE,OAAOA,aAAa;AAAG;AACxB;AAQH,MAAMW,oBAAoBA,SAASV,SAASA;IACxB,QAAmC;QAAE,MAAM;IAAQ,EAAE;IAEvE,OAAO,2BAAsD;QAC3D,OAAO;YAAE,MAAM;QAAS;IAC1B;IAES,kBAAkBW,KAAc,EAAEC,IAAe,EAAE;QAC1D,IAAI,CAAC,KAAK,CAAC,OAAO,CAACD,OAAOC;IAC5B;IAES,SAAS;QAChB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU;YAChC,qBAAO,IAACL,oBAAoBA;QAC9B;QAEA,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ;IAC5B;AACF;AAEO,MAAMM,gBAAgBA,SAASjB,eAAe,GACnD,gCACA;IACE,MAAMC,UAAU,CAAC;QACf,MAAMiB,kBAAkB,OAAOR,eAAeA;QAC9C,MAAMS,MAAM,OAAOV,mBAAmBA;QAEtC,MAAMW,UAAUnB,iBAAiB,CAAC,UAChCoB,SAA6B,EAC7BC,cAA6B;YAE7B,MAAMC,uBAAuBC,QAAQ,aAAa;YAClD,MAAMC,cAAc,CAACV,OAAgBC;gBACnC,KAAKG,IAAIlB,eAAe,CAAC,iCAAiCc,OAAOC,KAAK,cAAc;YACtF;YAEA,SAASU;gBACP,MAAM,CAACC,QAAQC,UAAU,GAAGrB,QAAQA,CAAgB,IAAO;wBACzD,MAAM;wBACN,WAAWe,eAAe,SAAS;oBACrC;gBAEAhB,eAAeA,CAAC;oBACdY,gBAAgB,UAAU,CAACI,eAAe,SAAS,EAAEM;oBACrDL,qBAAqB,OAAO;gBAC9B,GAAG,EAAE;gBAELjB,eAAeA,CAAC;oBACdY,gBAAgB,MAAM,CAACS;gBACzB,GAAG;oBAACA;iBAAO;gBAEX,qBACE,IAACb,oBAAoBA;oBAAC,SAASW;8BAC7B,kBAACb,SAASA;wBAAC,MAAMe,OAAO,SAAS;;;YAGvC;YAEA,OAAO1B,qBAAqB,CAC1BA,aAAU,CAAC;gBACT,KAAK,IACHO,WAAWA,CACTa,yBACA,IAAChB,UAAUA;kCACT,kBAACqB;wBAEH;wBAAE,WAAWJ,eAAe,SAAS;oBAAC;gBAE1C,OAAO,CAACO,QAAU,IAAIhB,sBAAsBA,CAAC;wBAAEgB;oBAAM;YACvD,IACA,CAACC,OAAS7B,WAAW,CAAC,IAAM6B,KAAK,OAAO;YAE1C,OAAO7B,cAAc,CAAC,IAAMsB,qBAAqB,OAAO;QAC1D;QAEA,OAAO;YAAEH;QAAQ;IACnB;AACF;IAEA,OAAgB,QAAQlB,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE;AACxD"}

package/dist/client/route-loader.d.ts

@@ -0,0 +1,81 @@
+import { Context, Effect, Layer } from 'effect';
+import type { RouteTreeModel } from '../rsc/route-tree.js';
+import { FlightClient, type FlightLoadError } from './flight-client.js';
+import { NavigationApi } from './navigation-api.js';
+export type RouteLoad = {
+    readonly _tag: 'Route';
+    readonly cache: (entry: NavigationHistoryEntry) => void;
+    readonly completed: Effect.Effect<void, FlightLoadError>;
+    readonly release: Effect.Effect<void>;
+    readonly resolvedUrl: URL;
+    readonly routeTree: RouteTreeModel;
+} | {
+    readonly _tag: 'Document';
+    readonly release: Effect.Effect<void>;
+};
+export type RouteLoadRequest = {
+    readonly destination: Pick<NavigationDestination, 'id' | 'url'>;
+    readonly navigationType: NavigationType;
+};
+declare const RouteLoader_base: Context.ServiceClass<RouteLoader, "ersc/client/RouteLoader", {
+    invalidate: () => void;
+    load: (request: RouteLoadRequest) => Effect.Effect<{
+        _tag: "Document";
+        release: Effect.Effect<void, never, never>;
+        completed?: never;
+        payload?: never;
+        resolvedUrl?: never;
+    } | {
+        _tag: "Route";
+        cache: (entry: NavigationHistoryEntry) => void;
+        completed: Effect.Effect<void, FlightLoadError, never>;
+        release: Effect.Effect<void, never, never>;
+        resolvedUrl: URL;
+        routeTree: RouteTreeModel;
+    }, FlightLoadError, import("effect/Scope").Scope>;
+    loadInitial: Effect.Effect<import("../rsc/flight.js").FlightPayload, FlightLoadError, never>;
+    prepareRefresh: (routeTree: RouteTreeModel) => () => void;
+}> & {
+    readonly make: Effect.Effect<{
+        invalidate: () => void;
+        load: (request: RouteLoadRequest) => Effect.Effect<{
+            _tag: "Document";
+            release: Effect.Effect<void, never, never>;
+            completed?: never;
+            payload?: never;
+            resolvedUrl?: never;
+        } | {
+            _tag: "Route";
+            cache: (entry: NavigationHistoryEntry) => void;
+            completed: Effect.Effect<void, FlightLoadError, never>;
+            release: Effect.Effect<void, never, never>;
+            resolvedUrl: URL;
+            routeTree: RouteTreeModel;
+        }, FlightLoadError, import("effect/Scope").Scope>;
+        loadInitial: Effect.Effect<import("../rsc/flight.js").FlightPayload, FlightLoadError, never>;
+        prepareRefresh: (routeTree: RouteTreeModel) => () => void;
+    }, never, FlightClient | NavigationApi | import("effect/Scope").Scope>;
+};
+export declare class RouteLoader extends RouteLoader_base {
+    static readonly layer: Layer.Layer<RouteLoader, never, FlightClient | NavigationApi>;
+    static readonly layerTest: (implementation: {
+        invalidate: () => void;
+        load?: (request: RouteLoadRequest) => Effect.Effect<{
+            _tag: "Document";
+            release: Effect.Effect<void, never, never>;
+            completed?: never;
+            payload?: never;
+            resolvedUrl?: never;
+        } | {
+            _tag: "Route";
+            cache: (entry: NavigationHistoryEntry) => void;
+            completed: Effect.Effect<void, FlightLoadError, never>;
+            release: Effect.Effect<void, never, never>;
+            resolvedUrl: URL;
+            routeTree: RouteTreeModel;
+        }, FlightLoadError, import("effect/Scope").Scope>;
+        loadInitial?: Effect.Effect<import("../rsc/flight.js").FlightPayload, FlightLoadError, never>;
+        prepareRefresh: (routeTree: RouteTreeModel) => () => void;
+    }) => Layer.Layer<RouteLoader, never, never>;
+}
+export {};

package/dist/client/route-loader.js

@@ -0,0 +1,128 @@
+import { Context, Effect, Layer, MutableRef } from "effect";
+import { FlightClient } from "./flight-client.js";
+import { NavigationApi } from "./navigation-api.js";
+
+
+
+
+
+
+
+class RouteLoader extends Context.Service()('ersc/client/RouteLoader', {
+    make: Effect.gen(function*() {
+        const flightClient = yield* FlightClient;
+        const navigationApi = yield* NavigationApi;
+        const scope = yield* Effect.scope;
+        const cacheRef = MutableRef.make(new Map());
+        const remove = (cache, entry)=>{
+            const cached = cache.get(entry.id);
+            if (cached?.entry === entry) {
+                cache.delete(entry.id);
+            }
+        };
+        const store = (cache, entry, routeTree)=>{
+            const cached = cache.get(entry.id);
+            if (cached?.entry !== entry) {
+                cached?.entry.removeEventListener('dispose', cached.onDispose);
+                const onDispose = ()=>remove(cache, entry);
+                entry.addEventListener('dispose', onDispose, {
+                    once: true
+                });
+                cache.set(entry.id, {
+                    entry,
+                    onDispose,
+                    routeTree
+                });
+                return;
+            }
+            cache.set(entry.id, {
+                ...cached,
+                routeTree
+            });
+        };
+        const clear = (cache)=>{
+            for (const cached of cache.values()){
+                cached.entry.removeEventListener('dispose', cached.onDispose);
+            }
+            cache.clear();
+        };
+        const invalidate = ()=>{
+            clear(MutableRef.get(cacheRef));
+            MutableRef.set(cacheRef, new Map());
+        };
+        const cacheRoute = (cache, routeTree)=>(entry)=>{
+                if (MutableRef.get(cacheRef) !== cache) {
+                    return;
+                }
+                store(cache, entry, routeTree);
+            };
+        const prepareRefresh = (routeTree)=>{
+            invalidate();
+            const cache = MutableRef.get(cacheRef);
+            const entry = navigationApi.getCurrentEntry();
+            return ()=>{
+                if (MutableRef.get(cacheRef) === cache && entry !== null && entry.index !== -1) {
+                    store(cache, entry, routeTree);
+                }
+            };
+        };
+        const load = Effect.fnUntraced(function*(request) {
+            const cache = MutableRef.get(cacheRef);
+            if (request.navigationType === 'traverse') {
+                const cached = cache.get(request.destination.id);
+                if (cached !== undefined) {
+                    return {
+                        _tag: 'Route',
+                        cache: ()=>undefined,
+                        completed: Effect["void"],
+                        release: Effect["void"],
+                        resolvedUrl: new URL(request.destination.url),
+                        routeTree: cached.routeTree
+                    };
+                }
+            }
+            const resource = yield* flightClient.load({
+                _tag: 'Navigation',
+                destination: new URL(request.destination.url)
+            });
+            if (resource._tag === 'Document') {
+                return resource;
+            }
+            return {
+                _tag: 'Route',
+                cache: cacheRoute(cache, resource.payload.routeTree),
+                completed: resource.completed,
+                release: resource.release,
+                resolvedUrl: resource.resolvedUrl,
+                routeTree: resource.payload.routeTree
+            };
+        });
+        const loadInitial = Effect.gen(function*() {
+            const cache = MutableRef.get(cacheRef);
+            const entry = navigationApi.getCurrentEntry();
+            const resource = yield* flightClient.loadInitial;
+            if (entry !== null) {
+                yield* resource.completed.pipe(Effect.andThen(Effect.sync(()=>{
+                    if (MutableRef.get(cacheRef) === cache && entry.index !== -1) {
+                        store(cache, entry, resource.payload.routeTree);
+                    }
+                })), Effect.forkIn(scope));
+            }
+            return resource.payload;
+        });
+        yield* Effect.addFinalizer(()=>Effect.sync(()=>clear(MutableRef.get(cacheRef))));
+        return {
+            invalidate,
+            load,
+            loadInitial,
+            prepareRefresh
+        };
+    })
+}) {
+    static layer = Layer.effect(this, this.make);
+    static layerTest = Layer.mock(this);
+}
+
+export { RouteLoader };
+
+//# sourceMappingURL=route-loader.js.map

package/dist/client/route-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client/route-loader.js","sources":["../../src/client/route-loader.ts"],"sourcesContent":["import { Context, Effect, Layer, MutableRef } from 'effect';\n\nimport type { RouteTreeModel } from '../rsc/route-tree';\nimport { FlightClient, type FlightLoadError } from './flight-client';\nimport { NavigationApi } from './navigation-api';\n\ntype CachedRoute = {\n  readonly entry: CacheHistoryEntry;\n  readonly onDispose: () => void;\n  readonly routeTree: RouteTreeModel;\n};\n\ntype CacheHistoryEntry = Pick<\n  NavigationHistoryEntry,\n  'addEventListener' | 'id' | 'index' | 'removeEventListener'\n>;\n\ntype RouteCache = Map<string, CachedRoute>;\n\nexport type RouteLoad =\n  | {\n      readonly _tag: 'Route';\n      readonly cache: (entry: NavigationHistoryEntry) => void;\n      readonly completed: Effect.Effect<void, FlightLoadError>;\n      readonly release: Effect.Effect<void>;\n      readonly resolvedUrl: URL;\n      readonly routeTree: RouteTreeModel;\n    }\n  | {\n      readonly _tag: 'Document';\n      readonly release: Effect.Effect<void>;\n    };\n\nexport type RouteLoadRequest = {\n  readonly destination: Pick<NavigationDestination, 'id' | 'url'>;\n  readonly navigationType: NavigationType;\n};\n\nexport class RouteLoader extends Context.Service<RouteLoader>()('ersc/client/RouteLoader', {\n  make: Effect.gen(function* () {\n    const flightClient = yield* FlightClient;\n    const navigationApi = yield* NavigationApi;\n    const scope = yield* Effect.scope;\n    const cacheRef = MutableRef.make<RouteCache>(new Map());\n\n    const remove = (cache: RouteCache, entry: CacheHistoryEntry) => {\n      const cached = cache.get(entry.id);\n      if (cached?.entry === entry) {\n        cache.delete(entry.id);\n      }\n    };\n\n    const store = (cache: RouteCache, entry: CacheHistoryEntry, routeTree: RouteTreeModel) => {\n      const cached = cache.get(entry.id);\n      if (cached?.entry !== entry) {\n        cached?.entry.removeEventListener('dispose', cached.onDispose);\n        const onDispose = () => remove(cache, entry);\n        entry.addEventListener('dispose', onDispose, { once: true });\n        cache.set(entry.id, { entry, onDispose, routeTree });\n        return;\n      }\n      cache.set(entry.id, { ...cached, routeTree });\n    };\n\n    const clear = (cache: RouteCache) => {\n      for (const cached of cache.values()) {\n        cached.entry.removeEventListener('dispose', cached.onDispose);\n      }\n      cache.clear();\n    };\n\n    const invalidate = () => {\n      clear(MutableRef.get(cacheRef));\n      MutableRef.set(cacheRef, new Map());\n    };\n\n    const cacheRoute =\n      (cache: RouteCache, routeTree: RouteTreeModel) => (entry: NavigationHistoryEntry) => {\n        if (MutableRef.get(cacheRef) !== cache) {\n          return;\n        }\n        store(cache, entry, routeTree);\n      };\n\n    const prepareRefresh = (routeTree: RouteTreeModel) => {\n      invalidate();\n      const cache = MutableRef.get(cacheRef);\n      const entry = navigationApi.getCurrentEntry();\n      return () => {\n        if (MutableRef.get(cacheRef) === cache && entry !== null && entry.index !== -1) {\n          store(cache, entry, routeTree);\n        }\n      };\n    };\n\n    const load = Effect.fnUntraced(function* (request: RouteLoadRequest) {\n      const cache = MutableRef.get(cacheRef);\n      if (request.navigationType === 'traverse') {\n        const cached = cache.get(request.destination.id);\n        if (cached !== undefined) {\n          return {\n            _tag: 'Route',\n            cache: () => undefined,\n            completed: Effect.void,\n            release: Effect.void,\n            resolvedUrl: new URL(request.destination.url),\n            routeTree: cached.routeTree,\n          } satisfies RouteLoad;\n        }\n      }\n\n      const resource = yield* flightClient.load({\n        _tag: 'Navigation',\n        destination: new URL(request.destination.url),\n      });\n      if (resource._tag === 'Document') {\n        return resource satisfies RouteLoad;\n      }\n      return {\n        _tag: 'Route',\n        cache: cacheRoute(cache, resource.payload.routeTree),\n        completed: resource.completed,\n        release: resource.release,\n        resolvedUrl: resource.resolvedUrl,\n        routeTree: resource.payload.routeTree,\n      } satisfies RouteLoad;\n    });\n\n    const loadInitial = Effect.gen(function* () {\n      const cache = MutableRef.get(cacheRef);\n      const entry = navigationApi.getCurrentEntry();\n      const resource = yield* flightClient.loadInitial;\n\n      if (entry !== null) {\n        yield* resource.completed.pipe(\n          Effect.andThen(\n            Effect.sync(() => {\n              if (MutableRef.get(cacheRef) === cache && entry.index !== -1) {\n                store(cache, entry, resource.payload.routeTree);\n              }\n            }),\n          ),\n          Effect.forkIn(scope),\n        );\n      }\n\n      return resource.payload;\n    });\n\n    yield* Effect.addFinalizer(() => Effect.sync(() => clear(MutableRef.get(cacheRef))));\n\n    return { invalidate, load, loadInitial, prepareRefresh };\n  }),\n}) {\n  static readonly layer = Layer.effect(this, this.make);\n\n  static readonly layerTest = Layer.mock(this);\n}\n"],"names":["Context","Effect","Layer","MutableRef","FlightClient","NavigationApi","RouteLoader","flightClient","navigationApi","scope","cacheRef","Map","remove","cache","entry","cached","store","routeTree","onDispose","clear","invalidate","cacheRoute","prepareRefresh","load","request","undefined","URL","resource","loadInitial"],"mappings":"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"}

package/dist/client/route-refresh.d.ts

@@ -0,0 +1,31 @@
+import { Context, Effect, Layer } from 'effect';
+import { BrowserEffectRunner } from './browser-effect-runner.js';
+import { BrowserRenderer } from './browser-renderer.js';
+import { NavigationApi } from './navigation-api.js';
+import { RouteLoader } from './route-loader.js';
+export type RouteRefreshTransitionType = 'hmr-refresh' | 'server-function';
+type RouteRefreshImplementation = {
+    readonly interruptCurrentRouteRefresh: Effect.Effect<void>;
+    readonly refreshCurrentRoute: (transitionType: RouteRefreshTransitionType) => Effect.Effect<void>;
+};
+declare const RouteRefresher_base: Context.ServiceClass<RouteRefresher, "ersc/client/RouteRefresher", {
+    interruptCurrentRouteRefresh: Effect.Effect<void, never, never>;
+    refreshCurrentRoute: (transitionType: RouteRefreshTransitionType) => Effect.Effect<void, never, never>;
+    replace: (replacement: RouteRefreshImplementation) => Effect.Effect<void, never, never>;
+}> & {
+    readonly make: Effect.Effect<{
+        interruptCurrentRouteRefresh: Effect.Effect<void, never, never>;
+        refreshCurrentRoute: (transitionType: RouteRefreshTransitionType) => Effect.Effect<void, never, never>;
+        replace: (replacement: RouteRefreshImplementation) => Effect.Effect<void, never, never>;
+    }, never, NavigationApi>;
+};
+export declare class RouteRefresher extends RouteRefresher_base {
+    static readonly layer: Layer.Layer<RouteRefresher, never, NavigationApi>;
+    static readonly layerTest: (implementation: {
+        interruptCurrentRouteRefresh?: Effect.Effect<void, never, never>;
+        refreshCurrentRoute?: (transitionType: RouteRefreshTransitionType) => Effect.Effect<void, never, never>;
+        replace?: (replacement: RouteRefreshImplementation) => Effect.Effect<void, never, never>;
+    }) => Layer.Layer<RouteRefresher, never, never>;
+}
+export declare const installRouteRefresh: Effect.Effect<void, never, BrowserEffectRunner | BrowserRenderer | NavigationApi | RouteLoader | RouteRefresher | import("effect/Scope").Scope>;
+export {};

package/dist/client/route-refresh.js

@@ -0,0 +1,132 @@
+import { Context, Effect, FiberMap, Layer, Ref, Schema } from "effect";
+import { addTransitionType, startTransition } from "react";
+import { BrowserEffectRunner } from "./browser-effect-runner.js";
+import { BrowserRenderer } from "./browser-renderer.js";
+import { NavigationApi } from "./navigation-api.js";
+import { isRoutedNavigation, preserveRequestedHash } from "./navigation-routing.js";
+import { RouteLoader } from "./route-loader.js";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const CurrentRouteRefreshKey = 'CurrentRouteRefresh';
+class RouteRefreshError extends Schema.TaggedError()('RouteRefreshError', {
+    cause: Schema.Defect()
+}) {
+}
+class RouteRefresher extends Context.Service()('ersc/client/RouteRefresher', {
+    make: Effect.gen(function*() {
+        const navigationApi = yield* NavigationApi;
+        const implementation = yield* Ref.make({
+            interruptCurrentRouteRefresh: Effect["void"],
+            refreshCurrentRoute: ()=>Effect.sync(navigationApi.reloadDocument)
+        });
+        const interruptCurrentRouteRefresh = Effect.gen(function*() {
+            const current = yield* Ref.get(implementation);
+            yield* current.interruptCurrentRouteRefresh;
+        });
+        const refreshCurrentRoute = Effect.fn('RouteRefresher.refreshCurrentRoute')(function*(transitionType) {
+            const current = yield* Ref.get(implementation);
+            yield* current.refreshCurrentRoute(transitionType);
+        });
+        return {
+            interruptCurrentRouteRefresh,
+            refreshCurrentRoute,
+            replace: (replacement)=>Ref.set(implementation, replacement)
+        };
+    })
+}) {
+    static layer = Layer.effect(this, this.make);
+    static layerTest = Layer.mock(this);
+}
+const installRouteRefresh = Effect.gen(function*() {
+    const browserRenderer = yield* BrowserRenderer;
+    const navigationApi = yield* NavigationApi;
+    const routeLoader = yield* RouteLoader;
+    const routeRefresher = yield* RouteRefresher;
+    const run = yield* BrowserEffectRunner;
+    const refreshes = yield* FiberMap.make();
+    const waitForNavigationIdle = Effect.suspend(()=>{
+        const transition = navigationApi.getTransition();
+        return transition === null ? Effect.succeed('Idle') : Effect.promise(()=>transition.finished.then(()=>undefined, ()=>undefined)).pipe(Effect.as('Settled'));
+    }).pipe(Effect.repeat({
+        while: (state)=>state === 'Settled'
+    }), Effect.asVoid);
+    const waitForRoutedNavigation = Effect.callback((resume)=>{
+        const onNavigate = (event)=>{
+            if (isRoutedNavigation(event)) {
+                resume(Effect["void"]);
+            }
+        };
+        const unsubscribe = navigationApi.subscribe(onNavigate);
+        return Effect.sync(unsubscribe);
+    });
+    const refreshRoute = Effect.fnUntraced(function*(transitionType) {
+        const currentEntry = navigationApi.getCurrentEntry();
+        const destination = new URL(currentEntry?.url ?? navigationApi.getCurrentUrl());
+        const resource = yield* routeLoader.load({
+            destination: {
+                id: currentEntry?.id ?? '',
+                url: destination.href
+            },
+            navigationType: 'replace'
+        });
+        if (resource._tag === 'Document') {
+            yield* resource.release;
+            yield* Effect.sync(navigationApi.reloadDocument);
+            return;
+        }
+        const resolvedDestination = preserveRequestedHash(destination, resource.resolvedUrl);
+        if (resolvedDestination.href !== destination.href) {
+            yield* resource.release;
+            yield* Effect.sync(()=>navigationApi.replaceDocument(resolvedDestination.href));
+            return;
+        }
+        const commitRefresh = routeLoader.prepareRefresh(resource.routeTree);
+        let renderCommitted;
+        yield* Effect.sync(()=>{
+            startTransition(()=>{
+                addTransitionType(transitionType);
+                renderCommitted = browserRenderer.refresh(resource.routeTree);
+            });
+        });
+        yield* Effect.all([
+            Effect.promise(()=>renderCommitted),
+            resource.completed
+        ], {
+            concurrency: 'unbounded',
+            discard: true
+        }).pipe(Effect.andThen(Effect.sync(commitRefresh)), Effect.ensuring(resource.release));
+    });
+    const refreshInReactTransition = (transitionType)=>Effect.callback((resume, signal)=>{
+            startTransition(()=>run(refreshRoute(transitionType), {
+                    signal
+                }).then(()=>resume(Effect["void"]), (cause)=>resume(Effect.fail(new RouteRefreshError({
+                        cause
+                    })))));
+        });
+    const refreshCurrentRoute = Effect.fnUntraced(function*(transitionType) {
+        routeLoader.invalidate();
+        yield* waitForNavigationIdle;
+        yield* Effect.raceFirst(refreshInReactTransition(transitionType), waitForRoutedNavigation);
+    }, Effect["catch"]((cause)=>Effect.logError('Failed to refresh the current route.', cause)));
+    yield* routeRefresher.replace({
+        interruptCurrentRouteRefresh: FiberMap.remove(refreshes, CurrentRouteRefreshKey),
+        refreshCurrentRoute: (transitionType)=>FiberMap.run(refreshes, CurrentRouteRefreshKey, refreshCurrentRoute(transitionType)).pipe(Effect.asVoid)
+    });
+});
+
+export { RouteRefresher, installRouteRefresh };
+
+//# sourceMappingURL=route-refresh.js.map

package/dist/client/route-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client/route-refresh.js","sources":["../../src/client/route-refresh.ts"],"sourcesContent":["import { Context, Effect, FiberMap, Layer, Ref, Schema } from 'effect';\nimport { addTransitionType, startTransition } from 'react';\n\nimport { BrowserEffectRunner } from './browser-effect-runner';\nimport { BrowserRenderer } from './browser-renderer';\nimport { NavigationApi } from './navigation-api';\nimport { isRoutedNavigation, preserveRequestedHash } from './navigation-routing';\nimport { RouteLoader } from './route-loader';\n\nconst CurrentRouteRefreshKey = 'CurrentRouteRefresh';\n\nclass RouteRefreshError extends Schema.TaggedError<RouteRefreshError>()('RouteRefreshError', {\n  cause: Schema.Defect(),\n}) {}\n\nexport type RouteRefreshTransitionType = 'hmr-refresh' | 'server-function';\n\ntype RouteRefreshImplementation = {\n  readonly interruptCurrentRouteRefresh: Effect.Effect<void>;\n  readonly refreshCurrentRoute: (transitionType: RouteRefreshTransitionType) => Effect.Effect<void>;\n};\n\nexport class RouteRefresher extends Context.Service<RouteRefresher>()(\n  'ersc/client/RouteRefresher',\n  {\n    make: Effect.gen(function* () {\n      const navigationApi = yield* NavigationApi;\n      const implementation = yield* Ref.make<RouteRefreshImplementation>({\n        interruptCurrentRouteRefresh: Effect.void,\n        refreshCurrentRoute: () => Effect.sync(navigationApi.reloadDocument),\n      });\n\n      const interruptCurrentRouteRefresh = Effect.gen(function* () {\n        const current = yield* Ref.get(implementation);\n        yield* current.interruptCurrentRouteRefresh;\n      });\n\n      const refreshCurrentRoute = Effect.fn('RouteRefresher.refreshCurrentRoute')(function* (\n        transitionType: RouteRefreshTransitionType,\n      ) {\n        const current = yield* Ref.get(implementation);\n        yield* current.refreshCurrentRoute(transitionType);\n      });\n\n      return {\n        interruptCurrentRouteRefresh,\n        refreshCurrentRoute,\n        replace: (replacement: RouteRefreshImplementation) => Ref.set(implementation, replacement),\n      };\n    }),\n  },\n) {\n  static readonly layer = Layer.effect(this, this.make);\n\n  static readonly layerTest = Layer.mock(this);\n}\n\nexport const installRouteRefresh = Effect.gen(function* () {\n  const browserRenderer = yield* BrowserRenderer;\n  const navigationApi = yield* NavigationApi;\n  const routeLoader = yield* RouteLoader;\n  const routeRefresher = yield* RouteRefresher;\n  const run = yield* BrowserEffectRunner;\n  const refreshes = yield* FiberMap.make<typeof CurrentRouteRefreshKey>();\n\n  const waitForNavigationIdle = Effect.suspend(() => {\n    const transition = navigationApi.getTransition();\n    return transition === null\n      ? Effect.succeed('Idle' as const)\n      : Effect.promise(() =>\n          transition.finished.then(\n            () => undefined,\n            () => undefined,\n          ),\n        ).pipe(Effect.as('Settled' as const));\n  }).pipe(Effect.repeat({ while: (state) => state === 'Settled' }), Effect.asVoid);\n\n  const waitForRoutedNavigation = Effect.callback<void>((resume) => {\n    const onNavigate = (event: NavigateEvent) => {\n      if (isRoutedNavigation(event)) {\n        resume(Effect.void);\n      }\n    };\n    const unsubscribe = navigationApi.subscribe(onNavigate);\n    return Effect.sync(unsubscribe);\n  });\n\n  const refreshRoute = Effect.fnUntraced(function* (transitionType: RouteRefreshTransitionType) {\n    const currentEntry = navigationApi.getCurrentEntry();\n    const destination = new URL(currentEntry?.url ?? navigationApi.getCurrentUrl());\n    const resource = yield* routeLoader.load({\n      destination: {\n        id: currentEntry?.id ?? '',\n        url: destination.href,\n      },\n      navigationType: 'replace',\n    });\n\n    if (resource._tag === 'Document') {\n      yield* resource.release;\n      yield* Effect.sync(navigationApi.reloadDocument);\n      return;\n    }\n\n    const resolvedDestination = preserveRequestedHash(destination, resource.resolvedUrl);\n    if (resolvedDestination.href !== destination.href) {\n      yield* resource.release;\n      yield* Effect.sync(() => navigationApi.replaceDocument(resolvedDestination.href));\n      return;\n    }\n\n    const commitRefresh = routeLoader.prepareRefresh(resource.routeTree);\n    let renderCommitted!: Promise<void>;\n    yield* Effect.sync(() => {\n      startTransition(() => {\n        addTransitionType(transitionType);\n        renderCommitted = browserRenderer.refresh(resource.routeTree);\n      });\n    });\n    yield* Effect.all([Effect.promise(() => renderCommitted), resource.completed], {\n      concurrency: 'unbounded',\n      discard: true,\n    }).pipe(Effect.andThen(Effect.sync(commitRefresh)), Effect.ensuring(resource.release));\n  });\n\n  const refreshInReactTransition = (transitionType: RouteRefreshTransitionType) =>\n    Effect.callback<void, RouteRefreshError>((resume, signal) => {\n      startTransition(() =>\n        run(refreshRoute(transitionType), { signal }).then(\n          () => resume(Effect.void),\n          (cause) => resume(Effect.fail(new RouteRefreshError({ cause }))),\n        ),\n      );\n    });\n\n  const refreshCurrentRoute = Effect.fnUntraced(\n    function* (transitionType: RouteRefreshTransitionType) {\n      routeLoader.invalidate();\n      yield* waitForNavigationIdle;\n      yield* Effect.raceFirst(refreshInReactTransition(transitionType), waitForRoutedNavigation);\n    },\n    Effect.catch((cause) => Effect.logError('Failed to refresh the current route.', cause)),\n  );\n\n  yield* routeRefresher.replace({\n    interruptCurrentRouteRefresh: FiberMap.remove(refreshes, CurrentRouteRefreshKey),\n    refreshCurrentRoute: (transitionType) =>\n      FiberMap.run(refreshes, CurrentRouteRefreshKey, refreshCurrentRoute(transitionType)).pipe(\n        Effect.asVoid,\n      ),\n  });\n});\n"],"names":["Context","Effect","FiberMap","Layer","Ref","Schema","addTransitionType","startTransition","BrowserEffectRunner","BrowserRenderer","NavigationApi","isRoutedNavigation","preserveRequestedHash","RouteLoader","CurrentRouteRefreshKey","RouteRefreshError","RouteRefresher","navigationApi","implementation","interruptCurrentRouteRefresh","current","refreshCurrentRoute","transitionType","replacement","installRouteRefresh","browserRenderer","routeLoader","routeRefresher","run","refreshes","waitForNavigationIdle","transition","undefined","state","waitForRoutedNavigation","resume","onNavigate","event","unsubscribe","refreshRoute","currentEntry","destination","URL","resource","resolvedDestination","commitRefresh","renderCommitted","refreshInReactTransition","signal","cause"],"mappings":"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"}

package/dist/client/route-tree.d.ts

@@ -0,0 +1,7 @@
+import type { RouteTreeModel } from '../rsc/route-tree.js';
+type RouteTreeProps = {
+    readonly root: RouteTreeModel;
+};
+export declare function RouteTree({ root }: RouteTreeProps): import("react").JSX.Element;
+export declare function RouteOutlet(): import("react").JSX.Element | null;
+export {};

package/dist/client/route-tree.js

@@ -0,0 +1,34 @@
+"use client"
+import { jsx } from "react/jsx-runtime";
+import { createContext, use } from "react";
+
+
+
+
+
+
+const RouteNodeContext = /*#__PURE__*/ createContext(null);
+function RouteNodeRenderer({ node }) {
+    return /*#__PURE__*/ jsx(RouteNodeContext, {
+        value: node,
+        children: node.content
+    });
+}
+function RouteTree({ root }) {
+    return /*#__PURE__*/ jsx(RouteNodeRenderer, {
+        node: root
+    });
+}
+function RouteOutlet() {
+    const node = use(RouteNodeContext);
+    if (node === null) {
+        throw new TypeError('RouteOutlet rendered outside its route node.');
+    }
+    return node.child === null ? null : /*#__PURE__*/ jsx(RouteNodeRenderer, {
+        node: node.child
+    }, node.child.id);
+}
+
+export { RouteOutlet, RouteTree };
+
+//# sourceMappingURL=route-tree.js.map

package/dist/client/route-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client/route-tree.js","sources":["../../src/client/route-tree.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, use } from 'react';\n\nimport type { RouteTreeModel } from '../rsc/route-tree';\n\ntype RouteNodeRendererProps = { readonly node: RouteTreeModel };\ntype RouteTreeProps = { readonly root: RouteTreeModel };\n\nconst RouteNodeContext = createContext<RouteTreeModel | null>(null);\n\nfunction RouteNodeRenderer({ node }: RouteNodeRendererProps) {\n  return <RouteNodeContext value={node}>{node.content}</RouteNodeContext>;\n}\n\nexport function RouteTree({ root }: RouteTreeProps) {\n  return <RouteNodeRenderer node={root} />;\n}\n\nexport function RouteOutlet() {\n  const node = use(RouteNodeContext);\n  if (node === null) {\n    throw new TypeError('RouteOutlet rendered outside its route node.');\n  }\n  return node.child === null ? null : <RouteNodeRenderer key={node.child.id} node={node.child} />;\n}\n"],"names":["createContext","use","RouteNodeContext","RouteNodeRenderer","node","RouteTree","root","RouteOutlet","TypeError"],"mappings":";;;;;;AAAa;;AAE8B;AAO3C,MAAME,gBAAgBA,iBAAGF,aAAaA,CAAwB;AAE9D,SAASG,iBAAiBA,CAAC,EAAEC,IAAI,EAA0B;IACzD,qBAAO,IAACF,gBAAgBA;QAAC,OAAOE;kBAAOA,KAAK,OAAO;;AACrD;AAEO,SAASC,SAASA,CAAC,EAAEC,IAAI,EAAkB;IAChD,qBAAO,IAACH,iBAAiBA;QAAC,MAAMG;;AAClC;AAEO,SAASC,WAAWA;IACzB,MAAMH,OAAOH,GAAGA,CAACC,gBAAgBA;IACjC,IAAIE,SAAS,MAAM;QACjB,MAAM,IAAII,UAAU;IACtB;IACA,OAAOJ,KAAK,KAAK,KAAK,OAAO,qBAAO,IAACD,iBAAiBA;QAAqB,MAAMC,KAAK,KAAK;OAA/BA,KAAK,KAAK,CAAC,EAAE;AAC3E"}

package/dist/dev/channel.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from 'effect';
+import { Rpc, RpcGroup } from 'effect/unstable/rpc';
+export declare const DevChannelPath = "/_ersc/dev";
+export declare const DevUpdate: Schema.Union<readonly [Schema.TaggedStruct<"ClientUpdate", {
+    readonly clientHash: Schema.String;
+}>, Schema.TaggedStruct<"RscUpdate", {
+    readonly clientHash: Schema.String;
+}>, Schema.TaggedStruct<"BuildFailed", {
+    readonly diagnostics: Schema.String;
+}>]>;
+export type DevUpdate = typeof DevUpdate.Type;
+export declare const DevRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"ObserveDevUpdates", Schema.Void, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"ClientUpdate", {
+    readonly clientHash: Schema.String;
+}>, Schema.TaggedStruct<"RscUpdate", {
+    readonly clientHash: Schema.String;
+}>, Schema.TaggedStruct<"BuildFailed", {
+    readonly diagnostics: Schema.String;
+}>]>, Schema.Never>, Schema.Never, never, never>>;

package/dist/dev/channel.js

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+
+
+
+
+
+const DevChannelPath = '/_ersc/dev';
+const ClientUpdate = Schema.TaggedStruct('ClientUpdate', {
+    clientHash: Schema.String
+});
+const RscUpdate = Schema.TaggedStruct('RscUpdate', {
+    clientHash: Schema.String
+});
+const BuildFailed = Schema.TaggedStruct('BuildFailed', {
+    diagnostics: Schema.String
+});
+const DevUpdate = Schema.Union([
+    ClientUpdate,
+    RscUpdate,
+    BuildFailed
+]);
+const DevRpcs = RpcGroup.make(Rpc.make('ObserveDevUpdates', {
+    success: DevUpdate,
+    stream: true
+}));
+
+export { DevChannelPath, DevRpcs, DevUpdate };
+
+//# sourceMappingURL=channel.js.map

package/dist/dev/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev/channel.js","sources":["../../src/dev/channel.ts"],"sourcesContent":["import { Schema } from 'effect';\nimport { Rpc, RpcGroup } from 'effect/unstable/rpc';\n\nexport const DevChannelPath = '/_ersc/dev';\n\nconst ClientUpdate = Schema.TaggedStruct('ClientUpdate', { clientHash: Schema.String });\n\nconst RscUpdate = Schema.TaggedStruct('RscUpdate', { clientHash: Schema.String });\n\nconst BuildFailed = Schema.TaggedStruct('BuildFailed', { diagnostics: Schema.String });\n\nexport const DevUpdate = Schema.Union([ClientUpdate, RscUpdate, BuildFailed]);\nexport type DevUpdate = typeof DevUpdate.Type;\n\nexport const DevRpcs = RpcGroup.make(\n  Rpc.make('ObserveDevUpdates', {\n    success: DevUpdate,\n    stream: true,\n  }),\n);\n"],"names":["Schema","Rpc","RpcGroup","DevChannelPath","ClientUpdate","RscUpdate","BuildFailed","DevUpdate","DevRpcs"],"mappings":";;;;;AAAgC;AACoB;AAE7C,MAAMG,cAAcA,GAAG,aAAa;AAE3C,MAAMC,YAAYA,GAAGJ,mBAAmB,CAAC,gBAAgB;IAAE,YAAYA,aAAa;AAAC;AAErF,MAAMK,SAASA,GAAGL,mBAAmB,CAAC,aAAa;IAAE,YAAYA,aAAa;AAAC;AAE/E,MAAMM,WAAWA,GAAGN,mBAAmB,CAAC,eAAe;IAAE,aAAaA,aAAa;AAAC;AAE7E,MAAMO,SAASA,GAAGP,YAAY,CAAC;IAACI,YAAYA;IAAEC,SAASA;IAAEC,WAAWA;CAAC,EAAE;AAGvE,MAAME,OAAOA,GAAGN,aAAa,CAClCD,QAAQ,CAAC,qBAAqB;IAC5B,SAASM,SAASA;IAClB,QAAQ;AACV,IACA"}

package/dist/dev/client.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from 'effect';
+import { RouteRefresher } from '../client/route-refresh.js';
+export declare const startDevClient: Effect.Effect<void, import("effect/unstable/rpc/RpcClientError").RpcClientError, RouteRefresher | import("effect/Scope").Scope>;