@upendra19/swagger-ui-custom 1.0.0 → 1.0.1

package/src/core/plugins/oas3/spec-extensions/selectors.js

@@ -1,100 +0,0 @@
-/**
- * @prettier
- */
-import { List, Map } from "immutable"
-
-import {
-  isSwagger2 as isSwagger2Helper,
-  isOAS30 as isOAS30Helper,
-} from "../helpers"
-
-/**
- * Helpers
- */
-
-const map = Map()
-
-export const isSwagger2 = () => (system) => {
-  const spec = system.getSystem().specSelectors.specJson()
-  return isSwagger2Helper(spec)
-}
-
-export const isOAS30 = () => (system) => {
-  const spec = system.getSystem().specSelectors.specJson()
-  return isOAS30Helper(spec)
-}
-
-export const isOAS3 = () => (system) => {
-  return system.getSystem().specSelectors.isOAS30()
-}
-
-function onlyOAS3(selector) {
-  return (state, ...args) =>
-    (system) => {
-      if (system.specSelectors.isOAS3()) {
-        const selectedValue = selector(state, ...args)
-        return typeof selectedValue === "function"
-          ? selectedValue(system)
-          : selectedValue
-      } else {
-        return null
-      }
-    }
-}
-
-export const servers = onlyOAS3(() => (system) => {
-  const spec = system.specSelectors.specJson()
-  return spec.get("servers", map)
-})
-
-export const findSchema = (state, schemaName) => {
-  const resolvedSchema = state.getIn(
-    ["resolvedSubtrees", "components", "schemas", schemaName],
-    null
-  )
-  const unresolvedSchema = state.getIn(
-    ["json", "components", "schemas", schemaName],
-    null
-  )
-
-  return resolvedSchema || unresolvedSchema || null
-}
-
-export const callbacksOperations = onlyOAS3(
-  (state, { callbacks, specPath }) =>
-    (system) => {
-      const validOperationMethods = system.specSelectors.validOperationMethods()
-
-      if (!Map.isMap(callbacks)) return {}
-
-      return callbacks
-        .reduce((allOperations, callback, callbackName) => {
-          if (!Map.isMap(callback)) return allOperations
-
-          const callbackOperations = callback.reduce(
-            (callbackOps, pathItem, expression) => {
-              if (!Map.isMap(pathItem)) return callbackOps
-
-              const pathItemOperations = pathItem
-                .entrySeq()
-                .filter(([key]) => validOperationMethods.includes(key))
-                .map(([method, operation]) => ({
-                  operation: Map({ operation }),
-                  method,
-                  path: expression,
-                  callbackName,
-                  specPath: specPath.concat([callbackName, expression, method]),
-                }))
-
-              return callbackOps.concat(pathItemOperations)
-            },
-            List()
-          )
-
-          return allOperations.concat(callbackOperations)
-        }, List())
-        .groupBy((operationDTO) => operationDTO.callbackName)
-        .map((operations) => operations.toArray())
-        .toObject()
-    }
-)

package/src/core/plugins/oas3/spec-extensions/wrap-selectors.js

@@ -1,71 +0,0 @@
-/**
- * @prettier
- */
-import { createSelector } from "reselect"
-import constant from "lodash/constant"
-import { specJsonWithResolvedSubtrees } from "../../spec/selectors"
-import { Map } from "immutable"
-
-/**
- * Helpers
- */
-
-const map = Map()
-
-function onlyOAS3(selector) {
-  return (ori, system) =>
-    (...args) => {
-      if (system.getSystem().specSelectors.isOAS3()) {
-        const result = selector(...args)
-        return typeof result === "function" ? result(system) : result
-      } else {
-        return ori(...args)
-      }
-    }
-}
-
-const nullSelector = constant(null)
-
-const OAS3NullSelector = onlyOAS3(nullSelector)
-
-/**
- * Wrappers
- */
-
-export const findDefinition = onlyOAS3((state, schemaName) => (system) => {
-  return system.getSystem().specSelectors.findSchema(schemaName)
-})
-
-export const definitions = onlyOAS3(() => (system) => {
-  const spec = system.getSystem().specSelectors.specJson()
-  const schemas = spec.getIn(["components", "schemas"])
-  return Map.isMap(schemas) ? schemas : map
-})
-
-export const hasHost = onlyOAS3(() => (system) => {
-  const spec = system.getSystem().specSelectors.specJson()
-  return spec.hasIn(["servers", 0])
-})
-
-export const securityDefinitions = onlyOAS3(
-  createSelector(
-    specJsonWithResolvedSubtrees,
-    (spec) => spec.getIn(["components", "securitySchemes"]) || null
-  )
-)
-
-export const validOperationMethods =
-  (oriSelector, system) =>
-  (state, ...args) => {
-    if (system.specSelectors.isOAS3()) {
-      return system.oas3Selectors.validOperationMethods()
-    }
-
-    return oriSelector(...args)
-  }
-
-export const host = OAS3NullSelector
-export const basePath = OAS3NullSelector
-export const consumes = OAS3NullSelector
-export const produces = OAS3NullSelector
-export const schemes = OAS3NullSelector

