@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/ajv/lib/refs/jtd-schema.ts

@@ -0,0 +1,130 @@
+import {SchemaObject} from "../types"
+
+type MetaSchema = (root: boolean) => SchemaObject
+
+const shared: MetaSchema = (root) => {
+  const sch: SchemaObject = {
+    nullable: {type: "boolean"},
+    metadata: {
+      optionalProperties: {
+        union: {elements: {ref: "schema"}},
+      },
+      additionalProperties: true,
+    },
+  }
+  if (root) sch.definitions = {values: {ref: "schema"}}
+  return sch
+}
+
+const emptyForm: MetaSchema = (root) => ({
+  optionalProperties: shared(root),
+})
+
+const refForm: MetaSchema = (root) => ({
+  properties: {
+    ref: {type: "string"},
+  },
+  optionalProperties: shared(root),
+})
+
+const typeForm: MetaSchema = (root) => ({
+  properties: {
+    type: {
+      enum: [
+        "boolean",
+        "timestamp",
+        "string",
+        "float32",
+        "float64",
+        "int8",
+        "uint8",
+        "int16",
+        "uint16",
+        "int32",
+        "uint32",
+      ],
+    },
+  },
+  optionalProperties: shared(root),
+})
+
+const enumForm: MetaSchema = (root) => ({
+  properties: {
+    enum: {elements: {type: "string"}},
+  },
+  optionalProperties: shared(root),
+})
+
+const elementsForm: MetaSchema = (root) => ({
+  properties: {
+    elements: {ref: "schema"},
+  },
+  optionalProperties: shared(root),
+})
+
+const propertiesForm: MetaSchema = (root) => ({
+  properties: {
+    properties: {values: {ref: "schema"}},
+  },
+  optionalProperties: {
+    optionalProperties: {values: {ref: "schema"}},
+    additionalProperties: {type: "boolean"},
+    ...shared(root),
+  },
+})
+
+const optionalPropertiesForm: MetaSchema = (root) => ({
+  properties: {
+    optionalProperties: {values: {ref: "schema"}},
+  },
+  optionalProperties: {
+    additionalProperties: {type: "boolean"},
+    ...shared(root),
+  },
+})
+
+const discriminatorForm: MetaSchema = (root) => ({
+  properties: {
+    discriminator: {type: "string"},
+    mapping: {
+      values: {
+        metadata: {
+          union: [propertiesForm(false), optionalPropertiesForm(false)],
+        },
+      },
+    },
+  },
+  optionalProperties: shared(root),
+})
+
+const valuesForm: MetaSchema = (root) => ({
+  properties: {
+    values: {ref: "schema"},
+  },
+  optionalProperties: shared(root),
+})
+
+const schema: MetaSchema = (root) => ({
+  metadata: {
+    union: [
+      emptyForm,
+      refForm,
+      typeForm,
+      enumForm,
+      elementsForm,
+      propertiesForm,
+      optionalPropertiesForm,
+      discriminatorForm,
+      valuesForm,
+    ].map((s) => s(root)),
+  },
+})
+
+const jtdMetaSchema: SchemaObject = {
+  definitions: {
+    schema: schema(false),
+  },
+  ...schema(true),
+}
+
+export default jtdMetaSchema

package/node_modules/ajv/lib/runtime/equal.ts

@@ -0,0 +1,7 @@
+// https://github.com/ajv-validator/ajv/issues/889
+import * as equal from "fast-deep-equal"
+
+type Equal = typeof equal & {code: string}
+;(equal as Equal).code = 'require("ajv/dist/runtime/equal").default'
+
+export default equal as Equal

package/node_modules/ajv/lib/runtime/parseJson.ts

