@upendra19/swagger-ui-custom 1.0.0

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

@@ -0,0 +1,65 @@
+/**
+ * @prettier
+ */
+import { number as randomNumber } from "../core/random"
+import formatAPI from "../api/formatAPI"
+
+const generateFormat = (schema) => {
+  const { format } = schema
+
+  const formatGenerator = formatAPI(format)
+  if (typeof formatGenerator === "function") {
+    return formatGenerator(schema)
+  }
+
+  return randomNumber()
+}
+
+export const applyNumberConstraints = (number, constraints = {}) => {
+  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum } = constraints
+  const { multipleOf } = constraints
+  const epsilon = Number.isInteger(number) ? 1 : Number.EPSILON
+  let minValue = typeof minimum === "number" ? minimum : null
+  let maxValue = typeof maximum === "number" ? maximum : null
+  let constrainedNumber = number
+
+  if (typeof exclusiveMinimum === "number") {
+    minValue =
+      minValue !== null
+        ? Math.max(minValue, exclusiveMinimum + epsilon)
+        : exclusiveMinimum + epsilon
+  }
+  if (typeof exclusiveMaximum === "number") {
+    maxValue =
+      maxValue !== null
+        ? Math.min(maxValue, exclusiveMaximum - epsilon)
+        : exclusiveMaximum - epsilon
+  }
+  constrainedNumber =
+    (minValue > maxValue && number) || minValue || maxValue || constrainedNumber
+
+  if (typeof multipleOf === "number" && multipleOf > 0) {
+    const remainder = constrainedNumber % multipleOf
+    constrainedNumber =
+      remainder === 0
+        ? constrainedNumber
+        : constrainedNumber + multipleOf - remainder
+  }
+
+  return constrainedNumber
+}
+
+const numberType = (schema) => {
+  const { format } = schema
+  let generatedNumber
+
+  if (typeof format === "string") {
+    generatedNumber = generateFormat(schema)
+  } else {
+    generatedNumber = randomNumber()
+  }
+
+  return applyNumberConstraints(generatedNumber, schema)
+}
+
+export default numberType

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

@@ -0,0 +1,9 @@
+/**
+ * @prettier
+ */
+
+const objectType = () => {
+  throw new Error("Not implemented")
+}
+
+export default objectType

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

@@ -0,0 +1,80 @@
+/**
+ * @prettier
+ */
+import identity from "lodash/identity"
+
+import { string as randomString, randexp } from "../core/random"
+import { isJSONSchema } from "../core/predicates"
+import formatAPI from "../api/formatAPI"
+import encoderAPI from "../api/encoderAPI"
+import mediaTypeAPI from "../api/mediaTypeAPI"
+
+const generateFormat = (schema) => {
+  const { format } = schema
+
+  const formatGenerator = formatAPI(format)
+  if (typeof formatGenerator === "function") {
+    return formatGenerator(schema)
+  }
+
+  return randomString()
+}
+
+const generateMediaType = (schema) => {
+  const { contentMediaType } = schema
+
+  const mediaTypeGenerator = mediaTypeAPI(contentMediaType)
+  if (typeof mediaTypeGenerator === "function") {
+    return mediaTypeGenerator(schema)
+  }
+
+  return randomString()
+}
+
+const applyStringConstraints = (string, constraints = {}) => {
+  const { maxLength, minLength } = constraints
+  let constrainedString = string
+
+  if (Number.isInteger(maxLength) && maxLength > 0) {
+    constrainedString = constrainedString.slice(0, maxLength)
+  }
+  if (Number.isInteger(minLength) && minLength > 0) {
+    let i = 0
+    while (constrainedString.length < minLength) {
+      constrainedString += constrainedString[i++ % constrainedString.length]
+    }
+  }
+
+  return constrainedString
+}
+
+const stringType = (schema, { sample } = {}) => {
+  const { contentEncoding, contentMediaType, contentSchema } = schema
+  const { pattern, format } = schema
+  const encode = encoderAPI(contentEncoding) || identity
+  let generatedString
+
+  if (typeof pattern === "string") {
+    generatedString = applyStringConstraints(randexp(pattern), schema)
+  } else if (typeof format === "string") {
+    generatedString = generateFormat(schema)
+  } else if (
+    isJSONSchema(contentSchema) &&
+    typeof contentMediaType === "string" &&
+    typeof sample !== "undefined"
+  ) {
+    if (Array.isArray(sample) || typeof sample === "object") {
+      generatedString = JSON.stringify(sample)
+    } else {
+      generatedString = applyStringConstraints(String(sample), schema)
+    }
+  } else if (typeof contentMediaType === "string") {
+    generatedString = generateMediaType(schema)
+  } else {
+    generatedString = applyStringConstraints(randomString(), schema)
+  }
+
+  return encode(generatedString)
+}
+
+export default stringType

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

