@api-client/ui 0.1.9 → 0.2.2

package/src/amf/lib/UrlUtils.ts

@@ -1,213 +0,0 @@
-import type { ComputeBaseUriOptions } from '../types.js'
-
-/**
- * Computes the base URI value for the API/endpoint/operation.
- *
- * @param url The url to check for protocol information.
- * @param options The computation options
- * @returns The base uri value with a protocol,
- */
-export function setProtocol(url = '', options: ComputeBaseUriOptions = {}): string {
-  const { server, protocols = [] } = options
-  const schemes = [...protocols]
-  if (server && server.protocol) {
-    schemes.unshift(server.protocol)
-  }
-
-  let result = url
-  // this also run when an Async API is loaded so the protocol may be whatever.
-  const hasProtocol = !!result && result.includes('://')
-  if (result && !hasProtocol && schemes.length) {
-    result = `${schemes[0]}://${result}`
-  } else if (result && !hasProtocol && options.forceHttpProtocol) {
-    result = `http://${result}`
-  }
-  return result
-}
-
-/**
- * Computes the base URI value for the API/endpoint/operation.
- *
- * @param options The computation options
- * @returns Base uri value. Can be empty string.
- */
-export function computeApiBaseUri(options: ComputeBaseUriOptions = {}): string {
-  const { baseUri, server, version } = options
-  if (baseUri) {
-    let result = baseUri
-    if (result.endsWith('/')) {
-      result = result.substr(0, result.length - 1)
-    }
-    return setProtocol(result, options)
-  }
-  if (!server) {
-    return ''
-  }
-  const { url = '' } = server
-  let result = url
-  if (version && result) {
-    result = result.replace('{version}', version)
-  }
-  if (result.endsWith('/')) {
-    result = result.substr(0, result.length - 1)
-  }
-  return setProtocol(result, options)
-}
-
-/**
- * Computes the base URI value for the API/endpoint/operation.
- *
- * @param options The computation options
- * @returns Base uri value. Can be empty string.
- */
-export function computeEndpointUri(options: ComputeBaseUriOptions = {}): string {
-  let result = computeApiBaseUri(options)
-  if (options.endpoint) {
-    let { path = '' } = options.endpoint
-    if (path[0] !== '/') {
-      path = `/${path}`
-    }
-    result += path
-  }
-  if (!result) {
-    result = '(unknown path)'
-  }
-  return result
-}
-
-/**
- * @param str A key or value to encode as x-www-form-urlencoded.
- * @param replacePlus When set it replaces `%20` with `+`.
- */
-export function wwwFormUrlEncode(str: string, replacePlus: boolean): string {
-  // Spec says to normalize newlines to \r\n and replace %20 spaces with +.
-  // jQuery does this as well, so this is likely to be widely compatible.
-  if (!str) {
-    return ''
-  }
-  let result = encodeURIComponent(str.toString().replace(/\r?\n/g, '\r\n'))
-  if (replacePlus) {
-    result = result.replace(/%20/g, '+')
-  }
-  return result
-}
-
-/**
- * Creates a RegExp object to replace template variable from the base string
- * @param name Name of the parameter to be replaced
- */
-function createUrlReplaceRegex(name: string): RegExp {
-  if (name[0] === '+' || name[0] === '#') {
-    name = `\\${name}`
-  }
-  return new RegExp(`{${name}}`, 'g')
-}
-
-/**
- * @param url The current URL
- * @param variables The path variables to apply.
- * @param encode Whether to encode parameters.
- */
-export function applyUrlVariables(url: string, variables: Record<string, unknown>, encode: boolean): string {
-  let result = url || ''
-  Object.keys(variables).forEach((variable) => {
-    let value = variables[variable]
-    if (value === undefined) {
-      return
-    }
-    value = String(value)
-    if (value === '') {
-      // this is to leave the URL template value in the URL so the validators
-      // can report an error.
-      return
-    }
-    if (encode) {
-      if (variable[0] === '+' || variable[0] === '#') {
-        value = encodeURI(value as string)
-      } else {
-        value = wwwFormUrlEncode(value as string, false)
-      }
-    }
-    const r = createUrlReplaceRegex(variable)
-    result = result.replace(r, String(value))
-  })
-  return result
-}
-
-/**
- * @param params The query parameters to use to generate the query string.
- * @param encode Whether to encode query parameters.
- * @returns The query string.
- */
-function generateQueryString(params: Record<string, unknown>, encode: boolean): string {
-  if (typeof params !== 'object') {
-    return ''
-  }
-  const parts: string[] = []
-  function addPart(name: string, value: unknown): void {
-    if (value === undefined) {
-      value = ''
-    } else {
-      value = String(value)
-    }
-    if (encode) {
-      name = wwwFormUrlEncode(name, true)
-      value = wwwFormUrlEncode(value as string, true)
-    }
-    parts.push(`${name}=${value}`)
-  }
-  Object.keys(params).forEach((key) => {
-    const value = params[key]
-    if (Array.isArray(value)) {
-      value.forEach((v) => {
-        let arrayValue = v
-        if (Array.isArray(arrayValue)) {
-          arrayValue = arrayValue.join(',')
-        }
-        addPart(key, arrayValue)
-      })
-    } else {
-      addPart(key, value)
-    }
-  })
-  return parts.join('&')
-}
-
-/**
- * @param url The current URL
- * @param params The query parameters to apply.
- * @param encode Whether to encode parameters.
- */
-export function applyUrlParameters(url: string, params: Record<string, unknown>, encode: boolean): string {
-  const query = generateQueryString(params, encode)
-  if (!query) {
-    return url
-  }
-  let result = url || ''
-  result += result.indexOf('?') === -1 ? '?' : '&'
-  result += query
-  return result
-}
-
-/**
- * Applies query parameter values to an object.
- * Repeated parameters will have array value instead of string value.
- *
- * @param param Query parameter value as string. Eg `name=value`
- * @param obj Target for values
- */
-export function applyQueryParamStringToObject(param: string, obj: Record<string, string | string[]>): void {
-  if (!param || !obj || typeof param !== 'string') {
-    return
-  }
-  const parts = param.split('=')
-  const name = parts[0]
-  if (name in obj) {
-    if (!Array.isArray(obj[name])) {
-      obj[name] = [obj[name] as string]
-    }
-    ;(obj[name] as string[]).push(parts[1])
-  } else {
-    obj[name] = parts[1]
-  }
-}

