Class EventRegistry

Hierarchy

{
    register: (
        type: string,
        handler: Effect<void>,
    ) => Effect<string, never, never>;
} & { _tag: "EventRegistry" }
- EventRegistry

Index

Constructors

constructor

new EventRegistry(
    _: {
        register: (
            type: string,
            handler: Effect<void>,
        ) => Effect<string, never, never>;
    },
): EventRegistry
Parameters
- _: {
      register: (
          type: string,
          handler: Effect<void>,
      ) => Effect<string, never, never>;
  }
Returns EventRegistry
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).constructor
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:26501

Properties

`Readonly`_tag

_tag: "EventRegistry"

Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } })._tag

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:26502

`Readonly`register

Defined in src/events.ts:32

`Static` `Readonly`_op

_op: "Tag"

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:28

`Static` `Readonly`[ChannelTypeId]

"[ChannelTypeId]": VarianceStruct<
    never,
    unknown,
    never,
    unknown,
    EventRegistry,
    unknown,
    EventRegistry,
>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Channel.d.ts:108

`Static` `Readonly`[EffectTypeId]

"[EffectTypeId]": VarianceStruct<EventRegistry, never, EventRegistry>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:194

`Static` `Optional`[ignoreSymbol]

"[ignoreSymbol]"?: TagUnifyIgnore

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:41

`Static` `Readonly`[SinkTypeId]

"[SinkTypeId]": VarianceStruct<
    EventRegistry,
    unknown,
    never,
    never,
    EventRegistry,
>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Sink.d.ts:82

`Static` `Readonly`[STMTypeId]

"[STMTypeId]": {
    _A: Covariant<EventRegistry>;
    _E: Covariant<never>;
    _R: Covariant<EventRegistry>;
}

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/STM.d.ts:136

`Static` `Readonly`[StreamTypeId]

"[StreamTypeId]": VarianceStruct<EventRegistry, never, EventRegistry>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Stream.d.ts:110

`Static` `Readonly`[TagTypeId]

"[TagTypeId]": {
_Identifier: Invariant<EventRegistry>;
_Service: Invariant<EventRegistry>;
}

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:31

`Static` `Optional`[typeSymbol]

"[typeSymbol]"?: unknown

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:39

`Static` `Optional`[unifySymbol]

"[unifySymbol]"?: TagUnify<
    Class<
        EventRegistry,
        "EventRegistry",
        {
            sync: () => {
                register: (
                    type: string,
                    handler: Effect<void>,
                ) => Effect<string, never, never>;
            };
        },
    >,
>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:40

`Static` `Readonly`Default

Default: Layer<EventRegistry, never, never>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:26509

`Static` `Readonly`Identifier

Identifier: EventRegistry

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:30

`Static` `Readonly`key

key: "EventRegistry"

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:38
Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:26507

`Static` `Readonly`make

make: (
    _: {
        register: (
            type: string,
            handler: Effect<void>,
        ) => Effect<string, never, never>;
    },
) => EventRegistry

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:26505

`Static` `Readonly`Service

Service: EventRegistry

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:29

`Static` `Optional` `Readonly`stack

stack?: string

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:37

`Static` `Readonly`use

use: <X>(
    body: (_: EventRegistry) => X,
) => [X] extends [Effect<A, E, R>]
    ? Effect<A, E, EventRegistry | R>
    : [X] extends [PromiseLike<A>]
        ? Effect<A, UnknownException, EventRegistry>
        : Effect<X, never, EventRegistry>

Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:26504

Methods

`Static`[iterator]

"[iterator]"(): EffectGenerator<Tag<EventRegistry, EventRegistry>>
Returns EffectGenerator<Tag<EventRegistry, EventRegistry>>
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).[iterator]
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Effect.d.ts:136

`Static`[NodeInspectSymbol]

"[NodeInspectSymbol]"(): unknown
Returns unknown
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).[NodeInspectSymbol]
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Inspectable.d.ts:22

`Static`context

context(self: EventRegistry): Context<EventRegistry>
Parameters
- self: EventRegistry
Returns Context<EventRegistry>
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).context
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:36

`Static`of

of(self: EventRegistry): EventRegistry
Parameters
- self: EventRegistry
Returns EventRegistry
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).of
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Context.d.ts:35

