@mininglamp-oss/octo-runtime 1.0.1 → 1.1.0

package/node_modules/ajv/lib/compile/names.ts

@@ -1,27 +0,0 @@
-import {Name} from "./codegen"
-
-const names = {
-  // validation function arguments
-  data: new Name("data"), // data passed to validation function
-  // args passed from referencing schema
-  valCxt: new Name("valCxt"), // validation/data context - should not be used directly, it is destructured to the names below
-  instancePath: new Name("instancePath"),
-  parentData: new Name("parentData"),
-  parentDataProperty: new Name("parentDataProperty"),
-  rootData: new Name("rootData"), // root data - same as the data passed to the first/top validation function
-  dynamicAnchors: new Name("dynamicAnchors"), // used to support recursiveRef and dynamicRef
-  // function scoped variables
-  vErrors: new Name("vErrors"), // null or array of validation errors
-  errors: new Name("errors"), // counter of validation errors
-  this: new Name("this"),
-  // "globals"
-  self: new Name("self"),
-  scope: new Name("scope"),
-  // JTD serialize/parse name for JSON string and position
-  json: new Name("json"),
-  jsonPos: new Name("jsonPos"),
-  jsonLen: new Name("jsonLen"),
-  jsonPart: new Name("jsonPart"),
-}
-
-export default names

package/node_modules/ajv/lib/compile/ref_error.ts

@@ -1,13 +0,0 @@
-import {resolveUrl, normalizeId, getFullPath} from "./resolve"
-import type {UriResolver} from "../types"
-
-export default class MissingRefError extends Error {
-  readonly missingRef: string
-  readonly missingSchema: string
-
-  constructor(resolver: UriResolver, baseId: string, ref: string, msg?: string) {
-    super(msg || `can't resolve reference ${ref} from id ${baseId}`)
-    this.missingRef = resolveUrl(resolver, baseId, ref)
-    this.missingSchema = normalizeId(getFullPath(resolver, this.missingRef))
-  }
-}

package/node_modules/ajv/lib/compile/resolve.ts

