effect 3.13.9 → 3.13.11

package/src/Schema.ts

@@ -2631,14 +2631,32 @@ export const optionalWith: {
  * @since 3.10.0
  */
 export declare namespace Struct {
+  /**
+   * Useful for creating a type that can be used to add custom constraints to the fields of a struct.
+   *
+   * ```ts
+   * import { Schema } from "effect"
+   *
+   * const f = <Fields extends Record<"a" | "b", Schema.Struct.Field>>(
+   *   schema: Schema.Struct<Fields>
+   * ) => {
+   *   return schema.omit("a")
+   * }
+   *
+   * //      ┌─── Schema.Struct<{ b: typeof Schema.Number; }>
+   * //      ▼
+   * const result = f(Schema.Struct({ a: Schema.String, b: Schema.Number }))
+   * ```
+   * @since 3.13.11
+   */
+  export type Field =
+    | Schema.All
+    | PropertySignature.All
+
   /**
    * @since 3.10.0
    */
-  export type Fields = {
-    readonly [x: PropertyKey]:
-      | Schema.All
-      | PropertySignature.All
-  }
+  export type Fields = { readonly [x: PropertyKey]: Field }
 
   type OptionalEncodedPropertySignature =
     | PropertySignature<PropertySignature.Token, any, PropertyKey, "?:", any, boolean, unknown>
@@ -2724,30 +2742,30 @@ export declare namespace IndexSignature {
    */
   export type NonEmptyRecords = array_.NonEmptyReadonlyArray<Record>
 
+  type MergeTuple<T extends ReadonlyArray<unknown>> = T extends readonly [infer Head, ...infer Tail] ?
+    Head & MergeTuple<Tail>
+    : {}
+
   /**
    * @since 3.10.0
    */
-  export type Type<
-    Records extends IndexSignature.Records
-  > = Types.UnionToIntersection<
+  export type Type<Records extends IndexSignature.Records> = MergeTuple<
     {
-      [K in keyof Records]: {
+      readonly [K in keyof Records]: {
         readonly [P in Schema.Type<Records[K]["key"]>]: Schema.Type<Records[K]["value"]>
       }
-    }[number]
+    }
   >
 
   /**
    * @since 3.10.0
    */
-  export type Encoded<
-    Records extends IndexSignature.Records
-  > = Types.UnionToIntersection<
+  export type Encoded<Records extends IndexSignature.Records> = MergeTuple<
     {
-      [K in keyof Records]: {
+      readonly [K in keyof Records]: {
         readonly [P in Schema.Encoded<Records[K]["key"]>]: Schema.Encoded<Records[K]["value"]>
       }
-    }[number]
+    }
   >
 
   /**
@@ -2800,7 +2818,7 @@ export interface TypeLiteral<
     | IndexSignature.Context<Records>
   >
 {
-  readonly fields: { readonly [K in keyof Fields]: Fields[K] }
+  readonly fields: Readonly<Fields>
   readonly records: Readonly<Records>
   annotations(
     annotations: Annotations.Schema<Simplify<TypeLiteral.Type<Fields, Records>>>
@@ -2910,14 +2928,11 @@ const lazilyMergeDefaults = (
   return out
 }
 
-const makeTypeLiteralClass = <
-  Fields extends Struct.Fields,
-  const Records extends IndexSignature.Records
->(
+function makeTypeLiteralClass<Fields extends Struct.Fields, const Records extends IndexSignature.Records>(
   fields: Fields,
   records: Records,
   ast: AST.AST = getDefaultTypeLiteralAST(fields, records)
-): TypeLiteral<Fields, Records> => {
+): TypeLiteral<Fields, Records> {
   return class TypeLiteralClass extends make<
     Simplify<TypeLiteral.Type<Fields, Records>>,
     Simplify<TypeLiteral.Encoded<Fields, Records>>,
@@ -2958,7 +2973,22 @@ const makeTypeLiteralClass = <
  * @category api interface
  * @since 3.10.0
  */
-export interface Struct<Fields extends Struct.Fields> extends TypeLiteral<Fields, []> {
+export interface Struct<Fields extends Struct.Fields> extends
+  AnnotableClass<
+    Struct<Fields>,
+    Simplify<Struct.Type<Fields>>,
+    Simplify<Struct.Encoded<Fields>>,
+    Struct.Context<Fields>
+  >
+{
+  readonly fields: Readonly<Fields>
+  readonly records: readonly []
+  make(
+    props: RequiredKeys<Struct.Constructor<Fields>> extends never ? void | Simplify<Struct.Constructor<Fields>>
+      : Simplify<Struct.Constructor<Fields>>,
+    options?: MakeOptions
+  ): Simplify<Struct.Type<Fields>>
+
   annotations(annotations: Annotations.Schema<Simplify<Struct.Type<Fields>>>): Struct<Fields>
   pick<Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys): Struct<Simplify<Pick<Fields, Keys[number]>>>
   omit<Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys): Struct<Simplify<Omit<Fields, Keys[number]>>>
@@ -2991,8 +3021,6 @@ export interface tag<Tag extends AST.LiteralValue> extends PropertySignature<":"
  * A tag is a literal value that is used to distinguish between different types of objects.
  * The tag is optional when using the `make` method.
  *
- * @see {@link TaggedStruct}
- *
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -3007,6 +3035,8 @@ export interface tag<Tag extends AST.LiteralValue> extends PropertySignature<":"
  * assert.deepStrictEqual(User.make({ name: "John", age: 44 }), { _tag: "User", name: "John", age: 44 })
  * ```
  *
+ * @see {@link TaggedStruct}
+ *
  * @since 3.10.0
  */
 export const tag = <Tag extends AST.LiteralValue>(tag: Tag): tag<Tag> =>
@@ -3050,29 +3080,43 @@ export const TaggedStruct = <Tag extends AST.LiteralValue, Fields extends Struct
  * @category api interface
  * @since 3.10.0
  */
-export interface Record$<K extends Schema.All, V extends Schema.All> extends TypeLiteral<{}, [{ key: K; value: V }]> {
+export interface Record$<K extends Schema.All, V extends Schema.All> extends
+  AnnotableClass<
+    Record$<K, V>,
+    { readonly [P in Schema.Type<K>]: Schema.Type<V> },
+    { readonly [P in Schema.Encoded<K>]: Schema.Encoded<V> },
+    | Schema.Context<K>
+    | Schema.Context<V>
+  >
+{
+  readonly fields: {}
+  readonly records: readonly [{ readonly key: K; readonly value: V }]
   readonly key: K
   readonly value: V
-  annotations(
-    annotations: Annotations.Schema<Simplify<TypeLiteral.Type<{}, [{ key: K; value: V }]>>>
-  ): Record$<K, V>
+  make(
+    props: void | { readonly [P in Schema.Type<K>]: Schema.Type<V> },
+    options?: MakeOptions
+  ): { readonly [P in Schema.Type<K>]: Schema.Type<V> }
+  annotations(annotations: Annotations.Schema<{ readonly [P in Schema.Type<K>]: Schema.Type<V> }>): Record$<K, V>
 }
 
-const makeRecordClass = <K extends Schema.All, V extends Schema.All>(
+function makeRecordClass<K extends Schema.All, V extends Schema.All>(
   key: K,
   value: V,
   ast?: AST.AST
-): Record$<K, V> => (class RecordClass extends makeTypeLiteralClass({}, [{ key, value }], ast) {
-  static override annotations(
-    annotations: Annotations.Schema<Simplify<TypeLiteral.Type<{}, [{ key: K; value: V }]>>>
-  ) {
-    return makeRecordClass(key, value, mergeSchemaAnnotations(this.ast, annotations))
-  }
+): Record$<K, V> {
+  return class RecordClass extends makeTypeLiteralClass({}, [{ key, value }], ast) {
+    static override annotations(
+      annotations: Annotations.Schema<{ readonly [P in Schema.Type<K>]: Schema.Type<V> }>
+    ): Record$<K, V> {
+      return makeRecordClass(key, value, mergeSchemaAnnotations(this.ast, annotations))
+    }
 
-  static key = key
+    static key = key
 
-  static value = value
-})
+    static value = value
+  }
+}
 
 /**
  * @category constructors
@@ -9539,7 +9583,8 @@ const makeClass = <Fields extends Struct.Fields>(
             .join(", ")
         } })`
       },
-      configurable: true
+      configurable: true,
+      writable: true
     })
   }
   return klass
