effect 3.12.8 → 3.12.10

package/dist/cjs/ParseResult.js

@@ -279,56 +279,39 @@ const _try = exports.try = Either.try;
  * @since 3.10.0
  */
 const fromOption = exports.fromOption = Either.fromOption;
+const isEither = Either.isEither;
 /**
  * @category optimisation
  * @since 3.10.0
  */
 const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
-  const s = self;
-  if (s["_tag"] === "Left") {
-    return s;
-  }
-  if (s["_tag"] === "Right") {
-    return f(s.right);
-  }
-  return Effect.flatMap(self, f);
+  return isEither(self) ? Either.match(self, {
+    onLeft: Either.left,
+    onRight: f
+  }) : Effect.flatMap(self, f);
 });
 /**
  * @category optimisation
  * @since 3.10.0
  */
 const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
-  const s = self;
-  if (s["_tag"] === "Left") {
-    return s;
-  }
-  if (s["_tag"] === "Right") {
-    return Either.right(f(s.right));
-  }
-  return Effect.map(self, f);
+  return isEither(self) ? Either.map(self, f) : Effect.map(self, f);
 });
 /**
  * @category optimisation
  * @since 3.10.0
  */
 const mapError = exports.mapError = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
-  const s = self;
-  if (s["_tag"] === "Left") {
-    return Either.left(f(s.left));
-  }
-  if (s["_tag"] === "Right") {
-    return s;
-  }
-  return Effect.mapError(self, f);
+  return isEither(self) ? Either.mapLeft(self, f) : Effect.mapError(self, f);
 });
+// TODO(4.0): remove
 /**
  * @category optimisation
  * @since 3.10.0
  */
 const eitherOrUndefined = self => {
-  const s = self;
-  if (s["_tag"] === "Left" || s["_tag"] === "Right") {
-    return s;
+  if (isEither(self)) {
+    return self;
   }
 };
 /**
@@ -337,28 +320,20 @@ const eitherOrUndefined = self => {
  */
 exports.eitherOrUndefined = eitherOrUndefined;
 const mapBoth = exports.mapBoth = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => {
-  const s = self;
-  if (s["_tag"] === "Left") {
-    return Either.left(options.onFailure(s.left));
-  }
-  if (s["_tag"] === "Right") {
-    return Either.right(options.onSuccess(s.right));
-  }
-  return Effect.mapBoth(self, options);
+  return isEither(self) ? Either.mapBoth(self, {
+    onLeft: options.onFailure,
+    onRight: options.onSuccess
+  }) : Effect.mapBoth(self, options);
 });
 /**
  * @category optimisation
  * @since 3.10.0
  */
 const orElse = exports.orElse = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
