@bedrockio/yada 1.2.9 → 1.4.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 1.4.0
+
+- Added object schema "require".
+- Added object schema "unwind" to get an inner array schema.
+- Added object schema "export" to allow object spreading.
+- "append" now handles handle deep fields.
+
+## 1.3.0
+
+- Added object schema "get".
+
 ## 1.2.9
 
 - Fixed field missing on empty strings.

package/README.md

@@ -331,7 +331,7 @@ const schema = yd
   .required();
 ```
 
-### Choosing Fields
+### Selecting Fields
 
 Object schemas also have a `pick` and `omit` method that allows custom field
 selection. These methods accept an array of field names or enumerated arguments:
@@ -350,6 +350,87 @@ schema.pick(['firstName', 'lastName']);
 schema.omit('firstName', 'lastName');
 ```
 
+To get a single field use the `get` method:
+
+```js
+const schema = yd.object({
+  profile: yd.object({
+    firstName: yd.string().required(),
+    lastName: yd.string().required(),
+  }),
+});
+
+// Gets the inner "profile" schema.
+schema.get('profile');
+
+// Gets just the "firstName" schema.
+schema.get('profile.firstName');
+
+// May also pass an array of path segments.
+schema.get(['profile', 'firstName']);
+```
+
+To get a nested array field use the `unwind` method:
+
+```js
+const schema = yd.object({
+  paymentMethods: yd.array(
+    yd.object({
+      brand: yd.string().allow('visa', 'mastercard'),
+      last4: yd.string().length(4),
+      expMonth: yd.number(),
+      expYear: yd.number(),
+    }),
+  ),
+});
+
+// Gets the inner "paymentMethods" object schema.
+// Will accept a single paymentMethod.
+schema.unwind('paymentMethods');
+```
+
+Compare `unwind` to `get` which would validate against an array instead of an
+object. Note that `unwind` only makes sense when there is exactly one inner
+schema and will error otherwise.
+
+### Augmenting Fields
+
+The `require` method allows augmentation of the schema to enforce specific
+fields:
+
+```js
+const schema = yd.object({
+  email: yd.string().email().required(),
+  phone: yd.string().phone(),
+  dob: yd.date(),
+});
+
+// For example a schema for a signup flow that
+// requires more fields for normal users than admins.
+const signupSchema = schema.require('phone', 'dob');
+
+// Also accepts an array.
+schema.require(['phone', 'dob']);
+```
+
+Note that there is no way to "unrequire" a field. The idea is to start with the
+minimal schema as a base and lock down more from there.
+
+### Merging Fields
+
+The [append](#append) method merges object schemas together, however it
+preserves custom and required assertions on the object itself which is not
+always desired. It also lacks the elegance of the spread operator. For this the
+`export` method is provided which will simply export the schema's fields as an
+object:
+
+```js
+const newSchema = yd.object({
+  ...schema1.export(),
+  ...schema2.export(),
+});
+```
+
 ## Date
 
 Dates are similar to the basic types with the exception that in addition to date
@@ -448,6 +529,10 @@ const schema2 = yd.object({
 const schema = schema1.append(schema2);
 ```
 
+Note however that this preserves custom and required assertions on the object
+itself. To simply merge fields as an object use the [export](#merging-fields)
+method instead.
+
 ### Custom
 
 The `custom` schema allows for custom validations expressed in code. A custom
@@ -727,7 +812,7 @@ The delimiter can be customized with the `delimiter` option:
 console.info(
   error.getFullMessage({
     delimiter: '\n',
-  })
+  }),
 );
 // "email" is required
 // "lastName" is required
@@ -740,7 +825,7 @@ labels:
 console.info(
   error.getFullMessage({
     natural: true,
-  })
+  }),
 );
 // "Email" is required
 // "Last Name" is required

package/dist/cjs/Schema.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 exports.isSchema = isSchema;
+var _lodashEs = require("lodash-es");
 var _errors = require("./errors");
-var _utils = require("./utils");
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform', 'empty'];
 const REQUIRED_TYPES = ['default', 'required', 'missing'];
 class Schema {
@@ -151,7 +151,6 @@ class Schema {
   async validate(value, options = {}) {
     let details = [];
     options = {
-      root: value,
       ...options,
       ...this.meta,
       original: value
@@ -204,7 +203,7 @@ class Schema {
 
   /**
    * Appends another schema. [Link](https://github.com/bedrockio/yada#append)
-   * @returns {this}
+   * @returns {Schema}
    */
   append(schema) {
     const merged = this.clone(schema.meta);
@@ -274,6 +273,12 @@ class Schema {
   inspect() {
     return JSON.stringify(this.toOpenApi(), null, 2);
   }
+  get() {
+    const {
+      name
+    } = this.constructor;
+    throw new Error(`"get" not implemented by ${name}.`);
+  }
 
   // Private
 
@@ -302,7 +307,7 @@ class Schema {
               // Must not pass cast option down when allowing
               // other schema types as they may be allowed, for
               // example allowing a string or array of strings.
-              options = (0, _utils.omit)(options, 'cast');
+              options = (0, _lodashEs.omit)(options, 'cast');
               return await el.validate(val, options);
             } catch (err) {
               const [first] = err.details;

package/dist/cjs/array.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
+var _lodashEs = require("lodash-es");
 var _Schema = _interopRequireDefault(require("./Schema"));
 var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
 var _errors = require("./errors");
-var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class ArraySchema extends _TypeSchema.default {
   constructor(schemas) {
@@ -42,7 +42,7 @@ class ArraySchema extends _TypeSchema.default {
           try {
             // Allow enum message to take
             // precedence over generic array message.
-            options = (0, _utils.omit)(options, 'message');
+            options = (0, _lodashEs.omit)(options, 'message');
             result.push(await schema.validate(el, options));
           } catch (error) {
             errors.push(new _errors.ElementError(message, i, error.details));

package/dist/cjs/date.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = _default;
 var _validator = _interopRequireDefault(require("validator"));
-var _errors = require("./errors");
 var _Schema = _interopRequireDefault(require("./Schema"));
+var _errors = require("./errors");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class DateSchema extends _Schema.default {
   constructor() {
@@ -32,7 +32,6 @@ class DateSchema extends _Schema.default {
     return this.clone().assert('min', date => {
       if (date < min) {
         throw new _errors.LocalizedError('Must be after {date}.', {
-          // @ts-ignore
           date: min.toISOString()
         });
       }
@@ -47,7 +46,6 @@ class DateSchema extends _Schema.default {
     return this.clone().assert('max', date => {
       if (date > max) {
         throw new _errors.LocalizedError('Must be before {date}.', {
-          // @ts-ignore
           date: max.toISOString()
         });
       }
@@ -62,7 +60,6 @@ class DateSchema extends _Schema.default {
     return this.clone().assert('before', date => {
       if (date >= max) {
         throw new _errors.LocalizedError('Must be before {date}.', {
-          // @ts-ignore
           date: max.toISOString()
         });
       }
@@ -77,7 +74,6 @@ class DateSchema extends _Schema.default {
     return this.clone().assert('after', date => {
       if (date <= min) {
         throw new _errors.LocalizedError('Must be after {date}.', {
-          // @ts-ignore
           date: min.toISOString()
         });
       }

package/dist/cjs/index.js

@@ -40,13 +40,13 @@ Object.defineProperty(exports, "getLocalizedMessages", {
 Object.defineProperty(exports, "isSchema", {
   enumerable: true,
   get: function () {
-    return _utils.isSchema;
+    return _Schema.isSchema;
   }
 });
 Object.defineProperty(exports, "isSchemaError", {
   enumerable: true,
   get: function () {
-    return _utils.isSchemaError;
+    return _errors.isSchemaError;
   }
 });
 Object.defineProperty(exports, "number", {
@@ -87,10 +87,11 @@ var _date = _interopRequireDefault(require("./date"));
 var _object = _interopRequireDefault(require("./object"));
 var _array = _interopRequireDefault(require("./array"));
 var _tuple = _interopRequireDefault(require("./tuple"));
-var _Schema = _interopRequireDefault(require("./Schema"));
-var _utils = require("./utils");
+var _Schema = _interopRequireWildcard(require("./Schema"));
 var _localization = require("./localization");
 var _errors = require("./errors");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Accepts anything.
@@ -132,8 +133,8 @@ var _default = {
   allow,
   reject,
   custom,
-  isSchema: _utils.isSchema,
-  isSchemaError: _utils.isSchemaError,
+  isSchema: _Schema.isSchema,
+  isSchemaError: _errors.isSchemaError,
   useLocalizer: _localization.useLocalizer,
   getLocalizedMessages: _localization.getLocalizedMessages,
   LocalizedError: _errors.LocalizedError

package/dist/cjs/object.js

@@ -4,25 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
+var _lodashEs = require("lodash-es");
 var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
 var _errors = require("./errors");
-var _utils = require("./utils");
 var _Schema = _interopRequireWildcard(require("./Schema"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const BASE_ASSERTIONS = ['type', 'transform', 'field'];
+const APPEND_ASSERTION_TYPES = ['required', 'type', 'custom'];
 
 /**
  * @typedef {{ [key: string]: Schema } | {}} SchemaMap
  */
 
 class ObjectSchema extends _TypeSchema.default {
-  constructor(fields, meta) {
-    super(Object, {
-      ...meta,
-      fields
-    });
+  constructor(meta) {
+    super(Object, meta);
     this.setup();
   }
   setup() {
@@ -60,14 +57,15 @@ class ObjectSchema extends _TypeSchema.default {
         return result;
       }
     });
-    for (let [key, schema] of Object.entries(this.getFields())) {
+    for (let [key, schema] of Object.entries(this.export())) {
       if (!(0, _Schema.isSchema)(schema)) {
-        throw new Error(`Key "${key}" must be a schema`);
+        throw new Error(`Key "${key}" must be a schema.`);
       }
       this.assert('field', async (obj, options) => {
         if (obj) {
           const {
-            path = []
+            path = [],
+            original
           } = options;
           const {
             strip,
@@ -86,12 +84,16 @@ class ObjectSchema extends _TypeSchema.default {
           try {
             // Do not pass down message into validators
             // to allow custom messages to take precedence.
-            options = (0, _utils.omit)(options, 'message');
+            options = (0, _lodashEs.omit)(options, 'message');
             const result = await schema.validate(val, {
               ...options,
-              // Re-pass the object as root here as its fields
-              // may have been transformed by defaults.
-              root: obj
+              // The root object may have been transformed here
+              // by defaults or values returned by custom functions
+              // so re-pass it here.
+              root: obj,
+              // The original root represents the root object
+              // before it was transformed.
+              originalRoot: original
             });
             if (result !== undefined) {
               return {
@@ -109,73 +111,156 @@ class ObjectSchema extends _TypeSchema.default {
       });
     }
   }
-  getFields() {
-    return this.meta.fields || {};
-  }
 
   /**
-   * @param {SchemaMap|Schema} arg Object or schema to append.
+   * Gets the schema for the given field. Deep fields accept
+   * either a string using dot syntax or an array representing
+   * the path.
+   *
+   * @param {string|Array<string>} [path] The path of the field.
    */
-  // @ts-ignore
-  append(arg) {
-    let schema;
-    if (arg instanceof ObjectSchema) {
-      schema = arg;
-    } else if (arg instanceof _Schema.default) {
-      // If the schema is of a different type then
-      // simply append it and don't merge fields.
-      return super.append(arg);
+  get(path) {
+    const {
+      fields
+    } = this.meta;
+    if (!fields) {
+      throw new Error('Cannot select field on an open object schema.');
+    }
+    path = Array.isArray(path) ? path : path.split('.');
+    const [name, ...rest] = path;
+    const schema = fields[name];
+    if (!schema) {
+      throw new Error(`Cannot find field "${name}".`);
+    }
+    if (rest.length) {
+      return schema.get(rest);
     } else {
-      schema = new ObjectSchema(arg);
+      return schema;
     }
-    const fields = {
-      ...this.meta.fields,
-      ...schema.meta.fields
-    };
-    const merged = new ObjectSchema(fields, {
-      ...this.meta,
-      ...schema.meta
-    });
-    const assertions = [...this.assertions, ...schema.assertions];
-    for (let assertion of assertions) {
-      const {
-        type
-      } = assertion;
-      if (!BASE_ASSERTIONS.includes(type)) {
-        merged.pushAssertion(assertion);
-      }
+  }
+
+  /**
+   * Returns the inner schema of an array field. This only makes
+   * sense if the array field holds a single schema, so all other
+   * scenarios will throw an error.
+   *
+   * @param {string|Array<string>} [path] The path of the field.
+   */
+  unwind(path) {
+    path = Array.isArray(path) ? path.join('.') : path;
+    const field = this.get(path);
+    const {
+      schemas
+    } = field.meta;
+    if (!schemas) {
+      throw new Error(`Field "${path}" is not an array schema.`);
+    } else if (schemas.length !== 1) {
+      throw new Error(`Field "${path}" should contain only one schema.`);
     }
-    return merged;
+    return schemas[0];
   }
 
   /**
+   * Returns a new schema that only validates the selected fields.
+   *
    * @param {...string} [names] Names to include.
    */
   pick(...names) {
     if (Array.isArray(names[0])) {
       names = names[0];
     }
-    const fields = (0, _utils.pick)(this.meta.fields, names);
-    return new ObjectSchema(fields, {
-      ...this.meta
+    return new ObjectSchema({
+      fields: (0, _lodashEs.pick)(this.meta.fields, names)
     });
   }
 
   /**
+   * Returns a new schema that omits fields.
+   *
    * @param {...string} [names] Names to exclude.
    */
   omit(...names) {
     if (Array.isArray(names[0])) {
       names = names[0];
     }
-    const fields = (0, _utils.omit)(this.meta.fields, names);
-    return new ObjectSchema(fields, {
-      ...this.meta
+    return new ObjectSchema({
+      fields: (0, _lodashEs.omit)(this.meta.fields, names)
+    });
+  }
+
+  /**
+   * Augments the object schema to make fields required.
+   * Field names may be passed as an array or arguments.
+   * Field names may be deep using dot syntax.
+   *
+   * @param {...string} fields
+   * @param {Array<string>} fields
+   */
+  require(...fields) {
+    if (!fields.length) {
+      throw new Error('No fields specified.');
+    }
+    if (Array.isArray(fields[0])) {
+      fields = fields[0];
+    }
+    const update = {};
+    for (let field of fields) {
+      (0, _lodashEs.set)(update, field, this.get(field).required());
+    }
+    return this.append(update);
+  }
+
+  /**
+   * Returns the schema's fields as an object allowing them
+   * to be "spread" to create new schemas. Note that doing
+   * this will mean that custom and required assertions will
+   * not be preserved. Compare to {@link append} which
+   * preserves all assertions on the base schema.
+   */
+  export() {
+    return this.meta.fields || {};
+  }
+
+  /**
+   * Appends another schema and returns a new one. Appended
+   * schemas may have nested fields. Note that custom and
+   * required assertions on the schemas are preserved. This
+   * means that if either object schema is required then the
+   * resulting merged schema will also be required. Compare
+   * to {@link export} which exports the fields as an object.
+   *
+   * @param {SchemaMap|Schema} arg Object or schema to append.
+   */
+  append(arg) {
+    let meta;
+    let assertions = [...this.assertions];
+    if (arg instanceof _Schema.default) {
+      meta = arg.meta;
+      assertions = [...assertions, ...arg.assertions];
+    } else {
+      meta = {
+        fields: arg
+      };
+    }
+    const fields = mergeFields(this.meta.fields, meta?.fields);
+    const schema = new ObjectSchema({
+      ...this.meta,
+      ...meta,
+      fields
     });
+    for (let assertion of assertions) {
+      const {
+        type
+      } = assertion;
+      if (APPEND_ASSERTION_TYPES.includes(type)) {
+        schema.pushAssertion(assertion);
+      }
+    }
+    return schema;
   }
   toOpenApi(extra) {
     const properties = {};
-    for (let [key, schema] of Object.entries(this.getFields())) {
+    for (let [key, schema] of Object.entries(this.export())) {
       properties[key] = schema.toOpenApi(extra);
     }
     return {
@@ -207,6 +292,24 @@ function expandDotProperties(obj) {
   }
   return result;
 }
+function mergeFields(aFields, bFields) {
+  if (!aFields || !bFields) {
+    return aFields || bFields;
+  }
+  const result = {
+    ...aFields
+  };
+  for (let key of Object.keys(bFields)) {
+    const aSchema = aFields[key];
+    const bSchema = bFields[key];
+    if (aSchema instanceof ObjectSchema) {
+      result[key] = aSchema.append(bSchema);
+    } else {
+      result[key] = bSchema;
+    }
+  }
+  return result;
+}
 
 /**
  * Creates an [object schema](https://github.com/bedrockio/yada#object).
@@ -216,5 +319,7 @@ function expandDotProperties(obj) {
  * empty object is passed then no keys will be allowed.
  */
 function _default(map) {
-  return new ObjectSchema(map);
+  return new ObjectSchema({
+    fields: map
+  });
 }

package/eslint.config.js

@@ -0,0 +1,3 @@
+import { jest, recommended, nodeImports } from '@bedrockio/eslint-plugin';
+
+export default [jest, recommended, nodeImports];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/yada",
-  "version": "1.2.9",
+  "version": "1.4.0",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",
@@ -17,19 +17,19 @@
   "author": "Andrew Plummer <plummer.andrew@gmail.com>",
   "license": "MIT",
   "dependencies": {
+    "lodash-es": "^4.17.21",
     "validator": "^13.9.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.20.7",
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
+    "@bedrockio/eslint-plugin": "^1.1.7",
     "@bedrockio/prettier-config": "^1.0.2",
     "babel-plugin-add-module-exports": "^1.0.4",
-    "eslint": "^8.26.0",
-    "eslint-plugin-bedrock": "^1.0.24",
+    "eslint": "^9.19.0",
     "jest": "^29.6.2",
-    "prettier": "^2.7.1",
-    "prettier-eslint": "^15.0.1",
+    "prettier": "^3.4.2",
     "typescript": "^5.7.2"
   },
   "prettier": "@bedrockio/prettier-config",

package/src/Schema.js

@@ -1,3 +1,5 @@
+import { omit } from 'lodash-es';
+
 import {
   TypeError,
   FormatError,
@@ -6,7 +8,6 @@ import {
   LocalizedError,
   ValidationError,
 } from './errors';
-import { omit } from './utils';
 
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform', 'empty'];
 const REQUIRED_TYPES = ['default', 'required', 'missing'];
@@ -143,7 +144,6 @@ export default class Schema {
     let details = [];
 
     options = {
-      root: value,
       ...options,
       ...this.meta,
       original: value,
@@ -194,7 +194,7 @@ export default class Schema {
 
   /**
    * Appends another schema. [Link](https://github.com/bedrockio/yada#append)
-   * @returns {this}
+   * @returns {Schema}
    */
   append(schema) {
     const merged = this.clone(schema.meta);
@@ -257,6 +257,11 @@ export default class Schema {
     return JSON.stringify(this.toOpenApi(), null, 2);
   }
 
+  get() {
+    const { name } = this.constructor;
+    throw new Error(`"get" not implemented by ${name}.`);
+  }
+
   // Private
 
   /**

package/src/array.js

@@ -1,7 +1,8 @@
+import { omit } from 'lodash-es';
+
 import Schema from './Schema';
 import TypeSchema from './TypeSchema';
 import { ArrayError, ElementError, LocalizedError } from './errors';
-import { omit } from './utils';
 
 class ArraySchema extends TypeSchema {
   constructor(schemas) {
@@ -82,7 +83,7 @@ class ArraySchema extends TypeSchema {
           {
             length,
             s,
-          }
+          },
         );
       }
     });

package/src/date.js

@@ -1,7 +1,7 @@
 import validator from 'validator';
-import { LocalizedError } from './errors';
 
 import Schema from './Schema';
+import { LocalizedError } from './errors';
 
 class DateSchema extends Schema {
   constructor() {
@@ -24,7 +24,6 @@ class DateSchema extends Schema {
     return this.clone().assert('min', (date) => {
       if (date < min) {
         throw new LocalizedError('Must be after {date}.', {
-          // @ts-ignore
           date: min.toISOString(),
         });
       }
@@ -39,7 +38,6 @@ class DateSchema extends Schema {
     return this.clone().assert('max', (date) => {
       if (date > max) {
         throw new LocalizedError('Must be before {date}.', {
-          // @ts-ignore
           date: max.toISOString(),
         });
       }
@@ -54,7 +52,6 @@ class DateSchema extends Schema {
     return this.clone().assert('before', (date) => {
       if (date >= max) {
         throw new LocalizedError('Must be before {date}.', {
-          // @ts-ignore
           date: max.toISOString(),
         });
       }
@@ -69,7 +66,6 @@ class DateSchema extends Schema {
     return this.clone().assert('after', (date) => {
       if (date <= min) {
         throw new LocalizedError('Must be after {date}.', {
-          // @ts-ignore
           date: min.toISOString(),
         });
       }
@@ -118,7 +114,7 @@ class DateSchema extends Schema {
         if (typeof original !== 'number' && !options.default) {
           throw new LocalizedError('Must be a timestamp in milliseconds.');
         }
-      }
+      },
     );
   }
 
@@ -134,7 +130,7 @@ class DateSchema extends Schema {
         } else {
           return new Date(original * 1000);
         }
-      }
+      },
     );
   }
 

package/src/index.js

@@ -7,10 +7,12 @@ import array from './array';
 import tuple from './tuple';
 
 import Schema from './Schema';
-import { isSchema, isSchemaError } from './utils';
 import { useLocalizer, getLocalizedMessages } from './localization';
 import { LocalizedError } from './errors';
 
+import { isSchema } from './Schema';
+import { isSchemaError } from './errors';
+
 /**
  * Accepts anything.
  */

package/src/object.js

@@ -1,17 +1,18 @@
+import { set, pick, omit } from 'lodash-es';
+
 import TypeSchema from './TypeSchema';
 import { FieldError, LocalizedError } from './errors';
-import { pick, omit } from './utils';
 import Schema, { isSchema } from './Schema';
 
-const BASE_ASSERTIONS = ['type', 'transform', 'field'];
+const APPEND_ASSERTION_TYPES = ['required', 'type', 'custom'];
 
 /**
  * @typedef {{ [key: string]: Schema } | {}} SchemaMap
  */
 
 class ObjectSchema extends TypeSchema {
-  constructor(fields, meta) {
-    super(Object, { ...meta, fields });
+  constructor(meta) {
+    super(Object, meta);
     this.setup();
   }
 
@@ -46,13 +47,13 @@ class ObjectSchema extends TypeSchema {
         return result;
       }
     });
-    for (let [key, schema] of Object.entries(this.getFields())) {
+    for (let [key, schema] of Object.entries(this.export())) {
       if (!isSchema(schema)) {
-        throw new Error(`Key "${key}" must be a schema`);
+        throw new Error(`Key "${key}" must be a schema.`);
       }
       this.assert('field', async (obj, options) => {
         if (obj) {
-          const { path = [] } = options;
+          const { path = [], original } = options;
           const { strip, required } = schema.meta;
           const val = obj[key];
 
@@ -72,9 +73,13 @@ class ObjectSchema extends TypeSchema {
             options = omit(options, 'message');
             const result = await schema.validate(val, {
               ...options,
-              // Re-pass the object as root here as its fields
-              // may have been transformed by defaults.
+              // The root object may have been transformed here
+              // by defaults or values returned by custom functions
+              // so re-pass it here.
               root: obj,
+              // The original root represents the root object
+              // before it was transformed.
+              originalRoot: original,
             });
             if (result !== undefined) {
               return {
@@ -91,78 +96,162 @@ class ObjectSchema extends TypeSchema {
     }
   }
 
-  getFields() {
-    return this.meta.fields || {};
-  }
-
   /**
-   * @param {SchemaMap|Schema} arg Object or schema to append.
+   * Gets the schema for the given field. Deep fields accept
+   * either a string using dot syntax or an array representing
+   * the path.
+   *
+   * @param {string|Array<string>} [path] The path of the field.
    */
-  // @ts-ignore
-  append(arg) {
-    let schema;
-    if (arg instanceof ObjectSchema) {
-      schema = arg;
-    } else if (arg instanceof Schema) {
-      // If the schema is of a different type then
-      // simply append it and don't merge fields.
-      return super.append(arg);
-    } else {
-      schema = new ObjectSchema(arg);
+  get(path) {
+    const { fields } = this.meta;
+    if (!fields) {
+      throw new Error('Cannot select field on an open object schema.');
     }
 
-    const fields = {
-      ...this.meta.fields,
-      ...schema.meta.fields,
-    };
+    path = Array.isArray(path) ? path : path.split('.');
 
-    const merged = new ObjectSchema(fields, {
-      ...this.meta,
-      ...schema.meta,
-    });
+    const [name, ...rest] = path;
+    const schema = fields[name];
 
-    const assertions = [...this.assertions, ...schema.assertions];
-    for (let assertion of assertions) {
-      const { type } = assertion;
-      if (!BASE_ASSERTIONS.includes(type)) {
-        merged.pushAssertion(assertion);
-      }
+    if (!schema) {
+      throw new Error(`Cannot find field "${name}".`);
     }
 
-    return merged;
+    if (rest.length) {
+      return schema.get(rest);
+    } else {
+      return schema;
+    }
   }
 
   /**
+   * Returns the inner schema of an array field. This only makes
+   * sense if the array field holds a single schema, so all other
+   * scenarios will throw an error.
+   *
+   * @param {string|Array<string>} [path] The path of the field.
+   */
+  unwind(path) {
+    path = Array.isArray(path) ? path.join('.') : path;
+    const field = this.get(path);
+    const { schemas } = field.meta;
+    if (!schemas) {
+      throw new Error(`Field "${path}" is not an array schema.`);
+    } else if (schemas.length !== 1) {
+      throw new Error(`Field "${path}" should contain only one schema.`);
+    }
+    return schemas[0];
+  }
+
+  /**
+   * Returns a new schema that only validates the selected fields.
+   *
    * @param {...string} [names] Names to include.
    */
   pick(...names) {
     if (Array.isArray(names[0])) {
       names = names[0];
     }
-    const fields = pick(this.meta.fields, names);
-
-    return new ObjectSchema(fields, {
-      ...this.meta,
+    return new ObjectSchema({
+      fields: pick(this.meta.fields, names),
     });
   }
 
   /**
+   * Returns a new schema that omits fields.
+   *
    * @param {...string} [names] Names to exclude.
    */
   omit(...names) {
     if (Array.isArray(names[0])) {
       names = names[0];
     }
-    const fields = omit(this.meta.fields, names);
+    return new ObjectSchema({
+      fields: omit(this.meta.fields, names),
+    });
+  }
+
+  /**
+   * Augments the object schema to make fields required.
+   * Field names may be passed as an array or arguments.
+   * Field names may be deep using dot syntax.
+   *
+   * @param {...string} fields
+   * @param {Array<string>} fields
+   */
+  require(...fields) {
+    if (!fields.length) {
+      throw new Error('No fields specified.');
+    }
+
+    if (Array.isArray(fields[0])) {
+      fields = fields[0];
+    }
+
+    const update = {};
+    for (let field of fields) {
+      set(update, field, this.get(field).required());
+    }
+
+    return this.append(update);
+  }
+
+  /**
+   * Returns the schema's fields as an object allowing them
+   * to be "spread" to create new schemas. Note that doing
+   * this will mean that custom and required assertions will
+   * not be preserved. Compare to {@link append} which
+   * preserves all assertions on the base schema.
+   */
+  export() {
+    return this.meta.fields || {};
+  }
+
+  /**
+   * Appends another schema and returns a new one. Appended
+   * schemas may have nested fields. Note that custom and
+   * required assertions on the schemas are preserved. This
+   * means that if either object schema is required then the
+   * resulting merged schema will also be required. Compare
+   * to {@link export} which exports the fields as an object.
+   *
+   * @param {SchemaMap|Schema} arg Object or schema to append.
+   */
+  append(arg) {
+    let meta;
+    let assertions = [...this.assertions];
+
+    if (arg instanceof Schema) {
+      meta = arg.meta;
+      assertions = [...assertions, ...arg.assertions];
+    } else {
+      meta = {
+        fields: arg,
+      };
+    }
 
-    return new ObjectSchema(fields, {
+    const fields = mergeFields(this.meta.fields, meta?.fields);
+
+    const schema = new ObjectSchema({
       ...this.meta,
+      ...meta,
+      fields,
     });
+
+    for (let assertion of assertions) {
+      const { type } = assertion;
+      if (APPEND_ASSERTION_TYPES.includes(type)) {
+        schema.pushAssertion(assertion);
+      }
+    }
+
+    return schema;
   }
 
   toOpenApi(extra) {
     const properties = {};
-    for (let [key, schema] of Object.entries(this.getFields())) {
+    for (let [key, schema] of Object.entries(this.export())) {
       properties[key] = schema.toOpenApi(extra);
     }
     return {
@@ -196,6 +285,24 @@ function expandDotProperties(obj) {
   return result;
 }
 
+function mergeFields(aFields, bFields) {
+  if (!aFields || !bFields) {
+    return aFields || bFields;
+  }
+  const result = { ...aFields };
+  for (let key of Object.keys(bFields)) {
+    const aSchema = aFields[key];
+    const bSchema = bFields[key];
+
+    if (aSchema instanceof ObjectSchema) {
+      result[key] = aSchema.append(bSchema);
+    } else {
+      result[key] = bSchema;
+    }
+  }
+  return result;
+}
+
 /**
  * Creates an [object schema](https://github.com/bedrockio/yada#object).
  *
@@ -204,5 +311,7 @@ function expandDotProperties(obj) {
  * empty object is passed then no keys will be allowed.
  */
 export default function (map) {
-  return new ObjectSchema(map);
+  return new ObjectSchema({
+    fields: map,
+  });
 }

package/src/password.js

@@ -38,22 +38,22 @@ export function validateLength(expected) {
 
 export const validateLowercase = validateRegex(
   LOWER_REG,
-  'Must contain at least {length} lowercase character{s}.'
+  'Must contain at least {length} lowercase character{s}.',
 );
 
 export const validateUppercase = validateRegex(
   UPPER_REG,
-  'Must contain at least {length} uppercase character{s}.'
+  'Must contain at least {length} uppercase character{s}.',
 );
 
 export const validateNumbers = validateRegex(
   NUMBER_REG,
-  'Must contain at least {length} number{s}.'
+  'Must contain at least {length} number{s}.',
 );
 
 export const validateSymbols = validateRegex(
   SYMBOL_REG,
-  'Must contain at least {length} symbol{s}.'
+  'Must contain at least {length} symbol{s}.',
 );
 
 function validateRegex(reg, message) {

package/src/string.js

@@ -1,4 +1,5 @@
 import validator from 'validator';
+
 import TypeSchema from './TypeSchema';
 import { LocalizedError } from './errors';
 import {
@@ -412,7 +413,7 @@ class StringSchema extends TypeSchema {
           return;
         }
         fn(val, options);
-      }
+      },
     );
   }
 

package/types/Schema.d.ts

@@ -68,9 +68,9 @@ export default class Schema {
     clone(meta: any): this;
     /**
      * Appends another schema. [Link](https://github.com/bedrockio/yada#append)
-     * @returns {this}
+     * @returns {Schema}
      */
-    append(schema: any): this;
+    append(schema: any): Schema;
     toOpenApi(extra: any): any;
     getAnyType(): {
         type: string[];
@@ -85,6 +85,7 @@ export default class Schema {
     };
     expandExtra(extra?: {}): {};
     inspect(): string;
+    get(): void;
     /**
      * @returns {this}
      */

package/types/Schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AA+ZA,kDAEC;AApZD;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;OAEG;IACH,YAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,YAFa,IAAI,CAIhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,gBAFa,IAAI,CAShB;IAED;;OAEG;IACH,+BAFa,IAAI,CAMhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED,iDAyCC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAMhB;IAED,2BAYC;IAED;;MAOC;IAED;;;;MASC;IAED;;MAOC;IAED,4BAMC;IAED,kBAEC;IAID;;OAEG;IACH,kCAFa,IAAI,CAiDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED,gEAQC;IAED;;OAEG;IACH,oBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAYC;IAED,qBAsCC;CACF"}
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAoaA,kDAEC;AAxZD;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;OAEG;IACH,YAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,YAFa,IAAI,CAIhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,gBAFa,IAAI,CAShB;IAED;;OAEG;IACH,+BAFa,IAAI,CAMhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED,iDAwCC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,MAAM,CAMlB;IAED,2BAYC;IAED;;MAOC;IAED;;;;MASC;IAED;;MAOC;IAED,4BAMC;IAED,kBAEC;IAED,YAGC;IAID;;OAEG;IACH,kCAFa,IAAI,CAiDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED,gEAQC;IAED;;OAEG;IACH,oBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAYC;IAED,qBAsCC;CACF"}

package/types/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AAoIA;;;;;;;GAOG;AACH,8CALc,MAAM,EAAA,eAUnB;mBAjJkB,UAAU;AAK7B;IACE,0BAGC;IAED,cAsCC;IAED,0BAUC;IAED,uBAUC;IAED,uBAaC;IAED,eAaC;IAED,mBAEC;CAuBF;uBAjIsB,cAAc"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AAqIA;;;;;;;GAOG;AACH,8CALc,MAAM,EAAA,eAUnB;mBAhJkB,UAAU;AAI7B;IACE,0BAGC;IAED,cAsCC;IAED,0BAUC;IAED,uBAUC;IAED,uBAaC;IAED,eAaC;IAED,mBAEC;CAuBF;uBAhIsB,cAAc"}

package/types/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../src/date.js"],"names":[],"mappings":"AAoKA;;GAEG;AACH,+CAEC;AApKD;IACE,cAUC;IAED;;OAEG;IACH,SAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAY5B;IAED;;OAEG;IACH,SAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAY5B;IAED;;OAEG;IACH,YAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAY5B;IAED;;OAEG;IACH,WAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAY5B;IAED,aAOC;IAED,eAOC;IAED;;OAEG;IACH,aAFW,MAAM,GAAG,WAAW,QAa9B;IAED,kBAUC;IAED,aAcC;CAwBF;mBA/JkB,UAAU"}
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../src/date.js"],"names":[],"mappings":"AAgKA;;GAEG;AACH,+CAEC;AAhKD;IACE,cAUC;IAED;;OAEG;IACH,SAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAW5B;IAED;;OAEG;IACH,SAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAW5B;IAED;;OAEG;IACH,YAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAW5B;IAED;;OAEG;IACH,WAFW,MAAM,GAAC,MAAM,GAAC,IAAI,QAW5B;IAED,aAOC;IAED,eAOC;IAED;;OAEG;IACH,aAFW,MAAM,GAAG,WAAW,QAa9B;IAED,kBAUC;IAED,aAcC;CAwBF;mBA5JkB,UAAU"}

package/types/index.d.ts

@@ -41,8 +41,8 @@ export function reject(...args: any[]): Schema;
  * @param {Function} fn
  */
 export function custom(fn: Function): Schema;
-import { isSchema } from './utils';
-import { isSchemaError } from './utils';
+import { isSchema } from './Schema';
+import { isSchemaError } from './errors';
 import { useLocalizer } from './localization';
 import { getLocalizedMessages } from './localization';
 import { LocalizedError } from './errors';

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;kBAKkB,SAAS;oBAHP,WAAW;iBACd,QAAQ;mBAFN,UAAU;mBAGV,UAAU;mBAJV,UAAU;kBAMX,SAAS;AAO3B;;GAEG;AACH,8BAEC;AAED;;GAEG;AACH,8CAEC;AAED;;GAEG;AACH,+CAEC;AAED;;;GAGG;AACH,6CAEC;yBA/BuC,SAAS;8BAAT,SAAS;6BACE,gBAAgB;qCAAhB,gBAAgB;+BACpC,UAAU;mBAHtB,UAAU"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;kBAKkB,SAAS;oBAHP,WAAW;iBACd,QAAQ;mBAFN,UAAU;mBAGV,UAAU;mBAJV,UAAU;kBAMX,SAAS;AAS3B;;GAEG;AACH,8BAEC;AAED;;GAEG;AACH,8CAEC;AAED;;GAEG;AACH,+CAEC;AAED;;;GAGG;AACH,6CAEC;yBA9BwB,UAAU;8BACL,UAAU;6BAJW,gBAAgB;qCAAhB,gBAAgB;+BACpC,UAAU;mBAFtB,UAAU"}

package/types/object.d.ts

@@ -13,20 +13,64 @@ export type SchemaMap = {
  * @typedef {{ [key: string]: Schema } | {}} SchemaMap
  */
 declare class ObjectSchema extends TypeSchema {
+    constructor(meta: any);
     setup(): void;
-    getFields(): any;
     /**
-     * @param {SchemaMap|Schema} arg Object or schema to append.
+     * Gets the schema for the given field. Deep fields accept
+     * either a string using dot syntax or an array representing
+     * the path.
+     *
+     * @param {string|Array<string>} [path] The path of the field.
      */
-    append(arg: SchemaMap | Schema): ObjectSchema;
+    get(path?: string | Array<string>): any;
+    /**
+     * Returns the inner schema of an array field. This only makes
+     * sense if the array field holds a single schema, so all other
+     * scenarios will throw an error.
+     *
+     * @param {string|Array<string>} [path] The path of the field.
+     */
+    unwind(path?: string | Array<string>): any;
     /**
+     * Returns a new schema that only validates the selected fields.
+     *
      * @param {...string} [names] Names to include.
      */
     pick(...names?: string[]): ObjectSchema;
     /**
+     * Returns a new schema that omits fields.
+     *
      * @param {...string} [names] Names to exclude.
      */
     omit(...names?: string[]): ObjectSchema;
+    /**
+     * Augments the object schema to make fields required.
+     * Field names may be passed as an array or arguments.
+     * Field names may be deep using dot syntax.
+     *
+     * @param {...string} fields
+     * @param {Array<string>} fields
+     */
+    require(...fields: string[]): ObjectSchema;
+    /**
+     * Returns the schema's fields as an object allowing them
+     * to be "spread" to create new schemas. Note that doing
+     * this will mean that custom and required assertions will
+     * not be preserved. Compare to {@link append} which
+     * preserves all assertions on the base schema.
+     */
+    export(): any;
+    /**
+     * Appends another schema and returns a new one. Appended
+     * schemas may have nested fields. Note that custom and
+     * required assertions on the schemas are preserved. This
+     * means that if either object schema is required then the
+     * resulting merged schema will also be required. Compare
+     * to {@link export} which exports the fields as an object.
+     *
+     * @param {SchemaMap|Schema} arg Object or schema to append.
+     */
+    append(arg: SchemaMap | Schema): ObjectSchema;
 }
 import Schema from './Schema';
 import TypeSchema from './TypeSchema';

package/types/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AAsMA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAMnB;wBAvMY;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,EAAE;AAD3C;;GAEG;AAEH;IAME,cA0EC;IAED,iBAEC;IAED;;OAEG;IAEH,YAHW,SAAS,GAAC,MAAM,gBAkC1B;IAED;;OAEG;IACH,gBAFc,MAAM,EAAA,gBAWnB;IAED;;OAEG;IACH,gBAFc,MAAM,EAAA,gBAWnB;CAcF;mBA3KgC,UAAU;uBAHpB,cAAc"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AAiTA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAQnB;wBAnTY;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,EAAE;AAD3C;;GAEG;AAEH;IACE,uBAGC;IAED,cA8EC;IAED;;;;;;OAMG;IACH,WAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAsB9B;IAED;;;;;;OAMG;IACH,cAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAY9B;IAED;;;;OAIG;IACH,gBAFc,MAAM,EAAA,gBASnB;IAED;;;;OAIG;IACH,gBAFc,MAAM,EAAA,gBASnB;IAED;;;;;;;OAOG;IACH,mBAHc,MAAM,EAAA,gBAkBnB;IAED;;;;;;OAMG;IACH,cAEC;IAED;;;;;;;;;OASG;IACH,YAFW,SAAS,GAAC,MAAM,gBA+B1B;CAcF;mBAnQgC,UAAU;uBAFpB,cAAc"}

package/types/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.js"],"names":[],"mappings":"AAgbA;;GAEG;AACH,iDAEC;AA/ZD;IACE,cAoBC;IAED;;OAEG;IACH,YAFa,IAAI,CAQhB;IAED;;OAEG;IACH,eAFW,MAAM,QAUhB;IAED;;OAEG;IACH,YAFW,MAAM,QAUhB;IAED;;OAEG;IACH,YAFW,MAAM,QAUhB;IAED,aAIC;IAED;;OAEG;IACH,mBAFW,OAAO,QAYjB;IAED;;OAEG;IACH,mBAFW,OAAO,QAYjB;IAED;;OAEG;IACH,WAFW,MAAM,QAahB;IAED,cAMC;IAED,uBASC;IAED,YAMC;IAED,YAMC;IAED,aAMC;IAED,cAMC;IAED;;;OAGG;IACH,iBAFG;QAA0B,OAAO,GAAzB,OAAO;KAAmB,QAQpC;IAED,mBAMC;IAED,WAMC;IAED,gBAMC;IAED,eAMC;IAED,YAMC;IAED,aAOC;IAED,eAMC;IAED;;OAEG;IACH,oBAFW,MAAM,QAQhB;IAED,gBAMC;IAED;;;;;;;OAOG;IACH,mBANG;QAAyB,SAAS,GAA1B,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,YAAY,GAA7B,MAAM;KAAwB,QA+BxC;IAED;;;;;;;;;;;OAWG;IACH,cAVG;QAA0B,gBAAgB,GAAlC,OAAO;QACW,sBAAsB,GAAxC,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,4BAA4B,GAA9C,OAAO;QACW,eAAe,GAAjC,OAAO;QACW,sBAAsB,GAAxC,OAAO;QACW,eAAe,GAAjC,OAAO;QACY,SAAS,GAA5B,MAAM,EAAE;KAAqB,QAQvC;IAED;;;;;;;;OAQG;IACH,iBAPG;QAA0B,WAAW,GAA7B,OAAO;QACW,iBAAiB,GAAnC,OAAO;QACW,kBAAkB,GAApC,OAAO;QACW,iBAAiB,GAAnC,OAAO;QACW,cAAc,GAAhC,OAAO;QACW,iBAAiB,GAAnC,OAAO;KAAmC,QAQpD;IAED;;OAEG;IACH,eAFW,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAQ3B;IAED,YAMC;IAED,YAMC;IAED,cAMC;IAED,cAMC;IAED,iCAWC;CAcF;uBA7asB,cAAc"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.js"],"names":[],"mappings":"AAibA;;GAEG;AACH,iDAEC;AA/ZD;IACE,cAoBC;IAED;;OAEG;IACH,YAFa,IAAI,CAQhB;IAED;;OAEG;IACH,eAFW,MAAM,QAUhB;IAED;;OAEG;IACH,YAFW,MAAM,QAUhB;IAED;;OAEG;IACH,YAFW,MAAM,QAUhB;IAED,aAIC;IAED;;OAEG;IACH,mBAFW,OAAO,QAYjB;IAED;;OAEG;IACH,mBAFW,OAAO,QAYjB;IAED;;OAEG;IACH,WAFW,MAAM,QAahB;IAED,cAMC;IAED,uBASC;IAED,YAMC;IAED,YAMC;IAED,aAMC;IAED,cAMC;IAED;;;OAGG;IACH,iBAFG;QAA0B,OAAO,GAAzB,OAAO;KAAmB,QAQpC;IAED,mBAMC;IAED,WAMC;IAED,gBAMC;IAED,eAMC;IAED,YAMC;IAED,aAOC;IAED,eAMC;IAED;;OAEG;IACH,oBAFW,MAAM,QAQhB;IAED,gBAMC;IAED;;;;;;;OAOG;IACH,mBANG;QAAyB,SAAS,GAA1B,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,YAAY,GAA7B,MAAM;KAAwB,QA+BxC;IAED;;;;;;;;;;;OAWG;IACH,cAVG;QAA0B,gBAAgB,GAAlC,OAAO;QACW,sBAAsB,GAAxC,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,4BAA4B,GAA9C,OAAO;QACW,eAAe,GAAjC,OAAO;QACW,sBAAsB,GAAxC,OAAO;QACW,eAAe,GAAjC,OAAO;QACY,SAAS,GAA5B,MAAM,EAAE;KAAqB,QAQvC;IAED;;;;;;;;OAQG;IACH,iBAPG;QAA0B,WAAW,GAA7B,OAAO;QACW,iBAAiB,GAAnC,OAAO;QACW,kBAAkB,GAApC,OAAO;QACW,iBAAiB,GAAnC,OAAO;QACW,cAAc,GAAhC,OAAO;QACW,iBAAiB,GAAnC,OAAO;KAAmC,QAQpD;IAED;;OAEG;IACH,eAFW,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAQ3B;IAED,YAMC;IAED,YAMC;IAED,cAMC;IAED,cAMC;IAED,iCAWC;CAcF;uBA7asB,cAAc"}

package/.prettierrc.cjs

@@ -1 +0,0 @@
-module.exports = require('@bedrockio/prettier-config');

package/dist/cjs/utils.js

@@ -1,37 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "isSchema", {
-  enumerable: true,
-  get: function () {
-    return _Schema.isSchema;
-  }
-});
-Object.defineProperty(exports, "isSchemaError", {
-  enumerable: true,
-  get: function () {
-    return _errors.isSchemaError;
-  }
-});
-exports.omit = omit;
-exports.pick = pick;
-var _Schema = require("./Schema");
-var _errors = require("./errors");
-function pick(obj, keys) {
-  const result = {};
-  for (let key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
-}
-function omit(obj, keys) {
-  const result = {};
-  for (let key of Object.keys(obj || {})) {
-    if (!keys.includes(key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}

package/src/utils.js

@@ -1,20 +0,0 @@
-export { isSchema } from './Schema';
-export { isSchemaError } from './errors';
-
-export function pick(obj, keys) {
-  const result = {};
-  for (let key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
-}
-
-export function omit(obj, keys) {
-  const result = {};
-  for (let key of Object.keys(obj || {})) {
-    if (!keys.includes(key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}