@bluefly/openstandardagents 0.4.6 → 0.4.9

package/node_modules/ajv/lib/2019.ts

@@ -1,81 +0,0 @@
-import type {AnySchemaObject} from "./types"
-import AjvCore, {Options} from "./core"
-
-import draft7Vocabularies from "./vocabularies/draft7"
-import dynamicVocabulary from "./vocabularies/dynamic"
-import nextVocabulary from "./vocabularies/next"
-import unevaluatedVocabulary from "./vocabularies/unevaluated"
-import discriminator from "./vocabularies/discriminator"
-import addMetaSchema2019 from "./refs/json-schema-2019-09"
-
-const META_SCHEMA_ID = "https://json-schema.org/draft/2019-09/schema"
-
-export class Ajv2019 extends AjvCore {
-  constructor(opts: Options = {}) {
-    super({
-      ...opts,
-      dynamicRef: true,
-      next: true,
-      unevaluated: true,
-    })
-  }
-
-  _addVocabularies(): void {
-    super._addVocabularies()
-    this.addVocabulary(dynamicVocabulary)
-    draft7Vocabularies.forEach((v) => this.addVocabulary(v))
-    this.addVocabulary(nextVocabulary)
-    this.addVocabulary(unevaluatedVocabulary)
-    if (this.opts.discriminator) this.addKeyword(discriminator)
-  }
-
-  _addDefaultMetaSchema(): void {
-    super._addDefaultMetaSchema()
-    const {$data, meta} = this.opts
-    if (!meta) return
-    addMetaSchema2019.call(this, $data)
-    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
-  }
-
-  defaultMeta(): string | AnySchemaObject | undefined {
-    return (this.opts.defaultMeta =
-      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
-  }
-}
-
-module.exports = exports = Ajv2019
-module.exports.Ajv2019 = Ajv2019
-Object.defineProperty(exports, "__esModule", {value: true})
-
-export default Ajv2019
-
-export {
-  Format,
-  FormatDefinition,
-  AsyncFormatDefinition,
-  KeywordDefinition,
-  KeywordErrorDefinition,
-  CodeKeywordDefinition,
-  MacroKeywordDefinition,
-  FuncKeywordDefinition,
-  Vocabulary,
-  Schema,
-  SchemaObject,
-  AnySchemaObject,
-  AsyncSchema,
-  AnySchema,
-  ValidateFunction,
-  AsyncValidateFunction,
-  ErrorObject,
-  ErrorNoParams,
-} from "./types"
-
-export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
-export {SchemaCxt, SchemaObjCxt} from "./compile"
-export {KeywordCxt} from "./compile/validate"
-export {DefinedError} from "./vocabularies/errors"
-export {JSONType} from "./compile/rules"
-export {JSONSchemaType} from "./types/json-schema"
-export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
-export {default as ValidationError} from "./runtime/validation_error"
-export {default as MissingRefError} from "./compile/ref_error"

package/node_modules/ajv/lib/2020.ts

@@ -1,75 +0,0 @@
-import type {AnySchemaObject} from "./types"
-import AjvCore, {Options} from "./core"
-
-import draft2020Vocabularies from "./vocabularies/draft2020"
-import discriminator from "./vocabularies/discriminator"
-import addMetaSchema2020 from "./refs/json-schema-2020-12"
-
-const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema"
-
-export class Ajv2020 extends AjvCore {
-  constructor(opts: Options = {}) {
-    super({
-      ...opts,
-      dynamicRef: true,
-      next: true,
-      unevaluated: true,
-    })
-  }
-
-  _addVocabularies(): void {
-    super._addVocabularies()
-    draft2020Vocabularies.forEach((v) => this.addVocabulary(v))
-    if (this.opts.discriminator) this.addKeyword(discriminator)
-  }
-
-  _addDefaultMetaSchema(): void {
-    super._addDefaultMetaSchema()
-    const {$data, meta} = this.opts
-    if (!meta) return
-    addMetaSchema2020.call(this, $data)
-    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
-  }
-
-  defaultMeta(): string | AnySchemaObject | undefined {
-    return (this.opts.defaultMeta =
-      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
-  }
-}
-
-module.exports = exports = Ajv2020
-module.exports.Ajv2020 = Ajv2020
-Object.defineProperty(exports, "__esModule", {value: true})
-
-export default Ajv2020
-
-export {
-  Format,
-  FormatDefinition,
-  AsyncFormatDefinition,
-  KeywordDefinition,
-  KeywordErrorDefinition,
-  CodeKeywordDefinition,
-  MacroKeywordDefinition,
-  FuncKeywordDefinition,
-  Vocabulary,
-  Schema,
-  SchemaObject,
-  AnySchemaObject,
-  AsyncSchema,
-  AnySchema,
-  ValidateFunction,
-  AsyncValidateFunction,
-  ErrorObject,
-  ErrorNoParams,
-} from "./types"
-
-export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
-export {SchemaCxt, SchemaObjCxt} from "./compile"
-export {KeywordCxt} from "./compile/validate"
-export {DefinedError} from "./vocabularies/errors"
-export {JSONType} from "./compile/rules"
-export {JSONSchemaType} from "./types/json-schema"
-export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
-export {default as ValidationError} from "./runtime/validation_error"
-export {default as MissingRefError} from "./compile/ref_error"

package/node_modules/ajv/lib/ajv.ts

@@ -1,70 +0,0 @@
-import type {AnySchemaObject} from "./types"
-import AjvCore from "./core"
-import draft7Vocabularies from "./vocabularies/draft7"
-import discriminator from "./vocabularies/discriminator"
-import * as draft7MetaSchema from "./refs/json-schema-draft-07.json"
-
-const META_SUPPORT_DATA = ["/properties"]
-
-const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema"
-
-export class Ajv extends AjvCore {
-  _addVocabularies(): void {
-    super._addVocabularies()
-    draft7Vocabularies.forEach((v) => this.addVocabulary(v))
-    if (this.opts.discriminator) this.addKeyword(discriminator)
-  }
-
-  _addDefaultMetaSchema(): void {
-    super._addDefaultMetaSchema()
-    if (!this.opts.meta) return
-    const metaSchema = this.opts.$data
-      ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)
-      : draft7MetaSchema
-    this.addMetaSchema(metaSchema, META_SCHEMA_ID, false)
-    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
-  }
-
-  defaultMeta(): string | AnySchemaObject | undefined {
-    return (this.opts.defaultMeta =
-      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
-  }
-}
-
-module.exports = exports = Ajv
-module.exports.Ajv = Ajv
-Object.defineProperty(exports, "__esModule", {value: true})
-
-export default Ajv
-
-export {
-  Format,
-  FormatDefinition,
-  AsyncFormatDefinition,
-  KeywordDefinition,
-  KeywordErrorDefinition,
-  CodeKeywordDefinition,
-  MacroKeywordDefinition,
-  FuncKeywordDefinition,
-  Vocabulary,
-  Schema,
-  SchemaObject,
-  AnySchemaObject,
-  AsyncSchema,
-  AnySchema,
-  ValidateFunction,
-  AsyncValidateFunction,
-  SchemaValidateFunction,
-  ErrorObject,
-  ErrorNoParams,
-} from "./types"
-
-export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
-export {SchemaCxt, SchemaObjCxt} from "./compile"
-export {KeywordCxt} from "./compile/validate"
-export {DefinedError} from "./vocabularies/errors"
-export {JSONType} from "./compile/rules"
-export {JSONSchemaType} from "./types/json-schema"
-export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
-export {default as ValidationError} from "./runtime/validation_error"
-export {default as MissingRefError} from "./compile/ref_error"

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

@@ -1,169 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export abstract class _CodeOrName {
-  abstract readonly str: string
-  abstract readonly names: UsedNames
-  abstract toString(): string
-  abstract emptyStr(): boolean
-}
-
-export const IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i
-
-export class Name extends _CodeOrName {
-  readonly str: string
-  constructor(s: string) {
-    super()
-    if (!IDENTIFIER.test(s)) throw new Error("CodeGen: name must be a valid identifier")
-    this.str = s
-  }
-
-  toString(): string {
-    return this.str
-  }
-
-  emptyStr(): boolean {
-    return false
-  }
-
-  get names(): UsedNames {
-    return {[this.str]: 1}
-  }
-}
-
-export class _Code extends _CodeOrName {
-  readonly _items: readonly CodeItem[]
-  private _str?: string
-  private _names?: UsedNames
-
-  constructor(code: string | readonly CodeItem[]) {
-    super()
-    this._items = typeof code === "string" ? [code] : code
-  }
-
-  toString(): string {
-    return this.str
-  }
-
-  emptyStr(): boolean {
-    if (this._items.length > 1) return false
-    const item = this._items[0]
-    return item === "" || item === '""'
-  }
-
-  get str(): string {
-    return (this._str ??= this._items.reduce((s: string, c: CodeItem) => `${s}${c}`, ""))
-  }
-
-  get names(): UsedNames {
-    return (this._names ??= this._items.reduce((names: UsedNames, c) => {
-      if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1
-      return names
-    }, {}))
-  }
-}
-
-export type CodeItem = Name | string | number | boolean | null
-
-export type UsedNames = Record<string, number | undefined>
-
-export type Code = _Code | Name
-
-export type SafeExpr = Code | number | boolean | null
-
-export const nil = new _Code("")
-
-type CodeArg = SafeExpr | string | undefined
-
-export function _(strs: TemplateStringsArray, ...args: CodeArg[]): _Code {
-  const code: CodeItem[] = [strs[0]]
-  let i = 0
-  while (i < args.length) {
-    addCodeArg(code, args[i])
-    code.push(strs[++i])
-  }
-  return new _Code(code)
-}
-
-const plus = new _Code("+")
-
-export function str(strs: TemplateStringsArray, ...args: (CodeArg | string[])[]): _Code {
-  const expr: CodeItem[] = [safeStringify(strs[0])]
-  let i = 0
-  while (i < args.length) {
-    expr.push(plus)
-    addCodeArg(expr, args[i])
-    expr.push(plus, safeStringify(strs[++i]))
-  }
-  optimize(expr)
-  return new _Code(expr)
-}
-
-export function addCodeArg(code: CodeItem[], arg: CodeArg | string[]): void {
-  if (arg instanceof _Code) code.push(...arg._items)
-  else if (arg instanceof Name) code.push(arg)
-  else code.push(interpolate(arg))
-}
-
-function optimize(expr: CodeItem[]): void {
-  let i = 1
-  while (i < expr.length - 1) {
-    if (expr[i] === plus) {
-      const res = mergeExprItems(expr[i - 1], expr[i + 1])
-      if (res !== undefined) {
-        expr.splice(i - 1, 3, res)
-        continue
-      }
-      expr[i++] = "+"
-    }
-    i++
-  }
-}
-
-function mergeExprItems(a: CodeItem, b: CodeItem): CodeItem | undefined {
-  if (b === '""') return a
-  if (a === '""') return b
-  if (typeof a == "string") {
-    if (b instanceof Name || a[a.length - 1] !== '"') return
-    if (typeof b != "string") return `${a.slice(0, -1)}${b}"`
-    if (b[0] === '"') return a.slice(0, -1) + b.slice(1)
-    return
-  }
-  if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) return `"${a}${b.slice(1)}`
-  return
-}
-
-export function strConcat(c1: Code, c2: Code): Code {
-  return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`
-}
-
-// TODO do not allow arrays here
-function interpolate(x?: string | string[] | number | boolean | null): SafeExpr | string {
-  return typeof x == "number" || typeof x == "boolean" || x === null
-    ? x
-    : safeStringify(Array.isArray(x) ? x.join(",") : x)
-}
-
-export function stringify(x: unknown): Code {
-  return new _Code(safeStringify(x))
-}
-
-export function safeStringify(x: unknown): string {
-  return JSON.stringify(x)
-    .replace(/\u2028/g, "\\u2028")
-    .replace(/\u2029/g, "\\u2029")
-}
-
-export function getProperty(key: Code | string | number): Code {
-  return typeof key == "string" && IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`
-}
-
-//Does best effort to format the name properly
-export function getEsmExportName(key: Code | string | number): Code {
-  if (typeof key == "string" && IDENTIFIER.test(key)) {
-    return new _Code(`${key}`)
-  }
-  throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`)
-}
-
-export function regexpCode(rx: RegExp): Code {
-  return new _Code(rx.toString())
-}