@@ -1,149 +0,0 @@
-import type {AnySchema, AnySchemaObject, UriResolver} from "../types"
-import type Ajv from "../ajv"
-import type {URIComponent} from "fast-uri"
-import {eachItem} from "./util"
-import * as equal from "fast-deep-equal"
-import * as traverse from "json-schema-traverse"
-
-// the hash of local references inside the schema (created by getSchemaRefs), used for inline resolution
-export type LocalRefs = {[Ref in string]?: AnySchemaObject}
-
-// TODO refactor to use keyword definitions
-const SIMPLE_INLINED = new Set([
-  "type",
-  "format",
-  "pattern",
-  "maxLength",
-  "minLength",
-  "maxProperties",
-  "minProperties",
-  "maxItems",
-  "minItems",
-  "maximum",
-  "minimum",
-  "uniqueItems",
-  "multipleOf",
-  "required",
-  "enum",
-  "const",
-])
-
-export function inlineRef(schema: AnySchema, limit: boolean | number = true): boolean {
-  if (typeof schema == "boolean") return true
-  if (limit === true) return !hasRef(schema)
-  if (!limit) return false
-  return countKeys(schema) <= limit
-}
-
-const REF_KEYWORDS = new Set([
-  "$ref",
-  "$recursiveRef",
-  "$recursiveAnchor",
-  "$dynamicRef",
-  "$dynamicAnchor",
-])
-
-function hasRef(schema: AnySchemaObject): boolean {
-  for (const key in schema) {
-    if (REF_KEYWORDS.has(key)) return true
-    const sch = schema[key]
-    if (Array.isArray(sch) && sch.some(hasRef)) return true
-    if (typeof sch == "object" && hasRef(sch)) return true
-  }
-  return false
-}
-
-function countKeys(schema: AnySchemaObject): number {
-  let count = 0
-  for (const key in schema) {
-    if (key === "$ref") return Infinity
-    count++
-    if (SIMPLE_INLINED.has(key)) continue
-    if (typeof schema[key] == "object") {
-      eachItem(schema[key], (sch) => (count += countKeys(sch)))
-    }
-    if (count === Infinity) return Infinity
-  }
-  return count
-}
-
-export function getFullPath(resolver: UriResolver, id = "", normalize?: boolean): string {
-  if (normalize !== false) id = normalizeId(id)
-  const p = resolver.parse(id)
-  return _getFullPath(resolver, p)
-}
-
-export function _getFullPath(resolver: UriResolver, p: URIComponent): string {
-  const serialized = resolver.serialize(p)
-  return serialized.split("#")[0] + "#"
-}
-
-const TRAILING_SLASH_HASH = /#\/?$/
-export function normalizeId(id: string | undefined): string {
-  return id ? id.replace(TRAILING_SLASH_HASH, "") : ""
-}
-
-export function resolveUrl(resolver: UriResolver, baseId: string, id: string): string {
-  id = normalizeId(id)
-  return resolver.resolve(baseId, id)
-}
-
-const ANCHOR = /^[a-z_][-a-z0-9._]*$/i
-
-export function getSchemaRefs(this: Ajv, schema: AnySchema, baseId: string): LocalRefs {
-  if (typeof schema == "boolean") return {}
-  const {schemaId, uriResolver} = this.opts
-  const schId = normalizeId(schema[schemaId] || baseId)
-  const baseIds: {[JsonPtr in string]?: string} = {"": schId}
-  const pathPrefix = getFullPath(uriResolver, schId, false)
-  const localRefs: LocalRefs = {}
-  const schemaRefs: Set<string> = new Set()
-
-  traverse(schema, {allKeys: true}, (sch, jsonPtr, _, parentJsonPtr) => {
-    if (parentJsonPtr === undefined) return
-    const fullPath = pathPrefix + jsonPtr
-    let innerBaseId = baseIds[parentJsonPtr]
-    if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId])
-    addAnchor.call(this, sch.$anchor)
-    addAnchor.call(this, sch.$dynamicAnchor)
-    baseIds[jsonPtr] = innerBaseId
-
-    function addRef(this: Ajv, ref: string): string {
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      const _resolve = this.opts.uriResolver.resolve
-      ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref)
-      if (schemaRefs.has(ref)) throw ambiguos(ref)
-      schemaRefs.add(ref)
-      let schOrRef = this.refs[ref]
-      if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef]
-      if (typeof schOrRef == "object") {
-        checkAmbiguosRef(sch, schOrRef.schema, ref)
-      } else if (ref !== normalizeId(fullPath)) {
-        if (ref[0] === "#") {
-          checkAmbiguosRef(sch, localRefs[ref], ref)
-          localRefs[ref] = sch
-        } else {
-          this.refs[ref] = fullPath
-        }
-      }
-      return ref
-    }
-
-    function addAnchor(this: Ajv, anchor: unknown): void {
-      if (typeof anchor == "string") {
-        if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor "${anchor}"`)
-        addRef.call(this, `#${anchor}`)
-      }
-    }
-  })
-
-  return localRefs
-
-  function checkAmbiguosRef(sch1: AnySchema, sch2: AnySchema | undefined, ref: string): void {
-    if (sch2 !== undefined && !equal(sch1, sch2)) throw ambiguos(ref)
-  }
-
-  function ambiguos(ref: string): Error {
-    return new Error(`reference "${ref}" resolves to more than one schema`)
-  }
-}

package/node_modules/ajv/lib/compile/rules.ts

