@webiny/plugins 0.0.0-ee-vpcs.549378cf03

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Plugin.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class Plugin {
+    static readonly type: string;
+    name?: string;
+    constructor();
+    get type(): string;
+}

package/Plugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Plugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+class Plugin {
+  constructor() {
+    (0, _defineProperty2.default)(this, "name", void 0);
+
+    if (!this.constructor.type) {
+      throw Error(`Missing "type" definition in "${this.constructor.name}"!`);
+    }
+  }
+
+  get type() {
+    return this.constructor.type;
+  }
+
+}
+
+exports.Plugin = Plugin;
+(0, _defineProperty2.default)(Plugin, "type", void 0);

package/Plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Plugin","constructor","type","Error","name"],"sources":["Plugin.ts"],"sourcesContent":["export abstract class Plugin {\n    public static readonly type: string;\n    public name?: string;\n\n    constructor() {\n        if (!(this.constructor as typeof Plugin).type) {\n            throw Error(`Missing \"type\" definition in \"${this.constructor.name}\"!`);\n        }\n    }\n\n    get type() {\n        return (this.constructor as typeof Plugin).type;\n    }\n}\n"],"mappings":";;;;;;;;;;;AAAO,MAAeA,MAAf,CAAsB;EAIzBC,WAAW,GAAG;IAAA;;IACV,IAAI,CAAE,KAAKA,WAAN,CAAoCC,IAAzC,EAA+C;MAC3C,MAAMC,KAAK,CAAE,iCAAgC,KAAKF,WAAL,CAAiBG,IAAK,IAAxD,CAAX;IACH;EACJ;;EAEO,IAAJF,IAAI,GAAG;IACP,OAAQ,KAAKD,WAAN,CAAoCC,IAA3C;EACH;;AAZwB;;;8BAAPF,M"}

package/PluginsContainer.d.ts

@@ -0,0 +1,14 @@
+import { Plugin, PluginCollection } from "./types";
+export declare class PluginsContainer {
+    private plugins;
+    private _byTypeCache;
+    constructor(...args: PluginCollection);
+    byName<T extends Plugin>(name: T["name"]): T | null;
+    byType<T extends Plugin>(type: T["type"]): T[];
+    atLeastOneByType<T extends Plugin>(type: T["type"]): T[];
+    oneByType<T extends Plugin>(type: T["type"]): T;
+    all<T extends Plugin>(): T[];
+    register(...args: any): void;
+    unregister(name: string): void;
+    private findByType;
+}

package/PluginsContainer.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginsContainer = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _uniqid = _interopRequireDefault(require("uniqid"));
+
+const isOptionsObject = item => item && !Array.isArray(item) && !item.type && !item.name;
+
+const normalizeArgs = args => {
+  let options = {}; // Check if last item in the plugins array is actually an options object.
+
+  if (isOptionsObject(args[args.length - 1])) {
+    [options] = args.splice(-1, 1);
+  }
+
+  return [args, options];
+};
+
+const assign = (plugins, options, target) => {
+  for (let i = 0; i < plugins.length; i++) {
+    const plugin = plugins[i];
+
+    if (Array.isArray(plugin)) {
+      assign(plugin, options, target);
+      continue;
+    }
+
+    let name = plugin._name || plugin.name;
+
+    if (!name) {
+      plugin.name = name = (0, _uniqid.default)(plugin.type + "-");
+    } // If skip existing was set to true, and a plugin with the same name was already registered, skip registration.
+
+
+    if (!options.skipExisting || !target[name]) {
+      target[name] = plugin;
+      plugin.init && plugin.init();
+    }
+  }
+};
+
+class PluginsContainer {
+  constructor(...args) {
+    (0, _defineProperty2.default)(this, "plugins", {});
+    (0, _defineProperty2.default)(this, "_byTypeCache", {});
+    this.register(...args);
+  }
+
+  byName(name) {
+    if (!name) {
+      return null;
+    }
+    /**
+     * We can safely cast name as string, we know it is so.
+     */
+
+
+    return this.plugins[name];
+  }
+
+  byType(type) {
+    if (this._byTypeCache[type]) {
+      return Array.from(this._byTypeCache[type]);
+    }
+
+    const plugins = this.findByType(type);
+    this._byTypeCache[type] = plugins;
+    return Array.from(plugins);
+  }
+
+  atLeastOneByType(type) {
+    const list = this.byType(type);
+
+    if (list.length === 0) {
+      throw new Error(`There are no plugins by type "${type}".`);
+    }
+
+    return list;
+  }
+
+  oneByType(type) {
+    const list = this.atLeastOneByType(type);
+
+    if (list.length > 1) {
+      throw new Error(`There is a requirement for plugin of type "${type}" to be only one registered.`);
+    }
+
+    return list[0];
+  }
+
+  all() {
+    return Object.values(this.plugins);
+  }
+
+  register(...args) {
+    // reset the cache when adding new plugins
+    this._byTypeCache = {};
+    const [plugins, options] = normalizeArgs(args);
+    assign(plugins, options, this.plugins);
+  }
+
+  unregister(name) {
+    // reset the cache when removing a plugin
+    this._byTypeCache = {};
+    delete this.plugins[name];
+  }
+
+  findByType(type) {
+    return Object.values(this.plugins).filter(pl => pl.type === type);
+  }
+
+}
+
+exports.PluginsContainer = PluginsContainer;