@@ -0,0 +1,177 @@
+const rxParseJson = /position\s(\d+)(?: \(line \d+ column \d+\))?$/
+
+export function parseJson(s: string, pos: number): unknown {
+  let endPos: number | undefined
+  parseJson.message = undefined
+  let matches: RegExpExecArray | null
+  if (pos) s = s.slice(pos)
+  try {
+    parseJson.position = pos + s.length
+    return JSON.parse(s)
+  } catch (e) {
+    matches = rxParseJson.exec((e as Error).message)
+    if (!matches) {
+      parseJson.message = "unexpected end"
+      return undefined
+    }
+    endPos = +matches[1]
+    const c = s[endPos]
+    s = s.slice(0, endPos)
+    parseJson.position = pos + endPos
+    try {
+      return JSON.parse(s)
+    } catch (e1) {
+      parseJson.message = `unexpected token ${c}`
+      return undefined
+    }
+  }
+}
+
+parseJson.message = undefined as string | undefined
+parseJson.position = 0 as number
+parseJson.code = 'require("ajv/dist/runtime/parseJson").parseJson'
+
+export function parseJsonNumber(s: string, pos: number, maxDigits?: number): number | undefined {
+  let numStr = ""
+  let c: string
+  parseJsonNumber.message = undefined
+  if (s[pos] === "-") {
+    numStr += "-"
+    pos++
+  }
+  if (s[pos] === "0") {
+    numStr += "0"
+    pos++
+  } else {
+    if (!parseDigits(maxDigits)) {
+      errorMessage()
+      return undefined
+    }
+  }
+  if (maxDigits) {
+    parseJsonNumber.position = pos
+    return +numStr
+  }
+  if (s[pos] === ".") {
+    numStr += "."
+    pos++
+    if (!parseDigits()) {
+      errorMessage()
+      return undefined
+    }
+  }
+  if (((c = s[pos]), c === "e" || c === "E")) {
+    numStr += "e"
+    pos++
+    if (((c = s[pos]), c === "+" || c === "-")) {
+      numStr += c
+      pos++
+    }
+    if (!parseDigits()) {
+      errorMessage()
+      return undefined
+    }
+  }
+  parseJsonNumber.position = pos
+  return +numStr
+
+  function parseDigits(maxLen?: number): boolean {
+    let digit = false
+    while (((c = s[pos]), c >= "0" && c <= "9" && (maxLen === undefined || maxLen-- > 0))) {
+      digit = true
+      numStr += c
+      pos++
+    }
+    return digit
+  }
+
+  function errorMessage(): void {
+    parseJsonNumber.position = pos
+    parseJsonNumber.message = pos < s.length ? `unexpected token ${s[pos]}` : "unexpected end"
+  }
+}
+
+parseJsonNumber.message = undefined as string | undefined
+parseJsonNumber.position = 0 as number
+parseJsonNumber.code = 'require("ajv/dist/runtime/parseJson").parseJsonNumber'
+
+const escapedChars: {[X in string]?: string} = {
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "\t",
+  '"': '"',
+  "/": "/",
+  "\\": "\\",
+}
+
+const CODE_A: number = "a".charCodeAt(0)
+const CODE_0: number = "0".charCodeAt(0)
+
+export function parseJsonString(s: string, pos: number): string | undefined {
+  let str = ""
+  let c: string | undefined
+  parseJsonString.message = undefined
+  // eslint-disable-next-line no-constant-condition, @typescript-eslint/no-unnecessary-condition
+  while (true) {
+    c = s[pos++]
+    if (c === '"') break
+    if (c === "\\") {
+      c = s[pos]
+      if (c in escapedChars) {
+        str += escapedChars[c]
+        pos++
+      } else if (c === "u") {
+        pos++
+        let count = 4
+        let code = 0
+        while (count--) {
+          code <<= 4
+          c = s[pos]
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (c === undefined) {
+            errorMessage("unexpected end")
+            return undefined
+          }
+          c = c.toLowerCase()
+          if (c >= "a" && c <= "f") {
+            code += c.charCodeAt(0) - CODE_A + 10
+          } else if (c >= "0" && c <= "9") {
+            code += c.charCodeAt(0) - CODE_0
+          } else {
+            errorMessage(`unexpected token ${c}`)
+            return undefined
+          }
+          pos++
+        }
+        str += String.fromCharCode(code)
+      } else {
+        errorMessage(`unexpected token ${c}`)
+        return undefined
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    } else if (c === undefined) {
+      errorMessage("unexpected end")
+      return undefined
+    } else {
+      if (c.charCodeAt(0) >= 0x20) {
+        str += c
+      } else {
+        errorMessage(`unexpected token ${c}`)
+        return undefined
+      }
+    }
+  }
+  parseJsonString.position = pos
+  return str
+
+  function errorMessage(msg: string): void {
+    parseJsonString.position = pos
+    parseJsonString.message = msg
+  }
+}
+
+parseJsonString.message = undefined as string | undefined
+parseJsonString.position = 0 as number
+parseJsonString.code = 'require("ajv/dist/runtime/parseJson").parseJsonString'

package/node_modules/ajv/lib/runtime/quote.ts

@@ -0,0 +1,31 @@
+const rxEscapable =
+  // eslint-disable-next-line no-control-regex, no-misleading-character-class
+  /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g
+
+const escaped: {[K in string]?: string} = {
+  "\b": "\\b",
+  "\t": "\\t",
+  "\n": "\\n",
+  "\f": "\\f",
+  "\r": "\\r",
+  '"': '\\"',
+  "\\": "\\\\",
+}
+
+export default function quote(s: string): string {
+  rxEscapable.lastIndex = 0
+  return (
+    '"' +
+    (rxEscapable.test(s)
+      ? s.replace(rxEscapable, (a) => {
+          const c = escaped[a]
+          return typeof c === "string"
+            ? c
+            : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
+        })
+      : s) +
+    '"'
+  )
+}
+
+quote.code = 'require("ajv/dist/runtime/quote").default'

package/node_modules/ajv/lib/runtime/re2.ts

@@ -0,0 +1,6 @@
+import * as re2 from "re2"
+
+type Re2 = typeof re2 & {code: string}
+;(re2 as Re2).code = 'require("ajv/dist/runtime/re2").default'
+
+export default re2 as Re2

package/node_modules/ajv/lib/runtime/timestamp.ts

@@ -0,0 +1,46 @@
+const DT_SEPARATOR = /t|\s/i
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+const TIME = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:z|([+-]\d\d)(?::?(\d\d))?)$/i
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+export default function validTimestamp(str: string, allowDate: boolean): boolean {
+  // http://tools.ietf.org/html/rfc3339#section-5.6
+  const dt: string[] = str.split(DT_SEPARATOR)
+  return (
+    (dt.length === 2 && validDate(dt[0]) && validTime(dt[1])) ||
+    (allowDate && dt.length === 1 && validDate(dt[0]))
+  )
+}
+
+function validDate(str: string): boolean {
+  const matches: string[] | null = DATE.exec(str)
+  if (!matches) return false
+  const y: number = +matches[1]
+  const m: number = +matches[2]
+  const d: number = +matches[3]
+  return (
+    m >= 1 &&
+    m <= 12 &&
+    d >= 1 &&
+    (d <= DAYS[m] ||
+      // leap year: https://tools.ietf.org/html/rfc3339#appendix-C
+      (m === 2 && d === 29 && (y % 100 === 0 ? y % 400 === 0 : y % 4 === 0)))
+  )
+}
+
+function validTime(str: string): boolean {
+  const matches: string[] | null = TIME.exec(str)
+  if (!matches) return false
+  const hr: number = +matches[1]
+  const min: number = +matches[2]
+  const sec: number = +matches[3]
+  const tzH: number = +(matches[4] || 0)
+  const tzM: number = +(matches[5] || 0)
+  return (
+    (hr <= 23 && min <= 59 && sec <= 59) ||
+    // leap second
+    (hr - tzH === 23 && min - tzM === 59 && sec === 60)
+  )
+}
+
+validTimestamp.code = 'require("ajv/dist/runtime/timestamp").default'