@@ -1,50 +0,0 @@
-import type {AddedKeywordDefinition} from "../types"
-
-const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"] as const
-
-export type JSONType = (typeof _jsonTypes)[number]
-
-const jsonTypes: Set<string> = new Set(_jsonTypes)
-
-export function isJSONType(x: unknown): x is JSONType {
-  return typeof x == "string" && jsonTypes.has(x)
-}
-
-type ValidationTypes = {
-  [K in JSONType]: boolean | RuleGroup | undefined
-}
-
-export interface ValidationRules {
-  rules: RuleGroup[]
-  post: RuleGroup
-  all: {[Key in string]?: boolean | Rule} // rules that have to be validated
-  keywords: {[Key in string]?: boolean} // all known keywords (superset of "all")
-  types: ValidationTypes
-}
-
-export interface RuleGroup {
-  type?: JSONType
-  rules: Rule[]
-}
-
-// This interface wraps KeywordDefinition because definition can have multiple keywords
-export interface Rule {
-  keyword: string
-  definition: AddedKeywordDefinition
-}
-
-export function getRules(): ValidationRules {
-  const groups: Record<"number" | "string" | "array" | "object", RuleGroup> = {
-    number: {type: "number", rules: []},
-    string: {type: "string", rules: []},
-    array: {type: "array", rules: []},
-    object: {type: "object", rules: []},
-  }
-  return {
-    types: {...groups, integer: true, boolean: true, null: true},
-    rules: [{rules: []}, groups.number, groups.string, groups.array, groups.object],
-    post: {rules: []},
-    all: {},
-    keywords: {},
-  }
-}

package/node_modules/ajv/lib/compile/util.ts

