Function TemplateLiteralParser

packages/effect/src/Schema.ts:923–962

(
  ...params: Params
)

 * @since 3.10.0
 */
export const TemplateLiteralParser = <Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParserParameters>>(
  ...params: Params
): TemplateLiteralParser<Params> => {
  const encodedSchemas: Array<Schema.Any> = []
  const elements: Array<Schema.Any> = []
  const schemas: Array<Schema.Any> = []
  let coerced = false
  for (let i = 0; i < params.length; i++) {
    const param = params[i]
    const schema = isSchema(param) ? param : Literal(param)
    schemas.push(schema)
    const encoded = encodedSchema(schema)
    encodedSchemas.push(encoded)
    const element = getTemplateLiteralParserCoercedElement(encoded, schema)
    if (element) {
      elements.push(element)
      coerced = true
    } else {
      elements.push(schema)
    }
  }
  const from = TemplateLiteral(...encodedSchemas as any)
  const re = AST.getTemplateLiteralCapturingRegExp(from.ast as AST.TemplateLiteral)
  let to = Tuple(...elements)
  if (coerced) {
    to = to.annotations({ [AST.AutoTitleAnnotationId]: format(Tuple(...schemas)) })
  }
  return class TemplateLiteralParserClass extends transformOrFail(from, to, {
    strict: false,
    decode: (i, _, ast) => {
      const match = re.exec(i)
      return match
        ? ParseResult.succeed(match.slice(1, params.length + 1))
        : ParseResult.fail(new ParseResult.Type(ast, i, `${re.source}: no match for ${JSON.stringify(i)}`))
    },
    encode: (tuple) => ParseResult.succeed(tuple.join(""))
  }) {
    static params = params.slice()
  } as any
}

const declareConstructor = <
  const TypeParameters extends ReadonlyArray<Schema.Any>,