@sean.holung/minicode 0.3.10 → 0.3.11

package/packages/agent-sdk/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/packages/agent-sdk/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
-  }
-}

package/packages/agent-sdk/node_modules/ajv/lib/types/index.ts

@@ -1,244 +0,0 @@
-import {URIComponent} from "fast-uri"
-import type {CodeGen, Code, Name, ScopeValueSets, ValueScopeName} from "../compile/codegen"
-import type {SchemaEnv, SchemaCxt, SchemaObjCxt} from "../compile"
-import type {JSONType} from "../compile/rules"
-import type {KeywordCxt} from "../compile/validate"
-import type Ajv from "../core"
-
-interface _SchemaObject {
-  id?: string
-  $id?: string
-  $schema?: string
-  [x: string]: any // TODO
-}
-
-export interface SchemaObject extends _SchemaObject {
-  id?: string
-  $id?: string
-  $schema?: string
-  $async?: false
-  [x: string]: any // TODO
-}
-
-export interface AsyncSchema extends _SchemaObject {
-  $async: true
-}
-
-export type AnySchemaObject = SchemaObject | AsyncSchema
-
-export type Schema = SchemaObject | boolean
-
-export type AnySchema = Schema | AsyncSchema
-
-export type SchemaMap = {[Key in string]?: AnySchema}
-
-export interface SourceCode {
-  validateName: ValueScopeName
-  validateCode: string
-  scopeValues: ScopeValueSets
-  evaluated?: Code
-}
-
-export interface DataValidationCxt<T extends string | number = string | number> {
-  instancePath: string
-  parentData: {[K in T]: any} // object or array
-  parentDataProperty: T // string or number
-  rootData: Record<string, any> | any[]
-  dynamicAnchors: {[Ref in string]?: ValidateFunction}
-}
-
-export interface ValidateFunction<T = unknown> {
-  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-  (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T
-  errors?: null | ErrorObject[]
-  evaluated?: Evaluated
-  schema: AnySchema
-  schemaEnv: SchemaEnv
-  source?: SourceCode
-}
-
-export interface JTDParser<T = unknown> {
-  (json: string): T | undefined
-  message?: string
-  position?: number
-}
-
-export type EvaluatedProperties = {[K in string]?: true} | true
-
-export type EvaluatedItems = number | true
-
-export interface Evaluated {
-  // determined at compile time if staticProps/Items is true
-  props?: EvaluatedProperties
-  items?: EvaluatedItems
-  // whether props/items determined at compile time
-  dynamicProps: boolean
-  dynamicItems: boolean
-}
-
-export interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {
-  (...args: Parameters<ValidateFunction<T>>): Promise<T>
-  $async: true
-}
-
-export type AnyValidateFunction<T = any> = ValidateFunction<T> | AsyncValidateFunction<T>
-
-export interface ErrorObject<K extends string = string, P = Record<string, any>, S = unknown> {
-  keyword: K
-  instancePath: string
-  schemaPath: string
-  params: P
-  // Added to validation errors of "propertyNames" keyword schema
-  propertyName?: string
-  // Excluded if option `messages` set to false.
-  message?: string
-  // These are added with the `verbose` option.
-  schema?: S
-  parentSchema?: AnySchemaObject
-  data?: unknown
-}
-
-export type ErrorNoParams<K extends string, S = unknown> = ErrorObject<K, Record<string, never>, S>
-
-interface _KeywordDef {
-  keyword: string | string[]
-  type?: JSONType | JSONType[] // data types that keyword applies to
-  schemaType?: JSONType | JSONType[] // allowed type(s) of keyword value in the schema
-  allowUndefined?: boolean // used for keywords that can be invoked by other keywords, not being present in the schema
-  $data?: boolean // keyword supports [$data reference](../../docs/guide/combining-schemas.md#data-reference)
-  implements?: string[] // other schema keywords that this keyword implements
-  before?: string // keyword should be executed before this keyword (should be applicable to the same type)
-  post?: boolean // keyword should be executed after other keywords without post flag
-  metaSchema?: AnySchemaObject // meta-schema for keyword schema value - it is better to use schemaType where applicable
-  validateSchema?: AnyValidateFunction // compiled keyword metaSchema - should not be passed
-  dependencies?: string[] // keywords that must be present in the same schema
-  error?: KeywordErrorDefinition
-  $dataError?: KeywordErrorDefinition
-}
-
-export interface CodeKeywordDefinition extends _KeywordDef {
-  code: (cxt: KeywordCxt, ruleType?: string) => void
-  trackErrors?: boolean
-}
-
-export type MacroKeywordFunc = (
-  schema: any,
-  parentSchema: AnySchemaObject,
-  it: SchemaCxt
-) => AnySchema
-
-export type CompileKeywordFunc = (
-  schema: any,
-  parentSchema: AnySchemaObject,
-  it: SchemaObjCxt
-) => DataValidateFunction
-
-export interface DataValidateFunction {
-  (...args: Parameters<ValidateFunction>): boolean | Promise<any>
-  errors?: Partial<ErrorObject>[]
-}
-
-export interface SchemaValidateFunction {
-  (
-    schema: any,
-    data: any,
-    parentSchema?: AnySchemaObject,
-    dataCxt?: DataValidationCxt
-  ): boolean | Promise<any>
-  errors?: Partial<ErrorObject>[]
-}
-
-export interface FuncKeywordDefinition extends _KeywordDef {
-  validate?: SchemaValidateFunction | DataValidateFunction
-  compile?: CompileKeywordFunc
-  // schema: false makes validate not to expect schema (DataValidateFunction)
-  schema?: boolean // requires "validate"
-  modifying?: boolean
-  async?: boolean
-  valid?: boolean
-  errors?: boolean | "full"
-}
-
-export interface MacroKeywordDefinition extends FuncKeywordDefinition {
-  macro: MacroKeywordFunc
-}
-
-export type KeywordDefinition =
-  | CodeKeywordDefinition
-  | FuncKeywordDefinition
-  | MacroKeywordDefinition
-
-export type AddedKeywordDefinition = KeywordDefinition & {
-  type: JSONType[]
-  schemaType: JSONType[]
-}
-
-export interface KeywordErrorDefinition {
-  message: string | Code | ((cxt: KeywordErrorCxt) => string | Code)
-  params?: Code | ((cxt: KeywordErrorCxt) => Code)
-}
-
-export type Vocabulary = (KeywordDefinition | string)[]
-
-export interface KeywordErrorCxt {
-  gen: CodeGen
-  keyword: string
-  data: Name
-  $data?: string | false
-  schema: any // TODO
-  parentSchema?: AnySchemaObject
-  schemaCode: Code | number | boolean
-  schemaValue: Code | number | boolean
-  schemaType?: JSONType[]
-  errsCount?: Name
-  params: KeywordCxtParams
-  it: SchemaCxt
-}
-
-export type KeywordCxtParams = {[P in string]?: Code | string | number}
-
-export type FormatValidator<T extends string | number> = (data: T) => boolean
-
-export type FormatCompare<T extends string | number> = (data1: T, data2: T) => number | undefined
-
-export type AsyncFormatValidator<T extends string | number> = (data: T) => Promise<boolean>
-
-export interface FormatDefinition<T extends string | number> {
-  type?: T extends string ? "string" | undefined : "number"
-  validate: FormatValidator<T> | (T extends string ? string | RegExp : never)
-  async?: false | undefined
-  compare?: FormatCompare<T>
-}
-
-export interface AsyncFormatDefinition<T extends string | number> {
-  type?: T extends string ? "string" | undefined : "number"
-  validate: AsyncFormatValidator<T>
-  async: true
-  compare?: FormatCompare<T>
-}
-
-export type AddedFormat =
-  | true
-  | RegExp
-  | FormatValidator<string>
-  | FormatDefinition<string>
-  | FormatDefinition<number>
-  | AsyncFormatDefinition<string>
-  | AsyncFormatDefinition<number>
-
-export type Format = AddedFormat | string
-
-export interface RegExpEngine {
-  (pattern: string, u: string): RegExpLike
-  code: string
-}
-
-export interface RegExpLike {
-  test: (s: string) => boolean
-}
-
-export interface UriResolver {
-  parse(uri: string): URIComponent
-  resolve(base: string, path: string): string
-  serialize(component: URIComponent): string
-}

package/packages/agent-sdk/node_modules/ajv/lib/types/json-schema.ts

@@ -1,187 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-interface */
-type StrictNullChecksWrapper<Name extends string, Type> = undefined extends null
-  ? `strictNullChecks must be true in tsconfig to use ${Name}`
-  : Type
-
-type UnionToIntersection<U> = (U extends any ? (_: U) => void : never) extends (_: infer I) => void
-  ? I
-  : never
-
-export type SomeJSONSchema = UncheckedJSONSchemaType<Known, true>
-
-type UncheckedPartialSchema<T> = Partial<UncheckedJSONSchemaType<T, true>>
-
-export type PartialSchema<T> = StrictNullChecksWrapper<"PartialSchema", UncheckedPartialSchema<T>>
-
-type JSONType<T extends string, IsPartial extends boolean> = IsPartial extends true
-  ? T | undefined
-  : T
-
-interface NumberKeywords {
-  minimum?: number
-  maximum?: number
-  exclusiveMinimum?: number
-  exclusiveMaximum?: number
-  multipleOf?: number
-  format?: string
-}
-
-interface StringKeywords {
-  minLength?: number
-  maxLength?: number
-  pattern?: string
-  format?: string
-}
-
-type UncheckedJSONSchemaType<T, IsPartial extends boolean> = (
-  | // these two unions allow arbitrary unions of types
-  {
-      anyOf: readonly UncheckedJSONSchemaType<T, IsPartial>[]
-    }
-  | {
-      oneOf: readonly UncheckedJSONSchemaType<T, IsPartial>[]
-    }
-  // this union allows for { type: (primitive)[] } style schemas
-  | ({
-      type: readonly (T extends number
-        ? JSONType<"number" | "integer", IsPartial>
-        : T extends string
-        ? JSONType<"string", IsPartial>
-        : T extends boolean
-        ? JSONType<"boolean", IsPartial>
-        : never)[]
-    } & UnionToIntersection<
-      T extends number
-        ? NumberKeywords
-        : T extends string
-        ? StringKeywords
-        : T extends boolean
-        ? // eslint-disable-next-line @typescript-eslint/ban-types
-          {}
-        : never
-    >)
-  // this covers "normal" types; it's last so typescript looks to it first for errors
-  | ((T extends number
-      ? {
-          type: JSONType<"number" | "integer", IsPartial>
-        } & NumberKeywords
-      : T extends string
-      ? {
-          type: JSONType<"string", IsPartial>
-        } & StringKeywords
-      : T extends boolean
-      ? {
-          type: JSONType<"boolean", IsPartial>
-        }
-      : T extends readonly [any, ...any[]]
-      ? {
-          // JSON AnySchema for tuple
-          type: JSONType<"array", IsPartial>
-          items: {
-            readonly [K in keyof T]-?: UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>
-          } & {length: T["length"]}
-          minItems: T["length"]
-        } & ({maxItems: T["length"]} | {additionalItems: false})
-      : T extends readonly any[]
-      ? {
-          type: JSONType<"array", IsPartial>
-          items: UncheckedJSONSchemaType<T[0], false>
-          contains?: UncheckedPartialSchema<T[0]>
-          minItems?: number
-          maxItems?: number
-          minContains?: number
-          maxContains?: number
-          uniqueItems?: true
-          additionalItems?: never
-        }
-      : T extends Record<string, any>
-      ? {
-          // JSON AnySchema for records and dictionaries
-          // "required" is not optional because it is often forgotten
-          // "properties" are optional for more concise dictionary schemas
-          // "patternProperties" and can be only used with interfaces that have string index
-          type: JSONType<"object", IsPartial>
-          additionalProperties?: boolean | UncheckedJSONSchemaType<T[string], false>
-          unevaluatedProperties?: boolean | UncheckedJSONSchemaType<T[string], false>
-          properties?: IsPartial extends true
-            ? Partial<UncheckedPropertiesSchema<T>>
-            : UncheckedPropertiesSchema<T>
-          patternProperties?: Record<string, UncheckedJSONSchemaType<T[string], false>>
-          propertyNames?: Omit<UncheckedJSONSchemaType<string, false>, "type"> & {type?: "string"}
-          dependencies?: {[K in keyof T]?: readonly (keyof T)[] | UncheckedPartialSchema<T>}
-          dependentRequired?: {[K in keyof T]?: readonly (keyof T)[]}
-          dependentSchemas?: {[K in keyof T]?: UncheckedPartialSchema<T>}
-          minProperties?: number
-          maxProperties?: number
-        } & (IsPartial extends true // "required" is not necessary if it's a non-partial type with no required keys // are listed it only asserts that optional cannot be listed. // "required" type does not guarantee that all required properties
-          ? {required: readonly (keyof T)[]}
-          : [UncheckedRequiredMembers<T>] extends [never]
-          ? {required?: readonly UncheckedRequiredMembers<T>[]}
-          : {required: readonly UncheckedRequiredMembers<T>[]})
-      : T extends null
-      ? {
-          type: JSONType<"null", IsPartial>
-          nullable: true
-        }
-      : never) & {
-      allOf?: readonly UncheckedPartialSchema<T>[]
-      anyOf?: readonly UncheckedPartialSchema<T>[]
-      oneOf?: readonly UncheckedPartialSchema<T>[]
-      if?: UncheckedPartialSchema<T>
-      then?: UncheckedPartialSchema<T>
-      else?: UncheckedPartialSchema<T>
-      not?: UncheckedPartialSchema<T>
-    })
-) & {
-  [keyword: string]: any
-  $id?: string
-  $ref?: string
-  $defs?: Record<string, UncheckedJSONSchemaType<Known, true>>
-  definitions?: Record<string, UncheckedJSONSchemaType<Known, true>>
-}
-
-export type JSONSchemaType<T> = StrictNullChecksWrapper<
-  "JSONSchemaType",
-  UncheckedJSONSchemaType<T, false>
->
-
-type Known =
-  | {[key: string]: Known}
-  | [Known, ...Known[]]
-  | Known[]
-  | number
-  | string
-  | boolean
-  | null
-
-type UncheckedPropertiesSchema<T> = {
-  [K in keyof T]-?: (UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>) | {$ref: string}
-}
-
-export type PropertiesSchema<T> = StrictNullChecksWrapper<
-  "PropertiesSchema",
-  UncheckedPropertiesSchema<T>
->
-
-type UncheckedRequiredMembers<T> = {
-  [K in keyof T]-?: undefined extends T[K] ? never : K
-}[keyof T]
-
-export type RequiredMembers<T> = StrictNullChecksWrapper<
-  "RequiredMembers",
-  UncheckedRequiredMembers<T>
->
-
-type Nullable<T> = undefined extends T
-  ? {
-      nullable: true
-      const?: null // any non-null value would fail `const: null`, `null` would fail any other value in const
-      enum?: readonly (T | null)[] // `null` must be explicitly included in "enum" for `null` to pass
-      default?: T | null
-    }
-  : {
-      nullable?: false
-      const?: T
-      enum?: readonly T[]
-      default?: T
-    }