@livestore/utils 0.3.0-dev.1 → 0.3.0-dev.10

package/src/effect/Subscribable.ts

@@ -0,0 +1,143 @@
+// Fork of effect/Subscribable.ts which makes Subscribable yieldable
+
+/**
+ * @since 2.0.0
+ */
+
+import { Effect, Effectable, Readable, Stream } from 'effect'
+import { dual } from 'effect/Function'
+import { hasProperty } from 'effect/Predicate'
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for('effect/Subscribable')
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R>, Effect.Effect<A, E, R> {
+  readonly [TypeId]: TypeId
+  readonly changes: Stream.Stream<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+// const Proto: Omit<Subscribable<any>, 'get' | 'changes'> = {
+//   [Readable.TypeId]: Readable.TypeId,
+//   [TypeId]: TypeId,
+//   pipe() {
+//     return pipeArguments(this, arguments)
+//   },
+// }
+
+class SubscribableImpl<in out A> extends Effectable.Class<A> implements Subscribable<A> {
+  // @ts-expect-error type symbol
+  readonly [TypeId] = TypeId
+  // @ts-expect-error type symbol
+  readonly [Readable.TypeId] = Readable.TypeId
+  constructor(
+    readonly get: Effect.Effect<A>,
+    readonly changes: Stream.Stream<A>,
+  ) {
+    super()
+  }
+  // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+  commit() {
+    return this.get
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+// export const make = <A, E, R>(options: {
+//   readonly get: Effect.Effect<A, E, R>
+//   readonly changes: Stream.Stream<A, E, R>
+// }): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
+
+export const make = <A, E, R>(options: {
+  readonly get: Effect.Effect<A, E, R>
+  readonly changes: Stream.Stream<A, E, R>
+}): Subscribable<A, E, R> => new SubscribableImpl(options.get as any, options.changes as any) as Subscribable<A, E, R>
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
+} = dual(
+  2,
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
+    make({
+      get: Effect.map(self.get, f),
+      changes: Stream.map(self.changes, f),
+    }),
+)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+  ): Subscribable<B, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+  ): Subscribable<B, E | E2, R | R2> =>
+    make({
+      get: Effect.flatMap(self.get, f),
+      changes: Stream.mapEffect(self.changes, f),
+    }),
+)
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>,
+): Subscribable<A, E | E1, R | R1> =>
+  make({
+    get: Effect.flatMap(effect, (s) => s.get),
+    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes)),
+  })

package/src/effect/WebChannel.ts

@@ -9,6 +9,21 @@ export * from './WebChannel/broadcastChannelWithAck.js'
 
 export * from './WebChannel/common.js'
 
+export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgListen, MsgSend>> =>
+  Effect.gen(function* () {
+    return {
+      [WebChannelSymbol]: WebChannelSymbol,
+      send: () => Effect.void,
+      listen: Stream.never,
+      closedDeferred: yield* Deferred.make<void>(),
+      schema: {
+        listen: Schema.Any,
+        send: Schema.Any,
+      } as any,
+      supportsTransferables: false,
+    }
+  })
+
 export const broadcastChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
   channelName,
   schema: inputSchema,

package/src/effect/index.ts

@@ -49,11 +49,13 @@ export {
   TRef,
   Channel,
   Predicate,
+  // Subscribable,
   pipe,
   identity,
   GlobalValue,
   Match,
   TestServices,
+  Mailbox,
 } from 'effect'
 
 export { dual } from 'effect/Function'
@@ -63,6 +65,7 @@ export * as Stream from './Stream.js'
 export * as BucketQueue from './BucketQueue.js'
 
 export * as SubscriptionRef from './SubscriptionRef.js'
+export * as Subscribable from './Subscribable.js'
 
 export * as Logger from './Logger.js'
 

package/src/node/mod.ts

@@ -8,7 +8,8 @@ import { Config, Effect, Layer } from 'effect'
 import type { ParentSpan } from 'effect/Tracer'
 
 import { tapCauseLogPretty } from '../effect/Effect.js'
-import type { OtelTracer } from '../effect/index.js'
+import { OtelTracer } from '../effect/index.js'
+import { makeNoopTracer } from '../NoopTracer.js'
 
 // import { tapCauseLogPretty } from '../effect/Effect.js'
 
@@ -30,6 +31,16 @@ export * as ChildProcessWorker from './ChildProcessRunner/ChildProcessWorker.js'
 
 // export const OtelLiveHttp = (args: any): Layer.Layer<never> => Layer.empty
 
+export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend(() => {
+  const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, makeNoopTracer())
+
+  const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
+    Layer.provideMerge(OtelTracerLive),
+  ) as any as Layer.Layer<OtelTracer.OtelTracer>
+
+  return TracingLive
+})
+
 export const OtelLiveHttp = ({
   serviceName,
   rootSpanName,