package/src/core/plugins/oas3/wrap-components/auth/auth-item.jsx

@@ -1,25 +0,0 @@
-import React from "react"
-import { OAS3ComponentWrapFactory } from "../../helpers"
-
-export default OAS3ComponentWrapFactory(({ Ori, ...props }) => {
-  const {
-    schema, getComponent, errSelectors, authorized, onAuthChange, name, authSelectors
-  } = props
-
-  const HttpAuth = getComponent("HttpAuth")
-  const type = schema.get("type")
-
-
-  if(type === "http") {
-    return <HttpAuth key={ name }
-              schema={ schema }
-              name={ name }
-              errSelectors={ errSelectors }
-              authorized={ authorized }
-              getComponent={ getComponent }
-              onChange={ onAuthChange }
-              authSelectors= { authSelectors }/>
-  } else {
-    return <Ori {...props} />
-  }
-})

package/src/core/plugins/oas3/wrap-components/index.js

@@ -1,15 +0,0 @@
-import Markdown from "./markdown"
-import AuthItem from "./auth/auth-item"
-import OnlineValidatorBadge from "./online-validator-badge"
-import Model from "./model"
-import JsonSchema_string from "./json-schema-string"
-import OpenAPIVersion from "./openapi-version"
-
-export default {
-  Markdown,
-  AuthItem,
-  OpenAPIVersion,
-  JsonSchema_string,
-  model: Model,
-  onlineValidatorBadge: OnlineValidatorBadge,
-}

package/src/core/plugins/oas3/wrap-components/json-schema-string.jsx

@@ -1,27 +0,0 @@
-import React from "react"
-import { OAS3ComponentWrapFactory } from "../helpers"
-
-export default OAS3ComponentWrapFactory(({ Ori, ...props }) => {
-  const {
-    schema,
-    getComponent,
-    errors,
-    onChange,
-    fn
-  } = props
-
-  const isFileUploadIntended = fn.isFileUploadIntended(schema)
-  const Input = getComponent("Input")
-
-  if (isFileUploadIntended) {
-    return <Input type="file"
-                   className={ errors.length ? "invalid" : ""}
-                   title={ errors.length ? errors : ""}
-                   onChange={(e) => {
-                     onChange(e.target.files[0])
-                   }}
-                   disabled={Ori.isDisabled}/>
-  } else {
-    return <Ori {...props} />
-  }
-})

package/src/core/plugins/oas3/wrap-components/markdown.jsx

@@ -1,45 +0,0 @@
-import React from "react"
-import PropTypes from "prop-types"
-import cx from "classnames"
-import { Remarkable } from "remarkable"
-import { OAS3ComponentWrapFactory } from "../helpers"
-import { sanitizer } from "core/components/providers/markdown"
-
-const parser = new Remarkable("commonmark")
-parser.block.ruler.enable(["table"])
-parser.set({ linkTarget: "_blank" })
-
-export const Markdown = ({ source, className = "", getConfigs = () => ({ useUnsafeMarkdown: false }) }) => {
-  if(typeof source !== "string") {
-    return null
-  }
-
-  if ( source ) {
-    const { useUnsafeMarkdown } = getConfigs()
-    const html = parser.render(source)
-    const sanitized = sanitizer(html, { useUnsafeMarkdown })
-
-    let trimmed
-
-    if(typeof sanitized === "string") {
-      trimmed = sanitized.trim()
-    }
-
-    return (
-      <div
-        dangerouslySetInnerHTML={{
-          __html: trimmed
-        }}
-        className={cx(className, "renderedMarkdown")}
-      />
-    )
-  }
-  return null
-}
-Markdown.propTypes = {
-  source: PropTypes.string,
-  className: PropTypes.string,
-  getConfigs: PropTypes.func,
-}
-
-export default OAS3ComponentWrapFactory(Markdown)

