@api-client/core 0.19.10 → 0.19.11

package/src/events/amf/AmfEventTypes.ts

@@ -1,6 +0,0 @@
-export const AmfEventTypes = Object.freeze({
-  processApiLink: 'amfprocessapilink',
-  processBuffer: 'amfprocessbuffer',
-  processApiFile: 'amfprocessapifile',
-  selectApiMainFile: 'amfselectapimainfile',
-})

package/src/events/amf/AmfEvents.ts

@@ -1,78 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-import { IApiParseResult, IAmfServiceProcessingOptions } from '../../amf/Parsing.js'
-import { ContextEvent } from '../BaseEvents.js'
-import { AmfEventTypes } from './AmfEventTypes.js'
-
-export class AmfEvents {
-  /**
-   * Downloads the file and processes it as a zipped API project.
-   *
-   * @param url API remote location.
-   * @param mainFile API main file. If not set the program will try to find the best match.
-   * @param md5 When set it will test data integrity with the MD5 hash
-   * @param packaging Default to `zip`.
-   * @returns Promise resolved to the AMF json-ld model.
-   */
-  static async processApiLink(
-    url: string,
-    mainFile?: string,
-    md5?: string,
-    packaging?: string,
-    target: EventTarget = globalThis
-  ): Promise<IApiParseResult> {
-    const e = new ContextEvent(AmfEventTypes.processApiLink, {
-      url,
-      mainFile,
-      md5,
-      packaging,
-    })
-    target.dispatchEvent(e)
-    return e.detail.result as unknown as Promise<IApiParseResult>
-  }
-
-  /**
-   * Parses API data to AMF model.
-   * @param buffer Buffer created from API file.
-   * @param opts Processing options
-   * @returns Promise resolved to the AMF json-ld model
-   */
-  static async processBuffer(
-    buffer: Buffer,
-    opts?: IAmfServiceProcessingOptions,
-    target: EventTarget = globalThis
-  ): Promise<IApiParseResult> {
-    const e = new ContextEvent(AmfEventTypes.processBuffer, {
-      buffer,
-      opts,
-    })
-    target.dispatchEvent(e)
-    return e.detail.result as unknown as Promise<IApiParseResult>
-  }
-
-  /**
-   * Processes file data.
-   * If the blob is a type of `application/zip` it processes the file as a
-   * zip file. Otherwise it processes it as a file.
-   *
-   * @param file File to process.
-   * @returns Promise resolved to the AMF json-ld model
-   */
-  static async processApiFile(file: File | Blob, target: EventTarget = globalThis): Promise<IApiParseResult> {
-    const e = new ContextEvent(AmfEventTypes.processApiFile, {
-      file,
-    })
-    target.dispatchEvent(e)
-    return e.detail.result as unknown as Promise<IApiParseResult>
-  }
-
-  /**
-   * Informs the UI to select a single file from the list of API entry point candidates.
-   */
-  static async selectApiMainFile(candidates: string[], target: EventTarget = globalThis): Promise<string | undefined> {
-    const e = new ContextEvent(AmfEventTypes.selectApiMainFile, {
-      candidates,
-    })
-    target.dispatchEvent(e)
-    return e.detail.result as Promise<string | undefined>
-  }
-}

package/src/mocking/RandExp.ts

