@typed/fx 1.32.0 → 2.0.0-beta.1

package/src/RefSubject/RefDateTime.ts

@@ -0,0 +1,264 @@
+/**
+ * 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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,188 @@
+/**
+ * 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);