@typed/fx 0.0.6 → 0.0.9

package/src/Cause/CauseError.ts

@@ -1,55 +0,0 @@
-import type { Cause } from './Cause.js'
-import { Renderer, defaultRenderer, prettyPrint } from './Renderer.js'
-
-import * as Trace from '@/Trace/Trace.js'
-
-export class CauseError<E> extends Error {
-  constructor(readonly causedBy: Cause<E>, renderer: Renderer<E> = defaultRenderer) {
-    // Separate any taces from the message to use the Error.stack with the Traces
-    const [cause, trace] = causeAndTrace(causedBy)
-
-    // Print the message
-    super(prettyPrint(cause, renderer))
-
-    this.name = 'CauseError'
-
-    // If there is a Trace, add it to the Error
-    if (trace.tag !== 'EmptyTrace') {
-      this.stack = renderer.renderTrace(trace).replace(/\n/g, '\n    ')
-    }
-
-    // Ammend the Error that caused everything
-    if (cause.tag === 'Unexpected' && cause.error instanceof Error) {
-      this.cause = cause.error
-    }
-
-    this.toString = () => prettyPrint(causedBy, renderer)
-  }
-}
-
-/**
- * Splits any top-level Trace nodes from the rest of the Cause
- */
-export function causeAndTrace<E>(cause: Cause<E>): readonly [Cause<E>, Trace.Trace] {
-  let trace: Trace.Trace = Trace.EmptyTrace
-  let causeToPrint = cause
-
-  while (causeToPrint.tag === 'Traced') {
-    trace = Trace.Associative.concat(trace, causeToPrint.trace)
-    causeToPrint = causeToPrint.cause
-  }
-
-  return [causeToPrint, trace] as const
-}
-
-export function getCauseError<E>(cause: Cause<E>): Error {
-  if (cause.tag === 'Traced') {
-    return getCauseError(cause.cause)
-  }
-
-  if ((cause.tag === 'Unexpected' || cause.tag === 'Expected') && cause.error instanceof Error) {
-    return cause.error
-  }
-
-  return new CauseError(cause)
-}

package/src/Cause/Renderer.ts

