rename project to "vue-extensions"

Author: nerdoc

README.md

@@ -1,56 +1,66 @@
-# vue-extensionpoints
+# vue-extensions
 
-This library is a Vue plugin providing a custom element which acts as extension point, with a named "hook". Plugins of your application then can provide components for this extension point which are automatically found and rendered replacing the extension.
+This library is a Vue plugin providing a custom element which acts as extension point, with a named "hook". Plugins of your application then can provide "extension" components for this extensionpoint which are automatically found and rendered replacing the extensionpoint.
 
 This is intended wherever you need to have a "list" of different looking components at one place each provided by a plugin.
 
-If you just need a list of the same component, just with different data, don't use `vue-extensionpoints` just use a `v-for` directive.
+If you just need a list of the same component, just with different data, don't use `vue-extensions` just use a `v-for` directive.
 
 ## Install
 
-The easiest way to install this library in your project is to use the corresponding Vue CLI plugin [extensionpoints](https://github.com/nerdocs/vue-cli-plugin-extensionpoints). It will do all magic for you:
+The easiest way to install this library in your project is to use the corresponding Vue CLI plugin [extensions](https://github.com/nerdocs/vue-cli-plugin-extensions). It will do all magic for you:
 ```bash
-# vue add extensionpoints
+# vue add extensions
 ```
 
 #### Manual install
 
 You can do everything manually too, if you want:
 ```bash
-npm install vue-extensionpoints
+npm install vue-extensions
 ```
 and add the following code:
 
-Create a file, e.g. named `plugins.js` (or `plugins/index.js`) which exports all of your plugins (you can e.g. automate the creation of this file in a script):
+Create a file, e.g. named `extensions.js`, which exports all of your extensions as default (you can e.g. automate the creation of this file in a script):
 ```javascript
-import FooPlugin from '@/plugins/fooplugin'
-import BarPlugin from 'my/path/to/some/plugins/barplugin.js'
+import FooPlugin from '@/extensions/fooplugin'
+import BarPlugin from 'my/path/to/some/extensions/barextension.js'
 
 export default {
-    FooPlugin, BarPlugin
+    FooExtension,
+    BarExtension
 }
 ```
 
-Now import that file into `main.js` and pass it to `vue-extensions`:
+Now import that file into `main.js` and pass it as "extensions" option to `vue-extensions`:
 
 ```javascript
 
-import Extensionpoints from 'vue-extensionpoints'
-import plugins from '@/plugins'
+import Extensionpoints from 'vue-extensions'
+import AppExtensions from '@/extensions'  // you can freely rename that
 
-Vue.add(Extensionpoints, {plugins})
+Vue.add(Extensionpoints, {extensions: AppExtensions})
 
 new Vue({
     //...
 })
 ```
 
-## Plugins
+Note that you have to enable Vue's runtime compiler if you want to render single file template components as extensions!
 
-Easily said: Plugins are Javascript modules that export a `hooks` object, which is a named index to Vue components:
+```Javascript
+// vue.config.js
+module.exports = {
+  runtimeCompiler: true
+}
+```
+
+## Extensions
+
+Easily said: Extensions are Javascript modules that export a `hooks` object, which is a named index pointing to Vue components:
 
 ```javascript
-// plugins/FooPlugin/index.js
+// extensions/FooExtension/index.js
 import AComponent from './components/acomponent.vue'
 import {FooElement, BazElement} from './components/othercomponents.vue'
 
@@ -72,7 +82,7 @@ You have an `<extensionpoint>` tag in your project available now:
 </template>
 ```
 
-The *vue-extensions* plugin renders the hooked elements replacing the <extensionpoint> element, one after another. It's up to you what the plugin is rendering: One plugin can render a simple `<div>` element with an image, the next plugin (same hook!) can render a complicated component with variables, sub-components etc. The `extensionpoint` renders them one after another. You only have to make sure that your components do what they promise: in the sample case above, `FooListElement` should render a \<li\> element - because it will be rendered within an \<ul\> element. But there are no constraints, you are free to choose.
+The *vue-extensions* plugin renders the hooked elements replacing the <extensionpoint> element, one after another. It's up to you what the extensions are rendering: One extension can render a simple `<div>` element with an image, the next extension (same hook!) can render a complicated component with variables, sub-components etc. The `<extensionpoint>` renders them one after another. You only have to make sure that your components do what they promise: in the sample case above, `FooListElement` should render a \<li\> element - because it will be rendered within an \<ul\> element. But there are no constraints, you are free to choose.
 
 
 ## Development
@@ -81,15 +91,15 @@ You have an idea, improvement, found a bug? Don't hesitate to contact me. PRs an
 
 ## License
 
-`vue-extensionpoints` is licensed under the [MIT](https://opensource.org/licenses/mit-license.php) license
+`vue-extensions` is licensed under the [MIT](https://opensource.org/licenses/mit-license.php) license
 
 #### Compiles and minifies library for production
 ```
 npm run build-lib
 ```
 
 #### Runs your tests
-Currently there are no tests, because of three important causes:
+Currently there are no tests (yet), because of three important causes:
 
 * I'm lazy
 * tests are not necessary here

index.js

@@ -5,34 +5,35 @@ export default {
     /**
      * Vue's plugin install hook.
      *
-     * Collects all available plugins and maintains a list of hooks, pointing to them.
+     * Collects all available extensions and maintains a list of hooks, pointing to them.
      * @param {Object} Vue The main Vue instance
      * @param {Object} options An named index of objects:
-     *      "plugins": a named index of modules that export a plugin:
-     *              name: the name of the plugin
-     *              hooks: named index of hooks, each pointing to a list of Vue components
-     *                  implementing that hook. They will be rendered at each extensionpoint
-     *                  that has the same hook name.
+     *      "extensions": a named index of modules that export a extension:
+     *              name: the name of the extensions
+     *              hooks: named index, each one pointing to a list of Vue
+     *                  components implementing that hook. They will be
+     *                  rendered at each extensionpoint that has the same hook
+     *                  name.
      */
     install: (Vue, options) => {
 
-        for (let pluginName in options.plugins) {
-            let plugin = options.plugins[pluginName]
-            if(plugin.initialize){
-                plugin.initialize()
+        for (let extensionName in options.extensions) {
+            let extension = options.extensions[extensionName]
+            if(extension.initialize){
+                extension.initialize()
             }
-            for (let hook in plugin.hooks) {
+            for (let hook in extension.hooks) {
                 if (hook_registry[hook] === undefined) {
-                    hook_registry[hook] = Array.isArray(plugin.hooks[hook])?
-                      plugin.hooks[hook] : [plugin.hooks[hook]]
+                    hook_registry[hook] = Array.isArray(extension.hooks[hook])?
+                      extension.hooks[hook] : [extension.hooks[hook]]
                 }
-                // console.debug(plugin.name + ": registering a component for hook '" + hook + "'")
+                // console.debug(extension.name + ": registering a component for hook '" + hook + "'")
 
-                // add plugin's component(s) to registry
-                if (Array.isArray(plugin.hooks[hook])) {
-                    hook_registry[hook].concat(plugin.hooks[hook])
+                // add extension's component(s) to registry
+                if (Array.isArray(extension.hooks[hook])) {
+                    hook_registry[hook].concat(extension.hooks[hook])
                 } else {
-                    hook_registry[hook].push(plugin.hooks[hook])
+                    hook_registry[hook].push(extension.hooks[hook])
                 }
 
             }
@@ -44,13 +45,13 @@ export default {
                 hook: String
             },
             computed: {
-                plugins ()  {
+                extensions ()  {
                     return hook_registry[this.hook]
                 }
             },
             template: `
-            <div class="extensionpoint-container">
-                <component :is="plugin_component" v-for="plugin_component in plugins" :key="plugin_component.id"/>
+            <div class="extension-container">
+                <component :is="extension_component" v-for="extension_component in extensions" :key="extension_component.id"/>
             </div>
             `
         })

package-lock.json

@@ -1,22 +1,22 @@
 {
-  "name": "vue-extensionpoints",
-  "version": "0.1.5",
+  "name": "vue-extensions",
+  "version": "0.2.0",
   "license": "MIT",
   "author": "Christian González <[email protected]>",
   "scripts": {
     "serve": "vue-cli-service serve",
-    "build": "vue-cli-service build --target lib --name vue-extensionpoints index.js",
+    "build": "vue-cli-service build --target lib --name vue-extensions index.js",
     "lint": "vue-cli-service lint",
     "prepublish": "npm run lint && npm run build"
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/nerdocs/vue-extensionpoints"
+    "url": "git://github.com/nerdocs/vue-extensions"
   },
   "bugs": {
-    "url": "https://github.com/nerdocs/vue-extensionpoints/issues"
+    "url": "https://github.com/nerdocs/vue-extensions/issues"
   },
-  "main": "./dist/vue-extensionpoints.common.js",
+  "main": "./dist/vue-extensions.common.js",
   "dependencies": {
     "core-js": "^3.4.3",
     "vue": "^2.6.10"