package/node_modules/ajv/lib/runtime/ucs2length.ts

@@ -0,0 +1,20 @@
+// https://mathiasbynens.be/notes/javascript-encoding
+// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode
+export default function ucs2length(str: string): number {
+  const len = str.length
+  let length = 0
+  let pos = 0
+  let value: number
+  while (pos < len) {
+    length++
+    value = str.charCodeAt(pos++)
+    if (value >= 0xd800 && value <= 0xdbff && pos < len) {
+      // high surrogate, and there is a next character
+      value = str.charCodeAt(pos)
+      if ((value & 0xfc00) === 0xdc00) pos++ // low surrogate
+    }
+  }
+  return length
+}
+
+ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default'

package/node_modules/ajv/lib/runtime/uri.ts

@@ -0,0 +1,6 @@
+import * as uri from "fast-uri"
+
+type URI = typeof uri & {code: string}
+;(uri as URI).code = 'require("ajv/dist/runtime/uri").default'
+
+export default uri as URI

package/node_modules/ajv/lib/runtime/validation_error.ts

@@ -0,0 +1,13 @@
+import type {ErrorObject} from "../types"
+
+export default class ValidationError extends Error {
+  readonly errors: Partial<ErrorObject>[]
+  readonly ajv: true
+  readonly validation: true
+
+  constructor(errors: Partial<ErrorObject>[]) {
+    super("validation failed")
+    this.errors = errors
+    this.ajv = this.validation = true
+  }
+}