@@ -1,289 +0,0 @@
-import * as M from 'hkt-ts/Maybe'
-import { pipe } from 'hkt-ts/function'
-
-import type { Cause, Expected, Interrupted, Unexpected } from './Cause.js'
-import { prettyStringify } from './prettyStringify.js'
-
-import { Debug as FiberIdDebug } from '@/FiberId/index.js'
-import { Trace, Debug as TraceDebug } from '@/Trace/index.js'
-
-export interface Renderer<E> {
-  readonly renderError: (error: E, hasTrace: boolean) => Lines
-  readonly renderUnknown: (error: unknown, hasTrace: boolean) => Lines
-  readonly renderTrace: TraceRenderer
-}
-
-export type TraceRenderer = (trace: Trace) => string
-
-/**
- * Each item in the array represents a newline
- */
-export type Lines = readonly string[]
-
-export type Segment = Sequential | Parallel | Failure
-
-export type Step = Parallel | Failure
-
-export interface Failure {
-  readonly type: 'Failure'
-  readonly lines: Lines
-}
-
-export interface Parallel {
-  readonly type: 'Parallel'
-  readonly all: readonly Sequential[]
-}
-
-export interface Sequential {
-  readonly type: 'Sequential'
-  readonly all: readonly Step[]
-}
-
-export function Failure(lines: readonly string[]): Failure {
-  return {
-    type: 'Failure',
-    lines,
-  }
-}
-
-export function Sequential(all: readonly Step[]): Sequential {
-  return {
-    type: 'Sequential',
-    all,
-  }
-}
-
-export function Parallel(all: readonly Sequential[]): Parallel {
-  return {
-    type: 'Parallel',
-    all,
-  }
-}
-
-export function renderInterrupted<E>(
-  cause: Interrupted,
-  trace: M.Maybe<Trace>,
-  renderer: Renderer<E>,
-): Sequential {
-  return Sequential([
-    Failure([
-      `Interrupted by ${FiberIdDebug.debug(cause.fiberId)}.`,
-      '',
-      ...renderTrace(trace, renderer),
-    ]),
-  ])
-}
-
-export function renderExpected<E>(
-  cause: Expected<E>,
-  trace: M.Maybe<Trace>,
-  renderer: Renderer<E>,
-) {
-  return Sequential([
-    Failure([
-      'An expected error has occurred.',
-      '',
-      ...renderer.renderError(
-        cause.error,
-        M.isJust(trace) && trace.value.tag !== 'EmptyTrace' && trace.value.frames.length > 0,
-      ),
-      ...renderTrace(trace, renderer),
-    ]),
-  ])
-}
-
-export function renderUnexpected<E>(
-  cause: Unexpected,
-  trace: M.Maybe<Trace>,
-  renderer: Renderer<E>,
-) {
-  return Sequential([
-    Failure([
-      'An unexpected error has occurred.',
-      '',
-      ...renderer.renderUnknown(
-        cause.error,
-        M.isJust(trace) && trace.value.tag !== 'EmptyTrace' && trace.value.frames.length > 0,
-      ),
-      ...renderTrace(trace, renderer),
-    ]),
-  ])
-}
-
-export function renderCauseToSequential<E>(cause: Cause<E>, renderer: Renderer<E>): Sequential {
-  switch (cause.tag) {
-    case 'Empty':
-      return Sequential([])
-    case 'Expected':
-      return renderExpected(cause, M.Nothing, renderer)
-    case 'Unexpected':
-      return renderUnexpected(cause, M.Nothing, renderer)
-    case 'Interrupted':
-      return renderInterrupted(cause, M.Nothing, renderer)
-    case 'Sequential':
-      return Sequential(linearSegments(cause, renderer))
-    case 'Parallel':
-      return Sequential([Parallel(parrallelSegments(cause, renderer))])
-    case 'Traced': {
-      switch (cause.cause.tag) {
-        case 'Expected':
-          return renderExpected(cause.cause, M.Just(cause.trace), renderer)
-        case 'Unexpected':
-          return renderUnexpected(cause.cause, M.Just(cause.trace), renderer)
-        case 'Interrupted':
-          return renderInterrupted(cause.cause, M.Just(cause.trace), renderer)
-        default: {
-          const { all }: Sequential = renderCauseToSequential(cause.cause, renderer)
-          const rendered = renderTrace(M.Just(cause.trace), renderer)
-
-          return Sequential([
-            ...(rendered.every((x) => includes(all, x))
-              ? []
-              : [Failure(['An error was rethrown with a new trace.', ...rendered])]),
-            ...all,
-          ])
-        }
-      }
-    }
-  }
-}
-
-function includes(steps: ReadonlyArray<Step>, value: string): boolean {
-  // Reverse steps as this will usually be at the bottom of the previous section
-  for (const step of steps.slice().reverse()) {
-    if (stepIncludes(step, value)) {
-      return true
-    }
-  }
-
-  return false
-}
-
-function stepIncludes(step: Step, value: string): boolean {
-  switch (step.type) {
-    case 'Failure':
-      return step.lines.includes(value)
-    case 'Parallel':
-      return includes(
-        step.all.flatMap((s) => s.all),
-        value,
-      )
-  }
-}
-
-export function linearSegments<E>(cause: Cause<E>, renderer: Renderer<E>): readonly Step[] {
-  switch (cause.tag) {
-    case 'Sequential':
-      return [...linearSegments(cause.left, renderer), ...linearSegments(cause.right, renderer)]
-    default:
-      return renderCauseToSequential(cause, renderer).all
-  }
-}
-
-export function parrallelSegments<E>(
-  cause: Cause<E>,
-  renderer: Renderer<E>,
-): readonly Sequential[] {
-  switch (cause.tag) {
-    case 'Parallel':
-      return [
-        ...parrallelSegments(cause.left, renderer),
-        ...parrallelSegments(cause.right, renderer),
-      ]
-    default:
-      return [renderCauseToSequential(cause, renderer)]
-  }
-}
-
-export function renderError(error: Error, hasTrace = false): Lines {
-  return hasTrace ? lines(`${error.name}: ${error.message}`) : lines(String(error))
-}
-
-export function renderTrace<E>(trace: M.Maybe<Trace>, renderer: Renderer<E>): Lines {
-  return pipe(
-    trace,
-    M.match(
-      () => [],
-      (trace) => lines(addPadding(renderer.renderTrace(trace))),
-    ),
-  )
-}
-
-export function lines(s: string): Lines {
-  return s.split('\n').map((s) => s.replace('\r', ''))
-}
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function renderString(u: any): string {
-  const s = u?.toString?.()
-  const shouldJsonify = !s || s.trim().startsWith('[object')
-
-  return shouldJsonify ? prettyStringify(u) : s
-}
-
-export function prefixBlock(lines: Lines, headPrefix: string, tailPrefix: string): Lines {
-  if (lines.length === 0) {
-    return []
-  }
-
-  const [head, ...tail] = lines
-
-  return [`${headPrefix}${head}`, ...tail.map((t) => `${tailPrefix}${t}`)]
-}
-
-export function format(segment: Segment): Lines {
-  switch (segment.type) {
-    case 'Failure': {
-      return prefixBlock(segment.lines, '─', ' ')
-    }
-    case 'Parallel': {
-      return [
-        '══╦'.repeat(segment.all.length - 1) + '══╗',
-        ...segment.all.reduceRight(
-          (acc: Lines, current: Sequential): Lines => [
-            ...prefixBlock(acc, '  ║', '  ║'),
-            ...prefixBlock(format(current), '  ', '  '),
-          ],
-          [],
-        ),
-      ]
-    }
-    case 'Sequential': {
-      return segment.all.flatMap((seg) => ['║', ...prefixBlock(format(seg), '╠', '║'), '▼'])
-    }
-  }
-}
-
-export function prettyLines<E>(cause: Cause<E>, renderer: Renderer<E>): Lines {
-  const s = renderCauseToSequential(cause, renderer)
-
-  if (s.all.length === 1 && s.all[0].type === 'Failure') {
-    return s.all[0].lines
-  }
-
-  const formatted = format(s)
-
-  return formatted.length === 0 ? [] : ['╥', ...formatted.slice(1)]
-}
-
-export function defaultErrorToLines(error: unknown, hasTrace = false): Lines {
-  return error instanceof Error ? renderError(error, hasTrace) : lines(renderString(error))
-}
-
-export const defaultRenderer: Renderer<unknown> = {
-  renderError: defaultErrorToLines,
-  renderUnknown: defaultErrorToLines,
-  // Add 4 spaces of padding like most JS runtimes.
-  renderTrace: TraceDebug.debug,
-}
-
-// Add 4-spaces of padding like most JS runtimes do for stack traces.
-function addPadding(s: string): string {
-  return '    ' + s.replace(/\n/g, '\n    ')
-}
-
-export function prettyPrint<E>(cause: Cause<E>, renderer: Renderer<E> = defaultRenderer): string {
-  const lines = prettyLines(cause, renderer)
-
-  return `\n${lines.join('\n')}`.trimEnd()
-}

