 Server : Apache/2 System : Linux server-15-235-50-60 5.15.0-164-generic #174-Ubuntu SMP Fri Nov 14 20:25:16 UTC 2025 x86_64 User : gositeme ( 1004) PHP Version : 8.2.29 Disable Function : exec,system,passthru,shell_exec,proc_close,proc_open,dl,popen,show_source,posix_kill,posix_mkfifo,posix_getpwuid,posix_setpgid,posix_setsid,posix_setuid,posix_setgid,posix_seteuid,posix_setegid,posix_uname Directory : /home/gositeme/domains/lavocat.quebec/private_html/node_modules/effect/dist/cjs/ |
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Array = exports.Any = void 0;
exports.ArrayEnsure = ArrayEnsure;
exports.Char = exports.CauseFromSelf = exports.Cause = exports.CapitalizedSchemaId = exports.Capitalized = exports.Capitalize = exports.BrandSchemaId = exports.BooleanFromUnknown = exports.BooleanFromString = exports.Boolean = exports.BigIntFromSelf = exports.BigIntFromNumber = exports.BigInt = exports.BigDecimalFromSelf = exports.BigDecimalFromNumber = exports.BigDecimal = exports.BetweenSchemaId = exports.BetweenDurationSchemaId = exports.BetweenDateSchemaId = exports.BetweenBigIntSchemaId = exports.BetweenBigDecimalSchemaId = exports.ArrayFormatterIssue = void 0;
exports.Chunk = Chunk;
exports.HashMapFromSelf = exports.HashMap = exports.GreaterThanSchemaId = exports.GreaterThanOrEqualToSchemaId = exports.GreaterThanOrEqualToDurationSchemaId = exports.GreaterThanOrEqualToDateSchemaId = exports.GreaterThanOrEqualToBigIntSchemaId = exports.GreaterThanOrEqualToBigDecimalSchemaId = exports.GreaterThanDurationSchemaId = exports.GreaterThanDateSchemaId = exports.GreaterThanBigIntSchemaId = exports.GreaterThanBigDecimalSchemaId = exports.FromPropertySignature = exports.FiniteSchemaId = exports.Finite = exports.FiberIdFromSelf = exports.FiberId = exports.ExitFromSelf = exports.Exit = exports.Enums = exports.EndsWithSchemaId = exports.EitherFromUnion = exports.EitherFromSelf = exports.Either = exports.DurationFromSelf = exports.DurationFromNanos = exports.DurationFromMillis = exports.Duration = exports.Defect = exports.DateTimeZonedFromSelf = exports.DateTimeZoned = exports.DateTimeUtcFromSelf = exports.DateTimeUtcFromNumber = exports.DateTimeUtcFromDate = exports.DateTimeUtc = exports.DateFromString = exports.DateFromSelfSchemaId = exports.DateFromSelf = exports.DateFromNumber = exports.Date = exports.DataFromSelf = exports.Data = exports.Config = exports.Class = exports.ChunkFromSelf = void 0;
exports.HashSet = HashSet;
exports.LessThanSchemaId = exports.LessThanOrEqualToSchemaId = exports.LessThanOrEqualToDurationSchemaId = exports.LessThanOrEqualToDateSchemaId = exports.LessThanOrEqualToBigIntSchemaId = exports.LessThanOrEqualToBigDecimalSchemaId = exports.LessThanDurationSchemaId = exports.LessThanDateSchemaId = exports.LessThanBigIntSchemaId = exports.LessThanBigDecimalSchemaId = exports.LengthSchemaId = exports.JsonNumberSchemaId = exports.JsonNumber = exports.ItemsCountSchemaId = exports.IntSchemaId = exports.Int = exports.InstanceOfSchemaId = exports.IncludesSchemaId = exports.HashSetFromSelf = void 0;
exports.List = List;
exports.ListFromSelf = void 0;
exports.Literal = Literal;
exports.LowercasedSchemaId = exports.Lowercased = exports.Lowercase = void 0;
exports.Map = map;
exports.MapFromSelf = exports.MapFromRecord = void 0;
exports.NonEmptyArray = exports.Never = exports.NegativeBigIntFromSelf = exports.NegativeBigInt = exports.NegativeBigDecimalSchemaId = exports.NegativeBigDecimalFromSelf = exports.Negative = exports.MultipleOfSchemaId = exports.MinLengthSchemaId = exports.MinItemsSchemaId = exports.MaxLengthSchemaId = exports.MaxItemsSchemaId = void 0;
exports.NonEmptyArrayEnsure = NonEmptyArrayEnsure;
exports.NonEmptyChunk = NonEmptyChunk;
exports.Object = exports.NumberFromString = exports.Number = exports.NullishOr = exports.NullOr = exports.Null = exports.Not = exports.NonPositiveBigIntFromSelf = exports.NonPositiveBigInt = exports.NonPositiveBigDecimalSchemaId = exports.NonPositiveBigDecimalFromSelf = exports.NonPositive = exports.NonNegativeInt = exports.NonNegativeBigIntFromSelf = exports.NonNegativeBigInt = exports.NonNegativeBigDecimalSchemaId = exports.NonNegativeBigDecimalFromSelf = exports.NonNegative = exports.NonNaNSchemaId = exports.NonNaN = exports.NonEmptyTrimmedString = exports.NonEmptyString = exports.NonEmptyChunkFromSelf = void 0;
exports.Option = Option;
exports.OptionFromNonEmptyTrimmedString = void 0;
exports.OptionFromNullOr = OptionFromNullOr;
exports.OptionFromNullishOr = OptionFromNullishOr;
exports.OptionFromSelf = void 0;
exports.OptionFromUndefinedOr = OptionFromUndefinedOr;
exports.PropertySignatureTypeId = exports.PropertySignatureTransformation = exports.PropertySignatureDeclaration = exports.PropertyKey = exports.PositiveBigIntFromSelf = exports.PositiveBigInt = exports.PositiveBigDecimalSchemaId = exports.PositiveBigDecimalFromSelf = exports.Positive = exports.PatternSchemaId = void 0;
exports.ReadonlyMap = ReadonlyMap;
exports.ReadonlyMapFromSelf = exports.ReadonlyMapFromRecord = void 0;
exports.ReadonlySet = ReadonlySet;
exports.Record = exports.ReadonlySetFromSelf = void 0;
exports.Redacted = Redacted;
exports.RefineSchemaId = exports.RedactedFromSelf = void 0;
exports.Set = set;
exports.SetFromSelf = void 0;
exports.SortedSet = SortedSet;
exports.StringFromUriComponent = exports.StringFromHex = exports.StringFromBase64Url = exports.StringFromBase64 = exports.String = exports.StartsWithSchemaId = exports.SortedSetFromSelf = void 0;
exports.Struct = Struct;
exports.TrimmedSchemaId = exports.Trimmed = exports.Trim = exports.ToPropertySignature = exports.TimeZoneOffsetFromSelf = exports.TimeZoneOffset = exports.TimeZoneNamedFromSelf = exports.TimeZoneNamed = exports.TimeZoneFromSelf = exports.TimeZone = exports.TemplateLiteralParser = exports.TemplateLiteral = exports.TaggedStruct = exports.TaggedRequest = exports.TaggedError = exports.TaggedClass = exports.SymbolFromSelf = exports.Symbol = void 0;
exports.Tuple = Tuple;
exports.Uint8 = exports.UUIDSchemaId = exports.UUID = exports.URLFromSelf = exports.URL = exports.ULIDSchemaId = exports.ULID = exports.TypeId = void 0;
exports.UndefinedOr = exports.Undefined = exports.UncapitalizedSchemaId = exports.Uncapitalized = exports.Uncapitalize = exports.Uint8ArrayFromSelf = exports.Uint8ArrayFromHex = exports.Uint8ArrayFromBase64Url = exports.Uint8ArrayFromBase64 = exports.Uint8Array = void 0;
exports.Union = Union;
exports.annotations = exports.Void = exports.ValidDateSchemaId = exports.ValidDateFromSelf = exports.UppercasedSchemaId = exports.Uppercased = exports.Uppercase = exports.Unknown = exports.UniqueSymbolFromSelf = void 0;
exports.asSchema = asSchema;
exports.asWithResult = exports.asSerializableWithResult = exports.asSerializable = void 0;
Object.defineProperty(exports, "asserts", {
enumerable: true,
get: function () {
return ParseResult.asserts;
}
});
exports.decodeEither = exports.decode = exports.declare = exports.compose = exports.clampDuration = exports.clampBigInt = exports.clampBigDecimal = exports.clamp = exports.capitalized = exports.brand = exports.betweenDuration = exports.betweenDate = exports.betweenBigInt = exports.betweenBigDecimal = exports.between = exports.attachPropertySignature = void 0;
Object.defineProperty(exports, "decodeOption", {
enumerable: true,
get: function () {
return ParseResult.decodeOption;
}
});
exports.decodePromise = void 0;
Object.defineProperty(exports, "decodeSync", {
enumerable: true,
get: function () {
return ParseResult.decodeSync;
}
});
exports.decodeUnknownEither = exports.decodeUnknown = void 0;
Object.defineProperty(exports, "decodeUnknownOption", {
enumerable: true,
get: function () {
return ParseResult.decodeUnknownOption;
}
});
exports.decodeUnknownPromise = void 0;
Object.defineProperty(exports, "decodeUnknownSync", {
enumerable: true,
get: function () {
return ParseResult.decodeUnknownSync;
}
});
exports.encodeEither = exports.encode = exports.element = exports.deserializeSuccess = exports.deserializeFailure = exports.deserializeExit = exports.deserialize = void 0;
Object.defineProperty(exports, "encodeOption", {
enumerable: true,
get: function () {
return ParseResult.encodeOption;
}
});
exports.encodePromise = void 0;
Object.defineProperty(exports, "encodeSync", {
enumerable: true,
get: function () {
return ParseResult.encodeSync;
}
});
exports.encodeUnknownEither = exports.encodeUnknown = void 0;
Object.defineProperty(exports, "encodeUnknownOption", {
enumerable: true,
get: function () {
return ParseResult.encodeUnknownOption;
}
});
exports.encodeUnknownPromise = void 0;
Object.defineProperty(exports, "encodeUnknownSync", {
enumerable: true,
get: function () {
return ParseResult.encodeUnknownSync;
}
});
exports.failureSchema = exports.extend = exports.exitSchema = exports.equivalence = exports.endsWith = exports.encodedSchema = exports.encodedBoundSchema = void 0;
exports.filter = filter;
exports.greaterThanOrEqualToDuration = exports.greaterThanOrEqualToDate = exports.greaterThanOrEqualToBigInt = exports.greaterThanOrEqualToBigDecimal = exports.greaterThanOrEqualTo = exports.greaterThanDuration = exports.greaterThanDate = exports.greaterThanBigInt = exports.greaterThanBigDecimal = exports.greaterThan = exports.getNumberIndexedAccess = exports.getClassTag = exports.fromKey = exports.fromBrand = exports.format = exports.finite = exports.filterEffect = void 0;
exports.head = head;
exports.headNonEmpty = headNonEmpty;
exports.int = exports.instanceOf = exports.includes = exports.headOrElse = void 0;
Object.defineProperty(exports, "is", {
enumerable: true,
get: function () {
return ParseResult.is;
}
});
exports.keyof = exports.itemsCount = exports.isSchema = exports.isPropertySignature = void 0;
exports.lowercased = exports.lessThanOrEqualToDuration = exports.lessThanOrEqualToDate = exports.lessThanOrEqualToBigInt = exports.lessThanOrEqualToBigDecimal = exports.lessThanOrEqualTo = exports.lessThanDuration = exports.lessThanDate = exports.lessThanBigInt = exports.lessThanBigDecimal = exports.lessThan = exports.length = void 0;
exports.make = make;
exports.parseJson = exports.optionalWith = exports.optionalToRequired = exports.optionalToOptional = exports.optionalElement = exports.optional = exports.omit = exports.nonPositiveBigInt = exports.nonPositiveBigDecimal = exports.nonPositive = exports.nonNegativeBigInt = exports.nonNegativeBigDecimal = exports.nonNegative = exports.nonNaN = exports.nonEmptyString = exports.negativeBigInt = exports.negativeBigDecimal = exports.negative = exports.mutable = exports.multipleOf = exports.minLength = exports.minItems = exports.maxLength = exports.maxItems = exports.makePropertySignature = void 0;
exports.parseNumber = parseNumber;
exports.transform = exports.tag = exports.symbolWithResult = exports.symbolSerializable = exports.suspend = exports.successSchema = exports.startsWith = exports.standardSchemaV1 = exports.split = exports.serializeSuccess = exports.serializeFailure = exports.serializeExit = exports.serialize = exports.serializableSchema = exports.requiredToOptional = exports.required = exports.rename = exports.propertySignature = exports.positiveBigInt = exports.positiveBigDecimal = exports.positive = exports.pluck = exports.pickLiteral = exports.pick = exports.pattern = exports.partialWith = exports.partial = void 0;
exports.transformLiteral = transformLiteral;
exports.transformLiterals = transformLiterals;
exports.validateEither = exports.validate = exports.validDate = exports.uppercased = exports.uncapitalized = exports.typeSchema = exports.trimmed = exports.transformOrFail = void 0;
Object.defineProperty(exports, "validateOption", {
enumerable: true,
get: function () {
return ParseResult.validateOption;
}
});
exports.validatePromise = void 0;
Object.defineProperty(exports, "validateSync", {
enumerable: true,
get: function () {
return ParseResult.validateSync;
}
});
exports.withDefaults = exports.withDecodingDefault = exports.withConstructorDefault = void 0;
var array_ = _interopRequireWildcard(require("./Array.js"));
var bigDecimal_ = _interopRequireWildcard(require("./BigDecimal.js"));
var bigInt_ = _interopRequireWildcard(require("./BigInt.js"));
var boolean_ = _interopRequireWildcard(require("./Boolean.js"));
var cause_ = _interopRequireWildcard(require("./Cause.js"));
var chunk_ = _interopRequireWildcard(require("./Chunk.js"));
var config_ = _interopRequireWildcard(require("./Config.js"));
var configError_ = _interopRequireWildcard(require("./ConfigError.js"));
var data_ = _interopRequireWildcard(require("./Data.js"));
var dateTime = _interopRequireWildcard(require("./DateTime.js"));
var duration_ = _interopRequireWildcard(require("./Duration.js"));
var Effect = _interopRequireWildcard(require("./Effect.js"));
var either_ = _interopRequireWildcard(require("./Either.js"));
var Encoding = _interopRequireWildcard(require("./Encoding.js"));
var Equal = _interopRequireWildcard(require("./Equal.js"));
var Equivalence = _interopRequireWildcard(require("./Equivalence.js"));
var exit_ = _interopRequireWildcard(require("./Exit.js"));
var fastCheck_ = _interopRequireWildcard(require("./FastCheck.js"));
var fiberId_ = _interopRequireWildcard(require("./FiberId.js"));
var _Function = require("./Function.js");
var _GlobalValue = require("./GlobalValue.js");
var hashMap_ = _interopRequireWildcard(require("./HashMap.js"));
var hashSet_ = _interopRequireWildcard(require("./HashSet.js"));
var internalCause_ = _interopRequireWildcard(require("./internal/cause.js"));
var errors_ = _interopRequireWildcard(require("./internal/schema/errors.js"));
var schemaId_ = _interopRequireWildcard(require("./internal/schema/schemaId.js"));
var util_ = _interopRequireWildcard(require("./internal/schema/util.js"));
var list_ = _interopRequireWildcard(require("./List.js"));
var number_ = _interopRequireWildcard(require("./Number.js"));
var option_ = _interopRequireWildcard(require("./Option.js"));
var ParseResult = _interopRequireWildcard(require("./ParseResult.js"));
var _Pipeable = require("./Pipeable.js");
var Predicate = _interopRequireWildcard(require("./Predicate.js"));
var redacted_ = _interopRequireWildcard(require("./Redacted.js"));
var Request = _interopRequireWildcard(require("./Request.js"));
var scheduler_ = _interopRequireWildcard(require("./Scheduler.js"));
var AST = _interopRequireWildcard(require("./SchemaAST.js"));
var sortedSet_ = _interopRequireWildcard(require("./SortedSet.js"));
var string_ = _interopRequireWildcard(require("./String.js"));
var struct_ = _interopRequireWildcard(require("./Struct.js"));
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
/**
* @since 3.10.0
*/
/**
* @since 3.10.0
* @category symbol
*/
const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/Schema");
/**
* @category constructors
* @since 3.10.0
*/
function make(ast) {
return class SchemaClass {
[TypeId] = variance;
static ast = ast;
static annotations(annotations) {
return make(mergeSchemaAnnotations(this.ast, annotations));
}
static pipe() {
return (0, _Pipeable.pipeArguments)(this, arguments);
}
static toString() {
return String(ast);
}
static Type;
static Encoded;
static Context;
static [TypeId] = variance;
};
}
const variance = {
/* c8 ignore next */
_A: _ => _,
/* c8 ignore next */
_I: _ => _,
/* c8 ignore next */
_R: _ => _
};
const makeStandardResult = exit => exit_.isSuccess(exit) ? exit.value : makeStandardFailureResult(cause_.pretty(exit.cause));
const makeStandardFailureResult = message => ({
issues: [{
message
}]
});
const makeStandardFailureFromParseIssue = issue => Effect.map(ParseResult.ArrayFormatter.formatIssue(issue), issues => ({
issues: issues.map(issue => ({
path: issue.path,
message: issue.message
}))
}));
/**
* Returns a "Standard Schema" object conforming to the [Standard Schema
* v1](https://standardschema.dev/) specification.
*
* This function creates a schema whose `validate` method attempts to decode and
* validate the provided input synchronously. If the underlying `Schema`
* includes any asynchronous components (e.g., asynchronous message resolutions
* or checks), then validation will necessarily return a `Promise` instead.
*
* Any detected defects will be reported via a single issue containing no
* `path`.
*
* @example
* ```ts
* import { Schema } from "effect"
*
* const schema = Schema.Struct({
* name: Schema.String
* })
*
* // ┌─── StandardSchemaV1<{ readonly name: string; }>
* // ▼
* const standardSchema = Schema.standardSchemaV1(schema)
* ```
*
* @category Standard Schema
* @since 3.13.0
*/
const standardSchemaV1 = (schema, overrideOptions) => {
const decodeUnknown = ParseResult.decodeUnknown(schema, {
errors: "all"
});
return class StandardSchemaV1Class extends make(schema.ast) {
static "~standard" = {
version: 1,
vendor: "effect",
validate(value) {
const scheduler = new scheduler_.SyncScheduler();
const fiber = Effect.runFork(Effect.matchEffect(decodeUnknown(value, overrideOptions), {
onFailure: makeStandardFailureFromParseIssue,
onSuccess: value => Effect.succeed({
value
})
}), {
scheduler
});
scheduler.flush();
const exit = fiber.unsafePoll();
if (exit) {
return makeStandardResult(exit);
}
return new Promise(resolve => {
fiber.addObserver(exit => {
resolve(makeStandardResult(exit));
});
});
}
};
};
};
exports.standardSchemaV1 = standardSchemaV1;
const builtInAnnotations = {
schemaId: AST.SchemaIdAnnotationId,
message: AST.MessageAnnotationId,
missingMessage: AST.MissingMessageAnnotationId,
identifier: AST.IdentifierAnnotationId,
title: AST.TitleAnnotationId,
description: AST.DescriptionAnnotationId,
examples: AST.ExamplesAnnotationId,
default: AST.DefaultAnnotationId,
documentation: AST.DocumentationAnnotationId,
jsonSchema: AST.JSONSchemaAnnotationId,
arbitrary: AST.ArbitraryAnnotationId,
pretty: AST.PrettyAnnotationId,
equivalence: AST.EquivalenceAnnotationId,
concurrency: AST.ConcurrencyAnnotationId,
batching: AST.BatchingAnnotationId,
parseIssueTitle: AST.ParseIssueTitleAnnotationId,
parseOptions: AST.ParseOptionsAnnotationId,
decodingFallback: AST.DecodingFallbackAnnotationId
};
const toASTAnnotations = annotations => {
if (!annotations) {
return {};
}
const out = {
...annotations
};
for (const key in builtInAnnotations) {
if (key in annotations) {
const id = builtInAnnotations[key];
out[id] = annotations[key];
delete out[key];
}
}
return out;
};
const mergeSchemaAnnotations = (ast, annotations) => AST.annotations(ast, toASTAnnotations(annotations));
/**
* @since 3.10.0
*/
function asSchema(schema) {
return schema;
}
/**
* @category formatting
* @since 3.10.0
*/
const format = schema => String(schema.ast);
/**
* The `encodedSchema` function allows you to extract the `Encoded` portion of a
* schema, creating a new schema that conforms to the properties defined in the
* original schema without retaining any refinements or transformations that
* were applied previously.
*
* @since 3.10.0
*/
exports.format = format;
const encodedSchema = schema => make(AST.encodedAST(schema.ast));
/**
* The `encodedBoundSchema` function is similar to `encodedSchema` but preserves
* the refinements up to the first transformation point in the original schema.
*
* @since 3.10.0
*/
exports.encodedSchema = encodedSchema;
const encodedBoundSchema = schema => make(AST.encodedBoundAST(schema.ast));
/**
* The `typeSchema` function allows you to extract the `Type` portion of a
* schema, creating a new schema that conforms to the properties defined in the
* original schema without considering the initial encoding or transformation
* processes.
*
* @since 3.10.0
*/
exports.encodedBoundSchema = encodedBoundSchema;
const typeSchema = schema => make(AST.typeAST(schema.ast));
/* c8 ignore start */
exports.typeSchema = typeSchema;
/* c8 ignore end */
/**
* @category encoding
* @since 3.10.0
*/
const encodeUnknown = (schema, options) => {
const encodeUnknown = ParseResult.encodeUnknown(schema, options);
return (u, overrideOptions) => ParseResult.mapError(encodeUnknown(u, overrideOptions), ParseResult.parseError);
};
/**
* @category encoding
* @since 3.10.0
*/
exports.encodeUnknown = encodeUnknown;
const encodeUnknownEither = (schema, options) => {
const encodeUnknownEither = ParseResult.encodeUnknownEither(schema, options);
return (u, overrideOptions) => either_.mapLeft(encodeUnknownEither(u, overrideOptions), ParseResult.parseError);
};
/**
* @category encoding
* @since 3.10.0
*/
exports.encodeUnknownEither = encodeUnknownEither;
const encodeUnknownPromise = (schema, options) => {
const parser = encodeUnknown(schema, options);
return (u, overrideOptions) => Effect.runPromise(parser(u, overrideOptions));
};
/**
* @category encoding
* @since 3.10.0
*/
exports.encodeUnknownPromise = encodeUnknownPromise;
const encode = exports.encode = encodeUnknown;
/**
* @category encoding
* @since 3.10.0
*/
const encodeEither = exports.encodeEither = encodeUnknownEither;
/**
* @category encoding
* @since 3.10.0
*/
const encodePromise = exports.encodePromise = encodeUnknownPromise;
/**
* @category decoding
* @since 3.10.0
*/
const decodeUnknown = (schema, options) => {
const decodeUnknown = ParseResult.decodeUnknown(schema, options);
return (u, overrideOptions) => ParseResult.mapError(decodeUnknown(u, overrideOptions), ParseResult.parseError);
};
/**
* @category decoding
* @since 3.10.0
*/
exports.decodeUnknown = decodeUnknown;
const decodeUnknownEither = (schema, options) => {
const decodeUnknownEither = ParseResult.decodeUnknownEither(schema, options);
return (u, overrideOptions) => either_.mapLeft(decodeUnknownEither(u, overrideOptions), ParseResult.parseError);
};
/**
* @category decoding
* @since 3.10.0
*/
exports.decodeUnknownEither = decodeUnknownEither;
const decodeUnknownPromise = (schema, options) => {
const parser = decodeUnknown(schema, options);
return (u, overrideOptions) => Effect.runPromise(parser(u, overrideOptions));
};
/**
* @category decoding
* @since 3.10.0
*/
exports.decodeUnknownPromise = decodeUnknownPromise;
const decode = exports.decode = decodeUnknown;
/**
* @category decoding
* @since 3.10.0
*/
const decodeEither = exports.decodeEither = decodeUnknownEither;
/**
* @category decoding
* @since 3.10.0
*/
const decodePromise = exports.decodePromise = decodeUnknownPromise;
/**
* @category validation
* @since 3.10.0
*/
const validate = (schema, options) => {
const validate = ParseResult.validate(schema, options);
return (u, overrideOptions) => ParseResult.mapError(validate(u, overrideOptions), ParseResult.parseError);
};
/**
* @category validation
* @since 3.10.0
*/
exports.validate = validate;
const validateEither = (schema, options) => {
const validateEither = ParseResult.validateEither(schema, options);
return (u, overrideOptions) => either_.mapLeft(validateEither(u, overrideOptions), ParseResult.parseError);
};
/**
* @category validation
* @since 3.10.0
*/
exports.validateEither = validateEither;
const validatePromise = (schema, options) => {
const parser = validate(schema, options);
return (u, overrideOptions) => Effect.runPromise(parser(u, overrideOptions));
};
/**
* Tests if a value is a `Schema`.
*
* @category guards
* @since 3.10.0
*/
exports.validatePromise = validatePromise;
const isSchema = u => Predicate.hasProperty(u, TypeId) && Predicate.isObject(u[TypeId]);
exports.isSchema = isSchema;
function getDefaultLiteralAST(literals) {
return AST.isMembers(literals) ? AST.Union.make(AST.mapMembers(literals, literal => new AST.Literal(literal))) : new AST.Literal(literals[0]);
}
function makeLiteralClass(literals, ast = getDefaultLiteralAST(literals)) {
return class LiteralClass extends make(ast) {
static annotations(annotations) {
return makeLiteralClass(this.literals, mergeSchemaAnnotations(this.ast, annotations));
}
static literals = [...literals];
};
}
function Literal(...literals) {
return array_.isNonEmptyReadonlyArray(literals) ? makeLiteralClass(literals) : Never;
}
/**
* Creates a new `Schema` from a literal schema.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import { Either, Schema } from "effect"
*
* const schema = Schema.Literal("a", "b", "c").pipe(Schema.pickLiteral("a", "b"))
*
* assert.deepStrictEqual(Schema.decodeSync(schema)("a"), "a")
* assert.deepStrictEqual(Schema.decodeSync(schema)("b"), "b")
* assert.strictEqual(Either.isLeft(Schema.decodeUnknownEither(schema)("c")), true)
* ```
*
* @category constructors
* @since 3.10.0
*/
const pickLiteral = (...literals) => _schema => Literal(...literals);
/**
* @category constructors
* @since 3.10.0
*/
exports.pickLiteral = pickLiteral;
const UniqueSymbolFromSelf = symbol => make(new AST.UniqueSymbol(symbol));
exports.UniqueSymbolFromSelf = UniqueSymbolFromSelf;
const getDefaultEnumsAST = enums => new AST.Enums(Object.keys(enums).filter(key => typeof enums[enums[key]] !== "number").map(key => [key, enums[key]]));
const makeEnumsClass = (enums, ast = getDefaultEnumsAST(enums)) => class EnumsClass extends make(ast) {
static annotations(annotations) {
return makeEnumsClass(this.enums, mergeSchemaAnnotations(this.ast, annotations));
}
static enums = {
...enums
};
};
/**
* @category constructors
* @since 3.10.0
*/
const Enums = enums => makeEnumsClass(enums);
/**
* @category template literal
* @since 3.10.0
*/
exports.Enums = Enums;
const TemplateLiteral = (...[head, ...tail]) => {
const spans = [];
let h = "";
let ts = tail;
if (isSchema(head)) {
if (AST.isLiteral(head.ast)) {
h = String(head.ast.literal);
} else {
ts = [head, ...ts];
}
} else {
h = String(head);
}
for (let i = 0; i < ts.length; i++) {
const item = ts[i];
if (isSchema(item)) {
if (i < ts.length - 1) {
const next = ts[i + 1];
if (isSchema(next)) {
if (AST.isLiteral(next.ast)) {
spans.push(new AST.TemplateLiteralSpan(item.ast, String(next.ast.literal)));
i++;
continue;
}
} else {
spans.push(new AST.TemplateLiteralSpan(item.ast, String(next)));
i++;
continue;
}
}
spans.push(new AST.TemplateLiteralSpan(item.ast, ""));
} else {
spans.push(new AST.TemplateLiteralSpan(new AST.Literal(item), ""));
}
}
if (array_.isNonEmptyArray(spans)) {
return make(new AST.TemplateLiteral(h, spans));
} else {
return make(new AST.TemplateLiteral("", [new AST.TemplateLiteralSpan(new AST.Literal(h), "")]));
}
};
exports.TemplateLiteral = TemplateLiteral;
function getTemplateLiteralParserCoercedElement(encoded, schema) {
const ast = encoded.ast;
switch (ast._tag) {
case "Literal":
{
const literal = ast.literal;
if (!Predicate.isString(literal)) {
const s = String(literal);
return transform(Literal(s), schema, {
strict: true,
decode: () => literal,
encode: () => s
});
}
break;
}
case "NumberKeyword":
return compose(NumberFromString, schema);
case "Union":
{
const members = [];
let hasCoercions = false;
for (const member of ast.types) {
const schema = make(member);
const encoded = encodedSchema(schema);
const coerced = getTemplateLiteralParserCoercedElement(encoded, schema);
if (coerced) {
hasCoercions = true;
}
members.push(coerced ?? schema);
}
return hasCoercions ? compose(Union(...members), schema) : schema;
}
}
}
/**
* @category template literal
* @since 3.10.0
*/
const TemplateLiteralParser = (...params) => {
const encodedSchemas = [];
const elements = [];
const schemas = [];
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);
const re = AST.getTemplateLiteralCapturingRegExp(from.ast);
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();
};
};
exports.TemplateLiteralParser = TemplateLiteralParser;
const declareConstructor = (typeParameters, options, annotations) => makeDeclareClass(typeParameters, new AST.Declaration(typeParameters.map(tp => tp.ast), (...typeParameters) => options.decode(...typeParameters.map(make)), (...typeParameters) => options.encode(...typeParameters.map(make)), toASTAnnotations(annotations)));
const declarePrimitive = (is, annotations) => {
const decodeUnknown = () => (input, _, ast) => is(input) ? ParseResult.succeed(input) : ParseResult.fail(new ParseResult.Type(ast, input));
const encodeUnknown = decodeUnknown;
return makeDeclareClass([], new AST.Declaration([], decodeUnknown, encodeUnknown, toASTAnnotations(annotations)));
};
function makeDeclareClass(typeParameters, ast) {
return class DeclareClass extends make(ast) {
static annotations(annotations) {
return makeDeclareClass(this.typeParameters, mergeSchemaAnnotations(this.ast, annotations));
}
static typeParameters = [...typeParameters];
};
}
/**
* The constraint `R extends Schema.Context<P[number]>` enforces dependencies solely from `typeParameters`.
* This ensures that when you call `Schema.to` or `Schema.from`, you receive a schema with a `never` context.
*
* @category constructors
* @since 3.10.0
*/
const declare = function () {
if (Array.isArray(arguments[0])) {
const typeParameters = arguments[0];
const options = arguments[1];
const annotations = arguments[2];
return declareConstructor(typeParameters, options, annotations);
}
const is = arguments[0];
const annotations = arguments[1];
return declarePrimitive(is, annotations);
};
/**
* @category schema id
* @since 3.10.0
*/
exports.declare = declare;
const BrandSchemaId = exports.BrandSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Brand");
/**
* @category constructors
* @since 3.10.0
*/
const fromBrand = (constructor, annotations) => self => {
const out = makeBrandClass(self, new AST.Refinement(self.ast, function predicate(a, _, ast) {
const either = constructor.either(a);
return either_.isLeft(either) ? option_.some(new ParseResult.Type(ast, a, either.left.map(v => v.message).join(", "))) : option_.none();
}, toASTAnnotations({
schemaId: BrandSchemaId,
[BrandSchemaId]: {
constructor
},
...annotations
})));
return out;
};
/**
* @category schema id
* @since 3.10.0
*/
exports.fromBrand = fromBrand;
const InstanceOfSchemaId = exports.InstanceOfSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/InstanceOf");
/**
* @category constructors
* @since 3.10.0
*/
const instanceOf = (constructor, annotations) => declare(u => u instanceof constructor, {
title: constructor.name,
description: `an instance of ${constructor.name}`,
pretty: () => String,
schemaId: InstanceOfSchemaId,
[InstanceOfSchemaId]: {
constructor
},
...annotations
});
/**
* @category primitives
* @since 3.10.0
*/
exports.instanceOf = instanceOf;
class Undefined extends /*#__PURE__*/make(AST.undefinedKeyword) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.Undefined = Undefined;
class Void extends /*#__PURE__*/make(AST.voidKeyword) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.Void = Void;
class Null extends /*#__PURE__*/make(AST.null) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.Null = Null;
class Never extends /*#__PURE__*/make(AST.neverKeyword) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.Never = Never;
class Unknown extends /*#__PURE__*/make(AST.unknownKeyword) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.Unknown = Unknown;
class Any extends /*#__PURE__*/make(AST.anyKeyword) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.Any = Any;
class BigIntFromSelf extends /*#__PURE__*/make(AST.bigIntKeyword) {}
/**
* @category primitives
* @since 3.10.0
*/
exports.BigIntFromSelf = BigIntFromSelf;
class SymbolFromSelf extends /*#__PURE__*/make(AST.symbolKeyword) {}
/** @ignore */
exports.SymbolFromSelf = SymbolFromSelf;
class String$ extends /*#__PURE__*/make(AST.stringKeyword) {}
/** @ignore */
exports.String = String$;
class Number$ extends /*#__PURE__*/make(AST.numberKeyword) {}
/** @ignore */
exports.Number = Number$;
class Boolean$ extends /*#__PURE__*/make(AST.booleanKeyword) {}
/** @ignore */
exports.Boolean = Boolean$;
class Object$ extends /*#__PURE__*/make(AST.objectKeyword) {}
exports.Object = Object$;
const getDefaultUnionAST = members => AST.Union.make(members.map(m => m.ast));
function makeUnionClass(members, ast = getDefaultUnionAST(members)) {
return class UnionClass extends make(ast) {
static annotations(annotations) {
return makeUnionClass(this.members, mergeSchemaAnnotations(this.ast, annotations));
}
static members = [...members];
};
}
function Union(...members) {
return AST.isMembers(members) ? makeUnionClass(members) : array_.isNonEmptyReadonlyArray(members) ? members[0] : Never;
}
/**
* @category combinators
* @since 3.10.0
*/
const NullOr = self => Union(self, Null);
/**
* @category combinators
* @since 3.10.0
*/
exports.NullOr = NullOr;
const UndefinedOr = self => Union(self, Undefined);
/**
* @category combinators
* @since 3.10.0
*/
exports.UndefinedOr = UndefinedOr;
const NullishOr = self => Union(self, Null, Undefined);
/**
* @category combinators
* @since 3.10.0
*/
exports.NullishOr = NullishOr;
const keyof = self => make(AST.keyof(self.ast));
/**
* @since 3.10.0
*/
exports.keyof = keyof;
const element = self => new ElementImpl(new AST.OptionalType(self.ast, false), self);
/**
* @since 3.10.0
*/
exports.element = element;
const optionalElement = self => new ElementImpl(new AST.OptionalType(self.ast, true), self);
exports.optionalElement = optionalElement;
class ElementImpl {
ast;
from;
[TypeId];
_Token;
constructor(ast, from) {
this.ast = ast;
this.from = from;
}
annotations(annotations) {
return new ElementImpl(new AST.OptionalType(this.ast.type, this.ast.isOptional, {
...this.ast.annotations,
...toASTAnnotations(annotations)
}), this.from);
}
toString() {
return `${this.ast.type}${this.ast.isOptional ? "?" : ""}`;
}
}
const getDefaultTupleTypeAST = (elements, rest) => new AST.TupleType(elements.map(el => isSchema(el) ? new AST.OptionalType(el.ast, false) : el.ast), rest.map(el => isSchema(el) ? new AST.Type(el.ast) : el.ast), true);
function makeTupleTypeClass(elements, rest, ast = getDefaultTupleTypeAST(elements, rest)) {
return class TupleTypeClass extends make(ast) {
static annotations(annotations) {
return makeTupleTypeClass(this.elements, this.rest, mergeSchemaAnnotations(this.ast, annotations));
}
static elements = [...elements];
static rest = [...rest];
};
}
function Tuple(...args) {
return Array.isArray(args[0]) ? makeTupleTypeClass(args[0], args.slice(1)) : makeTupleTypeClass(args, []);
}
function makeArrayClass(value, ast) {
return class ArrayClass extends makeTupleTypeClass([], [value], ast) {
static annotations(annotations) {
return makeArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations));
}
static value = value;
};
}
const Array$ = value => makeArrayClass(value);
exports.Array = Array$;
function makeNonEmptyArrayClass(value, ast) {
return class NonEmptyArrayClass extends makeTupleTypeClass([value], [value], ast) {
static annotations(annotations) {
return makeNonEmptyArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations));
}
static value = value;
};
}
/**
* @category constructors
* @since 3.10.0
*/
const NonEmptyArray = value => makeNonEmptyArrayClass(value);
/**
* @category constructors
* @since 3.10.0
*/
exports.NonEmptyArray = NonEmptyArray;
function ArrayEnsure(value) {
return transform(Union(value, Array$(value)), Array$(typeSchema(asSchema(value))), {
strict: true,
decode: i => array_.ensure(i),
encode: a => a.length === 1 ? a[0] : a
});
}
/**
* @category constructors
* @since 3.10.0
*/
function NonEmptyArrayEnsure(value) {
return transform(Union(value, NonEmptyArray(value)), NonEmptyArray(typeSchema(asSchema(value))), {
strict: true,
decode: i => array_.isNonEmptyReadonlyArray(i) ? i : array_.of(i),
encode: a => a.length === 1 ? a[0] : a
});
}
const formatPropertySignatureToken = isOptional => isOptional ? "\"?:\"" : "\":\"";
/**
* @category PropertySignature
* @since 3.10.0
*/
class PropertySignatureDeclaration extends AST.OptionalType {
isReadonly;
defaultValue;
/**
* @since 3.10.0
*/
_tag = "PropertySignatureDeclaration";
constructor(type, isOptional, isReadonly, annotations, defaultValue) {
super(type, isOptional, annotations);
this.isReadonly = isReadonly;
this.defaultValue = defaultValue;
}
/**
* @since 3.10.0
*/
toString() {
const token = formatPropertySignatureToken(this.isOptional);
const type = String(this.type);
return `PropertySignature<${token}, ${type}, never, ${token}, ${type}>`;
}
}
/**
* @category PropertySignature
* @since 3.10.0
*/
exports.PropertySignatureDeclaration = PropertySignatureDeclaration;
class FromPropertySignature extends AST.OptionalType {
isReadonly;
fromKey;
constructor(type, isOptional, isReadonly, annotations, fromKey) {
super(type, isOptional, annotations);
this.isReadonly = isReadonly;
this.fromKey = fromKey;
}
}
/**
* @category PropertySignature
* @since 3.10.0
*/
exports.FromPropertySignature = FromPropertySignature;
class ToPropertySignature extends AST.OptionalType {
isReadonly;
defaultValue;
constructor(type, isOptional, isReadonly, annotations, defaultValue) {
super(type, isOptional, annotations);
this.isReadonly = isReadonly;
this.defaultValue = defaultValue;
}
}
exports.ToPropertySignature = ToPropertySignature;
const formatPropertyKey = p => {
if (p === undefined) {
return "never";
}
if (Predicate.isString(p)) {
return JSON.stringify(p);
}
return String(p);
};
/**
* @category PropertySignature
* @since 3.10.0
*/
class PropertySignatureTransformation {
from;
to;
decode;
encode;
/**
* @since 3.10.0
*/
_tag = "PropertySignatureTransformation";
constructor(from, to, decode, encode) {
this.from = from;
this.to = to;
this.decode = decode;
this.encode = encode;
}
/**
* @since 3.10.0
*/
toString() {
return `PropertySignature<${formatPropertySignatureToken(this.to.isOptional)}, ${this.to.type}, ${formatPropertyKey(this.from.fromKey)}, ${formatPropertySignatureToken(this.from.isOptional)}, ${this.from.type}>`;
}
}
exports.PropertySignatureTransformation = PropertySignatureTransformation;
const mergeSignatureAnnotations = (ast, annotations) => {
switch (ast._tag) {
case "PropertySignatureDeclaration":
{
return new PropertySignatureDeclaration(ast.type, ast.isOptional, ast.isReadonly, {
...ast.annotations,
...annotations
}, ast.defaultValue);
}
case "PropertySignatureTransformation":
{
return new PropertySignatureTransformation(ast.from, new ToPropertySignature(ast.to.type, ast.to.isOptional, ast.to.isReadonly, {
...ast.to.annotations,
...annotations
}, ast.to.defaultValue), ast.decode, ast.encode);
}
}
};
/**
* @since 3.10.0
* @category symbol
*/
const PropertySignatureTypeId = exports.PropertySignatureTypeId = /*#__PURE__*/Symbol.for("effect/PropertySignature");
/**
* @since 3.10.0
* @category guards
*/
const isPropertySignature = u => Predicate.hasProperty(u, PropertySignatureTypeId);
exports.isPropertySignature = isPropertySignature;
class PropertySignatureImpl {
ast;
[TypeId];
[PropertySignatureTypeId] = null;
_TypeToken;
_Key;
_EncodedToken;
_HasDefault;
constructor(ast) {
this.ast = ast;
}
pipe() {
return (0, _Pipeable.pipeArguments)(this, arguments);
}
annotations(annotations) {
return new PropertySignatureImpl(mergeSignatureAnnotations(this.ast, toASTAnnotations(annotations)));
}
toString() {
return String(this.ast);
}
}
/**
* @category PropertySignature
* @since 3.10.0
*/
const makePropertySignature = ast => new PropertySignatureImpl(ast);
exports.makePropertySignature = makePropertySignature;
class PropertySignatureWithFromImpl extends PropertySignatureImpl {
from;
constructor(ast, from) {
super(ast);
this.from = from;
}
annotations(annotations) {
return new PropertySignatureWithFromImpl(mergeSignatureAnnotations(this.ast, toASTAnnotations(annotations)), this.from);
}
}
/**
* Lifts a `Schema` into a `PropertySignature`.
*
* @category PropertySignature
* @since 3.10.0
*/
const propertySignature = self => new PropertySignatureWithFromImpl(new PropertySignatureDeclaration(self.ast, false, true, {}, undefined), self);
/**
* Enhances a property signature with a default constructor value.
*
* @category PropertySignature
* @since 3.10.0
*/
exports.propertySignature = propertySignature;
const withConstructorDefault = exports.withConstructorDefault = /*#__PURE__*/(0, _Function.dual)(2, (self, defaultValue) => {
const ast = self.ast;
switch (ast._tag) {
case "PropertySignatureDeclaration":
return makePropertySignature(new PropertySignatureDeclaration(ast.type, ast.isOptional, ast.isReadonly, ast.annotations, defaultValue));
case "PropertySignatureTransformation":
return makePropertySignature(new PropertySignatureTransformation(ast.from, new ToPropertySignature(ast.to.type, ast.to.isOptional, ast.to.isReadonly, ast.to.annotations, defaultValue), ast.decode, ast.encode));
}
});
const applyDefaultValue = (o, defaultValue) => option_.match(o, {
onNone: () => option_.some(defaultValue()),
onSome: value => option_.some(value === undefined ? defaultValue() : value)
});
const pruneUndefined = ast => AST.pruneUndefined(ast, pruneUndefined, ast => {
const pruned = pruneUndefined(ast.to);
if (pruned) {
return new AST.Transformation(ast.from, pruned, ast.transformation);
}
});
/**
* Enhances a property signature with a default decoding value.
*
* @category PropertySignature
* @since 3.10.0
*/
const withDecodingDefault = exports.withDecodingDefault = /*#__PURE__*/(0, _Function.dual)(2, (self, defaultValue) => {
const ast = self.ast;
switch (ast._tag) {
case "PropertySignatureDeclaration":
{
const to = AST.typeAST(ast.type);
return makePropertySignature(new PropertySignatureTransformation(new FromPropertySignature(ast.type, ast.isOptional, ast.isReadonly, ast.annotations), new ToPropertySignature(pruneUndefined(to) ?? to, false, true, {}, ast.defaultValue), o => applyDefaultValue(o, defaultValue), _Function.identity));
}
case "PropertySignatureTransformation":
{
const to = ast.to.type;
return makePropertySignature(new PropertySignatureTransformation(ast.from, new ToPropertySignature(pruneUndefined(to) ?? to, false, ast.to.isReadonly, ast.to.annotations, ast.to.defaultValue), o => applyDefaultValue(ast.decode(o), defaultValue), ast.encode));
}
}
});
/**
* Enhances a property signature with a default decoding value and a default constructor value.
*
* @category PropertySignature
* @since 3.10.0
*/
const withDefaults = exports.withDefaults = /*#__PURE__*/(0, _Function.dual)(2, (self, defaults) => self.pipe(withDecodingDefault(defaults.decoding), withConstructorDefault(defaults.constructor)));
/**
* Enhances a property signature by specifying a different key for it in the Encoded type.
*
* @category PropertySignature
* @since 3.10.0
*/
const fromKey = exports.fromKey = /*#__PURE__*/(0, _Function.dual)(2, (self, key) => {
const ast = self.ast;
switch (ast._tag) {
case "PropertySignatureDeclaration":
{
return makePropertySignature(new PropertySignatureTransformation(new FromPropertySignature(ast.type, ast.isOptional, ast.isReadonly, ast.annotations, key), new ToPropertySignature(AST.typeAST(ast.type), ast.isOptional, ast.isReadonly, {}, ast.defaultValue), _Function.identity, _Function.identity));
}
case "PropertySignatureTransformation":
return makePropertySignature(new PropertySignatureTransformation(new FromPropertySignature(ast.from.type, ast.from.isOptional, ast.from.isReadonly, ast.from.annotations, key), ast.to, ast.decode, ast.encode));
}
});
/**
* Converts an optional property to a required one through a transformation `Option -> Type`.
*
* - `decode`: `none` as argument means the value is missing in the input.
* - `encode`: `none` as return value means the value will be missing in the output.
*
* @category PropertySignature
* @since 3.10.0
*/
const optionalToRequired = (from, to, options) => makePropertySignature(new PropertySignatureTransformation(new FromPropertySignature(from.ast, true, true, {}, undefined), new ToPropertySignature(to.ast, false, true, {}, undefined), o => option_.some(options.decode(o)), option_.flatMap(options.encode)));
/**
* Converts an optional property to a required one through a transformation `Type -> Option`.
*
* - `decode`: `none` as return value means the value will be missing in the output.
* - `encode`: `none` as argument means the value is missing in the input.
*
* @category PropertySignature
* @since 3.10.0
*/
exports.optionalToRequired = optionalToRequired;
const requiredToOptional = (from, to, options) => makePropertySignature(new PropertySignatureTransformation(new FromPropertySignature(from.ast, false, true, {}, undefined), new ToPropertySignature(to.ast, true, true, {}, undefined), option_.flatMap(options.decode), o => option_.some(options.encode(o))));
/**
* Converts an optional property to another optional property through a transformation `Option -> Option`.
*
* - `decode`:
* - `none` as argument means the value is missing in the input.
* - `none` as return value means the value will be missing in the output.
* - `encode`:
* - `none` as argument means the value is missing in the input.
* - `none` as return value means the value will be missing in the output.
*
* @category PropertySignature
* @since 3.10.0
*/
exports.requiredToOptional = requiredToOptional;
const optionalToOptional = (from, to, options) => makePropertySignature(new PropertySignatureTransformation(new FromPropertySignature(from.ast, true, true, {}, undefined), new ToPropertySignature(to.ast, true, true, {}, undefined), options.decode, options.encode));
exports.optionalToOptional = optionalToOptional;
const optionalPropertySignatureAST = (self, options) => {
const isExact = options?.exact;
const defaultValue = options?.default;
const isNullable = options?.nullable;
const asOption = options?.as == "Option";
const asOptionEncode = options?.onNoneEncoding ? option_.orElse(options.onNoneEncoding) : _Function.identity;
if (isExact) {
if (defaultValue) {
if (isNullable) {
return withConstructorDefault(optionalToRequired(NullOr(self), typeSchema(self), {
decode: option_.match({
onNone: defaultValue,
onSome: a => a === null ? defaultValue() : a
}),
encode: option_.some
}), defaultValue).ast;
} else {
return withConstructorDefault(optionalToRequired(self, typeSchema(self), {
decode: option_.match({
onNone: defaultValue,
onSome: _Function.identity
}),
encode: option_.some
}), defaultValue).ast;
}
} else if (asOption) {
if (isNullable) {
return optionalToRequired(NullOr(self), OptionFromSelf(typeSchema(self)), {
decode: option_.filter(Predicate.isNotNull),
encode: asOptionEncode
}).ast;
} else {
return optionalToRequired(self, OptionFromSelf(typeSchema(self)), {
decode: _Function.identity,
encode: _Function.identity
}).ast;
}
} else {
if (isNullable) {
return optionalToOptional(NullOr(self), typeSchema(self), {
decode: option_.filter(Predicate.isNotNull),
encode: _Function.identity
}).ast;
} else {
return new PropertySignatureDeclaration(self.ast, true, true, {}, undefined);
}
}
} else {
if (defaultValue) {
if (isNullable) {
return withConstructorDefault(optionalToRequired(NullishOr(self), typeSchema(self), {
decode: option_.match({
onNone: defaultValue,
onSome: a => a == null ? defaultValue() : a
}),
encode: option_.some
}), defaultValue).ast;
} else {
return withConstructorDefault(optionalToRequired(UndefinedOr(self), typeSchema(self), {
decode: option_.match({
onNone: defaultValue,
onSome: a => a === undefined ? defaultValue() : a
}),
encode: option_.some
}), defaultValue).ast;
}
} else if (asOption) {
if (isNullable) {
return optionalToRequired(NullishOr(self), OptionFromSelf(typeSchema(self)), {
decode: option_.filter(a => a != null),
encode: asOptionEncode
}).ast;
} else {
return optionalToRequired(UndefinedOr(self), OptionFromSelf(typeSchema(self)), {
decode: option_.filter(Predicate.isNotUndefined),
encode: asOptionEncode
}).ast;
}
} else {
if (isNullable) {
return optionalToOptional(NullishOr(self), UndefinedOr(typeSchema(self)), {
decode: option_.filter(Predicate.isNotNull),
encode: _Function.identity
}).ast;
} else {
return new PropertySignatureDeclaration(UndefinedOr(self).ast, true, true, {}, undefined);
}
}
}
};
/**
* @category PropertySignature
* @since 3.10.0
*/
const optional = self => {
const ast = self.ast === AST.undefinedKeyword || self.ast === AST.neverKeyword ? AST.undefinedKeyword : UndefinedOr(self).ast;
return new PropertySignatureWithFromImpl(new PropertySignatureDeclaration(ast, true, true, {}, undefined), self);
};
/**
* @category PropertySignature
* @since 3.10.0
*/
exports.optional = optional;
const optionalWith = exports.optionalWith = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[0]), (self, options) => {
return new PropertySignatureWithFromImpl(optionalPropertySignatureAST(self, options), self);
});
const preserveMissingMessageAnnotation = /*#__PURE__*/AST.pickAnnotations([AST.MissingMessageAnnotationId]);
const getDefaultTypeLiteralAST = (fields, records) => {
const ownKeys = util_.ownKeys(fields);
const pss = [];
if (ownKeys.length > 0) {
const from = [];
const to = [];
const transformations = [];
for (let i = 0; i < ownKeys.length; i++) {
const key = ownKeys[i];
const field = fields[key];
if (isPropertySignature(field)) {
const ast = field.ast;
switch (ast._tag) {
case "PropertySignatureDeclaration":
{
const type = ast.type;
const isOptional = ast.isOptional;
const toAnnotations = ast.annotations;
from.push(new AST.PropertySignature(key, type, isOptional, true, preserveMissingMessageAnnotation(ast)));
to.push(new AST.PropertySignature(key, AST.typeAST(type), isOptional, true, toAnnotations));
pss.push(new AST.PropertySignature(key, type, isOptional, true, toAnnotations));
break;
}
case "PropertySignatureTransformation":
{
const fromKey = ast.from.fromKey ?? key;
from.push(new AST.PropertySignature(fromKey, ast.from.type, ast.from.isOptional, true, ast.from.annotations));
to.push(new AST.PropertySignature(key, ast.to.type, ast.to.isOptional, true, ast.to.annotations));
transformations.push(new AST.PropertySignatureTransformation(fromKey, key, ast.decode, ast.encode));
break;
}
}
} else {
from.push(new AST.PropertySignature(key, field.ast, false, true));
to.push(new AST.PropertySignature(key, AST.typeAST(field.ast), false, true));
pss.push(new AST.PropertySignature(key, field.ast, false, true));
}
}
if (array_.isNonEmptyReadonlyArray(transformations)) {
const issFrom = [];
const issTo = [];
for (const r of records) {
const {
indexSignatures,
propertySignatures
} = AST.record(r.key.ast, r.value.ast);
propertySignatures.forEach(ps => {
from.push(ps);
to.push(new AST.PropertySignature(ps.name, AST.typeAST(ps.type), ps.isOptional, ps.isReadonly, ps.annotations));
});
indexSignatures.forEach(is => {
issFrom.push(is);
issTo.push(new AST.IndexSignature(is.parameter, AST.typeAST(is.type), is.isReadonly));
});
}
return new AST.Transformation(new AST.TypeLiteral(from, issFrom, {
[AST.AutoTitleAnnotationId]: "Struct (Encoded side)"
}), new AST.TypeLiteral(to, issTo, {
[AST.AutoTitleAnnotationId]: "Struct (Type side)"
}), new AST.TypeLiteralTransformation(transformations));
}
}
const iss = [];
for (const r of records) {
const {
indexSignatures,
propertySignatures
} = AST.record(r.key.ast, r.value.ast);
propertySignatures.forEach(ps => pss.push(ps));
indexSignatures.forEach(is => iss.push(is));
}
return new AST.TypeLiteral(pss, iss);
};
const lazilyMergeDefaults = (fields, out) => {
const ownKeys = util_.ownKeys(fields);
for (const key of ownKeys) {
const field = fields[key];
if (out[key] === undefined && isPropertySignature(field)) {
const ast = field.ast;
const defaultValue = ast._tag === "PropertySignatureDeclaration" ? ast.defaultValue : ast.to.defaultValue;
if (defaultValue !== undefined) {
out[key] = defaultValue();
}
}
}
return out;
};
function makeTypeLiteralClass(fields, records, ast = getDefaultTypeLiteralAST(fields, records)) {
return class TypeLiteralClass extends make(ast) {
static annotations(annotations) {
return makeTypeLiteralClass(this.fields, this.records, mergeSchemaAnnotations(this.ast, annotations));
}
static fields = {
...fields
};
static records = [...records];
static make = (props, options) => {
const propsWithDefaults = lazilyMergeDefaults(fields, {
...props
});
return getDisableValidationMakeOption(options) ? propsWithDefaults : ParseResult.validateSync(this)(propsWithDefaults);
};
static pick(...keys) {
return Struct(struct_.pick(fields, ...keys));
}
static omit(...keys) {
return Struct(struct_.omit(fields, ...keys));
}
};
}
function Struct(fields, ...records) {
return makeTypeLiteralClass(fields, records);
}
/**
* Returns a property signature that represents a tag.
* 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.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import { Schema } from "effect"
*
* const User = Schema.Struct({
* _tag: Schema.tag("User"),
* name: Schema.String,
* age: Schema.Number
* })
*
* assert.deepStrictEqual(User.make({ name: "John", age: 44 }), { _tag: "User", name: "John", age: 44 })
* ```
*
* @see {@link TaggedStruct}
*
* @since 3.10.0
*/
const tag = tag => Literal(tag).pipe(propertySignature, withConstructorDefault(() => tag));
/**
* A tagged struct is a struct that has a tag property that is used to distinguish between different types of objects.
*
* The tag is optional when using the `make` method.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import { Schema } from "effect"
*
* const User = Schema.TaggedStruct("User", {
* name: Schema.String,
* age: Schema.Number
* })
*
* assert.deepStrictEqual(User.make({ name: "John", age: 44 }), { _tag: "User", name: "John", age: 44 })
* ```
*
* @category constructors
* @since 3.10.0
*/
exports.tag = tag;
const TaggedStruct = (value, fields) => Struct({
_tag: tag(value),
...fields
});
exports.TaggedStruct = TaggedStruct;
function makeRecordClass(key, value, ast) {
return class RecordClass extends makeTypeLiteralClass({}, [{
key,
value
}], ast) {
static annotations(annotations) {
return makeRecordClass(key, value, mergeSchemaAnnotations(this.ast, annotations));
}
static key = key;
static value = value;
};
}
/**
* @category constructors
* @since 3.10.0
*/
const Record = options => makeRecordClass(options.key, options.value);
/**
* @category struct transformations
* @since 3.10.0
*/
exports.Record = Record;
const pick = (...keys) => self => make(AST.pick(self.ast, keys));
/**
* @category struct transformations
* @since 3.10.0
*/
exports.pick = pick;
const omit = (...keys) => self => make(AST.omit(self.ast, keys));
/**
* Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
* producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
*
* @example
* ```ts
* import * as Schema from "effect/Schema"
*
* // ---------------------------------------------
* // use case: pull out a single field from a
* // struct through a transformation
* // ---------------------------------------------
*
* const mytable = Schema.Struct({
* column1: Schema.NumberFromString,
* column2: Schema.Number
* })
*
* // const pullOutColumn: S.Schema<number, {
* // readonly column1: string;
* // }, never>
* const pullOutColumn = mytable.pipe(Schema.pluck("column1"))
*
* console.log(Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([{ column1: "1", column2: 100 }, { column1: "2", column2: 300 }]))
* // Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }
* ```
*
* @category struct transformations
* @since 3.10.0
*/
exports.omit = omit;
const pluck = exports.pluck = /*#__PURE__*/(0, _Function.dual)(2, (schema, key) => {
const ps = AST.getPropertyKeyIndexedAccess(AST.typeAST(schema.ast), key);
const value = make(ps.isOptional ? AST.orUndefined(ps.type) : ps.type);
const out = transform(schema.pipe(pick(key)), value, {
strict: true,
decode: i => i[key],
encode: a => ps.isOptional && a === undefined ? {} : {
[key]: a
}
});
return out;
});
function makeBrandClass(from, ast) {
return class BrandClass extends make(ast) {
static annotations(annotations) {
return makeBrandClass(this.from, mergeSchemaAnnotations(this.ast, annotations));
}
static make = (a, options) => {
return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a);
};
static from = from;
};
}
/**
* Returns a nominal branded schema by applying a brand to a given schema.
*
* ```
* Schema<A> + B -> Schema<A & Brand<B>>
* ```
*
* @example
* ```ts
* import * as Schema from "effect/Schema"
*
* const Int = Schema.Number.pipe(Schema.int(), Schema.brand("Int"))
* type Int = Schema.Schema.Type<typeof Int> // number & Brand<"Int">
* ```
*
* @category branding
* @since 3.10.0
*/
const brand = (brand, annotations) => self => {
const annotation = option_.match(AST.getBrandAnnotation(self.ast), {
onNone: () => [brand],
onSome: brands => [...brands, brand]
});
const ast = AST.annotations(self.ast, toASTAnnotations({
[AST.BrandAnnotationId]: annotation,
...annotations
}));
return makeBrandClass(self, ast);
};
/**
* @category combinators
* @since 3.10.0
*/
exports.brand = brand;
const partial = self => make(AST.partial(self.ast));
/**
* @category combinators
* @since 3.10.0
*/
exports.partial = partial;
const partialWith = exports.partialWith = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[0]), (self, options) => make(AST.partial(self.ast, options)));
/**
* @category combinators
* @since 3.10.0
*/
const required = self => make(AST.required(self.ast));
/**
* Creates a new schema with shallow mutability applied to its properties.
*
* @category combinators
* @since 3.10.0
*/
exports.required = required;
const mutable = schema => make(AST.mutable(schema.ast));
exports.mutable = mutable;
const intersectTypeLiterals = (x, y, path) => {
if (AST.isTypeLiteral(x) && AST.isTypeLiteral(y)) {
const propertySignatures = [...x.propertySignatures];
for (const ps of y.propertySignatures) {
const name = ps.name;
const i = propertySignatures.findIndex(ps => ps.name === name);
if (i === -1) {
propertySignatures.push(ps);
} else {
const {
isOptional,
type
} = propertySignatures[i];
propertySignatures[i] = new AST.PropertySignature(name, extendAST(type, ps.type, path.concat(name)), isOptional, true);
}
}
return new AST.TypeLiteral(propertySignatures, x.indexSignatures.concat(y.indexSignatures));
}
throw new Error(errors_.getSchemaExtendErrorMessage(x, y, path));
};
const preserveRefinementAnnotations = /*#__PURE__*/AST.omitAnnotations([AST.IdentifierAnnotationId]);
const addRefinementToMembers = (refinement, asts) => asts.map(ast => new AST.Refinement(ast, refinement.filter, preserveRefinementAnnotations(refinement)));
const extendAST = (x, y, path) => AST.Union.make(intersectUnionMembers([x], [y], path));
const getTypes = ast => AST.isUnion(ast) ? ast.types : [ast];
const intersectUnionMembers = (xs, ys, path) => array_.flatMap(xs, x => array_.flatMap(ys, y => {
switch (y._tag) {
case "Literal":
{
if (Predicate.isString(y.literal) && AST.isStringKeyword(x) || Predicate.isNumber(y.literal) && AST.isNumberKeyword(x) || Predicate.isBoolean(y.literal) && AST.isBooleanKeyword(x)) {
return [y];
}
break;
}
case "StringKeyword":
{
if (y === AST.stringKeyword) {
if (AST.isStringKeyword(x) || AST.isLiteral(x) && Predicate.isString(x.literal)) {
return [x];
} else if (AST.isRefinement(x)) {
return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path));
}
} else if (x === AST.stringKeyword) {
return [y];
}
break;
}
case "NumberKeyword":
{
if (y === AST.numberKeyword) {
if (AST.isNumberKeyword(x) || AST.isLiteral(x) && Predicate.isNumber(x.literal)) {
return [x];
} else if (AST.isRefinement(x)) {
return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path));
}
} else if (x === AST.numberKeyword) {
return [y];
}
break;
}
case "BooleanKeyword":
{
if (y === AST.booleanKeyword) {
if (AST.isBooleanKeyword(x) || AST.isLiteral(x) && Predicate.isBoolean(x.literal)) {
return [x];
} else if (AST.isRefinement(x)) {
return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path));
}
} else if (x === AST.booleanKeyword) {
return [y];
}
break;
}
case "Union":
return intersectUnionMembers(getTypes(x), y.types, path);
case "Suspend":
return [new AST.Suspend(() => extendAST(x, y.f(), path))];
case "Refinement":
return addRefinementToMembers(y, intersectUnionMembers(getTypes(x), getTypes(y.from), path));
case "TypeLiteral":
{
switch (x._tag) {
case "Union":
return intersectUnionMembers(x.types, [y], path);
case "Suspend":
return [new AST.Suspend(() => extendAST(x.f(), y, path))];
case "Refinement":
return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path));
case "TypeLiteral":
return [intersectTypeLiterals(x, y, path)];
case "Transformation":
{
const transformation = x.transformation;
const from = intersectTypeLiterals(x.from, y, path);
const to = intersectTypeLiterals(x.to, AST.typeAST(y), path);
switch (transformation._tag) {
case "TypeLiteralTransformation":
return [new AST.Transformation(from, to, new AST.TypeLiteralTransformation(transformation.propertySignatureTransformations))];
case "ComposeTransformation":
return [new AST.Transformation(from, to, AST.composeTransformation)];
case "FinalTransformation":
return [new AST.Transformation(from, to, new AST.FinalTransformation((fromA, options, ast, fromI) => ParseResult.map(transformation.decode(fromA, options, ast, fromI), partial => ({
...fromA,
...partial
})), (toI, options, ast, toA) => ParseResult.map(transformation.encode(toI, options, ast, toA), partial => ({
...toI,
...partial
}))))];
}
}
}
break;
}
case "Transformation":
{
if (AST.isTransformation(x)) {
if (AST.isTypeLiteralTransformation(y.transformation) && AST.isTypeLiteralTransformation(x.transformation)) {
return [new AST.Transformation(intersectTypeLiterals(x.from, y.from, path), intersectTypeLiterals(x.to, y.to, path), new AST.TypeLiteralTransformation(y.transformation.propertySignatureTransformations.concat(x.transformation.propertySignatureTransformations)))];
}
} else {
return intersectUnionMembers([y], [x], path);
}
break;
}
}
throw new Error(errors_.getSchemaExtendErrorMessage(x, y, path));
}));
/**
* Extends a schema with another schema.
*
* Not all extensions are supported, and their support depends on the nature of
* the involved schemas.
*
* Possible extensions include:
* - `Schema.String` with another `Schema.String` refinement or a string literal
* - `Schema.Number` with another `Schema.Number` refinement or a number literal
* - `Schema.Boolean` with another `Schema.Boolean` refinement or a boolean
* literal
* - A struct with another struct where overlapping fields support extension
* - A struct with in index signature
* - A struct with a union of supported schemas
* - A refinement of a struct with a supported schema
* - A suspend of a struct with a supported schema
* - A transformation between structs where the “from” and “to” sides have no
* overlapping fields with the target struct
*
* @example
* ```ts
* import * as Schema from "effect/Schema"
*
* const schema = Schema.Struct({
* a: Schema.String,
* b: Schema.String
* })
*
* // const extended: Schema<
* // {
* // readonly a: string
* // readonly b: string
* // } & {
* // readonly c: string
* // } & {
* // readonly [x: string]: string
* // }
* // >
* const extended = Schema.asSchema(schema.pipe(
* Schema.extend(Schema.Struct({ c: Schema.String })), // <= you can add more fields
* Schema.extend(Schema.Record({ key: Schema.String, value: Schema.String })) // <= you can add index signatures
* ))
* ```
*
* @category combinators
* @since 3.10.0
*/
const extend = exports.extend = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => make(extendAST(self.ast, that.ast, [])));
/**
* @category combinators
* @since 3.10.0
*/
const compose = exports.compose = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[1]), (from, to) => makeTransformationClass(from, to, AST.compose(from.ast, to.ast)));
/**
* @category constructors
* @since 3.10.0
*/
const suspend = f => make(new AST.Suspend(() => f().ast));
/**
* @since 3.10.0
* @category symbol
*/
exports.suspend = suspend;
const RefineSchemaId = exports.RefineSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Refine");
function makeRefineClass(from, filter, ast) {
return class RefineClass extends make(ast) {
static annotations(annotations) {
return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations));
}
static [RefineSchemaId] = from;
static from = from;
static filter = filter;
static make = (a, options) => {
return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a);
};
};
}
const fromFilterPredicateReturnTypeItem = (item, ast, input) => {
if (Predicate.isBoolean(item)) {
return item ? option_.none() : option_.some(new ParseResult.Type(ast, input));
}
if (Predicate.isString(item)) {
return option_.some(new ParseResult.Type(ast, input, item));
}
if (item !== undefined) {
if ("_tag" in item) {
return option_.some(item);
}
const issue = new ParseResult.Type(ast, input, item.message);
return option_.some(array_.isNonEmptyReadonlyArray(item.path) ? new ParseResult.Pointer(item.path, input, issue) : issue);
}
return option_.none();
};
const toFilterParseIssue = (out, ast, input) => {
if (util_.isSingle(out)) {
return fromFilterPredicateReturnTypeItem(out, ast, input);
}
if (array_.isNonEmptyReadonlyArray(out)) {
const issues = array_.filterMap(out, issue => fromFilterPredicateReturnTypeItem(issue, ast, input));
if (array_.isNonEmptyReadonlyArray(issues)) {
return option_.some(issues.length === 1 ? issues[0] : new ParseResult.Composite(ast, input, issues));
}
}
return option_.none();
};
function filter(predicate, annotations) {
return self => {
function filter(input, options, ast) {
return toFilterParseIssue(predicate(input, options, ast), ast, input);
}
const ast = new AST.Refinement(self.ast, filter, toASTAnnotations(annotations));
return makeRefineClass(self, filter, ast);
};
}
/**
* @category transformations
* @since 3.10.0
*/
const filterEffect = exports.filterEffect = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => transformOrFail(self, typeSchema(self), {
strict: true,
decode: (i, options, ast) => ParseResult.flatMap(f(i, options, ast), filterReturnType => option_.match(toFilterParseIssue(filterReturnType, ast, i), {
onNone: () => ParseResult.succeed(i),
onSome: ParseResult.fail
})),
encode: a => ParseResult.succeed(a)
}));
function makeTransformationClass(from, to, ast) {
return class TransformationClass extends make(ast) {
static annotations(annotations) {
return makeTransformationClass(this.from, this.to, mergeSchemaAnnotations(this.ast, annotations));
}
static from = from;
static to = to;
};
}
/**
* Create a new `Schema` by transforming the input and output of an existing `Schema`
* using the provided decoding functions.
*
* @category transformations
* @since 3.10.0
*/
const transformOrFail = exports.transformOrFail = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[0]) && isSchema(args[1]), (from, to, options) => makeTransformationClass(from, to, new AST.Transformation(from.ast, to.ast, new AST.FinalTransformation(options.decode, options.encode))));
/**
* Create a new `Schema` by transforming the input and output of an existing `Schema`
* using the provided mapping functions.
*
* @category transformations
* @since 3.10.0
*/
const transform = exports.transform = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[0]) && isSchema(args[1]), (from, to, options) => transformOrFail(from, to, {
strict: true,
decode: (fromA, _options, _ast, toA) => ParseResult.succeed(options.decode(fromA, toA)),
encode: (toI, _options, _ast, toA) => ParseResult.succeed(options.encode(toI, toA))
}));
/**
* Creates a new `Schema` which transforms literal values.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import * as S from "effect/Schema"
*
* const schema = S.transformLiteral(0, "a")
*
* assert.deepStrictEqual(S.decodeSync(schema)(0), "a")
* ```
*
* @category constructors
* @since 3.10.0
*/
function transformLiteral(from, to) {
return transform(Literal(from), Literal(to), {
strict: true,
decode: () => to,
encode: () => from
});
}
function transformLiterals(...pairs) {
return Union(...pairs.map(([from, to]) => transformLiteral(from, to)));
}
/**
* Attaches a property signature with the specified key and value to the schema.
* This API is useful when you want to add a property to your schema which doesn't describe the shape of the input,
* but rather maps to another schema, for example when you want to add a discriminant to a simple union.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import * as S from "effect/Schema"
* import { pipe } from "effect/Function"
*
* const Circle = S.Struct({ radius: S.Number })
* const Square = S.Struct({ sideLength: S.Number })
* const Shape = S.Union(
* Circle.pipe(S.attachPropertySignature("kind", "circle")),
* Square.pipe(S.attachPropertySignature("kind", "square"))
* )
*
* assert.deepStrictEqual(S.decodeSync(Shape)({ radius: 10 }), {
* kind: "circle",
* radius: 10
* })
* ```
*
* @category combinators
* @since 3.10.0
*/
const attachPropertySignature = exports.attachPropertySignature = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[0]), (schema, key, value, annotations) => {
const ast = extend(typeSchema(schema), Struct({
[key]: Predicate.isSymbol(value) ? UniqueSymbolFromSelf(value) : Literal(value)
})).ast;
return make(new AST.Transformation(schema.ast, annotations ? mergeSchemaAnnotations(ast, annotations) : ast, new AST.TypeLiteralTransformation([new AST.PropertySignatureTransformation(key, key, () => option_.some(value), () => option_.none())])));
});
/**
* Merges a set of new annotations with existing ones, potentially overwriting
* any duplicates.
*
* @category annotations
* @since 3.10.0
*/
const annotations = exports.annotations = /*#__PURE__*/(0, _Function.dual)(2, (self, annotations) => self.annotations(annotations));
/**
* @category renaming
* @since 3.10.0
*/
const rename = exports.rename = /*#__PURE__*/(0, _Function.dual)(2, (self, mapping) => make(AST.rename(self.ast, mapping)));
/**
* @category schema id
* @since 3.10.0
*/
const TrimmedSchemaId = exports.TrimmedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Trimmed");
/**
* Verifies that a string contains no leading or trailing whitespaces.
*
* Note. This combinator does not make any transformations, it only validates.
* If what you were looking for was a combinator to trim strings, then check out the `trim` combinator.
*
* @category string filters
* @since 3.10.0
*/
const trimmed = annotations => self => self.pipe(filter(a => a === a.trim(), {
schemaId: TrimmedSchemaId,
title: "trimmed",
description: "a string with no leading or trailing whitespace",
jsonSchema: {
pattern: "^\\S[\\s\\S]*\\S$|^\\S$|^$"
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.trimmed = trimmed;
const MaxLengthSchemaId = exports.MaxLengthSchemaId = schemaId_.MaxLengthSchemaId;
/**
* @category string filters
* @since 3.10.0
*/
const maxLength = (maxLength, annotations) => self => self.pipe(filter(a => a.length <= maxLength, {
schemaId: MaxLengthSchemaId,
title: `maxLength(${maxLength})`,
description: `a string at most ${maxLength} character(s) long`,
jsonSchema: {
maxLength
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.maxLength = maxLength;
const MinLengthSchemaId = exports.MinLengthSchemaId = schemaId_.MinLengthSchemaId;
/**
* @category string filters
* @since 3.10.0
*/
const minLength = (minLength, annotations) => self => self.pipe(filter(a => a.length >= minLength, {
schemaId: MinLengthSchemaId,
title: `minLength(${minLength})`,
description: `a string at least ${minLength} character(s) long`,
jsonSchema: {
minLength
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.minLength = minLength;
const LengthSchemaId = exports.LengthSchemaId = schemaId_.LengthSchemaId;
/**
* @category string filters
* @since 3.10.0
*/
const length = (length, annotations) => self => {
const minLength = Predicate.isObject(length) ? Math.max(0, Math.floor(length.min)) : Math.max(0, Math.floor(length));
const maxLength = Predicate.isObject(length) ? Math.max(minLength, Math.floor(length.max)) : minLength;
if (minLength !== maxLength) {
return self.pipe(filter(a => a.length >= minLength && a.length <= maxLength, {
schemaId: LengthSchemaId,
title: `length({ min: ${minLength}, max: ${maxLength})`,
description: `a string at least ${minLength} character(s) and at most ${maxLength} character(s) long`,
jsonSchema: {
minLength,
maxLength
},
...annotations
}));
}
return self.pipe(filter(a => a.length === minLength, {
schemaId: LengthSchemaId,
title: `length(${minLength})`,
description: minLength === 1 ? `a single character` : `a string ${minLength} character(s) long`,
jsonSchema: {
minLength,
maxLength: minLength
},
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.length = length;
const PatternSchemaId = exports.PatternSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Pattern");
/**
* @category string filters
* @since 3.10.0
*/
const pattern = (regex, annotations) => self => {
const source = regex.source;
return self.pipe(filter(a => {
// The following line ensures that `lastIndex` is reset to `0` in case the user has specified the `g` flag
regex.lastIndex = 0;
return regex.test(a);
}, {
schemaId: PatternSchemaId,
[PatternSchemaId]: {
regex
},
// title: `pattern(/${source}/)`, // avoiding this because it can be very long
description: `a string matching the pattern ${source}`,
jsonSchema: {
pattern: source
},
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.pattern = pattern;
const StartsWithSchemaId = exports.StartsWithSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/StartsWith");
/**
* @category string filters
* @since 3.10.0
*/
const startsWith = (startsWith, annotations) => self => {
const formatted = JSON.stringify(startsWith);
return self.pipe(filter(a => a.startsWith(startsWith), {
schemaId: StartsWithSchemaId,
[StartsWithSchemaId]: {
startsWith
},
title: `startsWith(${formatted})`,
description: `a string starting with ${formatted}`,
jsonSchema: {
pattern: `^${startsWith}`
},
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.startsWith = startsWith;
const EndsWithSchemaId = exports.EndsWithSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/EndsWith");
/**
* @category string filters
* @since 3.10.0
*/
const endsWith = (endsWith, annotations) => self => {
const formatted = JSON.stringify(endsWith);
return self.pipe(filter(a => a.endsWith(endsWith), {
schemaId: EndsWithSchemaId,
[EndsWithSchemaId]: {
endsWith
},
title: `endsWith(${formatted})`,
description: `a string ending with ${formatted}`,
jsonSchema: {
pattern: `^.*${endsWith}$`
},
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.endsWith = endsWith;
const IncludesSchemaId = exports.IncludesSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Includes");
/**
* @category string filters
* @since 3.10.0
*/
const includes = (searchString, annotations) => self => {
const formatted = JSON.stringify(searchString);
return self.pipe(filter(a => a.includes(searchString), {
schemaId: IncludesSchemaId,
[IncludesSchemaId]: {
includes: searchString
},
title: `includes(${formatted})`,
description: `a string including ${formatted}`,
jsonSchema: {
pattern: `.*${searchString}.*`
},
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.includes = includes;
const LowercasedSchemaId = exports.LowercasedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Lowercased");
/**
* Verifies that a string is lowercased.
*
* @category string filters
* @since 3.10.0
*/
const lowercased = annotations => self => self.pipe(filter(a => a === a.toLowerCase(), {
schemaId: LowercasedSchemaId,
title: "lowercased",
description: "a lowercase string",
jsonSchema: {
pattern: "^[^A-Z]*$"
},
...annotations
}));
/**
* @category string constructors
* @since 3.10.0
*/
exports.lowercased = lowercased;
class Lowercased extends /*#__PURE__*/String$.pipe(/*#__PURE__*/lowercased({
identifier: "Lowercased"
})) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.Lowercased = Lowercased;
const UppercasedSchemaId = exports.UppercasedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Uppercased");
/**
* Verifies that a string is uppercased.
*
* @category string filters
* @since 3.10.0
*/
const uppercased = annotations => self => self.pipe(filter(a => a === a.toUpperCase(), {
schemaId: UppercasedSchemaId,
title: "uppercased",
description: "an uppercase string",
jsonSchema: {
pattern: "^[^a-z]*$"
},
...annotations
}));
/**
* @category string constructors
* @since 3.10.0
*/
exports.uppercased = uppercased;
class Uppercased extends /*#__PURE__*/String$.pipe(/*#__PURE__*/uppercased({
identifier: "Uppercased"
})) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.Uppercased = Uppercased;
const CapitalizedSchemaId = exports.CapitalizedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Capitalized");
/**
* Verifies that a string is capitalized.
*
* @category string filters
* @since 3.10.0
*/
const capitalized = annotations => self => self.pipe(filter(a => a[0]?.toUpperCase() === a[0], {
schemaId: CapitalizedSchemaId,
title: "capitalized",
description: "a capitalized string",
jsonSchema: {
pattern: "^[^a-z]?.*$"
},
...annotations
}));
/**
* @category string constructors
* @since 3.10.0
*/
exports.capitalized = capitalized;
class Capitalized extends /*#__PURE__*/String$.pipe(/*#__PURE__*/capitalized({
identifier: "Capitalized"
})) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.Capitalized = Capitalized;
const UncapitalizedSchemaId = exports.UncapitalizedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Uncapitalized");
/**
* Verifies that a string is uncapitalized.
*
* @category string filters
* @since 3.10.0
*/
const uncapitalized = annotations => self => self.pipe(filter(a => a[0]?.toLowerCase() === a[0], {
schemaId: UncapitalizedSchemaId,
title: "uncapitalized",
description: "a uncapitalized string",
jsonSchema: {
pattern: "^[^A-Z]?.*$"
},
...annotations
}));
/**
* @category string constructors
* @since 3.10.0
*/
exports.uncapitalized = uncapitalized;
class Uncapitalized extends /*#__PURE__*/String$.pipe(/*#__PURE__*/uncapitalized({
identifier: "Uncapitalized"
})) {}
/**
* A schema representing a single character.
*
* @category string constructors
* @since 3.10.0
*/
exports.Uncapitalized = Uncapitalized;
class Char extends /*#__PURE__*/String$.pipe(/*#__PURE__*/length(1, {
identifier: "Char"
})) {}
/**
* @category string filters
* @since 3.10.0
*/
exports.Char = Char;
const nonEmptyString = annotations => minLength(1, {
title: "nonEmptyString",
description: "a non empty string",
...annotations
});
/**
* This schema converts a string to lowercase.
*
* @category string transformations
* @since 3.10.0
*/
exports.nonEmptyString = nonEmptyString;
class Lowercase extends /*#__PURE__*/transform(String$.annotations({
description: "a string that will be converted to lowercase"
}), Lowercased, {
strict: true,
decode: i => i.toLowerCase(),
encode: _Function.identity
}).annotations({
identifier: "Lowercase"
}) {}
/**
* This schema converts a string to uppercase.
*
* @category string transformations
* @since 3.10.0
*/
exports.Lowercase = Lowercase;
class Uppercase extends /*#__PURE__*/transform(String$.annotations({
description: "a string that will be converted to uppercase"
}), Uppercased, {
strict: true,
decode: i => i.toUpperCase(),
encode: _Function.identity
}).annotations({
identifier: "Uppercase"
}) {}
/**
* This schema converts a string to capitalized one.
*
* @category string transformations
* @since 3.10.0
*/
exports.Uppercase = Uppercase;
class Capitalize extends /*#__PURE__*/transform(String$.annotations({
description: "a string that will be converted to a capitalized format"
}), Capitalized, {
strict: true,
decode: i => string_.capitalize(i),
encode: _Function.identity
}).annotations({
identifier: "Capitalize"
}) {}
/**
* This schema converts a string to uncapitalized one.
*
* @category string transformations
* @since 3.10.0
*/
exports.Capitalize = Capitalize;
class Uncapitalize extends /*#__PURE__*/transform(String$.annotations({
description: "a string that will be converted to an uncapitalized format"
}), Uncapitalized, {
strict: true,
decode: i => string_.uncapitalize(i),
encode: _Function.identity
}).annotations({
identifier: "Uncapitalize"
}) {}
/**
* @category string constructors
* @since 3.10.0
*/
exports.Uncapitalize = Uncapitalize;
class Trimmed extends /*#__PURE__*/String$.pipe(/*#__PURE__*/trimmed({
identifier: "Trimmed"
})) {}
/**
* Useful for validating strings that must contain meaningful characters without
* leading or trailing whitespace.
*
* @example
* ```ts
* import { Schema } from "effect"
*
* console.log(Schema.decodeOption(Schema.NonEmptyTrimmedString)("")) // Option.none()
* console.log(Schema.decodeOption(Schema.NonEmptyTrimmedString)(" a ")) // Option.none()
* console.log(Schema.decodeOption(Schema.NonEmptyTrimmedString)("a")) // Option.some("a")
* ```
*
* @category string constructors
* @since 3.10.0
*/
exports.Trimmed = Trimmed;
class NonEmptyTrimmedString extends /*#__PURE__*/Trimmed.pipe(/*#__PURE__*/nonEmptyString({
identifier: "NonEmptyTrimmedString"
})) {}
/**
* This schema allows removing whitespaces from the beginning and end of a string.
*
* @category string transformations
* @since 3.10.0
*/
exports.NonEmptyTrimmedString = NonEmptyTrimmedString;
class Trim extends /*#__PURE__*/transform(String$.annotations({
description: "a string that will be trimmed"
}), Trimmed, {
strict: true,
decode: i => i.trim(),
encode: _Function.identity
}).annotations({
identifier: "Trim"
}) {}
/**
* Returns a schema that allows splitting a string into an array of strings.
*
* @category string transformations
* @since 3.10.0
*/
exports.Trim = Trim;
const split = separator => transform(String$.annotations({
description: "a string that will be split"
}), Array$(String$), {
strict: true,
decode: i => i.split(separator),
encode: a => a.join(separator)
});
exports.split = split;
const getErrorMessage = e => e instanceof Error ? e.message : String(e);
const getParseJsonTransformation = options => transformOrFail(String$.annotations({
description: "a string to be decoded into JSON"
}), Unknown, {
strict: true,
decode: (i, _, ast) => ParseResult.try({
try: () => JSON.parse(i, options?.reviver),
catch: e => new ParseResult.Type(ast, i, getErrorMessage(e))
}),
encode: (a, _, ast) => ParseResult.try({
try: () => JSON.stringify(a, options?.replacer, options?.space),
catch: e => new ParseResult.Type(ast, a, getErrorMessage(e))
})
}).annotations({
title: "parseJson",
schemaId: AST.ParseJsonSchemaId
});
/**
* The `ParseJson` combinator provides a method to convert JSON strings into the `unknown` type using the underlying
* functionality of `JSON.parse`. It also utilizes `JSON.stringify` for encoding.
*
* You can optionally provide a `ParseJsonOptions` to configure both `JSON.parse` and `JSON.stringify` executions.
*
* Optionally, you can pass a schema `Schema<A, I, R>` to obtain an `A` type instead of `unknown`.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import * as Schema from "effect/Schema"
*
* assert.deepStrictEqual(Schema.decodeUnknownSync(Schema.parseJson())(`{"a":"1"}`), { a: "1" })
* assert.deepStrictEqual(Schema.decodeUnknownSync(Schema.parseJson(Schema.Struct({ a: Schema.NumberFromString })))(`{"a":"1"}`), { a: 1 })
* ```
*
* @category string transformations
* @since 3.10.0
*/
const parseJson = (schemaOrOptions, o) => isSchema(schemaOrOptions) ? compose(parseJson(o), schemaOrOptions) : getParseJsonTransformation(schemaOrOptions);
/**
* @category string constructors
* @since 3.10.0
*/
exports.parseJson = parseJson;
class NonEmptyString extends /*#__PURE__*/String$.pipe(/*#__PURE__*/nonEmptyString({
identifier: "NonEmptyString"
})) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.NonEmptyString = NonEmptyString;
const UUIDSchemaId = exports.UUIDSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/UUID");
const uuidRegexp = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
/**
* Represents a Universally Unique Identifier (UUID).
*
* This schema ensures that the provided string adheres to the standard UUID format.
*
* @category string constructors
* @since 3.10.0
*/
class UUID extends /*#__PURE__*/String$.pipe(/*#__PURE__*/pattern(uuidRegexp, {
schemaId: UUIDSchemaId,
identifier: "UUID",
jsonSchema: {
format: "uuid",
pattern: uuidRegexp.source
},
description: "a Universally Unique Identifier",
arbitrary: () => fc => fc.uuid()
})) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.UUID = UUID;
const ULIDSchemaId = exports.ULIDSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/ULID");
const ulidRegexp = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i;
/**
* Represents a Universally Unique Lexicographically Sortable Identifier (ULID).
*
* ULIDs are designed to be compact, URL-safe, and ordered, making them suitable for use as identifiers.
* This schema ensures that the provided string adheres to the standard ULID format.
*
* @category string constructors
* @since 3.10.0
*/
class ULID extends /*#__PURE__*/String$.pipe(/*#__PURE__*/pattern(ulidRegexp, {
schemaId: ULIDSchemaId,
identifier: "ULID",
description: "a Universally Unique Lexicographically Sortable Identifier",
arbitrary: () => fc => fc.ulid()
})) {}
/**
* Defines a schema that represents a `URL` object.
*
* @category URL constructors
* @since 3.11.0
*/
exports.ULID = ULID;
class URLFromSelf extends /*#__PURE__*/instanceOf(URL, {
identifier: "URLFromSelf",
arbitrary: () => fc => fc.webUrl().map(s => new URL(s)),
pretty: () => url => url.toString()
}) {}
/** @ignore */
exports.URLFromSelf = URLFromSelf;
class URL$ extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a URL"
}), URLFromSelf, {
strict: true,
decode: (i, _, ast) => ParseResult.try({
try: () => new URL(i),
catch: e => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a URL. ${getErrorMessage(e)}`)
}),
encode: a => ParseResult.succeed(a.toString())
}).annotations({
identifier: "URL",
pretty: () => url => url.toString()
}) {}
exports.URL = URL$;
/**
* @category schema id
* @since 3.10.0
*/
const FiniteSchemaId = exports.FiniteSchemaId = schemaId_.FiniteSchemaId;
/**
* Ensures that the provided value is a finite number (excluding NaN, +Infinity, and -Infinity).
*
* @category number filters
* @since 3.10.0
*/
const finite = annotations => self => self.pipe(filter(Number.isFinite, {
schemaId: FiniteSchemaId,
title: "finite",
description: "a finite number",
jsonSchema: {
"type": "number"
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.finite = finite;
const GreaterThanSchemaId = exports.GreaterThanSchemaId = schemaId_.GreaterThanSchemaId;
/**
* This filter checks whether the provided number is greater than the specified minimum.
*
* @category number filters
* @since 3.10.0
*/
const greaterThan = (exclusiveMinimum, annotations) => self => self.pipe(filter(a => a > exclusiveMinimum, {
schemaId: GreaterThanSchemaId,
title: `greaterThan(${exclusiveMinimum})`,
description: exclusiveMinimum === 0 ? "a positive number" : `a number greater than ${exclusiveMinimum}`,
jsonSchema: {
exclusiveMinimum
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThan = greaterThan;
const GreaterThanOrEqualToSchemaId = exports.GreaterThanOrEqualToSchemaId = schemaId_.GreaterThanOrEqualToSchemaId;
/**
* This filter checks whether the provided number is greater than or equal to the specified minimum.
*
* @category number filters
* @since 3.10.0
*/
const greaterThanOrEqualTo = (minimum, annotations) => self => self.pipe(filter(a => a >= minimum, {
schemaId: GreaterThanOrEqualToSchemaId,
title: `greaterThanOrEqualTo(${minimum})`,
description: minimum === 0 ? "a non-negative number" : `a number greater than or equal to ${minimum}`,
jsonSchema: {
minimum
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanOrEqualTo = greaterThanOrEqualTo;
const MultipleOfSchemaId = exports.MultipleOfSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/MultipleOf");
/**
* @category number filters
* @since 3.10.0
*/
const multipleOf = (divisor, annotations) => self => {
const positiveDivisor = Math.abs(divisor); // spec requires positive divisor
return self.pipe(filter(a => number_.remainder(a, divisor) === 0, {
schemaId: MultipleOfSchemaId,
title: `multipleOf(${positiveDivisor})`,
description: `a number divisible by ${positiveDivisor}`,
jsonSchema: {
multipleOf: positiveDivisor
},
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.multipleOf = multipleOf;
const IntSchemaId = exports.IntSchemaId = schemaId_.IntSchemaId;
/**
* Ensures that the provided value is an integer number (excluding NaN, +Infinity, and -Infinity).
*
* @category number filters
* @since 3.10.0
*/
const int = annotations => self => self.pipe(filter(a => Number.isSafeInteger(a), {
schemaId: IntSchemaId,
title: "int",
description: "an integer",
jsonSchema: {
type: "integer"
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.int = int;
const LessThanSchemaId = exports.LessThanSchemaId = schemaId_.LessThanSchemaId;
/**
* This filter checks whether the provided number is less than the specified maximum.
*
* @category number filters
* @since 3.10.0
*/
const lessThan = (exclusiveMaximum, annotations) => self => self.pipe(filter(a => a < exclusiveMaximum, {
schemaId: LessThanSchemaId,
title: `lessThan(${exclusiveMaximum})`,
description: exclusiveMaximum === 0 ? "a negative number" : `a number less than ${exclusiveMaximum}`,
jsonSchema: {
exclusiveMaximum
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThan = lessThan;
const LessThanOrEqualToSchemaId = exports.LessThanOrEqualToSchemaId = schemaId_.LessThanOrEqualToSchemaId;
/**
* This schema checks whether the provided number is less than or equal to the specified maximum.
*
* @category number filters
* @since 3.10.0
*/
const lessThanOrEqualTo = (maximum, annotations) => self => self.pipe(filter(a => a <= maximum, {
schemaId: LessThanOrEqualToSchemaId,
title: `lessThanOrEqualTo(${maximum})`,
description: maximum === 0 ? "a non-positive number" : `a number less than or equal to ${maximum}`,
jsonSchema: {
maximum
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanOrEqualTo = lessThanOrEqualTo;
const BetweenSchemaId = exports.BetweenSchemaId = schemaId_.BetweenSchemaId;
/**
* This filter checks whether the provided number falls within the specified minimum and maximum values.
*
* @category number filters
* @since 3.10.0
*/
const between = (minimum, maximum, annotations) => self => self.pipe(filter(a => a >= minimum && a <= maximum, {
schemaId: BetweenSchemaId,
title: `between(${minimum}, ${maximum})`,
description: `a number between ${minimum} and ${maximum}`,
jsonSchema: {
minimum,
maximum
},
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.between = between;
const NonNaNSchemaId = exports.NonNaNSchemaId = schemaId_.NonNaNSchemaId;
/**
* @category number filters
* @since 3.10.0
*/
const nonNaN = annotations => self => self.pipe(filter(a => !Number.isNaN(a), {
schemaId: NonNaNSchemaId,
title: "nonNaN",
description: "a number excluding NaN",
...annotations
}));
/**
* @category number filters
* @since 3.10.0
*/
exports.nonNaN = nonNaN;
const positive = annotations => greaterThan(0, {
title: "positive",
...annotations
});
/**
* @category number filters
* @since 3.10.0
*/
exports.positive = positive;
const negative = annotations => lessThan(0, {
title: "negative",
...annotations
});
/**
* @category number filters
* @since 3.10.0
*/
exports.negative = negative;
const nonPositive = annotations => lessThanOrEqualTo(0, {
title: "nonPositive",
...annotations
});
/**
* @category number filters
* @since 3.10.0
*/
exports.nonPositive = nonPositive;
const nonNegative = annotations => greaterThanOrEqualTo(0, {
title: "nonNegative",
...annotations
});
/**
* Clamps a number between a minimum and a maximum value.
*
* @category number transformations
* @since 3.10.0
*/
exports.nonNegative = nonNegative;
const clamp = (minimum, maximum) => self => {
return transform(self, typeSchema(self).pipe(between(minimum, maximum)), {
strict: false,
decode: i => number_.clamp(i, {
minimum,
maximum
}),
encode: _Function.identity
});
};
/**
* Transforms a `string` into a `number` by parsing the string using the `parse`
* function of the `effect/Number` module.
*
* It returns an error if the value can't be converted (for example when
* non-numeric characters are provided).
*
* The following special string values are supported: "NaN", "Infinity",
* "-Infinity".
*
* @category number transformations
* @since 3.10.0
*/
exports.clamp = clamp;
function parseNumber(self) {
return transformOrFail(self, Number$, {
strict: false,
decode: (i, _, ast) => ParseResult.fromOption(number_.parse(i), () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a number`)),
encode: a => ParseResult.succeed(String(a))
});
}
/**
* This schema transforms a `string` into a `number` by parsing the string using the `parse` function of the `effect/Number` module.
*
* It returns an error if the value can't be converted (for example when non-numeric characters are provided).
*
* The following special string values are supported: "NaN", "Infinity", "-Infinity".
*
* @category number transformations
* @since 3.10.0
*/
class NumberFromString extends /*#__PURE__*/parseNumber(String$.annotations({
description: "a string to be decoded into a number"
})).annotations({
identifier: "NumberFromString"
}) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.NumberFromString = NumberFromString;
class Finite extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/finite({
identifier: "Finite"
})) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.Finite = Finite;
class Int extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/int({
identifier: "Int"
})) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.Int = Int;
class NonNaN extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/nonNaN({
identifier: "NonNaN"
})) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.NonNaN = NonNaN;
class Positive extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/positive({
identifier: "Positive"
})) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.Positive = Positive;
class Negative extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/negative({
identifier: "Negative"
})) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.Negative = Negative;
class NonPositive extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/nonPositive({
identifier: "NonPositive"
})) {}
/**
* @category number constructors
* @since 3.10.0
*/
exports.NonPositive = NonPositive;
class NonNegative extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/nonNegative({
identifier: "NonNegative"
})) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.NonNegative = NonNegative;
const JsonNumberSchemaId = exports.JsonNumberSchemaId = schemaId_.JsonNumberSchemaId;
/**
* The `JsonNumber` is a schema for representing JSON numbers. It ensures that the provided value is a valid
* number by filtering out `NaN` and `(+/-) Infinity`. This is useful when you want to validate and represent numbers in JSON
* format.
*
* @example
* ```ts
* import * as assert from "node:assert"
* import * as Schema from "effect/Schema"
*
* const is = Schema.is(S.JsonNumber)
*
* assert.deepStrictEqual(is(42), true)
* assert.deepStrictEqual(is(Number.NaN), false)
* assert.deepStrictEqual(is(Number.POSITIVE_INFINITY), false)
* assert.deepStrictEqual(is(Number.NEGATIVE_INFINITY), false)
* ```
*
* @category number constructors
* @since 3.10.0
*/
class JsonNumber extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/finite({
schemaId: JsonNumberSchemaId,
identifier: "JsonNumber"
})) {}
/**
* @category boolean transformations
* @since 3.10.0
*/
exports.JsonNumber = JsonNumber;
class Not extends /*#__PURE__*/transform(/*#__PURE__*/Boolean$.annotations({
description: "a boolean that will be negated"
}), Boolean$, {
strict: true,
decode: i => boolean_.not(i),
encode: a => boolean_.not(a)
}) {}
exports.Not = Not;
const encodeSymbol = (sym, ast) => {
const key = Symbol.keyFor(sym);
return key === undefined ? ParseResult.fail(new ParseResult.Type(ast, sym, `Unable to encode a unique symbol ${String(sym)} into a string`)) : ParseResult.succeed(key);
};
const decodeSymbol = s => ParseResult.succeed(Symbol.for(s));
/** @ignore */
class Symbol$ extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a globally shared symbol"
}), SymbolFromSelf, {
strict: false,
decode: i => decodeSymbol(i),
encode: (a, _, ast) => encodeSymbol(a, ast)
}).annotations({
identifier: "Symbol"
}) {}
exports.Symbol = Symbol$;
/**
* @category schema id
* @since 3.10.0
*/
const GreaterThanBigIntSchemaId = exports.GreaterThanBigIntSchemaId = schemaId_.GreaterThanBigintSchemaId;
/**
* @category bigint filters
* @since 3.10.0
*/
const greaterThanBigInt = (min, annotations) => self => self.pipe(filter(a => a > min, {
schemaId: GreaterThanBigIntSchemaId,
[GreaterThanBigIntSchemaId]: {
min
},
title: `greaterThanBigInt(${min})`,
description: min === 0n ? "a positive bigint" : `a bigint greater than ${min}n`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanBigInt = greaterThanBigInt;
const GreaterThanOrEqualToBigIntSchemaId = exports.GreaterThanOrEqualToBigIntSchemaId = schemaId_.GreaterThanOrEqualToBigIntSchemaId;
/**
* @category bigint filters
* @since 3.10.0
*/
const greaterThanOrEqualToBigInt = (min, annotations) => self => self.pipe(filter(a => a >= min, {
schemaId: GreaterThanOrEqualToBigIntSchemaId,
[GreaterThanOrEqualToBigIntSchemaId]: {
min
},
title: `greaterThanOrEqualToBigInt(${min})`,
description: min === 0n ? "a non-negative bigint" : `a bigint greater than or equal to ${min}n`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanOrEqualToBigInt = greaterThanOrEqualToBigInt;
const LessThanBigIntSchemaId = exports.LessThanBigIntSchemaId = schemaId_.LessThanBigIntSchemaId;
/**
* @category bigint filters
* @since 3.10.0
*/
const lessThanBigInt = (max, annotations) => self => self.pipe(filter(a => a < max, {
schemaId: LessThanBigIntSchemaId,
[LessThanBigIntSchemaId]: {
max
},
title: `lessThanBigInt(${max})`,
description: max === 0n ? "a negative bigint" : `a bigint less than ${max}n`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanBigInt = lessThanBigInt;
const LessThanOrEqualToBigIntSchemaId = exports.LessThanOrEqualToBigIntSchemaId = schemaId_.LessThanOrEqualToBigIntSchemaId;
/**
* @category bigint filters
* @since 3.10.0
*/
const lessThanOrEqualToBigInt = (max, annotations) => self => self.pipe(filter(a => a <= max, {
schemaId: LessThanOrEqualToBigIntSchemaId,
[LessThanOrEqualToBigIntSchemaId]: {
max
},
title: `lessThanOrEqualToBigInt(${max})`,
description: max === 0n ? "a non-positive bigint" : `a bigint less than or equal to ${max}n`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanOrEqualToBigInt = lessThanOrEqualToBigInt;
const BetweenBigIntSchemaId = exports.BetweenBigIntSchemaId = schemaId_.BetweenBigintSchemaId;
/**
* @category bigint filters
* @since 3.10.0
*/
const betweenBigInt = (min, max, annotations) => self => self.pipe(filter(a => a >= min && a <= max, {
schemaId: BetweenBigIntSchemaId,
[BetweenBigIntSchemaId]: {
min,
max
},
title: `betweenBigInt(${min}, ${max})`,
description: `a bigint between ${min}n and ${max}n`,
...annotations
}));
/**
* @category bigint filters
* @since 3.10.0
*/
exports.betweenBigInt = betweenBigInt;
const positiveBigInt = annotations => greaterThanBigInt(0n, {
title: "positiveBigInt",
...annotations
});
/**
* @category bigint filters
* @since 3.10.0
*/
exports.positiveBigInt = positiveBigInt;
const negativeBigInt = annotations => lessThanBigInt(0n, {
title: "negativeBigInt",
...annotations
});
/**
* @category bigint filters
* @since 3.10.0
*/
exports.negativeBigInt = negativeBigInt;
const nonNegativeBigInt = annotations => greaterThanOrEqualToBigInt(0n, {
title: "nonNegativeBigInt",
...annotations
});
/**
* @category bigint filters
* @since 3.10.0
*/
exports.nonNegativeBigInt = nonNegativeBigInt;
const nonPositiveBigInt = annotations => lessThanOrEqualToBigInt(0n, {
title: "nonPositiveBigInt",
...annotations
});
/**
* Clamps a bigint between a minimum and a maximum value.
*
* @category bigint transformations
* @since 3.10.0
*/
exports.nonPositiveBigInt = nonPositiveBigInt;
const clampBigInt = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, betweenBigInt(minimum, maximum)), {
strict: false,
decode: i => bigInt_.clamp(i, {
minimum,
maximum
}),
encode: _Function.identity
});
/** @ignore */
exports.clampBigInt = clampBigInt;
class BigInt$ extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a bigint"
}), BigIntFromSelf, {
strict: true,
decode: (i, _, ast) => ParseResult.fromOption(bigInt_.fromString(i), () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a bigint`)),
encode: a => ParseResult.succeed(String(a))
}).annotations({
identifier: "BigInt"
}) {}
exports.BigInt = BigInt$;
/**
* @category bigint constructors
* @since 3.10.0
*/
const PositiveBigIntFromSelf = exports.PositiveBigIntFromSelf = /*#__PURE__*/BigIntFromSelf.pipe(/*#__PURE__*/positiveBigInt({
identifier: "PositiveBigintFromSelf"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const PositiveBigInt = exports.PositiveBigInt = /*#__PURE__*/BigInt$.pipe(/*#__PURE__*/positiveBigInt({
identifier: "PositiveBigint"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const NegativeBigIntFromSelf = exports.NegativeBigIntFromSelf = /*#__PURE__*/BigIntFromSelf.pipe(/*#__PURE__*/negativeBigInt({
identifier: "NegativeBigintFromSelf"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const NegativeBigInt = exports.NegativeBigInt = /*#__PURE__*/BigInt$.pipe(/*#__PURE__*/negativeBigInt({
identifier: "NegativeBigint"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const NonPositiveBigIntFromSelf = exports.NonPositiveBigIntFromSelf = /*#__PURE__*/BigIntFromSelf.pipe(/*#__PURE__*/nonPositiveBigInt({
identifier: "NonPositiveBigintFromSelf"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const NonPositiveBigInt = exports.NonPositiveBigInt = /*#__PURE__*/BigInt$.pipe(/*#__PURE__*/nonPositiveBigInt({
identifier: "NonPositiveBigint"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const NonNegativeBigIntFromSelf = exports.NonNegativeBigIntFromSelf = /*#__PURE__*/BigIntFromSelf.pipe(/*#__PURE__*/nonNegativeBigInt({
identifier: "NonNegativeBigintFromSelf"
}));
/**
* @category bigint constructors
* @since 3.10.0
*/
const NonNegativeBigInt = exports.NonNegativeBigInt = /*#__PURE__*/BigInt$.pipe(/*#__PURE__*/nonNegativeBigInt({
identifier: "NonNegativeBigint"
}));
/**
* This schema transforms a `number` into a `bigint` by parsing the number using the `BigInt` function.
*
* It returns an error if the value can't be safely encoded as a `number` due to being out of range.
*
* @category bigint transformations
* @since 3.10.0
*/
class BigIntFromNumber extends /*#__PURE__*/transformOrFail(Number$.annotations({
description: "a number to be decoded into a bigint"
}), BigIntFromSelf.pipe(betweenBigInt(BigInt(Number.MIN_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER))), {
strict: true,
decode: (i, _, ast) => ParseResult.fromOption(bigInt_.fromNumber(i), () => new ParseResult.Type(ast, i, `Unable to decode ${i} into a bigint`)),
encode: (a, _, ast) => ParseResult.fromOption(bigInt_.toNumber(a), () => new ParseResult.Type(ast, a, `Unable to encode ${a}n into a number`))
}).annotations({
identifier: "BigIntFromNumber"
}) {}
exports.BigIntFromNumber = BigIntFromNumber;
const redactedArbitrary = value => fc => value(fc).map(redacted_.make);
const toComposite = (eff, onSuccess, ast, actual) => ParseResult.mapBoth(eff, {
onFailure: e => new ParseResult.Composite(ast, actual, e),
onSuccess
});
const redactedParse = decodeUnknown => (u, options, ast) => redacted_.isRedacted(u) ? toComposite(decodeUnknown(redacted_.value(u), options), redacted_.make, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Redacted constructors
* @since 3.10.0
*/
const RedactedFromSelf = value => declare([value], {
decode: value => redactedParse(ParseResult.decodeUnknown(value)),
encode: value => redactedParse(ParseResult.encodeUnknown(value))
}, {
description: "Redacted(<redacted>)",
pretty: () => () => "Redacted(<redacted>)",
arbitrary: redactedArbitrary,
equivalence: redacted_.getEquivalence
});
/**
* A transformation that transform a `Schema<A, I, R>` into a
* `RedactedFromSelf<A>`.
*
* @category Redacted transformations
* @since 3.10.0
*/
exports.RedactedFromSelf = RedactedFromSelf;
function Redacted(value) {
return transform(value, RedactedFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => redacted_.make(i),
encode: a => redacted_.value(a)
});
}
/**
* @category Duration constructors
* @since 3.10.0
*/
class DurationFromSelf extends /*#__PURE__*/declare(duration_.isDuration, {
identifier: "DurationFromSelf",
pretty: () => String,
arbitrary: () => fc => fc.oneof(fc.constant(duration_.infinity), fc.bigInt({
min: 0n
}).map(_ => duration_.nanos(_)), fc.maxSafeNat().map(_ => duration_.millis(_))),
equivalence: () => duration_.Equivalence
}) {}
/**
* A schema that transforms a non negative `bigint` into a `Duration`. Treats
* the value as the number of nanoseconds.
*
* @category Duration transformations
* @since 3.10.0
*/
exports.DurationFromSelf = DurationFromSelf;
class DurationFromNanos extends /*#__PURE__*/transformOrFail(NonNegativeBigIntFromSelf.annotations({
description: "a bigint to be decoded into a Duration"
}), DurationFromSelf.pipe(filter(duration => duration_.isFinite(duration), {
description: "a finite duration"
})), {
strict: true,
decode: i => ParseResult.succeed(duration_.nanos(i)),
encode: (a, _, ast) => option_.match(duration_.toNanos(a), {
onNone: () => ParseResult.fail(new ParseResult.Type(ast, a, `Unable to encode ${a} into a bigint`)),
onSome: nanos => ParseResult.succeed(nanos)
})
}).annotations({
identifier: "DurationFromNanos"
}) {}
/**
* A non-negative integer. +Infinity is excluded.
*
* @category number constructors
* @since 3.11.10
*/
exports.DurationFromNanos = DurationFromNanos;
const NonNegativeInt = exports.NonNegativeInt = /*#__PURE__*/NonNegative.pipe(int()).annotations({
identifier: "NonNegativeInt"
});
/**
* A schema that transforms a (possibly Infinite) non negative number into a
* `Duration`. Treats the value as the number of milliseconds.
*
* @category Duration transformations
* @since 3.10.0
*/
class DurationFromMillis extends /*#__PURE__*/transform(NonNegative.annotations({
description: "a non-negative number to be decoded into a Duration"
}), DurationFromSelf, {
strict: true,
decode: i => duration_.millis(i),
encode: a => duration_.toMillis(a)
}).annotations({
identifier: "DurationFromMillis"
}) {}
exports.DurationFromMillis = DurationFromMillis;
const DurationValueMillis = /*#__PURE__*/TaggedStruct("Millis", {
millis: NonNegativeInt
});
const DurationValueNanos = /*#__PURE__*/TaggedStruct("Nanos", {
nanos: BigInt$
});
const DurationValueInfinity = /*#__PURE__*/TaggedStruct("Infinity", {});
const durationValueInfinity = /*#__PURE__*/DurationValueInfinity.make({});
const DurationValue = /*#__PURE__*/Union(DurationValueMillis, DurationValueNanos, DurationValueInfinity).annotations({
identifier: "DurationValue",
description: "an JSON-compatible tagged union to be decoded into a Duration"
});
const FiniteHRTime = /*#__PURE__*/Tuple(element(NonNegativeInt).annotations({
title: "seconds"
}), element(NonNegativeInt).annotations({
title: "nanos"
})).annotations({
identifier: "FiniteHRTime"
});
const InfiniteHRTime = /*#__PURE__*/Tuple(Literal(-1), Literal(0)).annotations({
identifier: "InfiniteHRTime"
});
const HRTime = /*#__PURE__*/Union(FiniteHRTime, InfiniteHRTime).annotations({
identifier: "HRTime",
description: "a tuple of seconds and nanos to be decoded into a Duration"
});
const isDurationValue = u => typeof u === "object";
// TODO(4.0): remove HRTime union member
/**
* A schema that converts a JSON-compatible tagged union into a `Duration`.
*
* @category Duration transformations
* @since 3.10.0
*/
class Duration extends /*#__PURE__*/transform(Union(DurationValue, HRTime), DurationFromSelf, {
strict: true,
decode: i => {
if (isDurationValue(i)) {
switch (i._tag) {
case "Millis":
return duration_.millis(i.millis);
case "Nanos":
return duration_.nanos(i.nanos);
case "Infinity":
return duration_.infinity;
}
}
const [seconds, nanos] = i;
return seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos));
},
encode: a => {
switch (a.value._tag) {
case "Millis":
return DurationValueMillis.make({
millis: a.value.millis
});
case "Nanos":
return DurationValueNanos.make({
nanos: a.value.nanos
});
case "Infinity":
return durationValueInfinity;
}
}
}).annotations({
identifier: "Duration"
}) {}
/**
* Clamps a `Duration` between a minimum and a maximum value.
*
* @category Duration transformations
* @since 3.10.0
*/
exports.Duration = Duration;
const clampDuration = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, betweenDuration(minimum, maximum)), {
strict: false,
decode: i => duration_.clamp(i, {
minimum,
maximum
}),
encode: _Function.identity
});
/**
* @category schema id
* @since 3.10.0
*/
exports.clampDuration = clampDuration;
const LessThanDurationSchemaId = exports.LessThanDurationSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/LessThanDuration");
/**
* @category Duration filters
* @since 3.10.0
*/
const lessThanDuration = (max, annotations) => self => self.pipe(filter(a => duration_.lessThan(a, max), {
schemaId: LessThanDurationSchemaId,
[LessThanDurationSchemaId]: {
max
},
title: `lessThanDuration(${max})`,
description: `a Duration less than ${duration_.decode(max)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanDuration = lessThanDuration;
const LessThanOrEqualToDurationSchemaId = exports.LessThanOrEqualToDurationSchemaId = /*#__PURE__*/Symbol.for("effect/schema/LessThanOrEqualToDuration");
/**
* @category Duration filters
* @since 3.10.0
*/
const lessThanOrEqualToDuration = (max, annotations) => self => self.pipe(filter(a => duration_.lessThanOrEqualTo(a, max), {
schemaId: LessThanDurationSchemaId,
[LessThanDurationSchemaId]: {
max
},
title: `lessThanOrEqualToDuration(${max})`,
description: `a Duration less than or equal to ${duration_.decode(max)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanOrEqualToDuration = lessThanOrEqualToDuration;
const GreaterThanDurationSchemaId = exports.GreaterThanDurationSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/GreaterThanDuration");
/**
* @category Duration filters
* @since 3.10.0
*/
const greaterThanDuration = (min, annotations) => self => self.pipe(filter(a => duration_.greaterThan(a, min), {
schemaId: GreaterThanDurationSchemaId,
[GreaterThanDurationSchemaId]: {
min
},
title: `greaterThanDuration(${min})`,
description: `a Duration greater than ${duration_.decode(min)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanDuration = greaterThanDuration;
const GreaterThanOrEqualToDurationSchemaId = exports.GreaterThanOrEqualToDurationSchemaId = /*#__PURE__*/Symbol.for("effect/schema/GreaterThanOrEqualToDuration");
/**
* @category Duration filters
* @since 3.10.0
*/
const greaterThanOrEqualToDuration = (min, annotations) => self => self.pipe(filter(a => duration_.greaterThanOrEqualTo(a, min), {
schemaId: GreaterThanOrEqualToDurationSchemaId,
[GreaterThanOrEqualToDurationSchemaId]: {
min
},
title: `greaterThanOrEqualToDuration(${min})`,
description: `a Duration greater than or equal to ${duration_.decode(min)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanOrEqualToDuration = greaterThanOrEqualToDuration;
const BetweenDurationSchemaId = exports.BetweenDurationSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/BetweenDuration");
/**
* @category Duration filters
* @since 3.10.0
*/
const betweenDuration = (minimum, maximum, annotations) => self => self.pipe(filter(a => duration_.between(a, {
minimum,
maximum
}), {
schemaId: BetweenDurationSchemaId,
[BetweenDurationSchemaId]: {
maximum,
minimum
},
title: `betweenDuration(${minimum}, ${maximum})`,
description: `a Duration between ${duration_.decode(minimum)} and ${duration_.decode(maximum)}`,
...annotations
}));
/**
* @category Uint8Array constructors
* @since 3.10.0
*/
exports.betweenDuration = betweenDuration;
class Uint8ArrayFromSelf extends /*#__PURE__*/declare(Predicate.isUint8Array, {
identifier: "Uint8ArrayFromSelf",
pretty: () => u8arr => `new Uint8Array(${JSON.stringify(Array.from(u8arr))})`,
arbitrary: () => fc => fc.uint8Array(),
equivalence: () => array_.getEquivalence(Equal.equals)
}) {}
/**
* @category number constructors
* @since 3.11.10
*/
exports.Uint8ArrayFromSelf = Uint8ArrayFromSelf;
class Uint8 extends /*#__PURE__*/Number$.pipe(/*#__PURE__*/between(0, 255, {
identifier: "Uint8",
description: "a 8-bit unsigned integer"
})) {}
/** @ignore */
exports.Uint8 = Uint8;
class Uint8Array$ extends /*#__PURE__*/transform(Array$(Uint8).annotations({
description: "an array of 8-bit unsigned integers to be decoded into a Uint8Array"
}), Uint8ArrayFromSelf, {
strict: true,
decode: i => Uint8Array.from(i),
encode: a => Array.from(a)
}).annotations({
identifier: "Uint8Array"
}) {}
exports.Uint8Array = Uint8Array$;
const makeUint8ArrayTransformation = (id, decode, encode) => transformOrFail(String$.annotations({
description: "a string to be decoded into a Uint8Array"
}), Uint8ArrayFromSelf, {
strict: true,
decode: (i, _, ast) => either_.mapLeft(decode(i), decodeException => new ParseResult.Type(ast, i, decodeException.message)),
encode: a => ParseResult.succeed(encode(a))
}).annotations({
identifier: id
});
/**
* Decodes a base64 (RFC4648) encoded string into a `Uint8Array`.
*
* @category Uint8Array transformations
* @since 3.10.0
*/
const Uint8ArrayFromBase64 = exports.Uint8ArrayFromBase64 = /*#__PURE__*/makeUint8ArrayTransformation("Uint8ArrayFromBase64", Encoding.decodeBase64, Encoding.encodeBase64);
/**
* Decodes a base64 (URL) encoded string into a `Uint8Array`.
*
* @category Uint8Array transformations
* @since 3.10.0
*/
const Uint8ArrayFromBase64Url = exports.Uint8ArrayFromBase64Url = /*#__PURE__*/makeUint8ArrayTransformation("Uint8ArrayFromBase64Url", Encoding.decodeBase64Url, Encoding.encodeBase64Url);
/**
* Decodes a hex encoded string into a `Uint8Array`.
*
* @category Uint8Array transformations
* @since 3.10.0
*/
const Uint8ArrayFromHex = exports.Uint8ArrayFromHex = /*#__PURE__*/makeUint8ArrayTransformation("Uint8ArrayFromHex", Encoding.decodeHex, Encoding.encodeHex);
const makeEncodingTransformation = (id, decode, encode) => transformOrFail(String$.annotations({
description: `A string that is interpreted as being ${id}-encoded and will be decoded into a UTF-8 string`
}), String$, {
strict: true,
decode: (i, _, ast) => either_.mapLeft(decode(i), decodeException => new ParseResult.Type(ast, i, decodeException.message)),
encode: a => ParseResult.succeed(encode(a))
}).annotations({
identifier: `StringFrom${id}`
});
/**
* Decodes a base64 (RFC4648) encoded string into a UTF-8 string.
*
* @category string transformations
* @since 3.10.0
*/
const StringFromBase64 = exports.StringFromBase64 = /*#__PURE__*/makeEncodingTransformation("Base64", Encoding.decodeBase64String, Encoding.encodeBase64);
/**
* Decodes a base64 (URL) encoded string into a UTF-8 string.
*
* @category string transformations
* @since 3.10.0
*/
const StringFromBase64Url = exports.StringFromBase64Url = /*#__PURE__*/makeEncodingTransformation("Base64Url", Encoding.decodeBase64UrlString, Encoding.encodeBase64Url);
/**
* Decodes a hex encoded string into a UTF-8 string.
*
* @category string transformations
* @since 3.10.0
*/
const StringFromHex = exports.StringFromHex = /*#__PURE__*/makeEncodingTransformation("Hex", Encoding.decodeHexString, Encoding.encodeHex);
/**
* Decodes a URI component encoded string into a UTF-8 string.
* Can be used to store data in a URL.
*
* @example
* ```ts
* import { Schema } from "effect"
*
* const PaginationSchema = Schema.Struct({
* maxItemPerPage: Schema.Number,
* page: Schema.Number
* })
*
* const UrlSchema = Schema.compose(Schema.StringFromUriComponent, Schema.parseJson(PaginationSchema))
*
* console.log(Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }))
* // Output: %7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D
* ```
*
* @category string transformations
* @since 3.12.0
*/
const StringFromUriComponent = exports.StringFromUriComponent = /*#__PURE__*/transformOrFail(String$.annotations({
description: `A string that is interpreted as being UriComponent-encoded and will be decoded into a UTF-8 string`
}), String$, {
strict: true,
decode: (i, _, ast) => either_.mapLeft(Encoding.decodeUriComponent(i), decodeException => new ParseResult.Type(ast, i, decodeException.message)),
encode: (a, _, ast) => either_.mapLeft(Encoding.encodeUriComponent(a), encodeException => new ParseResult.Type(ast, a, encodeException.message))
}).annotations({
identifier: `StringFromUriComponent`
});
/**
* @category schema id
* @since 3.10.0
*/
const MinItemsSchemaId = exports.MinItemsSchemaId = schemaId_.MinItemsSchemaId;
/**
* @category ReadonlyArray filters
* @since 3.10.0
*/
const minItems = (n, annotations) => self => {
const minItems = Math.floor(n);
if (minItems < 1) {
throw new Error(errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 1, actual ${n}`));
}
return self.pipe(filter(a => a.length >= minItems, {
schemaId: MinItemsSchemaId,
title: `minItems(${minItems})`,
description: `an array of at least ${minItems} item(s)`,
jsonSchema: {
minItems
},
[AST.StableFilterAnnotationId]: true,
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.minItems = minItems;
const MaxItemsSchemaId = exports.MaxItemsSchemaId = schemaId_.MaxItemsSchemaId;
/**
* @category ReadonlyArray filters
* @since 3.10.0
*/
const maxItems = (n, annotations) => self => {
const maxItems = Math.floor(n);
if (maxItems < 1) {
throw new Error(errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 1, actual ${n}`));
}
return self.pipe(filter(a => a.length <= maxItems, {
schemaId: MaxItemsSchemaId,
title: `maxItems(${maxItems})`,
description: `an array of at most ${maxItems} item(s)`,
jsonSchema: {
maxItems
},
[AST.StableFilterAnnotationId]: true,
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.maxItems = maxItems;
const ItemsCountSchemaId = exports.ItemsCountSchemaId = schemaId_.ItemsCountSchemaId;
/**
* @category ReadonlyArray filters
* @since 3.10.0
*/
const itemsCount = (n, annotations) => self => {
const itemsCount = Math.floor(n);
if (itemsCount < 0) {
throw new Error(errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 0, actual ${n}`));
}
return self.pipe(filter(a => a.length === itemsCount, {
schemaId: ItemsCountSchemaId,
title: `itemsCount(${itemsCount})`,
description: `an array of exactly ${itemsCount} item(s)`,
jsonSchema: {
minItems: itemsCount,
maxItems: itemsCount
},
[AST.StableFilterAnnotationId]: true,
...annotations
}));
};
/**
* @category ReadonlyArray transformations
* @since 3.10.0
*/
exports.itemsCount = itemsCount;
const getNumberIndexedAccess = self => make(AST.getNumberIndexedAccess(self.ast));
/**
* Get the first element of a `ReadonlyArray`, or `None` if the array is empty.
*
* @category ReadonlyArray transformations
* @since 3.10.0
*/
exports.getNumberIndexedAccess = getNumberIndexedAccess;
function head(self) {
return transform(self, OptionFromSelf(getNumberIndexedAccess(typeSchema(self))), {
strict: false,
decode: i => array_.head(i),
encode: a => option_.match(a, {
onNone: () => [],
onSome: array_.of
})
});
}
/**
* Get the first element of a `NonEmptyReadonlyArray`.
*
* @category NonEmptyReadonlyArray transformations
* @since 3.12.0
*/
function headNonEmpty(self) {
return transform(self, getNumberIndexedAccess(typeSchema(self)), {
strict: false,
decode: i => array_.headNonEmpty(i),
encode: a => array_.of(a)
});
}
/**
* Retrieves the first element of a `ReadonlyArray`.
*
* If the array is empty, it returns the `fallback` argument if provided; otherwise, it fails.
*
* @category ReadonlyArray transformations
* @since 3.10.0
*/
const headOrElse = exports.headOrElse = /*#__PURE__*/(0, _Function.dual)(args => isSchema(args[0]), (self, fallback) => transformOrFail(self, getNumberIndexedAccess(typeSchema(self)), {
strict: true,
decode: (i, _, ast) => i.length > 0 ? ParseResult.succeed(i[0]) : fallback ? ParseResult.succeed(fallback()) : ParseResult.fail(new ParseResult.Type(ast, i, "Unable to retrieve the first element of an empty array")),
encode: a => ParseResult.succeed(array_.of(a))
}));
/**
* @category schema id
* @since 3.10.0
*/
const ValidDateSchemaId = exports.ValidDateSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/ValidDate");
/**
* Defines a filter that specifically rejects invalid dates, such as `new
* Date("Invalid Date")`. This filter ensures that only properly formatted and
* valid date objects are accepted, enhancing data integrity by preventing
* erroneous date values from being processed.
*
* @category Date filters
* @since 3.10.0
*/
const validDate = annotations => self => self.pipe(filter(a => !Number.isNaN(a.getTime()), {
schemaId: ValidDateSchemaId,
[ValidDateSchemaId]: {
noInvalidDate: true
},
title: "validDate",
description: "a valid Date",
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.validDate = validDate;
const LessThanDateSchemaId = exports.LessThanDateSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/LessThanDate");
/**
* @category Date filters
* @since 3.10.0
*/
const lessThanDate = (max, annotations) => self => self.pipe(filter(a => a < max, {
schemaId: LessThanDateSchemaId,
[LessThanDateSchemaId]: {
max
},
title: `lessThanDate(${util_.formatDate(max)})`,
description: `a date before ${util_.formatDate(max)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanDate = lessThanDate;
const LessThanOrEqualToDateSchemaId = exports.LessThanOrEqualToDateSchemaId = /*#__PURE__*/Symbol.for("effect/schema/LessThanOrEqualToDate");
/**
* @category Date filters
* @since 3.10.0
*/
const lessThanOrEqualToDate = (max, annotations) => self => self.pipe(filter(a => a <= max, {
schemaId: LessThanDateSchemaId,
[LessThanDateSchemaId]: {
max
},
title: `lessThanOrEqualToDate(${util_.formatDate(max)})`,
description: `a date before or equal to ${util_.formatDate(max)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanOrEqualToDate = lessThanOrEqualToDate;
const GreaterThanDateSchemaId = exports.GreaterThanDateSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/GreaterThanDate");
/**
* @category Date filters
* @since 3.10.0
*/
const greaterThanDate = (min, annotations) => self => self.pipe(filter(a => a > min, {
schemaId: GreaterThanDateSchemaId,
[GreaterThanDateSchemaId]: {
min
},
title: `greaterThanDate(${util_.formatDate(min)})`,
description: `a date after ${util_.formatDate(min)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanDate = greaterThanDate;
const GreaterThanOrEqualToDateSchemaId = exports.GreaterThanOrEqualToDateSchemaId = /*#__PURE__*/Symbol.for("effect/schema/GreaterThanOrEqualToDate");
/**
* @category Date filters
* @since 3.10.0
*/
const greaterThanOrEqualToDate = (min, annotations) => self => self.pipe(filter(a => a >= min, {
schemaId: GreaterThanOrEqualToDateSchemaId,
[GreaterThanOrEqualToDateSchemaId]: {
min
},
title: `greaterThanOrEqualToDate(${util_.formatDate(min)})`,
description: `a date after or equal to ${util_.formatDate(min)}`,
...annotations
}));
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanOrEqualToDate = greaterThanOrEqualToDate;
const BetweenDateSchemaId = exports.BetweenDateSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/BetweenDate");
/**
* @category Date filters
* @since 3.10.0
*/
const betweenDate = (min, max, annotations) => self => self.pipe(filter(a => a <= max && a >= min, {
schemaId: BetweenDateSchemaId,
[BetweenDateSchemaId]: {
max,
min
},
title: `betweenDate(${util_.formatDate(min)}, ${util_.formatDate(max)})`,
description: `a date between ${util_.formatDate(min)} and ${util_.formatDate(max)}`,
...annotations
}));
/**
* @category schema id
* @since 3.11.8
*/
exports.betweenDate = betweenDate;
const DateFromSelfSchemaId = exports.DateFromSelfSchemaId = schemaId_.DateFromSelfSchemaId;
/**
* Describes a schema that accommodates potentially invalid `Date` instances,
* such as `new Date("Invalid Date")`, without rejection.
*
* @category Date constructors
* @since 3.10.0
*/
class DateFromSelf extends /*#__PURE__*/declare(Predicate.isDate, {
identifier: "DateFromSelf",
schemaId: DateFromSelfSchemaId,
[DateFromSelfSchemaId]: {
noInvalidDate: false
},
description: "a potentially invalid Date instance",
pretty: () => date => `new Date(${JSON.stringify(date)})`,
arbitrary: () => fc => fc.date({
noInvalidDate: false
}),
equivalence: () => Equivalence.Date
}) {}
/**
* Defines a schema that ensures only valid dates are accepted. This schema
* rejects values like `new Date("Invalid Date")`, which, despite being a `Date`
* instance, represents an invalid date. Such stringent validation ensures that
* all date objects processed through this schema are properly formed and
* represent real dates.
*
* @category Date constructors
* @since 3.10.0
*/
exports.DateFromSelf = DateFromSelf;
class ValidDateFromSelf extends /*#__PURE__*/DateFromSelf.pipe(/*#__PURE__*/validDate({
identifier: "ValidDateFromSelf",
description: "a valid Date instance"
})) {}
/**
* Defines a schema that attempts to convert a `string` to a `Date` object using
* the `new Date` constructor. This conversion is lenient, meaning it does not
* reject strings that do not form valid dates (e.g., using `new Date("Invalid
* Date")` results in a `Date` object, despite being invalid).
*
* @category Date transformations
* @since 3.10.0
*/
exports.ValidDateFromSelf = ValidDateFromSelf;
class DateFromString extends /*#__PURE__*/transform(String$.annotations({
description: "a string to be decoded into a Date"
}), DateFromSelf, {
strict: true,
decode: i => new Date(i),
encode: a => util_.formatDate(a)
}).annotations({
identifier: "DateFromString"
}) {}
/** @ignore */
exports.DateFromString = DateFromString;
class Date$ extends /*#__PURE__*/DateFromString.pipe(/*#__PURE__*/validDate({
identifier: "Date"
})) {}
exports.Date = Date$;
/**
* Defines a schema that converts a `number` into a `Date` object using the `new
* Date` constructor. This schema does not validate the numerical input,
* allowing potentially invalid values such as `NaN`, `Infinity`, and
* `-Infinity` to be converted into `Date` objects. During the encoding process,
* any invalid `Date` object will be encoded to `NaN`.
*
* @category Date transformations
* @since 3.10.0
*/
class DateFromNumber extends /*#__PURE__*/transform(Number$.annotations({
description: "a number to be decoded into a Date"
}), DateFromSelf, {
strict: true,
decode: i => new Date(i),
encode: a => a.getTime()
}).annotations({
identifier: "DateFromNumber"
}) {}
/**
* Describes a schema that represents a `DateTime.Utc` instance.
*
* @category DateTime.Utc constructors
* @since 3.10.0
*/
exports.DateFromNumber = DateFromNumber;
class DateTimeUtcFromSelf extends /*#__PURE__*/declare(u => dateTime.isDateTime(u) && dateTime.isUtc(u), {
identifier: "DateTimeUtcFromSelf",
description: "a DateTime.Utc instance",
pretty: () => dateTime => dateTime.toString(),
arbitrary: () => fc => fc.date({
noInvalidDate: true
}).map(date => dateTime.unsafeFromDate(date)),
equivalence: () => dateTime.Equivalence
}) {}
exports.DateTimeUtcFromSelf = DateTimeUtcFromSelf;
const decodeDateTimeUtc = (input, ast) => ParseResult.try({
try: () => dateTime.unsafeMake(input),
catch: () => new ParseResult.Type(ast, input, `Unable to decode ${util_.formatUnknown(input)} into a DateTime.Utc`)
});
/**
* Defines a schema that attempts to convert a `number` to a `DateTime.Utc` instance using the `DateTime.unsafeMake` constructor.
*
* @category DateTime.Utc transformations
* @since 3.10.0
*/
class DateTimeUtcFromNumber extends /*#__PURE__*/transformOrFail(Number$.annotations({
description: "a number to be decoded into a DateTime.Utc"
}), DateTimeUtcFromSelf, {
strict: true,
decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
encode: a => ParseResult.succeed(dateTime.toEpochMillis(a))
}).annotations({
identifier: "DateTimeUtcFromNumber"
}) {}
/**
* Defines a schema that attempts to convert a `Date` to a `DateTime.Utc` instance using the `DateTime.unsafeMake` constructor.
*
* @category DateTime.Utc transformations
* @since 3.12.0
*/
exports.DateTimeUtcFromNumber = DateTimeUtcFromNumber;
class DateTimeUtcFromDate extends /*#__PURE__*/transformOrFail(DateFromSelf.annotations({
description: "a Date to be decoded into a DateTime.Utc"
}), DateTimeUtcFromSelf, {
strict: true,
decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
encode: a => ParseResult.succeed(dateTime.toDateUtc(a))
}).annotations({
identifier: "DateTimeUtcFromDate"
}) {}
/**
* Defines a schema that attempts to convert a `string` to a `DateTime.Utc` instance using the `DateTime.unsafeMake` constructor.
*
* @category DateTime.Utc transformations
* @since 3.10.0
*/
exports.DateTimeUtcFromDate = DateTimeUtcFromDate;
class DateTimeUtc extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a DateTime.Utc"
}), DateTimeUtcFromSelf, {
strict: true,
decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
encode: a => ParseResult.succeed(dateTime.formatIso(a))
}).annotations({
identifier: "DateTimeUtc"
}) {}
exports.DateTimeUtc = DateTimeUtc;
const timeZoneOffsetArbitrary = () => fc => fc.integer({
min: -12 * 60 * 60 * 1000,
max: 14 * 60 * 60 * 1000
}).map(dateTime.zoneMakeOffset);
/**
* Describes a schema that represents a `TimeZone.Offset` instance.
*
* @category TimeZone constructors
* @since 3.10.0
*/
class TimeZoneOffsetFromSelf extends /*#__PURE__*/declare(dateTime.isTimeZoneOffset, {
identifier: "TimeZoneOffsetFromSelf",
description: "a TimeZone.Offset instance",
pretty: () => zone => zone.toString(),
arbitrary: timeZoneOffsetArbitrary
}) {}
/**
* Defines a schema that converts a `number` to a `TimeZone.Offset` instance using the `DateTime.zoneMakeOffset` constructor.
*
* @category TimeZone transformations
* @since 3.10.0
*/
exports.TimeZoneOffsetFromSelf = TimeZoneOffsetFromSelf;
class TimeZoneOffset extends /*#__PURE__*/transform(Number$.annotations({
description: "a number to be decoded into a TimeZone.Offset"
}), TimeZoneOffsetFromSelf, {
strict: true,
decode: i => dateTime.zoneMakeOffset(i),
encode: a => a.offset
}).annotations({
identifier: "TimeZoneOffset"
}) {}
exports.TimeZoneOffset = TimeZoneOffset;
const timeZoneNamedArbitrary = () => fc => fc.constantFrom(...Intl.supportedValuesOf("timeZone")).map(dateTime.zoneUnsafeMakeNamed);
/**
* Describes a schema that represents a `TimeZone.Named` instance.
*
* @category TimeZone constructors
* @since 3.10.0
*/
class TimeZoneNamedFromSelf extends /*#__PURE__*/declare(dateTime.isTimeZoneNamed, {
identifier: "TimeZoneNamedFromSelf",
description: "a TimeZone.Named instance",
pretty: () => zone => zone.toString(),
arbitrary: timeZoneNamedArbitrary
}) {}
/**
* Defines a schema that attempts to convert a `string` to a `TimeZone.Named` instance using the `DateTime.zoneUnsafeMakeNamed` constructor.
*
* @category TimeZone transformations
* @since 3.10.0
*/
exports.TimeZoneNamedFromSelf = TimeZoneNamedFromSelf;
class TimeZoneNamed extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a TimeZone.Named"
}), TimeZoneNamedFromSelf, {
strict: true,
decode: (i, _, ast) => ParseResult.try({
try: () => dateTime.zoneUnsafeMakeNamed(i),
catch: () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a TimeZone.Named`)
}),
encode: a => ParseResult.succeed(a.id)
}).annotations({
identifier: "TimeZoneNamed"
}) {}
/**
* @category TimeZone constructors
* @since 3.10.0
*/
exports.TimeZoneNamed = TimeZoneNamed;
class TimeZoneFromSelf extends /*#__PURE__*/Union(TimeZoneOffsetFromSelf, TimeZoneNamedFromSelf) {}
/**
* Defines a schema that attempts to convert a `string` to a `TimeZone` using the `DateTime.zoneFromString` constructor.
*
* @category TimeZone transformations
* @since 3.10.0
*/
exports.TimeZoneFromSelf = TimeZoneFromSelf;
class TimeZone extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a TimeZone"
}), TimeZoneFromSelf, {
strict: true,
decode: (i, _, ast) => option_.match(dateTime.zoneFromString(i), {
onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a TimeZone`)),
onSome: ParseResult.succeed
}),
encode: a => ParseResult.succeed(dateTime.zoneToString(a))
}).annotations({
identifier: "TimeZone"
}) {}
exports.TimeZone = TimeZone;
const timeZoneArbitrary = fc => fc.oneof(timeZoneOffsetArbitrary()(fc), timeZoneNamedArbitrary()(fc));
/**
* Describes a schema that represents a `DateTime.Zoned` instance.
*
* @category DateTime.Zoned constructors
* @since 3.10.0
*/
class DateTimeZonedFromSelf extends /*#__PURE__*/declare(u => dateTime.isDateTime(u) && dateTime.isZoned(u), {
identifier: "DateTimeZonedFromSelf",
description: "a DateTime.Zoned instance",
pretty: () => dateTime => dateTime.toString(),
arbitrary: () => fc => fc.tuple(fc.integer({
// time zone db supports +/- 1000 years or so
min: -31536000000000,
max: 31536000000000
}), timeZoneArbitrary(fc)).map(([millis, timeZone]) => dateTime.unsafeMakeZoned(millis, {
timeZone
})),
equivalence: () => dateTime.Equivalence
}) {}
/**
* Defines a schema that attempts to convert a `string` to a `DateTime.Zoned` instance.
*
* @category DateTime.Zoned transformations
* @since 3.10.0
*/
exports.DateTimeZonedFromSelf = DateTimeZonedFromSelf;
class DateTimeZoned extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a DateTime.Zoned"
}), DateTimeZonedFromSelf, {
strict: true,
decode: (i, _, ast) => option_.match(dateTime.makeZonedFromString(i), {
onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a DateTime.Zoned`)),
onSome: ParseResult.succeed
}),
encode: a => ParseResult.succeed(dateTime.formatIsoZoned(a))
}).annotations({
identifier: "DateTimeZoned"
}) {}
exports.DateTimeZoned = DateTimeZoned;
const OptionNoneEncoded = /*#__PURE__*/Struct({
_tag: Literal("None")
}).annotations({
description: "NoneEncoded"
});
const optionSomeEncoded = value => Struct({
_tag: Literal("Some"),
value
}).annotations({
description: `SomeEncoded<${format(value)}>`
});
const optionEncoded = value => Union(OptionNoneEncoded, optionSomeEncoded(value)).annotations({
description: `OptionEncoded<${format(value)}>`
});
const optionDecode = input => input._tag === "None" ? option_.none() : option_.some(input.value);
const optionArbitrary = (value, ctx) => fc => fc.oneof(ctx, fc.record({
_tag: fc.constant("None")
}), fc.record({
_tag: fc.constant("Some"),
value: value(fc)
})).map(optionDecode);
const optionPretty = value => option_.match({
onNone: () => "none()",
onSome: a => `some(${value(a)})`
});
const optionParse = decodeUnknown => (u, options, ast) => option_.isOption(u) ? option_.isNone(u) ? ParseResult.succeed(option_.none()) : toComposite(decodeUnknown(u.value, options), option_.some, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Option transformations
* @since 3.10.0
*/
const OptionFromSelf = value => {
return declare([value], {
decode: value => optionParse(ParseResult.decodeUnknown(value)),
encode: value => optionParse(ParseResult.encodeUnknown(value))
}, {
description: `Option<${format(value)}>`,
pretty: optionPretty,
arbitrary: optionArbitrary,
equivalence: option_.getEquivalence
});
};
exports.OptionFromSelf = OptionFromSelf;
const makeNoneEncoded = {
_tag: "None"
};
const makeSomeEncoded = value => ({
_tag: "Some",
value
});
/**
* @category Option transformations
* @since 3.10.0
*/
function Option(value) {
const value_ = asSchema(value);
const out = transform(optionEncoded(value_), OptionFromSelf(typeSchema(value_)), {
strict: true,
decode: i => optionDecode(i),
encode: a => option_.match(a, {
onNone: () => makeNoneEncoded,
onSome: makeSomeEncoded
})
});
return out;
}
/**
* @category Option transformations
* @since 3.10.0
*/
function OptionFromNullOr(value) {
return transform(NullOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => option_.fromNullable(i),
encode: a => option_.getOrNull(a)
});
}
/**
* @category Option transformations
* @since 3.10.0
*/
function OptionFromNullishOr(value, onNoneEncoding) {
return transform(NullishOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => option_.fromNullable(i),
encode: onNoneEncoding === null ? a => option_.getOrNull(a) : a => option_.getOrUndefined(a)
});
}
/**
* @category Option transformations
* @since 3.10.0
*/
function OptionFromUndefinedOr(value) {
return transform(UndefinedOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => option_.fromNullable(i),
encode: a => option_.getOrUndefined(a)
});
}
/**
* Transforms strings into an Option type, effectively filtering out empty or
* whitespace-only strings by trimming them and checking their length. Returns
* `none` for invalid inputs and `some` for valid non-empty strings.
*
* @example
* ```ts
* import { Schema } from "effect"
*
* console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("")) // Option.none()
* console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)(" a ")) // Option.some("a")
* console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("a")) // Option.some("a")
* ```
*
* @category Option transformations
* @since 3.10.0
*/
class OptionFromNonEmptyTrimmedString extends /*#__PURE__*/transform(String$, /*#__PURE__*/OptionFromSelf(NonEmptyTrimmedString), {
strict: true,
decode: i => option_.filter(option_.some(i.trim()), string_.isNonEmpty),
encode: a => option_.getOrElse(a, () => "")
}) {}
exports.OptionFromNonEmptyTrimmedString = OptionFromNonEmptyTrimmedString;
const rightEncoded = right => Struct({
_tag: Literal("Right"),
right
}).annotations({
description: `RightEncoded<${format(right)}>`
});
const leftEncoded = left => Struct({
_tag: Literal("Left"),
left
}).annotations({
description: `LeftEncoded<${format(left)}>`
});
const eitherEncoded = (right, left) => Union(rightEncoded(right), leftEncoded(left)).annotations({
description: `EitherEncoded<${format(left)}, ${format(right)}>`
});
const eitherDecode = input => input._tag === "Left" ? either_.left(input.left) : either_.right(input.right);
const eitherArbitrary = (right, left) => fc => fc.oneof(fc.record({
_tag: fc.constant("Left"),
left: left(fc)
}), fc.record({
_tag: fc.constant("Right"),
right: right(fc)
})).map(eitherDecode);
const eitherPretty = (right, left) => either_.match({
onLeft: e => `left(${left(e)})`,
onRight: a => `right(${right(a)})`
});
const eitherParse = (parseRight, decodeUnknownLeft) => (u, options, ast) => either_.isEither(u) ? either_.match(u, {
onLeft: left => toComposite(decodeUnknownLeft(left, options), either_.left, ast, u),
onRight: right => toComposite(parseRight(right, options), either_.right, ast, u)
}) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Either transformations
* @since 3.10.0
*/
const EitherFromSelf = ({
left,
right
}) => {
return declare([right, left], {
decode: (right, left) => eitherParse(ParseResult.decodeUnknown(right), ParseResult.decodeUnknown(left)),
encode: (right, left) => eitherParse(ParseResult.encodeUnknown(right), ParseResult.encodeUnknown(left))
}, {
description: `Either<${format(right)}, ${format(left)}>`,
pretty: eitherPretty,
arbitrary: eitherArbitrary,
equivalence: (right, left) => either_.getEquivalence({
left,
right
})
});
};
exports.EitherFromSelf = EitherFromSelf;
const makeLeftEncoded = left => ({
_tag: "Left",
left
});
const makeRightEncoded = right => ({
_tag: "Right",
right
});
/**
* @category Either transformations
* @since 3.10.0
*/
const Either = ({
left,
right
}) => {
const right_ = asSchema(right);
const left_ = asSchema(left);
const out = transform(eitherEncoded(right_, left_), EitherFromSelf({
left: typeSchema(left_),
right: typeSchema(right_)
}), {
strict: true,
decode: i => eitherDecode(i),
encode: a => either_.match(a, {
onLeft: makeLeftEncoded,
onRight: makeRightEncoded
})
});
return out;
};
/**
* @example
* ```ts
* import * as Schema from "effect/Schema"
*
* // Schema<string | number, Either<string, number>>
* Schema.EitherFromUnion({ left: Schema.String, right: Schema.Number })
* ```
*
* @category Either transformations
* @since 3.10.0
*/
exports.Either = Either;
const EitherFromUnion = ({
left,
right
}) => {
const right_ = asSchema(right);
const left_ = asSchema(left);
const toright = typeSchema(right_);
const toleft = typeSchema(left_);
const fromRight = transform(right_, rightEncoded(toright), {
strict: true,
decode: i => makeRightEncoded(i),
encode: a => a.right
});
const fromLeft = transform(left_, leftEncoded(toleft), {
strict: true,
decode: i => makeLeftEncoded(i),
encode: a => a.left
});
const out = transform(Union(fromRight, fromLeft), EitherFromSelf({
left: toleft,
right: toright
}), {
strict: true,
decode: i => i._tag === "Left" ? either_.left(i.left) : either_.right(i.right),
encode: a => either_.match(a, {
onLeft: makeLeftEncoded,
onRight: makeRightEncoded
})
});
return out;
};
exports.EitherFromUnion = EitherFromUnion;
const mapArbitrary = (key, value, ctx) => {
return fc => {
const items = fc.array(fc.tuple(key(fc), value(fc)));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(as => new Map(as));
};
};
const readonlyMapPretty = (key, value) => map => `new Map([${Array.from(map.entries()).map(([k, v]) => `[${key(k)}, ${value(v)}]`).join(", ")}])`;
const readonlyMapEquivalence = (key, value) => {
const arrayEquivalence = array_.getEquivalence(Equivalence.make(([ka, va], [kb, vb]) => key(ka, kb) && value(va, vb)));
return Equivalence.make((a, b) => arrayEquivalence(Array.from(a.entries()), Array.from(b.entries())));
};
const readonlyMapParse = decodeUnknown => (u, options, ast) => Predicate.isMap(u) ? toComposite(decodeUnknown(Array.from(u.entries()), options), as => new Map(as), ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
const mapFromSelf_ = (key, value, description) => declare([key, value], {
decode: (Key, Value) => readonlyMapParse(ParseResult.decodeUnknown(Array$(Tuple(Key, Value)))),
encode: (Key, Value) => readonlyMapParse(ParseResult.encodeUnknown(Array$(Tuple(Key, Value))))
}, {
description,
pretty: readonlyMapPretty,
arbitrary: mapArbitrary,
equivalence: readonlyMapEquivalence
});
/**
* @category ReadonlyMap
* @since 3.10.0
*/
const ReadonlyMapFromSelf = ({
key,
value
}) => mapFromSelf_(key, value, `ReadonlyMap<${format(key)}, ${format(value)}>`);
/**
* @category Map
* @since 3.10.0
*/
exports.ReadonlyMapFromSelf = ReadonlyMapFromSelf;
const MapFromSelf = ({
key,
value
}) => mapFromSelf_(key, value, `Map<${format(key)}, ${format(value)}>`);
/**
* @category ReadonlyMap transformations
* @since 3.10.0
*/
exports.MapFromSelf = MapFromSelf;
function ReadonlyMap({
key,
value
}) {
return transform(Array$(Tuple(key, value)), ReadonlyMapFromSelf({
key: typeSchema(asSchema(key)),
value: typeSchema(asSchema(value))
}), {
strict: true,
decode: i => new Map(i),
encode: a => Array.from(a.entries())
});
}
/** @ignore */
function map({
key,
value
}) {
return transform(Array$(Tuple(key, value)), MapFromSelf({
key: typeSchema(asSchema(key)),
value: typeSchema(asSchema(value))
}), {
strict: true,
decode: i => new Map(i),
encode: a => Array.from(a.entries())
});
}
/**
* @category ReadonlyMap transformations
* @since 3.10.0
*/
const ReadonlyMapFromRecord = ({
key,
value
}) => transform(Record({
key: encodedBoundSchema(key),
value
}).annotations({
description: "a record to be decoded into a ReadonlyMap"
}), ReadonlyMapFromSelf({
key,
value: typeSchema(value)
}), {
strict: true,
decode: i => new Map(Object.entries(i)),
encode: a => Object.fromEntries(a)
});
/**
* @category Map transformations
* @since 3.10.0
*/
exports.ReadonlyMapFromRecord = ReadonlyMapFromRecord;
const MapFromRecord = ({
key,
value
}) => transform(Record({
key: encodedBoundSchema(key),
value
}).annotations({
description: "a record to be decoded into a Map"
}), MapFromSelf({
key,
value: typeSchema(value)
}), {
strict: true,
decode: i => new Map(Object.entries(i)),
encode: a => Object.fromEntries(a)
});
exports.MapFromRecord = MapFromRecord;
const setArbitrary = (item, ctx) => fc => {
const items = fc.array(item(fc));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(as => new Set(as));
};
const readonlySetPretty = item => set => `new Set([${Array.from(set.values()).map(a => item(a)).join(", ")}])`;
const readonlySetEquivalence = item => {
const arrayEquivalence = array_.getEquivalence(item);
return Equivalence.make((a, b) => arrayEquivalence(Array.from(a.values()), Array.from(b.values())));
};
const readonlySetParse = decodeUnknown => (u, options, ast) => Predicate.isSet(u) ? toComposite(decodeUnknown(Array.from(u.values()), options), as => new Set(as), ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
const setFromSelf_ = (value, description) => declare([value], {
decode: item => readonlySetParse(ParseResult.decodeUnknown(Array$(item))),
encode: item => readonlySetParse(ParseResult.encodeUnknown(Array$(item)))
}, {
description,
pretty: readonlySetPretty,
arbitrary: setArbitrary,
equivalence: readonlySetEquivalence
});
/**
* @category ReadonlySet
* @since 3.10.0
*/
const ReadonlySetFromSelf = value => setFromSelf_(value, `ReadonlySet<${format(value)}>`);
/**
* @category Set
* @since 3.10.0
*/
exports.ReadonlySetFromSelf = ReadonlySetFromSelf;
const SetFromSelf = value => setFromSelf_(value, `Set<${format(value)}>`);
/**
* @category ReadonlySet transformations
* @since 3.10.0
*/
exports.SetFromSelf = SetFromSelf;
function ReadonlySet(value) {
return transform(Array$(value), ReadonlySetFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => new Set(i),
encode: a => Array.from(a)
});
}
/** @ignore */
function set(value) {
return transform(Array$(value), SetFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => new Set(i),
encode: a => Array.from(a)
});
}
const bigDecimalPretty = () => val => `BigDecimal(${bigDecimal_.format(bigDecimal_.normalize(val))})`;
const bigDecimalArbitrary = () => fc => fc.tuple(fc.bigInt(), fc.integer({
min: 0,
max: 18
})).map(([value, scale]) => bigDecimal_.make(value, scale));
/**
* @category BigDecimal constructors
* @since 3.10.0
*/
class BigDecimalFromSelf extends /*#__PURE__*/declare(bigDecimal_.isBigDecimal, {
identifier: "BigDecimalFromSelf",
pretty: bigDecimalPretty,
arbitrary: bigDecimalArbitrary,
equivalence: () => bigDecimal_.Equivalence
}) {}
/**
* @category BigDecimal transformations
* @since 3.10.0
*/
exports.BigDecimalFromSelf = BigDecimalFromSelf;
class BigDecimal extends /*#__PURE__*/transformOrFail(String$.annotations({
description: "a string to be decoded into a BigDecimal"
}), BigDecimalFromSelf, {
strict: true,
decode: (i, _, ast) => bigDecimal_.fromString(i).pipe(option_.match({
onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a BigDecimal`)),
onSome: val => ParseResult.succeed(bigDecimal_.normalize(val))
})),
encode: a => ParseResult.succeed(bigDecimal_.format(bigDecimal_.normalize(a)))
}).annotations({
identifier: "BigDecimal"
}) {}
/**
* A schema that transforms a `number` into a `BigDecimal`.
* When encoding, this Schema will produce incorrect results if the BigDecimal exceeds the 64-bit range of a number.
*
* @category BigDecimal transformations
* @since 3.10.0
*/
exports.BigDecimal = BigDecimal;
class BigDecimalFromNumber extends /*#__PURE__*/transform(Number$.annotations({
description: "a number to be decoded into a BigDecimal"
}), BigDecimalFromSelf, {
strict: true,
decode: i => bigDecimal_.unsafeFromNumber(i),
encode: a => bigDecimal_.unsafeToNumber(a)
}).annotations({
identifier: "BigDecimalFromNumber"
}) {}
/**
* @category schema id
* @since 3.10.0
*/
exports.BigDecimalFromNumber = BigDecimalFromNumber;
const GreaterThanBigDecimalSchemaId = exports.GreaterThanBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/GreaterThanBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const greaterThanBigDecimal = (min, annotations) => self => {
const formatted = bigDecimal_.format(min);
return self.pipe(filter(a => bigDecimal_.greaterThan(a, min), {
schemaId: GreaterThanBigDecimalSchemaId,
[GreaterThanBigDecimalSchemaId]: {
min
},
title: `greaterThanBigDecimal(${formatted})`,
description: `a BigDecimal greater than ${formatted}`,
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanBigDecimal = greaterThanBigDecimal;
const GreaterThanOrEqualToBigDecimalSchemaId = exports.GreaterThanOrEqualToBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/schema/GreaterThanOrEqualToBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const greaterThanOrEqualToBigDecimal = (min, annotations) => self => {
const formatted = bigDecimal_.format(min);
return self.pipe(filter(a => bigDecimal_.greaterThanOrEqualTo(a, min), {
schemaId: GreaterThanOrEqualToBigDecimalSchemaId,
[GreaterThanOrEqualToBigDecimalSchemaId]: {
min
},
title: `greaterThanOrEqualToBigDecimal(${formatted})`,
description: `a BigDecimal greater than or equal to ${formatted}`,
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.greaterThanOrEqualToBigDecimal = greaterThanOrEqualToBigDecimal;
const LessThanBigDecimalSchemaId = exports.LessThanBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/LessThanBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const lessThanBigDecimal = (max, annotations) => self => {
const formatted = bigDecimal_.format(max);
return self.pipe(filter(a => bigDecimal_.lessThan(a, max), {
schemaId: LessThanBigDecimalSchemaId,
[LessThanBigDecimalSchemaId]: {
max
},
title: `lessThanBigDecimal(${formatted})`,
description: `a BigDecimal less than ${formatted}`,
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanBigDecimal = lessThanBigDecimal;
const LessThanOrEqualToBigDecimalSchemaId = exports.LessThanOrEqualToBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/schema/LessThanOrEqualToBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const lessThanOrEqualToBigDecimal = (max, annotations) => self => {
const formatted = bigDecimal_.format(max);
return self.pipe(filter(a => bigDecimal_.lessThanOrEqualTo(a, max), {
schemaId: LessThanOrEqualToBigDecimalSchemaId,
[LessThanOrEqualToBigDecimalSchemaId]: {
max
},
title: `lessThanOrEqualToBigDecimal(${formatted})`,
description: `a BigDecimal less than or equal to ${formatted}`,
...annotations
}));
};
/**
* @category schema id
* @since 3.10.0
*/
exports.lessThanOrEqualToBigDecimal = lessThanOrEqualToBigDecimal;
const PositiveBigDecimalSchemaId = exports.PositiveBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/schema/PositiveBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const positiveBigDecimal = annotations => self => self.pipe(filter(a => bigDecimal_.isPositive(a), {
schemaId: PositiveBigDecimalSchemaId,
title: "positiveBigDecimal",
description: `a positive BigDecimal`,
...annotations
}));
/**
* @category BigDecimal constructors
* @since 3.10.0
*/
exports.positiveBigDecimal = positiveBigDecimal;
const PositiveBigDecimalFromSelf = exports.PositiveBigDecimalFromSelf = /*#__PURE__*/BigDecimalFromSelf.pipe(/*#__PURE__*/positiveBigDecimal({
identifier: "PositiveBigDecimalFromSelf"
}));
/**
* @category schema id
* @since 3.10.0
*/
const NonNegativeBigDecimalSchemaId = exports.NonNegativeBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/schema/NonNegativeBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const nonNegativeBigDecimal = annotations => self => self.pipe(filter(a => a.value >= 0n, {
schemaId: NonNegativeBigDecimalSchemaId,
title: "nonNegativeBigDecimal",
description: `a non-negative BigDecimal`,
...annotations
}));
/**
* @category BigDecimal constructors
* @since 3.10.0
*/
exports.nonNegativeBigDecimal = nonNegativeBigDecimal;
const NonNegativeBigDecimalFromSelf = exports.NonNegativeBigDecimalFromSelf = /*#__PURE__*/BigDecimalFromSelf.pipe(/*#__PURE__*/nonNegativeBigDecimal({
identifier: "NonNegativeBigDecimalFromSelf"
}));
/**
* @category schema id
* @since 3.10.0
*/
const NegativeBigDecimalSchemaId = exports.NegativeBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/schema/NegativeBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const negativeBigDecimal = annotations => self => self.pipe(filter(a => bigDecimal_.isNegative(a), {
schemaId: NegativeBigDecimalSchemaId,
title: "negativeBigDecimal",
description: `a negative BigDecimal`,
...annotations
}));
/**
* @category BigDecimal constructors
* @since 3.10.0
*/
exports.negativeBigDecimal = negativeBigDecimal;
const NegativeBigDecimalFromSelf = exports.NegativeBigDecimalFromSelf = /*#__PURE__*/BigDecimalFromSelf.pipe(/*#__PURE__*/negativeBigDecimal({
identifier: "NegativeBigDecimalFromSelf"
}));
/**
* @category schema id
* @since 3.10.0
*/
const NonPositiveBigDecimalSchemaId = exports.NonPositiveBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/schema/NonPositiveBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const nonPositiveBigDecimal = annotations => self => self.pipe(filter(a => a.value <= 0n, {
schemaId: NonPositiveBigDecimalSchemaId,
title: "nonPositiveBigDecimal",
description: `a non-positive BigDecimal`,
...annotations
}));
/**
* @category BigDecimal constructors
* @since 3.10.0
*/
exports.nonPositiveBigDecimal = nonPositiveBigDecimal;
const NonPositiveBigDecimalFromSelf = exports.NonPositiveBigDecimalFromSelf = /*#__PURE__*/BigDecimalFromSelf.pipe(/*#__PURE__*/nonPositiveBigDecimal({
identifier: "NonPositiveBigDecimalFromSelf"
}));
/**
* @category schema id
* @since 3.10.0
*/
const BetweenBigDecimalSchemaId = exports.BetweenBigDecimalSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/BetweenBigDecimal");
/**
* @category BigDecimal filters
* @since 3.10.0
*/
const betweenBigDecimal = (minimum, maximum, annotations) => self => {
const formattedMinimum = bigDecimal_.format(minimum);
const formattedMaximum = bigDecimal_.format(maximum);
return self.pipe(filter(a => bigDecimal_.between(a, {
minimum,
maximum
}), {
schemaId: BetweenBigDecimalSchemaId,
[BetweenBigDecimalSchemaId]: {
maximum,
minimum
},
title: `betweenBigDecimal(${formattedMinimum}, ${formattedMaximum})`,
description: `a BigDecimal between ${formattedMinimum} and ${formattedMaximum}`,
...annotations
}));
};
/**
* Clamps a `BigDecimal` between a minimum and a maximum value.
*
* @category BigDecimal transformations
* @since 3.10.0
*/
exports.betweenBigDecimal = betweenBigDecimal;
const clampBigDecimal = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, betweenBigDecimal(minimum, maximum)), {
strict: false,
decode: i => bigDecimal_.clamp(i, {
minimum,
maximum
}),
encode: _Function.identity
});
exports.clampBigDecimal = clampBigDecimal;
const chunkArbitrary = (item, ctx) => fc => {
const items = fc.array(item(fc));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(chunk_.fromIterable);
};
const chunkPretty = item => c => `Chunk(${chunk_.toReadonlyArray(c).map(item).join(", ")})`;
const chunkParse = decodeUnknown => (u, options, ast) => chunk_.isChunk(u) ? chunk_.isEmpty(u) ? ParseResult.succeed(chunk_.empty()) : toComposite(decodeUnknown(chunk_.toReadonlyArray(u), options), chunk_.fromIterable, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Chunk
* @since 3.10.0
*/
const ChunkFromSelf = value => {
return declare([value], {
decode: item => chunkParse(ParseResult.decodeUnknown(Array$(item))),
encode: item => chunkParse(ParseResult.encodeUnknown(Array$(item)))
}, {
description: `Chunk<${format(value)}>`,
pretty: chunkPretty,
arbitrary: chunkArbitrary,
equivalence: chunk_.getEquivalence
});
};
/**
* @category Chunk transformations
* @since 3.10.0
*/
exports.ChunkFromSelf = ChunkFromSelf;
function Chunk(value) {
return transform(Array$(value), ChunkFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => i.length === 0 ? chunk_.empty() : chunk_.fromIterable(i),
encode: a => chunk_.toReadonlyArray(a)
});
}
const nonEmptyChunkArbitrary = item => fc => fastCheck_.array(item(fc), {
minLength: 1
}).map(as => chunk_.unsafeFromNonEmptyArray(as));
const nonEmptyChunkPretty = item => c => `NonEmptyChunk(${chunk_.toReadonlyArray(c).map(item).join(", ")})`;
const nonEmptyChunkParse = decodeUnknown => (u, options, ast) => chunk_.isChunk(u) && chunk_.isNonEmpty(u) ? toComposite(decodeUnknown(chunk_.toReadonlyArray(u), options), chunk_.unsafeFromNonEmptyArray, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Chunk
* @since 3.10.0
*/
const NonEmptyChunkFromSelf = value => {
return declare([value], {
decode: item => nonEmptyChunkParse(ParseResult.decodeUnknown(NonEmptyArray(item))),
encode: item => nonEmptyChunkParse(ParseResult.encodeUnknown(NonEmptyArray(item)))
}, {
description: `NonEmptyChunk<${format(value)}>`,
pretty: nonEmptyChunkPretty,
arbitrary: nonEmptyChunkArbitrary,
equivalence: chunk_.getEquivalence
});
};
/**
* @category Chunk transformations
* @since 3.10.0
*/
exports.NonEmptyChunkFromSelf = NonEmptyChunkFromSelf;
function NonEmptyChunk(value) {
return transform(NonEmptyArray(value), NonEmptyChunkFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => chunk_.unsafeFromNonEmptyArray(i),
encode: a => chunk_.toReadonlyArray(a)
});
}
const decodeData = a => Array.isArray(a) ? data_.array(a) : data_.struct(a);
const dataArbitrary = item => fc => item(fc).map(decodeData);
const dataPretty = item => d => `Data(${item(d)})`;
const dataParse = decodeUnknown => (u, options, ast) => Equal.isEqual(u) ? toComposite(decodeUnknown(u, options), decodeData, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* Type and Encoded must extend `Readonly<Record<string, any>> |
* ReadonlyArray<any>` to be compatible with this API.
*
* @category Data transformations
* @since 3.10.0
*/
const DataFromSelf = value => {
return declare([value], {
decode: item => dataParse(ParseResult.decodeUnknown(item)),
encode: item => dataParse(ParseResult.encodeUnknown(item))
}, {
description: `Data<${format(value)}>`,
pretty: dataPretty,
arbitrary: dataArbitrary
});
};
/**
* Type and Encoded must extend `Readonly<Record<string, any>> |
* ReadonlyArray<any>` to be compatible with this API.
*
* @category Data transformations
* @since 3.10.0
*/
exports.DataFromSelf = DataFromSelf;
const Data = value => {
return transform(value, DataFromSelf(typeSchema(value)), {
strict: false,
decode: i => decodeData(i),
encode: a => Array.isArray(a) ? Array.from(a) : Object.assign({}, a)
});
};
exports.Data = Data;
const isField = u => isSchema(u) || isPropertySignature(u);
const isFields = fields => util_.ownKeys(fields).every(key => isField(fields[key]));
const getFields = hasFields => "fields" in hasFields ? hasFields.fields : getFields(hasFields[RefineSchemaId]);
const getSchemaFromFieldsOr = fieldsOr => isFields(fieldsOr) ? Struct(fieldsOr) : isSchema(fieldsOr) ? fieldsOr : Struct(getFields(fieldsOr));
const getFieldsFromFieldsOr = fieldsOr => isFields(fieldsOr) ? fieldsOr : getFields(fieldsOr);
/**
* @example
* ```ts
* import { Schema } from "effect"
*
* class MyClass extends Schema.Class<MyClass>("MyClass")({
* someField: Schema.String
* }) {
* someMethod() {
* return this.someField + "bar"
* }
* }
* ```
*
* @category classes
* @since 3.10.0
*/
const Class = identifier => (fieldsOr, annotations) => makeClass({
kind: "Class",
identifier,
schema: getSchemaFromFieldsOr(fieldsOr),
fields: getFieldsFromFieldsOr(fieldsOr),
Base: data_.Class,
annotations
});
/** @internal */
exports.Class = Class;
const getClassTag = tag => withConstructorDefault(propertySignature(Literal(tag)), () => tag);
/**
* @example
* ```ts
* import { Schema } from "effect"
*
* class MyClass extends Schema.TaggedClass<MyClass>("MyClass")("MyClass", {
* a: Schema.String
* }) {}
* ```
*
* @category classes
* @since 3.10.0
*/
exports.getClassTag = getClassTag;
const TaggedClass = identifier => (tag, fieldsOr, annotations) => {
const fields = getFieldsFromFieldsOr(fieldsOr);
const schema = getSchemaFromFieldsOr(fieldsOr);
const newFields = {
_tag: getClassTag(tag)
};
const taggedFields = extendFields(newFields, fields);
return class TaggedClass extends makeClass({
kind: "TaggedClass",
identifier: identifier ?? tag,
schema: extend(schema, Struct(newFields)),
fields: taggedFields,
Base: data_.Class,
annotations
}) {
static _tag = tag;
};
};
/**
* @example
* ```ts
* import { Schema } from "effect"
*
* class MyError extends Schema.TaggedError<MyError>("MyError")(
* "MyError",
* {
* module: Schema.String,
* method: Schema.String,
* description: Schema.String
* }
* ) {
* get message(): string {
* return `${this.module}.${this.method}: ${this.description}`
* }
* }
* ```
* @category classes
* @since 3.10.0
*/
exports.TaggedClass = TaggedClass;
const TaggedError = identifier => (tag, fieldsOr, annotations) => {
class Base extends data_.Error {}
;
Base.prototype.name = tag;
const fields = getFieldsFromFieldsOr(fieldsOr);
const schema = getSchemaFromFieldsOr(fieldsOr);
const newFields = {
_tag: getClassTag(tag)
};
const taggedFields = extendFields(newFields, fields);
const hasMessageField = "message" in taggedFields;
class TaggedErrorClass extends makeClass({
kind: "TaggedError",
identifier: identifier ?? tag,
schema: extend(schema, Struct(newFields)),
fields: taggedFields,
Base,
annotations,
disableToString: true
}) {
static _tag = tag;
}
if (!hasMessageField) {
Object.defineProperty(TaggedErrorClass.prototype, "message", {
get() {
return `{ ${util_.ownKeys(fields).map(p => `${util_.formatPropertyKey(p)}: ${util_.formatUnknown(this[p])}`).join(", ")} }`;
},
enumerable: false,
// mirrors the built-in Error.prototype.message, whose descriptor is also non-enumerable
configurable: true
});
}
return TaggedErrorClass;
};
exports.TaggedError = TaggedError;
const extendFields = (a, b) => {
const out = {
...a
};
for (const key of util_.ownKeys(b)) {
if (key in a) {
throw new Error(errors_.getASTDuplicatePropertySignatureErrorMessage(key));
}
out[key] = b[key];
}
return out;
};
function getDisableValidationMakeOption(options) {
return Predicate.isBoolean(options) ? options : options?.disableValidation ?? false;
}
const astCache = /*#__PURE__*/(0, _GlobalValue.globalValue)("effect/Schema/astCache", () => new WeakMap());
const getClassAnnotations = annotations => {
if (annotations === undefined) {
return [];
} else if (Array.isArray(annotations)) {
return annotations;
} else {
return [annotations];
}
};
const makeClass = ({
Base,
annotations,
disableToString,
fields,
identifier,
kind,
schema
}) => {
const classSymbol = Symbol.for(`effect/Schema/${kind}/${identifier}`);
const [typeAnnotations, transformationAnnotations, encodedAnnotations] = getClassAnnotations(annotations);
const typeSchema_ = typeSchema(schema);
const declarationSurrogate = typeSchema_.annotations({
identifier,
...typeAnnotations
});
const typeSide = typeSchema_.annotations({
[AST.AutoTitleAnnotationId]: `${identifier} (Type side)`,
...typeAnnotations
});
const constructorSchema = schema.annotations({
[AST.AutoTitleAnnotationId]: `${identifier} (Constructor)`,
...typeAnnotations
});
const encodedSide = schema.annotations({
[AST.AutoTitleAnnotationId]: `${identifier} (Encoded side)`,
...encodedAnnotations
});
const transformationSurrogate = schema.annotations({
[AST.JSONIdentifierAnnotationId]: identifier,
...encodedAnnotations,
...typeAnnotations,
...transformationAnnotations
});
const fallbackInstanceOf = u => Predicate.hasProperty(u, classSymbol) && ParseResult.is(typeSide)(u);
const klass = class extends Base {
constructor(props = {}, options = false) {
props = {
...props
};
if (kind !== "Class") {
delete props["_tag"];
}
props = lazilyMergeDefaults(fields, props);
if (!getDisableValidationMakeOption(options)) {
props = ParseResult.validateSync(constructorSchema)(props);
}
super(props, true);
}
// ----------------
// Schema interface
// ----------------
static [TypeId] = variance;
static get ast() {
let out = astCache.get(this);
if (out) {
return out;
}
const declaration = declare([schema], {
decode: () => (input, _, ast) => input instanceof this || fallbackInstanceOf(input) ? ParseResult.succeed(input) : ParseResult.fail(new ParseResult.Type(ast, input)),
encode: () => (input, options) => input instanceof this ? ParseResult.succeed(input) : ParseResult.map(ParseResult.encodeUnknown(typeSide)(input, options), props => new this(props, true))
}, {
identifier,
pretty: pretty => self => `${identifier}(${pretty(self)})`,
// @ts-expect-error
arbitrary: arb => fc => arb(fc).map(props => new this(props)),
equivalence: _Function.identity,
[AST.SurrogateAnnotationId]: declarationSurrogate.ast,
...typeAnnotations
});
out = transform(encodedSide, declaration, {
strict: true,
decode: i => new this(i, true),
encode: _Function.identity
}).annotations({
[AST.SurrogateAnnotationId]: transformationSurrogate.ast,
...transformationAnnotations
}).ast;
astCache.set(this, out);
return out;
}
static pipe() {
return (0, _Pipeable.pipeArguments)(this, arguments);
}
static annotations(annotations) {
return make(this.ast).annotations(annotations);
}
static toString() {
return `(${String(encodedSide)} <-> ${identifier})`;
}
// ----------------
// Class interface
// ----------------
static make(...args) {
return new this(...args);
}
static fields = {
...fields
};
static identifier = identifier;
static extend(identifier) {
return (newFieldsOr, annotations) => {
const newFields = getFieldsFromFieldsOr(newFieldsOr);
const newSchema = getSchemaFromFieldsOr(newFieldsOr);
const extendedFields = extendFields(fields, newFields);
return makeClass({
kind,
identifier,
schema: extend(schema, newSchema),
fields: extendedFields,
Base: this,
annotations
});
};
}
static transformOrFail(identifier) {
return (newFieldsOr, options, annotations) => {
const transformedFields = extendFields(fields, newFieldsOr);
return makeClass({
kind,
identifier,
schema: transformOrFail(schema, typeSchema(Struct(transformedFields)), options),
fields: transformedFields,
Base: this,
annotations
});
};
}
static transformOrFailFrom(identifier) {
return (newFields, options, annotations) => {
const transformedFields = extendFields(fields, newFields);
return makeClass({
kind,
identifier,
schema: transformOrFail(encodedSchema(schema), Struct(transformedFields), options),
fields: transformedFields,
Base: this,
annotations
});
};
}
// ----------------
// other
// ----------------
get [classSymbol]() {
return classSymbol;
}
};
if (disableToString !== true) {
Object.defineProperty(klass.prototype, "toString", {
value() {
return `${identifier}({ ${util_.ownKeys(fields).map(p => `${util_.formatPropertyKey(p)}: ${util_.formatUnknown(this[p])}`).join(", ")} })`;
},
configurable: true,
writable: true
});
}
return klass;
};
const FiberIdNoneEncoded = /*#__PURE__*/Struct({
_tag: Literal("None")
}).annotations({
identifier: "FiberIdNoneEncoded"
});
const FiberIdRuntimeEncoded = /*#__PURE__*/Struct({
_tag: Literal("Runtime"),
id: Int,
startTimeMillis: Int
}).annotations({
identifier: "FiberIdRuntimeEncoded"
});
const FiberIdCompositeEncoded = /*#__PURE__*/Struct({
_tag: Literal("Composite"),
left: suspend(() => FiberIdEncoded),
right: suspend(() => FiberIdEncoded)
}).annotations({
identifier: "FiberIdCompositeEncoded"
});
const FiberIdEncoded = /*#__PURE__*/Union(FiberIdNoneEncoded, FiberIdRuntimeEncoded, FiberIdCompositeEncoded).annotations({
identifier: "FiberIdEncoded"
});
const fiberIdArbitrary = fc => fc.letrec(tie => ({
None: fc.record({
_tag: fc.constant("None")
}),
Runtime: fc.record({
_tag: fc.constant("Runtime"),
id: fc.integer(),
startTimeMillis: fc.integer()
}),
Composite: fc.record({
_tag: fc.constant("Composite"),
left: tie("FiberId"),
right: tie("FiberId")
}),
FiberId: fc.oneof(tie("None"), tie("Runtime"), tie("Composite"))
})).FiberId.map(fiberIdDecode);
const fiberIdPretty = fiberId => {
switch (fiberId._tag) {
case "None":
return "FiberId.none";
case "Runtime":
return `FiberId.runtime(${fiberId.id}, ${fiberId.startTimeMillis})`;
case "Composite":
return `FiberId.composite(${fiberIdPretty(fiberId.right)}, ${fiberIdPretty(fiberId.left)})`;
}
};
/**
* @category FiberId constructors
* @since 3.10.0
*/
class FiberIdFromSelf extends /*#__PURE__*/declare(fiberId_.isFiberId, {
identifier: "FiberIdFromSelf",
pretty: () => fiberIdPretty,
arbitrary: () => fiberIdArbitrary
}) {}
exports.FiberIdFromSelf = FiberIdFromSelf;
const fiberIdDecode = input => {
switch (input._tag) {
case "None":
return fiberId_.none;
case "Runtime":
return fiberId_.runtime(input.id, input.startTimeMillis);
case "Composite":
return fiberId_.composite(fiberIdDecode(input.left), fiberIdDecode(input.right));
}
};
const fiberIdEncode = input => {
switch (input._tag) {
case "None":
return {
_tag: "None"
};
case "Runtime":
return {
_tag: "Runtime",
id: input.id,
startTimeMillis: input.startTimeMillis
};
case "Composite":
return {
_tag: "Composite",
left: fiberIdEncode(input.left),
right: fiberIdEncode(input.right)
};
}
};
/**
* @category FiberId transformations
* @since 3.10.0
*/
class FiberId extends /*#__PURE__*/transform(FiberIdEncoded, FiberIdFromSelf, {
strict: true,
decode: i => fiberIdDecode(i),
encode: a => fiberIdEncode(a)
}).annotations({
identifier: "FiberId"
}) {}
exports.FiberId = FiberId;
const causeDieEncoded = defect => Struct({
_tag: Literal("Die"),
defect
});
const CauseEmptyEncoded = /*#__PURE__*/Struct({
_tag: /*#__PURE__*/Literal("Empty")
});
const causeFailEncoded = error => Struct({
_tag: Literal("Fail"),
error
});
const CauseInterruptEncoded = /*#__PURE__*/Struct({
_tag: /*#__PURE__*/Literal("Interrupt"),
fiberId: FiberIdEncoded
});
let causeEncodedId = 0;
const causeEncoded = (error, defect) => {
const error_ = asSchema(error);
const defect_ = asSchema(defect);
const suspended = suspend(() => out);
const out = Union(CauseEmptyEncoded, causeFailEncoded(error_), causeDieEncoded(defect_), CauseInterruptEncoded, Struct({
_tag: Literal("Sequential"),
left: suspended,
right: suspended
}), Struct({
_tag: Literal("Parallel"),
left: suspended,
right: suspended
})).annotations({
title: `CauseEncoded<${format(error)}>`,
[AST.JSONIdentifierAnnotationId]: `CauseEncoded${causeEncodedId++}`
});
return out;
};
const causeArbitrary = (error, defect) => fc => fc.letrec(tie => ({
Empty: fc.record({
_tag: fc.constant("Empty")
}),
Fail: fc.record({
_tag: fc.constant("Fail"),
error: error(fc)
}),
Die: fc.record({
_tag: fc.constant("Die"),
defect: defect(fc)
}),
Interrupt: fc.record({
_tag: fc.constant("Interrupt"),
fiberId: fiberIdArbitrary(fc)
}),
Sequential: fc.record({
_tag: fc.constant("Sequential"),
left: tie("Cause"),
right: tie("Cause")
}),
Parallel: fc.record({
_tag: fc.constant("Parallel"),
left: tie("Cause"),
right: tie("Cause")
}),
Cause: fc.oneof(tie("Empty"), tie("Fail"), tie("Die"), tie("Interrupt"), tie("Sequential"), tie("Parallel"))
})).Cause.map(causeDecode);
const causePretty = error => cause => {
const f = cause => {
switch (cause._tag) {
case "Empty":
return "Cause.empty";
case "Fail":
return `Cause.fail(${error(cause.error)})`;
case "Die":
return `Cause.die(${cause_.pretty(cause)})`;
case "Interrupt":
return `Cause.interrupt(${fiberIdPretty(cause.fiberId)})`;
case "Sequential":
return `Cause.sequential(${f(cause.left)}, ${f(cause.right)})`;
case "Parallel":
return `Cause.parallel(${f(cause.left)}, ${f(cause.right)})`;
}
};
return f(cause);
};
const causeParse = decodeUnknown => (u, options, ast) => cause_.isCause(u) ? toComposite(decodeUnknown(causeEncode(u), options), causeDecode, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Cause transformations
* @since 3.10.0
*/
const CauseFromSelf = ({
defect,
error
}) => {
return declare([error, defect], {
decode: (error, defect) => causeParse(ParseResult.decodeUnknown(causeEncoded(error, defect))),
encode: (error, defect) => causeParse(ParseResult.encodeUnknown(causeEncoded(error, defect)))
}, {
title: `Cause<${error.ast}>`,
pretty: causePretty,
arbitrary: causeArbitrary
});
};
exports.CauseFromSelf = CauseFromSelf;
function causeDecode(cause) {
switch (cause._tag) {
case "Empty":
return cause_.empty;
case "Fail":
return cause_.fail(cause.error);
case "Die":
return cause_.die(cause.defect);
case "Interrupt":
return cause_.interrupt(fiberIdDecode(cause.fiberId));
case "Sequential":
return cause_.sequential(causeDecode(cause.left), causeDecode(cause.right));
case "Parallel":
return cause_.parallel(causeDecode(cause.left), causeDecode(cause.right));
}
}
function causeEncode(cause) {
switch (cause._tag) {
case "Empty":
return {
_tag: "Empty"
};
case "Fail":
return {
_tag: "Fail",
error: cause.error
};
case "Die":
return {
_tag: "Die",
defect: cause.defect
};
case "Interrupt":
return {
_tag: "Interrupt",
fiberId: cause.fiberId
};
case "Sequential":
return {
_tag: "Sequential",
left: causeEncode(cause.left),
right: causeEncode(cause.right)
};
case "Parallel":
return {
_tag: "Parallel",
left: causeEncode(cause.left),
right: causeEncode(cause.right)
};
}
}
/**
* @category Cause transformations
* @since 3.10.0
*/
const Cause = ({
defect,
error
}) => {
const error_ = asSchema(error);
const defect_ = asSchema(defect);
const out = transform(causeEncoded(error_, defect_), CauseFromSelf({
error: typeSchema(error_),
defect: typeSchema(defect_)
}), {
strict: false,
decode: i => causeDecode(i),
encode: a => causeEncode(a)
});
return out;
};
/**
* Defines a schema for handling JavaScript errors (`Error` instances) and other types of defects.
* It decodes objects into Error instances if they match the expected structure (i.e., have a `message` and optionally a `name` and `stack`),
* or converts other values to their string representations.
*
* When encoding, it converts `Error` instances back into plain objects containing only the error's name and message,
* or other values into their string forms.
*
* This is useful for serializing and deserializing errors across network boundaries where error objects do not natively serialize.
*
* @category defect
* @since 3.10.0
*/
exports.Cause = Cause;
class Defect extends /*#__PURE__*/transform(Unknown, Unknown, {
strict: true,
decode: i => {
if (Predicate.isObject(i) && "message" in i && typeof i.message === "string") {
const err = new Error(i.message, {
cause: i
});
if ("name" in i && typeof i.name === "string") {
err.name = i.name;
}
err.stack = "stack" in i && typeof i.stack === "string" ? i.stack : "";
return err;
}
return String(i);
},
encode: a => {
if (a instanceof Error) {
return {
name: a.name,
message: a.message
// no stack because of security reasons
};
}
return internalCause_.prettyErrorMessage(a);
}
}).annotations({
identifier: "Defect"
}) {}
exports.Defect = Defect;
const exitFailureEncoded = (error, defect) => Struct({
_tag: Literal("Failure"),
cause: causeEncoded(error, defect)
});
const exitSuccessEncoded = value => Struct({
_tag: Literal("Success"),
value
});
const exitEncoded = (value, error, defect) => {
return Union(exitFailureEncoded(error, defect), exitSuccessEncoded(value)).annotations({
title: `ExitEncoded<${format(value)}, ${format(error)}, ${format(defect)}>`
});
};
const exitDecode = input => {
switch (input._tag) {
case "Failure":
return exit_.failCause(causeDecode(input.cause));
case "Success":
return exit_.succeed(input.value);
}
};
const exitArbitrary = (value, error, defect) => fc => fc.oneof(fc.record({
_tag: fc.constant("Failure"),
cause: causeArbitrary(error, defect)(fc)
}), fc.record({
_tag: fc.constant("Success"),
value: value(fc)
})).map(exitDecode);
const exitPretty = (value, error) => exit => exit._tag === "Failure" ? `Exit.failCause(${causePretty(error)(exit.cause)})` : `Exit.succeed(${value(exit.value)})`;
const exitParse = (decodeUnknownValue, decodeUnknownCause) => (u, options, ast) => exit_.isExit(u) ? exit_.match(u, {
onFailure: cause => toComposite(decodeUnknownCause(cause, options), exit_.failCause, ast, u),
onSuccess: value => toComposite(decodeUnknownValue(value, options), exit_.succeed, ast, u)
}) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category Exit transformations
* @since 3.10.0
*/
const ExitFromSelf = ({
defect,
failure,
success
}) => declare([success, failure, defect], {
decode: (success, failure, defect) => exitParse(ParseResult.decodeUnknown(success), ParseResult.decodeUnknown(CauseFromSelf({
error: failure,
defect
}))),
encode: (success, failure, defect) => exitParse(ParseResult.encodeUnknown(success), ParseResult.encodeUnknown(CauseFromSelf({
error: failure,
defect
})))
}, {
title: `Exit<${success.ast}, ${failure.ast}>`,
pretty: exitPretty,
arbitrary: exitArbitrary
});
/**
* @category Exit transformations
* @since 3.10.0
*/
exports.ExitFromSelf = ExitFromSelf;
const Exit = ({
defect,
failure,
success
}) => {
const success_ = asSchema(success);
const failure_ = asSchema(failure);
const defect_ = asSchema(defect);
const out = transform(exitEncoded(success_, failure_, defect_), ExitFromSelf({
failure: typeSchema(failure_),
success: typeSchema(success_),
defect: typeSchema(defect_)
}), {
strict: false,
decode: i => exitDecode(i),
encode: a => a._tag === "Failure" ? {
_tag: "Failure",
cause: a.cause
} : {
_tag: "Success",
value: a.value
}
});
return out;
};
exports.Exit = Exit;
const hashSetArbitrary = (item, ctx) => fc => {
const items = fc.array(item(fc));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(hashSet_.fromIterable);
};
const hashSetPretty = item => set => `HashSet(${Array.from(set).map(a => item(a)).join(", ")})`;
const hashSetEquivalence = item => {
const arrayEquivalence = array_.getEquivalence(item);
return Equivalence.make((a, b) => arrayEquivalence(Array.from(a), Array.from(b)));
};
const hashSetParse = decodeUnknown => (u, options, ast) => hashSet_.isHashSet(u) ? toComposite(decodeUnknown(Array.from(u), options), hashSet_.fromIterable, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category HashSet transformations
* @since 3.10.0
*/
const HashSetFromSelf = value => {
return declare([value], {
decode: item => hashSetParse(ParseResult.decodeUnknown(Array$(item))),
encode: item => hashSetParse(ParseResult.encodeUnknown(Array$(item)))
}, {
description: `HashSet<${format(value)}>`,
pretty: hashSetPretty,
arbitrary: hashSetArbitrary,
equivalence: hashSetEquivalence
});
};
/**
* @category HashSet transformations
* @since 3.10.0
*/
exports.HashSetFromSelf = HashSetFromSelf;
function HashSet(value) {
return transform(Array$(value), HashSetFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => hashSet_.fromIterable(i),
encode: a => Array.from(a)
});
}
const hashMapArbitrary = (key, value, ctx) => fc => {
const items = fc.array(fc.tuple(key(fc), value(fc)));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(hashMap_.fromIterable);
};
const hashMapPretty = (key, value) => map => `HashMap([${Array.from(map).map(([k, v]) => `[${key(k)}, ${value(v)}]`).join(", ")}])`;
const hashMapEquivalence = (key, value) => {
const arrayEquivalence = array_.getEquivalence(Equivalence.make(([ka, va], [kb, vb]) => key(ka, kb) && value(va, vb)));
return Equivalence.make((a, b) => arrayEquivalence(Array.from(a), Array.from(b)));
};
const hashMapParse = decodeUnknown => (u, options, ast) => hashMap_.isHashMap(u) ? toComposite(decodeUnknown(Array.from(u), options), hashMap_.fromIterable, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category HashMap transformations
* @since 3.10.0
*/
const HashMapFromSelf = ({
key,
value
}) => {
return declare([key, value], {
decode: (key, value) => hashMapParse(ParseResult.decodeUnknown(Array$(Tuple(key, value)))),
encode: (key, value) => hashMapParse(ParseResult.encodeUnknown(Array$(Tuple(key, value))))
}, {
description: `HashMap<${format(key)}, ${format(value)}>`,
pretty: hashMapPretty,
arbitrary: hashMapArbitrary,
equivalence: hashMapEquivalence
});
};
/**
* @category HashMap transformations
* @since 3.10.0
*/
exports.HashMapFromSelf = HashMapFromSelf;
const HashMap = ({
key,
value
}) => {
return transform(Array$(Tuple(key, value)), HashMapFromSelf({
key: typeSchema(asSchema(key)),
value: typeSchema(asSchema(value))
}), {
strict: true,
decode: i => hashMap_.fromIterable(i),
encode: a => Array.from(a)
});
};
exports.HashMap = HashMap;
const listArbitrary = (item, ctx) => fc => {
const items = fc.array(item(fc));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(list_.fromIterable);
};
const listPretty = item => set => `List(${Array.from(set).map(a => item(a)).join(", ")})`;
const listEquivalence = item => {
const arrayEquivalence = array_.getEquivalence(item);
return Equivalence.make((a, b) => arrayEquivalence(Array.from(a), Array.from(b)));
};
const listParse = decodeUnknown => (u, options, ast) => list_.isList(u) ? toComposite(decodeUnknown(Array.from(u), options), list_.fromIterable, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category List transformations
* @since 3.10.0
*/
const ListFromSelf = value => {
return declare([value], {
decode: item => listParse(ParseResult.decodeUnknown(Array$(item))),
encode: item => listParse(ParseResult.encodeUnknown(Array$(item)))
}, {
description: `List<${format(value)}>`,
pretty: listPretty,
arbitrary: listArbitrary,
equivalence: listEquivalence
});
};
/**
* @category List transformations
* @since 3.10.0
*/
exports.ListFromSelf = ListFromSelf;
function List(value) {
return transform(Array$(value), ListFromSelf(typeSchema(asSchema(value))), {
strict: true,
decode: i => list_.fromIterable(i),
encode: a => Array.from(a)
});
}
const sortedSetArbitrary = (item, ord, ctx) => fc => {
const items = fc.array(item(fc));
return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(as => sortedSet_.fromIterable(as, ord));
};
const sortedSetPretty = item => set => `new SortedSet([${Array.from(sortedSet_.values(set)).map(a => item(a)).join(", ")}])`;
const sortedSetParse = (decodeUnknown, ord) => (u, options, ast) => sortedSet_.isSortedSet(u) ? toComposite(decodeUnknown(Array.from(sortedSet_.values(u)), options), as => sortedSet_.fromIterable(as, ord), ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
/**
* @category SortedSet transformations
* @since 3.10.0
*/
const SortedSetFromSelf = (value, ordA, ordI) => {
return declare([value], {
decode: item => sortedSetParse(ParseResult.decodeUnknown(Array$(item)), ordA),
encode: item => sortedSetParse(ParseResult.encodeUnknown(Array$(item)), ordI)
}, {
description: `SortedSet<${format(value)}>`,
pretty: sortedSetPretty,
arbitrary: (arb, ctx) => sortedSetArbitrary(arb, ordA, ctx),
equivalence: () => sortedSet_.getEquivalence()
});
};
/**
* @category SortedSet transformations
* @since 3.10.0
*/
exports.SortedSetFromSelf = SortedSetFromSelf;
function SortedSet(value, ordA) {
const to = typeSchema(asSchema(value));
return transform(Array$(value), SortedSetFromSelf(to, ordA, ordA), {
strict: true,
decode: i => sortedSet_.fromIterable(i, ordA),
encode: a => Array.from(sortedSet_.values(a))
});
}
/**
* Converts an arbitrary value to a `boolean` by testing whether it is truthy.
* Uses `!!val` to coerce the value to a `boolean`.
*
* @see https://developer.mozilla.org/docs/Glossary/Truthy
*
* @category boolean constructors
* @since 3.10.0
*/
class BooleanFromUnknown extends /*#__PURE__*/transform(Unknown, Boolean$, {
strict: true,
decode: i => Predicate.isTruthy(i),
encode: _Function.identity
}).annotations({
identifier: "BooleanFromUnknown"
}) {}
/**
* Converts an `string` value into its corresponding `boolean`
* ("true" as `true` and "false" as `false`).
*
* @category boolean transformations
* @since 3.11.0
*/
exports.BooleanFromUnknown = BooleanFromUnknown;
class BooleanFromString extends /*#__PURE__*/transform(Literal("true", "false").annotations({
description: "a string to be decoded into a boolean"
}), Boolean$, {
strict: true,
decode: i => i === "true",
encode: a => a ? "true" : "false"
}).annotations({
identifier: "BooleanFromString"
}) {}
/**
* @category Config validations
* @since 3.10.0
*/
exports.BooleanFromString = BooleanFromString;
const Config = (name, schema) => {
const decodeUnknownEither = ParseResult.decodeUnknownEither(schema);
return config_.string(name).pipe(config_.mapOrFail(s => decodeUnknownEither(s).pipe(either_.mapLeft(error => configError_.InvalidData([], ParseResult.TreeFormatter.formatIssueSync(error))))));
};
// ---------------------------------------------
// Serializable
// ---------------------------------------------
/**
* @since 3.10.0
* @category symbol
*/
exports.Config = Config;
const symbolSerializable = exports.symbolSerializable = /*#__PURE__*/Symbol.for("effect/Schema/Serializable/symbol");
/**
* @since 3.10.0
*/
const asSerializable = serializable => serializable;
/**
* @since 3.10.0
* @category accessor
*/
exports.asSerializable = asSerializable;
const serializableSchema = self => self[symbolSerializable];
/**
* @since 3.10.0
* @category encoding
*/
exports.serializableSchema = serializableSchema;
const serialize = self => encodeUnknown(self[symbolSerializable])(self);
/**
* @since 3.10.0
* @category decoding
*/
exports.serialize = serialize;
const deserialize = exports.deserialize = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => decodeUnknown(self[symbolSerializable])(value));
/**
* @since 3.10.0
* @category symbol
*/
const symbolWithResult = exports.symbolWithResult = /*#__PURE__*/Symbol.for("effect/Schema/Serializable/symbolResult");
/**
* @since 3.10.0
*/
const asWithResult = withExit => withExit;
/**
* @since 3.10.0
* @category accessor
*/
exports.asWithResult = asWithResult;
const failureSchema = self => self[symbolWithResult].failure;
/**
* @since 3.10.0
* @category accessor
*/
exports.failureSchema = failureSchema;
const successSchema = self => self[symbolWithResult].success;
exports.successSchema = successSchema;
const exitSchemaCache = /*#__PURE__*/(0, _GlobalValue.globalValue)("effect/Schema/Serializable/exitSchemaCache", () => new WeakMap());
/**
* @since 3.10.0
* @category accessor
*/
const exitSchema = self => {
const proto = Object.getPrototypeOf(self);
if (!(symbolWithResult in proto)) {
return Exit({
failure: failureSchema(self),
success: successSchema(self),
defect: Defect
});
}
let schema = exitSchemaCache.get(proto);
if (schema === undefined) {
schema = Exit({
failure: failureSchema(self),
success: successSchema(self),
defect: Defect
});
exitSchemaCache.set(proto, schema);
}
return schema;
};
/**
* @since 3.10.0
* @category encoding
*/
exports.exitSchema = exitSchema;
const serializeFailure = exports.serializeFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => encode(self[symbolWithResult].failure)(value));
/**
* @since 3.10.0
* @category decoding
*/
const deserializeFailure = exports.deserializeFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => decodeUnknown(self[symbolWithResult].failure)(value));
/**
* @since 3.10.0
* @category encoding
*/
const serializeSuccess = exports.serializeSuccess = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => encode(self[symbolWithResult].success)(value));
/**
* @since 3.10.0
* @category decoding
*/
const deserializeSuccess = exports.deserializeSuccess = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => decodeUnknown(self[symbolWithResult].success)(value));
/**
* @since 3.10.0
* @category encoding
*/
const serializeExit = exports.serializeExit = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => encode(exitSchema(self))(value));
/**
* @since 3.10.0
* @category decoding
*/
const deserializeExit = exports.deserializeExit = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => decodeUnknown(exitSchema(self))(value));
/**
* @since 3.10.0
*/
const asSerializableWithResult = procedure => procedure;
/**
* @example
* ```ts
* import { Schema } from "effect"
*
* class MyRequest extends Schema.TaggedRequest<MyRequest>("MyRequest")("MyRequest", {
* failure: Schema.String,
* success: Schema.Number,
* payload: { id: Schema.String }
* }) {}
* ```
*
* @category classes
* @since 3.10.0
*/
exports.asSerializableWithResult = asSerializableWithResult;
const TaggedRequest = identifier => (tag, options, annotations) => {
const taggedFields = extendFields({
_tag: getClassTag(tag)
}, options.payload);
return class TaggedRequestClass extends makeClass({
kind: "TaggedRequest",
identifier: identifier ?? tag,
schema: Struct(taggedFields),
fields: taggedFields,
Base: Request.Class,
annotations
}) {
static _tag = tag;
static success = options.success;
static failure = options.failure;
get [symbolSerializable]() {
return this.constructor;
}
get [symbolWithResult]() {
return {
failure: options.failure,
success: options.success
};
}
};
};
// -------------------------------------------------------------------------------------------------
// Equivalence compiler
// -------------------------------------------------------------------------------------------------
/**
* Given a schema `Schema<A, I, R>`, returns an `Equivalence` instance for `A`.
*
* @category Equivalence
* @since 3.10.0
*/
exports.TaggedRequest = TaggedRequest;
const equivalence = schema => go(schema.ast, []);
exports.equivalence = equivalence;
const getEquivalenceAnnotation = /*#__PURE__*/AST.getAnnotation(AST.EquivalenceAnnotationId);
const go = (ast, path) => {
const hook = getEquivalenceAnnotation(ast);
if (option_.isSome(hook)) {
switch (ast._tag) {
case "Declaration":
return hook.value(...ast.typeParameters.map(tp => go(tp, path)));
case "Refinement":
return hook.value(go(ast.from, path));
default:
return hook.value();
}
}
switch (ast._tag) {
case "NeverKeyword":
throw new Error(errors_.getEquivalenceUnsupportedErrorMessage(ast, path));
case "Transformation":
return go(ast.to, path);
case "Declaration":
case "Literal":
case "StringKeyword":
case "TemplateLiteral":
case "UniqueSymbol":
case "SymbolKeyword":
case "UnknownKeyword":
case "AnyKeyword":
case "NumberKeyword":
case "BooleanKeyword":
case "BigIntKeyword":
case "UndefinedKeyword":
case "VoidKeyword":
case "Enums":
case "ObjectKeyword":
return Equal.equals;
case "Refinement":
return go(ast.from, path);
case "Suspend":
{
const get = util_.memoizeThunk(() => go(ast.f(), path));
return (a, b) => get()(a, b);
}
case "TupleType":
{
const elements = ast.elements.map((element, i) => go(element.type, path.concat(i)));
const rest = ast.rest.map(annotatedAST => go(annotatedAST.type, path));
return Equivalence.make((a, b) => {
if (!Array.isArray(a) || !Array.isArray(b)) {
return false;
}
const len = a.length;
if (len !== b.length) {
return false;
}
// ---------------------------------------------
// handle elements
// ---------------------------------------------
let i = 0;
for (; i < Math.min(len, ast.elements.length); i++) {
if (!elements[i](a[i], b[i])) {
return false;
}
}
// ---------------------------------------------
// handle rest element
// ---------------------------------------------
if (array_.isNonEmptyReadonlyArray(rest)) {
const [head, ...tail] = rest;
for (; i < len - tail.length; i++) {
if (!head(a[i], b[i])) {
return false;
}
}
// ---------------------------------------------
// handle post rest elements
// ---------------------------------------------
for (let j = 0; j < tail.length; j++) {
i += j;
if (!tail[j](a[i], b[i])) {
return false;
}
}
}
return true;
});
}
case "TypeLiteral":
{
if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
return Equal.equals;
}
const propertySignatures = ast.propertySignatures.map(ps => go(ps.type, path.concat(ps.name)));
const indexSignatures = ast.indexSignatures.map(is => go(is.type, path));
return Equivalence.make((a, b) => {
if (!Predicate.isRecord(a) || !Predicate.isRecord(b)) {
return false;
}
const aStringKeys = Object.keys(a);
const aSymbolKeys = Object.getOwnPropertySymbols(a);
// ---------------------------------------------
// handle property signatures
// ---------------------------------------------
for (let i = 0; i < propertySignatures.length; i++) {
const ps = ast.propertySignatures[i];
const name = ps.name;
const aHas = Object.prototype.hasOwnProperty.call(a, name);
const bHas = Object.prototype.hasOwnProperty.call(b, name);
if (ps.isOptional) {
if (aHas !== bHas) {
return false;
}
}
if (aHas && bHas && !propertySignatures[i](a[name], b[name])) {
return false;
}
}
// ---------------------------------------------
// handle index signatures
// ---------------------------------------------
let bSymbolKeys;
let bStringKeys;
for (let i = 0; i < indexSignatures.length; i++) {
const is = ast.indexSignatures[i];
const encodedParameter = AST.getEncodedParameter(is.parameter);
const isSymbol = AST.isSymbolKeyword(encodedParameter);
if (isSymbol) {
bSymbolKeys = bSymbolKeys || Object.getOwnPropertySymbols(b);
if (aSymbolKeys.length !== bSymbolKeys.length) {
return false;
}
} else {
bStringKeys = bStringKeys || Object.keys(b);
if (aStringKeys.length !== bStringKeys.length) {
return false;
}
}
const aKeys = isSymbol ? aSymbolKeys : aStringKeys;
for (let j = 0; j < aKeys.length; j++) {
const key = aKeys[j];
if (!Object.prototype.hasOwnProperty.call(b, key) || !indexSignatures[i](a[key], b[key])) {
return false;
}
}
}
return true;
});
}
case "Union":
{
const searchTree = ParseResult.getSearchTree(ast.types, true);
const ownKeys = util_.ownKeys(searchTree.keys);
const len = ownKeys.length;
return Equivalence.make((a, b) => {
let candidates = [];
if (len > 0 && Predicate.isRecordOrArray(a)) {
for (let i = 0; i < len; i++) {
const name = ownKeys[i];
const buckets = searchTree.keys[name].buckets;
if (Object.prototype.hasOwnProperty.call(a, name)) {
const literal = String(a[name]);
if (Object.prototype.hasOwnProperty.call(buckets, literal)) {
candidates = candidates.concat(buckets[literal]);
}
}
}
}
if (searchTree.otherwise.length > 0) {
candidates = candidates.concat(searchTree.otherwise);
}
const tuples = candidates.map(ast => [go(ast, path), ParseResult.is({
ast
})]);
for (let i = 0; i < tuples.length; i++) {
const [equivalence, is] = tuples[i];
if (is(a) && is(b)) {
if (equivalence(a, b)) {
return true;
}
}
}
return false;
});
}
}
};
const SymbolStruct = /*#__PURE__*/TaggedStruct("symbol", {
key: String$
}).annotations({
description: "an object to be decoded into a globally shared symbol"
});
const SymbolFromStruct = /*#__PURE__*/transformOrFail(SymbolStruct, SymbolFromSelf, {
strict: true,
decode: i => decodeSymbol(i.key),
encode: (a, _, ast) => ParseResult.map(encodeSymbol(a, ast), key => SymbolStruct.make({
key
}))
});
/** @ignore */
class PropertyKey$ extends /*#__PURE__*/Union(String$, Number$, SymbolFromStruct).annotations({
identifier: "PropertyKey"
}) {}
exports.PropertyKey = PropertyKey$;
/**
* @category ArrayFormatter
* @since 3.12.5
*/
class ArrayFormatterIssue extends /*#__PURE__*/Struct({
_tag: propertySignature(Literal("Pointer", "Unexpected", "Missing", "Composite", "Refinement", "Transformation", "Type", "Forbidden")).annotations({
description: "The tag identifying the type of parse issue"
}),
path: propertySignature(Array$(PropertyKey$)).annotations({
description: "The path to the property where the issue occurred"
}),
message: propertySignature(String$).annotations({
description: "A descriptive message explaining the issue"
})
}).annotations({
identifier: "ArrayFormatterIssue",
description: "Represents an issue returned by the ArrayFormatter formatter"
}) {}
exports.ArrayFormatterIssue = ArrayFormatterIssue;
//# sourceMappingURL=Schema.js.map