@typed/async-data 0.13.0 → 1.0.0-beta.0

package/src/LazyRef.ts

@@ -1,87 +0,0 @@
-import * as L from '@typed/lazy-ref'
-import { Effect, Layer } from 'effect'
-import { dual } from 'effect/Function'
-import type { Scope } from 'effect/Scope'
-import * as AsyncData from './AsyncData.js'
-
-export interface LazyRef<A, E = never, R = never> extends L.LazyRef<AsyncData.AsyncData<A, E>, never, R> {}
-
-export type LazyRefOptions<A, E = never> = L.LazyRefOptions<AsyncData.AsyncData<A, E>> & {
-  readonly drop?: number
-  readonly take?: number
-}
-
-export interface Tagged<Self, Id extends string, A, E = never>
-  extends L.TaggedClass<Self, Id, AsyncData.AsyncData<A, E>, never> {
-  // Layers
-
-  readonly Default: Layer.Layer<Self>
-  readonly fromEffect: <R>(
-    effect: Effect.Effect<A, E, R>,
-  ) => Layer.Layer<Self, never, Exclude<R, Scope>>
-
-  // Effects
-  readonly run: <R>(
-    effect: Effect.Effect<A, E, R>,
-  ) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R | Self>
-}
-
-export function Tag<const Id extends string>(id: Id) {
-  return <Self, A, E = never>(
-    options?: L.LazyRefOptions<AsyncData.AsyncData<A, E>>,
-  ): Tagged<Self, Id, A, E> =>
-    class extends L.Tag(id)<Self, AsyncData.AsyncData<A, E>>() {
-      static readonly Default = this.make(Effect.sync(AsyncData.noData<A, E>), options)
-
-      static readonly fromEffect = <R>(effect: Effect.Effect<A, E, R>) =>
-        Layer.scoped(
-          this.tag,
-          Effect.gen(function* () {
-            const ref = yield* lazyRef(options)
-            yield* runEffect(ref, effect).pipe(Effect.forkScoped, Effect.interruptible)
-            return ref
-          }),
-        )
-
-      static readonly run = <R>(effect: Effect.Effect<A, E, R>) => runEffect(this, effect)
-    }
-}
-
-export function lazyRef<A, E = never>(
-  options?: L.LazyRefOptions<AsyncData.AsyncData<A, E>>,
-): Effect.Effect<LazyRef<A, E>, never, Scope> {
-  return L.sync<AsyncData.AsyncData<A, E>>(AsyncData.noData<A, E>, options)
-}
-
-export const runEffect: {
-  <A, E, R2>(
-    effect: Effect.Effect<A, E, R2>,
-  ): <R>(
-    lazyRef: L.LazyRef<AsyncData.AsyncData<A, E>, never, R>,
-  ) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
-  <A, E, R, R2>(
-    lazyRef: L.LazyRef<AsyncData.AsyncData<A, E>, never, R>,
-    effect: Effect.Effect<A, E, R2>,
-  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
-} = dual(2, function runEffect<
-  A,
-  E,
-  R,
-  R2,
->(lazyRef: L.LazyRef<AsyncData.AsyncData<A, E>, never, R>, effect: Effect.Effect<A, E, R2>): Effect.Effect<
-  AsyncData.AsyncData<A, E>,
-  never,
-  R | R2
-> {
-  return lazyRef.runUpdates(({ get, set }) =>
-    Effect.gen(function* () {
-      const initial = yield* get
-      yield* set(AsyncData.startLoading(initial))
-      const exit = yield* effect.pipe(
-        Effect.onInterrupt(() => set(initial)),
-        Effect.exit,
-      )
-      return yield* set(AsyncData.fromExit(exit))
-    }),
-  )
-})

package/src/Progress.ts

@@ -1,33 +0,0 @@
-import { Option, Schema } from 'effect'
-import { dual } from 'effect/Function'
-import { DataStruct } from './_internal.js'
-
-export const Progress = DataStruct({
-  loaded: Schema.Number,
-  total: Schema.optionalWith(Schema.Number, { as: 'Option', default: undefined }),
-})
-
-export type ProgressEncoded = typeof Progress.Encoded
-export type Progress = typeof Progress.Type
-
-export const empty: Progress = Progress.make({ loaded: 0, total: Option.none() })
-
-/**
- * @since 1.0.0
- */
-export const setLoaded: {
-  (loaded: number): (progress: Progress) => Progress
-  (progress: Progress, loaded: number): Progress
-} = dual(2, function setLoaded(progress: Progress, loaded: number): Progress {
-  return Progress.make({ loaded, total: progress.total })
-})
-
-/**
- * @since 1.0.0
- */
-export const setTotal: {
-  (total: number): (progress: Progress) => Progress
-  (progress: Progress, total: number): Progress
-} = dual(2, function setTotal(progress: Progress, total: number): Progress {
-  return Progress.make({ loaded: progress.loaded, total: Option.some(total) })
-})

package/src/TypeId.ts

@@ -1,13 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- */
-export const AsyncDataTypeId = Symbol.for('@typed/async-data/AsyncData')
-
-/**
- * @since 1.0.0
- */
-export type AsyncDataTypeId = typeof AsyncDataTypeId

package/src/_internal.ts

@@ -1,114 +0,0 @@
-import {
-  Data,
-  type Effect,
-  Effectable,
-  Equal,
-  Hash,
-  Predicate,
-  Schema,
-  type SchemaAST,
-} from 'effect'
-import { constant } from 'effect/Function'
-import { structuralRegion } from 'effect/Utils'
-
-/**
- * Constructs the same interface as `Schema.Struct`, but with the ability to
- * wrap it in Data.struct to ensure we can hash the struct.
- */
-export function DataStruct<Fields extends Schema.Struct.Fields>(
-  fields: Fields,
-): Schema.Struct<Fields> {
-  return liftStructIntoDataStruct(Schema.Struct(fields))
-}
-
-function liftStructIntoDataStruct<Fields extends Schema.Struct.Fields>(
-  struct: Schema.Struct<Fields>,
-): Schema.Struct<Fields> {
-  const data = Schema.Data(struct)
-
-  return Object.assign(data, {
-    make: (...params: Parameters<typeof struct.make>) => Data.struct(struct.make(...params)),
-    pick: <K extends ReadonlyArray<keyof Fields>>(...params: K) =>
-      liftStructIntoDataStruct(struct.pick(...params)),
-    omit: <K extends ReadonlyArray<keyof Fields>>(...params: K) =>
-      liftStructIntoDataStruct(struct.omit(...params)),
-    fields: struct.fields,
-    records: struct.records,
-    annotations: (...params: Parameters<typeof struct.annotations>) =>
-      liftStructIntoDataStruct(struct.annotations(...params)),
-  })
-}
-
-export type LiteralWithDefault<
-  K extends string,
-  A extends SchemaAST.LiteralValue,
-> = Schema.PropertySignature<':', A, K, ':', A, true, never>
-
-export function LiteralWithDefault<K extends string>() {
-  return <const A extends SchemaAST.LiteralValue>(value: A): LiteralWithDefault<K, A> => {
-    return Schema.optionalWith(Schema.Literal(value), { default: () => value }) as any
-  }
-}
-
-export type DataEffect<F extends Record<string, any>, A, E = never, R = never> = Effect.Effect<
-  A,
-  E,
-  R
-> &
-  F &
-  Hash.Hash &
-  Equal.Equal
-
-export interface DataEffectClass<Tag extends string> {
-  readonly _tag: Tag
-
-  new <Fields extends Record<string, any>, A = never, E = never, R = never>(
-    fields: Fields,
-    commit: Effect.Effect<A, E, R>,
-  ): DataEffect<Fields & { readonly _tag: Tag }, A, E, R>
-}
-
-abstract class AbstractDataEffect<F extends Record<string, any>, A, E, R>
-  extends Effectable.Class<A, E, R>
-  implements Hash.Hash, Equal.Equal
-{
-  constructor(fields: F) {
-    super()
-    Object.assign(this, fields)
-  }
-
-  abstract commit(): Effect.Effect<A, E, R>
-
-  [Hash.symbol]() {
-    return Hash.structure(this)
-  }
-
-  [Equal.symbol](that: unknown) {
-    return Predicate.isObject(that) && structuralRegion(() => Equal.equals(this, that))
-  }
-}
-
-export function DataEffect<const Tag extends string>(tag: Tag): DataEffectClass<Tag> {
-  class DataEffect<
-    Fields extends Record<string, any>,
-    A = never,
-    E = never,
-    R = never,
-  > extends AbstractDataEffect<Fields, A, E, R> {
-    static readonly _tag = tag
-    readonly _tag = tag
-
-    constructor(
-      fields: Fields,
-      readonly effect: Effect.Effect<A, E, R>,
-    ) {
-      super(fields)
-    }
-
-    commit() {
-      return this.effect
-    }
-  }
-
-  return DataEffect as any
-}