@rancher/shell 0.3.3 → 0.3.5

package/nuxt/components/nuxt.js

@@ -0,0 +1,101 @@
+import Vue from 'vue'
+import { compile } from '../utils'
+
+import NuxtError from '../../layouts/error.vue'
+
+import NuxtChild from './nuxt-child'
+
+export default {
+  name: 'Nuxt',
+  components: {
+    NuxtChild,
+    NuxtError
+  },
+  props: {
+    nuxtChildKey: {
+      type: String,
+      default: undefined
+    },
+    keepAlive: Boolean,
+    keepAliveProps: {
+      type: Object,
+      default: undefined
+    },
+    name: {
+      type: String,
+      default: 'default'
+    }
+  },
+  errorCaptured (error) {
+    // if we receive and error while showing the NuxtError component
+    // capture the error and force an immediate update so we re-render
+    // without the NuxtError component
+    if (this.displayingNuxtError) {
+      this.errorFromNuxtError = error
+      this.$forceUpdate()
+    }
+  },
+  computed: {
+    routerViewKey () {
+      // If nuxtChildKey prop is given or current route has children
+      if (typeof this.nuxtChildKey !== 'undefined' || this.$route.matched.length > 1) {
+        return this.nuxtChildKey || compile(this.$route.matched[0].path)(this.$route.params)
+      }
+
+      const [matchedRoute] = this.$route.matched
+
+      if (!matchedRoute) {
+        return this.$route.path
+      }
+
+      const Component = matchedRoute.components.default
+
+      if (Component && Component.options) {
+        const { options } = Component
+
+        if (options.key) {
+          return (typeof options.key === 'function' ? options.key(this.$route) : options.key)
+        }
+      }
+
+      const strict = /\/$/.test(matchedRoute.path)
+      return strict ? this.$route.path : this.$route.path.replace(/\/$/, '')
+    }
+  },
+  beforeCreate () {
+    Vue.util.defineReactive(this, 'nuxt', this.$root.$options.nuxt)
+  },
+  render (h) {
+    // if there is no error
+    if (!this.nuxt.err) {
+      // Directly return nuxt child
+      return h('NuxtChild', {
+        key: this.routerViewKey,
+        props: this.$props
+      })
+    }
+
+    // if an error occurred within NuxtError show a simple
+    // error message instead to prevent looping
+    if (this.errorFromNuxtError) {
+      this.$nextTick(() => (this.errorFromNuxtError = false))
+
+      return h('div', {}, [
+        h('h2', 'An error occurred while showing the error page'),
+        h('p', 'Unfortunately an error occurred and while showing the error page another error occurred'),
+        h('p', `Error details: ${this.errorFromNuxtError.toString()}`),
+        h('nuxt-link', { props: { to: '/' } }, 'Go back to home')
+      ])
+    }
+
+    // track if we are showing the NuxtError component
+    this.displayingNuxtError = true
+    this.$nextTick(() => (this.displayingNuxtError = false))
+
+    return h(NuxtError, {
+      props: {
+        error: this.nuxt.err
+      }
+    })
+  }
+}

package/nuxt/cookie-universal-nuxt.js

@@ -0,0 +1,9 @@
+import cookieUniversal from 'cookie-universal'
+
+export default ({ req, res }, inject) => {
+  const options = {
+  "alias": "cookies",
+  "parseJSON": true
+}
+  inject(options.alias, cookieUniversal(req, res, options.parseJSON))
+}

package/nuxt/empty.js

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

package/nuxt/index.js