package/src/Cause/index.ts

@@ -1 +0,0 @@
-export * from './Cause.js'

package/src/Cause/prettyStringify.ts

@@ -1,8 +0,0 @@
-const NEWLINE_REGEX = /\r?\n/g
-
-export function prettyStringify(x: unknown, depth = 2): string {
-  const replacement = '\n'.padEnd(1 + depth, ' ')
-
-  // Optional chain is need for passing `undefined` to JSON.stringify returns `undefined`.
-  return JSON.stringify(x, null, 2)?.replace(NEWLINE_REGEX, replacement) ?? ''
-}

package/src/Clock/Clock.ts

@@ -1,82 +0,0 @@
-import { Lazy } from 'hkt-ts'
-import * as Associative from 'hkt-ts/Typeclass/Associative'
-import { Identity } from 'hkt-ts/Typeclass/Identity'
-
-import { Service } from '@/Service/index.js'
-import { Delay, MAX_UNIX_TIME, MIN_UNIX_TIME, Time, UnixTime } from '@/Time/index.js'
-
-export interface Clock {
-  readonly startTime: UnixTime
-  readonly getCurrentTime: Lazy<Time>
-}
-
-export const Clock = Service<Clock>('Clock')
-
-export function make(startTime: UnixTime, getCurrentTime: Lazy<Time>): Clock {
-  return {
-    startTime,
-    getCurrentTime,
-  }
-}
-
-export function delayToUnixTime(delay: Delay) {
-  return (clock: Clock): UnixTime => UnixTime(clock.startTime + clock.getCurrentTime() + delay)
-}
-
-export function timeToDate(time: Time) {
-  return (clock: Clock): Date => new Date(clock.startTime + time)
-}
-
-export function timeToUnixTime(time: Time) {
-  return (clock: Clock): UnixTime => UnixTime(clock.startTime + time)
-}
-
-export function dateToTime(date: Date) {
-  return (clock: Clock): Time => Time(clock.startTime - date.getTime())
-}
-
-export function addDelay(delay: Delay) {
-  return (clock: Clock): Time => Time(clock.getCurrentTime() + delay)
-}
-
-export function timeToDelay(time: Time) {
-  return (clock: Clock): Delay => Delay(Math.max(0, time - clock.getCurrentTime()))
-}
-
-export function unixTimeToDelay(time: UnixTime) {
-  return (clock: Clock): Delay =>
-    Delay(Math.max(0, time - timeToUnixTime(clock.getCurrentTime())(clock)))
-}
-
-export const UnionAssociative: Associative.Associative<Clock> = {
-  concat: (f, s) => (f.startTime <= s.startTime ? f : s),
-}
-
-export const IntersectionAssociative: Associative.Associative<Clock> =
-  Associative.reverse(UnionAssociative)
-
-export const or =
-  (second: Clock) =>
-  (first: Clock): Clock =>
-    UnionAssociative.concat(first, second)
-
-export const and =
-  (second: Clock) =>
-  (first: Clock): Clock =>
-    IntersectionAssociative.concat(first, second)
-
-export const UnionIdentity: Identity<Clock> = {
-  ...UnionAssociative,
-  id: make(MAX_UNIX_TIME, () => Time(0)),
-}
-
-export const IntersectionIdentity: Identity<Clock> = {
-  ...IntersectionAssociative,
-  id: make(MIN_UNIX_TIME, () => Time(0)),
-}
-
-export function fork(clock: Clock): Clock {
-  const offset = clock.getCurrentTime()
-
-  return make(timeToUnixTime(offset)(clock), () => Time(clock.getCurrentTime() - offset))
-}

