@upendra19/swagger-ui-custom 1.0.0 → 1.0.3

package/src/core/presets/base/plugins/core-components/index.js

@@ -1,130 +0,0 @@
-/**
- * @prettier
- */
-import App from "core/components/app"
-import AuthorizationPopup from "core/components/auth/authorization-popup"
-import AuthorizeBtn from "core/components/auth/authorize-btn"
-import AuthorizeBtnContainer from "core/containers/authorize-btn"
-import AuthorizeOperationBtn from "core/components/auth/authorize-operation-btn"
-import Auths from "core/components/auth/auths"
-import AuthItem from "core/components/auth/auth-item"
-import AuthError from "core/components/auth/error"
-import ApiKeyAuth from "core/components/auth/api-key-auth"
-import BasicAuth from "core/components/auth/basic-auth"
-import Example from "core/components/example"
-import ExamplesSelect from "core/components/examples-select"
-import ExamplesSelectValueRetainer from "core/components/examples-select-value-retainer"
-import Oauth2 from "core/components/auth/oauth2"
-import Clear from "core/components/clear"
-import LiveResponse from "core/components/live-response"
-import OnlineValidatorBadge from "core/components/online-validator-badge"
-import Operations from "core/components/operations"
-import OperationTag from "core/components/operation-tag"
-import Operation from "core/components/operation"
-import OperationContainer from "core/containers/OperationContainer"
-import OperationSummary from "core/components/operation-summary"
-import OperationSummaryMethod from "core/components/operation-summary-method"
-import OperationSummaryPath from "core/components/operation-summary-path"
-import OperationExt from "core/components/operation-extensions"
-import OperationExtRow from "core/components/operation-extension-row"
-import Responses from "core/components/responses"
-import Response from "core/components/response"
-import ResponseExtension from "core/components/response-extension"
-import ResponseBody from "core/components/response-body"
-import { Parameters } from "core/components/parameters"
-import ParameterExt from "core/components/parameter-extension"
-import ParameterIncludeEmpty from "core/components/parameter-include-empty"
-import ParameterRow from "core/components/parameter-row"
-import Execute from "core/components/execute"
-import Headers from "core/components/headers"
-import Errors from "core/components/errors"
-import ContentType from "core/components/content-type"
-import Overview from "core/components/overview"
-import InitializedInput from "core/components/initialized-input"
-import Info, { InfoUrl, InfoBasePath } from "core/components/info"
-import InfoContainer from "core/containers/info"
-import Contact from "core/components/contact"
-import License from "core/components/license"
-import JumpToPath from "core/components/jump-to-path"
-import CopyToClipboardBtn from "core/components/copy-to-clipboard-btn"
-import Footer from "core/components/footer"
-import FilterContainer from "core/containers/filter"
-import ParamBody from "core/components/param-body"
-import Curl from "core/components/curl"
-import Property from "core/components/property"
-import TryItOutButton from "core/components/try-it-out-button"
-import VersionPragmaFilter from "core/components/version-pragma-filter"
-import VersionStamp from "core/components/version-stamp"
-import OpenAPIVersion from "core/components/openapi-version"
-import DeepLink from "core/components/deep-link"
-import SvgAssets from "core/components/svg-assets"
-import Markdown from "core/components/providers/markdown"
-import BaseLayout from "core/components/layouts/base"
-
-const CoreComponentsPlugin = () => ({
-  components: {
-    App,
-    authorizationPopup: AuthorizationPopup,
-    authorizeBtn: AuthorizeBtn,
-    AuthorizeBtnContainer,
-    authorizeOperationBtn: AuthorizeOperationBtn,
-    auths: Auths,
-    AuthItem: AuthItem,
-    authError: AuthError,
-    oauth2: Oauth2,
-    apiKeyAuth: ApiKeyAuth,
-    basicAuth: BasicAuth,
-    clear: Clear,
-    liveResponse: LiveResponse,
-    InitializedInput,
-    info: Info,
-    InfoContainer,
-    InfoUrl,
-    InfoBasePath,
-    Contact,
-    License,
-    JumpToPath,
-    CopyToClipboardBtn,
-    onlineValidatorBadge: OnlineValidatorBadge,
-    operations: Operations,
-    operation: Operation,
-    OperationSummary,
-    OperationSummaryMethod,
-    OperationSummaryPath,
-    responses: Responses,
-    response: Response,
-    ResponseExtension: ResponseExtension,
-    responseBody: ResponseBody,
-    parameters: Parameters,
-    parameterRow: ParameterRow,
-    execute: Execute,
-    headers: Headers,
-    errors: Errors,
-    contentType: ContentType,
-    overview: Overview,
-    footer: Footer,
-    FilterContainer,
-    ParamBody: ParamBody,
-    curl: Curl,
-    Property,
-    TryItOutButton,
-    Markdown,
-    BaseLayout,
-    VersionPragmaFilter,
-    VersionStamp,
-    OperationExt,
-    OperationExtRow,
-    ParameterExt,
-    ParameterIncludeEmpty,
-    OperationTag,
-    OperationContainer,
-    OpenAPIVersion,
-    DeepLink,
-    SvgAssets,
-    Example,
-    ExamplesSelect,
-    ExamplesSelectValueRetainer,
-  },
-})
-
-export default CoreComponentsPlugin

