Update dependency @effect/language-service to ^0.69.0

bun.lock

@@ -6,7 +6,7 @@
       "name": "@effect-fc/monorepo",
       "devDependencies": {
         "@biomejs/biome": "^2.3.8",
-        "@effect/language-service": "^0.71.0",
+        "@effect/language-service": "^0.69.0",
         "@types/bun": "^1.3.3",
         "npm-check-updates": "^19.1.2",
         "npm-sort": "^0.0.4",
@@ -116,7 +116,7 @@
 
     "@effect-fc/example": ["@effect-fc/example@workspace:packages/example"],
 
-    "@effect/language-service": ["@effect/language-service@0.71.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-ttfev0+RFba5j4/xp+6puRNK7qDBxduT37zuKtNN4ylZkIw2MW5eS4cCgLAXrz/T2K3gdliJ3AP/yiNYPVoOpg=="],
+    "@effect/language-service": ["@effect/language-service@0.69.1", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-i/o3I/+vJYhL6Vm8LTkdgps+BkbgFXKUT/ESq4SySGfxbfLf5+w3Oqh0EnTC7BNJ/0Hevk0H+qJeuGd+fAR7jQ=="],
 
     "@effect/platform": ["@effect/platform@0.94.1", "", { "dependencies": { "find-my-way-ts": "^0.1.6", "msgpackr": "^1.11.4", "multipasta": "^0.2.7" }, "peerDependencies": { "effect": "^3.19.14" } }, "sha512-SlL8OMTogHmMNnFLnPAHHo3ua1yrB1LNQOVQMiZsqYu9g3216xjr0gn5WoDgCxUyOdZcseegMjWJ7dhm/2vnfg=="],
 

package.json

@@ -16,7 +16,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.8",
-    "@effect/language-service": "^0.71.0",
+    "@effect/language-service": "^0.69.0",
     "@types/bun": "^1.3.3",
     "npm-check-updates": "^19.1.2",
     "npm-sort": "^0.0.4",

packages/effect-fc/src/Component.ts

@@ -8,13 +8,6 @@ import { Memoized } from "./index.js"
 export const TypeId: unique symbol = Symbol.for("@effect-fc/Component/Component")
 export type TypeId = typeof TypeId
 
-/**
- * Interface representing an Effect-based React Component.
- *
- * This is both:
- * - an Effect that produces a React function component
- * - a constructor-like object with component metadata and options
- */
 export interface Component<P extends {}, A extends React.ReactNode, E, R>
 extends
     Effect.Effect<(props: P) => A, never, Exclude<R, Scope.Scope>>,
@@ -27,6 +20,7 @@ extends
     readonly "~Error": E
     readonly "~Context": R
 
+    /** @internal */
     readonly body: (props: P) => Effect.Effect<A, E, R>
 
     /** @internal */
@@ -43,22 +37,9 @@ export declare namespace Component {
 
     export type AsComponent<T extends Component<any, any, any, any>> = Component<Props<T>, Success<T>, Error<T>, Context<T>>
 
-    /**
-     * Options that can be set on the component
-     */
     export interface Options {
-        /** Custom displayName for React DevTools and debugging */
         readonly displayName?: string
-        /**
-         * Strategy used when executing finalizers on unmount/scope close
-         * @default ExecutionStrategy.sequential
-         */
         readonly finalizerExecutionStrategy: ExecutionStrategy.ExecutionStrategy
-        /**
-         * Debounce time before executing finalizers after component unmount
-         * Helps avoid unnecessary work during fast remount/remount cycles
-         * @default "100 millis"
-         */
         readonly finalizerExecutionDebounce: Duration.DurationInput
     }
 }
@@ -337,11 +318,6 @@ export declare namespace make {
     }
 }
 
-/**
- * Creates an Effect-based React component.
- *
- * Follows the `Effect.fn` API. Supports both generator syntax (recommended) and direct Effect composition.
- */
 export const make: (
     & make.Gen
     & make.NonGen
@@ -370,12 +346,6 @@ export const make: (
     }
 }
 
-/**
- * Same as `make` but creates an untraced version (no automatic span created).
- * Useful for very low-level utilities or when you want full control over tracing.
- *
- * Follows the `Effect.fnUntraced` API.
- */
 export const makeUntraced: (
     & make.Gen
     & make.NonGen
@@ -397,9 +367,6 @@ export const makeUntraced: (
         )
 )
 
-/**
- * Creates a new component with modified options while preserving original behavior.
- */
 export const withOptions: {
     <T extends Component<any, any, any, any>>(
         options: Partial<Component.Options>
@@ -416,39 +383,6 @@ export const withOptions: {
     Object.getPrototypeOf(self),
 ))
 
-/**
- * Wraps an Effect-FC `Component` and turns it into a regular React function component
- * that serves as an **entrypoint** into an Effect-FC component hierarchy.
- *
- * This is the recommended way to connect Effect-FC components to the rest of your React app,
- * especially when using routers (TanStack Router, React Router, etc.), lazy-loaded routes,
- * or any place where a standard React component is expected.
- *
- * The runtime is obtained from the provided React Context, allowing you to:
- * - Provide dependencies once at a high level
- * - Use the same runtime across an entire route tree or feature
- *
- * @example Using TanStack Router
- * ```tsx
- * // Main
- * export const runtime = ReactRuntime.make(Layer.empty)
- * function App() {
- *   return (
- *     <ReactRuntime.Provider runtime={runtime}>
- *       <RouterProvider router={router} />
- *     </ReactRuntime.Provider>
- *   )
- * }
- *
- * // Route
- * export const Route = createFileRoute("/")({
- *   component: withRuntime(HomePage, runtime.context),
- * })
- * ```
- *
- * @param self    - The Effect-FC Component you want to render as a regular React component.
- * @param context - React Context that holds the Runtime to use for this component tree. See the `ReactRuntime` module to create one.
- */
 export const withRuntime: {
     <P extends {}, A extends React.ReactNode, E, R>(
         context: React.Context<Runtime.Runtime<R>>,

packages/effect-fc/src/Query.ts

@@ -1,4 +1,4 @@
-import { type Cause, type Context, type Duration, Effect, Equal, Fiber, identity, Option, Pipeable, Predicate, type Scope, Stream, Subscribable, SubscriptionRef } from "effect"
+import { type Cause, type Context, DateTime, type Duration, Effect, Equal, Equivalence, Fiber, HashMap, identity, Option, Pipeable, Predicate, type Scope, Stream, Subscribable, SubscriptionRef } from "effect"
 import * as QueryClient from "./QueryClient.js"
 import * as Result from "./Result.js"
 
@@ -80,7 +80,7 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
         )
     }
 
-    get interrupt(): Effect.Effect<void> {
+    get interrupt(): Effect.Effect<void, never, never> {
         return Effect.andThen(this.fiber, Option.match({
             onSome: Fiber.interrupt,
             onNone: () => Effect.void,
@@ -159,7 +159,7 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
     > {
         return Effect.andThen(this.getCacheEntry(key), Option.match({
             onSome: entry => Effect.andThen(
-                QueryClient.isQueryClientCacheEntryStale(entry),
+                QueryClient.isQueryClientCacheEntryStale(entry, this.staleTime),
                 isStale => isStale
                     ? this.start(key, Result.willRefresh(entry.result) as Result.Final<A, E, P>)
                     : Effect.succeed(Subscribable.make({
@@ -212,7 +212,7 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
             ) as Effect.Effect<Result.Final<A, E, P>>),
             Effect.tap(result => SubscriptionRef.set(this.latestFinalResult, Option.some(result))),
             Effect.tap(result => Result.isSuccess(result)
-                ? this.setCacheEntry(key, result)
+                ? this.updateCacheEntry(key, result)
                 : Effect.void
             ),
         )
@@ -225,41 +225,44 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
     getCacheEntry(
         key: K
     ): Effect.Effect<Option.Option<QueryClient.QueryClientCacheEntry>, never, QueryClient.QueryClient> {
-        return Effect.andThen(
+        return QueryClient.QueryClient.pipe(
-            Effect.all([
+            Effect.andThen(client => client.cache),
-                Effect.succeed(this.makeCacheKey(key)),
+            Effect.map(HashMap.get(this.makeCacheKey(key))),
-                QueryClient.QueryClient,
-            ]),
-            ([key, client]) => client.getCacheEntry(key),
         )
     }
 
-    setCacheEntry(
+    updateCacheEntry(
         key: K,
         result: Result.Success<A>,
     ): Effect.Effect<QueryClient.QueryClientCacheEntry, never, QueryClient.QueryClient> {
-        return Effect.andThen(
+        return Effect.Do.pipe(
-            Effect.all([
+            Effect.bind("client", () => QueryClient.QueryClient),
-                Effect.succeed(this.makeCacheKey(key)),
+            Effect.bind("now", () => DateTime.now),
-                QueryClient.QueryClient,
+            Effect.let("entry", ({ now }) => new QueryClient.QueryClientCacheEntry(result, now)),
-            ]),
+            Effect.tap(({ client, entry }) => SubscriptionRef.update(
-            ([key, client]) => client.setCacheEntry(key, result, this.staleTime),
+                client.cache,
+                HashMap.set(this.makeCacheKey(key), entry),
+            )),
+            Effect.map(({ entry }) => entry),
         )
     }
 
     get invalidateCache(): Effect.Effect<void> {
         return QueryClient.QueryClient.pipe(
-            Effect.andThen(client => client.invalidateCacheEntries(this.f as (key: Query.AnyKey) => Effect.Effect<unknown, unknown, unknown>)),
+            Effect.andThen(client => SubscriptionRef.update(
+                client.cache,
+                HashMap.filter((_, key) => !Equivalence.strict()(key.f, this.f)),
+            )),
             Effect.provide(this.context),
         )
     }
 
     invalidateCacheEntry(key: K): Effect.Effect<void> {
-        return Effect.all([
+        return QueryClient.QueryClient.pipe(
-            Effect.succeed(this.makeCacheKey(key)),
+            Effect.andThen(client => SubscriptionRef.update(
-            QueryClient.QueryClient,
+                client.cache,
-        ]).pipe(
+                HashMap.remove(this.makeCacheKey(key)),
-            Effect.andThen(([key, client]) => client.invalidateCacheEntry(key)),
+            )),
             Effect.provide(this.context),
         )
     }

packages/effect-fc/src/QueryClient.ts

@@ -1,28 +1,17 @@
-import { DateTime, Duration, Effect, Equal, Equivalence, Hash, HashMap, type Option, Pipeable, Predicate, Schedule, type Scope, type Subscribable, SubscriptionRef } from "effect"
+import { DateTime, Duration, Effect, Equal, Equivalence, Hash, HashMap, Pipeable, Predicate, type Scope, SubscriptionRef } from "effect"
 import type * as Query from "./Query.js"
 import type * as Result from "./Result.js"
 
 
-export const QueryClientServiceTypeId: unique symbol = Symbol.for("@effect-fc/QueryClient/QueryClientService")
+export const QueryClientServiceTypeId: unique symbol = Symbol.for("@effect-fc/QueryClient/QueryClientServiceTypeId")
 export type QueryClientServiceTypeId = typeof QueryClientServiceTypeId
 
 export interface QueryClientService extends Pipeable.Pipeable {
     readonly [QueryClientServiceTypeId]: QueryClientServiceTypeId
-
+    readonly cache: SubscriptionRef.SubscriptionRef<HashMap.HashMap<QueryClientCacheKey, QueryClientCacheEntry>>
-    readonly cache: Subscribable.Subscribable<HashMap.HashMap<QueryClientCacheKey, QueryClientCacheEntry>>
+    readonly gcTime: Duration.DurationInput
-    readonly cacheGcTime: Duration.DurationInput
     readonly defaultStaleTime: Duration.DurationInput
     readonly defaultRefreshOnWindowFocus: boolean
-
-    readonly run: Effect.Effect<void>
-    getCacheEntry(key: QueryClientCacheKey): Effect.Effect<Option.Option<QueryClientCacheEntry>>
-    setCacheEntry(
-        key: QueryClientCacheKey,
-        result: Result.Success<unknown>,
-        staleTime: Duration.DurationInput,
-    ): Effect.Effect<QueryClientCacheEntry>
-    invalidateCacheEntries(f: (key: Query.Query.AnyKey) => Effect.Effect<unknown, unknown, unknown>): Effect.Effect<void>
-    invalidateCacheEntry(key: QueryClientCacheKey): Effect.Effect<void>
 }
 
 export class QueryClient extends Effect.Service<QueryClient>()("@effect-fc/QueryClient/QueryClient", {
@@ -36,64 +25,20 @@ implements QueryClientService {
 
     constructor(
         readonly cache: SubscriptionRef.SubscriptionRef<HashMap.HashMap<QueryClientCacheKey, QueryClientCacheEntry>>,
-        readonly cacheGcTime: Duration.DurationInput,
+        readonly gcTime: Duration.DurationInput,
         readonly defaultStaleTime: Duration.DurationInput,
         readonly defaultRefreshOnWindowFocus: boolean,
         readonly runSemaphore: Effect.Semaphore,
     ) {
         super()
     }
-
-    get run(): Effect.Effect<void> {
-        return this.runSemaphore.withPermits(1)(Effect.repeat(
-            Effect.andThen(
-                DateTime.now,
-                now => SubscriptionRef.update(this.cache, HashMap.filter(entry =>
-                    Duration.lessThan(
-                        DateTime.distanceDuration(entry.lastAccessedAt, now),
-                        Duration.sum(entry.staleTime, this.cacheGcTime),
-                    )
-                )),
-            ),
-            Schedule.spaced("30 second"),
-        ))
-    }
-
-    getCacheEntry(key: QueryClientCacheKey): Effect.Effect<Option.Option<QueryClientCacheEntry>> {
-        return Effect.all([
-            Effect.andThen(this.cache, HashMap.get(key)),
-            DateTime.now,
-        ]).pipe(
-            Effect.map(([entry, now]) => new QueryClientCacheEntry(entry.result, entry.staleTime, entry.createdAt, now)),
-            Effect.tap(entry => SubscriptionRef.update(this.cache, HashMap.set(key, entry))),
-            Effect.option,
-        )
-    }
-
-    setCacheEntry(
-        key: QueryClientCacheKey,
-        result: Result.Success<unknown>,
-        staleTime: Duration.DurationInput,
-    ): Effect.Effect<QueryClientCacheEntry> {
-        return DateTime.now.pipe(
-            Effect.map(now => new QueryClientCacheEntry(result, staleTime, now, now)),
-            Effect.tap(entry => SubscriptionRef.update(this.cache, HashMap.set(key, entry))),
-        )
-    }
-
-    invalidateCacheEntries(f: (key: Query.Query.AnyKey) => Effect.Effect<unknown, unknown, unknown>): Effect.Effect<void> {
-        return SubscriptionRef.update(this.cache, HashMap.filter((_, key) => !Equivalence.strict()(key.f, f)))
-    }
-    invalidateCacheEntry(key: QueryClientCacheKey): Effect.Effect<void> {
-        return SubscriptionRef.update(this.cache, HashMap.remove(key))
-    }
 }
 
 export const isQueryClientService = (u: unknown): u is QueryClientService => Predicate.hasProperty(u, QueryClientServiceTypeId)
 
 export declare namespace make {
     export interface Options {
-        readonly cacheGcTime?: Duration.DurationInput
+        readonly gcTime?: Duration.DurationInput
         readonly defaultStaleTime?: Duration.DurationInput
         readonly defaultRefreshOnWindowFocus?: boolean
     }
@@ -102,20 +47,22 @@ export declare namespace make {
 export const make = Effect.fnUntraced(function* (options: make.Options = {}): Effect.fn.Return<QueryClientService> {
     return new QueryClientServiceImpl(
         yield* SubscriptionRef.make(HashMap.empty<QueryClientCacheKey, QueryClientCacheEntry>()),
-        options.cacheGcTime ?? "5 minutes",
+        options.gcTime ?? "5 minutes",
         options.defaultStaleTime ?? "0 minutes",
         options.defaultRefreshOnWindowFocus ?? true,
         yield* Effect.makeSemaphore(1),
     )
 })
 
+export const run = (_self: QueryClientService): Effect.Effect<void> => Effect.void
+
 export declare namespace service {
     export interface Options extends make.Options {}
 }
 
 export const service = (options?: service.Options): Effect.Effect<QueryClientService, never, Scope.Scope> => Effect.tap(
     make(options),
-    client => Effect.forkScoped(client.run),
+    client => Effect.forkScoped(run(client)),
 )
 
 
@@ -155,9 +102,7 @@ implements Pipeable.Pipeable {
 
     constructor(
         readonly result: Result.Success<unknown>,
-        readonly staleTime: Duration.DurationInput,
         readonly createdAt: DateTime.DateTime,
-        readonly lastAccessedAt: DateTime.DateTime,
     ) {
         super()
     }
@@ -166,8 +111,9 @@ implements Pipeable.Pipeable {
 export const isQueryClientCacheEntry = (u: unknown): u is QueryClientCacheEntry => Predicate.hasProperty(u, QueryClientCacheEntryTypeId)
 
 export const isQueryClientCacheEntryStale = (
-    self: QueryClientCacheEntry
+    self: QueryClientCacheEntry,
+    staleTime: Duration.DurationInput,
 ): Effect.Effect<boolean> => Effect.andThen(
     DateTime.now,
-    now => Duration.greaterThanOrEqualTo(DateTime.distanceDuration(self.createdAt, now), self.staleTime),
+    now => Duration.greaterThanOrEqualTo(DateTime.distanceDuration(self.createdAt, now), staleTime),
 )