@sean.holung/minicode 0.3.10 → 0.3.11

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

@@ -1,273 +0,0 @@
-/** numeric strings */
-type NumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32"
-
-/** string strings */
-type StringType = "string" | "timestamp"
-
-/** Generic JTD Schema without inference of the represented type */
-export type SomeJTDSchemaType = (
-  | // ref
-  {ref: string}
-  // primitives
-  | {type: NumberType | StringType | "boolean"}
-  // enum
-  | {enum: string[]}
-  // elements
-  | {elements: SomeJTDSchemaType}
-  // values
-  | {values: SomeJTDSchemaType}
-  // properties
-  | {
-      properties: Record<string, SomeJTDSchemaType>
-      optionalProperties?: Record<string, SomeJTDSchemaType>
-      additionalProperties?: boolean
-    }
-  | {
-      properties?: Record<string, SomeJTDSchemaType>
-      optionalProperties: Record<string, SomeJTDSchemaType>
-      additionalProperties?: boolean
-    }
-  // discriminator
-  | {discriminator: string; mapping: Record<string, SomeJTDSchemaType>}
-  // empty
-  // NOTE see the end of
-  // https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | {}
-) & {
-  nullable?: boolean
-  metadata?: Record<string, unknown>
-  definitions?: Record<string, SomeJTDSchemaType>
-}
-
-/** required keys of an object, not undefined */
-type RequiredKeys<T> = {
-  [K in keyof T]-?: undefined extends T[K] ? never : K
-}[keyof T]
-
-/** optional or undifined-able keys of an object */
-type OptionalKeys<T> = {
-  [K in keyof T]-?: undefined extends T[K] ? K : never
-}[keyof T]
-
-/** type is true if T is a union type */
-type IsUnion_<T, U extends T = T> = false extends (
-  T extends unknown ? ([U] extends [T] ? false : true) : never
-)
-  ? false
-  : true
-type IsUnion<T> = IsUnion_<T>
-
-/** type is true if T is identically E */
-type TypeEquality<T, E> = [T] extends [E] ? ([E] extends [T] ? true : false) : false
-
-/** type is true if T or null is identically E or null*/
-type NullTypeEquality<T, E> = TypeEquality<T | null, E | null>
-
-/** gets only the string literals of a type or null if a type isn't a string literal */
-type EnumString<T> = [T] extends [never]
-  ? null
-  : T extends string
-  ? string extends T
-    ? null
-    : T
-  : null
-
-/** true if type is a union of string literals */
-type IsEnum<T> = null extends EnumString<T> ? false : true
-
-/** true only if all types are array types (not tuples) */
-// NOTE relies on the fact that tuples don't have an index at 0.5, but arrays
-// have an index at every number
-type IsElements<T> = false extends IsUnion<T>
-  ? [T] extends [readonly unknown[]]
-    ? undefined extends T[0.5]
-      ? false
-      : true
-    : false
-  : false
-
-/** true if the the type is a values type */
-type IsValues<T> = false extends IsUnion<T> ? TypeEquality<keyof T, string> : false
-
-/** true if type is a properties type and Union is false, or type is a discriminator type and Union is true */
-type IsRecord<T, Union extends boolean> = Union extends IsUnion<T>
-  ? null extends EnumString<keyof T>
-    ? false
-    : true
-  : false
-
-/** true if type represents an empty record */
-type IsEmptyRecord<T> = [T] extends [Record<string, never>]
-  ? [T] extends [never]
-    ? false
-    : true
-  : false
-
-/** actual schema */
-export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string, never>> = (
-  | // refs - where null wasn't specified, must match exactly
-  (null extends EnumString<keyof D>
-      ? never
-      :
-          | ({[K in keyof D]: [T] extends [D[K]] ? {ref: K} : never}[keyof D] & {nullable?: false})
-          // nulled refs - if ref is nullable and nullable is specified, then it can
-          // match either null or non-null definitions
-          | (null extends T
-              ? {
-                  [K in keyof D]: [Exclude<T, null>] extends [Exclude<D[K], null>]
-                    ? {ref: K}
-                    : never
-                }[keyof D] & {nullable: true}
-              : never))
-  // empty - empty schemas also treat nullable differently in that it's now fully ignored
-  | (unknown extends T ? {nullable?: boolean} : never)
-  // all other types // numbers - only accepts the type number
-  | ((true extends NullTypeEquality<T, number>
-      ? {type: NumberType}
-      : // booleans - accepts the type boolean
-      true extends NullTypeEquality<T, boolean>
-      ? {type: "boolean"}
-      : // strings - only accepts the type string
-      true extends NullTypeEquality<T, string>
-      ? {type: StringType}
-      : // strings - only accepts the type Date
-      true extends NullTypeEquality<T, Date>
-      ? {type: "timestamp"}
-      : // enums - only accepts union of string literals
-      // TODO we can't actually check that everything in the union was specified
-      true extends IsEnum<Exclude<T, null>>
-      ? {enum: EnumString<Exclude<T, null>>[]}
-      : // arrays - only accepts arrays, could be array of unions to be resolved later
-      true extends IsElements<Exclude<T, null>>
-      ? T extends readonly (infer E)[]
-        ? {
-            elements: JTDSchemaType<E, D>
-          }
-        : never
-      : // empty properties
-      true extends IsEmptyRecord<Exclude<T, null>>
-      ?
-          | {properties: Record<string, never>; optionalProperties?: Record<string, never>}
-          | {optionalProperties: Record<string, never>}
-      : // values
-      true extends IsValues<Exclude<T, null>>
-      ? T extends Record<string, infer V>
-        ? {
-            values: JTDSchemaType<V, D>
-          }
-        : never
-      : // properties
-      true extends IsRecord<Exclude<T, null>, false>
-      ? ([RequiredKeys<Exclude<T, null>>] extends [never]
-          ? {
-              properties?: Record<string, never>
-            }
-          : {
-              properties: {[K in RequiredKeys<T>]: JTDSchemaType<T[K], D>}
-            }) &
-          ([OptionalKeys<Exclude<T, null>>] extends [never]
-            ? {
-                optionalProperties?: Record<string, never>
-              }
-            : {
-                optionalProperties: {
-                  [K in OptionalKeys<T>]: JTDSchemaType<Exclude<T[K], undefined>, D>
-                }
-              }) & {
-            additionalProperties?: boolean
-          }
-      : // discriminator
-      true extends IsRecord<Exclude<T, null>, true>
-      ? {
-          [K in keyof Exclude<T, null>]-?: Exclude<T, null>[K] extends string
-            ? {
-                discriminator: K
-                mapping: {
-                  // TODO currently allows descriminator to be present in schema
-                  [M in Exclude<T, null>[K]]: JTDSchemaType<
-                    Omit<T extends Record<K, M> ? T : never, K>,
-                    D
-                  >
-                }
-              }
-            : never
-        }[keyof Exclude<T, null>]
-      : never) &
-      (null extends T
-        ? {
-            nullable: true
-          }
-        : {nullable?: false}))
-) & {
-  // extra properties
-  metadata?: Record<string, unknown>
-  // TODO these should only be allowed at the top level
-  definitions?: {[K in keyof D]: JTDSchemaType<D[K], D>}
-}
-
-type JTDDataDef<S, D extends Record<string, unknown>> =
-  | // ref
-  (S extends {ref: string}
-      ? D extends {[K in S["ref"]]: infer V}
-        ? JTDDataDef<V, D>
-        : never
-      : // type
-      S extends {type: NumberType}
-      ? number
-      : S extends {type: "boolean"}
-      ? boolean
-      : S extends {type: "string"}
-      ? string
-      : S extends {type: "timestamp"}
-      ? string | Date
-      : // enum
-      S extends {enum: readonly (infer E)[]}
-      ? string extends E
-        ? never
-        : [E] extends [string]
-        ? E
-        : never
-      : // elements
-      S extends {elements: infer E}
-      ? JTDDataDef<E, D>[]
-      : // properties
-      S extends {
-          properties: Record<string, unknown>
-          optionalProperties?: Record<string, unknown>
-          additionalProperties?: boolean
-        }
-      ? {-readonly [K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D>} & {
-          -readonly [K in keyof S["optionalProperties"]]+?: JTDDataDef<
-            S["optionalProperties"][K],
-            D
-          >
-        } & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown)
-      : S extends {
-          properties?: Record<string, unknown>
-          optionalProperties: Record<string, unknown>
-          additionalProperties?: boolean
-        }
-      ? {-readonly [K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D>} & {
-          -readonly [K in keyof S["optionalProperties"]]+?: JTDDataDef<
-            S["optionalProperties"][K],
-            D
-          >
-        } & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown)
-      : // values
-      S extends {values: infer V}
-      ? Record<string, JTDDataDef<V, D>>
-      : // discriminator
-      S extends {discriminator: infer M; mapping: Record<string, unknown>}
-      ? [M] extends [string]
-        ? {
-            [K in keyof S["mapping"]]: JTDDataDef<S["mapping"][K], D> & {[KM in M]: K}
-          }[keyof S["mapping"]]
-        : never
-      : // empty
-        unknown)
-  | (S extends {nullable: true} ? null : never)
-
-export type JTDDataType<S> = S extends {definitions: Record<string, unknown>}
-  ? JTDDataDef<S, S["definitions"]>
-  : JTDDataDef<S, Record<string, never>>

