chore: release v3.6.0

Author: javierbrea

docusaurus.config.js

@@ -1,6 +1,5 @@
 function docsUrl(page) {
-  // TODO, remove "next"
-  return `docs/next/${page}`;
+  return `docs/${page}`;
 }
 
 module.exports = {

src/pages/index.js

@@ -24,8 +24,7 @@ import { config } from "@fortawesome/fontawesome-svg-core";
 config.autoAddCss = false;
 
 function docsUrl(page) {
-  // TODO, remove "next"
-  return `docs/next/${page}`;
+  return `docs/${page}`;
 }
 
 const textContents = {

versioned_docs/version-3.6.0/api/javascript.md

@@ -0,0 +1,128 @@
+---
+id: javascript
+title: JavaScript API
+description: Mocks Server JavaScript API
+keywords:
+  - mocks server
+  - programmatic
+  - api
+  - core
+  - methods
+  - properties
+  - getters
+  - advanced usage
+  - JavaScript
+  - js
+  - node
+  - nodejs
+---
+
+```mdx-code-block
+import DocCardList from '@theme/DocCardList';
+import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
+```
+
+## Preface
+
+Mocks Server provides its `core` instance to plugins, middlewares and other system elements. It contains methods allowing to configure it, start or stop it, listen to its events, etc. Using it also enables to tap into, modify, or extend its internal behavior.
+
+:::caution
+Use only the API methods described in this docs. Use other methods under your own risk, and take into account that they may change in minor versions without considering it as a breaking change.
+:::
+
+## Constructor
+
+__`new Core([config], [advancedOptions])`__: Creates a new Mocks Server core instance. Read the [Javascript integrations](../integrations/javascript.md) for further info.
+  * `config` _(Object)_: Any of [Mocks Server core options](../configuration/options.md#core-options) or [plugins options](../configuration/options.md#plugin-options). Command line arguments, environment variables and configuration file options would override the values defined here.
+  * `advancedOptions` _(Object)_:
+    * `pkg` _(Object)_: Useful when creating custom distributions. It allows to define a different package name and version to check for updates. For example, the `@mocks-server/main` distribution provides its name and version to the core using this parameter, so when the core checks for updates, it uses these properties instead of its own.
+      * `name` _(String)_: Package name
+      * `version` _(String)_: Current package version
+
+```js
+const Core = require("@mocks-server/core");
+
+// highlight-next-line
+const core = new Core({
+  server: {
+    port: 3500
+  },
+});
+
+// highlight-next-line
+core.init().then(async () => {
+  // highlight-start
+  await core.start();
+  await core.stop();
+  // highlight-end
+});
+```
+
+:::warning
+The `Core` constructor is exported only by the `@mocks-server/core` package, and it doesn't include any pre-installed plugins, so you should [install them by yourself](../plugins/installation.md) if you choose this method for starting Mocks Server programmatically. Read the [next section](#creating-an-instance-with-pre-installed-plugins) for an alternative method of creating a core instance using the `@mocks-server/main` package, which includes pre-installed plugins and other optimal configuration to start it programmatically.
+:::
+
+### Creating an instance with pre-installed plugins
+
+The `@mocks-server/main` distribution includes some plugins providing useful integrations, such as the [Admin Api Plugin](../integrations/rest-api.md), etc. If you create a new server instance using the `@mocks-server/core` package as in the example above, you would have to [install your desired plugins](../plugins/installation.md) by your own (which may be useful to [create your own distribution](../integrations/javascript.md#creating-your-own-distribution), for example).
+
+Note also that the [default configuration](../configuration/options.md) of `@mocks-server/core` is intended to be used in CLI, so it tries to load files, read arguments and environment variables, etc. which might not be ideal to start it programmatically in Jest tests, for example.
+
+But it is also possible to create an instance with all `@mocks-server/main` distribution plugins and configuration optimized for a programmatic usage using the next function exported by the library:
+
+__`createServer([config])`__: Returns a new core instance. The `config` provided is merged with the default package config, which includes some pre-installed plugins and optimized configuration for a programmatic usage:
+  * It disables the files load. The scaffold is not created and routes and collections must have to be loaded using the JavaScript API.
+  * It disables loading configuration from file, environment variables or arguments. So, possible conflicts are avoided and all configuration has to be provided programmatically.
+  * It disables the interactive CLI plugin.
+
+```js
+const { createServer } = require("@mocks-server/main");
+const { routes, collections } = require("./fixtures");
+
+// highlight-next-line
+const core = createServer({
+  server: {
+    port: 3500
+  },
+});
+
+// highlight-next-line
+core.init().then(async () => {
+  // highlight-start
+  const { loadRoutes, loadCollections } = core.mock.createLoaders();
+  loadRoutes(routes);
+  loadCollections(collections);
+  
+  await core.start();
+  // highlight-end
+});
+```
+
+### Other ways of accessing to the core instance
+
+Apart from creating your own `core` instance programmatically, you can also use it from other system elements, because it is passed as an argument to them. Some elements to which the core instance is passed are:
+
+* __Plugins__: A plugin receives the core instance on its constructor and in all of its standardized methods. Read [plugins development](../plugins/development.md) for further info.
+* __Variant handlers__: A variant handler receives the core instance on its constructor. Read [variant handlers development](../variant-handlers/development.md) for further info.
+  * __middleware variants__: The core is passed from the `middleware` variant handler to the middleware functions defined in that type of variants. So, it can be used directly in Express middlewares. Read the [middleware variant chapter](../usage/variants/middleware.md) for further info.
+
+## API
+
+### init()
+
+__`core.init([config])`__: Register plugins, initialize options and prepare all other internal dependencies needed to start the server. Returns a promise. Accepts next arguments:
+  * `config` _(Object)_: Any of [Mocks Server options](../configuration/options.md#core-options) or [plugin options](../configuration/options.md#plugin-options). If provided, the config passed in the [constructor](#constructor) would be merged with this one. Command line arguments, environment variables and configuration file options would override the values defined here. Options are internally available using the [`core.config` API](./javascript/config.md) once they are initialized.
+
+### start()
+
+__`core.start()`__: Start the server and plugins. Returns a promise. It calls to the `init` method internally if it was not done before.
+
+### stop()
+
+__`core.stop()`__: Stop the server and plugins. Returns a promise.
+
+## Children objects APIs
+
+```mdx-code-block
+<DocCardList items={useCurrentSidebarCategory().items}/>
+```

versioned_docs/version-3.6.0/api/javascript/alerts.md

@@ -0,0 +1,98 @@
+---
+id: alerts
+title: core.alerts
+description: Methods of the core.alerts JavaScript API
+keywords:
+  - mocks server
+  - programmatic
+  - api
+  - core
+  - methods
+  - properties
+  - getters
+  - advanced usage
+  - JavaScript
+  - js
+  - node
+  - nodejs
+  - alerts
+---
+
+```mdx-code-block
+import ExampleDetails from '@site/src/components/ExampleDetails';
+```
+
+## Preface
+
+The `core.alerts` object provides access to methods related to Mocks Server alerts. Use alerts to inform the user about deprecated methods or other warning messages, or about current errors. For example, when an error happens loading files, the server adds automatically an alert in order to let the user know about the error.
+
+:::info
+Here are described only some methods of the `alerts` API, for further info please read the [`@mocks-server/nested-collections` docs](https://github.com/mocks-server/main/tree/master/packages/nested-collections/README.md), but take into account that in Mocks Server, the alerts `set` method is extended and supports passing a third `error` argument. 
+:::
+
+:::caution
+Use only the API methods described in this docs. Use other methods under your own risk, and take into account that they may change in minor versions without considering it as a breaking change.
+:::
+
+:::warning
+When the `core` is received in the plugin, you must use `core.alerts`, but when you are creating your own core instance programmatically, then you must use `core.alertsApi` instead. This was made in v3.2 due to backward compatibility reasons, and it will be fixed in next major version.
+:::
+
+## API
+
+:::caution
+When the core is passed to a plugin as a parameter, the `alerts` object is an `alerts` subcollection instead of the root `alerts` instance. The `alerts` subcollection is namespaced with the plugin id, so it is easy to trace where the alerts come from.
+:::
+
+### onChange()
+
+__`core.alerts.onChange(callback)`__: Add a callback to be executed when alerts change. Returns a function for removing the added callback.
+* `callback()` (Function): Function to be executed whenever alerts change.
+
+```mdx-code-block
+<ExampleDetails>
+```
+
+```js
+// Add event listener and store the method allowing to remove it
+// highlight-next-line
+const removeListener = core.alerts.onChange(() => {
+  console.log("Alerts have changed!");
+});
+
+// Remove event listener
+// highlight-next-line
+removeListener();
+```
+
+```mdx-code-block
+</ExampleDetails>
+```
+
+### set()
+
+__`core.alerts.set(id, message, error)`__: Adds an alert or modify it.
+* __`id`__ _(String)_: The id for the alert to be added or modified in case it already exists.
+* __`message`__ _(String)_: Message for the alert.
+* __`error`__ _(Error)_: Optional. Error causing the alert.
+
+### remove()
+
+__`core.alerts.remove(id)`__: Removes an alert.
+* __`id`__ _(String)_: Id of the alert to be removed.
+
+### clean()
+
+__`core.alerts.clean`__: Removes all alerts, including descendant collections.
+
+### collection()
+
+__`core.alerts.collection(id)`__: Allows to create a new subcollection of alerts or returns an already existent one. The returned collection will have all of the same methods described for `alerts`. It is useful to group alerts by its type. The `context` property of the alerts created in a child collection will include all parent collections ids joined with `:`, so the user can know the alert's "path".
+
+### flat
+
+__`core.alerts.flat`__: Returns all collection items and descendent collection items in a flat array. It adds a `collection` id to each item. For nested collections, the `id` is built with all parents ids and self id joined with `:`.
+
+### root
+
+__`core.alerts.root`__: Getter returning the root `alerts` object. It is useful when trying to access to the root Mocks Server alerts from a plugin, but use it with caution because you will be accessing to all of the elements alerts, not only to those owned by the plugin.