@bedrockio/yada 1.0.13 → 1.0.14

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 = [];
@@ -34,9 +39,19 @@ class Schema {
       }
     });
   }
+
+  /**
+   * @param {CustomSignature} args
+   */
   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) {
@@ -116,6 +131,10 @@ class Schema {
     }
     return value;
   }
+
+  /**
+   * @returns {this}
+   */
   clone(meta) {
     const clone = Object.create(this.constructor.prototype);
     clone.assertions = [...this.assertions];
@@ -125,11 +144,37 @@ class Schema {
     };
     return clone;
   }
+
+  /**
+   * @returns {Schema}
+   */
   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
 
@@ -207,28 +252,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

@@ -24,6 +24,10 @@ class ArraySchema extends _Schema.default {
     });
     this.setup();
   }
+
+  /**
+   * @private
+   */
   setup() {
     const {
       schemas
@@ -137,6 +141,12 @@ class ArraySchema extends _Schema.default {
     };
   }
 }
+
+/**
+ * @type {{
+ *   (...schemas: Schema[]) : ArraySchema;
+ *   (schemas: Schema[]) : ArraySchema;
+ * }}
+ */
 var _default = (0, _utils.wrapSchema)(ArraySchema);
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;

package/dist/cjs/boolean.js

@@ -27,6 +27,9 @@ class BooleanSchema extends _TypeSchema.default {
     });
   }
 }
+
+/**
+ * @type {function(): BooleanSchema}
+ */
 var _default = (0, _utils.wrapSchema)(BooleanSchema);
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;

package/dist/cjs/date.js

@@ -21,41 +21,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 +97,10 @@ class DateSchema extends _Schema.default {
       }
     });
   }
+
+  /**
+   * @param {"date" | "date-time"} format
+   */
   iso(format = 'date-time') {
     return this.clone({
       format
@@ -128,6 +152,9 @@ class DateSchema extends _Schema.default {
     };
   }
 }
+
+/**
+ * @type {() => DateSchema}
+ */
 var _default = (0, _utils.wrapSchema)(DateSchema);
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;

package/dist/cjs/index.js

@@ -3,21 +3,104 @@
 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)();
+function any() {
+  return new _Schema.default();
+}
+function allow(...args) {
+  return new _Schema.default().allow(...args);
+}
+function reject(...args) {
+  return new _Schema.default().reject(...args);
+}
+
+/**
+ * @param {import("./Schema").CustomSignature} args
+ */
+function custom(...args) {
+  return new _Schema.default().custom(...args);
+}
 var _default = {
   array: _array.default,
   boolean: _boolean.default,
@@ -32,8 +115,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;
 }

package/dist/cjs/number.js

@@ -21,25 +21,33 @@ class NumberSchema extends _TypeSchema.default {
       return val;
     });
   }