@@ -0,0 +1,51 @@
+/**
+ * @prettier
+ */
+import {
+  sampleFromSchema,
+  sampleFromSchemaGeneric,
+  createXMLExample,
+  memoizedSampleFromSchema,
+  memoizedCreateXMLExample,
+  optionAPI,
+  encoderAPI,
+  mediaTypeAPI,
+  formatAPI,
+  mergeJsonSchema,
+  foldType,
+} from "./fn/index"
+import makeGetJsonSampleSchema from "./fn/get-json-sample-schema"
+import makeGetYamlSampleSchema from "./fn/get-yaml-sample-schema"
+import makeGetXmlSampleSchema from "./fn/get-xml-sample-schema"
+import makeGetSampleSchema from "./fn/get-sample-schema"
+
+const JSONSchema202012SamplesPlugin = ({ getSystem }) => {
+  const getJsonSampleSchema = makeGetJsonSampleSchema(getSystem)
+  const getYamlSampleSchema = makeGetYamlSampleSchema(getSystem)
+  const getXmlSampleSchema = makeGetXmlSampleSchema(getSystem)
+  const getSampleSchema = makeGetSampleSchema(getSystem)
+
+  return {
+    fn: {
+      jsonSchema202012: {
+        sampleFromSchema,
+        sampleFromSchemaGeneric,
+        sampleOptionAPI: optionAPI,
+        sampleEncoderAPI: encoderAPI,
+        sampleFormatAPI: formatAPI,
+        sampleMediaTypeAPI: mediaTypeAPI,
+        createXMLExample,
+        memoizedSampleFromSchema,
+        memoizedCreateXMLExample,
+        getJsonSampleSchema,
+        getYamlSampleSchema,
+        getXmlSampleSchema,
+        getSampleSchema,
+        mergeJsonSchema,
+        foldType,
+      },
+    },
+  }
+}
+
+export default JSONSchema202012SamplesPlugin

package/src/core/plugins/json-schema-5/components/array-model.jsx

@@ -0,0 +1,80 @@
+import React, { Component } from "react"
+import PropTypes from "prop-types"
+import ImPropTypes from "react-immutable-proptypes"
+import { sanitizeUrl } from "core/utils/url"
+
+const propClass = "property"
+
+export default class ArrayModel extends Component {
+  static propTypes = {
+    schema: PropTypes.object.isRequired,
+    getComponent: PropTypes.func.isRequired,
+    getConfigs: PropTypes.func.isRequired,
+    specSelectors: PropTypes.object.isRequired,
+    name: PropTypes.string,
+    displayName: PropTypes.string,
+    required: PropTypes.bool,
+    expandDepth: PropTypes.number,
+    specPath: ImPropTypes.list.isRequired,
+    depth: PropTypes.number,
+    includeReadOnly: PropTypes.bool,
+    includeWriteOnly: PropTypes.bool,
+  }
+
+  render(){
+    let { getComponent, getConfigs, schema, depth, expandDepth, name, displayName, specPath } = this.props
+    let description = schema.get("description")
+    let items = schema.get("items")
+    let title = schema.get("title") || displayName || name
+    let properties = schema.filter( ( v, key) => ["type", "items", "description", "$$ref", "externalDocs"].indexOf(key) === -1 )
+    let externalDocsUrl = schema.getIn(["externalDocs", "url"])
+    let externalDocsDescription = schema.getIn(["externalDocs", "description"])
+
+
+    const Markdown = getComponent("Markdown", true)
+    const ModelCollapse = getComponent("ModelCollapse")
+    const Model = getComponent("Model")
+    const Property = getComponent("Property")
+    const Link = getComponent("Link")
+
+    const titleEl = title &&
+      <span className="model-title">
+        <span className="model-title__text">{ title }</span>
+      </span>
+
+    /*
+    Note: we set `name={null}` in <Model> below because we don't want
+    the name of the current Model passed (and displayed) as the name of the array element Model
+    */
+
+    return <span className="model">
+      <ModelCollapse title={titleEl} expanded={ depth <= expandDepth } collapsedContent="[...]">
+        [
+          {
+            properties.size ? properties.entrySeq().map( ( [ key, v ] ) => <Property key={`${key}-${v}`} propKey={ key } propVal={ v } propClass={ propClass } />) : null
+          }
+          {
+            !description ? (properties.size ? <div className="markdown"></div> : null) :
+              <Markdown source={ description } />
+          }
+          { externalDocsUrl &&
+            <div className="external-docs">
+               <Link target="_blank" href={sanitizeUrl(externalDocsUrl)}>{externalDocsDescription || externalDocsUrl}</Link>
+             </div>
+          }
+          <span>
+            <Model
+              { ...this.props }
+              getConfigs={ getConfigs }
+              specPath={specPath.push("items")}
+              name={null}
+              schema={ items }
+              required={ false }
+              depth={ depth + 1 }
+            />
+          </span>
+        ]
+      </ModelCollapse>
+    </span>
+  }
+}

package/src/core/plugins/json-schema-5/components/enum-model.jsx

@@ -0,0 +1,19 @@
+import React from "react"
+import ImPropTypes from "react-immutable-proptypes"
+
+const EnumModel = ({ value, getComponent }) => {
+  let ModelCollapse = getComponent("ModelCollapse")
+  let collapsedContent = <span>Array [ { value.count() } ]</span>
+  return <span className="prop-enum">
+    Enum:<br />
+    <ModelCollapse collapsedContent={ collapsedContent }>
+      [ { value.map(String).join(", ") } ]
+    </ModelCollapse>
+  </span>
+}
+EnumModel.propTypes = {
+  value: ImPropTypes.iterable,
+  getComponent: ImPropTypes.func
+}
+
+export default EnumModel