effect 4.0.0-beta.22 → 4.0.0-beta.24

package/dist/Schema.js

@@ -4,6 +4,7 @@
 import * as Arr from "./Array.js";
 import * as BigDecimal_ from "./BigDecimal.js";
 import * as Cause_ from "./Cause.js";
+import * as Chunk_ from "./Chunk.js";
 import * as Data from "./Data.js";
 import * as DateTime from "./DateTime.js";
 import * as Duration_ from "./Duration.js";
@@ -1248,17 +1249,6 @@ export function TaggedStruct(value, fields) {
     ...fields
   });
 }
-/** @internal */
-export function _getTagValueIfPropertyKey(tag, ast) {
-  const ps = ast.propertySignatures.find(p => p.name === tag);
-  if (ps) {
-    if (AST.isLiteral(ps.type) && Predicate.isPropertyKey(ps.type.literal)) {
-      return ps.type.literal;
-    } else if (AST.isUniqueSymbol(ps.type)) {
-      return ps.type.symbol;
-    }
-  }
-}
 /**
  * @since 4.0.0
  * @experimental
@@ -1280,15 +1270,16 @@ export function toTaggedUnion(tag) {
       if (AST.isUnion(ast) && "members" in schema && globalThis.Array.isArray(schema.members) && schema.members.every(isSchema)) {
         return schema.members.forEach(walk);
       }
-      if (AST.isObjects(ast)) {
-        const key = _getTagValueIfPropertyKey(tag, ast);
-        if (key !== undefined) {
-          cases[key] = schema;
-          guards[key] = is(toType(schema));
+      const sentinels = AST.collectSentinels(ast);
+      if (sentinels.length > 0) {
+        const literal = sentinels.find(s => s.key === tag)?.literal;
+        if (Predicate.isPropertyKey(literal)) {
+          cases[literal] = schema;
+          guards[literal] = is(toType(schema));
           return;
         }
       }
-      throw new globalThis.Error("No literal found");
+      throw new globalThis.Error("No literal or unique symbol found");
     }
     function match() {
       if (arguments.length === 1) {
@@ -3838,6 +3829,58 @@ export function HashSet(value) {
     value
   });
 }
+/**
+ * Creates a schema that validates a `Chunk` where values must conform to the
+ * provided schema.
+ *
+ * @category Chunk
+ * @since 4.0.0
+ */
+export function Chunk(value) {
+  const schema = declareConstructor()([value], ([value]) => {
+    const values = Array(value);
+    return (input, ast, options) => {
+      if (Chunk_.isChunk(input)) {
+        return Effect.mapBothEager(Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
+          onSuccess: Chunk_.fromIterable,
+          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+        });
+      }
+      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+    };
+  }, {
+    typeConstructor: {
+      _tag: "effect/Chunk"
+    },
+    generation: {
+      runtime: `Schema.Chunk(?)`,
+      Type: `Chunk.Chunk<?>`
+    },
+    expected: "Chunk",
+    toCodec: ([value]) => link()(Array(value), Transformation.transform({
+      decode: Chunk_.fromIterable,
+      encode: Arr.fromIterable
+    })),
+    toArbitrary: ([value]) => (fc, ctx) => {
+      return fc.oneof(ctx?.isSuspend ? {
+        maxDepth: 2,
+        depthIdentifier: "Chunk"
+      } : {}, fc.constant([]), fc.array(value, ctx?.constraints?.array)).map(Chunk_.fromIterable);
+    },
+    toEquivalence: ([value]) => Chunk_.makeEquivalence(value),
+    toFormatter: ([value]) => t => {
+      const size = Chunk_.size(t);
+      if (size === 0) {
+        return "Chunk(0) {}";
+      }
+      const values = globalThis.Array.from(t).sort().map(v => `${value(v)}`);
+      return `Chunk(${size}) { ${values.join(", ")} }`;
+    }
+  });
+  return make(schema.ast, {
+    value
+  });
+}
 /**
  * @since 4.0.0
  */
@@ -4893,6 +4936,7 @@ function getClassSchemaFactory(from, identifier, annotations) {
         toCodec: ([from]) => new AST.Link(from.ast, transformation),
         toArbitrary: ([from]) => () => from.map(args => new self(args)),
         toFormatter: ([from]) => t => `${self.identifier}(${from(t)})`,
+        "~sentinels": AST.collectSentinels(from.ast),
         ...annotations
       }));
       memo = from.pipe(decodeTo(to, transformation));