effect 4.0.0-beta.84 → 4.0.0-beta.86

package/dist/SchemaAST.js

@@ -23,7 +23,6 @@ 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";
@@ -450,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);
+    return tps === this.typeParameters && checks === this.checks && encodingChecks === this.encodingChecks ? 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() {
@@ -783,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;
   }
@@ -798,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}
@@ -838,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(""))));
   }
@@ -921,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;
   }
@@ -953,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";
   }
@@ -997,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;
@@ -1101,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]);
   }
@@ -1148,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]);
   }
@@ -1304,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);
+    return elements === this.elements && rest === this.rest && checks === this.checks && encodingChecks === this.encodingChecks ? 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() {
@@ -1373,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.
@@ -1445,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.
  *
@@ -1475,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;
@@ -1570,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") {
@@ -1665,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]);
@@ -1691,26 +1738,26 @@ 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);
     });
-    return props === this.propertySignatures && indexes === this.indexSignatures ? this : new Objects(props, indexes, this.annotations, checks, undefined, this.context, encodingChecks);
+    return props === this.propertySignatures && indexes === this.indexSignatures && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Objects(props, indexes, this.annotations, checks, undefined, this.context, encodingChecks);
   }
   /** @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() {
@@ -1739,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) {
@@ -1774,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);
 }
@@ -2001,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);
+    return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? 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) {
@@ -2143,18 +2194,6 @@ export class Suspend extends Base {
     return getExpected(this.thunk());
   }
 }
-/** @internal */
-export function getEncodingChecks(ast) {
-  switch (ast._tag) {
-    case "Declaration":
-    case "Arrays":
-    case "Objects":
-    case "Union":
-      return ast.encodingChecks;
-    default:
-      return undefined;
-  }
-}
 // -----------------------------------------------------------------------------
 // Checks
 // -----------------------------------------------------------------------------
@@ -2354,7 +2393,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;
@@ -2370,6 +2409,13 @@ export function applyToLastLink(f) {
   return ast => ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, f)) : ast;
 }
 /** @internal */
+export function applyToSelfOrLastLinkEncoding(f) {
+  function out(ast) {
+    return ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, out)) : f(ast);
+  }
+  return memoize(out);
+}
+/** @internal */
 export function middlewareDecoding(ast, middleware) {
   return appendTransformation(ast, middleware, toType(ast));
 }
@@ -2465,42 +2511,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 */
@@ -2565,9 +2602,13 @@ export const toType = /*#__PURE__*/memoize(ast => {
   }
   const out = ast;
   const type = out.recur?.(toType) ?? out;
-  if (getEncodingChecks(type)) {
+  const encodingChecks = type.encodingChecks;
+  if (encodingChecks) {
     return modifyOwnPropertyDescriptors(type, d => {
       d.encodingChecks.value = undefined;
+      if (type === ast) {
+        d.checks.value = combineChecks(type.checks, encodingChecks);
+      }
     });
   }
   return type;
@@ -2651,39 +2692,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 => {
@@ -2701,42 +2709,84 @@ 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], {
     title: e[0]
   })), "anyOf");
 });
-/** @internal */
-export function toCodec(f) {
-  function out(ast) {
-    return ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, out)) : f(ast);
-  }
-  return memoize(out);
-}
-const indexSignatureParameterFromString = /*#__PURE__*/toCodec(ast => {
+const parameterFromPropertyKey = /*#__PURE__*/applyToSelfOrLastLinkEncoding(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__*/applyToSelfOrLastLinkEncoding(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__*/applyToSelfOrLastLinkEncoding(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);
   }
 });
 /**
@@ -2745,6 +2795,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, {
@@ -3015,8 +3066,7 @@ export function isStringTree(u) {
   }
 }
 const StringTree = /*#__PURE__*/new Declaration([], () => (input, ast) => isStringTree(input) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input))), {
-  expected: "StringTree",
-  toCodecStringTree: () => new Link(unknown, SchemaTransformation.passthrough())
+  expected: "StringTree"
 });
 /** @internal */
 export const unknownToStringTree = /*#__PURE__*/new Link(StringTree, /*#__PURE__*/SchemaTransformation.passthrough());