package/PluginsContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isOptionsObject","item","Array","isArray","type","name","normalizeArgs","args","options","length","splice","assign","plugins","target","i","plugin","_name","uniqid","skipExisting","init","PluginsContainer","constructor","register","byName","byType","_byTypeCache","from","findByType","atLeastOneByType","list","Error","oneByType","all","Object","values","unregister","filter","pl"],"sources":["PluginsContainer.ts"],"sourcesContent":["import { Plugin, PluginCollection } from \"./types\";\nimport uniqid from \"uniqid\";\n\nconst isOptionsObject = (item?: any) => item && !Array.isArray(item) && !item.type && !item.name;\nconst normalizeArgs = (args: any[]) => {\n    let options = {};\n\n    // Check if last item in the plugins array is actually an options object.\n    if (isOptionsObject(args[args.length - 1])) {\n        [options] = args.splice(-1, 1);\n    }\n\n    return [args, options];\n};\n\nconst assign = (plugins: any, options: any, target: Record<string, any>): void => {\n    for (let i = 0; i < plugins.length; i++) {\n        const plugin = plugins[i];\n        if (Array.isArray(plugin)) {\n            assign(plugin, options, target);\n            continue;\n        }\n\n        let name = plugin._name || plugin.name;\n        if (!name) {\n            plugin.name = name = uniqid(plugin.type + \"-\");\n        }\n\n        // If skip existing was set to true, and a plugin with the same name was already registered, skip registration.\n        if (!options.skipExisting || !target[name]) {\n            target[name] = plugin;\n            plugin.init && plugin.init();\n        }\n    }\n};\n\nexport class PluginsContainer {\n    private plugins: Record<string, Plugin> = {};\n    private _byTypeCache: Record<string, Plugin[]> = {};\n\n    constructor(...args: PluginCollection) {\n        this.register(...args);\n    }\n\n    public byName<T extends Plugin>(name: T[\"name\"]): T | null {\n        if (!name) {\n            return null;\n        }\n        /**\n         * We can safely cast name as string, we know it is so.\n         */\n        return this.plugins[name as string] as T;\n    }\n\n    public byType<T extends Plugin>(type: T[\"type\"]): T[] {\n        if (this._byTypeCache[type]) {\n            return Array.from(this._byTypeCache[type]) as T[];\n        }\n        const plugins = this.findByType<T>(type);\n        this._byTypeCache[type] = plugins;\n        return Array.from(plugins);\n    }\n\n    public atLeastOneByType<T extends Plugin>(type: T[\"type\"]): T[] {\n        const list = this.byType<T>(type);\n        if (list.length === 0) {\n            throw new Error(`There are no plugins by type \"${type}\".`);\n        }\n        return list;\n    }\n\n    public oneByType<T extends Plugin>(type: T[\"type\"]): T {\n        const list = this.atLeastOneByType<T>(type);\n        if (list.length > 1) {\n            throw new Error(\n                `There is a requirement for plugin of type \"${type}\" to be only one registered.`\n            );\n        }\n        return list[0];\n    }\n\n    public all<T extends Plugin>(): T[] {\n        return Object.values(this.plugins) as T[];\n    }\n\n    public register(...args: any): void {\n        // reset the cache when adding new plugins\n        this._byTypeCache = {};\n        const [plugins, options] = normalizeArgs(args);\n        assign(plugins, options, this.plugins);\n    }\n\n    public unregister(name: string): void {\n        // reset the cache when removing a plugin\n        this._byTypeCache = {};\n        delete this.plugins[name];\n    }\n\n    private findByType<T extends Plugin>(type: T[\"type\"]): T[] {\n        return (Object.values(this.plugins) as T[]).filter(pl => pl.type === type) as T[];\n    }\n}\n"],"mappings":"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"}

package/README.md