@@ -1,335 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * randexp v0.4.6
- * Create random strings that match a given regular expression.
- *
- * Copyright (C) 2017 by fent (https://github.com/fent)
- * MIT License
- */
-
-import { ret, Token, types } from './lib/ret.js'
-
-class DRange {
-  low: number
-  high: number
-  length: number
-
-  constructor(low: number, high: number) {
-    this.low = low
-    this.high = high
-    this.length = 1 + high - low
-  }
-
-  overlaps(range: DRange): boolean {
-    return !(this.high < range.low || this.low > range.high)
-  }
-
-  touches(range: DRange): boolean {
-    return !(this.high + 1 < range.low || this.low - 1 > range.high)
-  }
-
-  add(range: DRange): DRange | null {
-    if (this.touches(range)) {
-      return new DRange(Math.min(this.low, range.low), Math.max(this.high, range.high))
-    }
-    return null
-  }
-
-  subtract(range: DRange): DRange[] {
-    if (!this.overlaps(range)) {
-      return [this.clone()]
-    }
-    if (range.low <= this.low && range.high >= this.high) {
-      return []
-    }
-    if (range.low > this.low && range.high < this.high) {
-      return [new DRange(this.low, range.low - 1), new DRange(range.high + 1, this.high)]
-    }
-    if (range.low <= this.low) {
-      return [new DRange(range.high + 1, this.high)]
-    }
-    // if (range.high >= this.high)
-    return [new DRange(this.low, range.low - 1)]
-  }
-
-  toString(): string {
-    return this.low === this.high ? String(this.low) : `${this.low}-${this.high}`
-  }
-
-  clone(): DRange {
-    return new DRange(this.low, this.high)
-  }
-}
-
-class DiscontinuousRange {
-  ranges: DRange[] = []
-  length = 0
-
-  constructor(low?: number | DiscontinuousRange, high?: number) {
-    if (low !== undefined) {
-      this.add(low, high)
-    }
-  }
-
-  private _setLength(): void {
-    this.length = this.ranges.reduce((sum, range) => sum + range.length, 0)
-  }
-
-  add(low: number | DiscontinuousRange | DRange, high?: number): this {
-    const addRange = (range: DRange) => {
-      const newRanges: DRange[] = []
-      let i = 0
-      while (i < this.ranges.length && !range.touches(this.ranges[i])) {
-        newRanges.push(this.ranges[i].clone())
-        i++
-      }
-      while (i < this.ranges.length && range.touches(this.ranges[i])) {
-        range = range.add(this.ranges[i]) as DRange
-        i++
-      }
-      newRanges.push(range)
-      while (i < this.ranges.length) {
-        newRanges.push(this.ranges[i].clone())
-        i++
-      }
-      this.ranges = newRanges
-      this._setLength()
-    }
-
-    if (low instanceof DiscontinuousRange) {
-      low.ranges.forEach(addRange)
-    } else if (low instanceof DRange) {
-      addRange(low)
-    } else {
-      if (high === undefined) high = low
-      addRange(new DRange(low, high))
-    }
-    return this
-  }
-
-  subtract(low: number | DiscontinuousRange | DRange, high?: number): this {
-    const subtractRange = (range: DRange) => {
-      const newRanges: DRange[] = []
-      let i = 0
-      while (i < this.ranges.length && !range.overlaps(this.ranges[i])) {
-        newRanges.push(this.ranges[i].clone())
-        i++
-      }
-      while (i < this.ranges.length && range.overlaps(this.ranges[i])) {
-        newRanges.push(...this.ranges[i].subtract(range))
-        i++
-      }
-      while (i < this.ranges.length) {
-        newRanges.push(this.ranges[i].clone())
-        i++
-      }
-      this.ranges = newRanges
-      this._setLength()
-    }
-
-    if (low instanceof DiscontinuousRange) {
-      low.ranges.forEach(subtractRange)
-    } else if (low instanceof DRange) {
-      subtractRange(low)
-    } else {
-      if (high === undefined) high = low
-      subtractRange(new DRange(low, high))
-    }
-    return this
-  }
-
-  index(i: number): number | null {
-    let j = 0
-    while (j < this.ranges.length && this.ranges[j].length <= i) {
-      i -= this.ranges[j].length
-      j++
-    }
-    if (j >= this.ranges.length) {
-      return null
-    }
-    return this.ranges[j].low + i
-  }
-
-  toString(): string {
-    return `[ ${this.ranges.join(', ')} ]`
-  }
-
-  clone(): DiscontinuousRange {
-    return new DiscontinuousRange(this)
-  }
-}
-
-export interface RandExpOptions {
-  max?: number
-  defaultRange?: DiscontinuousRange
-  randInt?: (min: number, max: number) => number
-}
-
-export class RandExp {
-  max = 10 // Reduced from 100 to 10 for more reasonable string lengths
-  defaultRange: DiscontinuousRange = new DiscontinuousRange(32, 126)
-  randInt: (min: number, max: number) => number = (min, max) => {
-    return min + Math.floor(Math.random() * (max - min + 1))
-  }
-
-  private tokens: Token
-  private ignoreCase: boolean
-  private multiline: boolean
-
-  constructor(regexp: RegExp | string, flags?: string, options?: RandExpOptions) {
-    this.defaultRange = this.defaultRange.clone()
-
-    // Apply options if provided
-    if (options) {
-      if (typeof options.max === 'number') {
-        this.max = options.max
-      }
-      if (options.defaultRange instanceof DiscontinuousRange) {
-        this.defaultRange = options.defaultRange
-      }
-      if (typeof options.randInt === 'function') {
-        this.randInt = options.randInt
-      }
-    }
-
-    if (regexp instanceof RegExp) {
-      this.ignoreCase = regexp.ignoreCase
-      this.multiline = regexp.multiline
-      this._setDefaults(regexp)
-      regexp = regexp.source
-    } else if (typeof regexp === 'string') {
-      this.ignoreCase = flags?.includes('i') ?? false
-      this.multiline = flags?.includes('m') ?? false
-    } else {
-      throw new Error('Expected a regexp or string')
-    }
-    this.tokens = ret(regexp)
-  }
-
-  private _setDefaults(regexp: any): void {
-    if (typeof regexp.max === 'number') {
-      this.max = regexp.max
-    }
-    if (regexp.defaultRange instanceof DiscontinuousRange) {
-      this.defaultRange = regexp.defaultRange
-    }
-    if (typeof regexp.randInt === 'function') {
-      this.randInt = regexp.randInt
-    }
-  }
-
-  gen(): string {
-    return this._gen(this.tokens, [])
-  }
-
-  private _gen(token: Token, groups: (string | null)[]): string {
-    let stack, str, i, l
-
-    switch (token.type) {
-      case types.ROOT:
-      case types.GROUP:
-        if (token.followedBy || token.notFollowedBy) return ''
-
-        if (token.remember && token.groupNumber === undefined) {
-          token.groupNumber = groups.push(null) - 1
-        }
-
-        stack = token.options ? this._choice(token.options) : token.stack
-        str = ''
-        for (i = 0, l = stack.length; i < l; i++) {
-          str += this._gen(stack[i], groups)
-        }
-
-        if (token.remember) {
-          groups[token.groupNumber] = str
-        }
-        return str
-
-      case types.POSITION:
-        return ''
-
-      case types.SET: {
-        const set = this._processSet(token)
-        if (!set.length) return ''
-        return String.fromCharCode(this._choice(set) as number)
-      }
-      case types.REPETITION: {
-        const n = this.randInt(token.min, token.max === Infinity ? token.min + this.max : token.max)
-        str = ''
-        for (i = 0; i < n; i++) {
-          str += this._gen(token.value, groups)
-        }
-        return str
-      }
-      case types.REFERENCE:
-        return groups[token.value - 1] || ''
-
-      case types.CHAR: {
-        const code = this.ignoreCase && this._coin() ? RandExp._toCaseInverse(token.value) : token.value
-        return String.fromCharCode(code)
-      }
-    }
-    return ''
-  }
-
-  private _processSet(token: Token): DiscontinuousRange {
-    if (token.type === types.CHAR) {
-      return new DiscontinuousRange(token.value)
-    }
-    if (token.type === types.RANGE) {
-      return new DiscontinuousRange(token.from, token.to)
-    }
-
-    const dr = new DiscontinuousRange()
-    for (const char of token.set) {
-      const sub = this._processSet(char)
-      dr.add(sub)
-      if (this.ignoreCase) {
-        for (let j = 0; j < sub.length; j++) {
-          const charCode = sub.index(j) as number
-          const otherCase = RandExp._toCaseInverse(charCode)
-          if (charCode !== otherCase) {
-            dr.add(otherCase)
-          }
-        }
-      }
-    }
-
-    return token.not ? this.defaultRange.clone().subtract(dr) : dr
-  }
-
-  private static _toCaseInverse(code: number): number {
-    if (code >= 97 && code <= 122) return code - 32
-    if (code >= 65 && code <= 90) return code + 32
-    return code
-  }
-
-  private _coin(): boolean {
-    return this.randInt(0, 1) === 0
-  }
-
-  private _choice(choices: any[] | DiscontinuousRange): any {
-    if (choices instanceof DiscontinuousRange) {
-      return choices.index(this.randInt(0, choices.length - 1))
-    }
-    return choices[this.randInt(0, choices.length - 1)]
-  }
-
-  static randexp(regexp: RegExp | string, flags?: string, options?: RandExpOptions): string {
-    let randexpInstance
-    if ((regexp as any)._randexp === undefined) {
-      randexpInstance = new RandExp(regexp, flags, options)
-      ;(regexp as any)._randexp = randexpInstance
-    } else {
-      randexpInstance = (regexp as any)._randexp
-    }
-    randexpInstance._setDefaults(regexp)
-    return randexpInstance.gen()
-  }
-
-  static sugar(): void {
-    ;(RegExp.prototype as any).gen = function () {
-      return RandExp.randexp(this)
-    }
-  }
-}

package/src/mocking/lib/ret.ts

@@ -1,279 +0,0 @@
-// Regular Expression Tokenizer
-// https://github.com/fent/ret.js
-
-export enum types {
-  ROOT = 0,
-  GROUP = 1,
-  POSITION = 2,
-  SET = 3,
-  RANGE = 4,
-  REPETITION = 5,
-  REFERENCE = 6,
-  CHAR = 7,
-}
-
-export interface Token {
-  type: types
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [key: string]: any
-}
-const wordBoundary = (): Token => ({ type: types.POSITION, value: 'b' })
-const nonWordBoundary = (): Token => ({ type: types.POSITION, value: 'B' })
-const begin = (): Token => ({ type: types.POSITION, value: '^' })
-const end = (): Token => ({ type: types.POSITION, value: '$' })
-
-const ints = (): Token[] => [{ type: types.RANGE, from: 48, to: 57 }]
-const words = (): Token[] => [
-  { type: types.CHAR, value: 95 },
-  { type: types.RANGE, from: 97, to: 122 },
-  { type: types.RANGE, from: 65, to: 90 },
-  ...ints(),
-]
-const whitespace = (): Token[] => [
-  { type: types.CHAR, value: 9 },
-  { type: types.CHAR, value: 10 },
-  { type: types.CHAR, value: 11 },
-  { type: types.CHAR, value: 12 },
-  { type: types.CHAR, value: 13 },
-  { type: types.CHAR, value: 32 },
-  { type: types.CHAR, value: 160 },
-  { type: types.CHAR, value: 5760 },
-  { type: types.CHAR, value: 6158 },
-  { type: types.CHAR, value: 8192 },
-  { type: types.CHAR, value: 8193 },
-  { type: types.CHAR, value: 8194 },
-  { type: types.CHAR, value: 8195 },
-  { type: types.CHAR, value: 8196 },
-  { type: types.CHAR, value: 8197 },
-  { type: types.CHAR, value: 8198 },
-  { type: types.CHAR, value: 8199 },
-  { type: types.CHAR, value: 8200 },
-  { type: types.CHAR, value: 8201 },
-  { type: types.CHAR, value: 8202 },
-  { type: types.CHAR, value: 8232 },
-  { type: types.CHAR, value: 8233 },
-  { type: types.CHAR, value: 8239 },
-  { type: types.CHAR, value: 8287 },
-  { type: types.CHAR, value: 12288 },
-  { type: types.CHAR, value: 65279 },
-]
-const notanychar = (): Token[] => [
-  { type: types.CHAR, value: 10 },
-  { type: types.CHAR, value: 13 },
-  { type: types.CHAR, value: 8232 },
-  { type: types.CHAR, value: 8233 },
-]
-
-const words_ = (): Token => ({ type: types.SET, set: words(), not: false })
-const notWords = (): Token => ({ type: types.SET, set: words(), not: true })
-const ints_ = (): Token => ({ type: types.SET, set: ints(), not: false })
-const notInts = (): Token => ({ type: types.SET, set: ints(), not: true })
-const whitespace_ = (): Token => ({ type: types.SET, set: whitespace(), not: false })
-const notWhitespace = (): Token => ({ type: types.SET, set: whitespace(), not: true })
-const anyChar = (): Token => ({ type: types.SET, set: notanychar(), not: true })
-
-const specialChars: Record<string, number> = {
-  '0': 0,
-  't': 9,
-  'n': 10,
-  'v': 11,
-  'f': 12,
-  'r': 13,
-}
-
-const strToChars = (str: string): string => {
-  const chars = /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g
-  return str.replace(chars, (match, b, s, uh, xh, o, c, sp) => {
-    if (s) return match
-    const code = b
-      ? 8
-      : uh
-        ? parseInt(uh, 16)
-        : xh
-          ? parseInt(xh, 16)
-          : o
-            ? parseInt(o, 8)
-            : c
-              ? '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?'.indexOf(c)
-              : specialChars[sp]
-    let ch = String.fromCharCode(code)
-    if (/[[{}^$.|?*+()]/.test(ch)) {
-      ch = `\\${ch}`
-    }
-    return ch
-  })
-}
-
-const tokenizeClass = (str: string, regexpStr: string): [Token[], number] => {
-  const tokens: Token[] = []
-  const classTokens = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(?:\\)?([^\]]))|(\])|(?:\\)?(.)/g
-  let match
-  let char
-  while ((match = classTokens.exec(str)) !== null) {
-    if (match[1]) {
-      tokens.push(words_())
-    } else if (match[2]) {
-      tokens.push(ints_())
-    } else if (match[3]) {
-      tokens.push(whitespace_())
-    } else if (match[4]) {
-      tokens.push(notWords())
-    } else if (match[5]) {
-      tokens.push(notInts())
-    } else if (match[6]) {
-      tokens.push(notWhitespace())
-    } else if (match[7]) {
-      tokens.push({
-        type: types.RANGE,
-        from: (match[8] || match[9]).charCodeAt(0),
-        to: match[10].charCodeAt(0),
-      })
-    } else if ((char = match[12])) {
-      tokens.push({ type: types.CHAR, value: char.charCodeAt(0) })
-    } else {
-      return [tokens, classTokens.lastIndex]
-    }
-  }
-  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Unterminated character class`)
-}
-
-const error = (regexpStr: string, msg: string): never => {
-  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: ${msg}`)
-}
-
-export const ret = (regexpStr: string): Token => {
-  let i = 0
-  const root: Token = { type: types.ROOT, stack: [] }
-  let p: Token = root
-  let stack: Token[] = root.stack
-  const groupStack: Token[] = []
-
-  const repeatErr = (i: number) => error(regexpStr, `Nothing to repeat at column ${i - 1}`)
-  const chars = strToChars(regexpStr)
-
-  while (i < chars.length) {
-    let c = chars[i++]
-    switch (c) {
-      case '\\':
-        c = chars[i++]
-        switch (c) {
-          case 'b':
-            stack.push(wordBoundary())
-            break
-          case 'B':
-            stack.push(nonWordBoundary())
-            break
-          case 'w':
-            stack.push(words_())
-            break
-          case 'W':
-            stack.push(notWords())
-            break
-          case 'd':
-            stack.push(ints_())
-            break
-          case 'D':
-            stack.push(notInts())
-            break
-          case 's':
-            stack.push(whitespace_())
-            break
-          case 'S':
-            stack.push(notWhitespace())
-            break
-          default:
-            if (/\d/.test(c)) {
-              stack.push({ type: types.REFERENCE, value: parseInt(c, 10) })
-            } else {
-              stack.push({ type: types.CHAR, value: c.charCodeAt(0) })
-            }
-        }
-        break
-      case '^':
-        stack.push(begin())
-        break
-      case '$':
-        stack.push(end())
-        break
-      case '[': {
-        let not = false
-        if (chars[i] === '^') {
-          not = true
-          i++
-        }
-        const [set, lastIndex] = tokenizeClass(chars.slice(i), regexpStr)
-        i += lastIndex
-        stack.push({ type: types.SET, set, not })
-        break
-      }
-      case '.':
-        stack.push(anyChar())
-        break
-      case '(': {
-        const group: Token = { type: types.GROUP, stack: [], remember: true }
-        if (chars[i] === '?') {
-          c = chars[i + 1]
-          i += 2
-          if (c === '=') {
-            group.followedBy = true
-          } else if (c === '!') {
-            group.notFollowedBy = true
-          } else if (c !== ':') {
-            error(regexpStr, `Invalid group, character '${c}' after '?' at column ${i - 1}`)
-          }
-          group.remember = false
-        }
-        stack.push(group)
-        groupStack.push(p)
-        p = group
-        stack = group.stack
-        break
-      }
-      case ')':
-        if (groupStack.length === 0) error(regexpStr, `Unmatched ) at column ${i - 1}`)
-        p = groupStack.pop() as Token
-        stack = p.options ? p.options[p.options.length - 1] : p.stack
-        break
-      case '|':
-        if (!p.options) {
-          p.options = [p.stack]
-          delete p.stack
-        }
-        {
-          const newStack: Token[] = []
-          p.options.push(newStack)
-          stack = newStack
-        }
-        break
-      case '{': {
-        const repetition = /^(\d+)(,(\d+)?)?\}/.exec(chars.slice(i))
-        if (repetition) {
-          if (stack.length === 0) repeatErr(i)
-          const min = parseInt(repetition[1], 10)
-          const max = repetition[2] ? (repetition[3] ? parseInt(repetition[3], 10) : Infinity) : min
-          i += repetition[0].length
-          stack.push({ type: types.REPETITION, min, max, value: stack.pop() })
-        } else {
-          stack.push({ type: types.CHAR, value: 123 })
-        }
-        break
-      }
-      case '?':
-        if (stack.length === 0) repeatErr(i)
-        stack.push({ type: types.REPETITION, min: 0, max: 1, value: stack.pop() })
-        break
-      case '+':
-        if (stack.length === 0) repeatErr(i)
-        stack.push({ type: types.REPETITION, min: 1, max: Infinity, value: stack.pop() })
-        break
-      case '*':
-        if (stack.length === 0) repeatErr(i)
-        stack.push({ type: types.REPETITION, min: 0, max: Infinity, value: stack.pop() })
-        break
-      default:
-        stack.push({ type: types.CHAR, value: c.charCodeAt(0) })
-    }
-  }
-  if (groupStack.length !== 0) error(regexpStr, 'Unterminated group')
-  return root
-}