package/src/core/plugins/oas3/wrap-components/model.jsx

@@ -1,40 +0,0 @@
-import React, { Component } from "react"
-import PropTypes from "prop-types"
-import { OAS3ComponentWrapFactory } from "../helpers"
-
-class ModelComponent extends Component {
-  static propTypes = {
-    schema: PropTypes.object.isRequired,
-    name: PropTypes.string,
-    getComponent: PropTypes.func.isRequired,
-    getConfigs: PropTypes.func.isRequired,
-    specSelectors: PropTypes.object.isRequired,
-    expandDepth: PropTypes.number,
-    includeReadOnly: PropTypes.bool,
-    includeWriteOnly: PropTypes.bool,
-    Ori: PropTypes.func.isRequired,
-  }
-
-  render(){
-    let { getConfigs, schema, Ori: Model } = this.props
-    let classes = ["model-box"]
-    let isDeprecated = schema.get("deprecated") === true
-    let message = null
-
-    if(isDeprecated) {
-      classes.push("deprecated")
-      message = <span className="model-deprecated-warning">Deprecated:</span>
-    }
-
-    return <div className={classes.join(" ")}>
-      {message}
-      <Model { ...this.props }
-        getConfigs={ getConfigs }
-        depth={ 1 }
-        expandDepth={ this.props.expandDepth || 0 }
-        />
-    </div>
-  }
-}
-
-export default OAS3ComponentWrapFactory(ModelComponent)

package/src/core/plugins/oas3/wrap-components/online-validator-badge.js

@@ -1,5 +0,0 @@
-import { OAS3ComponentWrapFactory } from "../helpers"
-import OnlineValidatorBadge from "core/components/online-validator-badge"
-
-// OAS3 spec is now supported by the online validator.
-export default OAS3ComponentWrapFactory(OnlineValidatorBadge)

package/src/core/plugins/oas3/wrap-components/openapi-version.jsx

@@ -1,7 +0,0 @@
-import React from "react"
-import { OAS30ComponentWrapFactory } from "../helpers"
-
-export default OAS30ComponentWrapFactory((props) => {
-  const { Ori } = props
-  return <Ori oasVersion="3.0" />
-})

package/src/core/plugins/oas31/after-load.js

@@ -1,72 +0,0 @@
-/**
- * @prettier
- */
-import {
-  makeIsExpandable,
-  getProperties,
-} from "./json-schema-2020-12-extensions/fn"
-import { wrapOAS31Fn } from "./fn"
-import { makeIsFileUploadIntended } from "./oas3-extensions/fn"
-import { immutableToJS } from "core/utils"
-
-function afterLoad({ fn, getSystem }) {
-  // overrides for fn.jsonSchema202012
-  if (fn.jsonSchema202012) {
-    const isExpandable = makeIsExpandable(
-      fn.jsonSchema202012.isExpandable,
-      getSystem
-    )
-
-    Object.assign(this.fn.jsonSchema202012, { isExpandable, getProperties })
-  }
-
-  // wraps schema generators from samples plugin and make them specific to OpenAPI 3.1 version
-  if (typeof fn.sampleFromSchema === "function" && fn.jsonSchema202012) {
-    const wrappedFns = wrapOAS31Fn(
-      {
-        sampleFromSchema: fn.jsonSchema202012.sampleFromSchema,
-        sampleFromSchemaGeneric: fn.jsonSchema202012.sampleFromSchemaGeneric,
-        createXMLExample: fn.jsonSchema202012.createXMLExample,
-        memoizedSampleFromSchema: fn.jsonSchema202012.memoizedSampleFromSchema,
-        memoizedCreateXMLExample: fn.jsonSchema202012.memoizedCreateXMLExample,
-        getJsonSampleSchema: fn.jsonSchema202012.getJsonSampleSchema,
-        getYamlSampleSchema: fn.jsonSchema202012.getYamlSampleSchema,
-        getXmlSampleSchema: fn.jsonSchema202012.getXmlSampleSchema,
-        getSampleSchema: fn.jsonSchema202012.getSampleSchema,
-        mergeJsonSchema: fn.jsonSchema202012.mergeJsonSchema,
-        getSchemaObjectTypeLabel: (schema) =>
-          fn.jsonSchema202012.getType(immutableToJS(schema)),
-        getSchemaObjectType: (schema) =>
-          fn.jsonSchema202012.foldType(immutableToJS(schema)?.type),
-      },
-      getSystem()
-    )
-
-    Object.assign(this.fn, wrappedFns)
-  }
-
-  // overrides behavior in OpenAPI 3.1.x, recognizes more intentions
-  const isFileUploadIntended = makeIsFileUploadIntended(getSystem)
-  const { isFileUploadIntended: isFileUploadIntendedWrap } = wrapOAS31Fn(
-    {
-      isFileUploadIntended,
-    },
-    getSystem()
-  )
-
-  this.fn.isFileUploadIntended = isFileUploadIntendedWrap
-  this.fn.isFileUploadIntendedOAS31 = isFileUploadIntended
-
-  if (fn.jsonSchema202012) {
-    const { hasSchemaType } = wrapOAS31Fn(
-      {
-        hasSchemaType: fn.jsonSchema202012.hasSchemaType,
-      },
-      getSystem()
-    )
-
-    this.fn.hasSchemaType = hasSchemaType
-  }
-}
-
-export default afterLoad

