node_modules ignore

server/node_modules/ajv-draft-04/src/index.ts

@@ -0,0 +1,81 @@
+import type {AnySchemaObject, Options} from "ajv/dist/core"
+import AjvCore from "ajv/dist/core"
+import draft4Vocabularies from "./vocabulary/draft4"
+import discriminator from "ajv/dist/vocabularies/discriminator"
+import * as draft4MetaSchema from "./refs/json-schema-draft-04.json"
+
+const META_SUPPORT_DATA = ["/properties"]
+
+const META_SCHEMA_ID = "http://json-schema.org/draft-04/schema"
+
+class Ajv extends AjvCore {
+  constructor(opts: Options = {}) {
+    super({
+      ...opts,
+      schemaId: "id",
+    })
+  }
+
+  _addVocabularies(): void {
+    super._addVocabularies()
+    draft4Vocabularies.forEach((v) => this.addVocabulary(v))
+    if (this.opts.discriminator) this.addKeyword(discriminator)
+  }
+
+  _addDefaultMetaSchema(): void {
+    super._addDefaultMetaSchema()
+    if (!this.opts.meta) return
+    const metaSchema = this.opts.$data
+      ? this.$dataMetaSchema(draft4MetaSchema, META_SUPPORT_DATA)
+      : draft4MetaSchema
+    this.addMetaSchema(metaSchema, META_SCHEMA_ID, false)
+    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
+  }
+
+  defaultMeta(): string | AnySchemaObject | undefined {
+    return (this.opts.defaultMeta =
+      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
+  }
+}
+
+module.exports = exports = Ajv
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default Ajv
+
+export {
+  Format,
+  FormatDefinition,
+  AsyncFormatDefinition,
+  KeywordDefinition,
+  KeywordErrorDefinition,
+  CodeKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+  Vocabulary,
+  Schema,
+  SchemaObject,
+  AnySchemaObject,
+  AsyncSchema,
+  AnySchema,
+  ValidateFunction,
+  AsyncValidateFunction,
+  SchemaValidateFunction,
+  ErrorObject,
+  ErrorNoParams,
+} from "ajv/dist/types"
+
+export {
+  Plugin,
+  Options,
+  CodeOptions,
+  InstanceOptions,
+  Logger,
+  ErrorsTextOptions,
+} from "ajv/dist/core"
+export {SchemaCxt, SchemaObjCxt} from "ajv/dist/core"
+export {KeywordCxt} from "ajv/dist/core"
+export {DefinedError} from "ajv/dist/core"
+export {JSONType} from "ajv/dist/core"
+export {JSONSchemaType} from "ajv/dist/core"
+export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "ajv/dist/core"

server/node_modules/ajv-draft-04/src/refs/json-schema-draft-04.json

@@ -0,0 +1,138 @@
+{
+  "id": "http://json-schema.org/draft-04/schema#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"$ref": "#"}
+    },
+    "positiveInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "positiveIntegerDefault0": {
+      "allOf": [{"$ref": "#/definitions/positiveInteger"}, {"default": 0}]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": {"type": "string"},
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": {},
+    "multipleOf": {
+      "type": "number",
+      "minimum": 0,
+      "exclusiveMinimum": true
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "boolean",
+      "default": false
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxLength": {"$ref": "#/definitions/positiveInteger"},
+    "minLength": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "items": {
+      "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/schemaArray"}],
+      "default": {}
+    },
+    "maxItems": {"$ref": "#/definitions/positiveInteger"},
+    "minItems": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxProperties": {"$ref": "#/definitions/positiveInteger"},
+    "minProperties": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "required": {"$ref": "#/definitions/stringArray"},
+    "additionalProperties": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/stringArray"}]
+      }
+    },
+    "enum": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        {"$ref": "#/definitions/simpleTypes"},
+        {
+          "type": "array",
+          "items": {"$ref": "#/definitions/simpleTypes"},
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "allOf": {"$ref": "#/definitions/schemaArray"},
+    "anyOf": {"$ref": "#/definitions/schemaArray"},
+    "oneOf": {"$ref": "#/definitions/schemaArray"},
+    "not": {"$ref": "#"}
+  },
+  "dependencies": {
+    "exclusiveMaximum": ["maximum"],
+    "exclusiveMinimum": ["minimum"]
+  },
+  "default": {}
+}

server/node_modules/ajv-draft-04/src/vocabulary/core.ts

@@ -0,0 +1,13 @@
+import type {Vocabulary} from "ajv/dist/core"
+import refKeyword from "ajv/dist/vocabularies/core/ref"
+
+const core: Vocabulary = [
+  "$schema",
+  "id",
+  "$defs",
+  {keyword: "$comment"},
+  "definitions",
+  refKeyword,
+]
+
+export default core

server/node_modules/ajv-draft-04/src/vocabulary/draft4.ts

@@ -0,0 +1,17 @@
+import type {Vocabulary} from "ajv/dist/core"
+import coreVocabulary from "./core"
+import validationDraft4 from "./validation"
+import getApplicatorVocabulary from "ajv/dist/vocabularies/applicator"
+import formatVocabulary from "ajv/dist/vocabularies/format"
+
+const metadataVocabulary: Vocabulary = ["title", "description", "default"]
+
+const draft4Vocabularies: Vocabulary[] = [
+  coreVocabulary,
+  validationDraft4,
+  getApplicatorVocabulary(),
+  formatVocabulary,
+  metadataVocabulary,
+]
+
+export default draft4Vocabularies