@@ -0,0 +1,74 @@
+# @webiny/plugins
+[![](https://img.shields.io/npm/dw/@webiny/plugins.svg)](https://www.npmjs.com/package/@webiny/plugins) 
+[![](https://img.shields.io/npm/v/@webiny/plugins.svg)](https://www.npmjs.com/package/@webiny/plugins)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A simple registry that stores all plugins in a shared object.
+The only requirement for a plugin is to have a `name` and a `type` properties. 
+The rest is entirely up to you.
+
+There is nothing spectacular going on under the hood, just a simple 
+object for storing references and a few utility functions.
+
+For more information, please visit [the official docs](https://docs.webiny.com/docs/developer-tutorials/plugins-crash-course).
+  
+## Install
+```
+npm install --save @webiny/plugins
+```
+
+Or if you prefer yarn: 
+```
+yarn add @webiny/plugins
+```
+
+## Usage
+
+### Adding a plugin
+```
+import { plugins } from "@webiny/plugins";
+
+// Add a plugin
+plugins.register({
+    name: "my-plugin",
+    type: "say-hi",
+    salute: () => "Hi!"
+});
+
+plugins.register({
+    name: "my-second-plugin",
+    type: "say-hi",
+    salute: () => "Yo!"
+});
+```
+
+### Getting plugins by type
+```
+// anywhere in your app
+import { plugins } from "@webiny/plugins";
+
+const pluginList = plugins.byType("say-hi");
+pluginList.forEach(plugin => {
+    // Call "salute" function
+    plugin.salute();
+});
+```
+
+### Getting a single plugin by name
+```
+// anywhere in your app
+import { plugins } from "@webiny/plugins";
+
+const plugin = plugins.byName("my-plugin");
+// Call "salute" function
+plugin.salute();
+```
+
+### Removing a plugin
+```
+// anywhere in your app
+import { plugins } from "@webiny/plugins";
+
+plugins.unregister("my-plugin");
+```

package/index.d.ts

@@ -0,0 +1,4 @@
+import { PluginsContainer } from "./PluginsContainer";
+import { Plugin } from "./Plugin";
+declare const plugins: PluginsContainer;
+export { Plugin, PluginsContainer, plugins };

package/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Plugin", {
+  enumerable: true,
+  get: function () {
+    return _Plugin.Plugin;
+  }
+});
+Object.defineProperty(exports, "PluginsContainer", {
+  enumerable: true,
+  get: function () {
+    return _PluginsContainer.PluginsContainer;
+  }
+});
+exports.plugins = void 0;
+
+var _PluginsContainer = require("./PluginsContainer");
+
+var _Plugin = require("./Plugin");
+
+const plugins = new _PluginsContainer.PluginsContainer();
+exports.plugins = plugins;

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["plugins","PluginsContainer"],"sources":["index.ts"],"sourcesContent":["import { PluginsContainer } from \"./PluginsContainer\";\nimport { Plugin } from \"./Plugin\";\n\nconst plugins = new PluginsContainer();\n\nexport { Plugin, PluginsContainer, plugins };\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AAEA,MAAMA,OAAO,GAAG,IAAIC,kCAAJ,EAAhB"}

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@webiny/plugins",
+	"version": "0.0.0-ee-vpcs.549378cf03",
+	"main": "index.js",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "A simple registry that stores all plugins in a shared object.",
+	"contributors": [
+		"Pavel Denisjuk <pavel@webiny.com>",
+		"Adrian Smijulj <adrian@webiny.com>"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@babel/runtime": "7.19.0",
+		"uniqid": "5.4.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.19.3",
+		"@babel/core": "^7.19.3",
+		"@types/uniqid": "^5.3.2",
+		"@webiny/cli": "^0.0.0-ee-vpcs.549378cf03",
+		"@webiny/project-utils": "^0.0.0-ee-vpcs.549378cf03",
+		"rimraf": "^3.0.2",
+		"ttypescript": "^1.5.13",
+		"typescript": "4.7.4"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"gitHead": "549378cf03fcd27845fc3fa23d1dc6b32896f630"
+}

package/types.d.ts

@@ -0,0 +1,8 @@
+export { PluginsContainer } from "./PluginsContainer";
+export declare type Plugin<T = Record<string, any>> = {
+    type: string;
+    name?: string;
+    init?: () => void;
+    [key: string]: any;
+} & T;
+export declare type PluginCollection = (Plugin | PluginCollection)[];

package/types.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PluginsContainer", {
+  enumerable: true,
+  get: function () {
+    return _PluginsContainer.PluginsContainer;
+  }
+});
+
+var _PluginsContainer = require("./PluginsContainer");

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export { PluginsContainer } from \"./PluginsContainer\";\n\nexport type Plugin<T = Record<string, any>> = {\n    type: string;\n    name?: string;\n    init?: () => void;\n    [key: string]: any;\n} & T;\n\nexport type PluginCollection = (Plugin | PluginCollection)[];\n"],"mappings":";;;;;;;;;;;;AAAA"}