package/node_modules/ajv/lib/standalone/index.ts

@@ -0,0 +1,100 @@
+import type AjvCore from "../core"
+import type {AnyValidateFunction, SourceCode} from "../types"
+import type {SchemaEnv} from "../compile"
+import {UsedScopeValues, UsedValueState, ValueScopeName, varKinds} from "../compile/codegen/scope"
+import {_, nil, _Code, Code, getProperty, getEsmExportName} from "../compile/codegen/code"
+
+function standaloneCode(
+  ajv: AjvCore,
+  refsOrFunc?: {[K in string]?: string} | AnyValidateFunction
+): string {
+  if (!ajv.opts.code.source) {
+    throw new Error("moduleCode: ajv instance must have code.source option")
+  }
+  const {_n} = ajv.scope.opts
+  return typeof refsOrFunc == "function"
+    ? funcExportCode(refsOrFunc.source)
+    : refsOrFunc !== undefined
+    ? multiExportsCode<string>(refsOrFunc, getValidate)
+    : multiExportsCode<SchemaEnv>(ajv.schemas, (sch) =>
+        sch.meta ? undefined : ajv.compile(sch.schema)
+      )
+
+  function getValidate(id: string): AnyValidateFunction {
+    const v = ajv.getSchema(id)
+    if (!v) throw new Error(`moduleCode: no schema with id ${id}`)
+    return v
+  }
+
+  function funcExportCode(source?: SourceCode): string {
+    const usedValues: UsedScopeValues = {}
+    const n = source?.validateName
+    const vCode = validateCode(usedValues, source)
+    if (ajv.opts.code.esm) {
+      // Always do named export as `validate` rather than the variable `n` which is `validateXX` for known export value
+      return `"use strict";${_n}export const validate = ${n};${_n}export default ${n};${_n}${vCode}`
+    }
+    return `"use strict";${_n}module.exports = ${n};${_n}module.exports.default = ${n};${_n}${vCode}`
+  }
+
+  function multiExportsCode<T extends SchemaEnv | string>(
+    schemas: {[K in string]?: T},
+    getValidateFunc: (schOrId: T) => AnyValidateFunction | undefined
+  ): string {
+    const usedValues: UsedScopeValues = {}
+    let code = _`"use strict";`
+    for (const name in schemas) {
+      const v = getValidateFunc(schemas[name] as T)
+      if (v) {
+        const vCode = validateCode(usedValues, v.source)
+        const exportSyntax = ajv.opts.code.esm
+          ? _`export const ${getEsmExportName(name)}`
+          : _`exports${getProperty(name)}`
+        code = _`${code}${_n}${exportSyntax} = ${v.source?.validateName};${_n}${vCode}`
+      }
+    }
+    return `${code}`
+  }
+
+  function validateCode(usedValues: UsedScopeValues, s?: SourceCode): Code {
+    if (!s) throw new Error('moduleCode: function does not have "source" property')
+    if (usedState(s.validateName) === UsedValueState.Completed) return nil
+    setUsedState(s.validateName, UsedValueState.Started)
+
+    const scopeCode = ajv.scope.scopeCode(s.scopeValues, usedValues, refValidateCode)
+    const code = new _Code(`${scopeCode}${_n}${s.validateCode}`)
+    return s.evaluated ? _`${code}${s.validateName}.evaluated = ${s.evaluated};${_n}` : code
+
+    function refValidateCode(n: ValueScopeName): Code | undefined {
+      const vRef = n.value?.ref
+      if (n.prefix === "validate" && typeof vRef == "function") {
+        const v = vRef as AnyValidateFunction
+        return validateCode(usedValues, v.source)
+      } else if ((n.prefix === "root" || n.prefix === "wrapper") && typeof vRef == "object") {
+        const {validate, validateName} = vRef as SchemaEnv
+        if (!validateName) throw new Error("ajv internal error")
+        const def = ajv.opts.code.es5 ? varKinds.var : varKinds.const
+        const wrapper = _`${def} ${n} = {validate: ${validateName}};`
+        if (usedState(validateName) === UsedValueState.Started) return wrapper
+        const vCode = validateCode(usedValues, validate?.source)
+        return _`${wrapper}${_n}${vCode}`
+      }
+      return undefined
+    }
+
+    function usedState(name: ValueScopeName): UsedValueState | undefined {
+      return usedValues[name.prefix]?.get(name)
+    }
+
+    function setUsedState(name: ValueScopeName, state: UsedValueState): void {
+      const {prefix} = name
+      const names = (usedValues[prefix] = usedValues[prefix] || new Map())
+      names.set(name, state)
+    }
+  }
+}
+
+module.exports = exports = standaloneCode
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default standaloneCode

