@mininglamp-oss/octo-runtime 1.0.1 → 1.1.0

package/node_modules/ajv/lib/compile/codegen/scope.ts

@@ -1,215 +0,0 @@
-import {_, nil, Code, Name} from "./code"
-
-interface NameGroup {
-  prefix: string
-  index: number
-}
-
-export interface NameValue {
-  ref: ValueReference // this is the reference to any value that can be referred to from generated code via `globals` var in the closure
-  key?: unknown // any key to identify a global to avoid duplicates, if not passed ref is used
-  code?: Code // this is the code creating the value needed for standalone code wit_out closure - can be a primitive value, function or import (`require`)
-}
-
-export type ValueReference = unknown // possibly make CodeGen parameterized type on this type
-
-class ValueError extends Error {
-  readonly value?: NameValue
-  constructor(name: ValueScopeName) {
-    super(`CodeGen: "code" for ${name} not defined`)
-    this.value = name.value
-  }
-}
-
-interface ScopeOptions {
-  prefixes?: Set<string>
-  parent?: Scope
-}
-
-interface ValueScopeOptions extends ScopeOptions {
-  scope: ScopeStore
-  es5?: boolean
-  lines?: boolean
-}
-
-export type ScopeStore = Record<string, ValueReference[] | undefined>
-
-type ScopeValues = {
-  [Prefix in string]?: Map<unknown, ValueScopeName>
-}
-
-export type ScopeValueSets = {
-  [Prefix in string]?: Set<ValueScopeName>
-}
-
-export enum UsedValueState {
-  Started,
-  Completed,
-}
-
-export type UsedScopeValues = {
-  [Prefix in string]?: Map<ValueScopeName, UsedValueState | undefined>
-}
-
-export const varKinds = {
-  const: new Name("const"),
-  let: new Name("let"),
-  var: new Name("var"),
-}
-
-export class Scope {
-  protected readonly _names: {[Prefix in string]?: NameGroup} = {}
-  protected readonly _prefixes?: Set<string>
-  protected readonly _parent?: Scope
-
-  constructor({prefixes, parent}: ScopeOptions = {}) {
-    this._prefixes = prefixes
-    this._parent = parent
-  }
-
-  toName(nameOrPrefix: Name | string): Name {
-    return nameOrPrefix instanceof Name ? nameOrPrefix : this.name(nameOrPrefix)
-  }
-
-  name(prefix: string): Name {
-    return new Name(this._newName(prefix))
-  }
-
-  protected _newName(prefix: string): string {
-    const ng = this._names[prefix] || this._nameGroup(prefix)
-    return `${prefix}${ng.index++}`
-  }
-
-  private _nameGroup(prefix: string): NameGroup {
-    if (this._parent?._prefixes?.has(prefix) || (this._prefixes && !this._prefixes.has(prefix))) {
-      throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`)
-    }
-    return (this._names[prefix] = {prefix, index: 0})
-  }
-}
-
-interface ScopePath {
-  property: string
-  itemIndex: number
-}
-
-export class ValueScopeName extends Name {
-  readonly prefix: string
-  value?: NameValue
-  scopePath?: Code
-
-  constructor(prefix: string, nameStr: string) {
-    super(nameStr)
-    this.prefix = prefix
-  }
-
-  setValue(value: NameValue, {property, itemIndex}: ScopePath): void {
-    this.value = value
-    this.scopePath = _`.${new Name(property)}[${itemIndex}]`
-  }
-}
-
-interface VSOptions extends ValueScopeOptions {
-  _n: Code
-}
-
-const line = _`\n`
-
-export class ValueScope extends Scope {
-  protected readonly _values: ScopeValues = {}
-  protected readonly _scope: ScopeStore
-  readonly opts: VSOptions
-
-  constructor(opts: ValueScopeOptions) {
-    super(opts)
-    this._scope = opts.scope
-    this.opts = {...opts, _n: opts.lines ? line : nil}
-  }
-
-  get(): ScopeStore {
-    return this._scope
-  }
-
-  name(prefix: string): ValueScopeName {
-    return new ValueScopeName(prefix, this._newName(prefix))
-  }
-
-  value(nameOrPrefix: ValueScopeName | string, value: NameValue): ValueScopeName {
-    if (value.ref === undefined) throw new Error("CodeGen: ref must be passed in value")
-    const name = this.toName(nameOrPrefix) as ValueScopeName
-    const {prefix} = name
-    const valueKey = value.key ?? value.ref
-    let vs = this._values[prefix]
-    if (vs) {
-      const _name = vs.get(valueKey)
-      if (_name) return _name
-    } else {
-      vs = this._values[prefix] = new Map()
-    }
-    vs.set(valueKey, name)
-
-    const s = this._scope[prefix] || (this._scope[prefix] = [])
-    const itemIndex = s.length
-    s[itemIndex] = value.ref
-    name.setValue(value, {property: prefix, itemIndex})
-    return name
-  }
-
-  getValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined {
-    const vs = this._values[prefix]
-    if (!vs) return
-    return vs.get(keyOrRef)
-  }
-
-  scopeRefs(scopeName: Name, values: ScopeValues | ScopeValueSets = this._values): Code {
-    return this._reduceValues(values, (name: ValueScopeName) => {
-      if (name.scopePath === undefined) throw new Error(`CodeGen: name "${name}" has no value`)
-      return _`${scopeName}${name.scopePath}`
-    })
-  }
-
-  scopeCode(
-    values: ScopeValues | ScopeValueSets = this._values,
-    usedValues?: UsedScopeValues,
-    getCode?: (n: ValueScopeName) => Code | undefined
-  ): Code {
-    return this._reduceValues(
-      values,
-      (name: ValueScopeName) => {
-        if (name.value === undefined) throw new Error(`CodeGen: name "${name}" has no value`)
-        return name.value.code
-      },
-      usedValues,
-      getCode
-    )
-  }
-
-  private _reduceValues(
-    values: ScopeValues | ScopeValueSets,
-    valueCode: (n: ValueScopeName) => Code | undefined,
-    usedValues: UsedScopeValues = {},
-    getCode?: (n: ValueScopeName) => Code | undefined
-  ): Code {
-    let code: Code = nil
-    for (const prefix in values) {
-      const vs = values[prefix]
-      if (!vs) continue
-      const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map())
-      vs.forEach((name: ValueScopeName) => {
-        if (nameSet.has(name)) return
-        nameSet.set(name, UsedValueState.Started)
-        let c = valueCode(name)
-        if (c) {
-          const def = this.opts.es5 ? varKinds.var : varKinds.const
-          code = _`${code}${def} ${name} = ${c};${this.opts._n}`
-        } else if ((c = getCode?.(name))) {
-          code = _`${code}${c}${this.opts._n}`
-        } else {
-          throw new ValueError(name)
-        }
-        nameSet.set(name, UsedValueState.Completed)
-      })
-    }
-    return code
-  }
-}

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

@@ -1,184 +0,0 @@
-import type {KeywordErrorCxt, KeywordErrorDefinition} from "../types"
-import type {SchemaCxt} from "./index"
-import {CodeGen, _, str, strConcat, Code, Name} from "./codegen"
-import {SafeExpr} from "./codegen/code"
-import {getErrorPath, Type} from "./util"
-import N from "./names"
-
-export const keywordError: KeywordErrorDefinition = {
-  message: ({keyword}) => str`must pass "${keyword}" keyword validation`,
-}
-
-export const keyword$DataError: KeywordErrorDefinition = {
-  message: ({keyword, schemaType}) =>
-    schemaType
-      ? str`"${keyword}" keyword must be ${schemaType} ($data)`
-      : str`"${keyword}" keyword is invalid ($data)`,
-}
-
-export interface ErrorPaths {
-  instancePath?: Code
-  schemaPath?: string
-  parentSchema?: boolean
-}
-
-export function reportError(
-  cxt: KeywordErrorCxt,
-  error: KeywordErrorDefinition = keywordError,
-  errorPaths?: ErrorPaths,
-  overrideAllErrors?: boolean
-): void {
-  const {it} = cxt
-  const {gen, compositeRule, allErrors} = it
-  const errObj = errorObjectCode(cxt, error, errorPaths)
-  if (overrideAllErrors ?? (compositeRule || allErrors)) {
-    addError(gen, errObj)
-  } else {
-    returnErrors(it, _`[${errObj}]`)
-  }
-}
-
-export function reportExtraError(
-  cxt: KeywordErrorCxt,
-  error: KeywordErrorDefinition = keywordError,
-  errorPaths?: ErrorPaths
-): void {
-  const {it} = cxt
-  const {gen, compositeRule, allErrors} = it
-  const errObj = errorObjectCode(cxt, error, errorPaths)
-  addError(gen, errObj)
-  if (!(compositeRule || allErrors)) {
-    returnErrors(it, N.vErrors)
-  }
-}
-
-export function resetErrorsCount(gen: CodeGen, errsCount: Name): void {
-  gen.assign(N.errors, errsCount)
-  gen.if(_`${N.vErrors} !== null`, () =>
-    gen.if(
-      errsCount,
-      () => gen.assign(_`${N.vErrors}.length`, errsCount),
-      () => gen.assign(N.vErrors, null)
-    )
-  )
-}
-
-export function extendErrors({
-  gen,
-  keyword,
-  schemaValue,
-  data,
-  errsCount,
-  it,
-}: KeywordErrorCxt): void {
-  /* istanbul ignore if */
-  if (errsCount === undefined) throw new Error("ajv implementation error")
-  const err = gen.name("err")
-  gen.forRange("i", errsCount, N.errors, (i) => {
-    gen.const(err, _`${N.vErrors}[${i}]`)
-    gen.if(_`${err}.instancePath === undefined`, () =>
-      gen.assign(_`${err}.instancePath`, strConcat(N.instancePath, it.errorPath))
-    )
-    gen.assign(_`${err}.schemaPath`, str`${it.errSchemaPath}/${keyword}`)
-    if (it.opts.verbose) {
-      gen.assign(_`${err}.schema`, schemaValue)
-      gen.assign(_`${err}.data`, data)
-    }
-  })
-}
-
-function addError(gen: CodeGen, errObj: Code): void {
-  const err = gen.const("err", errObj)
-  gen.if(
-    _`${N.vErrors} === null`,
-    () => gen.assign(N.vErrors, _`[${err}]`),
-    _`${N.vErrors}.push(${err})`
-  )
-  gen.code(_`${N.errors}++`)
-}
-
-function returnErrors(it: SchemaCxt, errs: Code): void {
-  const {gen, validateName, schemaEnv} = it
-  if (schemaEnv.$async) {
-    gen.throw(_`new ${it.ValidationError as Name}(${errs})`)
-  } else {
-    gen.assign(_`${validateName}.errors`, errs)
-    gen.return(false)
-  }
-}
-
-const E = {
-  keyword: new Name("keyword"),
-  schemaPath: new Name("schemaPath"), // also used in JTD errors
-  params: new Name("params"),
-  propertyName: new Name("propertyName"),
-  message: new Name("message"),
-  schema: new Name("schema"),
-  parentSchema: new Name("parentSchema"),
-}
-
-function errorObjectCode(
-  cxt: KeywordErrorCxt,
-  error: KeywordErrorDefinition,
-  errorPaths?: ErrorPaths
-): Code {
-  const {createErrors} = cxt.it
-  if (createErrors === false) return _`{}`
-  return errorObject(cxt, error, errorPaths)
-}
-
-function errorObject(
-  cxt: KeywordErrorCxt,
-  error: KeywordErrorDefinition,
-  errorPaths: ErrorPaths = {}
-): Code {
-  const {gen, it} = cxt
-  const keyValues: [Name, SafeExpr | string][] = [
-    errorInstancePath(it, errorPaths),
-    errorSchemaPath(cxt, errorPaths),
-  ]
-  extraErrorProps(cxt, error, keyValues)
-  return gen.object(...keyValues)
-}
-
-function errorInstancePath({errorPath}: SchemaCxt, {instancePath}: ErrorPaths): [Name, Code] {
-  const instPath = instancePath
-    ? str`${errorPath}${getErrorPath(instancePath, Type.Str)}`
-    : errorPath
-  return [N.instancePath, strConcat(N.instancePath, instPath)]
-}
-
-function errorSchemaPath(
-  {keyword, it: {errSchemaPath}}: KeywordErrorCxt,
-  {schemaPath, parentSchema}: ErrorPaths
-): [Name, string | Code] {
-  let schPath = parentSchema ? errSchemaPath : str`${errSchemaPath}/${keyword}`
-  if (schemaPath) {
-    schPath = str`${schPath}${getErrorPath(schemaPath, Type.Str)}`
-  }
-  return [E.schemaPath, schPath]
-}
-
-function extraErrorProps(
-  cxt: KeywordErrorCxt,
-  {params, message}: KeywordErrorDefinition,
-  keyValues: [Name, SafeExpr | string][]
-): void {
-  const {keyword, data, schemaValue, it} = cxt
-  const {opts, propertyName, topSchemaRef, schemaPath} = it
-  keyValues.push(
-    [E.keyword, keyword],
-    [E.params, typeof params == "function" ? params(cxt) : params || _`{}`]
-  )
-  if (opts.messages) {
-    keyValues.push([E.message, typeof message == "function" ? message(cxt) : message])
-  }
-  if (opts.verbose) {
-    keyValues.push(
-      [E.schema, schemaValue],
-      [E.parentSchema, _`${topSchemaRef}${schemaPath}`],
-      [N.data, data]
-    )
-  }
-  if (propertyName) keyValues.push([E.propertyName, propertyName])
-}