Update dependency @effect/language-service to ^0.78.0

2026-03-06 12:01:53 +00:00
7 changed files with 35 additions and 182 deletions
--- a/bun.lock
+++ b/bun.lock
@@ -6,7 +6,7 @@
      "name": "@effect-fc/monorepo",
      "devDependencies": {
        "@biomejs/biome": "^2.3.11",
-        "@effect/language-service": "^0.80.0",
+        "@effect/language-service": "^0.78.0",
        "@types/bun": "^1.3.6",
        "npm-check-updates": "^19.3.1",
        "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.80.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-dKMATT1fDzaCpNrICpXga7sjJBtFLpKCAoE/1MiGXI8UwcHA9rmAZ2t52JO9g/kJpERWyomkJ+rl+VFlwNIofg=="],
+    "@effect/language-service": ["@effect/language-service@0.78.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-dEYMhvhKFhikXpXjOlcByRKOU34xFeZbZcOuVTeWTQmjmZ/ZF4K3z0Ku6vL4cWKC8RRIB5di+ix18Y4f9ey5Dg=="],

    "@effect/platform": ["@effect/platform@0.94.2", "", { "dependencies": { "find-my-way-ts": "^0.1.6", "msgpackr": "^1.11.4", "multipasta": "^0.2.7" }, "peerDependencies": { "effect": "^3.19.15" } }, "sha512-85vdwpnK4oH/rJ3EuX/Gi2Hkt+K4HvXWr9bxCuqvty9hxyEcRxkJcqTesYrcVoQB6aULb1Za2B0MKoTbvffB3Q=="],

--- a/package.json
+++ b/package.json
@@ -16,7 +16,7 @@
  },
  "devDependencies": {
    "@biomejs/biome": "^2.3.11",
-    "@effect/language-service": "^0.80.0",
+    "@effect/language-service": "^0.78.0",
    "@types/bun": "^1.3.6",
    "npm-check-updates": "^19.3.1",
    "npm-sort": "^0.0.4",
--- a/packages/effect-fc/src/Async.ts
+++ b/packages/effect-fc/src/Async.ts
@@ -1,5 +1,5 @@
 /** biome-ignore-all lint/complexity/useArrowFunction: necessary for class prototypes */
-import { Effect, type Equivalence, Function, Predicate, Runtime, Scope } from "effect"
+import { Effect, Function, Predicate, Runtime, Scope } from "effect"
 import * as React from "react"
 import * as Component from "./Component.js"

@@ -7,30 +7,16 @@ import * as Component from "./Component.js"
 export const AsyncTypeId: unique symbol = Symbol.for("@effect-fc/Async/Async")
 export type AsyncTypeId = typeof AsyncTypeId

-
-/**
- * A trait for `Component`'s that allows them running asynchronous effects.
- */
 export interface Async extends AsyncPrototype, AsyncOptions {}

 export interface AsyncPrototype {
    readonly [AsyncTypeId]: AsyncTypeId
 }

-/**
- * Configuration options for `Async` components.
- */
 export interface AsyncOptions {
-    /**
-     * The default fallback React node to display while the async operation is pending.
-     * Used if no fallback is provided to the component when rendering.
-     */
    readonly defaultFallback?: React.ReactNode
 }

-/**
- * Props for `Async` components.
- */
 export type AsyncProps = Omit<React.SuspenseProps, "children">


@@ -60,52 +46,9 @@ export const AsyncPrototype: AsyncPrototype = Object.freeze({
    },
 } as const)

-/**
- * An equivalence function for comparing `AsyncProps` that ignores the `fallback` property.
- * Used by default by async components with `Memoized.memoized` applied.
- */
-export const defaultPropsEquivalence: Equivalence.Equivalence<AsyncProps> = (
-    self: Record<string, unknown>,
-    that: Record<string, unknown>,
-) => {
-    if (self === that)
-        return true
-
-    for (const key in self) {
-        if (key === "fallback")
-            continue
-        if (!(key in that) || !Object.is(self[key], that[key]))
-            return false
-    }
-
-    for (const key in that) {
-        if (key === "fallback")
-            continue
-        if (!(key in self))
-            return false
-    }
-
-    return true
-}
-

 export const isAsync = (u: unknown): u is Async => Predicate.hasProperty(u, AsyncTypeId)