server/node_modules/ajv-draft-04/src/vocabulary/validation/index.ts

@@ -0,0 +1,51 @@
+import type {ErrorObject, Vocabulary} from "ajv/dist/core"
+import limitNumber, {LimitNumberError} from "./limitNumber"
+import limitNumberExclusive from "./limitNumberExclusive"
+import multipleOf, {MultipleOfError} from "ajv/dist/vocabularies/validation/multipleOf"
+import limitLength from "ajv/dist/vocabularies/validation/limitLength"
+import pattern, {PatternError} from "ajv/dist/vocabularies/validation/pattern"
+import limitProperties from "ajv/dist/vocabularies/validation/limitProperties"
+import required, {RequiredError} from "ajv/dist/vocabularies/validation/required"
+import limitItems from "ajv/dist/vocabularies/validation/limitItems"
+import uniqueItems, {UniqueItemsError} from "ajv/dist/vocabularies/validation/uniqueItems"
+import constKeyword, {ConstError} from "ajv/dist/vocabularies/validation/const"
+import enumKeyword, {EnumError} from "ajv/dist/vocabularies/validation/enum"
+
+const validation: Vocabulary = [
+  // number
+  limitNumber,
+  limitNumberExclusive,
+  multipleOf,
+  // string
+  limitLength,
+  pattern,
+  // object
+  limitProperties,
+  required,
+  // array
+  limitItems,
+  uniqueItems,
+  // any
+  {keyword: "type", schemaType: ["string", "array"]},
+  {keyword: "nullable", schemaType: "boolean"},
+  constKeyword,
+  enumKeyword,
+]
+
+export default validation
+
+type LimitError = ErrorObject<
+  "maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength",
+  {limit: number},
+  number | {$data: string}
+>
+
+export type ValidationKeywordError =
+  | LimitError
+  | LimitNumberError
+  | MultipleOfError
+  | PatternError
+  | RequiredError
+  | UniqueItemsError
+  | ConstError
+  | EnumError

server/node_modules/ajv-draft-04/src/vocabulary/validation/limitNumber.ts

@@ -0,0 +1,76 @@
+import type {
+  CodeKeywordDefinition,
+  ErrorObject,
+  KeywordCxt,
+  KeywordErrorDefinition,
+} from "ajv/dist/core"
+import type {KeywordErrorCxt} from "ajv/dist/types"
+import {_, str, Code} from "ajv/dist/core"
+import {operators} from "ajv/dist/compile/codegen"
+
+const ops = operators
+
+export type LimitKwd = "maximum" | "minimum"
+
+export type ExclusiveLimitKwd = "exclusiveMaximum" | "exclusiveMinimum"
+
+type Comparison = "<=" | ">=" | "<" | ">"
+
+interface KwdOp {
+  okStr: Comparison
+  ok: Code
+  fail: Code
+}
+
+interface KwdDef {
+  exclusive: ExclusiveLimitKwd
+  ops: [KwdOp, KwdOp]
+}
+
+const KWDs: {[K in LimitKwd]: KwdDef} = {
+  maximum: {
+    exclusive: "exclusiveMaximum",
+    ops: [
+      {okStr: "<=", ok: ops.LTE, fail: ops.GT},
+      {okStr: "<", ok: ops.LT, fail: ops.GTE},
+    ],
+  },
+  minimum: {
+    exclusive: "exclusiveMinimum",
+    ops: [
+      {okStr: ">=", ok: ops.GTE, fail: ops.LT},
+      {okStr: ">", ok: ops.GT, fail: ops.LTE},
+    ],
+  },
+}
+
+export type LimitNumberError = ErrorObject<
+  LimitKwd,
+  {limit: number; comparison: Comparison},
+  number | {$data: string}
+>
+
+const error: KeywordErrorDefinition = {
+  message: (cxt) => str`must be ${kwdOp(cxt).okStr} ${cxt.schemaCode}`,
+  params: (cxt) => _`{comparison: ${kwdOp(cxt).okStr}, limit: ${cxt.schemaCode}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "number",
+  $data: true,
+  error,
+  code(cxt: KeywordCxt) {
+    const {data, schemaCode} = cxt
+    cxt.fail$data(_`${data} ${kwdOp(cxt).fail} ${schemaCode} || isNaN(${data})`)
+  },
+}
+
+function kwdOp(cxt: KeywordErrorCxt): KwdOp {
+  const keyword = cxt.keyword as LimitKwd
+  const opsIdx = cxt.parentSchema?.[KWDs[keyword].exclusive] ? 1 : 0
+  return KWDs[keyword].ops[opsIdx]
+}
+
+export default def

server/node_modules/ajv-draft-04/src/vocabulary/validation/limitNumberExclusive.ts

@@ -0,0 +1,26 @@
+import type {
+  CodeKeywordDefinition,
+  // ErrorObject,
+  KeywordCxt,
+  // KeywordErrorDefinition,
+} from "ajv/dist/core"
+import {LimitKwd, ExclusiveLimitKwd} from "./limitNumber"
+
+const KWDs: {[K in ExclusiveLimitKwd]: LimitKwd} = {
+  exclusiveMaximum: "maximum",
+  exclusiveMinimum: "minimum",
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "boolean",
+  code({keyword, parentSchema}: KeywordCxt) {
+    const limitKwd = KWDs[keyword as ExclusiveLimitKwd]
+    if (parentSchema[limitKwd] === undefined) {
+      throw new Error(`${keyword} can only be used with ${limitKwd}`)
+    }
+  },
+}
+
+export default def