package/src/amf/lib/Utils.ts

@@ -1,220 +0,0 @@
-import { Headers } from '@api-client/core/lib/headers/Headers.js'
-import { AmfNamespace } from '@api-client/core/amf/definitions/Namespace.js'
-import sanitizer from 'dompurify'
-import type {
-  IShapeUnion,
-  IApiScalarShape,
-  IApiTupleShape,
-  IApiArrayShape,
-  IApiNodeShape,
-  IApiUnionShape,
-} from '@api-client/core/amf/definitions/Shapes.js'
-import type { IApiParameter, IApiParametrizedDeclaration } from '@api-client/core/amf/definitions/Api.js'
-/**
- * Stops an event and cancels it.
- * @param e The event to stop
- */
-export function cancelEvent(e: Event): void {
-  e.preventDefault()
-  e.stopPropagation()
-  e.stopImmediatePropagation()
-}
-
-/**
- * @param types Shape's types
- */
-export function isScalarType(types: string[] = []): boolean {
-  const { shapes } = AmfNamespace.aml.vocabularies
-  return types.includes(shapes.ScalarShape) || types.includes(shapes.NilShape) || types.includes(shapes.FileShape)
-}
-
-/**
- * @param value The value from the graph model to use to read the value from
- */
-export function schemaToType(value: string): string {
-  const typed = String(value)
-  let index = typed.lastIndexOf('#')
-  if (index === -1) {
-    index = typed.lastIndexOf('/')
-  }
-  let v = typed.substr(index + 1)
-  if (v) {
-    v = `${v[0].toUpperCase()}${v.substr(1)}`
-  }
-  return v
-}
-
-/**
- * Reads the label for a data type for a shape union.
- * @param schema
- * @param isArray Used internally
- * @returns Computed label for a shape.
- */
-export function readPropertyTypeLabel(schema: IShapeUnion, isArray = false): string | undefined {
-  if (!schema) {
-    return undefined
-  }
-  const { types } = schema
-  if (types.includes(AmfNamespace.aml.vocabularies.shapes.NilShape)) {
-    return 'Nil'
-  }
-  if (types.includes(AmfNamespace.aml.vocabularies.shapes.ScalarShape)) {
-    const scalar = schema as IApiScalarShape
-    return schemaToType(scalar.dataType || '')
-  }
-  if (types.includes(AmfNamespace.aml.vocabularies.shapes.TupleShape)) {
-    const array = schema as IApiTupleShape
-    if (!array.items || !array.items.length) {
-      return undefined
-    }
-    const label = readPropertyTypeLabel(array.items[0], true)
-    return `List of ${label}`
-  }
-  if (types.includes(AmfNamespace.aml.vocabularies.shapes.ArrayShape)) {
-    const array = schema as IApiArrayShape
-    if (!array.items) {
-      return undefined
-    }
-    let label = readPropertyTypeLabel(array.items, true)
-    if (label === 'items' && !isScalarType(array.items.types)) {
-      label = 'objects'
-    }
-    return `List of ${label}`
-  }
-  if (types.includes(AmfNamespace.w3.shacl.NodeShape)) {
-    let { name } = schema as IApiNodeShape
-    const { properties } = schema as IApiNodeShape
-    if (isArray && properties && properties.length === 1) {
-      const potentialScalar = properties[0].range as IApiScalarShape
-      if (potentialScalar.types.includes(AmfNamespace.aml.vocabularies.shapes.ScalarShape)) {
-        return schemaToType(potentialScalar.dataType || '')
-      }
-    }
-    if (name === 'type') {
-      // AMF seems to put `type` value into a property that is declared inline (?).
-      name = undefined
-    }
-    return name || 'Object'
-  }
-  if (types.includes(AmfNamespace.aml.vocabularies.shapes.UnionShape)) {
-    const union = schema as IApiUnionShape
-    const items = union.anyOf.map((i) => readPropertyTypeLabel(i))
-    return items.join(' or ')
-  }
-  if (types.includes(AmfNamespace.aml.vocabularies.shapes.FileShape)) {
-    return 'File'
-  }
-  return schema.name || 'Unknown'
-}
-
-/**
- * @param shapes
- * @returns true when all of passed shapes are scalar.
- */
-function isAllScalar(shapes: IShapeUnion[] = []): boolean {
-  return !shapes.some((i) => !isScalarType(i.types))
-}
-
-/**
- * @param shape
- * @returns true when the passed union type consists of scalar values only. Nil counts as scalar.
- */
-export function isScalarUnion(shape: IApiUnionShape): boolean {
-  const { anyOf = [], or = [], and = [], xone = [] } = shape
-  if (anyOf.length) {
-    return isAllScalar(anyOf)
-  }
-  if (or.length) {
-    return isAllScalar(or)
-  }
-  if (and.length) {
-    return isAllScalar(and)
-  }
-  if (xone.length) {
-    return isAllScalar(xone)
-  }
-  return true
-}
-
-export function sanitizeHTML(HTML: string): string {
-  const result = sanitizer.sanitize(HTML, {
-    ADD_ATTR: ['target', 'href'],
-    ALLOWED_TAGS: ['a'],
-    USE_PROFILES: { html: true },
-  })
-
-  if (typeof result === 'string') {
-    return result
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  return result.toString()
-}
-
-export function joinTraitNames(traits: IApiParametrizedDeclaration[]): string {
-  const names = traits.map((trait) => trait.name).filter((i) => !!i)
-  let value = ''
-  if (names.length === 2) {
-    value = names.join(' and ')
-  } else if (value.length > 2) {
-    const last = names.pop()
-    value = names.join(', ')
-    value += `, and ${last}`
-  } else {
-    value = names.join(', ')
-  }
-  return value
-}
-
-export function generateHeaders(params: Record<string, unknown>): string {
-  if (typeof params !== 'object') {
-    return ''
-  }
-  const lines = Object.keys(params).map((name) => {
-    let value = params[name]
-    if (value === undefined) {
-      value = ''
-    } else if (Array.isArray(value)) {
-      value = value.join(',')
-    } else {
-      value = String(value)
-    }
-    let result = `${name}: `
-    value = (value as string).split('\n').join(' ')
-    result += value
-    return result
-  })
-  return lines.join('\n')
-}
-
-/**
- * Ensures the headers have content type header.
- * @param headers The generated headers string
- * @param mime The expected by the selected payload media type. If not set then it does nothing.
- */
-export function ensureContentType(headers: string, mime?: string): string {
-  if (!mime) {
-    return headers
-  }
-  const parsed = new Headers(headers)
-  const current = parsed.get('content-type')
-  if (!current && mime) {
-    parsed.set('content-type', mime)
-  }
-  return parsed.toString()
-}
-
-/**
- * @param parameter
- * @param schema
- * @returns The name to use in the input.
- */
-export function readLabelValue(parameter: IApiParameter, schema: IShapeUnion): string {
-  let label = parameter.paramName || schema.displayName || parameter.name || schema.name || ''
-  const { required } = parameter
-  if (required) {
-    label += '*'
-  }
-  return label
-}

package/src/amf/lib/navigation-layout/ApiSorting.ts

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-import type { ApiEndPointListItem } from '../../types.js'
-
-export class ApiSorting {
-  /**
-   * Sorts endpoints by path.
-   */
-  static sortEndpointsByPath(list: ApiEndPointListItem[]): ApiEndPointListItem[] {
-    list.sort((a, b) => {
-      if (a.path < b.path) {
-        return -1
-      }
-      if (a.path > b.path) {
-        return 1
-      }
-      return 0
-    })
-    return list
-  }
-}

package/src/amf/lib/navigation-layout/EndpointsTree.ts

@@ -1,189 +0,0 @@
-import type { ApiEndpointsTreeItem, ApiEndPointListItem } from '../../types.js'
-
-export interface CommonRootInfo {
-  index: number
-  item: ApiEndpointsTreeItem
-  common: string
-}
-
-/**
- * A class that transforms the list of endpoints and methods into
- * a tree structure with indentation
- */
-export class EndpointsTree {
-  result: ApiEndpointsTreeItem[]
-
-  indents: Record<string, number>
-
-  constructor() {
-    this.result = []
-    this.indents = {}
-  }
-
-  /**
-   * @param list Sorted list of endpoints.
-   */
-  create(list: ApiEndPointListItem[]): ApiEndpointsTreeItem[] {
-    if (!Array.isArray(list) || !list.length) {
-      return []
-    }
-    const { result, indents } = this
-    let prev: ApiEndpointsTreeItem | undefined
-    for (let i = 0, len = list.length; i < len; i++) {
-      const item = { ...list[i], indent: 0, label: '' } as ApiEndpointsTreeItem
-      const { path } = item
-      const parts = path.split('/')
-      const hasParts = parts.length > 1 && !(parts.length === 2 && !parts[0])
-      if (i === 0) {
-        if (hasParts) {
-          const parent: ApiEndpointsTreeItem = {
-            indent: 0,
-            path: parts.slice(0, parts.length - 1).join('/'),
-            label: undefined,
-            operations: [],
-            hasChildren: true,
-          }
-          parent.label = parent.path
-          prev = parent
-          indents[parent.path] = item.indent
-          result.push(parent)
-        } else {
-          prev = item
-          indents[item.path] = item.indent
-          result.push(this.prepareLabel(item))
-          continue
-        }
-      }
-      if (!prev) {
-        continue
-      }
-      // this is similar to the next block but is faster when the previous item is parent.
-      if (path.startsWith(prev.path || '')) {
-        item.indent = prev.indent + 1
-        prev.hasChildren = true
-        indents[item.path] = item.indent
-        result.push(this.prepareLabel(item, prev.path))
-        prev = item
-        continue
-      }
-      const upPath = this.findParentEndpoint(parts)
-      if (upPath) {
-        item.indent = indents[upPath] + 1
-        const parent = result.find((p) => p.path === upPath) as ApiEndpointsTreeItem
-        parent.hasChildren = true
-        indents[item.path] = item.indent
-        result.push(this.prepareLabel(item, upPath))
-      } else {
-        if (hasParts) {
-          const info = this.findCommonRootInfo(parts)
-          if (info) {
-            // this is an abstract item, it's not actually an endpoint
-            const parent: ApiEndpointsTreeItem = {
-              indent: info.item.indent,
-              path: info.common,
-              label: info.common,
-              operations: [],
-              hasChildren: true,
-            }
-            this.postInsertParent(parent)
-            indents[parent.path] = parent.indent
-            result.splice(info.index, 0, parent)
-            item.indent = parent.indent + 1
-            indents[item.path] = item.indent
-            result.push(this.prepareLabel(item, parent.path))
-            continue
-          }
-        }
-        item.indent = 0
-        indents[item.path] = item.indent
-        result.push(this.prepareLabel(item))
-      }
-      prev = item
-    }
-    return result
-  }
-
-  /**
-   * @param parts Path parts of the currently evaluated endpoint
-   */
-  findParentEndpoint(parts: string[]): string | undefined {
-    const { indents } = this
-    const list = Array.from(parts)
-    const compare = Object.keys(indents).reverse()
-    while (true) {
-      const path = list.join('/')
-      if (!path) {
-        break
-      }
-      const upPath = compare.find((candidate) => path.startsWith(candidate))
-      if (upPath) {
-        return upPath
-      }
-      list.pop()
-      if (!list.length) {
-        break
-      }
-    }
-    return undefined
-  }
-
-  /**
-   * @param parts Path parts of the currently evaluated endpoint
-   */
-  findCommonRootInfo(parts: string[]): CommonRootInfo | undefined {
-    const { result } = this
-    const list = Array.from(parts)
-    while (true) {
-      list.pop()
-      if (!list.length) {
-        break
-      }
-      const path = list.join('/')
-      if (!path) {
-        break
-      }
-      const index = result.findIndex((candidate) => candidate.path.startsWith(path))
-      if (index !== -1) {
-        return {
-          index,
-          item: result[index],
-          common: path,
-        }
-      }
-    }
-    return undefined
-  }
-
-  prepareLabel(item: ApiEndpointsTreeItem, prevPath?: string): ApiEndpointsTreeItem {
-    const { name, path, indent } = item
-    item.label = path
-    if (name) {
-      item.label = name
-    } else if (indent > 0 && prevPath) {
-      let label = item.label.replace(prevPath, '')
-      if (label.startsWith('-')) {
-        label = label.substring(1)
-      }
-      item.label = label
-      item.hasShortPath = true
-      if (!item.label.startsWith('/')) {
-        item.label = `/${item.label}`
-      }
-    }
-    return item
-  }
-
-  /**
-   * Updates paths and indentation of children after inserting a new (abstract) parent.
-   */
-  postInsertParent(parent: ApiEndpointsTreeItem): void {
-    const { result } = this
-    result.forEach((item) => {
-      const { path } = item
-      if (path.startsWith(parent.path)) {
-        item.indent += 1
-        item.label = (item.label || '').replace(parent.path, '')
-      }
-    })
-  }
-}