-  min(min, msg) {
-    msg ||= 'Must be greater than {min}.';
+
+  /**
+   * @param {number} min
+   * @param {string} message
+   */
+  min(min, message = 'Must be greater than {min}.') {
     return this.clone({
       min
     }).assert('min', num => {
       if (num < min) {
-        throw new _errors.LocalizedError(msg, {
+        throw new _errors.LocalizedError(message, {
           min
         });
       }
     });
   }
-  max(max, msg) {
-    msg ||= 'Must be less than {max}.';
+
+  /**
+   * @param {number} max
+   * @param {string} message
+   */
+  max(max, message = 'Must be less than {max}.') {
     return this.clone({
       max
     }).assert('max', num => {
       if (num > max) {
-        throw new _errors.LocalizedError(msg, {
+        throw new _errors.LocalizedError(message, {
           max
         });
       }
@@ -89,6 +97,9 @@ class NumberSchema extends _TypeSchema.default {
     };
   }
 }
+
+/**
+ * @type {() => NumberSchema}
+ */
 var _default = (0, _utils.wrapSchema)(NumberSchema);
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;

package/dist/cjs/object.js

@@ -18,6 +18,10 @@ class ObjectSchema extends _TypeSchema.default {
     });
     this.setup();
   }
+
+  /**
+   * @private
+   */
   setup() {
     this.assert('type', val => {
       if (val === null || typeof val !== 'object') {
@@ -85,6 +89,11 @@ class ObjectSchema extends _TypeSchema.default {
       });
     }
   }
+
+  /**
+   * @param {object|ObjectSchema} arg
+   * @returns Schema
+   */
   append(arg) {
     let schema;
     if (arg instanceof ObjectSchema) {
@@ -128,6 +137,9 @@ class ObjectSchema extends _TypeSchema.default {
     };
   }
 }
+
+/**
+ * @type {(arg: object) => ObjectSchema}
+ */
 var _default = (0, _utils.wrapSchema)(ObjectSchema);
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;

package/dist/cjs/string.js

@@ -25,6 +25,10 @@ class StringSchema extends _TypeSchema.default {
       return val;
     });
   }
+
+  /**
+   * @param {number} length
+   */
   min(length) {
     return this.clone({
       min: length
@@ -36,6 +40,10 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {number} length
+   */
   max(length) {
     return this.clone({
       max: length
@@ -52,6 +60,10 @@ class StringSchema extends _TypeSchema.default {
       return str.trim();
     });
   }
+
+  /**
+   * @param {boolean} [assert] Throws an error if not lowercase. Default: `false`.
+   */
   lowercase(assert = false) {
     return this.clone().transform(str => {
       const lower = str.toLowerCase();
@@ -63,6 +75,10 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {boolean} [assert] Throws an error if not uppercase. Default: `false`.
+   */
   uppercase(assert = false) {
     return this.clone().transform(str => {
       const upper = str.toUpperCase();
@@ -74,6 +90,10 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {RegExp} reg
+   */
   match(reg) {
     if (!(reg instanceof RegExp)) {
       throw new _errors.LocalizedError('Argument must be a regular expression');
@@ -128,6 +148,11 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.urlSafe]
+   */
   base64(options) {
     return this.format('base64', str => {
       if (!_validator.default.isBase64(str, options)) {
@@ -185,6 +210,10 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {string} locale
+   */
   postalCode(locale = 'any') {
     return this.format('postal-code', str => {
       if (!_validator.default.isPostalCode(str, locale)) {
@@ -192,13 +221,22 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {Object} [options]
+   * @param {number} [options.minLength]
+   * @param {number} [options.minNumbers]
+   * @param {number} [options.minSymbols]
+   * @param {number} [options.minLowercase]
+   * @param {number} [options.minUppercase]
+   */
   password(options = {}) {
     const {
       minLength,
-      minLowercase,
-      minUppercase,
       minNumbers,
-      minSymbols
+      minSymbols,
+      minLowercase,
+      minUppercase
     } = {
       ..._password.PASSWORD_DEFAULTS,
       ...options
@@ -221,6 +259,19 @@ class StringSchema extends _TypeSchema.default {
     }
     return schema;
   }
+
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.require_protocol]
+   * @param {boolean} [options.require_valid_protocol]
+   * @param {boolean} [options.require_host]
+   * @param {boolean} [options.require_port]
+   * @param {boolean} [options.allow_protocol_relative_urls]
+   * @param {boolean} [options.allow_fragments]
+   * @param {boolean} [options.allow_query_components]
+   * @param {boolean} [options.validate_length]
+   * @param {string[]} [options.protocols]
+   */
   url(options) {
     return this.format('url', str => {
       if (!_validator.default.isURL(str, options)) {
@@ -228,6 +279,16 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.require_tld=true]
+   * @param {boolean} [options.allow_underscores=false]
+   * @param {boolean} [options.allow_trailing_dot=false]
+   * @param {boolean} [options.allow_numeric_tld=false]
+   * @param {boolean} [options.allow_wildcard=false]
+   * @param {boolean} [options.ignore_max_length=false]
+   */
   domain(options) {
     return this.format('domain', str => {
       if (!_validator.default.isFQDN(str, options)) {
@@ -235,6 +296,10 @@ class StringSchema extends _TypeSchema.default {
       }
     });
   }
+
+  /**
+   * @param {1 | 2 | 3 | 4 | 5} [version] Version of UUID to check.
+   */
   uuid(version) {
     return this.format('uuid', str => {
       if (!_validator.default.isUUID(str, version)) {
@@ -286,6 +351,9 @@ class StringSchema extends _TypeSchema.default {
     };
   }
 }
+
+/**
+ * @type {() => StringSchema}
+ */
 var _default = (0, _utils.wrapSchema)(StringSchema);
-exports.default = _default;
-module.exports = exports.default;
+exports.default = _default;