package/src/core/presets/base/plugins/form-components/index.js

@@ -1,10 +0,0 @@
-/**
- * @prettier
- */
-import * as LayoutUtils from "core/components/layout-utils"
-
-const FormComponentsPlugin = () => ({
-  components: { ...LayoutUtils },
-})
-
-export default FormComponentsPlugin

package/src/core/system.js

@@ -1,511 +0,0 @@
-import React from "react"
-import { createStore, applyMiddleware, bindActionCreators, compose } from "redux"
-import Im, { fromJS, Map } from "immutable"
-import deepExtend from "deep-extend"
-import { combineReducers } from "redux-immutable"
-import { serializeError } from "serialize-error"
-import merge from "lodash/merge"
-import { NEW_THROWN_ERR } from "core/plugins/err/actions"
-import win from "core/window"
-
-import { systemThunkMiddleware, isFn, objMap, objReduce, isObject, isArray, isFunc } from "core/utils"
-
-const idFn = a => a
-
-// Apply middleware that gets sandwitched between `dispatch` and the reducer function(s)
-function createStoreWithMiddleware(rootReducer, initialState, getSystem) {
-
-  let middlwares = [
-    // createLogger( {
-    //   stateTransformer: state => state && state.toJS()
-    // } ),
-    systemThunkMiddleware( getSystem )
-  ]
-
-  const composeEnhancers = win.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose
-
-  return createStore(rootReducer, initialState, composeEnhancers(
-    applyMiddleware( ...middlwares )
-  ))
-}
-
-export default class Store {
-
-  constructor(opts={}) {
-    deepExtend(this, {
-      state: {},
-      plugins: [],
-      system: {
-        configs: {},
-        fn: {},
-        components: {},
-        rootInjects: {},
-        statePlugins: {}
-      },
-      boundSystem: {},
-      toolbox: {}
-    }, opts)
-
-    this.getSystem = this._getSystem.bind(this)
-
-    // Bare system (nothing in it, besides the state)
-    this.store = configureStore(idFn, fromJS(this.state), this.getSystem )
-
-    // will be the system + Im, we can add more tools when we need to
-    this.buildSystem(false)
-
-    // Bootstrap plugins
-    this.register(this.plugins)
-  }
-
-  getStore() {
-    return this.store
-  }
-
-  register(plugins, rebuild=true) {
-    var pluginSystem = combinePlugins(plugins, this.getSystem())
-    systemExtend(this.system, pluginSystem)
-    if(rebuild) {
-      this.buildSystem()
-    }
-
-    const needAnotherRebuild = callAfterLoad.call(this.system, plugins, this.getSystem())
-
-    if(needAnotherRebuild) {
-      this.buildSystem()
-    }
-  }
-
-  buildSystem(buildReducer=true) {
-    let dispatch = this.getStore().dispatch
-    let getState = this.getStore().getState
-
-    this.boundSystem = Object.assign({},
-        this.getRootInjects(),
-        this.getWrappedAndBoundActions(dispatch),
-        this.getWrappedAndBoundSelectors(getState, this.getSystem),
-        this.getStateThunks(getState),
-        this.getFn(),
-        this.getConfigs()
-     )
-
-    if(buildReducer)
-      this.rebuildReducer()
-  }
-
-  _getSystem() {
-    return this.boundSystem
-  }
-
-  getRootInjects() {
-    return Object.assign({
-      getSystem: this.getSystem,
-      getStore: this.getStore.bind(this),
-      getComponents: this.getComponents.bind(this),
-      getState: this.getStore().getState,
-      getConfigs: this._getConfigs.bind(this),
-      Im,
-      React
-    }, this.system.rootInjects || {})
-  }
-
-  _getConfigs(){
-    return this.system.configs
-  }
-
-  getConfigs() {
-    return {
-      configs: this.system.configs
-    }
-  }
-
-  setConfigs(configs) {
-    this.system.configs = configs
-  }
-
-  rebuildReducer() {
-    this.store.replaceReducer(buildReducer(this.system.statePlugins, this.getSystem))
-  }
-
-  /**
-   * Generic getter from system.statePlugins
-   *
-   */
-  getType(name) {
-    let upName = name[0].toUpperCase() + name.slice(1)
-    return objReduce(this.system.statePlugins, (val, namespace) => {
-        let thing = val[name]
-        if(thing)
-        return {[namespace+upName]:  thing}
-      })
-  }
-
-  getSelectors() {
-    return this.getType("selectors")
-  }
-
-  getActions() {
-    let actionHolders = this.getType("actions")
-
-    return objMap(actionHolders, (actions) => {
-      return objReduce(actions, (action, actionName) => {
-        if(isFn(action))
-          return {[actionName]: action}
-      })
-    })
-  }
-
-  getWrappedAndBoundActions(dispatch) {
-    let actionGroups = this.getBoundActions(dispatch)
-      return objMap(actionGroups, (actions, actionGroupName) => {
-        let wrappers = this.system.statePlugins[actionGroupName.slice(0,-7)].wrapActions
-          if(wrappers) {
-            return objMap(actions, (action, actionName) => {
-              let wrap = wrappers[actionName]
-              if(!wrap) {
-                return action
-              }
-
-              if(!Array.isArray(wrap)) {
-                wrap = [wrap]
-              }
-              return wrap.reduce((acc, fn) => {
-                let newAction = (...args) => {
-                  return fn(acc, this.getSystem())(...args)
-                }
-                if(!isFn(newAction)) {
-                  throw new TypeError("wrapActions needs to return a function that returns a new function (ie the wrapped action)")
-                }
-                return wrapWithTryCatch(newAction, this.getSystem)
-              }, action || Function.prototype)
-            })
-          }
-        return actions
-      })
-  }
-
-  getWrappedAndBoundSelectors(getState, getSystem) {
-    let selectorGroups = this.getBoundSelectors(getState, getSystem)
-      return objMap(selectorGroups, (selectors, selectorGroupName) => {
-        let stateName = [selectorGroupName.slice(0, -9)] // selectors = 9 chars
-        let wrappers = this.system.statePlugins[stateName].wrapSelectors
-          if(wrappers) {
-            return objMap(selectors, (selector, selectorName) => {
-              let wrap = wrappers[selectorName]
-              if(!wrap) {
-                return selector
-              }
-
-              if(!Array.isArray(wrap)) {
-                wrap = [wrap]
-              }
-              return wrap.reduce((acc, fn) => {
-                let wrappedSelector = (...args) => {
-                  return fn(acc, this.getSystem())(getState().getIn(stateName), ...args)
-                }
-                if(!isFn(wrappedSelector)) {
-                  throw new TypeError("wrapSelector needs to return a function that returns a new function (ie the wrapped action)")
-                }
-                return wrappedSelector
-              }, selector || Function.prototype)
-            })
-          }
-        return selectors
-      })
-  }
-
-  getStates(state) {
-    return Object.keys(this.system.statePlugins).reduce((obj, key) => {
-      obj[key] = state.get(key)
-      return obj
-    }, {})
-  }
-
-  getStateThunks(getState) {
-    return Object.keys(this.system.statePlugins).reduce((obj, key) => {
-        obj[key] = ()=> getState().get(key)
-    return obj
-  }, {})
-  }
-
-  getFn() {
-    return {
-      fn: this.system.fn
-    }
-  }
-
-  getComponents(component) {
-    const res = this.system.components[component]
-
-    if(Array.isArray(res)) {
-      return res.reduce((ori, wrapper) => {
-        return wrapper(ori, this.getSystem())
-      })
-    }
-    if(typeof component !== "undefined") {
-      return this.system.components[component]
-    }
-
-    return this.system.components
-  }
-
-  getBoundSelectors(getState, getSystem) {
-    return objMap(this.getSelectors(), (obj, key) => {
-      let stateName = [key.slice(0, -9)] // selectors = 9 chars
-      const getNestedState = ()=> getState().getIn(stateName)
-
-      return objMap(obj, (fn) => {
-        return (...args) => {
-          let res = wrapWithTryCatch(fn, this.getSystem).apply(null, [getNestedState(), ...args])
-
-          //  If a selector returns a function, give it the system - for advanced usage
-          if(typeof(res) === "function")
-            res = wrapWithTryCatch(res, this.getSystem)(getSystem())
-
-          return res
-        }
-      })
-    })
-  }
-
-  getBoundActions(dispatch) {
-
-    dispatch = dispatch || this.getStore().dispatch
-
-    const actions = this.getActions()
-
-    const process = creator =>{
-      if( typeof( creator ) !== "function" ) {
-        return objMap(creator, prop => process(prop))
-      }
-
-      return ( ...args )=>{
-        var action = null
-        try{
-          action = creator( ...args )
-        }
-        catch( e ){
-          action = {type: NEW_THROWN_ERR, error: true, payload: serializeError(e) }
-        }
-        finally{
-          return action // eslint-disable-line no-unsafe-finally
-        }
-      }
-
-    }
-    return objMap(actions, actionCreator => bindActionCreators( process( actionCreator ), dispatch ) )
-  }
-
-  getMapStateToProps() {
-    return () => {
-      return Object.assign({}, this.getSystem())
-    }
-  }
-
-  getMapDispatchToProps(extras) {
-    return (dispatch) => {
-      return deepExtend({}, this.getWrappedAndBoundActions(dispatch), this.getFn(), extras)
-    }
-  }
-
-}
-
-function combinePlugins(plugins, toolbox) {
-  if(isObject(plugins) && !isArray(plugins)) {
-    return merge({}, plugins)
-  }
-
-  if(isFunc(plugins)) {
-    return combinePlugins(plugins(toolbox), toolbox)
-  }
-
-  if(isArray(plugins)) {
-    return plugins
-      .map(plugin => combinePlugins(plugin, toolbox))
-      .reduce(systemExtend, { components: toolbox.getComponents() })
-  }
-
-  return {}
-}
-
-function callAfterLoad(plugins, system, { hasLoaded } = {}) {
-  let calledSomething = hasLoaded
-  if(isObject(plugins) && !isArray(plugins)) {
-    if(typeof plugins.afterLoad === "function") {
-      calledSomething = true
-      wrapWithTryCatch(plugins.afterLoad, system.getSystem).call(this, system)
-    }
-  }
-
-  if(isFunc(plugins))
-    return callAfterLoad.call(this, plugins(system), system, { hasLoaded: calledSomething })
-
-  if(isArray(plugins)) {
-    return plugins.map(plugin => callAfterLoad.call(this, plugin, system, { hasLoaded: calledSomething }))
-  }
-
-  return calledSomething
-}
-
-// Wraps deepExtend, to account for certain fields, being wrappers.
-// Ie: we need to convert some fields into arrays, and append to them.
-// Rather than overwrite
-function systemExtend(dest={}, src={}) {
-
-  if(!isObject(dest)) {
-    return {}
-  }
-  if(!isObject(src)) {
-    return dest
-  }
-
-  // Wrap components
-  // Parses existing components in the system, and prepares them for wrapping via getComponents
-  if(src.wrapComponents) {
-    objMap(src.wrapComponents, (wrapperFn, key) => {
-      const ori = dest.components && dest.components[key]
-      if(ori && Array.isArray(ori)) {
-        dest.components[key] = ori.concat([wrapperFn])
-        delete src.wrapComponents[key]
-      } else if(ori) {
-        dest.components[key] = [ori, wrapperFn]
-        delete src.wrapComponents[key]
-      }
-    })
-
-    if(!Object.keys(src.wrapComponents).length) {
-      // only delete wrapComponents if we've matched all of our wrappers to components
-      // this handles cases where the component to wrap may be out of our scope,
-      // but a higher recursive `combinePlugins` call will be able to handle it.
-      delete src.wrapComponents
-    }
-  }
-
-
-  // Account for wrapActions, make it an array and append to it
-  // Modifies `src`
-  // 80% of this code is just safe traversal. We need to address that ( ie: use a lib )
-  const { statePlugins } = dest
-  if(isObject(statePlugins)) {
-    for(let namespace in statePlugins) {
-      const namespaceObj = statePlugins[namespace]
-      if(!isObject(namespaceObj)) {
-        continue
-      }
-
-      const { wrapActions, wrapSelectors } = namespaceObj
-
-      // process action wrapping
-      if (isObject(wrapActions)) {
-        for(let actionName in wrapActions) {
-          let action = wrapActions[actionName]
-
-          // This should only happen if dest is the first plugin, since invocations after that will ensure its an array
-          if(!Array.isArray(action)) {
-            action = [action]
-            wrapActions[actionName] = action // Put the value inside an array
-          }
-
-          if(src && src.statePlugins && src.statePlugins[namespace] && src.statePlugins[namespace].wrapActions && src.statePlugins[namespace].wrapActions[actionName]) {
-            src.statePlugins[namespace].wrapActions[actionName] = wrapActions[actionName].concat(src.statePlugins[namespace].wrapActions[actionName])
-          }
-
-        }
-      }
-
-      // process selector wrapping
-      if (isObject(wrapSelectors)) {
-        for(let selectorName in wrapSelectors) {
-          let selector = wrapSelectors[selectorName]
-
-          // This should only happen if dest is the first plugin, since invocations after that will ensure its an array
-          if(!Array.isArray(selector)) {
-            selector = [selector]
-            wrapSelectors[selectorName] = selector // Put the value inside an array
-          }
-
-          if(src && src.statePlugins && src.statePlugins[namespace] && src.statePlugins[namespace].wrapSelectors && src.statePlugins[namespace].wrapSelectors[selectorName]) {
-            src.statePlugins[namespace].wrapSelectors[selectorName] = wrapSelectors[selectorName].concat(src.statePlugins[namespace].wrapSelectors[selectorName])
-          }
-
-        }
-      }
-    }
-  }
-
-  return deepExtend(dest, src)
-}
-
-function buildReducer(states, getSystem) {
-  let reducerObj = objMap(states, (val) => {
-    return val.reducers
-  })
-  return allReducers(reducerObj, getSystem)
-}
-
-function allReducers(reducerSystem, getSystem) {
-  let reducers = Object.keys(reducerSystem).reduce((obj, key) => {
-    obj[key] = makeReducer(reducerSystem[key], getSystem)
-    return obj
-  },{})
-
-  if(!Object.keys(reducers).length) {
-    return idFn
-  }
-
-  return combineReducers(reducers)
-}
-
-function makeReducer(reducerObj, getSystem) {
-  return (state = new Map(), action) => {
-    if(!reducerObj)
-      return state
-
-    let redFn = (reducerObj[action.type])
-    if(redFn) {
-      const res = wrapWithTryCatch(redFn, getSystem)(state, action)
-      // If the try/catch wrapper kicks in, we'll get null back...
-      // in that case, we want to avoid making any changes to state
-      return res === null ? state : res
-    }
-    return state
-  }
-}
-
-function wrapWithTryCatch(fn, getSystem, {
-  logErrors = true
-} = {}) {
-  if(typeof fn !== "function") {
-    return fn
-  }
-
-  return function(...args) {
-    try {
-      return fn.call(this, ...args)
-    } catch(error) {
-      if(logErrors) {
-        const { uncaughtExceptionHandler} = getSystem().getConfigs()
-        if (typeof uncaughtExceptionHandler === "function") {
-          uncaughtExceptionHandler(error)
-        } else {
-          console.error(error)
-        }
-      }
-      return null
-    }
-  }
-}
-
-function configureStore(rootReducer, initialState, getSystem) {
-  const store = createStoreWithMiddleware(rootReducer, initialState, getSystem)
-
-  // if (module.hot) {
-  //   // Enable Webpack hot module replacement for reducers
-  //   module.hot.accept("reducers/index", () => {
-  //     const nextRootReducer = require("reducers/index")
-  //     store.replaceReducer(nextRootReducer)
-  //   })
-  // }
-
-  return store
-}

package/src/core/utils/create-html-ready-id.js

@@ -1,10 +0,0 @@
-/**
- * Replace invalid characters from a string to create an html-ready ID
- *
- * @param {string} id A string that may contain invalid characters for the HTML ID attribute
- * @param {string} [replacement=_] The string to replace invalid characters with; "_" by default
- * @return {string} Information about the parameter schema
- */
-export default function createHtmlReadyId(id, replacement = "_") {
-  return id.replace(/[^\w-]/g, replacement)
-}