Estoy trabajando con un proyecto de tamaño medio que utiliza Vuejs como front-end. Las opciones que estoy explorando para encapsular / separar los métodos comunes que se pueden usar en muchos componentes incluyen el enfoque mixins y el enfoque plugin.
Enfoque Mixin
Tengo que escribir una declaración de importación en cada uno de los componentes (archivo) donde quiero usar los métodos mixin. ¿Esto aumenta el tamaño final del archivo ya que el mixin se importará en varios lugares? Puedo usarthis dentro de los métodos mixin.

Enfoque de complemento
Puedo instalar el complemento globalmente conVue.use(MyPlugin) y use el complemento en cualquier componente sin importar el complemento en cada componente.
Inconveniente: no puedo usarthis[field] dentro de los métodos del complemento. Tengo que pasar la instancia del componente de llamadavm usar tales métodos.

Edición 1: para incluir el enfoque extendido
Enfoque extendido
Puedo definir un componente base con todos los métodos que se usarán en varios otros componentes y luego extender este Componente Base para crear nuevos componentes. Aquí nuevamente, necesito pasar la instancia del componente heredado, esto utilizado en el Componente Base no se refiere al componente de llamada / herencia.

Encuentre el ejemplo trivial de código similar al que estoy usando a continuación:

    //mixin.js
    var MyMixin = {
       methods:{
          getName(){
              return this.name;
          }
       }
    };
    export default MyMixin;  


    //plugin.js
    var MyPlugin = {};

    MyPlugin.install = function(Vue, options){
        var service = {
    	getTheName(){
    	    retrun this.name;
    	},
            getTheNameVersion2(vm){  //here vm is the instance of the calling component passed as a parameter - is this proper way?
                return vm.name;
            }  
        }
    	
        Vue.prototype.$service = service;
    };

    export default MyPlugin;



    //my-component.js
    import MyMixin from './mixin';
    export default{
        template:require('./my-component-template.html'),
        mixins:[MyMixin],
        data(){
            return{
    	    name:'John Doe'
    	}
        },
        methods:{
           displayNameFromMixin(){
              console.log(this.getName()); //displays John Doe - using the mixin method.
           },
           displayNameFromPlugin(){
              console.log(this.$service.getTheName()); //error "this" references the plugin instead of the component instance
           },
           displayNameFromPluginVersion2(){
               console.log(this.$service.getTheNameVersion2(this)); //this works - passing the instance as method parameter
           }
    }   
    
    //base-component.js  
    export default{
        methods:{
            getName(vm){
                return vm.name;
            }
        }
    }   
    
//another-component.js
import BaseComponent from './base-component';
BaseComponent.extend({
    template:require('./another-component-template.html'),
    data(){
        return{
            name:'Jack Daniels';
        }
    },
    methods:{
        getNameFromBaseComponent(){
            console.log(this.getName(this)); //displays Jack Daniels - instance passed as method parameter
        }
    }
});


    //main.js

    import Vue from 'vue';
    import MyPlugin from './plugin';
    import MyComponent from './my-component';
    import AnotherComponent from './another-component';

    Vue.use(MyPlugin);

    new Vue({
        el:'body',
        components:{
            MyComponent, AnotherComponent
        }
    });

Mis preguntas:

Importar archivos mixin en cada componente (que requiere los métodos) ¿es una forma eficiente de hacerlo?
¿Importar mixin en varios lugares (archivos de componentes) incluye el código del archivo mixin repetidamente y aumenta el tamaño del archivo?

Pasar la instancia del componente de llamadavm = this como parámetro: ¿es una buena práctica? ¿La transferencia de instancias de componentes como parámetros de método causa algún problema de eficiencia?

Cómo atarthis (instance of the calling/inheriting component) a los métodos dentro del complemento y / o BaseComponent para quethis se refiere a la instancia del componente que llama / hereda en lugar del complemento / BaseComponent?

¿Qué enfoque es más efectivo con respecto al rendimiento, SECADO y tamaño de archivo?