@typed/router 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/router",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -19,16 +19,16 @@
     }
   },
   "dependencies": {
-    "@effect/data": "^0.5.0",
-    "@effect/io": "^0.10.0",
-    "@typed/context": "0.3.0",
-    "@typed/dom": "8.3.0",
-    "@typed/fx": "1.3.0",
-    "@typed/html": "3.3.0",
+    "@effect/data": "^0.7.4",
+    "@effect/io": "^0.15.1",
+    "@typed/context": "0.4.1",
+    "@typed/dom": "8.4.1",
+    "@typed/fx": "1.4.1",
+    "@typed/html": "3.4.1",
     "@typed/path": "0.1.0",
-    "@typed/route": "0.2.0"
+    "@typed/route": "0.3.0"
   },
-  "gitHead": "04cb57919fddf70d6a2df1656f64acb869c3f5e2",
+  "gitHead": "045d1a1cbd6ebed153f24f946b14fd2c638fdb4c",
   "publishConfig": {
     "access": "public"
   },

package/src/Link.ts

@@ -12,7 +12,7 @@ export function Link<R = never, E = never, R2 = never>(
   return Fx.gen(function* ($) {
     const useBase = props.useBase ?? true
     const href = useBase ? pathJoin(yield* $(getBasePath), props.href) || '/' : props.href
-    const router = yield* $(Router.get)
+    const router = yield* $(Router)
     const clickHandler = (event: MouseEvent & { currentTarget: HTMLAnchorElement }) =>
       Effect.gen(function* ($) {
         if (props.fullReload) {

package/src/RouteMatcher.ts

@@ -112,7 +112,7 @@ export function RouteMatcher<R, E>(routes: RouteMatcher<R, E>['routes']): RouteM
     ) =>
       Router.withFx((router) =>
         Fx.gen(function* ($) {
-          const { environment } = yield* $(RenderContext.get)
+          const { environment } = yield* $(RenderContext)
           // Create stable references to the route matchers
           const matchers = Array.from(routes.values()).map(
             (v) =>
@@ -138,7 +138,7 @@ export function RouteMatcher<R, E>(routes: RouteMatcher<R, E>['routes']): RouteM
             layout?: Fx.Fx<any, any, html.Renderable>,
           ): Effect.Effect<any, any, Option.Option<Fx.Fx<any, any, html.Renderable>>> =>
             Effect.gen(function* ($) {
-              const { outlet } = yield* $(Router.get)
+              const { outlet } = yield* $(Router)
               const previous = samplePreviousValues()
 
               // Update the previous values
@@ -250,6 +250,7 @@ function runRouteMatch<R, E, P extends string>(
     const params = pipe(nestedRouter.params, Fx.provideContext(env))
     const render = pipe(
       match(params as unknown as Fx.Fx<never, never, Path.ParamsOf<P>>),
+      Fx.provideContext(env),
       Router.provideFx(nestedRouter as Router),
     )
 

package/src/router.ts

@@ -66,60 +66,60 @@ export interface Router<out R = never, out E = never, in out P extends string =
   readonly provideContext: (environment: Context.Context<R>) => Router<never, E, P>
 }
 
-export const Router = Object.assign(function makeRouter<
-  R = never,
-  E = never,
-  P extends string = string,
->(
-  route: Route.Route<R, E, P>,
-  currentPath: Fx.RefSubject<string>,
-  parent: Option.Option<Router<any, any, string>> = Option.none(),
-): Router<R, E, P> {
-  const outlet = Fx.RefSubject.unsafeMake((): html.Renderable => null)
-
-  const createPath = <R2 extends Route.Route<any, any, string>, P extends Route.ParamsOf<R2>>(
-    other: R2,
-    ...[params]: [keyof P] extends [never] ? [] : [P]
-  ): Effect.Effect<
-    R,
-    E,
-    Path.PathJoin<
-      [Path.Interpolate<Route.PathOf<R>, Route.ParamsOf<R>>, Path.Interpolate<Route.PathOf<R2>, P>]
-    >
-  > =>
-    Effect.gen(function* ($) {
-      const path = yield* $(currentPath.get)
-      const baseParams = yield* $(route.match(path))
-
-      if (Option.isNone(baseParams)) {
-        return yield* $(
-          Effect.dieMessage(
-            `Can not create path when the parent can not be matched.
+export const Router = Object.assign(Context.Tag<Router>('@typed/router/Router'), {
+  make: function makeRouter<R = never, E = never, P extends string = string>(
+    route: Route.Route<R, E, P>,
+    currentPath: Fx.RefSubject<string>,
+    parent: Option.Option<Router<any, any, string>> = Option.none(),
+  ): Router<R, E, P> {
+    const outlet = Fx.RefSubject.unsafeMake((): html.Renderable => null)
+
+    const createPath = <R2 extends Route.Route<any, any, string>, P extends Route.ParamsOf<R2>>(
+      other: R2,
+      ...[params]: [keyof P] extends [never] ? [] : [P]
+    ): Effect.Effect<
+      R,
+      E,
+      Path.PathJoin<
+        [
+          Path.Interpolate<Route.PathOf<R>, Route.ParamsOf<R>>,
+          Path.Interpolate<Route.PathOf<R2>, P>,
+        ]
+      >
+    > =>
+      Effect.gen(function* ($) {
+        const path = yield* $(currentPath.get)
+        const baseParams = yield* $(route.match(path))
+
+        if (Option.isNone(baseParams)) {
+          return yield* $(
+            Effect.dieMessage(
+              `Can not create path when the parent can not be matched.
                 Parent Route: ${route.path}
                 Current Route: ${other.path}
                 Current Path: ${path}`,
-          ),
-        )
-      }
-
-      return route.concat(other).make({ ...baseParams.value, ...params } as any) as any
-    })
-
-  const router: Router<R, E, P> = {
-    route,
-    currentPath,
-    params: pipe(currentPath, Fx.switchMapEffect(route.match), Fx.compact, Fx.skipRepeats),
-    outlet,
-    createPath: createPath as Router<R, P>['createPath'],
-    define: <R2, E2, Path2 extends string>(other: Route.Route<R2, E2, Path2>) =>
-      makeRouter(route.concat(other), currentPath, Option.some(router as any)) as any,
-    provideContext: (env) => provideContext(env)(router),
-    parent,
-  }
+            ),
+          )
+        }
+
+        return route.concat(other).make({ ...baseParams.value, ...params } as any) as any
+      })
+
+    const router: Router<R, E, P> = {
+      route,
+      currentPath,
+      params: pipe(currentPath, Fx.switchMapEffect(route.match), Fx.compact, Fx.skipRepeats),
+      outlet,
+      createPath: createPath as Router<R, P>['createPath'],
+      define: <R2, E2, Path2 extends string>(other: Route.Route<R2, E2, Path2>) =>
+        makeRouter(route.concat(other), currentPath, Option.some(router as any)) as any,
+      provideContext: (env) => provideContext(env)(router),
+      parent,
+    }
 
-  return router
-},
-Context.Tag<Router>('@typed/router/Router'))
+    return router
+  },
+})
 
 export const outlet: Fx.Fx<RenderContext | Router, never, html.Renderable> = RenderContext.withFx(
   ({ environment }) =>
@@ -197,8 +197,8 @@ export const makeRouter = (
   currentPath?: Fx.RefSubject<string>,
 ): Effect.Effect<Location | History | Window | Document | Scope.Scope, never, Router> =>
   Effect.gen(function* ($) {
-    const history = yield* $(History.get)
-    const location = yield* $(Location.get)
+    const history = yield* $(History)
+    const location = yield* $(Location)
 
     if (!currentPath) {
       currentPath = Fx.RefSubject.unsafeMake(() => getCurrentPathFromLocation(location))
@@ -225,24 +225,22 @@ export const makeRouter = (
       pipe(
         currentPath,
         Fx.skipRepeats,
-        Fx.observe((path) =>
-          Effect.sync(() => {
-            if (path !== getCurrentPathFromLocation(location)) {
-              history.pushState({}, '', path)
-            }
-          }),
-        ),
+        Fx.observeSync((path) => {
+          if (path !== getCurrentPathFromLocation(location)) {
+            history.pushState({}, '', path)
+          }
+        }),
         Effect.forkScoped,
       ),
     )
 
     // Find the configured base path
-    const document = yield* $(Document.get)
+    const document = yield* $(Document)
     const base = document.querySelector('base')
     const baseHref = base ? getBasePathFromHref(base.href) : '/'
 
     // Make our base router
-    return Router(Route.Route(baseHref), currentPath) as Router
+    return Router.make(Route.Route(baseHref), currentPath) as Router
   })
 
 export const live = (
@@ -269,10 +267,11 @@ export const getBasePath = Router.with((r) => {
 })
 
 const patchHistory = Effect.gen(function* ($) {
-  const history = yield* $(History.get)
+  const history = yield* $(History)
   const historyEvents = Fx.Subject.unsafeMake<never, void>()
   const runtime = yield* $(Effect.runtime<never>())
-  const cleanup = patchHistory_(history, () => Runtime.runFork(runtime)(historyEvents.event()))
+  const runFork = Runtime.runFork(runtime)
+  const cleanup = patchHistory_(history, () => runFork(historyEvents.event()))
 
   // unpatch history upon finalization
   yield* $(Effect.addFinalizer(() => Effect.sync(cleanup)))