@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

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

@@ -1,171 +0,0 @@
-import type {KeywordCxt} from "."
-import type {
-  AnySchema,
-  SchemaValidateFunction,
-  AnyValidateFunction,
-  AddedKeywordDefinition,
-  MacroKeywordDefinition,
-  FuncKeywordDefinition,
-} from "../../types"
-import type {SchemaObjCxt} from ".."
-import {_, nil, not, stringify, Code, Name, CodeGen} from "../codegen"
-import N from "../names"
-import type {JSONType} from "../rules"
-import {callValidateCode} from "../../vocabularies/code"
-import {extendErrors} from "../errors"
-
-type KeywordCompilationResult = AnySchema | SchemaValidateFunction | AnyValidateFunction
-
-export function macroKeywordCode(cxt: KeywordCxt, def: MacroKeywordDefinition): void {
-  const {gen, keyword, schema, parentSchema, it} = cxt
-  const macroSchema = def.macro.call(it.self, schema, parentSchema, it)
-  const schemaRef = useKeyword(gen, keyword, macroSchema)
-  if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true)
-
-  const valid = gen.name("valid")
-  cxt.subschema(
-    {
-      schema: macroSchema,
-      schemaPath: nil,
-      errSchemaPath: `${it.errSchemaPath}/${keyword}`,
-      topSchemaRef: schemaRef,
-      compositeRule: true,
-    },
-    valid
-  )
-  cxt.pass(valid, () => cxt.error(true))
-}
-
-export function funcKeywordCode(cxt: KeywordCxt, def: FuncKeywordDefinition): void {
-  const {gen, keyword, schema, parentSchema, $data, it} = cxt
-  checkAsyncKeyword(it, def)
-  const validate =
-    !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate
-  const validateRef = useKeyword(gen, keyword, validate)
-  const valid = gen.let("valid")
-  cxt.block$data(valid, validateKeyword)
-  cxt.ok(def.valid ?? valid)
-
-  function validateKeyword(): void {
-    if (def.errors === false) {
-      assignValid()
-      if (def.modifying) modifyData(cxt)
-      reportErrs(() => cxt.error())
-    } else {
-      const ruleErrs = def.async ? validateAsync() : validateSync()
-      if (def.modifying) modifyData(cxt)
-      reportErrs(() => addErrs(cxt, ruleErrs))
-    }
-  }
-
-  function validateAsync(): Name {
-    const ruleErrs = gen.let("ruleErrs", null)
-    gen.try(
-      () => assignValid(_`await `),
-      (e) =>
-        gen.assign(valid, false).if(
-          _`${e} instanceof ${it.ValidationError as Name}`,
-          () => gen.assign(ruleErrs, _`${e}.errors`),
-          () => gen.throw(e)
-        )
-    )
-    return ruleErrs
-  }
-
-  function validateSync(): Code {
-    const validateErrs = _`${validateRef}.errors`
-    gen.assign(validateErrs, null)
-    assignValid(nil)
-    return validateErrs
-  }
-
-  function assignValid(_await: Code = def.async ? _`await ` : nil): void {
-    const passCxt = it.opts.passContext ? N.this : N.self
-    const passSchema = !(("compile" in def && !$data) || def.schema === false)
-    gen.assign(
-      valid,
-      _`${_await}${callValidateCode(cxt, validateRef, passCxt, passSchema)}`,
-      def.modifying
-    )
-  }
-
-  function reportErrs(errors: () => void): void {
-    gen.if(not(def.valid ?? valid), errors)
-  }
-}
-
-function modifyData(cxt: KeywordCxt): void {
-  const {gen, data, it} = cxt
-  gen.if(it.parentData, () => gen.assign(data, _`${it.parentData}[${it.parentDataProperty}]`))
-}
-
-function addErrs(cxt: KeywordCxt, errs: Code): void {
-  const {gen} = cxt
-  gen.if(
-    _`Array.isArray(${errs})`,
-    () => {
-      gen
-        .assign(N.vErrors, _`${N.vErrors} === null ? ${errs} : ${N.vErrors}.concat(${errs})`)
-        .assign(N.errors, _`${N.vErrors}.length`)
-      extendErrors(cxt)
-    },
-    () => cxt.error()
-  )
-}
-
-function checkAsyncKeyword({schemaEnv}: SchemaObjCxt, def: FuncKeywordDefinition): void {
-  if (def.async && !schemaEnv.$async) throw new Error("async keyword in sync schema")
-}
-
-function useKeyword(gen: CodeGen, keyword: string, result?: KeywordCompilationResult): Name {
-  if (result === undefined) throw new Error(`keyword "${keyword}" failed to compile`)
-  return gen.scopeValue(
-    "keyword",
-    typeof result == "function" ? {ref: result} : {ref: result, code: stringify(result)}
-  )
-}
-
-export function validSchemaType(
-  schema: unknown,
-  schemaType: JSONType[],
-  allowUndefined = false
-): boolean {
-  // TODO add tests
-  return (
-    !schemaType.length ||
-    schemaType.some((st) =>
-      st === "array"
-        ? Array.isArray(schema)
-        : st === "object"
-        ? schema && typeof schema == "object" && !Array.isArray(schema)
-        : typeof schema == st || (allowUndefined && typeof schema == "undefined")
-    )
-  )
-}
-
-export function validateKeywordUsage(
-  {schema, opts, self, errSchemaPath}: SchemaObjCxt,
-  def: AddedKeywordDefinition,
-  keyword: string
-): void {
-  /* istanbul ignore if */
-  if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
-    throw new Error("ajv implementation error")
-  }
-
-  const deps = def.dependencies
-  if (deps?.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
-    throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`)
-  }
-
-  if (def.validateSchema) {
-    const valid = def.validateSchema(schema[keyword])
-    if (!valid) {
-      const msg =
-        `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` +
-        self.errorsText(def.validateSchema.errors)
-      if (opts.validateSchema === "log") self.logger.error(msg)
-      else throw new Error(msg)
-    }
-  }
-}

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

@@ -1,135 +0,0 @@
-import type {AnySchema} from "../../types"
-import type {SchemaObjCxt} from ".."
-import {_, str, getProperty, Code, Name} from "../codegen"
-import {escapeFragment, getErrorPath, Type} from "../util"
-import type {JSONType} from "../rules"
-
-export interface SubschemaContext {
-  // TODO use Optional? align with SchemCxt property types
-  schema: AnySchema
-  schemaPath: Code
-  errSchemaPath: string
-  topSchemaRef?: Code
-  errorPath?: Code
-  dataLevel?: number
-  dataTypes?: JSONType[]
-  data?: Name
-  parentData?: Name
-  parentDataProperty?: Code | number
-  dataNames?: Name[]
-  dataPathArr?: (Code | number)[]
-  propertyName?: Name
-  jtdDiscriminator?: string
-  jtdMetadata?: boolean
-  compositeRule?: true
-  createErrors?: boolean
-  allErrors?: boolean
-}
-
-export type SubschemaArgs = Partial<{
-  keyword: string
-  schemaProp: string | number
-  schema: AnySchema
-  schemaPath: Code
-  errSchemaPath: string
-  topSchemaRef: Code
-  data: Name | Code
-  dataProp: Code | string | number
-  dataTypes: JSONType[]
-  definedProperties: Set<string>
-  propertyName: Name
-  dataPropType: Type
-  jtdDiscriminator: string
-  jtdMetadata: boolean
-  compositeRule: true
-  createErrors: boolean
-  allErrors: boolean
-}>
-
-export function getSubschema(
-  it: SchemaObjCxt,
-  {keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef}: SubschemaArgs
-): SubschemaContext {
-  if (keyword !== undefined && schema !== undefined) {
-    throw new Error('both "keyword" and "schema" passed, only one allowed')
-  }
-
-  if (keyword !== undefined) {
-    const sch = it.schema[keyword]
-    return schemaProp === undefined
-      ? {
-          schema: sch,
-          schemaPath: _`${it.schemaPath}${getProperty(keyword)}`,
-          errSchemaPath: `${it.errSchemaPath}/${keyword}`,
-        }
-      : {
-          schema: sch[schemaProp],
-          schemaPath: _`${it.schemaPath}${getProperty(keyword)}${getProperty(schemaProp)}`,
-          errSchemaPath: `${it.errSchemaPath}/${keyword}/${escapeFragment(schemaProp)}`,
-        }
-  }
-
-  if (schema !== undefined) {
-    if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
-      throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"')
-    }
-    return {
-      schema,
-      schemaPath,
-      topSchemaRef,
-      errSchemaPath,
-    }
-  }
-
-  throw new Error('either "keyword" or "schema" must be passed')
-}
-
-export function extendSubschemaData(
-  subschema: SubschemaContext,
-  it: SchemaObjCxt,
-  {dataProp, dataPropType: dpType, data, dataTypes, propertyName}: SubschemaArgs
-): void {
-  if (data !== undefined && dataProp !== undefined) {
-    throw new Error('both "data" and "dataProp" passed, only one allowed')
-  }
-
-  const {gen} = it
-
-  if (dataProp !== undefined) {
-    const {errorPath, dataPathArr, opts} = it
-    const nextData = gen.let("data", _`${it.data}${getProperty(dataProp)}`, true)
-    dataContextProps(nextData)
-    subschema.errorPath = str`${errorPath}${getErrorPath(dataProp, dpType, opts.jsPropertySyntax)}`
-    subschema.parentDataProperty = _`${dataProp}`
-    subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]
-  }
-
-  if (data !== undefined) {
-    const nextData = data instanceof Name ? data : gen.let("data", data, true) // replaceable if used once?
-    dataContextProps(nextData)
-    if (propertyName !== undefined) subschema.propertyName = propertyName
-    // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr
-  }
-
-  if (dataTypes) subschema.dataTypes = dataTypes
-
-  function dataContextProps(_nextData: Name): void {
-    subschema.data = _nextData
-    subschema.dataLevel = it.dataLevel + 1
-    subschema.dataTypes = []
-    it.definedProperties = new Set<string>()
-    subschema.parentData = it.data
-    subschema.dataNames = [...it.dataNames, _nextData]
-  }
-}
-
-export function extendSubschemaMode(
-  subschema: SubschemaContext,
-  {jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors}: SubschemaArgs
-): void {
-  if (compositeRule !== undefined) subschema.compositeRule = compositeRule
-  if (createErrors !== undefined) subschema.createErrors = createErrors
-  if (allErrors !== undefined) subschema.allErrors = allErrors
-  subschema.jtdDiscriminator = jtdDiscriminator // not inherited
-  subschema.jtdMetadata = jtdMetadata // not inherited
-}