-/**
- * Converts a Component into an `Async` component that supports running asynchronous effects.
- *
- * Note: The component cannot have a prop named "promise" as it's reserved for internal use.
- *
- * @param self - The component to convert to an Async component
- * @returns A new `Async` component with the same body, error, and context types as the input
- *
- * @example
- * ```ts
- * const MyAsyncComponent = MyComponent.pipe(
- *   Async.async,
- * )
- * ```
- */
 export const async = <T extends Component.Component<any, any, any, any>>(
    self: T & (
        "promise" extends keyof Component.Component.Props<T>
@@ -122,37 +65,13 @@ export const async = <T extends Component.Component<any, any, any, any>>(
    >
    & Async
 ) => Object.setPrototypeOf(
-    Object.assign(function() {}, self, { propsEquivalence: defaultPropsEquivalence }),
+    Object.assign(function() {}, self),
    Object.freeze(Object.setPrototypeOf(
        Object.assign({}, AsyncPrototype),
        Object.getPrototypeOf(self),
    )),
 )

-/**
- * Applies options to an Async component, returning a new Async component with the updated configuration.
- *
- * Supports both curried and uncurried application styles.
- *
- * @param self - The Async component to apply options to (in uncurried form)
- * @param options - The options to apply to the component
- * @returns An Async component with the applied options
- *
- * @example
- * ```ts
- * // Curried
- * const MyAsyncComponent = MyComponent.pipe(
- *   Async.async,
- *   Async.withOptions({ defaultFallback: <p>Loading...</p> }),
- * )
- *
- * // Uncurried
- * const MyAsyncComponent = Async.withOptions(
- *   Async.async(MyComponent),
- *   { defaultFallback: <p>Loading...</p> },
- * )
- * ```
- */
 export const withOptions: {
    <T extends Component.Component<any, any, any, any> & Async>(
        options: Partial<AsyncOptions>
--- a/packages/effect-fc/src/Component.ts
+++ b/packages/effect-fc/src/Component.ts
@@ -4,8 +4,8 @@ import { Context, type Duration, Effect, Equivalence, ExecutionStrategy, Exit, F
 import * as React from "react"


-export const ComponentTypeId: unique symbol = Symbol.for("@effect-fc/Component/Component")
-export type ComponentTypeId = typeof ComponentTypeId
+export const TypeId: unique symbol = Symbol.for("@effect-fc/Component/Component")
+export type TypeId = typeof TypeId

 /**
 * Represents an Effect-based React Component that integrates the Effect system with React.
@@ -13,7 +13,7 @@ export type ComponentTypeId = typeof ComponentTypeId
 export interface Component<P extends {}, A extends React.ReactNode, E, R>
 extends ComponentPrototype<P, A, R>, ComponentOptions {
    new(_: never): Record<string, never>
-    readonly [ComponentTypeId]: ComponentTypeId
+    readonly [TypeId]: TypeId
    readonly "~Props": P
    readonly "~Success": A
    readonly "~Error": E
@@ -34,7 +34,7 @@ export declare namespace Component {

 export interface ComponentPrototype<P extends {}, A extends React.ReactNode, R>
 extends Pipeable.Pipeable {
-    readonly [ComponentTypeId]: ComponentTypeId
+    readonly [TypeId]: TypeId
    readonly use: Effect.Effect<(props: P) => A, never, Exclude<R, Scope.Scope>>

    asFunctionComponent(
@@ -46,7 +46,7 @@ extends Pipeable.Pipeable {
 }

 export const ComponentPrototype: ComponentPrototype<any, any, any> = Object.freeze({
-    [ComponentTypeId]: ComponentTypeId,
+    [TypeId]: TypeId,
    ...Pipeable.Prototype,

    get use() { return use(this) },
@@ -88,7 +88,7 @@ const use = Effect.fnUntraced(function* <P extends {}, A extends React.ReactNode
        }),
        Equivalence.array(Equivalence.strict()),
    )))[0](Array.from(
-        Context.omit(...self.nonReactiveTags)(runtimeRef.current.context).unsafeMap.values()
+        Context.omit(...nonReactiveTags)(runtimeRef.current.context).unsafeMap.values()
    ))
 })

@@ -96,16 +96,10 @@ const use = Effect.fnUntraced(function* <P extends {}, A extends React.ReactNode
 export interface ComponentOptions {
    /**
     * Custom display name for the component in React DevTools and debugging utilities.
+     * Improves developer experience by providing meaningful component identification.
     */
    readonly displayName?: string

-    /**
-     * Context tags that should not trigger component remount when their values change.
-     *
-     * @default [Tracer.ParentSpan]
-     */
-    readonly nonReactiveTags: readonly Context.Tag<any, any>[]
-
    /**
     * Specifies the execution strategy for finalizers when the component unmounts or its scope closes.
     * Determines whether finalizers execute sequentially or in parallel.
@@ -125,13 +119,15 @@ export interface ComponentOptions {
 }

 export const defaultOptions: ComponentOptions = {
-    nonReactiveTags: [Tracer.ParentSpan],
    finalizerExecutionStrategy: ExecutionStrategy.sequential,
    finalizerExecutionDebounce: "100 millis",
 }


-export const isComponent = (u: unknown): u is Component<{}, React.ReactNode, unknown, unknown> => Predicate.hasProperty(u, ComponentTypeId)
+export const nonReactiveTags = [Tracer.ParentSpan] as const
+
+
+export const isComponent = (u: unknown): u is Component<{}, React.ReactNode, unknown, unknown> => Predicate.hasProperty(u, TypeId)

 export declare namespace make {
    export type Gen = {
@@ -511,7 +507,7 @@ export const makeUntraced: (
 * const MyComponentWithCustomOptions = MyComponent.pipe(
 *   Component.withOptions({
 *     finalizerExecutionStrategy: ExecutionStrategy.parallel,
- *     finalizerExecutionDebounce: "50 millis",
+ *     finalizerExecutionDebounce: "50 millis"
 *   })
 * )
 * ```
--- a/packages/effect-fc/src/ErrorObserver.ts
+++ b/packages/effect-fc/src/ErrorObserver.ts
@@ -1,20 +1,20 @@
 import { type Cause, Context, Effect, Exit, Layer, Option, Pipeable, Predicate, PubSub, type Queue, type Scope, Supervisor } from "effect"


-export const ErrorObserverTypeId: unique symbol = Symbol.for("@effect-fc/ErrorObserver/ErrorObserver")
-export type ErrorObserverTypeId = typeof ErrorObserverTypeId
+export const TypeId: unique symbol = Symbol.for("@effect-fc/ErrorObserver/ErrorObserver")
+export type TypeId = typeof TypeId

 export interface ErrorObserver<in out E = never> extends Pipeable.Pipeable {
-    readonly [ErrorObserverTypeId]: ErrorObserverTypeId
+    readonly [TypeId]: TypeId
    handle<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
    readonly subscribe: Effect.Effect<Queue.Dequeue<Cause.Cause<E>>, never, Scope.Scope>
 }

 export const ErrorObserver = <E = never>(): Context.Tag<ErrorObserver, ErrorObserver<E>> => Context.GenericTag("@effect-fc/ErrorObserver/ErrorObserver")

-export class ErrorObserverImpl<in out E = never>
+class ErrorObserverImpl<in out E = never>
 extends Pipeable.Class() implements ErrorObserver<E> {
-    readonly [ErrorObserverTypeId]: ErrorObserverTypeId = ErrorObserverTypeId
+    readonly [TypeId]: TypeId = TypeId
    readonly subscribe: Effect.Effect<Queue.Dequeue<Cause.Cause<E>>, never, Scope.Scope>

    constructor(
@@ -29,7 +29,7 @@ extends Pipeable.Class() implements ErrorObserver<E> {
    }
 }

-export class ErrorObserverSupervisorImpl extends Supervisor.AbstractSupervisor<void> {
+class ErrorObserverSupervisorImpl extends Supervisor.AbstractSupervisor<void> {
    readonly value = Effect.void
    constructor(readonly pubsub: PubSub.PubSub<Cause.Cause<never>>) {
        super()
@@ -43,7 +43,7 @@ export class ErrorObserverSupervisorImpl extends Supervisor.AbstractSupervisor<v
 }


-export const isErrorObserver = (u: unknown): u is ErrorObserver<unknown> => Predicate.hasProperty(u, ErrorObserverTypeId)
+export const isErrorObserver = (u: unknown): u is ErrorObserver<unknown> => Predicate.hasProperty(u, TypeId)

 export const layer: Layer.Layer<ErrorObserver> = Layer.unwrapEffect(Effect.map(
    PubSub.unbounded<Cause.Cause<never>>(),
--- a/packages/effect-fc/src/Memoized.ts
+++ b/packages/effect-fc/src/Memoized.ts
@@ -4,38 +4,20 @@ import * as React from "react"
 import type * as Component from "./Component.js"


-export const MemoizedTypeId: unique symbol = Symbol.for("@effect-fc/Memoized/Memoized")
-export type MemoizedTypeId = typeof MemoizedTypeId
+export const TypeId: unique symbol = Symbol.for("@effect-fc/Memoized/Memoized")
+export type TypeId = typeof TypeId

-
-/**
- * A trait for `Component`'s that uses `React.memo` to optimize re-renders based on prop equality.
- *
- * @template P The props type of the component
- */
-export interface Memoized<P> extends MemoizedPrototype, MemoizedOptions<P> {}
-
-export interface MemoizedPrototype {
-    readonly [MemoizedTypeId]: MemoizedTypeId
+export interface Memoized<P> extends MemoizedOptions<P> {
+    readonly [TypeId]: TypeId
 }

-/**
- * Configuration options for Memoized components.
- *
- * @template P The props type of the component
- */
 export interface MemoizedOptions<P> {
-    /**
-     * An optional equivalence function for comparing component props.
-     * If provided, this function is used by React.memo to determine if props have changed.
-     * Returns `true` if props are equivalent (no re-render), `false` if they differ (re-render).
-     */
    readonly propsEquivalence?: Equivalence.Equivalence<P>
 }


-export const MemoizedPrototype: MemoizedPrototype = Object.freeze({
-    [MemoizedTypeId]: MemoizedTypeId,
+export const MemoizedPrototype = Object.freeze({
+    [TypeId]: TypeId,

    transformFunctionComponent<P extends {}>(
        this: Memoized<P>,
@@ -46,21 +28,8 @@ export const MemoizedPrototype: MemoizedPrototype = Object.freeze({
 } as const)


-export const isMemoized = (u: unknown): u is Memoized<unknown> => Predicate.hasProperty(u, MemoizedTypeId)
+export const isMemoized = (u: unknown): u is Memoized<unknown> => Predicate.hasProperty(u, TypeId)

-/**
- * Converts a Component into a `Memoized` component that optimizes re-renders using `React.memo`.
- *
- * @param self - The component to convert to a Memoized component
- * @returns A new `Memoized` component with the same body, error, and context types as the input
- *
- * @example
- * ```ts
- * const MyMemoizedComponent = MyComponent.pipe(
- *   Memoized.memoized,
- * )
- * ```
- */
 export const memoized = <T extends Component.Component<any, any, any, any>>(
    self: T
 ): T & Memoized<Component.Component.Props<T>> => Object.setPrototypeOf(
@@ -71,30 +40,6 @@ export const memoized = <T extends Component.Component<any, any, any, any>>(
    )),
 )

-/**
- * Applies options to a Memoized component, returning a new Memoized component with the updated configuration.
- *
- * Supports both curried and uncurried application styles.
- *
- * @param self - The Memoized component to apply options to (in uncurried form)
- * @param options - The options to apply to the component
- * @returns A Memoized component with the applied options
- *
- * @example
- * ```ts
- * // Curried
- * const MyMemoizedComponent = MyComponent.pipe(
- *   Memoized.memoized,
- *   Memoized.withOptions({ propsEquivalence: (a, b) => a.id === b.id }),
- * )
- *
- * // Uncurried
- * const MyMemoizedComponent = Memoized.withOptions(
- *   Memoized.memoized(MyComponent),
- *   { propsEquivalence: (a, b) => a.id === b.id },
- * )
- * ```
- */
 export const withOptions: {
    <T extends Component.Component<any, any, any, any> & Memoized<any>>(
        options: Partial<MemoizedOptions<Component.Component.Props<T>>>
--- a/packages/example/src/routes/async.tsx
+++ b/packages/example/src/routes/async.tsx
@@ -1,5 +1,5 @@
 import { HttpClient } from "@effect/platform"
-import { Container, Flex, Heading, Slider, Text, TextField } from "@radix-ui/themes"
+import { Container, Flex, Heading, Slider, Text } from "@radix-ui/themes"
 import { createFileRoute } from "@tanstack/react-router"
 import { Array, Effect, flow, Option, Schema } from "effect"
 import { Async, Component, Memoized } from "effect-fc"
@@ -34,31 +34,24 @@ class AsyncFetchPostView extends Component.make("AsyncFetchPostView")(function*(
    )
 }).pipe(
    Async.async,
-    Async.withOptions({ defaultFallback: <Text>Default fallback</Text> }),
+    Async.withOptions({ defaultFallback: <Text>Loading post...</Text> }),
    Memoized.memoized,
 ) {}


 const AsyncRouteComponent = Component.make("AsyncRouteView")(function*() {
-    const [text, setText] = React.useState("Typing here should not trigger a refetch of the post")
    const [id, setId] = React.useState(1)
-
    const AsyncFetchPost = yield* AsyncFetchPostView.use

    return (
        <Container>
-            <Flex direction="column" align="stretch" gap="2">
-                <TextField.Root
-                    value={text}
-                    onChange={e => setText(e.currentTarget.value)}
-                />
-
+            <Flex direction="column" align="center" gap="2">
                <Slider
                    value={[id]}
                    onValueChange={flow(Array.head, Option.getOrThrow, setId)}
                />

-                <AsyncFetchPost id={id} fallback={<Text>Loading post...</Text>} />
+                <AsyncFetchPost id={id} />
            </Flex>
        </Container>
    )