package/src/Clock/DateClock.ts

@@ -1,9 +0,0 @@
-import { Clock, make } from './Clock.js'
-
-import { Time, UnixTime } from '@/Time/index.js'
-
-export function DateClock(startTime: Date = new Date()): Clock {
-  const offset = startTime.getTime()
-
-  return make(UnixTime(offset), () => Time(new Date().getTime() - offset))
-}

package/src/Clock/TestClock.ts

@@ -1,25 +0,0 @@
-import { Clock, make } from './Clock.js'
-
-import { Delay, Time, UnixTime } from '@/Time/index.js'
-
-/**
- * A Clock which provides imperative access to progressing Time forward.
- */
-export interface TestClock extends Clock {
-  readonly progressTimeBy: (delay: Delay) => Time
-  readonly progressTimeTo: (delay: Time) => Time
-}
-
-export function TestClock(startTime: UnixTime = Date.now()): TestClock {
-  let time: Time = Time(0)
-
-  return {
-    ...make(startTime, () => time),
-    progressTimeBy: (delay: Delay) => {
-      return (time = Time(time + delay))
-    },
-    progressTimeTo: (to: Time) => {
-      return (time = to)
-    },
-  }
-}

package/src/Clock/index.ts

@@ -1,3 +0,0 @@
-export * from './Clock.js'
-export * from './DateClock.js'
-export * from './TestClock.js'

package/src/Disposable/Disposable.ts

@@ -1,63 +0,0 @@
-import { constVoid } from 'hkt-ts'
-
-/**
- * A Synchronous representation of a Resource that can be disposed of or cancelled.
- */
-export interface Disposable {
-  readonly dispose: () => void
-}
-
-export function Disposable(dispose: () => void): Disposable {
-  return {
-    dispose,
-  }
-}
-
-export const None: Disposable = {
-  dispose: constVoid,
-}
-
-Disposable.None = None
-
-export function all(...disposables: readonly Disposable[]): Disposable {
-  return Disposable(() => disposables.forEach((d) => d.dispose()))
-}
-
-export interface Settable extends Disposable {
-  readonly isDisposed: () => boolean
-  readonly add: (disposable: Disposable) => Disposable
-}
-
-export function settable(): Settable {
-  return new SettableDisposable()
-}
-
-export class SettableDisposable implements Settable {
-  protected disposables = new Set<Disposable>()
-  protected disposed = false
-
-  readonly isDisposed = () => this.disposed
-
-  readonly add = (d: Disposable) => {
-    if (d === None) {
-      return d
-    }
-
-    if (this.disposed) {
-      d.dispose()
-
-      return None
-    }
-
-    this.disposables.add(d)
-
-    return Disposable(() => this.disposables.delete(d))
-  }
-
-  readonly dispose = () => {
-    this.disposed = true
-    const disposable = all(...Array.from(this.disposables))
-    this.disposables.clear()
-    disposable.dispose()
-  }
-}

package/src/Disposable/index.ts

@@ -1 +0,0 @@
-export * from './Disposable.js'

package/src/Duration/Duration.ts

