effect 2.0.0-next.38 → 2.0.0-next.39

package/dist/Brand-f068009f.esm.js

@@ -1,215 +0,0 @@
-import { b as match, i as isRight, r as right, l as left, a as isLeft } from './Either-aa46c018.esm.js';
-import { i as identity } from './Function-12511160.esm.js';
-import { k as getRight, s as some } from './Option-df40d2b9.esm.js';
-import { D as flatten } from './ReadonlyArray-0a71b226.esm.js';
-
-/**
- * This module provides types and utility functions to create and work with branded types,
- * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
- *
- * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
- * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
- *
- * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
- * This is useful when you want to distinguish between two values of the same type that have different meanings.
- * The `nominal` function does not perform any validation of the input data.
- *
- * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
- * but with a different name, and it also allows for validation of the input data.
- * The `refined` function takes a predicate that is used to validate the input data.
- * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
- *
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const BrandTypeId = /*#__PURE__*/Symbol.for("effect/Brand");
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-const RefinedConstructorsTypeId = /*#__PURE__*/Symbol.for("effect/Brand/Refined");
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-
-/**
- * A generic interface that defines a branded type.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- */
-
-/**
- * @category alias
- * @since 2.0.0
- */
-
-/**
- * Returns a `BrandErrors` that contains a single `RefinementError`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const error = (message, meta) => [{
-  message,
-  meta
-}];
-
-/**
- * Takes a variable number of `BrandErrors` and returns a single `BrandErrors` that contains all refinement errors.
- *
- * @since 2.0.0
- * @category constructors
- */
-const errors = (...errors) => flatten(errors);
-
-/**
- * Returns a `Brand.Constructor` that can construct a branded type from an unbranded value using the provided `refinement`
- * predicate as validation of the input data.
- *
- * If you don't want to perform any validation but only distinguish between two values of the same type but with different meanings,
- * see {@link nominal}.
- *
- * @param refinement - The refinement predicate to apply to the unbranded value.
- * @param onFailure - Takes the unbranded value that did not pass the `refinement` predicate and returns a `BrandErrors`.
- *
- * @example
- * import * as Brand from "effect/Brand"
- *
- * type Int = number & Brand.Brand<"Int">
- *
- * const Int = Brand.refined<Int>(
- *   (n) => Number.isInteger(n),
- *   (n) => Brand.error(`Expected ${n} to be an integer`)
- * )
- *
- * assert.strictEqual(Int(1), 1)
- * assert.throws(() => Int(1.1))
- *
- * @since 2.0.0
- * @category constructors
- */
-const refined = (refinement, onFailure) => {
-  const either = args => refinement(args) ? right(args) : left(onFailure(args));
-  // @ts-expect-error
-  return Object.assign(args => match(either(args), {
-    onLeft: e => {
-      throw e;
-    },
-    onRight: identity
-  }), {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: args => getRight(either(args)),
-    either,
-    is: args => isRight(either(args))
-  });
-};
-
-/**
- * This function returns a `Brand.Constructor` that **does not apply any runtime checks**, it just returns the provided value.
- * It can be used to create nominal types that allow distinguishing between two values of the same type but with different meanings.
- *
- * If you also want to perform some validation, see {@link refined}.
- *
- * @example
- * import * as Brand from "effect/Brand"
- *
- * type UserId = number & Brand.Brand<"UserId">
- *
- * const UserId = Brand.nominal<UserId>()
- *
- * assert.strictEqual(UserId(1), 1)
- *
- * @since 2.0.0
- * @category constructors
- */
-const nominal = () => {
-  // @ts-expect-error
-  return Object.assign(args => args, {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: args => some(args),
-    either: args => right(args),
-    is: _args => true
-  });
-};
-
-/**
- * Combines two or more brands together to form a single branded type.
- * This API is useful when you want to validate that the input data passes multiple brand validators.
- *
- * @example
- * import * as Brand from "effect/Brand"
- *
- * type Int = number & Brand.Brand<"Int">
- * const Int = Brand.refined<Int>(
- *   (n) => Number.isInteger(n),
- *   (n) => Brand.error(`Expected ${n} to be an integer`)
- * )
- * type Positive = number & Brand.Brand<"Positive">
- * const Positive = Brand.refined<Positive>(
- *   (n) => n > 0,
- *   (n) => Brand.error(`Expected ${n} to be positive`)
- * )
- *
- * const PositiveInt = Brand.all(Int, Positive)
- *
- * assert.strictEqual(PositiveInt(1), 1)
- * assert.throws(() => PositiveInt(1.1))
- *
- * @since 2.0.0
- * @category combining
- */
-const all = (...brands) => {
-  const either = args => {
-    let result = right(args);
-    for (const brand of brands) {
-      const nextResult = brand.either(args);
-      if (isLeft(result) && isLeft(nextResult)) {
-        result = left([...result.left, ...nextResult.left]);
-      } else {
-        result = isLeft(result) ? result : nextResult;
-      }
-    }
-    return result;
-  };
-  // @ts-expect-error
-  return Object.assign(args => match(either(args), {
-    onLeft: e => {
-      throw e;
-    },
-    onRight: identity
-  }), {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: args => getRight(either(args)),
-    either,
-    is: args => isRight(either(args))
-  });
-};
-
-var Brand = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  BrandTypeId: BrandTypeId,
-  RefinedConstructorsTypeId: RefinedConstructorsTypeId,
-  error: error,
-  errors: errors,
-  refined: refined,
-  nominal: nominal,
-  all: all
-});
-
-export { Brand as B, RefinedConstructorsTypeId as R, BrandTypeId as a, errors as b, all as c, error as e, nominal as n, refined as r };

