inkdrop-model 2.6.1 → 2.7.1

package/lib/validate_tag.js

@@ -1,340 +0,0 @@
-'use strict';
-var ucs2length = require('ajv/lib/compile/ucs2length');
-var equal = require('ajv/lib/compile/equal');
-var validate = (function() {
-  var pattern0 = new RegExp('^tag:');
-  var refVal = [];
-  return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
-    'use strict'; /*# sourceURL=tag */
-    var vErrors = null;
-    var errors = 0;
-    if ((data && typeof data === "object" && !Array.isArray(data))) {
-      if (true) {
-        var errs__0 = errors;
-        var valid1 = true;
-        var data1 = data._id;
-        if (data1 === undefined) {
-          valid1 = false;
-          validate.errors = [{
-            keyword: 'required',
-            dataPath: (dataPath || '') + "",
-            schemaPath: '#/required',
-            params: {
-              missingProperty: '_id'
-            },
-            message: 'should have required property \'_id\''
-          }];
-          return false;
-        } else {
-          var errs_1 = errors;
-          if (typeof data1 === "string") {
-            if (ucs2length(data1) > 128) {
-              validate.errors = [{
-                keyword: 'maxLength',
-                dataPath: (dataPath || '') + '._id',
-                schemaPath: '#/properties/_id/maxLength',
-                params: {
-                  limit: 128
-                },
-                message: 'should NOT be longer than 128 characters'
-              }];
-              return false;
-            } else {
-              if (ucs2length(data1) < 6) {
-                validate.errors = [{
-                  keyword: 'minLength',
-                  dataPath: (dataPath || '') + '._id',
-                  schemaPath: '#/properties/_id/minLength',
-                  params: {
-                    limit: 6
-                  },
-                  message: 'should NOT be shorter than 6 characters'
-                }];
-                return false;
-              } else {
-                if (!pattern0.test(data1)) {
-                  validate.errors = [{
-                    keyword: 'pattern',
-                    dataPath: (dataPath || '') + '._id',
-                    schemaPath: '#/properties/_id/pattern',
-                    params: {
-                      pattern: '^tag:'
-                    },
-                    message: 'should match pattern "^tag:"'
-                  }];
-                  return false;
-                }
-              }
-            }
-          } else {
-            validate.errors = [{
-              keyword: 'type',
-              dataPath: (dataPath || '') + '._id',
-              schemaPath: '#/properties/_id/type',
-              params: {
-                type: 'string'
-              },
-              message: 'should be string'
-            }];
-            return false;
-          }
-          var valid1 = errors === errs_1;
-        }
-        if (valid1) {
-          if (data._rev === undefined) {
-            valid1 = true;
-          } else {
-            var errs_1 = errors;
-            if (typeof data._rev !== "string") {
-              validate.errors = [{
-                keyword: 'type',
-                dataPath: (dataPath || '') + '._rev',
-                schemaPath: '#/properties/_rev/type',
-                params: {
-                  type: 'string'
-                },
-                message: 'should be string'
-              }];
-              return false;
-            }
-            var valid1 = errors === errs_1;
-          }
-          if (valid1) {
-            var data1 = data.name;
-            if (data1 === undefined) {
-              valid1 = false;
-              validate.errors = [{
-                keyword: 'required',
-                dataPath: (dataPath || '') + "",
-                schemaPath: '#/required',
-                params: {
-                  missingProperty: 'name'
-                },
-                message: 'should have required property \'name\''
-              }];
-              return false;
-            } else {
-              var errs_1 = errors;
-              if (typeof data1 === "string") {
-                if (ucs2length(data1) > 64) {
-                  validate.errors = [{
-                    keyword: 'maxLength',
-                    dataPath: (dataPath || '') + '.name',
-                    schemaPath: '#/properties/name/maxLength',
-                    params: {
-                      limit: 64
-                    },
-                    message: 'should NOT be longer than 64 characters'
-                  }];
-                  return false;
-                }
-              } else {
-                validate.errors = [{
-                  keyword: 'type',
-                  dataPath: (dataPath || '') + '.name',
-                  schemaPath: '#/properties/name/type',
-                  params: {
-                    type: 'string'
-                  },
-                  message: 'should be string'
-                }];
-                return false;
-              }
-              var valid1 = errors === errs_1;
-            }
-            if (valid1) {
-              if (data.count === undefined) {
-                valid1 = false;
-                validate.errors = [{
-                  keyword: 'required',
-                  dataPath: (dataPath || '') + "",
-                  schemaPath: '#/required',
-                  params: {
-                    missingProperty: 'count'
-                  },
-                  message: 'should have required property \'count\''
-                }];
-                return false;
-              } else {
-                var errs_1 = errors;
-                if (typeof data.count !== "number") {
-                  validate.errors = [{
-                    keyword: 'type',
-                    dataPath: (dataPath || '') + '.count',
-                    schemaPath: '#/properties/count/type',
-                    params: {
-                      type: 'number'
-                    },
-                    message: 'should be number'
-                  }];
-                  return false;
-                }
-                var valid1 = errors === errs_1;
-              }
-              if (valid1) {
-                var data1 = data.color;
-                if (data1 === undefined) {
-                  valid1 = true;
-                } else {
-                  var errs_1 = errors;
-                  if (typeof data1 !== "string") {
-                    validate.errors = [{
-                      keyword: 'type',
-                      dataPath: (dataPath || '') + '.color',
-                      schemaPath: '#/properties/color/type',
-                      params: {
-                        type: 'string'
-                      },
-                      message: 'should be string'
-                    }];
-                    return false;
-                  }
-                  var schema1 = validate.schema.properties.color.enum;
-                  var valid1;
-                  valid1 = false;
-                  for (var i1 = 0; i1 < schema1.length; i1++)
-                    if (equal(data1, schema1[i1])) {
-                      valid1 = true;
-                      break;
-                    } if (!valid1) {
-                    validate.errors = [{
-                      keyword: 'enum',
-                      dataPath: (dataPath || '') + '.color',
-                      schemaPath: '#/properties/color/enum',
-                      params: {
-                        allowedValues: schema1
-                      },
-                      message: 'should be equal to one of the allowed values'
-                    }];
-                    return false;
-                  }
-                  var valid1 = errors === errs_1;
-                }
-                if (valid1) {
-                  if (data.updatedAt === undefined) {
-                    valid1 = false;
-                    validate.errors = [{
-                      keyword: 'required',
-                      dataPath: (dataPath || '') + "",
-                      schemaPath: '#/required',
-                      params: {
-                        missingProperty: 'updatedAt'
-                      },
-                      message: 'should have required property \'updatedAt\''
-                    }];
-                    return false;
-                  } else {
-                    var errs_1 = errors;
-                    if (typeof data.updatedAt !== "number") {
-                      validate.errors = [{
-                        keyword: 'type',
-                        dataPath: (dataPath || '') + '.updatedAt',
-                        schemaPath: '#/properties/updatedAt/type',
-                        params: {
-                          type: 'number'
-                        },
-                        message: 'should be number'
-                      }];
-                      return false;
-                    }
-                    var valid1 = errors === errs_1;
-                  }
-                  if (valid1) {
-                    if (data.createdAt === undefined) {
-                      valid1 = false;
-                      validate.errors = [{
-                        keyword: 'required',
-                        dataPath: (dataPath || '') + "",
-                        schemaPath: '#/required',
-                        params: {
-                          missingProperty: 'createdAt'
-                        },
-                        message: 'should have required property \'createdAt\''
-                      }];
-                      return false;
-                    } else {
-                      var errs_1 = errors;
-                      if (typeof data.createdAt !== "number") {
-                        validate.errors = [{
-                          keyword: 'type',
-                          dataPath: (dataPath || '') + '.createdAt',
-                          schemaPath: '#/properties/createdAt/type',
-                          params: {
-                            type: 'number'
-                          },
-                          message: 'should be number'
-                        }];
-                        return false;
-                      }
-                      var valid1 = errors === errs_1;
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    } else {
-      validate.errors = [{
-        keyword: 'type',
-        dataPath: (dataPath || '') + "",
-        schemaPath: '#/type',
-        params: {
-          type: 'object'
-        },
-        message: 'should be object'
-      }];
-      return false;
-    }
-    validate.errors = vErrors;
-    return errors === 0;
-  };
-})();
-validate.schema = {
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "id": "tag",
-  "title": "Tag",
-  "description": "A note tag",
-  "type": "object",
-  "properties": {
-    "_id": {
-      "description": "The unique tag ID which should start with `tag:` and the remains are randomly generated string",
-      "type": "string",
-      "minLength": 6,
-      "maxLength": 128,
-      "pattern": "^tag:",
-      "example": "tag:0ebd717b"
-    },
-    "_rev": {
-      "description": "This is a CouchDB specific field. The current MVCC-token/revision of this document (mandatory and immutable)",
-      "type": "string",
-      "example": "14-813af5085bb6a2648c3f0aca37fc821f"
-    },
-    "name": {
-      "description": "The name of the tag",
-      "type": "string",
-      "maxLength": 64
-    },
-    "count": {
-      "description": "It indicates the number of notes with the tag",
-      "type": "number"
-    },
-    "color": {
-      "description": "The color type of the tag",
-      "type": "string",
-      "enum": ["default", "red", "orange", "yellow", "olive", "green", "teal", "blue", "violet", "purple", "pink", "brown", "grey", "black"]
-    },
-    "updatedAt": {
-      "description": "The date time when the tag was last updated, represented with Unix timestamps in milliseconds",
-      "type": "number"
-    },
-    "createdAt": {
-      "description": "The date time when the tag was created, represented with Unix timestamps in milliseconds",
-      "type": "number"
-    }
-  },
-  "required": ["_id", "name", "count", "updatedAt", "createdAt"]
-};
-validate.errors = null;
-module.exports = validate;