@@ -1,213 +0,0 @@
-import type {AnySchema, EvaluatedProperties, EvaluatedItems} from "../types"
-import type {SchemaCxt, SchemaObjCxt} from "."
-import {_, getProperty, Code, Name, CodeGen} from "./codegen"
-import {_Code} from "./codegen/code"
-import type {Rule, ValidationRules} from "./rules"
-
-// TODO refactor to use Set
-export function toHash<T extends string = string>(arr: T[]): {[K in T]?: true} {
-  const hash: {[K in T]?: true} = {}
-  for (const item of arr) hash[item] = true
-  return hash
-}
-
-export function alwaysValidSchema(it: SchemaCxt, schema: AnySchema): boolean | void {
-  if (typeof schema == "boolean") return schema
-  if (Object.keys(schema).length === 0) return true
-  checkUnknownRules(it, schema)
-  return !schemaHasRules(schema, it.self.RULES.all)
-}
-
-export function checkUnknownRules(it: SchemaCxt, schema: AnySchema = it.schema): void {
-  const {opts, self} = it
-  if (!opts.strictSchema) return
-  if (typeof schema === "boolean") return
-  const rules = self.RULES.keywords
-  for (const key in schema) {
-    if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`)
-  }
-}
-
-export function schemaHasRules(
-  schema: AnySchema,
-  rules: {[Key in string]?: boolean | Rule}
-): boolean {
-  if (typeof schema == "boolean") return !schema
-  for (const key in schema) if (rules[key]) return true
-  return false
-}
-
-export function schemaHasRulesButRef(schema: AnySchema, RULES: ValidationRules): boolean {
-  if (typeof schema == "boolean") return !schema
-  for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true
-  return false
-}
-
-export function schemaRefOrVal(
-  {topSchemaRef, schemaPath}: SchemaObjCxt,
-  schema: unknown,
-  keyword: string,
-  $data?: string | false
-): Code | number | boolean {
-  if (!$data) {
-    if (typeof schema == "number" || typeof schema == "boolean") return schema
-    if (typeof schema == "string") return _`${schema}`
-  }
-  return _`${topSchemaRef}${schemaPath}${getProperty(keyword)}`
-}
-
-export function unescapeFragment(str: string): string {
-  return unescapeJsonPointer(decodeURIComponent(str))
-}
-
-export function escapeFragment(str: string | number): string {
-  return encodeURIComponent(escapeJsonPointer(str))
-}
-
-export function escapeJsonPointer(str: string | number): string {
-  if (typeof str == "number") return `${str}`
-  return str.replace(/~/g, "~0").replace(/\//g, "~1")
-}
-
-export function unescapeJsonPointer(str: string): string {
-  return str.replace(/~1/g, "/").replace(/~0/g, "~")
-}
-
-export function eachItem<T>(xs: T | T[], f: (x: T) => void): void {
-  if (Array.isArray(xs)) {
-    for (const x of xs) f(x)
-  } else {
-    f(xs)
-  }
-}
-
-type SomeEvaluated = EvaluatedProperties | EvaluatedItems
-
-type MergeEvaluatedFunc<T extends SomeEvaluated> = (
-  gen: CodeGen,
-  from: Name | T,
-  to: Name | Exclude<T, true> | undefined,
-  toName?: typeof Name
-) => Name | T
-
-interface MakeMergeFuncArgs<T extends SomeEvaluated> {
-  mergeNames: (gen: CodeGen, from: Name, to: Name) => void
-  mergeToName: (gen: CodeGen, from: T, to: Name) => void
-  mergeValues: (from: T, to: Exclude<T, true>) => T
-  resultToName: (gen: CodeGen, res?: T) => Name
-}
-
-function makeMergeEvaluated<T extends SomeEvaluated>({
-  mergeNames,
-  mergeToName,
-  mergeValues,
-  resultToName,
-}: MakeMergeFuncArgs<T>): MergeEvaluatedFunc<T> {
-  return (gen, from, to, toName) => {
-    const res =
-      to === undefined
-        ? from
-        : to instanceof Name
-        ? (from instanceof Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to)
-        : from instanceof Name
-        ? (mergeToName(gen, to, from), from)
-        : mergeValues(from, to)
-    return toName === Name && !(res instanceof Name) ? resultToName(gen, res) : res
-  }
-}
-
-interface MergeEvaluated {
-  props: MergeEvaluatedFunc<EvaluatedProperties>
-  items: MergeEvaluatedFunc<EvaluatedItems>
-}
-
-export const mergeEvaluated: MergeEvaluated = {
-  props: makeMergeEvaluated({
-    mergeNames: (gen, from, to) =>
-      gen.if(_`${to} !== true && ${from} !== undefined`, () => {
-        gen.if(
-          _`${from} === true`,
-          () => gen.assign(to, true),
-          () => gen.assign(to, _`${to} || {}`).code(_`Object.assign(${to}, ${from})`)
-        )
-      }),
-    mergeToName: (gen, from, to) =>
-      gen.if(_`${to} !== true`, () => {
-        if (from === true) {
-          gen.assign(to, true)
-        } else {
-          gen.assign(to, _`${to} || {}`)
-          setEvaluated(gen, to, from)
-        }
-      }),
-    mergeValues: (from, to) => (from === true ? true : {...from, ...to}),
-    resultToName: evaluatedPropsToName,
-  }),
-  items: makeMergeEvaluated({
-    mergeNames: (gen, from, to) =>
-      gen.if(_`${to} !== true && ${from} !== undefined`, () =>
-        gen.assign(to, _`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)
-      ),
-    mergeToName: (gen, from, to) =>
-      gen.if(_`${to} !== true`, () =>
-        gen.assign(to, from === true ? true : _`${to} > ${from} ? ${to} : ${from}`)
-      ),
-    mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),
-    resultToName: (gen, items) => gen.var("items", items),
-  }),
-}
-
-export function evaluatedPropsToName(gen: CodeGen, ps?: EvaluatedProperties): Name {
-  if (ps === true) return gen.var("props", true)
-  const props = gen.var("props", _`{}`)
-  if (ps !== undefined) setEvaluated(gen, props, ps)
-  return props
-}
-
-export function setEvaluated(gen: CodeGen, props: Name, ps: {[K in string]?: true}): void {
-  Object.keys(ps).forEach((p) => gen.assign(_`${props}${getProperty(p)}`, true))
-}
-
-const snippets: {[S in string]?: _Code} = {}
-
-export function useFunc(gen: CodeGen, f: {code: string}): Name {
-  return gen.scopeValue("func", {
-    ref: f,
-    code: snippets[f.code] || (snippets[f.code] = new _Code(f.code)),
-  })
-}
-
-export enum Type {
-  Num,
-  Str,
-}
-
-export function getErrorPath(
-  dataProp: Name | string | number,
-  dataPropType?: Type,
-  jsPropertySyntax?: boolean
-): Code | string {
-  // let path
-  if (dataProp instanceof Name) {
-    const isNumber = dataPropType === Type.Num
-    return jsPropertySyntax
-      ? isNumber
-        ? _`"[" + ${dataProp} + "]"`
-        : _`"['" + ${dataProp} + "']"`
-      : isNumber
-      ? _`"/" + ${dataProp}`
-      : _`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")` // TODO maybe use global escapePointer
-  }
-  return jsPropertySyntax ? getProperty(dataProp).toString() : "/" + escapeJsonPointer(dataProp)
-}
-
-export function checkStrictMode(
-  it: SchemaCxt,
-  msg: string,
-  mode: boolean | "log" = it.opts.strictSchema
-): void {
-  if (!mode) return
-  msg = `strict mode: ${msg}`
-  if (mode === true) throw new Error(msg)
-  it.self.logger.warn(msg)
-}

