hume 0.8.5 → 0.8.7

package/core/schemas/builders/object/property.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from '../../Schema';
+import { Schema } from "../../Schema";
 export declare function property<RawKey extends string, RawValue, ParsedValue>(rawKey: RawKey, valueSchema: Schema<RawValue, ParsedValue>): Property<RawKey, RawValue, ParsedValue>;
 export interface Property<RawKey extends string, RawValue, ParsedValue> {
     rawKey: RawKey;

package/core/schemas/builders/object/types.d.ts

@@ -1,8 +1,8 @@
-import { BaseSchema, inferParsed, inferRaw, Schema } from '../../Schema';
-import { addQuestionMarksToNullableProperties } from '../../utils/addQuestionMarksToNullableProperties';
-import { ObjectLikeUtils } from '../object-like';
-import { SchemaUtils } from '../schema-utils';
-import { Property } from './property';
+import { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
+import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
+import { ObjectLikeUtils } from "../object-like";
+import { SchemaUtils } from "../schema-utils";
+import { Property } from "./property";
 export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
     _getRawProperties: () => (keyof Raw)[];

package/core/schemas/builders/object-like/getObjectLikeUtils.d.ts

@@ -1,5 +1,5 @@
-import { BaseSchema } from '../../Schema';
-import { ObjectLikeSchema, ObjectLikeUtils } from './types';
+import { BaseSchema } from "../../Schema";
+import { ObjectLikeSchema, ObjectLikeUtils } from "./types";
 export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports

package/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -22,7 +22,7 @@ function withParsedProperties(objectLike, properties) {
                 return parsedObject;
             }
             const additionalProperties = Object.entries(properties).reduce((processed, [key, value]) => {
-                return Object.assign(Object.assign({}, processed), { [key]: typeof value === 'function' ? value(parsedObject.value) : value });
+                return Object.assign(Object.assign({}, processed), { [key]: typeof value === "function" ? value(parsedObject.value) : value });
             }, {});
             return {
                 ok: true,
@@ -37,7 +37,7 @@ function withParsedProperties(objectLike, properties) {
                     errors: [
                         {
                             path: (_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : [],
-                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, 'object'),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, "object"),
                         },
                     ],
                 };

package/core/schemas/builders/object-like/index.d.ts

@@ -1,2 +1,2 @@
-export { getObjectLikeUtils, withParsedProperties } from './getObjectLikeUtils';
-export type { ObjectLikeSchema, ObjectLikeUtils } from './types';
+export { getObjectLikeUtils, withParsedProperties } from "./getObjectLikeUtils";
+export type { ObjectLikeSchema, ObjectLikeUtils } from "./types";

package/core/schemas/builders/object-like/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema } from '../../Schema';
+import { BaseSchema, Schema } from "../../Schema";
 export declare type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
 export interface ObjectLikeUtils<Raw, Parsed> {
     withParsedProperties: <T extends Record<string, any>>(properties: {

package/core/schemas/builders/primitives/boolean.js

@@ -5,7 +5,7 @@ const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 exports.boolean = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN, (value, { breadcrumbsPrefix = [] } = {}) => {
-    if (typeof value === 'boolean') {
+    if (typeof value === "boolean") {
         return {
             ok: true,
             value,
@@ -17,7 +17,7 @@ exports.boolean = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)
             errors: [
                 {
                     path: breadcrumbsPrefix,
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, 'boolean'),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "boolean"),
                 },
             ],
         };

package/core/schemas/builders/primitives/index.d.ts

@@ -1,5 +1,5 @@
-export { any } from './any';
-export { boolean } from './boolean';
-export { number } from './number';
-export { string } from './string';
-export { unknown } from './unknown';
+export { any } from "./any";
+export { boolean } from "./boolean";
+export { number } from "./number";
+export { string } from "./string";
+export { unknown } from "./unknown";

package/core/schemas/builders/primitives/number.js

@@ -5,7 +5,7 @@ const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 exports.number = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.NUMBER, (value, { breadcrumbsPrefix = [] } = {}) => {
-    if (typeof value === 'number') {
+    if (typeof value === "number") {
         return {
             ok: true,
             value,
@@ -17,7 +17,7 @@ exports.number = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(
             errors: [
                 {
                     path: breadcrumbsPrefix,
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, 'number'),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "number"),
                 },
             ],
         };

package/core/schemas/builders/primitives/string.js

@@ -5,7 +5,7 @@ const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 exports.string = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING, (value, { breadcrumbsPrefix = [] } = {}) => {
-    if (typeof value === 'string') {
+    if (typeof value === "string") {
         return {
             ok: true,
             value,
@@ -17,7 +17,7 @@ exports.string = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(
             errors: [
                 {
                     path: breadcrumbsPrefix,
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, 'string'),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "string"),
                 },
             ],
         };

package/core/schemas/builders/record/index.d.ts

@@ -1,2 +1,2 @@
-export { record } from './record';
-export type { BaseRecordSchema, RecordSchema } from './types';
+export { record } from "./record";
+export type { BaseRecordSchema, RecordSchema } from "./types";

package/core/schemas/builders/record/record.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from '../../Schema';
-import { RecordSchema } from './types';
+import { Schema } from "../../Schema";
+import { RecordSchema } from "./types";
 export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/core/schemas/builders/record/record.js

@@ -15,10 +15,7 @@ function record(keySchema, valueSchema) {
                 isKeyNumeric: keySchema.getType() === Schema_1.SchemaType.NUMBER,
                 transformKey: (key) => {
                     var _a;
-                    return keySchema.parse(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [
-                            ...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []),
-                            `${key} (key)`,
-                        ] }));
+                    return keySchema.parse(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
                 },
                 transformValue: (value, key) => {
                     var _a;
@@ -33,10 +30,7 @@ function record(keySchema, valueSchema) {
                 isKeyNumeric: keySchema.getType() === Schema_1.SchemaType.NUMBER,
                 transformKey: (key) => {
                     var _a;
-                    return keySchema.json(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [
-                            ...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []),
-                            `${key} (key)`,
-                        ] }));
+                    return keySchema.json(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
                 },
                 transformValue: (value, key) => {
                     var _a;
@@ -57,7 +51,7 @@ function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transfo
             errors: [
                 {
                     path: breadcrumbsPrefix,
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, 'object'),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
                 },
             ],
         };

package/core/schemas/builders/record/types.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema } from '../../Schema';
-import { SchemaUtils } from '../schema-utils';
+import { BaseSchema } from "../../Schema";
+import { SchemaUtils } from "../schema-utils";
 export declare type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
 export declare type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

package/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from '../../Schema';
+import { ValidationError } from "../../Schema";
 export declare class JsonError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/core/schemas/builders/schema-utils/JsonError.js

@@ -4,7 +4,7 @@ exports.JsonError = void 0;
 const stringifyValidationErrors_1 = require("./stringifyValidationErrors");
 class JsonError extends Error {
     constructor(errors) {
-        super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join('; '));
+        super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join("; "));
         this.errors = errors;
         Object.setPrototypeOf(this, JsonError.prototype);
     }

package/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from '../../Schema';
+import { ValidationError } from "../../Schema";
 export declare class ParseError extends Error {
     readonly errors: ValidationError[];
     constructor(errors: ValidationError[]);

package/core/schemas/builders/schema-utils/ParseError.js

@@ -4,7 +4,7 @@ exports.ParseError = void 0;
 const stringifyValidationErrors_1 = require("./stringifyValidationErrors");
 class ParseError extends Error {
     constructor(errors) {
-        super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join('; '));
+        super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join("; "));
         this.errors = errors;
         Object.setPrototypeOf(this, ParseError.prototype);
     }

package/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -1,4 +1,4 @@
-import { BaseSchema, Schema, SchemaOptions } from '../../Schema';
+import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
     transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;

package/core/schemas/builders/schema-utils/getSchemaUtils.js

@@ -40,6 +40,12 @@ function optional(schema) {
             return schema.parse(raw, opts);
         },
         json: (parsed, opts) => {
+            if ((opts === null || opts === void 0 ? void 0 : opts.omitUndefined) && parsed === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
             if (parsed == null) {
                 return {
                     ok: true,

package/core/schemas/builders/schema-utils/index.d.ts

@@ -1,4 +1,4 @@
-export { getSchemaUtils, optional, transform } from './getSchemaUtils';
-export type { SchemaUtils } from './getSchemaUtils';
-export { JsonError } from './JsonError';
-export { ParseError } from './ParseError';
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
+export type { SchemaUtils } from "./getSchemaUtils";
+export { JsonError } from "./JsonError";
+export { ParseError } from "./ParseError";

package/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -1,2 +1,2 @@
-import { ValidationError } from '../../Schema';
+import { ValidationError } from "../../Schema";
 export declare function stringifyValidationError(error: ValidationError): string;

package/core/schemas/builders/schema-utils/stringifyValidationErrors.js

@@ -5,6 +5,6 @@ function stringifyValidationError(error) {
     if (error.path.length === 0) {
         return error.message;
     }
-    return `${error.path.join(' -> ')}: ${error.message}`;
+    return `${error.path.join(" -> ")}: ${error.message}`;
 }
 exports.stringifyValidationError = stringifyValidationError;

package/core/schemas/builders/set/index.d.ts

@@ -1 +1 @@
-export { set } from './set';
+export { set } from "./set";

package/core/schemas/builders/set/set.d.ts

@@ -1,2 +1,2 @@
-import { Schema } from '../../Schema';
+import { Schema } from "../../Schema";
 export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/core/schemas/builders/set/set.js

@@ -29,7 +29,7 @@ function set(schema) {
                     errors: [
                         {
                             path: (_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : [],
-                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, 'Set'),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, "Set"),
                         },
                     ],
                 };

package/core/schemas/builders/undiscriminated-union/index.d.ts

@@ -1,2 +1,2 @@
-export type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema, UndiscriminatedUnionSchema, } from './types';
-export { undiscriminatedUnion } from './undiscriminatedUnion';
+export type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema, UndiscriminatedUnionSchema, } from "./types";
+export { undiscriminatedUnion } from "./undiscriminatedUnion";

package/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -1,4 +1,4 @@
-import { inferParsed, inferRaw, Schema } from '../../Schema';
+import { inferParsed, inferRaw, Schema } from "../../Schema";
 export declare type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
 export declare type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
 export declare type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -1,3 +1,3 @@
-import { Schema } from '../../Schema';
-import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from './types';
+import { Schema } from "../../Schema";
+import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
 export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/core/schemas/builders/union/index.d.ts

@@ -1,4 +1,4 @@
-export { discriminant } from './discriminant';
-export type { Discriminant } from './discriminant';
-export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from './types';
-export { union } from './union';
+export { discriminant } from "./discriminant";
+export type { Discriminant } from "./discriminant";
+export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
+export { union } from "./union";

package/core/schemas/builders/union/types.d.ts

@@ -1,5 +1,5 @@
-import { inferParsedObject, inferRawObject, ObjectSchema } from '../object';
-import { Discriminant } from './discriminant';
+import { inferParsedObject, inferRawObject, ObjectSchema } from "../object";
+import { Discriminant } from "./discriminant";
 export declare type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };

package/core/schemas/builders/union/union.d.ts

@@ -1,4 +1,4 @@
-import { ObjectLikeSchema } from '../object-like';
-import { Discriminant } from './discriminant';
-import { inferParsedUnion, inferRawUnion, UnionSubtypes } from './types';
+import { ObjectLikeSchema } from "../object-like";
+import { Discriminant } from "./discriminant";
+import { inferParsedUnion, inferRawUnion, UnionSubtypes } from "./types";
 export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/core/schemas/builders/union/union.js

@@ -21,10 +21,8 @@ const enum_1 = require("../enum");
 const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
 function union(discriminant, union) {
-    const rawDiscriminant = typeof discriminant === 'string'
-        ? discriminant
-        : discriminant.rawDiscriminant;
-    const parsedDiscriminant = typeof discriminant === 'string'
+    const rawDiscriminant = typeof discriminant === "string" ? discriminant : discriminant.rawDiscriminant;
+    const parsedDiscriminant = typeof discriminant === "string"
         ? discriminant
         : discriminant.parsedDiscriminant;
     const discriminantValueSchema = (0, enum_1.enum_)((0, keys_1.keys)(union));
@@ -38,10 +36,7 @@ function union(discriminant, union) {
                     var _a;
                     return discriminantValueSchema.parse(discriminantValue, {
                         allowUnrecognizedEnumValues: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
-                        breadcrumbsPrefix: [
-                            ...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []),
-                            rawDiscriminant,
-                        ],
+                        breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), rawDiscriminant],
                     });
                 },
                 getAdditionalPropertiesSchema: (discriminantValue) => union[discriminantValue],
@@ -59,10 +54,7 @@ function union(discriminant, union) {
                     var _a;
                     return discriminantValueSchema.json(discriminantValue, {
                         allowUnrecognizedEnumValues: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
-                        breadcrumbsPrefix: [
-                            ...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []),
-                            parsedDiscriminant,
-                        ],
+                        breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), parsedDiscriminant],
                     });
                 },
                 getAdditionalPropertiesSchema: (discriminantValue) => union[discriminantValue],
