@rancher/shell 0.3.5 → 0.3.7

package/utils/router.scrollBehavior.js

@@ -1,4 +1,4 @@
-import { getMatchedComponents, setScrollRestoration } from '../nuxt/utils';
+import { getMatchedComponents, setScrollRestoration } from './nuxt';
 
 if (process.client) {
   if ('scrollRestoration' in window.history) {

package/vue.config.js

@@ -4,8 +4,17 @@ const serveStatic = require('serve-static');
 const webpack = require('webpack');
 const { generateDynamicTypeImport } = require('./pkg/auto-import');
 const CopyWebpackPlugin = require('copy-webpack-plugin');
+
+// Suppress info level logging messages from http-proxy-middleware
+// This hides all of the "[HPM Proxy created] ..." messages
+const oldInfoLogger = console.info; // eslint-disable-line no-console
+
+console.info = () => {}; // eslint-disable-line no-console
+
 const { createProxyMiddleware } = require('http-proxy-middleware');
 
+console.info = oldInfoLogger; // eslint-disable-line no-console
+
 // This is currently hardcoded to avoid importing the TS
 // const { STANDARD } = require('./config/private-label');
 const STANDARD = 1;
@@ -78,32 +87,14 @@ module.exports = function(dir, _appConfig) {
 
   const appConfig = _appConfig || {};
   const excludes = appConfig.excludes || [];
-  const autoLoad = appConfig.autoLoad || [];
 
   const serverMiddleware = [];
-  const autoLoadPackages = [];
   const watcherIgnores = [
     /.shell/,
     /dist-pkg/,
     /scripts\/standalone/
   ];
 
-  autoLoad.forEach((pkg) => {
-    // Need the version number of each file
-    const pkgPackageFile = require(path.join(dir, 'pkg', pkg, 'package.json'));
-    const pkgRef = `${ pkg }-${ pkgPackageFile.version }`;
-
-    autoLoadPackages.push({
-      name:    `app-autoload-${ pkgRef }`,
-      content: `/pkg/${ pkgRef }/${ pkgRef }.umd.min.js`
-    });
-
-    // Anything auto-loaded should also be excluded
-    if (!excludes.includes(pkg)) {
-      excludes.push(pkg);
-    }
-  });
-
   // Find any UI packages in node_modules
   const NM = path.join(dir, 'node_modules');
   const pkg = require(path.join(dir, 'package.json'));
@@ -321,6 +312,13 @@ module.exports = function(dir, _appConfig) {
       before(app, server) {
         const socketProxies = {};
 
+        // Close down quickly in response to CTRL + C
+        process.once('SIGINT', () => {
+          server.close();
+          console.log('\n'); // eslint-disable-line no-console
+          process.exit(1);
+        });
+
         Object.keys(proxy).forEach((p) => {
           const px = createProxyMiddleware({
             ...proxy[p],
@@ -371,7 +369,7 @@ module.exports = function(dir, _appConfig) {
 
     pages: {
       index: {
-        entry:    path.join(SHELL_ABS, '/nuxt/client.js'),
+        entry:    path.join(SHELL_ABS, '/initialize/client.js'),
         template: path.join(SHELL_ABS, '/public/index.html')
       }
     },
@@ -561,6 +559,19 @@ module.exports = function(dir, _appConfig) {
       ];
 
       config.module.rules.push(...loaders);
+
+      // Update vue-loader to set whitespace to 'preserve'
+      // This was the setting with nuxt, but is not the default with vue cli
+      // Need to find the vue loader in the webpack config and update the setting
+      config.module.rules.forEach((loader) => {
+        if (loader.use) {
+          loader.use.forEach((use) => {
+            if (use.loader.includes('vue-loader')) {
+              use.options.compilerOptions.whitespace = 'preserve';
+            }
+          });
+        }
+      });
     },
   };
 

package/nuxt/App.js

@@ -1,210 +0,0 @@
-import Vue from 'vue'
-import { decode, parsePath, withoutBase, withoutTrailingSlash, normalizeURL } from 'ufo'
-
-import { getMatchedComponentsInstances, getChildrenComponentInstancesUsingFetch, promisify, globalHandleError, urlJoin, sanitizeComponent } from './utils'
-import NuxtError from '../layouts/error.vue'
-import NuxtLoading from '../components/nav/GlobalLoading.vue'
-import NuxtBuildIndicator from './components/nuxt-build-indicator'
-
-import '../assets/styles/app.scss'
-
-import _77180f1e from '../layouts/blank.vue'
-import _6f6c098b from '../layouts/default.vue'
-import _2d2495d5 from '../layouts/home.vue'
-import _77dd5794 from '../layouts/plain.vue'
-import _44002f80 from '../layouts/unauthenticated.vue'
-
-const layouts = { "_blank": sanitizeComponent(_77180f1e),"_default": sanitizeComponent(_6f6c098b),"_home": sanitizeComponent(_2d2495d5),"_plain": sanitizeComponent(_77dd5794),"_unauthenticated": sanitizeComponent(_44002f80) }
-
-export default {
-  render (h, props) {
-    const loadingEl = h('NuxtLoading', { ref: 'loading' })
-
-    const layoutEl = h(this.layout || 'nuxt')
-    const templateEl = h('div', {
-      domProps: {
-        id: '__layout'
-      },
-      key: this.layoutName
-    }, [layoutEl])
-
-    const transitionEl = h('transition', {
-      props: {
-        name: 'layout',
-        mode: 'out-in'
-      },
-      on: {
-        beforeEnter (el) {
-          // Ensure to trigger scroll event after calling scrollBehavior
-          window.$nuxt.$nextTick(() => {
-            window.$nuxt.$emit('triggerScroll')
-          })
-        }
-      }
-    }, [templateEl])
-
-    return h('div', {
-      domProps: {
-        id: '__nuxt'
-      }
-    }, [
-      loadingEl,
-      //h(NuxtBuildIndicator), // The build indicator doesn't work as is right now and emits an error in the console so I'm leaving it out for now
-      transitionEl
-    ])
-  },
-
-  data: () => ({
-    isOnline: true,
-
-    layout: null,
-    layoutName: '',
-
-    nbFetching: 0
-    }),
-
-  beforeCreate () {
-    Vue.util.defineReactive(this, 'nuxt', this.$options.nuxt)
-  },
-  created () {
-    // Add this.$nuxt in child instances
-    this.$root.$options.$nuxt = this
-
-    if (process.client) {
-      // add to window so we can listen when ready
-      window.$nuxt = this
-
-      this.refreshOnlineStatus()
-      // Setup the listeners
-      window.addEventListener('online', this.refreshOnlineStatus)
-      window.addEventListener('offline', this.refreshOnlineStatus)
-    }
-    // Add $nuxt.error()
-    this.error = this.nuxt.error
-    // Add $nuxt.context
-    this.context = this.$options.context
-  },
-
-  async mounted () {
-    this.$loading = this.$refs.loading
-  },
-
-  watch: {
-    'nuxt.err': 'errorChanged'
-  },
-
-  computed: {
-    isOffline () {
-      return !this.isOnline
-    },
-
-    isFetching () {
-      return this.nbFetching > 0
-    },
-  },
-
-  methods: {
-    refreshOnlineStatus () {
-      if (process.client) {
-        if (typeof window.navigator.onLine === 'undefined') {
-          // If the browser doesn't support connection status reports
-          // assume that we are online because most apps' only react
-          // when they now that the connection has been interrupted
-          this.isOnline = true
-        } else {
-          this.isOnline = window.navigator.onLine
-        }
-      }
-    },
-
-    async refresh () {
-      const pages = getMatchedComponentsInstances(this.$route)
-
-      if (!pages.length) {
-        return
-      }
-      this.$loading.start()
-
-      const promises = pages.map((page) => {
-        const p = []
-
-        // Old fetch
-        if (page.$options.fetch && page.$options.fetch.length) {
-          p.push(promisify(page.$options.fetch, this.context))
-        }
-        if (page.$fetch) {
-          p.push(page.$fetch())
-        } else {
-          // Get all component instance to call $fetch
-          for (const component of getChildrenComponentInstancesUsingFetch(page.$vnode.componentInstance)) {
-            p.push(component.$fetch())
-          }
-        }
-
-        if (page.$options.asyncData) {
-          p.push(
-            promisify(page.$options.asyncData, this.context)
-              .then((newData) => {
-                for (const key in newData) {
-                  Vue.set(page.$data, key, newData[key])
-                }
-              })
-          )
-        }
-
-        return Promise.all(p)
-      })
-      try {
-        await Promise.all(promises)
-      } catch (error) {
-        this.$loading.fail(error)
-        globalHandleError(error)
-        this.error(error)
-      }
-      this.$loading.finish()
-    },
-    errorChanged () {
-      if (this.nuxt.err) {
-        if (this.$loading) {
-          if (this.$loading.fail) {
-            this.$loading.fail(this.nuxt.err)
-          }
-          if (this.$loading.finish) {
-            this.$loading.finish()
-          }
-        }
-
-        let errorLayout = (NuxtError.options || NuxtError).layout;
-
-        if (typeof errorLayout === 'function') {
-          errorLayout = errorLayout(this.context)
-        }
-
-        this.setLayout(errorLayout)
-      }
-    },
-
-    setLayout (layout) {
-      if(layout && typeof layout !== 'string') {
-        throw new Error('[nuxt] Avoid using non-string value as layout property.')
-      }
-
-      if (!layout || !layouts['_' + layout]) {
-        layout = 'default'
-      }
-      this.layoutName = layout
-      this.layout = layouts['_' + layout]
-      return this.layout
-    },
-    loadLayout (layout) {
-      if (!layout || !layouts['_' + layout]) {
-        layout = 'default'
-      }
-      return Promise.resolve(layouts['_' + layout])
-    },
-  },
-
-  components: {
-    NuxtLoading
-  }
-}

package/nuxt/axios.js

@@ -1,186 +0,0 @@
-import Axios from 'axios'
-import defu from 'defu'
-import axiosRetry from 'axios-retry'
-
-// Axios.prototype cannot be modified
-const axiosExtra = {
-  setBaseURL (baseURL) {
-    this.defaults.baseURL = baseURL
-  },
-  setHeader (name, value, scopes = 'common') {
-    for (let scope of Array.isArray(scopes) ? scopes : [ scopes ]) {
-      if (!value) {
-        delete this.defaults.headers[scope][name];
-        return
-      }
-      this.defaults.headers[scope][name] = value
-    }
-  },
-  setToken (token, type, scopes = 'common') {
-    const value = !token ? null : (type ? type + ' ' : '') + token
-    this.setHeader('Authorization', value, scopes)
-  },
-  onRequest(fn) {
-    this.interceptors.request.use(config => fn(config) || config)
-  },
-  onResponse(fn) {
-    this.interceptors.response.use(response => fn(response) || response)
-  },
-  onRequestError(fn) {
-    this.interceptors.request.use(undefined, error => fn(error) || Promise.reject(error))
-  },
-  onResponseError(fn) {
-    this.interceptors.response.use(undefined, error => fn(error) || Promise.reject(error))
-  },
-  onError(fn) {
-    this.onRequestError(fn)
-    this.onResponseError(fn)
-  },
-  create(options) {
-    return createAxiosInstance(defu(options, this.defaults))
-  }
-}
-
-// Request helpers ($get, $post, ...)
-for (let method of ['request', 'delete', 'get', 'head', 'options', 'post', 'put', 'patch']) {
-  axiosExtra['$' + method] = function () { return this[method].apply(this, arguments).then(res => res && res.data) }
-}
-
-const extendAxiosInstance = axios => {
-  for (let key in axiosExtra) {
-    axios[key] = axiosExtra[key].bind(axios)
-  }
-}
-
-const createAxiosInstance = axiosOptions => {
-  // Create new axios instance
-  const axios = Axios.create(axiosOptions)
-  axios.CancelToken = Axios.CancelToken
-  axios.isCancel = Axios.isCancel
-
-  // Extend axios proto
-  extendAxiosInstance(axios)
-
-  // Setup interceptors
-
-  setupProgress(axios)
-  axiosRetry(axios, {"retries":0})
-
-  return axios
-}
-
-const setupProgress = (axios) => {
-  if (process.server) {
-    return
-  }
-
-  // A noop loading inteterface for when $nuxt is not yet ready
-  const noopLoading = {
-    finish: () => { },
-    start: () => { },
-    fail: () => { },
-    set: () => { }
-  }
-
-  const $loading = () => {
-    const $nuxt = typeof window !== 'undefined' && window['$nuxt']
-    return ($nuxt && $nuxt.$loading && $nuxt.$loading.set) ? $nuxt.$loading : noopLoading
-  }
-
-  let currentRequests = 0
-
-  axios.onRequest(config => {
-    if (config && config.progress === false) {
-      return
-    }
-
-    currentRequests++
-  })
-
-  axios.onResponse(response => {
-    if (response && response.config && response.config.progress === false) {
-      return
-    }
-
-    currentRequests--
-    if (currentRequests <= 0) {
-      currentRequests = 0
-      $loading().finish()
-    }
-  })
-
-  axios.onError(error => {
-    if (error && error.config && error.config.progress === false) {
-      return
-    }
-
-    currentRequests--
-
-    if (Axios.isCancel(error)) {
-      return
-    }
-
-    $loading().fail()
-    $loading().finish()
-  })
-
-  const onProgress = e => {
-    if (!currentRequests) {
-      return
-    }
-    const progress = ((e.loaded * 100) / (e.total * currentRequests))
-    $loading().set(Math.min(100, progress))
-  }
-
-  axios.defaults.onUploadProgress = onProgress
-  axios.defaults.onDownloadProgress = onProgress
-}
-
-export default (ctx, inject) => {
-  // runtimeConfig
-  const runtimeConfig = ctx.$config && ctx.$config.axios || {}
-  // baseURL
-  const baseURL = process.browser
-    ? (runtimeConfig.browserBaseURL || runtimeConfig.baseURL || '/')
-      : (runtimeConfig.baseURL || process.env._AXIOS_BASE_URL_ || 'https://localhost:8005/')
-
-  // Create fresh objects for all default header scopes
-  // Axios creates only one which is shared across SSR requests!
-  // https://github.com/mzabriskie/axios/blob/master/lib/defaults.js
-  const headers = {
-    "common": {
-        "Accept": "application/json, text/plain, */*"
-    },
-    "delete": {},
-    "get": {},
-    "head": {},
-    "post": {},
-    "put": {},
-    "patch": {}
-}
-
-  const axiosOptions = {
-    baseURL,
-    headers
-  }
-
-  // Proxy SSR request headers headers
-  if (process.server && ctx.req && ctx.req.headers) {
-    const reqHeaders = { ...ctx.req.headers }
-    for (let h of ["accept","host","cf-ray","cf-connecting-ip","content-length","content-md5","content-type"]) {
-      delete reqHeaders[h]
-    }
-    axiosOptions.headers.common = { ...reqHeaders, ...axiosOptions.headers.common }
-  }
-
-  if (process.server) {
-    // Don't accept brotli encoding because Node can't parse it
-    axiosOptions.headers.common['accept-encoding'] = 'gzip, deflate'
-  }
-
-  const axios = createAxiosInstance(axiosOptions)
-
-  // Inject axios to the context as $axios
-  ctx.$axios = axios
-  inject('axios', axios)
-}

package/nuxt/empty.js

@@ -1 +0,0 @@
-// This file is intentionally left empty for noop aliases

package/nuxt/jsonp.js

@@ -1,82 +0,0 @@
-const chunks = {} // chunkId => exports
-const chunksInstalling = {} // chunkId => Promise
-const failedChunks = {}
-
-function importChunk(chunkId, src) {
-  // Already installed
-  if (chunks[chunkId]) {
-    return Promise.resolve(chunks[chunkId])
-  }
-
-  // Failed loading
-  if (failedChunks[chunkId]) {
-    return Promise.reject(failedChunks[chunkId])
-  }
-
-  // Installing
-  if (chunksInstalling[chunkId]) {
-    return chunksInstalling[chunkId]
-  }
-
-  // Set a promise in chunk cache
-  let resolve, reject
-  const promise = chunksInstalling[chunkId] = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-
-  // Clear chunk data from cache
-  delete chunks[chunkId]
-
-  // Start chunk loading
-  const script = document.createElement('script')
-  script.charset = 'utf-8'
-  script.timeout = 120
-  script.src = src
-  let timeout
-
-  // Create error before stack unwound to get useful stacktrace later
-  const error = new Error()
-
-  // Complete handlers
-  const onScriptComplete = script.onerror = script.onload = (event) => {
-    // Cleanups
-    clearTimeout(timeout)
-    delete chunksInstalling[chunkId]
-
-    // Avoid mem leaks in IE
-    script.onerror = script.onload = null
-
-    // Verify chunk is loaded
-    if (chunks[chunkId]) {
-      return resolve(chunks[chunkId])
-    }
-
-    // Something bad happened
-    const errorType = event && (event.type === 'load' ? 'missing' : event.type)
-    const realSrc = event && event.target && event.target.src
-    error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')'
-    error.name = 'ChunkLoadError'
-    error.type = errorType
-    error.request = realSrc
-    failedChunks[chunkId] = error
-    reject(error)
-  }
-
-  // Timeout
-  timeout = setTimeout(() => {
-    onScriptComplete({ type: 'timeout', target: script })
-  }, 120000)
-
-  // Append script
-  document.head.appendChild(script)
-
-  // Return promise
-  return promise
-}
-
-export function installJsonp() {
-  window.__NUXT_JSONP__ = function (chunkId, exports) { chunks[chunkId] = exports }
-  window.__NUXT_JSONP_CACHE__ = chunks
-  window.__NUXT_IMPORT__ = importChunk
-}

package/nuxt/loading.html

@@ -1,39 +0,0 @@
-<style>
-.initial-load-spinner-container {
-  align-items: center;
-  background-color: #f8f8f8;
-  display: flex;
-  justify-content: center;
-  height: 100vh;
-  left: 0;
-  position: absolute;
-  top: 0;
-  width: 100vw;
-}
-
-.initial-load-spinner {
-  animation: initial-load-animate 1s infinite linear;
-  background-color: #fff;
-  box-sizing: border-box;
-  border: 5px solid #008ACF;
-  border-radius: 50%;
-  border-top-color: #00B2E2;
-  display: inline-block;
-  height: 80px;
-  margin: 0 auto;
-  width: 80px;
-}
-
-@keyframes initial-load-animate {
-  0% {
-    transform: rotate(0deg);
-  }
-
-  100% {
-    transform: rotate(359deg);
-  }
-}
-</style>
-<div class="initial-load-spinner-container">
-  <i class="initial-load-spinner"></i>
-</div>

package/nuxt/mixins/fetch.client.js

@@ -1,90 +0,0 @@
-import Vue from 'vue'
-import { hasFetch, normalizeError, addLifecycleHook, createGetCounter } from '../utils'
-
-const isSsrHydration = (vm) => vm.$vnode && vm.$vnode.elm && vm.$vnode.elm.dataset && vm.$vnode.elm.dataset.fetchKey
-const nuxtState = window.__NUXT__
-
-export default {
-  beforeCreate () {
-    if (!hasFetch(this)) {
-      return
-    }
-
-    this._fetchDelay = typeof this.$options.fetchDelay === 'number' ? this.$options.fetchDelay : 200
-
-    Vue.util.defineReactive(this, '$fetchState', {
-      pending: false,
-      error: null,
-      timestamp: Date.now()
-    })
-
-    this.$fetch = $fetch.bind(this)
-    addLifecycleHook(this, 'created', created)
-    addLifecycleHook(this, 'beforeMount', beforeMount)
-  }
-}
-
-function beforeMount() {
-  if (!this._hydrated) {
-    return this.$fetch()
-  }
-}
-
-function created() {
-  if (!isSsrHydration(this)) {
-    return
-  }
-
-  // Hydrate component
-  this._hydrated = true
-  this._fetchKey = this.$vnode.elm.dataset.fetchKey
-  const data = nuxtState.fetch[this._fetchKey]
-
-  // If fetch error
-  if (data && data._error) {
-    this.$fetchState.error = data._error
-    return
-  }
-
-  // Merge data
-  for (const key in data) {
-    Vue.set(this.$data, key, data[key])
-  }
-}
-
-function $fetch() {
-  if (!this._fetchPromise) {
-    this._fetchPromise = $_fetch.call(this)
-      .then(() => { delete this._fetchPromise })
-  }
-  return this._fetchPromise
-}
-
-async function $_fetch() {
-  this.$nuxt.nbFetching++
-  this.$fetchState.pending = true
-  this.$fetchState.error = null
-  this._hydrated = false
-  let error = null
-  const startTime = Date.now()
-
-  try {
-    await this.$options.fetch.call(this)
-  } catch (err) {
-    if (process.dev) {
-      console.error('Error in fetch():', err)
-    }
-    error = normalizeError(err)
-  }
-
-  const delayLeft = this._fetchDelay - (Date.now() - startTime)
-  if (delayLeft > 0) {
-    await new Promise(resolve => setTimeout(resolve, delayLeft))
-  }
-
-  this.$fetchState.error = error
-  this.$fetchState.pending = false
-  this.$fetchState.timestamp = Date.now()
-
-  this.$nextTick(() => this.$nuxt.nbFetching--)
-}