@@ -0,0 +1,365 @@
+import Vue from 'vue';
+import Vuex from 'vuex';
+import Meta from 'vue-meta';
+import ClientOnly from 'vue-client-only';
+import NoSsr from 'vue-no-ssr';
+import { createRouter } from '../config/router.js';
+import NuxtChild from './components/nuxt-child.js';
+import NuxtError from '../layouts/error.vue';
+import Nuxt from './components/nuxt.js';
+import App from './App.js';
+import { setContext, getLocation, getRouteData, normalizeError } from './utils';
+import { createStore } from './store.js';
+
+/* Plugins */
+
+import './portal-vue.js';
+import cookieUniversalNuxt from './cookie-universal-nuxt.js';
+import axios from './axios.js';
+import plugins from '../core/plugins.js';
+import pluginsLoader from '../core/plugins-loader.js';
+import axiosShell from '../plugins/axios';
+import '../plugins/tooltip';
+import '../plugins/vue-clipboard2';
+import '../plugins/v-select';
+import '../plugins/directives';
+import '../plugins/clean-html-directive';
+import '../plugins/transitions';
+import '../plugins/vue-js-modal';
+import '../plugins/js-yaml';
+import '../plugins/resize';
+import '../plugins/shortkey';
+import '../plugins/i18n';
+import '../plugins/global-formatters';
+import '../plugins/trim-whitespace';
+import '../plugins/extend-router';
+
+import consolePlugin from '../plugins/console';
+import intNumber from '../plugins/int-number';
+import nuxtClientInit from '../plugins/nuxt-client-init';
+import replaceAll from '../plugins/replaceall';
+import backButton from '../plugins/back-button';
+import plugin from '../plugins/plugin';
+import codeMirror from '../plugins/codemirror-loader';
+import '../plugins/formatters';
+import version from  '../plugins/version';
+import steveCreateWorker from '../plugins/steve-create-worker';
+
+// Component: <ClientOnly>
+Vue.component(ClientOnly.name, ClientOnly);
+
+// TODO: Remove in Nuxt 3: <NoSsr>
+Vue.component(NoSsr.name, {
+  ...NoSsr,
+  render(h, ctx) {
+    if (process.client && !NoSsr._warned) {
+      NoSsr._warned = true;
+
+      console.warn('<no-ssr> has been deprecated and will be removed in Nuxt 3, please use <client-only> instead');
+    }
+
+    return NoSsr.render(h, ctx);
+  }
+});
+
+// Component: <NuxtChild>
+Vue.component(NuxtChild.name, NuxtChild);
+Vue.component('NChild', NuxtChild);
+
+// Component NuxtLink is imported in server.js or client.js
+
+// Component: <Nuxt>
+Vue.component(Nuxt.name, Nuxt);
+
+Object.defineProperty(Vue.prototype, '$nuxt', {
+  get() {
+    const globalNuxt = this.$root.$options.$nuxt;
+
+    if (process.client && !globalNuxt && typeof window !== 'undefined') {
+      return window.$nuxt;
+    }
+
+    return globalNuxt;
+  },
+  configurable: true
+});
+
+Vue.use(Meta, {
+  keyName: 'head', attribute: 'data-n-head', ssrAttribute: 'data-n-head-ssr', tagIDKeyName: 'hid'
+});
+
+const defaultTransition = {
+  name: 'page', mode: 'out-in', appear: true, appearClass: 'appear', appearActiveClass: 'appear-active', appearToClass: 'appear-to'
+};
+
+const originalRegisterModule = Vuex.Store.prototype.registerModule;
+
+function registerModule(path, rawModule, options = {}) {
+  const preserveState = process.client && (
+    Array.isArray(path) ? !!path.reduce((namespacedState, path) => namespacedState && namespacedState[path], this.state) : path in this.state
+  );
+
+  return originalRegisterModule.call(this, path, rawModule, { preserveState, ...options });
+}
+
+async function createApp(ssrContext, config = {}) {
+  const router = await createRouter(ssrContext, config);
+
+  const store = createStore(ssrContext);
+
+  // Add this.$router into store actions/mutations
+  store.$router = router;
+
+  // Create Root instance
+
+  // here we inject the router and store to all child components,
+  // making them available everywhere as `this.$router` and `this.$store`.
+  const app = {
+    head: {"title":"dashboard","meta":[{"charset":"utf-8"},{"name":"viewport","content":"width=device-width, initial-scale=1"},{"hid":"description","name":"description","content":"Rancher Dashboard"}],"link":[{"hid":"icon","rel":"icon","type":"image\u002Fx-icon","href":"\u002Ffavicon.png"}],"style":[],"script":[]},
+
+    store,
+    router,
+    nuxt: {
+      defaultTransition,
+      transitions: [defaultTransition],
+      setTransitions(transitions) {
+        if (!Array.isArray(transitions)) {
+          transitions = [transitions];
+        }
+        transitions = transitions.map((transition) => {
+          if (!transition) {
+            transition = defaultTransition;
+          } else if (typeof transition === 'string') {
+            transition = Object.assign({}, defaultTransition, { name: transition });
+          } else {
+            transition = Object.assign({}, defaultTransition, transition);
+          }
+
+          return transition;
+        });
+        this.$options.nuxt.transitions = transitions;
+
+        return transitions;
+      },
+
+      err:     null,
+      dateErr: null,
+      error(err) {
+        err = err || null;
+        app.context._errored = Boolean(err);
+        err = err ? normalizeError(err) : null;
+        let nuxt = app.nuxt; // to work with @vue/composition-api, see https://github.com/nuxt/nuxt.js/issues/6517#issuecomment-573280207
+
+        if (this) {
+          nuxt = this.nuxt || this.$options.nuxt;
+        }
+        nuxt.dateErr = Date.now();
+        nuxt.err = err;
+        // Used in src/server.js
+        if (ssrContext) {
+          ssrContext.nuxt.error = err;
+        }
+
+        return err;
+      }
+    },
+    ...App
+  };
+
+  // Make app available into store via this.app
+  store.app = app;
+
+  const next = ssrContext ? ssrContext.next : location => app.router.push(location);
+  // Resolve route
+  let route;
+
+  if (ssrContext) {
+    route = router.resolve(ssrContext.url).route;
+  } else {
+    const path = getLocation(router.options.base, router.options.mode);
+
+    route = router.resolve(path).route;
+  }
+
+  // Set context to app.context
+  await setContext(app, {
+    store,
+    route,
+    next,
+    error:           app.nuxt.error.bind(app),
+    payload:         ssrContext ? ssrContext.payload : undefined,
+    req:             ssrContext ? ssrContext.req : undefined,
+    res:             ssrContext ? ssrContext.res : undefined,
+    beforeRenderFns: ssrContext ? ssrContext.beforeRenderFns : undefined,
+    ssrContext
+  });
+
+  function inject(key, value) {
+    if (!key) {
+      throw new Error('inject(key, value) has no key provided');
+    }
+    if (value === undefined) {
+      throw new Error(`inject('${ key }', value) has no value provided`);
+    }
+
+    key = `$${ key }`;
+    // Add into app
+    app[key] = value;
+    // Add into context
+    if (!app.context[key]) {
+      app.context[key] = value;
+    }
+
+    // Add into store
+    store[key] = app[key];
+
+    // Check if plugin not already installed
+    const installKey = `__nuxt_${ key }_installed__`;
+
+    if (Vue[installKey]) {
+      return;
+    }
+    Vue[installKey] = true;
+    // Call Vue.use() to install the plugin into vm
+    Vue.use(() => {
+      if (!Object.prototype.hasOwnProperty.call(Vue.prototype, key)) {
+        Object.defineProperty(Vue.prototype, key, {
+          get() {
+            return this.$root.$options[key];
+          }
+        });
+      }
+    });
+  }
+
+  // Inject runtime config as $config
+  inject('config', config);
+
+  if (process.client) {
+    // Replace store state before plugins execution
+    if (window.__NUXT__ && window.__NUXT__.state) {
+      store.replaceState(window.__NUXT__.state);
+    }
+  }
+
+  // Add enablePreview(previewData = {}) in context for plugins
+  if (process.static && process.client) {
+    app.context.enablePreview = function(previewData = {}) {
+      app.previewData = Object.assign({}, previewData);
+      inject('preview', previewData);
+    };
+  }
+  // Plugin execution
+
+  // if (typeof nuxt_plugin_portalvue_6babae27 === 'function') {
+  //   await nuxt_plugin_portalvue_6babae27(app.context, inject);
+  // }
+
+  if (typeof cookieUniversalNuxt === 'function') {
+    await cookieUniversalNuxt(app.context, inject);
+  }
+
+  if (typeof axios === 'function') {
+    await axios(app.context, inject);
+  }
+
+  if (typeof plugins === 'function') {
+    await plugins(app.context, inject);
+  }
+
+  if (typeof pluginsLoader === 'function') {
+    await pluginsLoader(app.context, inject);
+  }
+
+  if (typeof axiosShell === 'function') {
+    await axiosShell(app.context, inject);
+  }
+
+  if (process.client && typeof consolePlugin === 'function') {
+    await consolePlugin(app.context, inject);
+  }
+
+  if (process.client && typeof intNumber === 'function') {
+    await intNumber(app.context, inject);
+  }
+
+  if (process.client && typeof nuxtClientInit === 'function') {
+    await nuxtClientInit(app.context, inject);
+  }
+
+  if (typeof replaceAll === 'function') {
+    await replaceAll(app.context, inject);
+  }
+
+  if (typeof backButton === 'function') {
+    await backButton(app.context, inject);
+  }
+
+  if (process.client && typeof plugin === 'function') {
+    await plugin(app.context, inject);
+  }
+
+  if (process.client && typeof codeMirror === 'function') {
+    await codeMirror(app.context, inject);
+  }
+
+  if (process.client && typeof version === 'function') {
+    await version(app.context, inject);
+  }
+
+  if (process.client && typeof steveCreateWorker === 'function') {
+    await steveCreateWorker(app.context, inject);
+  }
+
+  // if (process.client && typeof formatters === 'function') {
+  //   await formatters(app.context, inject);
+  // }
+
+  // Lock enablePreview in context
+  if (process.static && process.client) {
+    app.context.enablePreview = function() {
+      console.warn('You cannot call enablePreview() outside a plugin.');
+    };
+  }
+
+  // Wait for async component to be resolved first
+  await new Promise((resolve, reject) => {
+    // Ignore 404s rather than blindly replacing URL in browser
+    if (process.client) {
+      const { route } = router.resolve(app.context.route.fullPath);
+
+      if (!route.matched.length) {
+        return resolve();
+      }
+    }
+    router.replace(app.context.route.fullPath, resolve, (err) => {
+      // https://github.com/vuejs/vue-router/blob/v3.4.3/src/util/errors.js
+      if (!err._isRouter) {
+        return reject(err);
+      }
+      if (err.type !== 2 /* NavigationFailureType.redirected */) {
+        return resolve();
+      }
+
+      // navigated to a different route in router guard
+      const unregister = router.afterEach(async(to, from) => {
+        if (process.server && ssrContext && ssrContext.url) {
+          ssrContext.url = to.fullPath;
+        }
+        app.context.route = await getRouteData(to);
+        app.context.params = to.params || {};
+        app.context.query = to.query || {};
+        unregister();
+        resolve();
+      });
+    });
+  });
+
+  return {
+    store,
+    app,
+    router
+  };
+}
+
+export { createApp, NuxtError };

package/nuxt/jsonp.js

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,39 @@
+<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/middleware.js

@@ -0,0 +1,12 @@
+const middleware = {}
+
+middleware['authenticated'] = require('../middleware/authenticated.js')
+middleware['authenticated'] = middleware['authenticated'].default || middleware['authenticated']
+
+middleware['i18n'] = require('../middleware/i18n.js')
+middleware['i18n'] = middleware['i18n'].default || middleware['i18n']
+
+middleware['unauthenticated'] = require('../middleware/unauthenticated.js')
+middleware['unauthenticated'] = middleware['unauthenticated'].default || middleware['unauthenticated']
+
+export default middleware

package/nuxt/mixins/fetch.client.js

@@ -0,0 +1,90 @@
+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--)
+}