package/dist/Cache-27cd0ab7.esm.js

@@ -1,120 +0,0 @@
-import { C as CacheTypeId$1, m as make$1, a as makeWith$1, b as makeCacheStats$1, c as makeEntryStats$1 } from './cache-d62912e6.esm.js';
-
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const CacheTypeId = CacheTypeId$1;
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-
-/**
- * A `Cache` is defined in terms of a lookup function that, given a key of
- * type `Key`, can either fail with an error of type `Error` or succeed with a
- * value of type `Value`. Getting a value from the cache will either return
- * the previous result of the lookup function if it is available or else
- * compute a new result with the lookup function, put it in the cache, and
- * return it.
- *
- * A cache also has a specified capacity and time to live. When the cache is
- * at capacity the least recently accessed values in the cache will be
- * removed to make room for new values. Getting a value with a life older than
- * the specified time to live will result in a new value being computed with
- * the lookup function and returned when available.
- *
- * The cache is safe for concurrent access. If multiple fibers attempt to get
- * the same key the lookup function will only be computed once and the result
- * will be returned to all fibers.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * A ConsumerCache models a portion of a cache which is safe to share without allowing to create new values or access existing ones.
- *
- * It can be used safely to give over control for request management without leaking writer side details.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- */
-
-/**
- * Constructs a new cache with the specified capacity, time to live, and
- * lookup function.
- *
- * @since 2.0.0
- * @category constructors
- */
-const make = make$1;
-
-/**
- * Constructs a new cache with the specified capacity, time to live, and
- * lookup function, where the time to live can depend on the `Exit` value
- * returned by the lookup function.
- *
- * @since 2.0.0
- * @category constructors
- */
-const makeWith = makeWith$1;
-
-/**
- * `CacheStats` represents a snapshot of statistics for the cache as of a
- * point in time.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * Constructs a new `CacheStats` from the specified values.
- *
- * @since 2.0.0
- * @category constructors
- */
-const makeCacheStats = makeCacheStats$1;
-
-/**
- * Represents a snapshot of statistics for an entry in the cache.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * Constructs a new `EntryStats` from the specified values.
- *
- * @since 2.0.0
- * @category constructors
- */
-const makeEntryStats = makeEntryStats$1;
-
-/**
- * A `Lookup` represents a lookup function that, given a key of type `Key`, can
- * return an effect that will either produce a value of type `Value` or fail
- * with an error of type `Error` using an environment of type `Environment`.
- *
- * @since 2.0.0
- * @category models
- */
-
-var Cache = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CacheTypeId: CacheTypeId,
-  make: make,
-  makeWith: makeWith,
-  makeCacheStats: makeCacheStats,
-  makeEntryStats: makeEntryStats
-});
-
-export { Cache as C, CacheTypeId as a, makeWith as b, makeCacheStats as c, makeEntryStats as d, make as m };