@upendra19/swagger-ui-custom 1.0.0

package/src/core/plugins/json-schema-2020-12-samples/fn/class/EncoderRegistry.js

@@ -0,0 +1,33 @@
+/**
+ * @prettier
+ */
+import Registry from "./Registry"
+import encode7bit from "../encoders/7bit"
+import encode8bit from "../encoders/8bit"
+import encodeBinary from "../encoders/binary"
+import encodeQuotedPrintable from "../encoders/quoted-printable"
+import encodeBase16 from "../encoders/base16"
+import encodeBase32 from "../encoders/base32"
+import encodeBase64 from "../encoders/base64"
+import encodeBase64Url from "../encoders/base64url"
+
+class EncoderRegistry extends Registry {
+  #defaults = {
+    "7bit": encode7bit,
+    "8bit": encode8bit,
+    binary: encodeBinary,
+    "quoted-printable": encodeQuotedPrintable,
+    base16: encodeBase16,
+    base32: encodeBase32,
+    base64: encodeBase64,
+    base64url: encodeBase64Url,
+  }
+
+  data = { ...this.#defaults }
+
+  get defaults() {
+    return { ...this.#defaults }
+  }
+}
+
+export default EncoderRegistry

package/src/core/plugins/json-schema-2020-12-samples/fn/class/FormatRegistry.js

@@ -0,0 +1,65 @@
+/**
+ * @prettier
+ */
+import Registry from "./Registry"
+import int32Generator from "../generators/int32"
+import int64Generator from "../generators/int64"
+import floatGenerator from "../generators/float"
+import doubleGenerator from "../generators/double"
+import emailGenerator from "../generators/email"
+import idnEmailGenerator from "../generators/idn-email"
+import hostnameGenerator from "../generators/hostname"
+import idnHostnameGenerator from "../generators/idn-hostname"
+import ipv4Generator from "../generators/ipv4"
+import ipv6Generator from "../generators/ipv6"
+import uriGenerator from "../generators/uri"
+import uriReferenceGenerator from "../generators/uri-reference"
+import iriGenerator from "../generators/iri"
+import iriReferenceGenerator from "../generators/iri-reference"
+import uuidGenerator from "../generators/uuid"
+import uriTemplateGenerator from "../generators/uri-template"
+import jsonPointerGenerator from "../generators/json-pointer"
+import relativeJsonPointerGenerator from "../generators/relative-json-pointer"
+import dateTimeGenerator from "../generators/date-time"
+import dateGenerator from "../generators/date"
+import timeGenerator from "../generators/time"
+import durationGenerator from "../generators/duration"
+import passwordGenerator from "../generators/password"
+import regexGenerator from "../generators/regex"
+
+class FormatRegistry extends Registry {
+  #defaults = {
+    int32: int32Generator,
+    int64: int64Generator,
+    float: floatGenerator,
+    double: doubleGenerator,
+    email: emailGenerator,
+    "idn-email": idnEmailGenerator,
+    hostname: hostnameGenerator,
+    "idn-hostname": idnHostnameGenerator,
+    ipv4: ipv4Generator,
+    ipv6: ipv6Generator,
+    uri: uriGenerator,
+    "uri-reference": uriReferenceGenerator,
+    iri: iriGenerator,
+    "iri-reference": iriReferenceGenerator,
+    uuid: uuidGenerator,
+    "uri-template": uriTemplateGenerator,
+    "json-pointer": jsonPointerGenerator,
+    "relative-json-pointer": relativeJsonPointerGenerator,
+    "date-time": dateTimeGenerator,
+    date: dateGenerator,
+    time: timeGenerator,
+    duration: durationGenerator,
+    password: passwordGenerator,
+    regex: regexGenerator,
+  }
+
+  data = { ...this.#defaults }
+
+  get defaults() {
+    return { ...this.#defaults }
+  }
+}
+
+export default FormatRegistry

package/src/core/plugins/json-schema-2020-12-samples/fn/class/MediaTypeRegistry.js

@@ -0,0 +1,27 @@
+/**
+ * @prettier
+ */
+import Registry from "./Registry"
+import textMediaTypesGenerators from "../generators/media-types/text"
+import imageMediaTypesGenerators from "../generators/media-types/image"
+import audioMediaTypesGenerators from "../generators/media-types/audio"
+import videoMediaTypesGenerators from "../generators/media-types/video"
+import applicationMediaTypesGenerators from "../generators/media-types/application"
+
+class MediaTypeRegistry extends Registry {
+  #defaults = {
+    ...textMediaTypesGenerators,
+    ...imageMediaTypesGenerators,
+    ...audioMediaTypesGenerators,
+    ...videoMediaTypesGenerators,
+    ...applicationMediaTypesGenerators,
+  }
+
+  data = { ...this.#defaults }
+
+  get defaults() {
+    return { ...this.#defaults }
+  }
+}
+
+export default MediaTypeRegistry

package/src/core/plugins/json-schema-2020-12-samples/fn/class/OptionRegistry.js

@@ -0,0 +1,16 @@
+/**
+ * @prettier
+ */
+import Registry from "./Registry"
+
+class OptionRegistry extends Registry {
+  #defaults = {}
+
+  data = { ...this.#defaults }
+
+  get defaults() {
+    return { ...this.#defaults }
+  }
+}
+
+export default OptionRegistry

package/src/core/plugins/json-schema-2020-12-samples/fn/class/Registry.js

@@ -0,0 +1,24 @@
+/**
+ * @prettier
+ */
+class Registry {
+  data = {}
+
+  register(name, value) {
+    this.data[name] = value
+  }
+
+  unregister(name) {
+    if (typeof name === "undefined") {
+      this.data = {}
+    } else {
+      delete this.data[name]
+    }
+  }
+
+  get(name) {
+    return this.data[name]
+  }
+}
+
+export default Registry

package/src/core/plugins/json-schema-2020-12-samples/fn/core/constants.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+export const SCALAR_TYPES = ["number", "integer", "string", "boolean", "null"]
+
+export const ALL_TYPES = ["array", "object", ...SCALAR_TYPES]

package/src/core/plugins/json-schema-2020-12-samples/fn/core/example.js

@@ -0,0 +1,57 @@
+/**
+ * @prettier
+ */
+import { isJSONSchemaObject } from "./predicates"
+
+/**
+ * Precedence of keywords that provides author defined values (top of the list = higher priority)
+ *
+ *  ### examples
+ *  Array containing example values for the item defined by the schema.
+ *  Not guaranteed to be valid or invalid against the schema
+ *
+ *  ### default
+ *  Default value for an item defined by the schema.
+ *  Is expected to be a valid instance of the schema.
+ *
+ *  ### example
+ *  Deprecated. Part of OpenAPI 3.1.0 Schema Object dialect.
+ *  Represents single example. Equivalent of `examples` keywords
+ *  with single item.
+ */
+
+export const hasExample = (schema) => {
+  if (!isJSONSchemaObject(schema)) return false
+
+  const { examples, example, default: defaultVal } = schema
+
+  if (Array.isArray(examples) && examples.length >= 1) {
+    return true
+  }
+
+  if (typeof defaultVal !== "undefined") {
+    return true
+  }
+
+  return typeof example !== "undefined"
+}
+
+export const extractExample = (schema) => {
+  if (!isJSONSchemaObject(schema)) return null
+
+  const { examples, example, default: defaultVal } = schema
+
+  if (Array.isArray(examples) && examples.length >= 1) {
+    return examples.at(0)
+  }
+
+  if (typeof defaultVal !== "undefined") {
+    return defaultVal
+  }
+
+  if (typeof example !== "undefined") {
+    return example
+  }
+
+  return undefined
+}

package/src/core/plugins/json-schema-2020-12-samples/fn/core/merge.js

@@ -0,0 +1,83 @@
+/**
+ * @prettier
+ */
+import { normalizeArray as ensureArray } from "core/utils"
+import { isBooleanJSONSchema, isJSONSchema } from "./predicates"
+
+const merge = (target, source, config = {}) => {
+  if (isBooleanJSONSchema(target) && target === true) return true
+  if (isBooleanJSONSchema(target) && target === false) return false
+  if (isBooleanJSONSchema(source) && source === true) return true
+  if (isBooleanJSONSchema(source) && source === false) return false
+
+  if (!isJSONSchema(target)) return source
+  if (!isJSONSchema(source)) return target
+
+  /**
+   * Merging properties from the source object into the target object
+   * only if they do not already exist in the target object.
+   */
+  const merged = { ...source, ...target }
+
+  // merging the type keyword
+  if (source.type && target.type) {
+    if (Array.isArray(source.type) && typeof source.type === "string") {
+      const mergedType = ensureArray(source.type).concat(target.type)
+      merged.type = Array.from(new Set(mergedType))
+    }
+  }
+
+  // merging required keyword
+  if (Array.isArray(source.required) && Array.isArray(target.required)) {
+    merged.required = [...new Set([...target.required, ...source.required])]
+  }
+
+  // merging properties keyword
+  if (source.properties && target.properties) {
+    const allPropertyNames = new Set([
+      ...Object.keys(source.properties),
+      ...Object.keys(target.properties),
+    ])
+
+    merged.properties = {}
+    for (const name of allPropertyNames) {
+      const sourceProperty = source.properties[name] || {}
+      const targetProperty = target.properties[name] || {}
+
+      if (
+        (sourceProperty.readOnly && !config.includeReadOnly) ||
+        (sourceProperty.writeOnly && !config.includeWriteOnly)
+      ) {
+        merged.required = (merged.required || []).filter((p) => p !== name)
+      } else {
+        merged.properties[name] = merge(targetProperty, sourceProperty, config)
+      }
+    }
+  }
+
+  // merging items keyword
+  if (isJSONSchema(source.items) && isJSONSchema(target.items)) {
+    merged.items = merge(target.items, source.items, config)
+  }
+
+  // merging contains keyword
+  if (isJSONSchema(source.contains) && isJSONSchema(target.contains)) {
+    merged.contains = merge(target.contains, source.contains, config)
+  }
+
+  // merging contentSchema keyword
+  if (
+    isJSONSchema(source.contentSchema) &&
+    isJSONSchema(target.contentSchema)
+  ) {
+    merged.contentSchema = merge(
+      target.contentSchema,
+      source.contentSchema,
+      config
+    )
+  }
+
+  return merged
+}
+
+export default merge

package/src/core/plugins/json-schema-2020-12-samples/fn/core/predicates.js

@@ -0,0 +1,16 @@
+/**
+ * @prettier
+ */
+import isPlainObject from "lodash/isPlainObject"
+
+export const isBooleanJSONSchema = (schema) => {
+  return typeof schema === "boolean"
+}
+
+export const isJSONSchemaObject = (schema) => {
+  return isPlainObject(schema)
+}
+
+export const isJSONSchema = (schema) => {
+  return isBooleanJSONSchema(schema) || isJSONSchemaObject(schema)
+}

package/src/core/plugins/json-schema-2020-12-samples/fn/core/random.js

@@ -0,0 +1,46 @@
+/**
+ * @prettier
+ */
+import randomBytes from "randombytes"
+import RandExp from "randexp"
+
+/**
+ * Some of the functions returns constants. This is due to the nature
+ * of SwaggerUI expectations - provide as stable data as possible.
+ *
+ * In future, we may decide to randomize these function and provide
+ * true random values.
+ */
+
+export const bytes = (length) => randomBytes(length)
+
+export const randexp = (pattern) => {
+  try {
+    /**
+     * Applying maximum value (100) to numbers from regex patterns to avoid ReDoS:
+     * 1. {x}
+     * 2. {x,}
+     * 3. {,y}
+     * 4. {x,y}
+     */
+    const patternSanitizer =
+      /(?<=(?<!\\)\{)(\d{3,})(?=\})|(?<=(?<!\\)\{\d*,)(\d{3,})(?=\})|(?<=(?<!\\)\{)(\d{3,})(?=,\d*\})/g
+    const safePattern = pattern.replace(patternSanitizer, "100")
+    const randexpInstance = new RandExp(safePattern)
+    randexpInstance.max = 100
+    return randexpInstance.gen()
+  } catch {
+    // invalid regex should not cause a crash (regex syntax varies across languages)
+    return "string"
+  }
+}
+
+export const pick = (list) => {
+  return list.at(0)
+}
+
+export const string = () => "string"
+
+export const number = () => 0
+
+export const integer = () => 0

package/src/core/plugins/json-schema-2020-12-samples/fn/core/type.js

@@ -0,0 +1,156 @@
+/**
+ * @prettier
+ */
+import { ALL_TYPES } from "./constants"
+import { isJSONSchemaObject } from "./predicates"
+import { pick as randomPick } from "./random"
+import { hasExample, extractExample } from "./example"
+
+const inferringKeywords = {
+  array: [
+    "items",
+    "prefixItems",
+    "contains",
+    "maxContains",
+    "minContains",
+    "maxItems",
+    "minItems",
+    "uniqueItems",
+    "unevaluatedItems",
+  ],
+  object: [
+    "properties",
+    "additionalProperties",
+    "patternProperties",
+    "propertyNames",
+    "minProperties",
+    "maxProperties",
+    "required",
+    "dependentSchemas",
+    "dependentRequired",
+    "unevaluatedProperties",
+  ],
+  string: [
+    "pattern",
+    "format",
+    "minLength",
+    "maxLength",
+    "contentEncoding",
+    "contentMediaType",
+    "contentSchema",
+  ],
+  integer: [
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+  ],
+}
+inferringKeywords.number = inferringKeywords.integer
+
+const fallbackType = "string"
+
+const inferTypeFromValue = (value) => {
+  if (typeof value === "undefined") return null
+  if (value === null) return "null"
+  if (Array.isArray(value)) return "array"
+  if (Number.isInteger(value)) return "integer"
+
+  return typeof value
+}
+
+export const foldType = (type) => {
+  if (Array.isArray(type) && type.length >= 1) {
+    if (type.includes("array")) {
+      return "array"
+    } else if (type.includes("object")) {
+      return "object"
+    } else {
+      const notNullTypes = type.filter((t) => t !== "null")
+      const pickedType = randomPick(
+        notNullTypes.length > 0 ? notNullTypes : type
+      )
+      if (ALL_TYPES.includes(pickedType)) {
+        return pickedType
+      }
+    }
+  }
+
+  if (ALL_TYPES.includes(type)) {
+    return type
+  }
+
+  return null
+}
+
+export const inferType = (schema, processedSchemas = new WeakSet()) => {
+  if (!isJSONSchemaObject(schema)) return fallbackType
+  if (processedSchemas.has(schema)) return fallbackType
+
+  processedSchemas.add(schema)
+
+  let { type, const: constant } = schema
+  type = foldType(type)
+
+  // inferring type from inferring keywords
+  if (typeof type !== "string") {
+    const inferringTypes = Object.keys(inferringKeywords)
+
+    interrupt: for (let i = 0; i < inferringTypes.length; i += 1) {
+      const inferringType = inferringTypes[i]
+      const inferringTypeKeywords = inferringKeywords[inferringType]
+
+      for (let j = 0; j < inferringTypeKeywords.length; j += 1) {
+        const inferringKeyword = inferringTypeKeywords[j]
+        if (Object.hasOwn(schema, inferringKeyword)) {
+          type = inferringType
+          break interrupt
+        }
+      }
+    }
+  }
+
+  // inferring type from const keyword
+  if (typeof type !== "string" && typeof constant !== "undefined") {
+    const constType = inferTypeFromValue(constant)
+    type = typeof constType === "string" ? constType : type
+  }
+
+  // inferring type from combining schemas
+  if (typeof type !== "string") {
+    const combineTypes = (keyword) => {
+      if (Array.isArray(schema[keyword])) {
+        const combinedTypes = schema[keyword].map((subSchema) =>
+          inferType(subSchema, processedSchemas)
+        )
+        return foldType(combinedTypes)
+      }
+      return null
+    }
+
+    const allOf = combineTypes("allOf")
+    const anyOf = combineTypes("anyOf")
+    const oneOf = combineTypes("oneOf")
+    const not = schema.not ? inferType(schema.not, processedSchemas) : null
+
+    if (allOf || anyOf || oneOf || not) {
+      type = foldType([allOf, anyOf, oneOf, not].filter(Boolean))
+    }
+  }
+
+  // inferring type from example
+  if (typeof type !== "string" && hasExample(schema)) {
+    const example = extractExample(schema)
+    const exampleType = inferTypeFromValue(example)
+    type = typeof exampleType === "string" ? exampleType : type
+  }
+
+  processedSchemas.delete(schema)
+
+  return type || fallbackType
+}
+
+export const getType = (schema) => {
+  return inferType(schema)
+}

package/src/core/plugins/json-schema-2020-12-samples/fn/core/utils.js

@@ -0,0 +1,23 @@
+/**
+ * @prettier
+ */
+import { isBooleanJSONSchema, isJSONSchemaObject } from "./predicates"
+
+export const fromJSONBooleanSchema = (schema) => {
+  if (schema === false) {
+    return { not: {} }
+  }
+
+  return {}
+}
+
+export const typeCast = (schema) => {
+  if (isBooleanJSONSchema(schema)) {
+    return fromJSONBooleanSchema(schema)
+  }
+  if (!isJSONSchemaObject(schema)) {
+    return {}
+  }
+
+  return schema
+}

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/7bit.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+const encode7bit = (content) => Buffer.from(content).toString("ascii")
+
+export default encode7bit

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/8bit.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+const encode8bit = (content) => Buffer.from(content).toString("utf8")
+
+export default encode8bit

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/base16.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+const encodeBase16 = (content) => Buffer.from(content).toString("hex")
+
+export default encodeBase16

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/base32.js

@@ -0,0 +1,34 @@
+/**
+ * @prettier
+ */
+const encodeBase32 = (content) => {
+  const utf8Value = Buffer.from(content).toString("utf8")
+  const base32Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+  let paddingCount = 0
+  let base32Str = ""
+  let buffer = 0
+  let bufferLength = 0
+
+  for (let i = 0; i < utf8Value.length; i++) {
+    buffer = (buffer << 8) | utf8Value.charCodeAt(i)
+    bufferLength += 8
+
+    while (bufferLength >= 5) {
+      base32Str += base32Alphabet.charAt((buffer >>> (bufferLength - 5)) & 31)
+      bufferLength -= 5
+    }
+  }
+
+  if (bufferLength > 0) {
+    base32Str += base32Alphabet.charAt((buffer << (5 - bufferLength)) & 31)
+    paddingCount = (8 - ((utf8Value.length * 8) % 5)) % 5
+  }
+
+  for (let i = 0; i < paddingCount; i++) {
+    base32Str += "="
+  }
+
+  return base32Str
+}
+
+export default encodeBase32

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/base64.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+const encodeBase64 = (content) => Buffer.from(content).toString("base64")
+
+export default encodeBase64

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/base64url.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+const encodeBase64Url = (content) => Buffer.from(content).toString("base64url")
+
+export default encodeBase64Url

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/binary.js

@@ -0,0 +1,6 @@
+/**
+ * @prettier
+ */
+const encodeBinary = (content) => Buffer.from(content).toString("binary")
+
+export default encodeBinary

package/src/core/plugins/json-schema-2020-12-samples/fn/encoders/quoted-printable.js

@@ -0,0 +1,38 @@
+/**
+ * @prettier
+ */
+const encodeQuotedPrintable = (content) => {
+  let quotedPrintable = ""
+
+  for (let i = 0; i < content.length; i++) {
+    const charCode = content.charCodeAt(i)
+
+    if (charCode === 61) {
+      // ASCII content of "="
+      quotedPrintable += "=3D"
+    } else if (
+      (charCode >= 33 && charCode <= 60) ||
+      (charCode >= 62 && charCode <= 126) ||
+      charCode === 9 ||
+      charCode === 32
+    ) {
+      quotedPrintable += content.charAt(i)
+    } else if (charCode === 13 || charCode === 10) {
+      quotedPrintable += "\r\n"
+    } else if (charCode > 126) {
+      // convert non-ASCII characters to UTF-8 and encode each byte
+      const utf8 = unescape(encodeURIComponent(content.charAt(i)))
+      for (let j = 0; j < utf8.length; j++) {
+        quotedPrintable +=
+          "=" + ("0" + utf8.charCodeAt(j).toString(16)).slice(-2).toUpperCase()
+      }
+    } else {
+      quotedPrintable +=
+        "=" + ("0" + charCode.toString(16)).slice(-2).toUpperCase()
+    }
+  }
+
+  return quotedPrintable
+}
+
+export default encodeQuotedPrintable