package/node_modules/ajv/lib/compile/validate/applicability.ts

@@ -1,22 +0,0 @@
-import type {AnySchemaObject} from "../../types"
-import type {SchemaObjCxt} from ".."
-import type {JSONType, RuleGroup, Rule} from "../rules"
-
-export function schemaHasRulesForType(
-  {schema, self}: SchemaObjCxt,
-  type: JSONType
-): boolean | undefined {
-  const group = self.RULES.types[type]
-  return group && group !== true && shouldUseGroup(schema, group)
-}
-
-export function shouldUseGroup(schema: AnySchemaObject, group: RuleGroup): boolean {
-  return group.rules.some((rule) => shouldUseRule(schema, rule))
-}
-
-export function shouldUseRule(schema: AnySchemaObject, rule: Rule): boolean | undefined {
-  return (
-    schema[rule.keyword] !== undefined ||
-    rule.definition.implements?.some((kwd) => schema[kwd] !== undefined)
-  )
-}

package/node_modules/ajv/lib/compile/validate/boolSchema.ts

@@ -1,47 +0,0 @@
-import type {KeywordErrorDefinition, KeywordErrorCxt} from "../../types"
-import type {SchemaCxt} from ".."
-import {reportError} from "../errors"
-import {_, Name} from "../codegen"
-import N from "../names"
-
-const boolError: KeywordErrorDefinition = {
-  message: "boolean schema is false",
-}
-
-export function topBoolOrEmptySchema(it: SchemaCxt): void {
-  const {gen, schema, validateName} = it
-  if (schema === false) {
-    falseSchemaError(it, false)
-  } else if (typeof schema == "object" && schema.$async === true) {
-    gen.return(N.data)
-  } else {
-    gen.assign(_`${validateName}.errors`, null)
-    gen.return(true)
-  }
-}
-
-export function boolOrEmptySchema(it: SchemaCxt, valid: Name): void {
-  const {gen, schema} = it
-  if (schema === false) {
-    gen.var(valid, false) // TODO var
-    falseSchemaError(it)
-  } else {
-    gen.var(valid, true) // TODO var
-  }
-}
-
-function falseSchemaError(it: SchemaCxt, overrideAllErrors?: boolean): void {
-  const {gen, data} = it
-  // TODO maybe some other interface should be used for non-keyword validation errors...
-  const cxt: KeywordErrorCxt = {
-    gen,
-    keyword: "false schema",
-    data,
-    schema: false,
-    schemaCode: false,
-    schemaValue: false,
-    params: {},
-    it,
-  }
-  reportError(cxt, boolError, undefined, overrideAllErrors)
-}