package/src/core/plugins/oas31/auth-extensions/wrap-selectors.js

@@ -1,28 +0,0 @@
-/**
- * @prettier
- */
-import { Map } from "immutable"
-import { createOnlyOAS31SelectorWrapper } from "../fn"
-
-export const definitionsToAuthorize = createOnlyOAS31SelectorWrapper(
-  () => (oriSelector, system) => {
-    const definitions = system.specSelectors.securityDefinitions()
-    let list = oriSelector()
-
-    if (!definitions) return list
-
-    definitions.entrySeq().forEach(([defName, definition]) => {
-      const type = definition?.get("type")
-
-      if (type === "mutualTLS") {
-        list = list.push(
-          new Map({
-            [defName]: definition,
-          })
-        )
-      }
-    })
-
-    return list
-  }
-)

package/src/core/plugins/oas31/components/_all.scss

@@ -1,2 +0,0 @@
-@use "./model/model";
-@use "./models/models";

package/src/core/plugins/oas31/components/auth/auths.jsx

@@ -1,186 +0,0 @@
-/**
- * @prettier
- */
-import React from "react"
-import PropTypes from "prop-types"
-import ImPropTypes from "react-immutable-proptypes"
-
-class Auths extends React.Component {
-  static propTypes = {
-    definitions: ImPropTypes.iterable.isRequired,
-    getComponent: PropTypes.func.isRequired,
-    authSelectors: PropTypes.object.isRequired,
-    authActions: PropTypes.object.isRequired,
-    errSelectors: PropTypes.object.isRequired,
-    specSelectors: PropTypes.object.isRequired,
-  }
-
-  constructor(props, context) {
-    super(props, context)
-
-    this.state = {}
-  }
-
-  onAuthChange = (auth) => {
-    let { name } = auth
-
-    this.setState({ [name]: auth })
-  }
-
-  submitAuth = (e) => {
-    e.preventDefault()
-
-    let { authActions } = this.props
-    authActions.authorizeWithPersistOption(this.state)
-  }
-
-  logoutClick = (e) => {
-    e.preventDefault()
-
-    let { authActions, definitions } = this.props
-    let auths = definitions
-      .map((val, key) => {
-        return key
-      })
-      .toArray()
-
-    this.setState(
-      auths.reduce((prev, auth) => {
-        prev[auth] = ""
-        return prev
-      }, {})
-    )
-
-    authActions.logoutWithPersistOption(auths)
-  }
-
-  close = (e) => {
-    e.preventDefault()
-    let { authActions } = this.props
-
-    authActions.showDefinitions(false)
-  }
-
-  render() {
-    let { definitions, getComponent, authSelectors, errSelectors } = this.props
-    const AuthItem = getComponent("AuthItem")
-    const Oauth2 = getComponent("oauth2", true)
-    const Button = getComponent("Button")
-
-    const authorized = authSelectors.authorized()
-    const authorizedAuth = definitions.filter((definition, key) => {
-      return !!authorized.get(key)
-    })
-    const nonOauthDefinitions = definitions.filter(
-      (schema) =>
-        schema.get("type") !== "oauth2" && schema.get("type") !== "mutualTLS"
-    )
-    const oauthDefinitions = definitions.filter(
-      (schema) => schema.get("type") === "oauth2"
-    )
-    const mutualTLSDefinitions = definitions.filter(
-      (schema) => schema.get("type") === "mutualTLS"
-    )
-    return (
-      <div className="auth-container">
-        {nonOauthDefinitions.size > 0 && (
-          <form onSubmit={this.submitAuth}>
-            {nonOauthDefinitions
-              .map((schema, name) => {
-                return (
-                  <AuthItem
-                    key={name}
-                    schema={schema}
-                    name={name}
-                    getComponent={getComponent}
-                    onAuthChange={this.onAuthChange}
-                    authorized={authorized}
-                    errSelectors={errSelectors}
-                    authSelectors={authSelectors}
-                  />
-                )
-              })
-              .toArray()}
-            <div className="auth-btn-wrapper">
-              {nonOauthDefinitions.size === authorizedAuth.size ? (
-                <Button
-                  className="btn modal-btn auth"
-                  onClick={this.logoutClick}
-                  aria-label="Remove authorization"
-                >
-                  Logout
-                </Button>
-              ) : (
-                <Button
-                  type="submit"
-                  className="btn modal-btn auth authorize"
-                  aria-label="Apply credentials"
-                >
-                  Authorize
-                </Button>
-              )}
-              <Button
-                className="btn modal-btn auth btn-done"
-                onClick={this.close}
-              >
-                Close
-              </Button>
-            </div>
-          </form>
-        )}
-
-        {oauthDefinitions.size > 0 ? (
-          <div>
-            <div className="scope-def">
-              <p>
-                Scopes are used to grant an application different levels of
-                access to data on behalf of the end user. Each API may declare
-                one or more scopes.
-              </p>
-              <p>
-                API requires the following scopes. Select which ones you want to
-                grant to Swagger UI.
-              </p>
-            </div>
-            {definitions
-              .filter((schema) => schema.get("type") === "oauth2")
-              .map((schema, name) => {
-                return (
-                  <div key={name}>
-                    <Oauth2
-                      authorized={authorized}
-                      schema={schema}
-                      name={name}
-                    />
-                  </div>
-                )
-              })
-              .toArray()}
-          </div>
-        ) : null}
-        {mutualTLSDefinitions.size > 0 && (
-          <div>
-            {mutualTLSDefinitions
-              .map((schema, name) => {
-                return (
-                  <AuthItem
-                    key={name}
-                    schema={schema}
-                    name={name}
-                    getComponent={getComponent}
-                    onAuthChange={this.onAuthChange}
-                    authorized={authorized}
-                    errSelectors={errSelectors}
-                    authSelectors={authSelectors}
-                  />
-                )
-              })
-              .toArray()}
-          </div>
-        )}
-      </div>
-    )
-  }
-}
-
-export default Auths

package/src/core/plugins/oas31/components/auth/mutual-tls-auth.jsx

@@ -1,32 +0,0 @@
-/**
- * @prettier
- */
-import React from "react"
-import PropTypes from "prop-types"
-
-const MutualTLSAuth = ({ schema, getComponent, name, authSelectors }) => {
-  const JumpToPath = getComponent("JumpToPath", true)
-  const path = authSelectors.selectAuthPath(name)
-
-  return (
-    <div>
-      <h4>
-        {name} (mutualTLS) <JumpToPath path={path} />
-      </h4>
-      <p>
-        Mutual TLS is required by this API/Operation. Certificates are managed
-        via your Operating System and/or your browser.
-      </p>
-      <p>{schema.get("description")}</p>
-    </div>
-  )
-}
-
-MutualTLSAuth.propTypes = {
-  schema: PropTypes.object.isRequired,
-  getComponent: PropTypes.func.isRequired,
-  name: PropTypes.string.isRequired,
-  authSelectors: PropTypes.object.isRequired,
-}
-
-export default MutualTLSAuth