effect 4.0.0-beta.83 → 4.0.0-beta.85

package/dist/SchemaAST.js

@@ -19,10 +19,10 @@ import { memoize } from "./Function.js";
 import { effectIsExit, iterateEager } from "./internal/effect.js";
 import * as internalRecord from "./internal/record.js";
 import * as InternalAnnotations from "./internal/schema/annotations.js";
+import * as InternalSchemaCause from "./internal/schema/cause.js";
 import * as Option from "./Option.js";
 import * as Pipeable from "./Pipeable.js";
 import * as Predicate from "./Predicate.js";
-import * as RegEx from "./RegExp.js";
 import * as Result from "./Result.js";
 import * as SchemaGetter from "./SchemaGetter.js";
 import * as SchemaIssue from "./SchemaIssue.js";
@@ -449,17 +449,17 @@ export class Declaration extends Base {
       return Effect.mapEager(run(oinput.value, this, options), Option.some);
     };
   }
-  rebuild(recur, checks, encodingChecks) {
+  _rebuild(recur, checks, encodingChecks) {
     const tps = mapOrSame(this.typeParameters, recur);
     return tps === this.typeParameters ? this : new Declaration(tps, this.run, this.annotations, checks, undefined, this.context, encodingChecks);
   }
   /** @internal */
   recur(recur) {
-    return this.rebuild(recur, this.checks, this.encodingChecks);
+    return this._rebuild(recur, this.checks, this.encodingChecks);
   }
   /** @internal */
   flip(recur) {
-    return this.rebuild(recur, this.encodingChecks, this.checks);
+    return this._rebuild(recur, this.encodingChecks, this.checks);
   }
   /** @internal */
   getExpected() {
@@ -782,11 +782,12 @@ function isTemplateLiteralPart(ast) {
     case "String":
     case "Number":
     case "BigInt":
+      return true;
     case "Literal":
     case "TemplateLiteral":
-      return true;
+      return ast.checks === undefined;
     case "Union":
-      return ast.types.every(isTemplateLiteralPart);
+      return ast.checks === undefined && ast.types.every(isTemplateLiteralPart);
     default:
       return false;
   }
@@ -797,8 +798,7 @@ function isTemplateLiteralPart(ast) {
  *
  * **Details**
  *
- * `parts` is an array of AST nodes; each part contributes to the
- * template literal pattern. A regex is derived from the parts to validate
+ * `parts` is an array of AST nodes; each part contributes to matching
  * strings at runtime.
  *
  * @see {@link isTemplateLiteral}
@@ -837,14 +837,17 @@ export class TemplateLiteral extends Base {
     return "string";
   }
   /** @internal */
+  matchPart(s, options) {
+    return segmentTemplateLiteralParts(this.encodedParts, s, options) === undefined ? undefined : s;
+  }
+  /** @internal */
   asTemplateLiteralParser() {
-    const tuple = new Arrays(false, this.parts.map(templateLiteralPartFromString), []);
-    const regExp = getTemplateLiteralRegExp(this);
-    return decodeTo(string, tuple, new SchemaTransformation.Transformation(SchemaGetter.transformOrFail(s => {
-      const match = regExp.exec(s);
-      if (match) return Effect.succeed(match.slice(1, this.parts.length + 1));
+    const tuple = new Arrays(false, this.parts.map(partFromString), []);
+    return decodeTo(string, tuple, new SchemaTransformation.Transformation(SchemaGetter.transformOrFail((s, options) => {
+      const segments = segmentTemplateLiteralParts(this.encodedParts, s, options);
+      if (segments !== undefined) return Effect.succeed(segments);
       return Effect.fail(new SchemaIssue.InvalidValue(Option.some(s), {
-        message: `Expected a value matching ${regExp.source}, got ${format(s)}`
+        message: `Expected a string matching template literal parts, got ${format(s)}`
       }));
     }), SchemaGetter.transform(parts => parts.join(""))));
   }
@@ -920,6 +923,10 @@ export class Literal extends Base {
     return fromConst(this, this.literal);
   }
   /** @internal */
+  matchPart(s, _options) {
+    return s === globalThis.String(this.literal) ? this.literal : undefined;
+  }
+  /** @internal */
   toCodecJson() {
     return typeof this.literal === "bigint" ? literalToString(this) : this;
   }
@@ -952,6 +959,10 @@ export class String extends Base {
     return fromRefinement(this, Predicate.isString);
   }
   /** @internal */
+  matchPart(s, options) {
+    return applyTemplateLiteralPartChecks(this, s, options);
+  }
+  /** @internal */
   getExpected() {
     return "string";
   }
@@ -996,6 +1007,17 @@ export class Number extends Base {
     return fromRefinement(this, Predicate.isNumber);
   }
   /** @internal */
+  matchKey(s, options) {
+    return this._match(isStringNumberRegExp, s, options);
+  }
+  /** @internal */
+  matchPart(s, options) {
+    return this._match(isStringFiniteRegExp, s, options);
+  }
+  _match(regexp, s, options) {
+    return regexp.test(s) ? applyTemplateLiteralPartChecks(this, globalThis.Number(s), options) : undefined;
+  }
+  /** @internal */
   toCodecJson() {
     if (this.checks && (hasCheck(this.checks, "isFinite") || hasCheck(this.checks, "isInt"))) {
       return this;
@@ -1100,6 +1122,10 @@ export class Symbol extends Base {
     return fromRefinement(this, Predicate.isSymbol);
   }
   /** @internal */
+  matchKey(s, options) {
+    return applyTemplateLiteralPartChecks(this, s, options);
+  }
+  /** @internal */
   toCodecStringTree() {
     return replaceEncoding(this, [symbolToString]);
   }
@@ -1147,6 +1173,10 @@ export class BigInt extends Base {
     return fromRefinement(this, Predicate.isBigInt);
   }
   /** @internal */
+  matchPart(s, options) {
+    return isStringBigIntRegExp.test(s) ? applyTemplateLiteralPartChecks(this, globalThis.BigInt(s), options) : undefined;
+  }
+  /** @internal */
   toCodecStringTree() {
     return replaceEncoding(this, [bigIntToString]);
   }
@@ -1303,18 +1333,18 @@ export class Arrays extends Base {
       return Option.some(state.output);
     });
   }
-  rebuild(recur, checks, encodingChecks) {
+  _rebuild(recur, checks, encodingChecks) {
     const elements = mapOrSame(this.elements, recur);
     const rest = mapOrSame(this.rest, recur);
     return elements === this.elements && rest === this.rest ? this : new Arrays(this.isMutable, elements, rest, this.annotations, checks, undefined, this.context, encodingChecks);
   }
   /** @internal */
   recur(recur) {
-    return this.rebuild(recur, this.checks, this.encodingChecks);
+    return this._rebuild(recur, this.checks, this.encodingChecks);
   }
   /** @internal */
   flip(recur) {
-    return this.rebuild(recur, this.encodingChecks, this.checks);
+    return this._rebuild(recur, this.encodingChecks, this.checks);
   }
   /** @internal */
   getExpected() {
@@ -1353,15 +1383,18 @@ const resolveConcurrency = value => {
   } : undefined;
 };
 const wrapPropertyKeyIssue = (s, ast, key, exit) => {
-  const issueResult = Cause.findError(exit.cause);
-  if (Result.isFailure(issueResult)) {
+  if (exit.cause.reasons.length === 0) {
     return exit;
   }
-  const issue = new SchemaIssue.Pointer([key], issueResult.success);
+  const issue = InternalSchemaCause.getSchemaIssue(exit.cause);
+  if (issue === undefined) {
+    return Exit.failCause(Cause.map(exit.cause, issue => new SchemaIssue.Composite(ast, s.oinput, [new SchemaIssue.Pointer([key], issue)])));
+  }
+  const pointer = new SchemaIssue.Pointer([key], issue);
   if (s.options.errors === "all") {
-    if (s.issues) s.issues.push(issue);else s.issues = [issue];
+    if (s.issues) s.issues.push(pointer);else s.issues = [pointer];
   } else {
-    return Exit.fail(new SchemaIssue.Composite(ast, s.oinput, [issue]));
+    return Exit.fail(new SchemaIssue.Composite(ast, s.oinput, [pointer]));
   }
 };
 /**
@@ -1369,30 +1402,29 @@ const wrapPropertyKeyIssue = (s, ast, key, exit) => {
  * @internal
  */
 export const FINITE_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?";
-const isNumberStringRegExp = /*#__PURE__*/new globalThis.RegExp(`(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)`);
 /**
  * Returns the object keys that match the index signature parameter schema.
  * @internal
  */
-export function getIndexSignatureKeys(input, parameter) {
-  const encoded = toEncoded(parameter);
-  switch (encoded._tag) {
-    case "String":
-      return Object.keys(input);
-    case "TemplateLiteral":
-      {
-        const regExp = getTemplateLiteralRegExp(encoded);
-        return Object.keys(input).filter(k => regExp.test(k));
-      }
-    case "Symbol":
-      return Object.getOwnPropertySymbols(input);
-    case "Number":
-      return Object.keys(input).filter(k => isNumberStringRegExp.test(k));
-    case "Union":
-      return [...new Set(encoded.types.flatMap(t => getIndexSignatureKeys(input, t)))];
-    default:
-      return [];
+export function getIndexSignatureKeys(input, parameter, options = defaultParseOptions) {
+  let stringKeys;
+  let symbolKeys;
+  function go(parameter) {
+    switch (parameter._tag) {
+      case "String":
+      case "TemplateLiteral":
+        return (stringKeys ??= Object.keys(input)).filter(k => parameter.matchPart(k, options) !== undefined);
+      case "Number":
+        return (stringKeys ??= Object.keys(input)).filter(k => parameter.matchKey(k, options) !== undefined);
+      case "Symbol":
+        return (symbolKeys ??= Object.getOwnPropertySymbols(input)).filter(k => parameter.matchKey(k, options) !== undefined);
+      case "Union":
+        return [...new Set(parameter.types.flatMap(go))];
+      default:
+        return [];
+    }
   }
+  return go(parameterFromPropertyKey(toEncoded(parameter)));
 }
 /**
  * Represents a named property within an {@link Objects} node.
@@ -1441,6 +1473,22 @@ export class KeyValueCombiner {
     return new KeyValueCombiner(this.encode, this.decode);
   }
 }
+function isIndexSignatureParameterSide(ast) {
+  switch (ast._tag) {
+    case "String":
+    case "Number":
+    case "Symbol":
+    case "TemplateLiteral":
+      return true;
+    case "Union":
+      return ast.types.every(isIndexSignatureParameterSide);
+    default:
+      return false;
+  }
+}
+function isIndexSignatureParameter(ast) {
+  return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterSide(toEncoded(ast));
+}
 /**
  * Represents an index signature entry within an {@link Objects} node.
  *
@@ -1471,6 +1519,9 @@ export class IndexSignature {
   type;
   merge;
   constructor(parameter, type, merge) {
+    if (!isIndexSignatureParameter(parameter)) {
+      throw new Error(`Invalid index signature parameter ${parameter._tag}`);
+    }
     this.parameter = parameter;
     this.type = type;
     this.merge = merge;
@@ -1566,7 +1617,7 @@ export class Objects extends Base {
     }
     const parseIndexes = indexCount > 0 ? iterateEager()({
       onItem: Effect.fnUntracedEager(function* (s, [key, is]) {
-        const parserKey = recur(indexSignatureParameterFromString(is.parameter));
+        const parserKey = recur(parameterFromPropertyKey(is.parameter));
         const effKey = parserKey(Option.some(key), s.options);
         const exitKey = effectIsExit(effKey) ? effKey : yield* Effect.exit(effKey);
         if (exitKey._tag === "Failure") {
@@ -1661,7 +1712,7 @@ export class Objects extends Base {
         const keyPairs = Arr.empty();
         for (let i = 0; i < indexCount; i++) {
           const is = ast.indexSignatures[i];
-          const keys = getIndexSignatureKeys(input, is.parameter);
+          const keys = getIndexSignatureKeys(input, is.parameter, options);
           for (let j = 0; j < keys.length; j++) {
             const key = keys[j];
             keyPairs.push([key, is]);
@@ -1687,13 +1738,13 @@ export class Objects extends Base {
       return Option.some(out);
     });
   }
-  rebuild(recur, flipMerge, checks, encodingChecks) {
+  _rebuild(recur, recurParameter, flipMerge, checks, encodingChecks) {
     const props = mapOrSame(this.propertySignatures, ps => {
       const t = recur(ps.type);
       return t === ps.type ? ps : new PropertySignature(ps.name, t);
     });
     const indexes = mapOrSame(this.indexSignatures, is => {
-      const p = recur(is.parameter);
+      const p = recurParameter(is.parameter);
       const t = recur(is.type);
       const merge = flipMerge ? is.merge?.flip() : is.merge;
       return p === is.parameter && t === is.type && merge === is.merge ? is : new IndexSignature(p, t, merge);
@@ -1702,11 +1753,11 @@ export class Objects extends Base {
   }
   /** @internal */
   flip(recur) {
-    return this.rebuild(recur, true, this.encodingChecks, this.checks);
+    return this._rebuild(recur, recur, true, this.encodingChecks, this.checks);
   }
   /** @internal */
-  recur(recur) {
-    return this.rebuild(recur, false, this.checks, this.encodingChecks);
+  recur(recur, recurParameter = recur) {
+    return this._rebuild(recur, recurParameter, false, this.checks, this.encodingChecks);
   }
   /** @internal */
   getExpected() {
@@ -1735,14 +1786,10 @@ const parseProperties = /*#__PURE__*/iterateEager()({
     }
   }
 });
-function mergeChecks(checks, b) {
-  if (!checks) {
-    return b.checks;
-  }
-  if (!b.checks) {
-    return checks;
-  }
-  return [...checks, ...b.checks];
+function combineChecks(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return [...a, ...b];
 }
 /** @internal */
 export function struct(fields, checks, annotations) {
@@ -1770,10 +1817,10 @@ export function structWithRest(ast, records) {
   let propertySignatures = ast.propertySignatures;
   let indexSignatures = ast.indexSignatures;
   let checks = ast.checks;
-  for (const r of records) {
-    propertySignatures = propertySignatures.concat(r.propertySignatures);
-    indexSignatures = indexSignatures.concat(r.indexSignatures);
-    checks = mergeChecks(checks, r);
+  for (const record of records) {
+    propertySignatures = propertySignatures.concat(record.propertySignatures);
+    indexSignatures = indexSignatures.concat(record.indexSignatures);
+    checks = combineChecks(checks, record.checks);
   }
   return new Objects(propertySignatures, indexSignatures, undefined, checks);
 }
@@ -1997,17 +2044,25 @@ export class Union extends Base {
       });
     };
   }
-  rebuild(recur, checks, encodingChecks) {
+  _rebuild(recur, checks, encodingChecks) {
     const types = mapOrSame(this.types, recur);
     return types === this.types ? this : new Union(types, this.mode, this.annotations, checks, undefined, this.context, encodingChecks);
   }
   /** @internal */
   recur(recur) {
-    return this.rebuild(recur, this.checks, this.encodingChecks);
+    return this._rebuild(recur, this.checks, this.encodingChecks);
   }
   /** @internal */
   flip(recur) {
-    return this.rebuild(recur, this.encodingChecks, this.checks);
+    return this._rebuild(recur, this.encodingChecks, this.checks);
+  }
+  /** @internal */
+  matchPart(s, options) {
+    for (const type of this.types) {
+      const out = type.matchPart(s, options);
+      if (out !== undefined) return out;
+    }
+    return undefined;
   }
   /** @internal */
   getExpected(getExpected) {
@@ -2046,11 +2101,11 @@ const parseUnion = /*#__PURE__*/iterateEager()({
   },
   step(s, candidate, exit) {
     if (exit._tag === "Failure") {
-      const issueResult = Cause.findError(exit.cause);
-      if (Result.isFailure(issueResult)) {
+      const issue = InternalSchemaCause.getSchemaIssue(exit.cause);
+      if (issue === undefined) {
         return exit;
       }
-      if (s.issues) s.issues.push(issueResult.success);else s.issues = [issueResult.success];
+      if (s.issues) s.issues.push(issue);else s.issues = [issue];
     } else {
       if (s.out && s.ast.mode === "oneOf") {
         s.successes.push(candidate);
@@ -2094,7 +2149,7 @@ export function memoizeThunk(f) {
  * define recursive or mutually recursive schemas without infinite loops at
  * construction time.
  *
- * **Example** (Recursive schema AST)
+ * **Example** (Defining recursive schema ASTs)
  *
  * ```ts
  * import { Schema, SchemaAST } from "effect"
@@ -2350,7 +2405,7 @@ export function replaceChecks(ast, checks) {
 }
 /** @internal */
 export function appendChecks(ast, checks) {
-  return replaceChecks(ast, ast.checks ? [...ast.checks, ...checks] : checks);
+  return replaceChecks(ast, combineChecks(ast.checks, checks));
 }
 function updateLastLink(encoding, f) {
   const links = encoding;
@@ -2461,42 +2516,33 @@ export function decodeTo(from, to, transformation) {
   return appendTransformation(from, transformation, to);
 }
 function parseParameter(ast) {
-  switch (ast._tag) {
-    case "Literal":
-      return {
-        literals: Predicate.isPropertyKey(ast.literal) ? [ast.literal] : [],
-        parameters: []
-      };
-    case "UniqueSymbol":
-      return {
-        literals: [ast.symbol],
-        parameters: []
-      };
-    case "String":
-    case "Number":
-    case "Symbol":
-    case "TemplateLiteral":
-      return {
-        literals: [],
-        parameters: [ast]
-      };
-    case "Union":
-      {
-        const out = {
-          literals: [],
-          parameters: []
-        };
+  const literals = [];
+  const parameters = [];
+  function go(ast) {
+    switch (ast._tag) {
+      case "Literal":
+        if (Predicate.isPropertyKey(ast.literal)) {
+          literals.push(ast.literal);
+        }
+        return;
+      case "UniqueSymbol":
+        literals.push(ast.symbol);
+        return;
+      case "Never":
+        return;
+      case "Union":
         for (let i = 0; i < ast.types.length; i++) {
-          const parsed = parseParameter(ast.types[i]);
-          out.literals = out.literals.concat(parsed.literals);
-          out.parameters = out.parameters.concat(parsed.parameters);
+          go(ast.types[i]);
         }
-        return out;
-      }
+        return;
+      default:
+        parameters.push(ast);
+    }
   }
+  go(ast);
   return {
-    literals: [],
-    parameters: []
+    literals,
+    parameters
   };
 }
 /** @internal */
@@ -2647,39 +2693,6 @@ export function containsUndefined(ast) {
       return false;
   }
 }
-function getTemplateLiteralSource(ast, top) {
-  return ast.encodedParts.map(part => handleTemplateLiteralASTPartParens(part, getTemplateLiteralASTPartPattern(part), top)).join("");
-}
-/** @internal */
-export const getTemplateLiteralRegExp = /*#__PURE__*/memoize(ast => {
-  return new globalThis.RegExp(`^${getTemplateLiteralSource(ast, true)}$`);
-});
-function getTemplateLiteralASTPartPattern(part) {
-  switch (part._tag) {
-    case "Literal":
-      return RegEx.escape(globalThis.String(part.literal));
-    case "String":
-      return STRING_PATTERN;
-    case "Number":
-      return FINITE_PATTERN;
-    case "BigInt":
-      return BIGINT_PATTERN;
-    case "TemplateLiteral":
-      return getTemplateLiteralSource(part, false);
-    case "Union":
-      return part.types.map(getTemplateLiteralASTPartPattern).join("|");
-  }
-}
-function handleTemplateLiteralASTPartParens(part, s, top) {
-  if (isUnion(part)) {
-    if (!top) {
-      return `(?:${s})`;
-    }
-  } else if (!top) {
-    return s;
-  }
-  return `(${s})`;
-}
 function fromConst(ast, value) {
   const succeed = Effect.succeedSome(value);
   return oinput => {
@@ -2697,6 +2710,46 @@ function fromRefinement(ast, refinement) {
     return refinement(oinput.value) ? Effect.succeed(oinput) : Effect.fail(new SchemaIssue.InvalidType(ast, oinput));
   };
 }
+function applyTemplateLiteralPartChecks(ast, value, options) {
+  if (options?.disableChecks || ast.checks === undefined) return value;
+  const issues = [];
+  collectIssues(ast.checks, value, issues, ast, options);
+  return issues.length === 0 ? value : undefined;
+}
+function segmentTemplateLiteralParts(parts, input, options) {
+  const out = new Array(parts.length);
+  const failures = new Set();
+  function go(i, pos) {
+    if (i === parts.length) return pos === input.length;
+    const key = `${i}/${pos}`;
+    if (failures.has(key)) return false;
+    const part = parts[i];
+    if (i === parts.length - 1) {
+      const s = input.slice(pos);
+      if (part.matchPart(s, options) !== undefined) {
+        out[i] = s;
+        return true;
+      }
+    } else if (part._tag === "Literal") {
+      const s = globalThis.String(part.literal);
+      if (input.startsWith(s, pos) && go(i + 1, pos + s.length)) {
+        out[i] = s;
+        return true;
+      }
+    } else {
+      for (let end = input.length; end >= pos; end--) {
+        const s = input.slice(pos, end);
+        if (part.matchPart(s, options) !== undefined && go(i + 1, end)) {
+          out[i] = s;
+          return true;
+        }
+      }
+    }
+    failures.add(key);
+    return false;
+  }
+  return go(0, 0) ? out : undefined;
+}
 /** @internal */
 export const enumsToLiterals = /*#__PURE__*/memoize(ast => {
   return new Union(ast.enums.map(e => new Literal(e[1], {
@@ -2710,29 +2763,38 @@ export function toCodec(f) {
   }
   return memoize(out);
 }
-const indexSignatureParameterFromString = /*#__PURE__*/toCodec(ast => {
+const parameterFromPropertyKey = /*#__PURE__*/toCodec(ast => {
   switch (ast._tag) {
     default:
       return ast;
     case "Number":
       return ast.toCodecStringTree();
     case "Union":
-      return ast.recur(indexSignatureParameterFromString);
+      return ast.recur(parameterFromPropertyKey);
   }
 });
-const templateLiteralPartFromString = /*#__PURE__*/toCodec(ast => {
+/** @internal */
+export const parameterFromString = /*#__PURE__*/toCodec(ast => {
   switch (ast._tag) {
     default:
       return ast;
-    case "String":
-    case "TemplateLiteral":
+    case "Symbol":
+    case "UniqueSymbol":
+      return ast.toCodecStringTree();
+    case "Union":
+      return ast.recur(parameterFromString);
+  }
+});
+const partFromString = /*#__PURE__*/toCodec(ast => {
+  switch (ast._tag) {
+    default:
       return ast;
-    case "BigInt":
     case "Number":
     case "Literal":
+    case "BigInt":
       return ast.toCodecStringTree();
     case "Union":
-      return ast.recur(templateLiteralPartFromString);
+      return ast.recur(partFromString);
   }
 });
 /**
@@ -2741,6 +2803,7 @@ const templateLiteralPartFromString = /*#__PURE__*/toCodec(ast => {
  */
 export const STRING_PATTERN = "[\\s\\S]*?";
 const isStringFiniteRegExp = /*#__PURE__*/new globalThis.RegExp(`^${FINITE_PATTERN}$`);
+const isStringNumberRegExp = /*#__PURE__*/new globalThis.RegExp(`(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)`);
 /** @internal */
 export function isStringFinite(annotations) {
   return isPattern(isStringFiniteRegExp, {