vue-identify-network/dist/vue-identify-network.esm.js

/*!
 * vue-identify-network v2.0.0
 * Identify the network your users are using!
 * (c) 2021 Vinayak Kulkarni<inbox.vinayak@gmail.com>
 * Released under the MIT License
 */

import VueCompositionApi, { defineComponent, ref, onMounted, onBeforeUnmount } from '@vue/composition-api';

var script = defineComponent({
  name: 'VueIdentifyNetwork',
  props: {
    unknownClass: {
      type: String ,
      required: false,
      default: null,
    },
    slowClass: {
      type: String ,
      required: false,
      default: null,
    },
    fastClass: {
      type: String ,
      required: false,
      default: null,
    },
  },
  emits: ['network-type', 'network-speed'],
  setup(_, { emit }) {
    const type = ref(null);
    const downLink = ref('Unknown');
    const vendor = ref(
      typeof window === 'undefined' ? 'Unknown' : navigator.vendor,
    );

    onMounted(() => {
      if (vendor.value.includes('Google') && type.value !== 'Unknown') {
        type.value = navigator.connection.effectiveType;
        downLink.value = navigator.connection.downlink;
      } else {
        type.value = 'Unknown';
        downLink.value = 'Unknown';
      }
      emit('network-type', type.value);
      emit('network-speed', downLink.value);
      navigator.connection.addEventListener('change', updateConnection);
    });

    onBeforeUnmount(() => {
      navigator.connection.removeEventListener('change', updateConnection);
    });

    /**
     * Updates the type & downLink info
     *
     * @param {Evented} e - The type & downlink info
     */
    function updateConnection(e) {
      type.value = e.currentTarget && e.currentTarget.effectiveType;
      downLink.value = e.currentTarget && e.currentTarget.downlink;
      emit('network-type', type.value);
      emit('network-speed', downLink.value);
    }

    return {
      type,
    };
  },
});

function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
    if (typeof shadowMode !== 'boolean') {
        createInjectorSSR = createInjector;
        createInjector = shadowMode;
        shadowMode = false;
    }
    // Vue.extend constructor export interop.
    const options = typeof script === 'function' ? script.options : script;
    // render functions
    if (template && template.render) {
        options.render = template.render;
        options.staticRenderFns = template.staticRenderFns;
        options._compiled = true;
        // functional template
        if (isFunctionalTemplate) {
            options.functional = true;
        }
    }
    // scopedId
    if (scopeId) {
        options._scopeId = scopeId;
    }
    let hook;
    if (moduleIdentifier) {
        // server build
        hook = function (context) {
            // 2.3 injection
            context =
                context || // cached call
                    (this.$vnode && this.$vnode.ssrContext) || // stateful
                    (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional
            // 2.2 with runInNewContext: true
            if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
                context = __VUE_SSR_CONTEXT__;
            }
            // inject component styles
            if (style) {
                style.call(this, createInjectorSSR(context));
            }
            // register component module identifier for async chunk inference
            if (context && context._registeredComponents) {
                context._registeredComponents.add(moduleIdentifier);
            }
        };
        // used by ssr in case component is cached and beforeCreate
        // never gets called
        options._ssrRegister = hook;
    }
    else if (style) {
        hook = shadowMode
            ? function (context) {
                style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));
            }
            : function (context) {
                style.call(this, createInjector(context));
            };
    }
    if (hook) {
        if (options.functional) {
            // register for functional component in vue file
            const originalRender = options.render;
            options.render = function renderWithStyleInjection(h, context) {
                hook.call(context);
                return originalRender(h, context);
            };
        }
        else {
            // inject component registration as beforeCreate hook
            const existing = options.beforeCreate;
            options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
        }
    }
    return script;
}

/* script */
const __vue_script__ = script;

/* template */
var __vue_render__ = function () {
  var _vm = this;
  var _h = _vm.$createElement;
  var _c = _vm._self._c || _h;
  return _c("div", [
    _vm.type === "Unknown"
      ? _c("div", { class: _vm.unknownClass }, [_vm._t("unknown")], 2)
      : _vm._e(),
    _vm._v(" "),
    _vm.type === "2g"
      ? _c("div", { class: _vm.slowClass }, [_vm._t("slow")], 2)
      : _vm._e(),
    _vm._v(" "),
    _vm.type !== "2g" && _vm.type !== "Unknown"
      ? _c("div", { class: _vm.fastClass }, [_vm._t("fast")], 2)
      : _vm._e(),
  ])
};
var __vue_staticRenderFns__ = [];
__vue_render__._withStripped = true;

  /* style */
  const __vue_inject_styles__ = undefined;
  /* scoped */
  const __vue_scope_id__ = undefined;
  /* module identifier */
  const __vue_module_identifier__ = undefined;
  /* functional template */
  const __vue_is_functional_template__ = false;
  /* style inject */
  
  /* style inject SSR */
  
  /* style inject shadow dom */
  

  
  const __vue_component__ = /*#__PURE__*/normalizeComponent(
    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
    __vue_inject_styles__,
    __vue_script__,
    __vue_scope_id__,
    __vue_is_functional_template__,
    __vue_module_identifier__,
    false,
    undefined,
    undefined,
    undefined
  );

  var VueIdentifyNetwork = __vue_component__;

let installed = false;

const install = {
  install(Vue) {
    if (installed) return;
    Vue.use(VueCompositionApi);
    Vue.component('VueIdentifyNetwork', VueIdentifyNetwork);
    installed = true;
  },
};

var install$1 = install;

export { VueIdentifyNetwork, install$1 as default };
//# sourceMappingURL=vue-identify-network.esm.js.map