@@ -10500,6 +10545,7 @@ export function SortedSet<Value extends Schema.Any>(
  * Uses `!!val` to coerce the value to a `boolean`.
  *
  * @see https://developer.mozilla.org/docs/Glossary/Truthy
+ *
  * @category boolean constructors
  * @since 3.10.0
  */
@@ -11232,8 +11278,8 @@ const go = (ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equival
         let bStringKeys: Array<string> | undefined
         for (let i = 0; i < indexSignatures.length; i++) {
           const is = ast.indexSignatures[i]
-          const base = AST.getParameterBase(is.parameter)
-          const isSymbol = AST.isSymbolKeyword(base)
+          const encodedParameter = AST.getEncodedParameter(is.parameter)
+          const isSymbol = AST.isSymbolKeyword(encodedParameter)
           if (isSymbol) {
             bSymbolKeys = bSymbolKeys || Object.getOwnPropertySymbols(b)
             if (aSymbolKeys.length !== bSymbolKeys.length) {

package/src/SchemaAST.ts

@@ -1489,13 +1489,13 @@ export class TypeLiteral implements Annotated {
       symbol: false
     }
     for (let i = 0; i < indexSignatures.length; i++) {
-      const parameter = getParameterBase(indexSignatures[i].parameter)
-      if (isStringKeyword(parameter)) {
+      const encodedParameter = getEncodedParameter(indexSignatures[i].parameter)
+      if (isStringKeyword(encodedParameter)) {
         if (parameters.string) {
           throw new Error(errors_.getASTDuplicateIndexSignatureErrorMessage("string"))
         }
         parameters.string = true
-      } else if (isSymbolKeyword(parameter)) {
+      } else if (isSymbolKeyword(encodedParameter)) {
         if (parameters.symbol) {
           throw new Error(errors_.getASTDuplicateIndexSignatureErrorMessage("symbol"))
         }
@@ -2177,22 +2177,37 @@ export const getTemplateLiteralCapturingRegExp = (ast: TemplateLiteral): RegExp
  * @since 3.10.0
  */
 export const getPropertySignatures = (ast: AST): Array<PropertySignature> => {
+  const annotation = getSurrogateAnnotation(ast)
+  if (Option.isSome(annotation)) {
+    return getPropertySignatures(annotation.value)
+  }
   switch (ast._tag) {
-    case "Declaration": {
-      const annotation = getSurrogateAnnotation(ast)
-      if (Option.isSome(annotation)) {
-        return getPropertySignatures(annotation.value)
-      }
-      break
-    }
     case "TypeLiteral":
       return ast.propertySignatures.slice()
     case "Suspend":
       return getPropertySignatures(ast.f())
+    case "Refinement":
+      return getPropertySignatures(ast.from)
   }
   return getPropertyKeys(ast).map((name) => getPropertyKeyIndexedAccess(ast, name))
 }
 
+const getIndexSignatures = (ast: AST): Array<IndexSignature> => {
+  const annotation = getSurrogateAnnotation(ast)
+  if (Option.isSome(annotation)) {
+    return getIndexSignatures(annotation.value)
+  }
+  switch (ast._tag) {
+    case "TypeLiteral":
+      return ast.indexSignatures.slice()
+    case "Suspend":
+      return getIndexSignatures(ast.f())
+    case "Refinement":
+      return getIndexSignatures(ast.from)
+  }
+  return []
+}
+
 /** @internal */
 export const getNumberIndexedAccess = (ast: AST): AST => {
   switch (ast._tag) {
@@ -2232,10 +2247,10 @@ const getTypeLiteralPropertySignature = (ast: TypeLiteral, name: PropertyKey): P
   if (Predicate.isString(name)) {
     let out: PropertySignature | undefined = undefined
     for (const is of ast.indexSignatures) {
-      const parameterBase = getParameterBase(is.parameter)
-      switch (parameterBase._tag) {
+      const encodedParameter = getEncodedParameter(is.parameter)
+      switch (encodedParameter._tag) {
         case "TemplateLiteral": {
-          const regex = getTemplateLiteralRegExp(parameterBase)
+          const regex = getTemplateLiteralRegExp(encodedParameter)
           if (regex.test(name)) {
             return new PropertySignature(name, is.type, false, true)
           }
@@ -2253,8 +2268,8 @@ const getTypeLiteralPropertySignature = (ast: TypeLiteral, name: PropertyKey): P
     }
   } else if (Predicate.isSymbol(name)) {
     for (const is of ast.indexSignatures) {
-      const parameterBase = getParameterBase(is.parameter)
-      if (isSymbolKeyword(parameterBase)) {
+      const encodedParameter = getEncodedParameter(is.parameter)
+      if (isSymbolKeyword(encodedParameter)) {
         return new PropertySignature(name, is.type, false, true)
       }
     }
@@ -2298,13 +2313,15 @@ const getPropertyKeys = (ast: AST): Array<PropertyKey> => {
   switch (ast._tag) {
     case "TypeLiteral":
       return ast.propertySignatures.map((ps) => ps.name)
-    case "Suspend":
-      return getPropertyKeys(ast.f())
     case "Union":
       return ast.types.slice(1).reduce(
         (out: Array<PropertyKey>, ast) => Arr.intersection(out, getPropertyKeys(ast)),
         getPropertyKeys(ast.types[0])
       )
+    case "Suspend":
+      return getPropertyKeys(ast.f())
+    case "Refinement":
+      return getPropertyKeys(ast.from)
     case "Transformation":
       return getPropertyKeys(ast.to)
   }
@@ -2430,8 +2447,16 @@ export const pick = (ast: AST, keys: ReadonlyArray<PropertyKey>): TypeLiteral |
  *
  * @since 3.10.0
  */
-export const omit = (ast: AST, keys: ReadonlyArray<PropertyKey>): TypeLiteral | Transformation =>
-  pick(ast, getPropertyKeys(ast).filter((name) => !keys.includes(name)))
+export const omit = (ast: AST, keys: ReadonlyArray<PropertyKey>): TypeLiteral | Transformation => {
+  let indexSignatures = getIndexSignatures(ast)
+  if (indexSignatures.length > 0) {
+    if (indexSignatures.some((is) => isStringKeyword(getEncodedParameter(is.parameter)))) {
+      indexSignatures = indexSignatures.filter((is) => !isTemplateLiteral(getEncodedParameter(is.parameter)))
+    }
+    return new TypeLiteral([], indexSignatures)
+  }
+  return pick(ast, getPropertyKeys(ast).filter((name) => !keys.includes(name)))
+}
 
 /** @internal */
 export const orUndefined = (ast: AST): AST => Union.make([ast, undefinedKeyword])
@@ -2794,7 +2819,7 @@ const toJSONAnnotations = (annotations: Annotations): object => {
 }
 
 /** @internal */
-export const getParameterBase = (
+export const getEncodedParameter = (
   ast: Parameter
 ): StringKeyword | SymbolKeyword | TemplateLiteral => {
   switch (ast._tag) {
@@ -2803,7 +2828,7 @@ export const getParameterBase = (
     case "TemplateLiteral":
       return ast
     case "Refinement":
-      return getParameterBase(ast.from)
+      return getEncodedParameter(ast.from)
   }
 }
 
@@ -2866,7 +2891,7 @@ const _keyof = (ast: AST): Array<AST> => {
     case "TypeLiteral":
       return ast.propertySignatures.map((p): AST =>
         Predicate.isSymbol(p.name) ? new UniqueSymbol(p.name) : new Literal(p.name)
-      ).concat(ast.indexSignatures.map((is) => getParameterBase(is.parameter)))
+      ).concat(ast.indexSignatures.map((is) => getEncodedParameter(is.parameter)))
     case "Suspend":
       return _keyof(ast.f())
     case "Union":

package/src/Scope.ts

@@ -120,6 +120,7 @@ export declare namespace Scope {
  * `Exit` value that the scope is closed with.
  *
  * @see {@link addFinalizerExit}
+ *
  * @since 2.0.0
  * @category utils
  */
@@ -134,6 +135,7 @@ export const addFinalizer: (
  * on the exit status.
  *
  * @see {@link addFinalizer}
+ *
  * @since 2.0.0
  * @category utils
  */