-  const s = self;
-  if (s["_tag"] === "Left") {
-    return f(s.left);
-  }
-  if (s["_tag"] === "Right") {
-    return s;
-  }
-  return Effect.catchAll(self, f);
+  return isEither(self) ? Either.match(self, {
+    onLeft: f,
+    onRight: Either.right
+  }) : Effect.catchAll(self, f);
 });
 /** @internal */
 const mergeInternalOptions = (options, overrideOptions) => {
@@ -731,11 +706,10 @@ const go = (ast, isDecoding) => {
             } else {
               const parser = elements[i];
               const te = parser(input[i], options);
-              const eu = eitherOrUndefined(te);
-              if (eu) {
-                if (Either.isLeft(eu)) {
+              if (isEither(te)) {
+                if (Either.isLeft(te)) {
                   // the input element is present but is not valid
-                  const e = new Pointer(i, input, eu.left);
+                  const e = new Pointer(i, input, te.left);
                   if (allErrors) {
                     es.push([stepKey++, e]);
                     continue;
@@ -743,7 +717,7 @@ const go = (ast, isDecoding) => {
                     return Either.left(new Composite(ast, input, e, sortByIndex(output)));
                   }
                 }
-                output.push([stepKey++, eu.right]);
+                output.push([stepKey++, te.right]);
               } else {
                 const nk = stepKey++;
                 const index = i;
@@ -777,10 +751,9 @@ const go = (ast, isDecoding) => {
             const [head, ...tail] = rest;
             for (; i < len - tail.length; i++) {
               const te = head(input[i], options);
-              const eu = eitherOrUndefined(te);
-              if (eu) {
-                if (Either.isLeft(eu)) {
-                  const e = new Pointer(i, input, eu.left);
+              if (isEither(te)) {
+                if (Either.isLeft(te)) {
+                  const e = new Pointer(i, input, te.left);
                   if (allErrors) {
                     es.push([stepKey++, e]);
                     continue;
@@ -788,7 +761,7 @@ const go = (ast, isDecoding) => {
                     return Either.left(new Composite(ast, input, e, sortByIndex(output)));
                   }
                 } else {
-                  output.push([stepKey++, eu.right]);
+                  output.push([stepKey++, te.right]);
                 }
               } else {
                 const nk = stepKey++;
@@ -824,11 +797,10 @@ const go = (ast, isDecoding) => {
                 continue;
               } else {
                 const te = tail[j](input[i], options);
-                const eu = eitherOrUndefined(te);
-                if (eu) {
-                  if (Either.isLeft(eu)) {
+                if (isEither(te)) {
+                  if (Either.isLeft(te)) {
                     // the input element is present but is not valid
-                    const e = new Pointer(i, input, eu.left);
+                    const e = new Pointer(i, input, te.left);
                     if (allErrors) {
                       es.push([stepKey++, e]);
                       continue;
@@ -836,7 +808,7 @@ const go = (ast, isDecoding) => {
                       return Either.left(new Composite(ast, input, e, sortByIndex(output)));
                     }
                   }
-                  output.push([stepKey++, eu.right]);
+                  output.push([stepKey++, te.right]);
                 } else {
                   const nk = stepKey++;
                   const index = i;
@@ -926,8 +898,8 @@ const go = (ast, isDecoding) => {
           if (onExcessPropertyError || onExcessPropertyPreserve) {
             inputKeys = util_.ownKeys(input);
             for (const key of inputKeys) {
-              const eu = eitherOrUndefined(expected(key, options));
-              if (Either.isLeft(eu)) {
+              const te = expected(key, options);
+              if (isEither(te) && Either.isLeft(te)) {
                 // key is unexpected
                 if (onExcessPropertyError) {
                   const e = new Pointer(key, input, new Unexpected(input[key], `is unexpected, expected: ${String(expectedAST)}`));
@@ -965,10 +937,9 @@ const go = (ast, isDecoding) => {
             }
             const parser = propertySignatures[i][0];
             const te = parser(input[name], options);
-            const eu = eitherOrUndefined(te);
-            if (eu) {
-              if (Either.isLeft(eu)) {
-                const e = new Pointer(name, input, hasKey ? eu.left : new Missing(ps));
+            if (isEither(te)) {
+              if (Either.isLeft(te)) {
+                const e = new Pointer(name, input, hasKey ? te.left : new Missing(ps));
                 if (allErrors) {
                   es.push([stepKey++, e]);
                   continue;
@@ -976,7 +947,7 @@ const go = (ast, isDecoding) => {
                   return Either.left(new Composite(ast, input, e, output));
                 }
               }
-              output[name] = eu.right;
+              output[name] = te.right;
             } else {
               const nk = stepKey++;
               const index = name;
@@ -1013,16 +984,15 @@ const go = (ast, isDecoding) => {
               // ---------------------------------------------
               // handle keys
               // ---------------------------------------------
-              const keu = eitherOrUndefined(parameter(key, options));
-              if (keu && Either.isRight(keu)) {
+              const keu = parameter(key, options);
+              if (isEither(keu) && Either.isRight(keu)) {
                 // ---------------------------------------------
                 // handle values
                 // ---------------------------------------------
                 const vpr = type(input[key], options);
-                const veu = eitherOrUndefined(vpr);
-                if (veu) {
-                  if (Either.isLeft(veu)) {
-                    const e = new Pointer(key, input, veu.left);
+                if (isEither(vpr)) {
+                  if (Either.isLeft(vpr)) {
+                    const e = new Pointer(key, input, vpr.left);
                     if (allErrors) {
                       es.push([stepKey++, e]);
                       continue;
@@ -1031,7 +1001,7 @@ const go = (ast, isDecoding) => {
                     }
                   } else {
                     if (!Object.prototype.hasOwnProperty.call(expectedKeysMap, key)) {
-                      output[key] = veu.right;
+                      output[key] = vpr.right;
                     }
                   }
                 } else {
@@ -1173,12 +1143,11 @@ const go = (ast, isDecoding) => {
             // the members of a union are ordered based on which one should be decoded first,
             // therefore if one member has added a task, all subsequent members must
             // also add a task to the queue even if they are synchronous
-            const eu = !queue || queue.length === 0 ? eitherOrUndefined(pr) : undefined;
-            if (eu) {
-              if (Either.isRight(eu)) {
-                return eu;
+            if (isEither(pr) && (!queue || queue.length === 0)) {
+              if (Either.isRight(pr)) {
+                return pr;
               } else {
-                es.push([stepKey++, eu.left]);
+                es.push([stepKey++, pr.left]);
               }
             } else {
               const nk = stepKey++;
@@ -1347,11 +1316,9 @@ const handleForbidden = (effect, ast, actual, options) => {
   if (options?.isEffectAllowed === true) {
     return effect;
   }
-  // Convert the effect to an Either, if possible
-  const eu = eitherOrUndefined(effect);
   // If the effect is already an Either, return it directly
-  if (eu) {
-    return eu;
+  if (isEither(effect)) {
+    return effect;
   }
   // Otherwise, attempt to execute the effect synchronously
   const scheduler = new Scheduler.SyncScheduler();
@@ -1423,8 +1390,11 @@ const makeTree = (value, forest = []) => ({
  * @since 3.10.0
  */
 const TreeFormatter = exports.TreeFormatter = {
-  formatIssue: issue => Effect.map(formatTree(issue), drawTree),
-  formatIssueSync: issue => Effect.runSync(TreeFormatter.formatIssue(issue)),
+  formatIssue: issue => map(formatTree(issue), drawTree),
+  formatIssueSync: issue => {
+    const e = TreeFormatter.formatIssue(issue);
+    return isEither(e) ? Either.getOrThrow(e) : Effect.runSync(e);
+  },
   formatError: error => TreeFormatter.formatIssue(error.issue),
   formatErrorSync: error => TreeFormatter.formatIssueSync(error.issue)
 };
@@ -1460,21 +1430,35 @@ const formatRefinementKind = kind => {
   }
 };
 const getAnnotated = issue => "ast" in issue ? Option.some(issue.ast) : Option.none();
-const getCurrentMessage = issue => getAnnotated(issue).pipe(Option.flatMap(AST.getMessageAnnotation), Effect.flatMap(annotation => {
-  const out = annotation(issue);
-  return Predicate.isString(out) ? Effect.succeed({
-    message: out,
-    override: false
-  }) : Effect.isEffect(out) ? Effect.map(out, message => ({
-    message,
-    override: false
-  })) : Predicate.isString(out.message) ? Effect.succeed({
-    message: out.message,
-    override: out.override
-  }) : Effect.map(out.message, message => ({
-    message,
-    override: out.override
-  }));
+// TODO: replace with Either.void when 3.13 lands
+const Either_void = /*#__PURE__*/Either.right(undefined);
+const getCurrentMessage = issue => getAnnotated(issue).pipe(Option.flatMap(AST.getMessageAnnotation), Option.match({
+  onNone: () => Either_void,
+  onSome: messageAnnotation => {
+    const union = messageAnnotation(issue);
+    if (Predicate.isString(union)) {
+      return Either.right({
+        message: union,
+        override: false
+      });
+    }
+    if (Effect.isEffect(union)) {
+      return Effect.map(union, message => ({
+        message,
+        override: false
+      }));
+    }
+    if (Predicate.isString(union.message)) {
+      return Either.right({
+        message: union.message,
+        override: union.override
+      });
+    }
+    return Effect.map(union.message, message => ({
+      message,
+      override: union.override
+    }));
+  }
 }));
 const createParseIssueGuard = tag => issue => issue._tag === tag;
 /**
@@ -1486,110 +1470,119 @@ const createParseIssueGuard = tag => issue => issue._tag === tag;
 const isComposite = exports.isComposite = /*#__PURE__*/createParseIssueGuard("Composite");
 const isRefinement = /*#__PURE__*/createParseIssueGuard("Refinement");
 const isTransformation = /*#__PURE__*/createParseIssueGuard("Transformation");
-const getMessage = issue => getCurrentMessage(issue).pipe(Effect.flatMap(currentMessage => {
-  const useInnerMessage = !currentMessage.override && (isComposite(issue) || isRefinement(issue) && issue.kind === "From" || isTransformation(issue) && issue.kind !== "Transformation");
-  return useInnerMessage ? isTransformation(issue) || isRefinement(issue) ? getMessage(issue.issue) : Option.none() : Effect.succeed(currentMessage.message);
-}));
-const getParseIssueTitleAnnotation = issue => getAnnotated(issue).pipe(Option.flatMap(AST.getParseIssueTitleAnnotation), Option.filterMap(annotation => Option.fromNullable(annotation(issue))));
+const getMessage = issue => flatMap(getCurrentMessage(issue), currentMessage => {
+  if (currentMessage !== undefined) {
+    const useInnerMessage = !currentMessage.override && (isComposite(issue) || isRefinement(issue) && issue.kind === "From" || isTransformation(issue) && issue.kind !== "Transformation");
+    return useInnerMessage ? isTransformation(issue) || isRefinement(issue) ? getMessage(issue.issue) : Either_void : Either.right(currentMessage.message);
+  }
+  return Either_void;
+});
+const getParseIssueTitleAnnotation = issue => getAnnotated(issue).pipe(Option.flatMap(AST.getParseIssueTitleAnnotation), Option.filterMap(annotation => Option.fromNullable(annotation(issue))), Option.getOrUndefined);
 /** @internal */
 function getRefinementExpected(ast) {
   return AST.getDescriptionAnnotation(ast).pipe(Option.orElse(() => AST.getTitleAnnotation(ast)), Option.orElse(() => AST.getAutoTitleAnnotation(ast)), Option.orElse(() => AST.getIdentifierAnnotation(ast)), Option.getOrElse(() => `{ ${ast.from} | filter }`));
 }
-function getDefaultTypeMessage(e) {
-  if (e.message !== undefined) {
-    return e.message;
+function getDefaultTypeMessage(issue) {
+  if (issue.message !== undefined) {
+    return issue.message;
   }
-  const expected = AST.isRefinement(e.ast) ? getRefinementExpected(e.ast) : String(e.ast);
-  return `Expected ${expected}, actual ${util_.formatUnknown(e.actual)}`;
+  const expected = AST.isRefinement(issue.ast) ? getRefinementExpected(issue.ast) : String(issue.ast);
+  return `Expected ${expected}, actual ${util_.formatUnknown(issue.actual)}`;
 }
-const formatTypeMessage = e => getMessage(e).pipe(Effect.orElse(() => getParseIssueTitleAnnotation(e)), Effect.catchAll(() => Effect.succeed(getDefaultTypeMessage(e))));
-const getParseIssueTitle = issue => Option.getOrElse(getParseIssueTitleAnnotation(issue), () => String(issue.ast));
-const formatForbiddenMessage = e => e.message ?? "is forbidden";
-const formatUnexpectedMessage = e => e.message ?? "is unexpected";
-const formatMissingMessage = e => AST.getMissingMessageAnnotation(e.ast).pipe(Effect.flatMap(annotation => {
-  const out = annotation();
-  return Predicate.isString(out) ? Effect.succeed(out) : out;
-}), Effect.catchAll(() => Effect.succeed(e.message ?? "is missing")));
-const getTree = (issue, onFailure) => Effect.matchEffect(getMessage(issue), {
-  onFailure,
-  onSuccess: message => Effect.succeed(makeTree(message))
-});
-const formatTree = e => {
-  switch (e._tag) {
+const formatTypeMessage = issue => map(getMessage(issue), message => message ?? getParseIssueTitleAnnotation(issue) ?? getDefaultTypeMessage(issue));
+const getParseIssueTitle = issue => getParseIssueTitleAnnotation(issue) ?? String(issue.ast);
+const formatForbiddenMessage = issue => issue.message ?? "is forbidden";
+const formatUnexpectedMessage = issue => issue.message ?? "is unexpected";
+const formatMissingMessage = issue => {
+  const missingMessageAnnotation = AST.getMissingMessageAnnotation(issue.ast);
+  if (Option.isSome(missingMessageAnnotation)) {
+    const annotation = missingMessageAnnotation.value();
+    return Predicate.isString(annotation) ? Either.right(annotation) : annotation;
+  }
+  return Either.right(issue.message ?? "is missing");
+};
+const formatTree = issue => {
+  switch (issue._tag) {
     case "Type":
-      return Effect.map(formatTypeMessage(e), makeTree);
+      return map(formatTypeMessage(issue), makeTree);
     case "Forbidden":
-      return Effect.succeed(makeTree(getParseIssueTitle(e), [makeTree(formatForbiddenMessage(e))]));
+      return Either.right(makeTree(getParseIssueTitle(issue), [makeTree(formatForbiddenMessage(issue))]));
     case "Unexpected":
-      return Effect.succeed(makeTree(formatUnexpectedMessage(e)));
+      return Either.right(makeTree(formatUnexpectedMessage(issue)));
     case "Missing":
-      return Effect.map(formatMissingMessage(e), makeTree);
+      return map(formatMissingMessage(issue), makeTree);
     case "Transformation":
-      return getTree(e, () => Effect.map(formatTree(e.issue), tree => makeTree(getParseIssueTitle(e), [makeTree(formatTransformationKind(e.kind), [tree])])));
+      return flatMap(getMessage(issue), message => {
+        if (message !== undefined) {
+          return Either.right(makeTree(message));
+        }
+        return map(formatTree(issue.issue), tree => makeTree(getParseIssueTitle(issue), [makeTree(formatTransformationKind(issue.kind), [tree])]));
+      });
     case "Refinement":
-      return getTree(e, () => Effect.map(formatTree(e.issue), tree => makeTree(getParseIssueTitle(e), [makeTree(formatRefinementKind(e.kind), [tree])])));
+      return flatMap(getMessage(issue), message => {
+        if (message !== undefined) {
+          return Either.right(makeTree(message));
+        }
+        return map(formatTree(issue.issue), tree => makeTree(getParseIssueTitle(issue), [makeTree(formatRefinementKind(issue.kind), [tree])]));
+      });
     case "Pointer":
-      return Effect.map(formatTree(e.issue), tree => makeTree(util_.formatPath(e.path), [tree]));
+      return map(formatTree(issue.issue), tree => makeTree(util_.formatPath(issue.path), [tree]));
     case "Composite":
-      {
-        const parseIssueTitle = getParseIssueTitle(e);
-        return getTree(e, () => util_.isNonEmpty(e.issues) ? Effect.map(Effect.forEach(e.issues, formatTree), forest => makeTree(parseIssueTitle, forest)) : Effect.map(formatTree(e.issues), tree => makeTree(parseIssueTitle, [tree])));
-      }
+      return flatMap(getMessage(issue), message => {
+        if (message !== undefined) {
+          return Either.right(makeTree(message));
+        }
+        const parseIssueTitle = getParseIssueTitle(issue);
+        return util_.isNonEmpty(issue.issues) ? map(Effect.forEach(issue.issues, formatTree), forest => makeTree(parseIssueTitle, forest)) : map(formatTree(issue.issues), tree => makeTree(parseIssueTitle, [tree]));
+      });
   }
 };
+const makeArrayFormatterIssue = (_tag, path, message) => ({
+  _tag,
+  path,
+  message
+});
 /**
  * @category formatting
  * @since 3.10.0
  */
 const ArrayFormatter = exports.ArrayFormatter = {
-  formatIssue: issue => formatArray(issue),
-  formatIssueSync: issue => Effect.runSync(ArrayFormatter.formatIssue(issue)),
+  formatIssue: issue => getArrayFormatterIssues(issue),
+  formatIssueSync: issue => {
+    const e = ArrayFormatter.formatIssue(issue);
+    return isEither(e) ? Either.getOrThrow(e) : Effect.runSync(e);
+  },
   formatError: error => ArrayFormatter.formatIssue(error.issue),
   formatErrorSync: error => ArrayFormatter.formatIssueSync(error.issue)
 };
-const succeedArrayFormatterIssue = issue => Effect.succeed([issue]);
-const getArray = (issue, path, onFailure) => Effect.matchEffect(getMessage(issue), {
-  onFailure,
-  onSuccess: message => succeedArrayFormatterIssue({
-    _tag: issue._tag,
-    path,
-    message
-  })
-});
-const formatArray = (e, path = []) => {
-  const _tag = e._tag;
+const getArrayFormatterIssues = (issue, path = []) => {
+  const _tag = issue._tag;
   switch (_tag) {
     case "Type":
-      return Effect.map(formatTypeMessage(e), message => [{
-        _tag,
-        path,
-        message
-      }]);
+      return map(formatTypeMessage(issue), message => [makeArrayFormatterIssue(_tag, path, message)]);
     case "Forbidden":
-      return succeedArrayFormatterIssue({
-        _tag,
-        path,
-        message: formatForbiddenMessage(e)
-      });
+      return Either.right([makeArrayFormatterIssue(_tag, path, formatForbiddenMessage(issue))]);
     case "Unexpected":
-      return succeedArrayFormatterIssue({
-        _tag,
-        path,
-        message: formatUnexpectedMessage(e)
-      });
+      return Either.right([makeArrayFormatterIssue(_tag, path, formatUnexpectedMessage(issue))]);
     case "Missing":
-      return Effect.map(formatMissingMessage(e), message => [{
-        _tag,
-        path,
-        message
-      }]);
+      return map(formatMissingMessage(issue), message => [makeArrayFormatterIssue(_tag, path, message)]);
     case "Pointer":
-      return formatArray(e.issue, path.concat(e.path));
+      return getArrayFormatterIssues(issue.issue, path.concat(issue.path));
     case "Composite":
-      return getArray(e, path, () => util_.isNonEmpty(e.issues) ? Effect.map(Effect.forEach(e.issues, issue => formatArray(issue, path)), Arr.flatten) : formatArray(e.issues, path));
+      return flatMap(getMessage(issue), message => {
+        if (message !== undefined) {
+          return Either.right([makeArrayFormatterIssue(issue._tag, path, message)]);
+        }
+        return util_.isNonEmpty(issue.issues) ? map(Effect.forEach(issue.issues, issue => getArrayFormatterIssues(issue, path)), Arr.flatten) : getArrayFormatterIssues(issue.issues, path);
+      });
     case "Refinement":
     case "Transformation":
-      return getArray(e, path, () => formatArray(e.issue, path));
+      return flatMap(getMessage(issue), message => {
+        if (message !== undefined) {
+          return Either.right([makeArrayFormatterIssue(issue._tag, path, message)]);
+        }
+        return getArrayFormatterIssues(issue.issue, path);
+      });
   }
 };
 //# sourceMappingURL=ParseResult.js.map