package/node_modules/ajv/lib/standalone/instance.ts

@@ -0,0 +1,36 @@
+import Ajv, {AnySchema, AnyValidateFunction, ErrorObject} from "../core"
+import standaloneCode from "."
+import * as requireFromString from "require-from-string"
+
+export default class AjvPack {
+  errors?: ErrorObject[] | null // errors from the last validation
+  constructor(readonly ajv: Ajv) {}
+
+  validate(schemaKeyRef: AnySchema | string, data: unknown): boolean | Promise<unknown> {
+    return Ajv.prototype.validate.call(this, schemaKeyRef, data)
+  }
+
+  compile<T = unknown>(schema: AnySchema, meta?: boolean): AnyValidateFunction<T> {
+    return this.getStandalone(this.ajv.compile<T>(schema, meta))
+  }
+
+  getSchema<T = unknown>(keyRef: string): AnyValidateFunction<T> | undefined {
+    const v = this.ajv.getSchema<T>(keyRef)
+    if (!v) return undefined
+    return this.getStandalone(v)
+  }
+
+  private getStandalone<T = unknown>(v: AnyValidateFunction<T>): AnyValidateFunction<T> {
+    return requireFromString(standaloneCode(this.ajv, v)) as AnyValidateFunction<T>
+  }
+
+  addSchema(...args: Parameters<typeof Ajv.prototype.addSchema>): AjvPack {
+    this.ajv.addSchema.call(this.ajv, ...args)
+    return this
+  }
+
+  addKeyword(...args: Parameters<typeof Ajv.prototype.addKeyword>): AjvPack {
+    this.ajv.addKeyword.call(this.ajv, ...args)
+    return this
+  }
+}