@typed/async-data 0.12.0 → 0.13.1

package/src/LazyRef.ts

@@ -0,0 +1,89 @@
+import * as L from '@typed/lazy-ref'
+import * as Effect from 'effect/Effect'
+import { dual } from 'effect/Function'
+import * as Layer from 'effect/Layer'
+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,80 +1,34 @@
-/**
- * @since 1.0.0
- */
-
-import * as Data from "effect/Data"
-import * as Equivalence from "effect/Equivalence"
-import { dual } from "effect/Function"
-import * as Option from "effect/Option"
-
-/**
- * @since 1.0.0
- */
-export interface Progress {
-  readonly loaded: bigint
-  readonly total: Option.Option<bigint>
-}
+import * as Option from 'effect/Option'
+import * as Schema from 'effect/Schema'
+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 }),
+})
 
-/**
- * @since 1.0.0
- */
-export function Progress(loaded: bigint, total: Option.Option<bigint> = Option.none()): Progress {
-  return Data.struct({
-    loaded,
-    total
-  })
-}
+export type ProgressEncoded = typeof Progress.Encoded
+export type Progress = typeof Progress.Type
 
-/**
- * @since 1.0.0
- */
-export const make = (loaded: bigint, total?: bigint | null): Progress => Progress(loaded, Option.fromNullable(total))
+export const empty: Progress = Progress.make({ loaded: 0, total: Option.none() })
 
 /**
  * @since 1.0.0
  */
 export const setLoaded: {
-  (loaded: bigint): (progress: Progress) => Progress
-  (progress: Progress, loaded: bigint): Progress
-} = dual(2, function setLoaded(progress: Progress, loaded: bigint): Progress {
-  return Progress(
-    loaded,
-    progress.total
-  )
+  (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: bigint): (progress: Progress) => Progress
-  (progress: Progress, total: bigint): Progress
-} = dual(2, function setTotal(progress: Progress, total: bigint): Progress {
-  return Progress(
-    progress.loaded,
-    Option.some(total)
-  )
-})
-
-/**
- * @since 1.0.0
- */
-export const equals: Equivalence.Equivalence<Progress> = Equivalence.struct({
-  loaded: Equivalence.bigint,
-  total: Option.getEquivalence(Equivalence.bigint)
+  (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) })
 })
-
-/**
- * @since 1.0.0
- */
-export function pretty(progress: Progress): string {
-  return `${progress.loaded}${
-    Option.match(
-      progress.total,
-      {
-        onNone: () => "",
-        onSome: (total) => `/${total}`
-      }
-    )
-  }`
-}

package/src/TypeId.ts

@@ -5,7 +5,7 @@
 /**
  * @since 1.0.0
  */
-export const AsyncDataTypeId = Symbol.for("@typed/async-data/AsyncData")
+export const AsyncDataTypeId = Symbol.for('@typed/async-data/AsyncData')
 
 /**
  * @since 1.0.0

package/src/_internal.ts

@@ -0,0 +1,111 @@
+import * as Data from 'effect/Data'
+import type * as Effect from 'effect/Effect'
+import * as Effectable from 'effect/Effectable'
+import * as Equal from 'effect/Equal'
+import * as Hash from 'effect/Hash'
+import * as Predicate from 'effect/Predicate'
+import * as Schema from 'effect/Schema'
+import type * as SchemaAST from 'effect/SchemaAST'
+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
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './AsyncData.js'
+export * from './LazyRef.js'
+export * from './Progress.js'
+export * from './TypeId.js'

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": [
+      "ES2022",
+      "DOM"
+    ],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}

package/AsyncData/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/AsyncData.js",
-  "module": "../dist/esm/AsyncData.js",
-  "types": "../dist/dts/AsyncData.d.ts",
-  "sideEffects": []
-}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/Progress/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Progress.js",
-  "module": "../dist/esm/Progress.js",
-  "types": "../dist/dts/Progress.d.ts",
-  "sideEffects": []
-}

package/README.md

@@ -1,5 +0,0 @@
-# @typed/async-data
-
-> WIP
-
-Docs: https://tylors.github.io/typed/docs/async-data

package/Schema/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Schema.js",
-  "module": "../dist/esm/Schema.js",
-  "types": "../dist/dts/Schema.d.ts",
-  "sideEffects": []
-}

package/TypeId/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/TypeId.js",
-  "module": "../dist/esm/TypeId.js",
-  "types": "../dist/dts/TypeId.d.ts",
-  "sideEffects": []
-}