`Static`pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:9
pipe<A, B = never>(this: A, ab: (_: A) => B): B
Type Parameters
- A
- B = never
Parameters
- this: A
- ab: (_: A) => B
Returns B
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:10
pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
Type Parameters
- A
- B = never
- C = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
Returns C
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:11
pipe<A, B = never, C = never, D = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
): D
Type Parameters
- A
- B = never
- C = never
- D = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
Returns D
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:12
pipe<A, B = never, C = never, D = never, E = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
): E
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
Returns E
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:13
pipe<A, B = never, C = never, D = never, E = never, F = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
): F
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
Returns F
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:14
pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
): G
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
Returns G
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:15
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
): H
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
Returns H
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:16
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
): I
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
Returns I
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:17
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
): J
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
Returns J
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:18
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
): K
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
Returns K
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:19
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
): L
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
Returns L
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:20
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
): M
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
Returns M
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:21
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
): N
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
Returns N
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:22
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
): O
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
Returns O
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:23
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
): P
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
Returns P
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:24
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
): Q
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
Returns Q
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:25
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
): R
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
Returns R
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:26
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
): S
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
Returns S
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:27
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
): T
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
Returns T
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:28
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:29
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).pipe
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Pipeable.d.ts:30

`Static`toJSON

toJSON(): unknown
Returns unknown
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).toJSON
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Inspectable.d.ts:21

`Static`toString

toString(): string
Returns string
Inherited from Effect.Service<EventRegistry>()("EventRegistry", { sync: () => { return { register: (type: string, handler: Effect.Effect<void>) => Effect.gen(function*() { let id try { const cachedFn = yield* getCachedEventId id = yield* cachedFn(handler) } catch { id = yield* generateEventId registry.set(id, () => void Effect.runPromise(handler)) } if (!listeners.has(type)) { document.addEventListener(type, (event) => { const target = event.target as HTMLElement | null const key = target?.getAttribute(`data-${type}-event`) if (!key) return const handler = registry.get(key) if (handler) handler(event) }) listeners.add(type) } return id }) } as const } }).toString
- Defined in node_modules/.pnpm/effect@3.14.5/node_modules/effect/dist/dts/Inspectable.d.ts:20

Class EventRegistry

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns EventRegistry

Properties

Readonly_tag

Readonlyregister

Static Readonly_op

Static Readonly[ChannelTypeId]

Static Readonly[EffectTypeId]

Static Optional[ignoreSymbol]

Static Readonly[SinkTypeId]

Static Readonly[STMTypeId]

Static Readonly[StreamTypeId]

Static Readonly[TagTypeId]

Static Optional[typeSymbol]

Static Optional[unifySymbol]

Static ReadonlyDefault

Static ReadonlyIdentifier

Static Readonlykey

Static Readonlymake

Static ReadonlyService

Static Optional Readonlystack

Static Readonlyuse

Methods

Static[iterator]

Returns EffectGenerator<Tag<EventRegistry, EventRegistry>>

Static[NodeInspectSymbol]

Returns unknown

Staticcontext

Parameters

Returns Context<EventRegistry>

Staticof

Parameters

Returns EventRegistry

Staticpipe

Type Parameters

Parameters

Returns A

Type Parameters

Parameters

Returns B

Type Parameters

Parameters

Returns C

Type Parameters

Parameters

Returns D

Type Parameters

Parameters

Returns E

Type Parameters

Parameters

Returns F

Type Parameters

Parameters

Returns G

Type Parameters

Parameters

Returns H

Type Parameters

Parameters

Returns I

Type Parameters

Parameters

Returns J

Type Parameters

Parameters

Returns K

Type Parameters

Parameters

Returns L

Type Parameters

Parameters

`Readonly`_tag

`Readonly`register

`Static` `Readonly`_op

`Static` `Readonly`[ChannelTypeId]

`Static` `Readonly`[EffectTypeId]

`Static` `Optional`[ignoreSymbol]

`Static` `Readonly`[SinkTypeId]

`Static` `Readonly`[STMTypeId]

`Static` `Readonly`[StreamTypeId]

`Static` `Readonly`[TagTypeId]

`Static` `Optional`[typeSymbol]

`Static` `Optional`[unifySymbol]

`Static` `Readonly`Default

`Static` `Readonly`Identifier

`Static` `Readonly`key

`Static` `Readonly`make

`Static` `Readonly`Service

`Static` `Optional` `Readonly`stack

`Static` `Readonly`use

`Static`[iterator]

`Static`[NodeInspectSymbol]

`Static`context

`Static`of

`Static`pipe

`Static`toJSON

`Static`toString