@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

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

@@ -1,130 +0,0 @@
-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

@@ -1,7 +0,0 @@
-// 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

@@ -1,177 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,20 +0,0 @@
-// 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

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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
-  }
-}