effect 3.12.2 → 3.12.3

package/src/Arbitrary.ts

@@ -360,31 +360,39 @@ export const toOp = (
     case "TemplateLiteral":
       return new Succeed((fc) => {
         const string = fc.string({ maxLength: 5 })
-        const number = fc.float({ noDefaultInfinity: true }).filter((n) => !Number.isNaN(n))
-
-        const components: Array<FastCheck.Arbitrary<string | number>> = ast.head !== "" ? [fc.constant(ast.head)] : []
-
-        const addArb = (ast: AST.TemplateLiteralSpan["type"]) => {
-          switch (ast._tag) {
-            case "StringKeyword":
-              return components.push(string)
-            case "NumberKeyword":
-              return components.push(number)
-            case "Literal":
-              return components.push(fc.constant(String(ast.literal)))
-            case "Union":
-              return ast.types.forEach(addArb)
+        const number = fc.float({ noDefaultInfinity: true, noNaN: true })
+
+        const getTemplateLiteralArb = (ast: AST.TemplateLiteral) => {
+          const components: Array<FastCheck.Arbitrary<string | number>> = ast.head !== "" ? [fc.constant(ast.head)] : []
+
+          const getTemplateLiteralSpanTypeArb = (
+            ast: AST.TemplateLiteralSpan["type"]
+          ): FastCheck.Arbitrary<string | number> => {
+            switch (ast._tag) {
+              case "StringKeyword":
+                return string
+              case "NumberKeyword":
+                return number
+              case "Literal":
+                return fc.constant(String(ast.literal))
+              case "Union":
+                return fc.oneof(...ast.types.map(getTemplateLiteralSpanTypeArb))
+              case "TemplateLiteral":
+                return getTemplateLiteralArb(ast)
+            }
           }
-        }
 
-        ast.spans.forEach((span) => {
-          addArb(span.type)
-          if (span.literal !== "") {
-            components.push(fc.constant(span.literal))
-          }
-        })
+          ast.spans.forEach((span) => {
+            components.push(getTemplateLiteralSpanTypeArb(span.type))
+            if (span.literal !== "") {
+              components.push(fc.constant(span.literal))
+            }
+          })
 
-        return fc.tuple(...components).map((spans) => spans.join(""))
+          return fc.tuple(...components).map((spans) => spans.join(""))
+        }
+
+        return getTemplateLiteralArb(ast)
       })
     case "Refinement": {
       const from = toOp(ast.from, ctx, path)
@@ -452,7 +460,7 @@ export const toOp = (
       return new Succeed((fc) => fc.constant(null).chain(() => get()(fc)))
     }
     case "Transformation":
-      return new Succeed(go(ast.to, ctx, path))
+      return toOp(ast.to, ctx, path)
   }
 }
 
@@ -577,6 +585,16 @@ const getOr = (a: boolean | undefined, b: boolean | undefined): boolean | undefi
   return a === undefined ? b : b === undefined ? a : a || b
 }
 
+function mergePattern(pattern1: string | undefined, pattern2: string | undefined): string | undefined {
+  if (pattern1 === undefined) {
+    return pattern2
+  }
+  if (pattern2 === undefined) {
+    return pattern1
+  }
+  return `(?:${pattern1})|(?:${pattern2})`
+}
+
 const merge = (c1: Config, c2: Constraints | undefined): Config => {
   if (c2) {
     switch (c1._tag) {
@@ -585,7 +603,7 @@ const merge = (c1: Config, c2: Constraints | undefined): Config => {
           return makeStringConstraints({
             minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
             maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength),
-            pattern: c1.pattern ?? c2.pattern
+            pattern: mergePattern(c1.pattern, c2.pattern)
           })
         }
         break

package/src/SchemaAST.ts

@@ -2100,7 +2100,7 @@ export const annotations = (ast: AST, a: Annotations): AST => {
  */
 export const keyof = (ast: AST): AST => Union.unify(_keyof(ast))
 
-const STRING_KEYWORD_PATTERN = ".*"
+const STRING_KEYWORD_PATTERN = "[\\s\\S]*" // any string, including newlines
 const NUMBER_KEYWORD_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?"
 
 const getTemplateLiteralSpanTypePattern = (type: TemplateLiteralSpanType, capture: boolean): string => {

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.12.2"
+let moduleVersion = "3.12.3"
 
 export const getCurrentVersion = () => moduleVersion