@bedrockio/yada 1.0.13 → 1.0.15

package/README.md

@@ -607,7 +607,7 @@ yd.useLocalizer((template) => {
 Any validation message matching the keys passed to the map will result in the
 localized message instead. The curly braces allow for variable substitution.
 
-A special method `getLocalizerTemplates` will aggregte used error messages to
+A special method `getLocalizedMessages` will aggregte used error messages to
 allow quick discovery of strings that have not yet been localized:
 
 ```js
@@ -616,7 +616,7 @@ yd.useLocalizer({
   'Object failed validation.': '不正な入力がありました。',
 });
 // Error validation occuring here
-yd.getLocalizedTemplates();
+yd.getLocalizedMessages();
 // {
 //   'Must be at least {length} character{s}.': '{length}文字以上入力して下さい。',
 //   'Object failed validation.': '不正な入力がありました。',
@@ -685,7 +685,7 @@ Basic utility methods:
 - `isSchema`: returns `true` if the object passed is a schema.
 - `isSchemaError`: returns `true` if the error object is a schema error.
 - `useLocalizer`: Allows [localization](#localization) of error messages.
-- `getLocalizerTemplates`: Allows discovery of messages for
+- `getLocalizedMessages`: Allows discovery of messages for
   [localization](#localization).
 - `LocalizedError`: An error object that can be thrown in custom validations to
   allow [localization](#localization).

package/dist/cjs/Schema.js

@@ -8,6 +8,11 @@ exports.isSchema = isSchema;
 var _errors = require("./errors");
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform'];
 const REQUIRED_TYPES = ['default', 'required'];
+
+/**
+ * @typedef {[fn: Function] | [type: string, fn: Function]} CustomSignature
+ */
+
 class Schema {
   constructor(meta = {}) {
     this.assertions = [];
@@ -16,6 +21,9 @@ class Schema {
 
   // Public
 
+  /**
+   * @returns {this}
+   */
   required() {
     return this.clone({
       required: true
@@ -25,6 +33,11 @@ class Schema {
       }
     });
   }
+
+  /**
+   * Sets the schema default. [Link](https://github.com/bedrockio/yada#default)
+   * @returns {this}
+   */
   default(value) {
     return this.clone({
       default: value
@@ -34,9 +47,21 @@ class Schema {
       }
     });
   }
+
+  /**
+   * Validate by a custom function. [Link](https://github.com/bedrockio/yada#custom)
+   * @param {CustomSignature} args
+   * @returns {this}
+   */
   custom(...args) {
-    const type = args.length > 1 ? args[0] : 'custom';
-    const fn = args.length > 1 ? args[1] : args[0];
+    let type, fn;
+    if (typeof args[0] === 'function') {
+      type = 'custom';
+      fn = args[0];
+    } else {
+      type = args[0];
+      fn = args[1];
+    }
     if (!type) {
       throw new Error('Assertion type required.');
     } else if (!fn) {
@@ -46,22 +71,46 @@ class Schema {
       return await fn(val, options);
     });
   }
+
+  /**
+   * Conditionally exclude fields inside an object schema.
+   * [Link](https://github.com/bedrockio/yada#strip)
+   * @returns {this}
+   */
   strip(strip) {
     return this.clone({
       strip
     });
   }
+
+  /**
+   * Accept values or schemas. [Link](https://github.com/bedrockio/yada#allow)
+   * @returns {this}
+   */
   allow(...set) {
     return this.assertEnum(set, true);
   }
+
+  /**
+   * Reject values or schemas. [Link](https://github.com/bedrockio/yada#reject)
+   * @returns {this}
+   */
   reject(...set) {
     return this.assertEnum(set, false);
   }
+
+  /**
+   * @returns {this}
+   */
   message(message) {
     return this.clone({
       message
     });
   }
+
+  /**
+   * @returns {this}
+   */
   tag(tags) {
     return this.clone({
       tags: {
@@ -70,11 +119,19 @@ class Schema {
       }
     });
   }
+
+  /**
+   * @returns {this}
+   */
   description(description) {
     return this.tag({
       description
     });
   }
+
+  /**
+   * @returns {this}
+   */
   options(options) {
     return this.clone({
       ...options
@@ -116,6 +173,10 @@ class Schema {
     }
     return value;
   }
+
+  /**
+   * @returns {this}
+   */
   clone(meta) {
     const clone = Object.create(this.constructor.prototype);
     clone.assertions = [...this.assertions];
@@ -125,14 +186,44 @@ class Schema {
     };
     return clone;
   }
+
+  /**
+   * Appends another schema. [Link](https://github.com/bedrockio/yada#append)
+   * @returns {this}
+   */
   append(schema) {
     const merged = this.clone(schema.meta);
     merged.assertions = [...this.assertions, ...schema.assertions];
     return merged;
   }
+  toOpenApi(extra) {
+    const {
+      required,
+      format,
+      tags,
+      default: defaultValue
+    } = this.meta;
+    return {
+      ...(required && {
+        required: true
+      }),
+      ...(defaultValue && {
+        default: defaultValue
+      }),
+      ...(format && {
+        format
+      }),
+      ...this.enumToOpenApi(),
+      ...tags,
+      ...extra
+    };
+  }
 
   // Private
 
+  /**
+   * @returns {this}
+   */
   assertEnum(set, allow) {
     if (set.length === 1 && Array.isArray(set[0])) {
       set = set[0];
@@ -166,6 +257,10 @@ class Schema {
       }
     });
   }
+
+  /**
+   * @returns {this}
+   */
   assert(type, fn) {
     this.pushAssertion({
       halt: INITIAL_TYPES.includes(type),
@@ -181,6 +276,10 @@ class Schema {
       return this.getSortIndex(a.type) - this.getSortIndex(b.type);
     });
   }
+
+  /**
+   * @returns {this}
+   */
   transform(fn) {
     this.assert('transform', (val, options) => {
       if (val !== undefined) {
@@ -207,28 +306,6 @@ class Schema {
       throw new _errors.AssertionError(error.message, error.type || type, error);
     }
   }
-  toOpenApi(extra) {
-    const {
-      required,
-      format,
-      tags,
-      default: defaultValue
-    } = this.meta;
-    return {
-      ...(required && {
-        required: true
-      }),
-      ...(defaultValue && {
-        default: defaultValue
-      }),
-      ...(format && {
-        format
-      }),
-      ...this.enumToOpenApi(),
-      ...tags,
-      ...extra
-    };
-  }
   enumToOpenApi() {
     const {
       enum: allowed

package/dist/cjs/TypeSchema.js

@@ -29,5 +29,4 @@ class TypeSchema extends _Schema.default {
     };
   }
 }
-exports.default = TypeSchema;
-module.exports = exports.default;
+exports.default = TypeSchema;

package/dist/cjs/array.js

@@ -3,27 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = _default;
 var _Schema = _interopRequireDefault(require("./Schema"));
 var _errors = require("./errors");
-var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class ArraySchema extends _Schema.default {
-  constructor(...args) {
-    let schemas, meta;
-    if (Array.isArray(args[0])) {
-      schemas = args[0];
-      meta = args[1];
-    } else {
-      schemas = args;
-    }
+  constructor(schemas) {
     super({
       message: 'Array failed validation.',
-      ...meta,
       schemas
     });
     this.setup();
   }
+
+  /**
+   * @private
+   */
   setup() {
     const {
       schemas
@@ -137,6 +132,18 @@ class ArraySchema extends _Schema.default {
     };
   }
 }
-var _default = (0, _utils.wrapSchema)(ArraySchema);
-exports.default = _default;
-module.exports = exports.default;
+
+/**
+ * Creates an [array schema](https://github.com/bedrockio/yada#array).
+ *
+ * @param {...Schema} [schemas] Optional schemas to validate
+ * the different types of elements allowed in the array. If
+ * no arguments are passed elements may be of any type. Also
+ * accepts a single array argument.
+ */
+function _default(...schemas) {
+  if (Array.isArray(schemas[0])) {
+    schemas = schemas[0];
+  }
+  return new ArraySchema(schemas);
+}

package/dist/cjs/boolean.js

@@ -3,10 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = _default;
 var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
 var _errors = require("./errors");
-var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class BooleanSchema extends _TypeSchema.default {
   constructor() {
@@ -27,6 +26,10 @@ class BooleanSchema extends _TypeSchema.default {
     });
   }
 }
-var _default = (0, _utils.wrapSchema)(BooleanSchema);
-exports.default = _default;
-module.exports = exports.default;
+
+/**
+ * Creates a [boolean schema](https://github.com/bedrockio/yada#boolean).
+ */
+function _default() {
+  return new BooleanSchema();
+}

package/dist/cjs/date.js

@@ -3,9 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = _default;
 var _validator = _interopRequireDefault(require("validator"));
-var _utils = require("./utils");
 var _errors = require("./errors");
 var _Schema = _interopRequireDefault(require("./Schema"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -21,41 +20,61 @@ class DateSchema extends _Schema.default {
       }
     });
   }
+
+  /**
+   * @param {string|number|Date} min
+   */
   min(min) {
     min = new Date(min);
     return this.clone().assert('min', date => {
       if (date < min) {
         throw new _errors.LocalizedError('Must be after {date}.', {
+          // @ts-ignore
           date: min.toISOString()
         });
       }
     });
   }
+
+  /**
+   * @param {string|number|Date} max
+   */
   max(max) {
     max = new Date(max);
     return this.clone().assert('max', date => {
       if (date > max) {
         throw new _errors.LocalizedError('Must be before {date}.', {
+          // @ts-ignore
           date: max.toISOString()
         });
       }
     });
   }
+
+  /**
+   * @param {string|number|Date} max
+   */
   before(max) {
     max = new Date(max);
     return this.clone().assert('before', date => {
       if (date >= max) {
         throw new _errors.LocalizedError('Must be before {date}.', {
+          // @ts-ignore
           date: max.toISOString()
         });
       }
     });
   }
+
+  /**
+   * @param {string|number|Date} min
+   */
   after(min) {
     min = new Date(min);
     return this.clone().assert('after', date => {
       if (date <= min) {
         throw new _errors.LocalizedError('Must be after {date}.', {
+          // @ts-ignore
           date: min.toISOString()
         });
       }
@@ -77,6 +96,10 @@ class DateSchema extends _Schema.default {
       }
     });
   }
+
+  /**
+   * @param {"date" | "date-time"} format
+   */
   iso(format = 'date-time') {
     return this.clone({
       format
@@ -128,6 +151,10 @@ class DateSchema extends _Schema.default {
     };
   }
 }
-var _default = (0, _utils.wrapSchema)(DateSchema);
-exports.default = _default;
-module.exports = exports.default;
+
+/**
+ * Creates a [date schema](https://github.com/bedrockio/yada#date).
+ */
+function _default() {
+  return new DateSchema();
+}

package/dist/cjs/index.js

@@ -3,21 +3,116 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "LocalizedError", {
+  enumerable: true,
+  get: function () {
+    return _errors.LocalizedError;
+  }
+});
+exports.allow = allow;
+exports.any = any;
+Object.defineProperty(exports, "array", {
+  enumerable: true,
+  get: function () {
+    return _array.default;
+  }
+});
+Object.defineProperty(exports, "boolean", {
+  enumerable: true,
+  get: function () {
+    return _boolean.default;
+  }
+});
+exports.custom = custom;
+Object.defineProperty(exports, "date", {
+  enumerable: true,
+  get: function () {
+    return _date.default;
+  }
+});
 exports.default = void 0;
+Object.defineProperty(exports, "getLocalizedMessages", {
+  enumerable: true,
+  get: function () {
+    return _localization.getLocalizedMessages;
+  }
+});
+Object.defineProperty(exports, "isSchema", {
+  enumerable: true,
+  get: function () {
+    return _utils.isSchema;
+  }
+});
+Object.defineProperty(exports, "isSchemaError", {
+  enumerable: true,
+  get: function () {
+    return _utils.isSchemaError;
+  }
+});
+Object.defineProperty(exports, "number", {
+  enumerable: true,
+  get: function () {
+    return _number.default;
+  }
+});
+Object.defineProperty(exports, "object", {
+  enumerable: true,
+  get: function () {
+    return _object.default;
+  }
+});
+exports.reject = reject;
+Object.defineProperty(exports, "string", {
+  enumerable: true,
+  get: function () {
+    return _string.default;
+  }
+});
+Object.defineProperty(exports, "useLocalizer", {
+  enumerable: true,
+  get: function () {
+    return _localization.useLocalizer;
+  }
+});
 var _array = _interopRequireDefault(require("./array"));
 var _boolean = _interopRequireDefault(require("./boolean"));
 var _date = _interopRequireDefault(require("./date"));
 var _number = _interopRequireDefault(require("./number"));
 var _object = _interopRequireDefault(require("./object"));
 var _string = _interopRequireDefault(require("./string"));
+var _Schema = _interopRequireDefault(require("./Schema"));
 var _utils = require("./utils");
 var _localization = require("./localization");
 var _errors = require("./errors");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const allow = (0, _utils.wrapArgs)('allow');
-const reject = (0, _utils.wrapArgs)('reject');
-const custom = (0, _utils.wrapArgs)('custom');
-const any = (0, _utils.wrapAny)();
+/**
+ * Accepts anything.
+ */
+function any() {
+  return new _Schema.default();
+}
+
+/**
+ * Accept values or schemas. [Link](https://github.com/bedrockio/yada#allow)
+ */
+function allow(...args) {
+  return new _Schema.default().allow(...args);
+}
+
+/**
+ * Reject values or schemas. [Link](https://github.com/bedrockio/yada#reject)
+ */
+function reject(...args) {
+  return new _Schema.default().reject(...args);
+}
+
+/**
+ * Validate by a custom function. [Link](https://github.com/bedrockio/yada#custom)
+ * @param {import("./Schema").CustomSignature} args
+ */
+function custom(...args) {
+  return new _Schema.default().custom(...args);
+}
 var _default = {
   array: _array.default,
   boolean: _boolean.default,
@@ -32,8 +127,7 @@ var _default = {
   isSchema: _utils.isSchema,
   isSchemaError: _utils.isSchemaError,
   useLocalizer: _localization.useLocalizer,
-  getLocalizerTemplates: _localization.getLocalizerTemplates,
+  getLocalizedMessages: _localization.getLocalizedMessages,
   LocalizedError: _errors.LocalizedError
 };
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;

package/dist/cjs/localization.js

@@ -4,38 +4,54 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getLocalized = getLocalized;
-exports.getLocalizerTemplates = getLocalizerTemplates;
+exports.getLocalizedMessages = getLocalizedMessages;
 exports.localize = localize;
 exports.useLocalizer = useLocalizer;
 const TOKEN_REG = /{(.+?)}/g;
 let localizer;
-let templates = {};
+
+/**
+ * @type {{ [key: string]: string }}
+ */
+let messages = {};
+
+/**
+ * @param {{ [key: string]: string } | ((key: string) => string)} arg
+ * An object that maps messages to localized strings or a function that
+ * accepts a message and returns a localized string. Use "getLocalizedMessages"
+ * to see the messages that exist.
+ */
 function useLocalizer(arg) {
-  const fn = typeof arg === 'function' ? arg : template => arg[template];
+  const fn = typeof arg === 'function' ? arg : message => arg[message];
   localizer = fn;
-  templates = {};
+  messages = {};
 }
-function getLocalized(template) {
+function getLocalized(message) {
   if (localizer) {
-    return localizer(template);
+    return localizer(message);
   }
 }
-function localize(template, values = {}) {
-  let message = template;
-  if (localizer) {
-    let localized = getLocalized(template);
+function localize(message, values = {}) {
+  let str = message;
+  if (str) {
+    let localized = getLocalized(message);
     if (typeof localized === 'function') {
       localized = localized(values);
     }
     if (localized) {
-      message = localized;
+      str = localized;
     }
   }
-  templates[template] = message;
-  return message.replace(TOKEN_REG, (match, token) => {
+  messages[message] = str;
+  return str.replace(TOKEN_REG, (match, token) => {
     return token in values ? values[token] : match;
   });
 }
-function getLocalizerTemplates() {
-  return templates;
+
+/**
+ * Returns an object containing all encountered messages
+ * mapped to their localizations.
+ */
+function getLocalizedMessages() {
+  return messages;
 }