@@ -1,125 +0,0 @@
-import { Delay, Time, UnixTime } from '@/Time/index.js'
-
-/**
- * TODO: Add support for Month/Year -- how to deal with the variability of each month/year?
- */
-export enum Unit {
-  Week,
-  Day,
-  Hour,
-  Minute,
-  Second,
-  Milliseconds,
-}
-
-const SECOND_MS = 1000
-const MINUTE_MS = 60 * SECOND_MS
-const HOUR_MS = 60 * MINUTE_MS
-const DAY_MS = 24 * HOUR_MS
-const WEEK_MS = 7 * DAY_MS
-
-export interface Duration<U extends Unit> {
-  readonly value: number
-  readonly unit: U
-}
-
-export function Duration<U extends Unit>(value: number, unit: U): Duration<U> {
-  return {
-    value,
-    unit,
-  }
-}
-
-export function toMilliseconds<U extends Unit>(duration: Duration<U>): Duration<Unit.Milliseconds> {
-  switch (duration.unit) {
-    case Unit.Week:
-      return Duration(duration.value * WEEK_MS, Unit.Milliseconds)
-    case Unit.Day:
-      return Duration(duration.value * DAY_MS, Unit.Milliseconds)
-    case Unit.Hour:
-      return Duration(duration.value * HOUR_MS, Unit.Milliseconds)
-    case Unit.Minute:
-      return Duration(duration.value * WEEK_MS, Unit.Milliseconds)
-    case Unit.Second:
-      return Duration(duration.value * SECOND_MS, Unit.Milliseconds)
-    case Unit.Milliseconds:
-      return Duration(duration.value, Unit.Milliseconds)
-    default:
-      throw new Error(`Unknown Duration Unit: ${duration.unit}`)
-  }
-}
-
-export function toUnit<U2 extends Unit>(unit: U2) {
-  return <U extends Unit>(duration: Duration<U>): Duration<U2> => {
-    const ms = toMilliseconds(duration)
-
-    switch (unit) {
-      case Unit.Week:
-        return Duration(ms.value / WEEK_MS, unit)
-      case Unit.Day:
-        return Duration(ms.value / DAY_MS, unit)
-      case Unit.Hour:
-        return Duration(ms.value / HOUR_MS, unit)
-      case Unit.Minute:
-        return Duration(ms.value / WEEK_MS, unit)
-      case Unit.Second:
-        return Duration(ms.value / SECOND_MS, unit)
-      case Unit.Milliseconds:
-        return Duration(ms.value, unit)
-      default:
-        throw new Error(`Unknown Duration Unit: ${duration.unit}`)
-    }
-  }
-}
-
-export function fromTime(time: Time | Delay | UnixTime): Duration<Unit.Milliseconds> {
-  return Duration(time, Unit.Milliseconds)
-}
-
-export function toTime<U extends Unit>(duration: Duration<U>): Time {
-  return Time(toMilliseconds(duration).value)
-}
-
-export function toDelay<U extends Unit>(duration: Duration<U>): Delay {
-  return Delay(toMilliseconds(duration).value)
-}
-
-export function toUnixTime<U extends Unit>(duration: Duration<U>): UnixTime {
-  return UnixTime(toMilliseconds(duration).value)
-}
-
-const formatOrder = [Unit.Week, Unit.Day, Unit.Hour, Unit.Minute, Unit.Second, Unit.Milliseconds]
-
-// Attempts to format using the largest unit possible
-export function format<U extends Unit>(duration: Duration<U>): string {
-  for (const unit of formatOrder) {
-    const d = toUnit(unit)(duration)
-
-    if (d.value >= 1) {
-      return formatDuration(d)
-    }
-  }
-
-  return formatDuration(duration)
-}
-
-export function formatDuration<U extends Unit>(duration: Duration<U>): string {
-  return `${duration.value}${formatUnit(duration.unit)}`
-}
-
-export function formatUnit(unit: Unit): string {
-  switch (unit) {
-    case Unit.Week:
-      return 'wk'
-    case Unit.Day:
-      return 'day'
-    case Unit.Hour:
-      return 'hr'
-    case Unit.Minute:
-      return 'min'
-    case Unit.Second:
-      return 'sec'
-    case Unit.Milliseconds:
-      return 'ms'
-  }
-}

package/src/Duration/index.ts

@@ -1 +0,0 @@
-export * from './Duration.js'

package/src/Env/Env.ts

@@ -1,14 +0,0 @@
-import { getServiceFromFiberRefs } from '@/FiberRef/builtins.js'
-import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
-import { Of } from '@/Fx/Fx.js'
-import { Service } from '@/Service/Service.js'
-
-export interface Env<R> {
-  readonly get: <S extends R>(service: Service<S>) => Of<S>
-}
-
-export function Env<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
-  return {
-    get: getServiceFromFiberRefs(fiberRefs.fork()),
-  }
-}

package/src/Env/index.ts

@@ -1 +0,0 @@
-export * from './Env.js'