@typed/fx 2.0.0-beta.1 → 2.0.0-beta.10

package/src/RefSubject/RefDateTime.ts

@@ -1,264 +0,0 @@
-/**
- * Extensions to RefSubject for working with DateTime values
- * @since 1.18.0
- */
-
-import * as DateTime from "effect/DateTime";
-import type * as Duration from "effect/Duration";
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefDateTime is a RefSubject specialized over a DateTime value.
- * @since 1.18.0
- * @category models
- */
-export interface RefDateTime<in out E = never, out R = never> extends RefSubject.RefSubject<
-  DateTime.DateTime,
-  E,
-  R
-> {}
-
-/**
- * Creates a new `RefDateTime` from a DateTime, `Effect`, or `Fx`.
- *
- * @example
- * ```ts
- * import { Effect, DateTime } from "effect"
- * import * as RefDateTime from "effect/typed/fx/RefSubject/RefDateTime"
- *
- * const program = Effect.gen(function* () {
- *   const value = yield* RefDateTime.make(DateTime.nowUnsafe())
- *   const current = yield* value
- *   console.log(current) // DateTime(...)
- * })
- * ```
- *
- * @since 1.18.0
- * @category constructors
- */
-export function make<E = never, R = never>(
-  initial:
-    | DateTime.DateTime
-    | Effect.Effect<DateTime.DateTime, E, R>
-    | Fx.Fx<DateTime.DateTime, E, R>,
-): Effect.Effect<RefDateTime<E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: DateTime.Equivalence });
-}
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Add a Duration to the current state of a RefDateTime.
- * @since 1.18.0
- * @category computed
- */
-export const add: {
-  (
-    parts: Partial<{
-      readonly millis?: number;
-      readonly seconds?: number;
-      readonly minutes?: number;
-      readonly hours?: number;
-      readonly days?: number;
-      readonly weeks?: number;
-      readonly months?: number;
-      readonly years?: number;
-    }>,
-  ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<DateTime.DateTime, E, R>;
-  <E, R>(
-    ref: RefDateTime<E, R>,
-    parts: Partial<{
-      readonly millis?: number;
-      readonly seconds?: number;
-      readonly minutes?: number;
-      readonly hours?: number;
-      readonly days?: number;
-      readonly weeks?: number;
-      readonly months?: number;
-      readonly years?: number;
-    }>,
-  ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(
-  2,
-  function add<E, R>(
-    ref: RefDateTime<E, R>,
-    parts: Partial<{
-      readonly millis?: number;
-      readonly seconds?: number;
-      readonly minutes?: number;
-      readonly hours?: number;
-      readonly days?: number;
-      readonly weeks?: number;
-      readonly months?: number;
-      readonly years?: number;
-    }>,
-  ) {
-    return RefSubject.map(ref, (self) => DateTime.add(self, parts));
-  },
-);
-
-/**
- * Add a Duration to the current state of a RefDateTime.
- * @since 1.18.0
- * @category computed
- */
-export const addDuration: {
-  (
-    duration: Duration.Input,
-  ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<DateTime.DateTime, E, R>;
-  <E, R>(
-    ref: RefDateTime<E, R>,
-    duration: Duration.Input,
-  ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(2, function addDuration<E, R>(ref: RefDateTime<E, R>, duration: Duration.Input) {
-  return RefSubject.map(ref, (self) => DateTime.addDuration(self, duration));
-});
-
-/**
- * Subtract a Duration from the current state of a RefDateTime.
- * @since 1.18.0
- * @category computed
- */
-export const subtract: {
-  (
-    parts: Partial<{
-      readonly millis?: number;
-      readonly seconds?: number;
-      readonly minutes?: number;
-      readonly hours?: number;
-      readonly days?: number;
-      readonly weeks?: number;
-      readonly months?: number;
-      readonly years?: number;
-    }>,
-  ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<DateTime.DateTime, E, R>;
-  <E, R>(
-    ref: RefDateTime<E, R>,
-    parts: Partial<{
-      readonly millis?: number;
-      readonly seconds?: number;
-      readonly minutes?: number;
-      readonly hours?: number;
-      readonly days?: number;
-      readonly weeks?: number;
-      readonly months?: number;
-      readonly years?: number;
-    }>,
-  ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(
-  2,
-  function subtract<E, R>(
-    ref: RefDateTime<E, R>,
-    parts: Partial<{
-      readonly millis?: number;
-      readonly seconds?: number;
-      readonly minutes?: number;
-      readonly hours?: number;
-      readonly days?: number;
-      readonly weeks?: number;
-      readonly months?: number;
-      readonly years?: number;
-    }>,
-  ) {
-    return RefSubject.map(ref, (self) => DateTime.subtract(self, parts));
-  },
-);
-
-/**
- * Subtract a Duration from the current state of a RefDateTime.
- * @since 1.18.0
- * @category computed
- */
-export const subtractDuration: {
-  (
-    duration: Duration.Input,
-  ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<DateTime.DateTime, E, R>;
-  <E, R>(
-    ref: RefDateTime<E, R>,
-    duration: Duration.Input,
-  ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(2, function subtractDuration<
-  E,
-  R,
->(ref: RefDateTime<E, R>, duration: Duration.Input) {
-  return RefSubject.map(ref, (self) => DateTime.subtractDuration(self, duration));
-});
-
-/**
- * Get the epoch milliseconds of the current state of a RefDateTime.
- * @since 1.18.0
- * @category computed
- */
-export const epochMillis = <E, R>(ref: RefDateTime<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, (self) => self.epochMillis);
-
-/**
- * Format the current state of a RefDateTime.
- * @since 1.18.0
- * @category computed
- */
-export const format: {
-  (
-    options?: Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined;
-    },
-  ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<string, E, R>;
-  <E, R>(
-    ref: RefDateTime<E, R>,
-    options?: Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined;
-    },
-  ): RefSubject.Computed<string, E, R>;
-} = dual(
-  2,
-  function format<E, R>(
-    ref: RefDateTime<E, R>,
-    options?: Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined;
-    },
-  ) {
-    return RefSubject.map(ref, (self) => DateTime.format(self, options));
-  },
-);
-
-/**
- * Check if the current state of a RefDateTime is before another DateTime.
- * @since 1.18.0
- * @category computed
- */
-export const isBefore: {
-  (that: DateTime.DateTime): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(ref: RefDateTime<E, R>, that: DateTime.DateTime): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function isBefore<E, R>(ref: RefDateTime<E, R>, that: DateTime.DateTime) {
-  return RefSubject.map(ref, (self) => DateTime.isLessThan(self, that));
-});
-
-/**
- * Check if the current state of a RefDateTime is after another DateTime.
- * @since 1.18.0
- * @category computed
- */
-export const isAfter: {
-  (that: DateTime.DateTime): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(ref: RefDateTime<E, R>, that: DateTime.DateTime): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function isAfter<E, R>(ref: RefDateTime<E, R>, that: DateTime.DateTime) {
-  return RefSubject.map(ref, (self) => DateTime.isGreaterThan(self, that));
-});
-
-/**
- * Check if the current state of a RefDateTime equals another DateTime.
- * @since 1.18.0
- * @category computed
- */
-export const isEqual: {
-  (that: DateTime.DateTime): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(ref: RefDateTime<E, R>, that: DateTime.DateTime): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function isEqual<E, R>(ref: RefDateTime<E, R>, that: DateTime.DateTime) {
-  return RefSubject.map(ref, (self) => DateTime.Equivalence(self, that));
-});

package/src/RefSubject/RefDuration.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Effect } from "effect";
-import * as Duration from "effect/Duration";
-import * as RefDuration from "./RefDuration.js";
-
-describe("RefDuration", () => {
-  it("creates and gets value", () =>
-    Effect.gen(function* () {
-      const value = Duration.seconds(5);
-      const ref = yield* RefDuration.make(value);
-      const current = yield* ref;
-      expect(Duration.equals(current, value)).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("adds two durations", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefDuration.make(Duration.seconds(5));
-      const result = yield* RefDuration.add(ref, Duration.seconds(3));
-      expect(Duration.toSeconds(result)).toBe(8);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("subtracts two durations", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefDuration.make(Duration.seconds(10));
-      const result = yield* RefDuration.subtract(ref, Duration.seconds(3));
-      expect(Duration.toSeconds(result)).toBe(7);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("multiplies duration by number", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefDuration.make(Duration.seconds(5));
-      const result = yield* RefDuration.multiply(ref, 2);
-      expect(Duration.toSeconds(result)).toBe(10);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks if zero", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefDuration.make(Duration.zero);
-      const isZero = yield* RefDuration.isZero(ref);
-      expect(isZero).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("gets seconds", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefDuration.make(Duration.seconds(5));
-      const seconds = yield* RefDuration.seconds(ref);
-      expect(seconds).toBe(5);
-    }).pipe(Effect.scoped, Effect.runPromise));
-});

package/src/RefSubject/RefDuration.ts

@@ -1,188 +0,0 @@
-/**
- * Extensions to RefSubject for working with Duration values
- * @since 1.18.0
- */
-
-import * as Duration from "effect/Duration";
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefDuration is a RefSubject specialized over a Duration value.
- * @since 1.18.0
- * @category models
- */
-export interface RefDuration<in out E = never, out R = never> extends RefSubject.RefSubject<
-  Duration.Duration,
-  E,
-  R
-> {}
-
-/**
- * Creates a new `RefDuration` from a Duration, `Effect`, or `Fx`.
- *
- * @example
- * ```ts
- * import { Effect, Duration } from "effect"
- * import * as RefDuration from "effect/typed/fx/RefSubject/RefDuration"
- *
- * const program = Effect.gen(function* () {
- *   const value = yield* RefDuration.make(Duration.seconds(5))
- *   const current = yield* value
- *   console.log(current) // Duration(...)
- * })
- * ```
- *
- * @since 1.18.0
- * @category constructors
- */
-export function make<E = never, R = never>(
-  initial:
-    | Duration.Duration
-    | Effect.Effect<Duration.Duration, E, R>
-    | Fx.Fx<Duration.Duration, E, R>,
-): Effect.Effect<RefDuration<E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: Duration.Equivalence });
-}
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Add a Duration to the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const add: {
-  (
-    that: Duration.Duration,
-  ): <E, R>(ref: RefDuration<E, R>) => RefSubject.Computed<Duration.Duration, E, R>;
-  <E, R>(
-    ref: RefDuration<E, R>,
-    that: Duration.Duration,
-  ): RefSubject.Computed<Duration.Duration, E, R>;
-} = dual(2, function add<E, R>(ref: RefDuration<E, R>, that: Duration.Duration) {
-  return RefSubject.map(ref, (self) => Duration.sum(self, that));
-});
-
-/**
- * Subtract a Duration from the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const subtract: {
-  (
-    that: Duration.Duration,
-  ): <E, R>(ref: RefDuration<E, R>) => RefSubject.Computed<Duration.Duration, E, R>;
-  <E, R>(
-    ref: RefDuration<E, R>,
-    that: Duration.Duration,
-  ): RefSubject.Computed<Duration.Duration, E, R>;
-} = dual(2, function subtract<E, R>(ref: RefDuration<E, R>, that: Duration.Duration) {
-  return RefSubject.map(ref, (self) => Duration.subtract(self, that));
-});
-
-/**
- * Multiply the current state of a RefDuration by a number.
- * @since 1.18.0
- * @category computed
- */
-export const multiply: {
-  (that: number): <E, R>(ref: RefDuration<E, R>) => RefSubject.Computed<Duration.Duration, E, R>;
-  <E, R>(ref: RefDuration<E, R>, that: number): RefSubject.Computed<Duration.Duration, E, R>;
-} = dual(2, function multiply<E, R>(ref: RefDuration<E, R>, that: number) {
-  return RefSubject.map(ref, (self) => Duration.times(self, that));
-});
-
-/**
- * Divide the current state of a RefDuration by a number.
- * @since 1.18.0
- * @category computed
- */
-export const divide: {
-  (
-    that: number,
-  ): <E, R>(ref: RefDuration<E, R>) => RefSubject.Computed<Duration.Duration | undefined, E, R>;
-  <E, R>(
-    ref: RefDuration<E, R>,
-    that: number,
-  ): RefSubject.Computed<Duration.Duration | undefined, E, R>;
-} = dual(2, function divide<E, R>(ref: RefDuration<E, R>, that: number) {
-  return RefSubject.map(ref, (self) => Duration.divide(self, that));
-});
-
-/**
- * Check if the current state of a RefDuration is zero.
- * @since 1.18.0
- * @category computed
- */
-export const isZero = <E, R>(ref: RefDuration<E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, Duration.isZero);
-
-/**
- * Check if the current state of a RefDuration is less than a Duration.
- * @since 1.18.0
- * @category computed
- */
-export const isLessThan: {
-  (that: Duration.Duration): <E, R>(ref: RefDuration<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(ref: RefDuration<E, R>, that: Duration.Duration): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function isLessThan<E, R>(ref: RefDuration<E, R>, that: Duration.Duration) {
-  return RefSubject.map(ref, (self) => Duration.isLessThan(self, that));
-});
-
-/**
- * Check if the current state of a RefDuration is greater than a Duration.
- * @since 1.18.0
- * @category computed
- */
-export const isGreaterThan: {
-  (that: Duration.Duration): <E, R>(ref: RefDuration<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(ref: RefDuration<E, R>, that: Duration.Duration): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function isGreaterThan<E, R>(ref: RefDuration<E, R>, that: Duration.Duration) {
-  return RefSubject.map(ref, (self) => Duration.isGreaterThan(self, that));
-});
-
-/**
- * Get the milliseconds value of the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const millis = <E, R>(ref: RefDuration<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, Duration.toMillis);
-
-/**
- * Get the seconds value of the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const seconds = <E, R>(ref: RefDuration<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, Duration.toSeconds);
-
-/**
- * Get the minutes value of the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const minutes = <E, R>(ref: RefDuration<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, Duration.toMinutes);
-
-/**
- * Get the hours value of the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const hours = <E, R>(ref: RefDuration<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, Duration.toHours);
-
-/**
- * Get the days value of the current state of a RefDuration.
- * @since 1.18.0
- * @category computed
- */
-export const days = <E, R>(ref: RefDuration<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, Duration.toDays);