@@ -83,7 +75,7 @@ function transformAndValidateUnion({ value, discriminant, transformedDiscriminan
             errors: [
                 {
                     path: breadcrumbsPrefix,
-                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, 'object'),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
                 },
             ],
         };
@@ -121,7 +113,7 @@ function transformAndValidateUnion({ value, discriminant, transformedDiscriminan
                 errors: [
                     {
                         path: [...breadcrumbsPrefix, discriminant],
-                        message: 'Unexpected discriminant value',
+                        message: "Unexpected discriminant value",
                     },
                 ],
             };

package/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
-export * from './builders';
-export type { inferParsed, inferRaw, Schema, SchemaOptions } from './Schema';
+export * from "./builders";
+export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -1,2 +1,2 @@
-import { MaybeValid, Schema, SchemaOptions, SchemaType } from '../Schema';
+import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
 export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/core/schemas/utils/getErrorMessageForIncorrectType.js

@@ -7,17 +7,17 @@ function getErrorMessageForIncorrectType(value, expectedType) {
 exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
 function getTypeAsString(value) {
     if (Array.isArray(value)) {
-        return 'list';
+        return "list";
     }
     if (value === null) {
-        return 'null';
+        return "null";
     }
     switch (typeof value) {
-        case 'string':
+        case "string":
             return `"${value}"`;
-        case 'number':
-        case 'boolean':
-        case 'undefined':
+        case "number":
+        case "boolean":
+        case "undefined":
             return `${value}`;
     }
     return typeof value;

package/core/schemas/utils/isPlainObject.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPlainObject = void 0;
 // borrowed from https://github.com/lodash/lodash/blob/master/isPlainObject.js
 function isPlainObject(value) {
-    if (typeof value !== 'object' || value === null) {
+    if (typeof value !== "object" || value === null) {
         return false;
     }
     if (Object.getPrototypeOf(value) === null) {

package/core/schemas/utils/maybeSkipValidation.d.ts

@@ -1,2 +1,2 @@
-import { BaseSchema } from '../Schema';
+import { BaseSchema } from "../Schema";
 export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/core/schemas/utils/maybeSkipValidation.js

@@ -12,12 +12,10 @@ function transformAndMaybeSkipValidation(transform) {
         if (!transformed.ok && skipValidation) {
             // eslint-disable-next-line no-console
             console.warn([
-                'Failed to validate.',
-                ...transformed.errors.map((error) => '  - ' +
-                    (error.path.length > 0
-                        ? `${error.path.join('.')}: ${error.message}`
-                        : error.message)),
-            ].join('\n'));
+                "Failed to validate.",
+                ...transformed.errors.map((error) => "  - " +
+                    (error.path.length > 0 ? `${error.path.join(".")}: ${error.message}` : error.message)),
+            ].join("\n"));
             return {
                 ok: true,
                 value: value,

package/core/utils/index.d.ts

@@ -0,0 +1 @@
+export { setObjectProperty } from "./setObjectProperty";

package/core/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setObjectProperty = void 0;
+var setObjectProperty_1 = require("./setObjectProperty");
+Object.defineProperty(exports, "setObjectProperty", { enumerable: true, get: function () { return setObjectProperty_1.setObjectProperty; } });

package/core/utils/setObjectProperty.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sets the value at path of object. If a portion of path doesn’t exist it’s created. This is
+ * inspired by Lodash's set function, but is simplified to accommodate our use case.
+ * For more details, see https://lodash.com/docs/4.17.15#set.
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @return Returns object.
+ */
+export declare function setObjectProperty<T extends object>(object: T, path: string, value: any): T;

package/core/utils/setObjectProperty.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setObjectProperty = void 0;
+/**
+ * Sets the value at path of object. If a portion of path doesn’t exist it’s created. This is
+ * inspired by Lodash's set function, but is simplified to accommodate our use case.
+ * For more details, see https://lodash.com/docs/4.17.15#set.
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @return Returns object.
+ */
+function setObjectProperty(object, path, value) {
+    if (object == null) {
+        return object;
+    }
+    const keys = path.split(".");
+    if (keys.length === 0) {
+        // Invalid path; do nothing.
+        return object;
+    }
+    let current = object;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (key == null) {
+            // Unreachable.
+            continue;
+        }
+        if (!current[key] || typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey == null) {
+        // Unreachable.
+        return object;
+    }
+    current[lastKey] = value;
+    return object;
+}
+exports.setObjectProperty = setObjectProperty;

package/core/websocket/events.js

@@ -10,15 +10,15 @@ class Event {
 exports.Event = Event;
 class ErrorEvent extends Event {
     constructor(error, target) {
-        super('error', target);
+        super("error", target);
         this.message = error.message;
         this.error = error;
     }
 }
 exports.ErrorEvent = ErrorEvent;
 class CloseEvent extends Event {
-    constructor(code = 1000, reason = '', target) {
-        super('close', target);
+    constructor(code = 1000, reason = "", target) {
+        super("close", target);
         this.wasClean = true;
         this.code = code;
         this.reason = reason;

package/core/websocket/index.d.ts

@@ -1 +1 @@
-export * from './ws';
+export * from "./ws";

package/core/websocket/ws.d.ts

@@ -1,4 +1,4 @@
-import * as Events from './events';
+import * as Events from "./events";
 export declare type Event = Events.Event;
 export declare type ErrorEvent = Events.ErrorEvent;
 export declare type CloseEvent = Events.CloseEvent;
@@ -17,10 +17,10 @@ export declare type Options = {
 export declare type UrlProvider = string | (() => string) | (() => Promise<string>);
 export declare type Message = string | ArrayBuffer | Blob | ArrayBufferView;
 export declare type ListenersMap = {
-    error: Array<Events.WebSocketEventListenerMap['error']>;
-    message: Array<Events.WebSocketEventListenerMap['message']>;
-    open: Array<Events.WebSocketEventListenerMap['open']>;
-    close: Array<Events.WebSocketEventListenerMap['close']>;
+    error: Array<Events.WebSocketEventListenerMap["error"]>;
+    message: Array<Events.WebSocketEventListenerMap["message"]>;
+    open: Array<Events.WebSocketEventListenerMap["open"]>;
+    close: Array<Events.WebSocketEventListenerMap["close"]>;
 };
 export declare class ReconnectingWebSocket {
     private _ws?;