inkdrop-model 2.6.0 → 2.7.0

package/lib/tag.js.flow

@@ -1,60 +0,0 @@
-// @flow
-import TagSchema from '../json-schema/tag.json'
-import validateTag from '../validators/tag.js'
-import type { EncryptedData } from './crypto'
-
-delete TagSchema.id
-
-export type TagColor =
-  | 'default'
-  | 'red'
-  | 'orange'
-  | 'yellow'
-  | 'olive'
-  | 'green'
-  | 'teal'
-  | 'blue'
-  | 'violet'
-  | 'purple'
-  | 'pink'
-  | 'brown'
-  | 'grey'
-  | 'black'
-
-export const TAG_COLOR: $ReadOnly<{ [string]: TagColor }> = {
-  DEFAULT: 'default',
-  RED: 'red',
-  ORANGE: 'orange',
-  YELLOW: 'yellow',
-  OLIVE: 'olive',
-  GREEN: 'green',
-  TEAL: 'teal',
-  BLUE: 'blue',
-  VIOLET: 'violet',
-  PURPLE: 'purple',
-  PINK: 'pink',
-  BROWN: 'brown',
-  GREY: 'grey',
-  BLACK: 'black'
-}
-
-export type TagMetadata = {
-  _id: string,
-  _rev?: string,
-  count?: number,
-  color: TagColor,
-  updatedAt: number,
-  createdAt: number
-}
-
-export type Tag = {
-  ...$Exact<TagMetadata>,
-  name: string
-}
-
-export type EncryptedTag = {
-  ...$Exact<TagMetadata>,
-  encryptedData: EncryptedData
-}
-
-export { TagSchema, validateTag }

package/lib/validate_book.js

@@ -1,323 +0,0 @@
-'use strict';
-var ucs2length = require('ajv/lib/compile/ucs2length');
-var validate = (function() {
-  var pattern0 = new RegExp('^book:');
-  var refVal = [];
-  return function validate(data, dataPath, parentData, parentDataProperty, rootData) {
-    'use strict'; /*# sourceURL=book */
-    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: '^book:'
-                    },
-                    message: 'should match pattern "^book:"'
-                  }];
-                  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 {
-                  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.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;
-                }
-                if (valid1) {
-                  if (data.count === undefined) {
-                    valid1 = true;
-                  } 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.parentBookId;
-                    if (data1 === undefined) {
-                      valid1 = true;
-                    } else {
-                      var errs_1 = errors;
-                      if (typeof data1 !== "string" && data1 !== null) {
-                        validate.errors = [{
-                          keyword: 'type',
-                          dataPath: (dataPath || '') + '.parentBookId',
-                          schemaPath: '#/properties/parentBookId/type',
-                          params: {
-                            type: 'string,null'
-                          },
-                          message: 'should be string,null'
-                        }];
-                        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": "book",
-  "title": "Book",
-  "description": "A notebook data",
-  "type": "object",
-  "properties": {
-    "_id": {
-      "description": "The unique notebook ID which should start with `book:` and the remains are randomly generated string",
-      "type": "string",
-      "minLength": 6,
-      "maxLength": 128,
-      "pattern": "^book:",
-      "example": "book:9dc6a7a7"
-    },
-    "_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 notebook name",
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 64
-    },
-    "updatedAt": {
-      "description": "The date time when the notebook was last updated, represented with Unix timestamps in milliseconds",
-      "type": "number"
-    },
-    "createdAt": {
-      "description": "The date time when the notebook was created, represented with Unix timestamps in milliseconds",
-      "type": "number"
-    },
-    "count": {
-      "description": "It indicates the number of notes in the notebook",
-      "type": "number"
-    },
-    "parentBookId": {
-      "description": "The ID of the parent notebook",
-      "type": ["string", "null"]
-    }
-  },
-  "required": ["_id", "name", "updatedAt", "createdAt"]
-};
-validate.errors = null;
-module.exports = validate;