package/packages/agent-sdk/node_modules/ajv/lib/vocabularies/applicator/additionalItems.ts

@@ -1,56 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, not, Name} from "../../compile/codegen"
-import {alwaysValidSchema, checkStrictMode, Type} from "../../compile/util"
-
-export type AdditionalItemsError = ErrorObject<"additionalItems", {limit: number}, AnySchema>
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {len}}) => str`must NOT have more than ${len} items`,
-  params: ({params: {len}}) => _`{limit: ${len}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "additionalItems" as const,
-  type: "array",
-  schemaType: ["boolean", "object"],
-  before: "uniqueItems",
-  error,
-  code(cxt: KeywordCxt) {
-    const {parentSchema, it} = cxt
-    const {items} = parentSchema
-    if (!Array.isArray(items)) {
-      checkStrictMode(it, '"additionalItems" is ignored when "items" is not an array of schemas')
-      return
-    }
-    validateAdditionalItems(cxt, items)
-  },
-}
-
-export function validateAdditionalItems(cxt: KeywordCxt, items: AnySchema[]): void {
-  const {gen, schema, data, keyword, it} = cxt
-  it.items = true
-  const len = gen.const("len", _`${data}.length`)
-  if (schema === false) {
-    cxt.setParams({len: items.length})
-    cxt.pass(_`${len} <= ${items.length}`)
-  } else if (typeof schema == "object" && !alwaysValidSchema(it, schema)) {
-    const valid = gen.var("valid", _`${len} <= ${items.length}`) // TODO var
-    gen.if(not(valid), () => validateItems(valid))
-    cxt.ok(valid)
-  }
-
-  function validateItems(valid: Name): void {
-    gen.forRange("i", items.length, len, (i) => {
-      cxt.subschema({keyword, dataProp: i, dataPropType: Type.Num}, valid)
-      if (!it.allErrors) gen.if(not(valid), () => gen.break())
-    })
-  }
-}
-
-export default def

package/packages/agent-sdk/node_modules/ajv/lib/vocabularies/applicator/additionalProperties.ts

@@ -1,118 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  AddedKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import {allSchemaProperties, usePattern, isOwnProperty} from "../code"
-import {_, nil, or, not, Code, Name} from "../../compile/codegen"
-import N from "../../compile/names"
-import type {SubschemaArgs} from "../../compile/validate/subschema"
-import {alwaysValidSchema, schemaRefOrVal, Type} from "../../compile/util"
-
-export type AdditionalPropertiesError = ErrorObject<
-  "additionalProperties",
-  {additionalProperty: string},
-  AnySchema
->
-
-const error: KeywordErrorDefinition = {
-  message: "must NOT have additional properties",
-  params: ({params}) => _`{additionalProperty: ${params.additionalProperty}}`,
-}
-
-const def: CodeKeywordDefinition & AddedKeywordDefinition = {
-  keyword: "additionalProperties",
-  type: ["object"],
-  schemaType: ["boolean", "object"],
-  allowUndefined: true,
-  trackErrors: true,
-  error,
-  code(cxt) {
-    const {gen, schema, parentSchema, data, errsCount, it} = cxt
-    /* istanbul ignore if */
-    if (!errsCount) throw new Error("ajv implementation error")
-    const {allErrors, opts} = it
-    it.props = true
-    if (opts.removeAdditional !== "all" && alwaysValidSchema(it, schema)) return
-    const props = allSchemaProperties(parentSchema.properties)
-    const patProps = allSchemaProperties(parentSchema.patternProperties)
-    checkAdditionalProperties()
-    cxt.ok(_`${errsCount} === ${N.errors}`)
-
-    function checkAdditionalProperties(): void {
-      gen.forIn("key", data, (key: Name) => {
-        if (!props.length && !patProps.length) additionalPropertyCode(key)
-        else gen.if(isAdditional(key), () => additionalPropertyCode(key))
-      })
-    }
-
-    function isAdditional(key: Name): Code {
-      let definedProp: Code
-      if (props.length > 8) {
-        // TODO maybe an option instead of hard-coded 8?
-        const propsSchema = schemaRefOrVal(it, parentSchema.properties, "properties")
-        definedProp = isOwnProperty(gen, propsSchema as Code, key)
-      } else if (props.length) {
-        definedProp = or(...props.map((p) => _`${key} === ${p}`))
-      } else {
-        definedProp = nil
-      }
-      if (patProps.length) {
-        definedProp = or(definedProp, ...patProps.map((p) => _`${usePattern(cxt, p)}.test(${key})`))
-      }
-      return not(definedProp)
-    }
-
-    function deleteAdditional(key: Name): void {
-      gen.code(_`delete ${data}[${key}]`)
-    }
-
-    function additionalPropertyCode(key: Name): void {
-      if (opts.removeAdditional === "all" || (opts.removeAdditional && schema === false)) {
-        deleteAdditional(key)
-        return
-      }
-
-      if (schema === false) {
-        cxt.setParams({additionalProperty: key})
-        cxt.error()
-        if (!allErrors) gen.break()
-        return
-      }
-
-      if (typeof schema == "object" && !alwaysValidSchema(it, schema)) {
-        const valid = gen.name("valid")
-        if (opts.removeAdditional === "failing") {
-          applyAdditionalSchema(key, valid, false)
-          gen.if(not(valid), () => {
-            cxt.reset()
-            deleteAdditional(key)
-          })
-        } else {
-          applyAdditionalSchema(key, valid)
-          if (!allErrors) gen.if(not(valid), () => gen.break())
-        }
-      }
-    }
-
-    function applyAdditionalSchema(key: Name, valid: Name, errors?: false): void {
-      const subschema: SubschemaArgs = {
-        keyword: "additionalProperties",
-        dataProp: key,
-        dataPropType: Type.Str,
-      }
-      if (errors === false) {
-        Object.assign(subschema, {
-          compositeRule: true,
-          createErrors: false,
-          allErrors: false,
-        })
-      }
-      cxt.subschema(subschema, valid)
-    }
-  },
-}
-
-export default def

package/packages/agent-sdk/node_modules/ajv/lib/vocabularies/applicator/allOf.ts

@@ -1,22 +0,0 @@
-import type {CodeKeywordDefinition, AnySchema} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {alwaysValidSchema} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: "allOf",
-  schemaType: "array",
-  code(cxt: KeywordCxt) {
-    const {gen, schema, it} = cxt
-    /* istanbul ignore if */
-    if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-    const valid = gen.name("valid")
-    schema.forEach((sch: AnySchema, i: number) => {
-      if (alwaysValidSchema(it, sch)) return
-      const schCxt = cxt.subschema({keyword: "allOf", schemaProp: i}, valid)
-      cxt.ok(valid)
-      cxt.mergeEvaluated(schCxt)
-    })
-  },
-}
-
-export default def

package/packages/agent-sdk/node_modules/ajv/lib/vocabularies/applicator/anyOf.ts

@@ -1,14 +0,0 @@
-import type {CodeKeywordDefinition, ErrorNoParams, AnySchema} from "../../types"
-import {validateUnion} from "../code"
-
-export type AnyOfError = ErrorNoParams<"anyOf", AnySchema[]>
-
-const def: CodeKeywordDefinition = {
-  keyword: "anyOf",
-  schemaType: "array",
-  trackErrors: true,
-  code: validateUnion,
-  error: {message: "must match a schema in anyOf"},
-}
-
-export default def

package/packages/agent-sdk/node_modules/ajv/lib/vocabularies/applicator/contains.ts

@@ -1,109 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  KeywordErrorDefinition,
-  ErrorObject,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, Name} from "../../compile/codegen"
-import {alwaysValidSchema, checkStrictMode, Type} from "../../compile/util"
-
-export type ContainsError = ErrorObject<
-  "contains",
-  {minContains: number; maxContains?: number},
-  AnySchema
->
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {min, max}}) =>
-    max === undefined
-      ? str`must contain at least ${min} valid item(s)`
-      : str`must contain at least ${min} and no more than ${max} valid item(s)`,
-  params: ({params: {min, max}}) =>
-    max === undefined ? _`{minContains: ${min}}` : _`{minContains: ${min}, maxContains: ${max}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "contains",
-  type: "array",
-  schemaType: ["object", "boolean"],
-  before: "uniqueItems",
-  trackErrors: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, parentSchema, data, it} = cxt
-    let min: number
-    let max: number | undefined
-    const {minContains, maxContains} = parentSchema
-    if (it.opts.next) {
-      min = minContains === undefined ? 1 : minContains
-      max = maxContains
-    } else {
-      min = 1
-    }
-    const len = gen.const("len", _`${data}.length`)
-    cxt.setParams({min, max})
-    if (max === undefined && min === 0) {
-      checkStrictMode(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`)
-      return
-    }
-    if (max !== undefined && min > max) {
-      checkStrictMode(it, `"minContains" > "maxContains" is always invalid`)
-      cxt.fail()
-      return
-    }
-    if (alwaysValidSchema(it, schema)) {
-      let cond = _`${len} >= ${min}`
-      if (max !== undefined) cond = _`${cond} && ${len} <= ${max}`
-      cxt.pass(cond)
-      return
-    }
-
-    it.items = true
-    const valid = gen.name("valid")
-    if (max === undefined && min === 1) {
-      validateItems(valid, () => gen.if(valid, () => gen.break()))
-    } else if (min === 0) {
-      gen.let(valid, true)
-      if (max !== undefined) gen.if(_`${data}.length > 0`, validateItemsWithCount)
-    } else {
-      gen.let(valid, false)
-      validateItemsWithCount()
-    }
-    cxt.result(valid, () => cxt.reset())
-
-    function validateItemsWithCount(): void {
-      const schValid = gen.name("_valid")
-      const count = gen.let("count", 0)
-      validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)))
-    }
-
-    function validateItems(_valid: Name, block: () => void): void {
-      gen.forRange("i", 0, len, (i) => {
-        cxt.subschema(
-          {
-            keyword: "contains",
-            dataProp: i,
-            dataPropType: Type.Num,
-            compositeRule: true,
-          },
-          _valid
-        )
-        block()
-      })
-    }
-
-    function checkLimits(count: Name): void {
-      gen.code(_`${count}++`)
-      if (max === undefined) {
-        gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true).break())
-      } else {
-        gen.if(_`${count} > ${max}`, () => gen.assign(valid, false).break())
-        if (min === 1) gen.assign(valid, true)
-        else gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true))
-      }
-    }
-  },
-}
-
-export default def