inkdrop-model 2.6.0 → 2.7.0

package/lib/validate_file.js

@@ -1,609 +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('^file:');
-  var refVal = [];
-  return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
-    'use strict'; /*# sourceURL=file */
-    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: '^file:'
-                    },
-                    message: 'should match pattern "^file:"'
-                  }];
-                  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) > 128) {
-                  validate.errors = [{
-                    keyword: 'maxLength',
-                    dataPath: (dataPath || '') + '.name',
-                    schemaPath: '#/properties/name/maxLength',
-                    params: {
-                      limit: 128
-                    },
-                    message: 'should NOT be longer than 128 characters'
-                  }];
-                  return false;
-                } else {
-                  if (ucs2length(data1) < 1) {
-                    validate.errors = [{
-                      keyword: 'minLength',
-                      dataPath: (dataPath || '') + '.name',
-                      schemaPath: '#/properties/name/minLength',
-                      params: {
-                        limit: 1
-                      },
-                      message: 'should NOT be shorter than 1 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.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;
-              }
-              if (valid1) {
-                var data1 = data.contentType;
-                if (data1 === undefined) {
-                  valid1 = false;
-                  validate.errors = [{
-                    keyword: 'required',
-                    dataPath: (dataPath || '') + "",
-                    schemaPath: '#/required',
-                    params: {
-                      missingProperty: 'contentType'
-                    },
-                    message: 'should have required property \'contentType\''
-                  }];
-                  return false;
-                } else {
-                  var errs_1 = errors;
-                  if (typeof data1 === "string") {
-                    if (ucs2length(data1) > 128) {
-                      validate.errors = [{
-                        keyword: 'maxLength',
-                        dataPath: (dataPath || '') + '.contentType',
-                        schemaPath: '#/properties/contentType/maxLength',
-                        params: {
-                          limit: 128
-                        },
-                        message: 'should NOT be longer than 128 characters'
-                      }];
-                      return false;
-                    }
-                  } else {
-                    validate.errors = [{
-                      keyword: 'type',
-                      dataPath: (dataPath || '') + '.contentType',
-                      schemaPath: '#/properties/contentType/type',
-                      params: {
-                        type: 'string'
-                      },
-                      message: 'should be string'
-                    }];
-                    return false;
-                  }
-                  if (errors === errs_1) {
-                    var schema1 = validate.schema.properties.contentType.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 || '') + '.contentType',
-                        schemaPath: '#/properties/contentType/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.contentLength === undefined) {
-                    valid1 = false;
-                    validate.errors = [{
-                      keyword: 'required',
-                      dataPath: (dataPath || '') + "",
-                      schemaPath: '#/required',
-                      params: {
-                        missingProperty: 'contentLength'
-                      },
-                      message: 'should have required property \'contentLength\''
-                    }];
-                    return false;
-                  } else {
-                    var errs_1 = errors;
-                    if (typeof data.contentLength !== "number") {
-                      validate.errors = [{
-                        keyword: 'type',
-                        dataPath: (dataPath || '') + '.contentLength',
-                        schemaPath: '#/properties/contentLength/type',
-                        params: {
-                          type: 'number'
-                        },
-                        message: 'should be number'
-                      }];
-                      return false;
-                    }
-                    var valid1 = errors === errs_1;
-                  }
-                  if (valid1) {
-                    var data1 = data.publicIn;
-                    if (data1 === undefined) {
-                      valid1 = false;
-                      validate.errors = [{
-                        keyword: 'required',
-                        dataPath: (dataPath || '') + "",
-                        schemaPath: '#/required',
-                        params: {
-                          missingProperty: 'publicIn'
-                        },
-                        message: 'should have required property \'publicIn\''
-                      }];
-                      return false;
-                    } else {
-                      var errs_1 = errors;
-                      if (Array.isArray(data1)) {
-                        var errs__1 = errors;
-                        var valid1;
-                        for (var i1 = 0; i1 < data1.length; i1++) {
-                          var errs_2 = errors;
-                          if (typeof data1[i1] !== "string") {
-                            validate.errors = [{
-                              keyword: 'type',
-                              dataPath: (dataPath || '') + '.publicIn[' + i1 + ']',
-                              schemaPath: '#/properties/publicIn/items/type',
-                              params: {
-                                type: 'string'
-                              },
-                              message: 'should be string'
-                            }];
-                            return false;
-                          }
-                          var valid2 = errors === errs_2;
-                          if (!valid2) break;
-                        }
-                        if (errs__1 == errors) {
-                          var i = data1.length,
-                            valid1 = true,
-                            j;
-                          if (i > 1) {
-                            var itemIndices = {},
-                              item;
-                            for (; i--;) {
-                              var item = data1[i];
-                              if (typeof item !== "string") continue;
-                              if (typeof itemIndices[item] == 'number') {
-                                valid1 = false;
-                                j = itemIndices[item];
-                                break;
-                              }
-                              itemIndices[item] = i;
-                            }
-                          }
-                          if (!valid1) {
-                            validate.errors = [{
-                              keyword: 'uniqueItems',
-                              dataPath: (dataPath || '') + '.publicIn',
-                              schemaPath: '#/properties/publicIn/uniqueItems',
-                              params: {
-                                i: i,
-                                j: j
-                              },
-                              message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)'
-                            }];
-                            return false;
-                          }
-                        }
-                      } else {
-                        validate.errors = [{
-                          keyword: 'type',
-                          dataPath: (dataPath || '') + '.publicIn',
-                          schemaPath: '#/properties/publicIn/type',
-                          params: {
-                            type: 'array'
-                          },
-                          message: 'should be array'
-                        }];
-                        return false;
-                      }
-                      var valid1 = errors === errs_1;
-                    }
-                    if (valid1) {
-                      var data1 = data._attachments;
-                      if (data1 === undefined) {
-                        valid1 = false;
-                        validate.errors = [{
-                          keyword: 'required',
-                          dataPath: (dataPath || '') + "",
-                          schemaPath: '#/required',
-                          params: {
-                            missingProperty: '_attachments'
-                          },
-                          message: 'should have required property \'_attachments\''
-                        }];
-                        return false;
-                      } else {
-                        var errs_1 = errors;
-                        if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
-                          if (true) {
-                            var errs__1 = errors;
-                            var valid2 = true;
-                            var data2 = data1.index;
-                            if (data2 === undefined) {
-                              valid2 = false;
-                              validate.errors = [{
-                                keyword: 'required',
-                                dataPath: (dataPath || '') + '._attachments',
-                                schemaPath: '#/properties/_attachments/required',
-                                params: {
-                                  missingProperty: 'index'
-                                },
-                                message: 'should have required property \'index\''
-                              }];
-                              return false;
-                            } else {
-                              var errs_2 = errors;
-                              if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
-                                if (true) {
-                                  var errs__2 = errors;
-                                  var valid3 = true;
-                                  var data3 = data2.content_type;
-                                  if (data3 === undefined) {
-                                    valid3 = false;
-                                    validate.errors = [{
-                                      keyword: 'required',
-                                      dataPath: (dataPath || '') + '._attachments.index',
-                                      schemaPath: '#/properties/_attachments/properties/index/required',
-                                      params: {
-                                        missingProperty: 'content_type'
-                                      },
-                                      message: 'should have required property \'content_type\''
-                                    }];
-                                    return false;
-                                  } else {
-                                    var errs_3 = errors;
-                                    if (typeof data3 !== "string") {
-                                      validate.errors = [{
-                                        keyword: 'type',
-                                        dataPath: (dataPath || '') + '._attachments.index.content_type',
-                                        schemaPath: '#/properties/_attachments/properties/index/properties/content_type/type',
-                                        params: {
-                                          type: 'string'
-                                        },
-                                        message: 'should be string'
-                                      }];
-                                      return false;
-                                    }
-                                    var schema3 = validate.schema.properties._attachments.properties.index.properties.content_type.enum;
-                                    var valid3;
-                                    valid3 = false;
-                                    for (var i3 = 0; i3 < schema3.length; i3++)
-                                      if (equal(data3, schema3[i3])) {
-                                        valid3 = true;
-                                        break;
-                                      } if (!valid3) {
-                                      validate.errors = [{
-                                        keyword: 'enum',
-                                        dataPath: (dataPath || '') + '._attachments.index.content_type',
-                                        schemaPath: '#/properties/_attachments/properties/index/properties/content_type/enum',
-                                        params: {
-                                          allowedValues: schema3
-                                        },
-                                        message: 'should be equal to one of the allowed values'
-                                      }];
-                                      return false;
-                                    }
-                                    var valid3 = errors === errs_3;
-                                  }
-                                  if (valid3) {
-                                    var data3 = data2.data;
-                                    if (data3 === undefined) {
-                                      valid3 = false;
-                                      validate.errors = [{
-                                        keyword: 'required',
-                                        dataPath: (dataPath || '') + '._attachments.index',
-                                        schemaPath: '#/properties/_attachments/properties/index/required',
-                                        params: {
-                                          missingProperty: 'data'
-                                        },
-                                        message: 'should have required property \'data\''
-                                      }];
-                                      return false;
-                                    } else {
-                                      var errs_3 = errors;
-                                      if (typeof data3 !== "string" && (!data3 || typeof data3 !== "object" || Array.isArray(data3))) {
-                                        validate.errors = [{
-                                          keyword: 'type',
-                                          dataPath: (dataPath || '') + '._attachments.index.data',
-                                          schemaPath: '#/properties/_attachments/properties/index/properties/data/type',
-                                          params: {
-                                            type: 'string,object'
-                                          },
-                                          message: 'should be string,object'
-                                        }];
-                                        return false;
-                                      }
-                                      var valid3 = errors === errs_3;
-                                    }
-                                  }
-                                }
-                              } else {
-                                validate.errors = [{
-                                  keyword: 'type',
-                                  dataPath: (dataPath || '') + '._attachments.index',
-                                  schemaPath: '#/properties/_attachments/properties/index/type',
-                                  params: {
-                                    type: 'object'
-                                  },
-                                  message: 'should be object'
-                                }];
-                                return false;
-                              }
-                              var valid2 = errors === errs_2;
-                            }
-                          }
-                        } else {
-                          validate.errors = [{
-                            keyword: 'type',
-                            dataPath: (dataPath || '') + '._attachments',
-                            schemaPath: '#/properties/_attachments/type',
-                            params: {
-                              type: 'object'
-                            },
-                            message: 'should be object'
-                          }];
-                          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": "file",
-  "title": "File",
-  "description": "An attachment file",
-  "type": "object",
-  "properties": {
-    "_id": {
-      "description": "The unique document ID which should start with `file:` and the remains are randomly generated string",
-      "type": "string",
-      "minLength": 6,
-      "maxLength": 128,
-      "pattern": "^file:",
-      "example": "file:By8_nQtce"
-    },
-    "_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 file name",
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 128
-    },
-    "createdAt": {
-      "description": "The date time when the note was created, represented with Unix timestamps in milliseconds",
-      "type": "number"
-    },
-    "contentType": {
-      "description": "The MIME type of the content",
-      "type": "string",
-      "enum": ["image/png", "image/jpeg", "image/jpg", "image/svg+xml", "image/gif", "image/heic", "image/heif"],
-      "maxLength": 128
-    },
-    "contentLength": {
-      "description": "The content length of the file",
-      "type": "number"
-    },
-    "publicIn": {
-      "description": "An array of the note IDs where the file is included",
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "uniqueItems": true
-    },
-    "_attachments": {
-      "description": "The attachment file",
-      "type": "object",
-      "properties": {
-        "index": {
-          "description": "The attachment file",
-          "type": "object",
-          "properties": {
-            "content_type": {
-              "description": "The content type of the file",
-              "type": "string",
-              "enum": ["image/png", "image/jpeg", "image/jpg", "image/svg+xml", "image/gif", "image/heic", "image/heif"]
-            },
-            "data": {
-              "description": "The file data",
-              "type": ["string", "object"]
-            }
-          },
-          "required": ["content_type", "data"]
-        }
-      },
-      "required": ["index"]
-    }
-  },
-  "required": ["_id", "name", "createdAt", "contentType", "contentLength", "publicIn", "_attachments"]
-};
-validate.errors = null;
-module.exports = validate;