effect 2.0.0-next.46 → 2.0.0-next.48

package/Match/dist/effect-Match.cjs.dev.js

@@ -0,0 +1,620 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Either_dist_effectEither = require('../../Either/dist/effect-Either.cjs.dev.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.dev.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+var Predicate_dist_effectPredicate = require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+require('../../dist/Either-e7500e90.cjs.dev.js');
+require('../../Equal/dist/effect-Equal.cjs.dev.js');
+require('../../Hash/dist/effect-Hash.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+require('../../dist/Option-01caa9d4.cjs.dev.js');
+require('../../dist/Effectable-71c10ab9.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+require('../../Order/dist/effect-Order.cjs.dev.js');
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/matcher/Matcher");
+const TypeMatcherProto = {
+  [TypeId]: {
+    _input: Function_dist_effectFunction.identity,
+    _filters: Function_dist_effectFunction.identity,
+    _remaining: Function_dist_effectFunction.identity,
+    _result: Function_dist_effectFunction.identity
+  },
+  _tag: "TypeMatcher",
+  add(_case) {
+    return makeTypeMatcher([...this.cases, _case]);
+  },
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+};
+function makeTypeMatcher(cases) {
+  const matcher = Object.create(TypeMatcherProto);
+  matcher.cases = cases;
+  return matcher;
+}
+const ValueMatcherProto = {
+  [TypeId]: {
+    _input: Function_dist_effectFunction.identity,
+    _filters: Function_dist_effectFunction.identity,
+    _result: Function_dist_effectFunction.identity
+  },
+  _tag: "ValueMatcher",
+  add(_case) {
+    if (this.value._tag === "Right") {
+      return this;
+    }
+    if (_case._tag === "When" && _case.guard(this.provided) === true) {
+      return makeValueMatcher(this.provided, Either_dist_effectEither.right(_case.evaluate(this.provided)));
+    } else if (_case._tag === "Not" && _case.guard(this.provided) === false) {
+      return makeValueMatcher(this.provided, Either_dist_effectEither.right(_case.evaluate(this.provided)));
+    }
+    return this;
+  },
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+};
+function makeValueMatcher(provided, value) {
+  const matcher = Object.create(ValueMatcherProto);
+  matcher.provided = provided;
+  matcher.value = value;
+  return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+  _tag: "When",
+  guard,
+  evaluate
+});
+const makeNot = (guard, evaluate) => ({
+  _tag: "Not",
+  guard,
+  evaluate
+});
+const makePredicate = pattern => {
+  if (typeof pattern === "function") {
+    return pattern;
+  } else if (Array.isArray(pattern)) {
+    const predicates = pattern.map(makePredicate);
+    const len = predicates.length;
+    return u => {
+      if (!Array.isArray(u)) {
+        return false;
+      }
+      for (let i = 0; i < len; i++) {
+        if (predicates[i](u[i]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  } else if (pattern !== null && typeof pattern === "object") {
+    const keysAndPredicates = Object.entries(pattern).map(([k, p]) => [k, makePredicate(p)]);
+    const len = keysAndPredicates.length;
+    return u => {
+      if (typeof u !== "object" || u === null) {
+        return false;
+      }
+      for (let i = 0; i < len; i++) {
+        const [key, predicate] = keysAndPredicates[i];
+        if (!(key in u) || predicate(u[key]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  return u => u === pattern;
+};
+const makeOrPredicate = patterns => {
+  const predicates = patterns.map(makePredicate);
+  const len = predicates.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (predicates[i](u) === true) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+const makeAndPredicate = patterns => {
+  const predicates = patterns.map(makePredicate);
+  const len = predicates.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (predicates[i](u) === false) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+
+/** @internal */
+const type$1 = () => makeTypeMatcher([]);
+
+/** @internal */
+const value$1 = i => makeValueMatcher(i, Either_dist_effectEither.left(i));
+
+/** @internal */
+const valueTags$1 = fields => {
+  const match = tagsExhaustive$1(fields)(makeTypeMatcher([]));
+  return input => match(input);
+};
+
+/** @internal */
+const typeTags$1 = () => fields => {
+  const match = tagsExhaustive$1(fields)(makeTypeMatcher([]));
+  return input => match(input);
+};
+
+/** @internal */
+const when$1 = (pattern, f) => self => self.add(makeWhen(makePredicate(pattern), f));
+
+/** @internal */
+const whenOr$1 = (...args) => self => {
+  const onMatch = args[args.length - 1];
+  const patterns = args.slice(0, -1);
+  return self.add(makeWhen(makeOrPredicate(patterns), onMatch));
+};
+
+/** @internal */
+const whenAnd$1 = (...args) => self => {
+  const onMatch = args[args.length - 1];
+  const patterns = args.slice(0, -1);
+  return self.add(makeWhen(makeAndPredicate(patterns), onMatch));
+};
+
+/** @internal */
+const discriminator$1 = field => (...pattern) => {
+  const f = pattern[pattern.length - 1];
+  const values = pattern.slice(0, -1);
+  const pred = values.length === 1 ? _ => _[field] === values[0] : _ => values.includes(_[field]);
+  return self => self.add(makeWhen(pred, f));
+};
+
+/** @internal */
+const discriminatorStartsWith$1 = field => (pattern, f) => {
+  const pred = _ => typeof _[field] === "string" && _[field].startsWith(pattern);
+  return self => self.add(makeWhen(pred, f));
+};
+
+/** @internal */
+const discriminators$1 = field => fields => {
+  const predicates = [];
+  for (const key in fields) {
+    const pred = _ => _[field] === key;
+    const f = fields[key];
+    if (f) {
+      predicates.push(makeWhen(pred, f));
+    }
+  }
+  const len = predicates.length;
+  return self => {
+    let matcher = self;
+    for (let i = 0; i < len; i++) {
+      matcher = matcher.add(predicates[i]);
+    }
+    return matcher;
+  };
+};
+
+/** @internal */
+const discriminatorsExhaustive$1 = field => fields => {
+  const addCases = discriminators$1(field)(fields);
+  return matcher => exhaustive$1(addCases(matcher));
+};
+
+/** @internal */
+const tag$1 = /*#__PURE__*/discriminator$1("_tag");
+
+/** @internal */
+const tagStartsWith$1 = /*#__PURE__*/discriminatorStartsWith$1("_tag");
+
+/** @internal */
+const tags$1 = /*#__PURE__*/discriminators$1("_tag");
+
+/** @internal */
+const tagsExhaustive$1 = /*#__PURE__*/discriminatorsExhaustive$1("_tag");
+
+/** @internal */
+const not$1 = (pattern, f) => self => self.add(makeNot(makePredicate(pattern), f));
+
+/** @internal */
+const nonEmptyString$1 = u => typeof u === "string" && u.length > 0;
+
+/** @internal */
+const is$1 = (...literals) => {
+  const len = literals.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (u === literals[i]) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+
+/** @internal */
+const any$1 = () => true;
+
+/** @internal */
+const defined$1 = u => u !== undefined && u !== null;
+
+/** @internal */
+const instanceOf$1 = constructor => u => u instanceof constructor;
+
+/** @internal */
+const orElse$1 = f => self => {
+  const result = either$1(self);
+  if (Either_dist_effectEither.isEither(result)) {
+    // @ts-expect-error
+    return result._tag === "Right" ? result.right : f(result.left);
+  }
+
+  // @ts-expect-error
+  return input => {
+    const a = result(input);
+    return a._tag === "Right" ? a.right : f(a.left);
+  };
+};
+
+/** @internal */
+const orElseAbsurd$1 = self => orElse$1(() => {
+  throw new Error("absurd");
+})(self);
+
+/** @internal */
+const either$1 = self => {
+  if (self._tag === "ValueMatcher") {
+    return self.value;
+  }
+  const len = self.cases.length;
+  return input => {
+    for (let i = 0; i < len; i++) {
+      const _case = self.cases[i];
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return Either_dist_effectEither.right(_case.evaluate(input));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return Either_dist_effectEither.right(_case.evaluate(input));
+      }
+    }
+    return Either_dist_effectEither.left(input);
+  };
+};
+
+/** @internal */
+const option$1 = self => {
+  const toEither = either$1(self);
+  if (Either_dist_effectEither.isEither(toEither)) {
+    return Either_dist_effectEither.match(toEither, {
+      onLeft: () => Option_dist_effectOption.none(),
+      onRight: Option_dist_effectOption.some
+    });
+  }
+  return input => Either_dist_effectEither.match(toEither(input), {
+    onLeft: () => Option_dist_effectOption.none(),
+    onRight: Option_dist_effectOption.some
+  });
+};
+
+/** @internal */
+const exhaustive$1 = self => {
+  const toEither = either$1(self);
+  if (Either_dist_effectEither.isEither(toEither)) {
+    if (toEither._tag === "Right") {
+      return toEither.right;
+    }
+    throw new Error("@effect/match: exhaustive absurd");
+  }
+  return u => {
+    // @ts-expect-error
+    const result = toEither(u);
+    if (result._tag === "Right") {
+      return result.right;
+    }
+    throw new Error("@effect/match: exhaustive absurd");
+  };
+};
+
+/**
+ * @since 1.0.0
+ */
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+const MatcherTypeId = TypeId;
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const type = type$1;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const value = value$1;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const valueTags = valueTags$1;
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+const typeTags = typeTags$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const when = when$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const whenOr = whenOr$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const whenAnd = whenAnd$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const discriminator = discriminator$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const discriminatorStartsWith = discriminatorStartsWith$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const discriminators = discriminators$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const discriminatorsExhaustive = discriminatorsExhaustive$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const tag = tag$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const tagStartsWith = tagStartsWith$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const tags = tags$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const tagsExhaustive = tagsExhaustive$1;
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+const not = not$1;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const nonEmptyString = nonEmptyString$1;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const is = is$1;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const string = Predicate_dist_effectPredicate.isString;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const number = Predicate_dist_effectPredicate.isNumber;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const any = any$1;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const defined = defined$1;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const boolean = Predicate_dist_effectPredicate.isBoolean;
+const _undefined = Predicate_dist_effectPredicate.isUndefined;
+const _null = Predicate_dist_effectPredicate.isNull;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const bigint = Predicate_dist_effectPredicate.isBigInt;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const date = Predicate_dist_effectPredicate.isDate;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const record = Predicate_dist_effectPredicate.isRecord;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const instanceOf = instanceOf$1;
+
+/**
+ * @category predicates
+ * @since 1.0.0
+ */
+const instanceOfUnsafe = instanceOf$1;
+
+/**
+ * @category conversions
+ * @since 1.0.0
+ */
+const orElse = orElse$1;
+
+/**
+ * @category conversions
+ * @since 1.0.0
+ */
+const orElseAbsurd = orElseAbsurd$1;
+
+/**
+ * @category conversions
+ * @since 1.0.0
+ */
+const either = either$1;
+
+/**
+ * @category conversions
+ * @since 1.0.0
+ */
+const option = option$1;
+
+/**
+ * @category conversions
+ * @since 1.0.0
+ */
+const exhaustive = exhaustive$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const SafeRefinementId = /*#__PURE__*/Symbol.for("./SafeRefinement");
+
+/**
+ * @since 1.0.0
+ */
+
+exports.MatcherTypeId = MatcherTypeId;
+exports.SafeRefinementId = SafeRefinementId;
+exports.any = any;
+exports.bigint = bigint;
+exports.boolean = boolean;
+exports.date = date;
+exports.defined = defined;
+exports.discriminator = discriminator;
+exports.discriminatorStartsWith = discriminatorStartsWith;
+exports.discriminators = discriminators;
+exports.discriminatorsExhaustive = discriminatorsExhaustive;
+exports.either = either;
+exports.exhaustive = exhaustive;
+exports.instanceOf = instanceOf;
+exports.instanceOfUnsafe = instanceOfUnsafe;
+exports.is = is;
+exports.nonEmptyString = nonEmptyString;
+exports.not = not;
+exports["null"] = _null;
+exports.number = number;
+exports.option = option;
+exports.orElse = orElse;
+exports.orElseAbsurd = orElseAbsurd;
+exports.record = record;
+exports.string = string;
+exports.tag = tag;
+exports.tagStartsWith = tagStartsWith;
+exports.tags = tags;
+exports.tagsExhaustive = tagsExhaustive;
+exports.type = type;
+exports.typeTags = typeTags;
+exports["undefined"] = _undefined;
+exports.value = value;
+exports.valueTags = valueTags;
+exports.when = when;
+exports.whenAnd = whenAnd;
+exports.whenOr = whenOr;

package/Match/dist/effect-Match.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./effect-Match.cjs.prod.js");
+} else {
+  module.exports = require("./effect-Match.cjs.dev.js");
+}

package/Match/dist/effect-Match.cjs.mjs

@@ -0,0 +1,39 @@
+export {
+  MatcherTypeId,
+  SafeRefinementId,
+  any,
+  bigint,
+  boolean,
+  date,
+  defined,
+  discriminator,
+  discriminatorStartsWith,
+  discriminators,
+  discriminatorsExhaustive,
+  either,
+  exhaustive,
+  instanceOf,
+  instanceOfUnsafe,
+  is,
+  nonEmptyString,
+  not,
+  null,
+  number,
+  option,
+  orElse,
+  orElseAbsurd,
+  record,
+  string,
+  tag,
+  tagStartsWith,
+  tags,
+  tagsExhaustive,
+  type,
+  typeTags,
+  undefined,
+  value,
+  valueTags,
+  when,
+  whenAnd,
+  whenOr
+} from "./effect-Match.cjs.js";