coveo.analytics 2.25.2 → 2.25.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +119 -136
- package/dist/coveoua.browser.js +1 -1
- package/dist/coveoua.debug.js +1 -1
- package/dist/coveoua.js +1 -1
- package/dist/definitions/src/client/location.d.ts +1 -0
- package/dist/definitions/version.d.ts +1 -1
- package/dist/library.es.js +1 -1
- package/dist/library.js +1 -1
- package/dist/react-native.es.js +1 -1
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -1,164 +1,182 @@
|
|
|
1
1
|
# 
|
|
2
2
|
|
|
3
3
|
[](https://travis-ci.org/coveo/coveo.analytics.js)
|
|
4
|
-
[](https://david-dm.org/coveo/coveo.analytics.js)
|
|
5
|
-
[](https://david-dm.org/coveo/coveo.analytics.js#info=devDependencies)
|
|
6
4
|
[](https://coveralls.io/github/coveo/coveo.analytics.js?branch=master)
|
|
7
5
|
[](https://github.com/ellerbrock/typescript-badges/)
|
|
8
6
|
|
|
9
|
-
|
|
7
|
+
# Coveo Analytics JavaScript client
|
|
10
8
|
|
|
11
|
-
|
|
9
|
+
The Coveo analytics javascript client, also called coveo.analytics.js or coveoua for short, is responsible for logging analytics events to the Coveo platform. Analytics events may include basic Coveo web events such as pageviews, clicks or searches. For specific usecases, such as commerce and service, dedicated events may be defined and logged.
|
|
12
10
|
|
|
13
|
-
|
|
14
|
-
- A code snippet to add in website pages
|
|
11
|
+
The analytics library is bundled with all Coveo provided UI components. Integrations which exclusively rely on these components, generally don't have to interact with coveoua directly. For Coveo integrations which integrate with an already existing UI and do not use headless, coveoua will be required to ensure events are logged correctly.
|
|
15
12
|
|
|
16
|
-
##
|
|
13
|
+
## Loading and initializing the library in the browser
|
|
17
14
|
|
|
18
|
-
|
|
15
|
+
In order to ensure the tracking code is available on your webpage, the following code snippet needs to be added to the top of each page on which analytics are required. This will load the latest major version of coveo.analytics.js from a Coveo CDN. As of writing, the current major version is 2.
|
|
19
16
|
|
|
20
|
-
|
|
17
|
+
```html
|
|
18
|
+
<script>
|
|
19
|
+
(function (c, o, v, e, O, u, a) {
|
|
20
|
+
a = 'coveoua';
|
|
21
|
+
c[a] =
|
|
22
|
+
c[a] ||
|
|
23
|
+
function () {
|
|
24
|
+
(c[a].q = c[a].q || []).push(arguments);
|
|
25
|
+
};
|
|
26
|
+
c[a].t = Date.now();
|
|
27
|
+
u = o.createElement(v);
|
|
28
|
+
u.async = 1;
|
|
29
|
+
u.src = e;
|
|
30
|
+
O = o.getElementsByTagName(v)[0];
|
|
31
|
+
O.parentNode.insertBefore(u, O);
|
|
32
|
+
})(window, document, 'script', 'https://static.cloud.coveo.com/coveo.analytics.js/2/coveoua.js');
|
|
33
|
+
</script>
|
|
21
34
|
|
|
22
|
-
|
|
35
|
+
coveoua('init', #COVEO_API_KEY); // Replace #COVEO_API_KEY with your api key
|
|
36
|
+
```
|
|
23
37
|
|
|
24
|
-
|
|
38
|
+
Since calls to the coveo analytics service need to be authenticated, the library needs to be initialized with a Coveo api key which has push access to the [Analytics Data Domain](https://docs.coveo.com/en/1707/cloud-v2-administrators/privilege-reference#analytics-data-domain). You can create an API key from the [administration console](https://platform.cloud.coveo.com/admin/#/organization/api-access/) selecting the **Push** option box for the **Analytics Data** domain (see [Adding and Managing API Keys](https://docs.coveo.com/en/1718/cloud-v2-administrators/adding-and-managing-api-keys)).
|
|
25
39
|
|
|
26
|
-
|
|
40
|
+
## Available actions
|
|
27
41
|
|
|
28
|
-
|
|
42
|
+
After the library has loaded sucessfully, you can interact with coveoua through the global `coveoua` function. Any interaction with the library happens through this function by supplying both a action name, followed by an optional series of action arguments. The following actions are available:
|
|
29
43
|
|
|
30
|
-
|
|
44
|
+
### Initialization
|
|
31
45
|
|
|
32
|
-
|
|
46
|
+
- `coveoua('version')`: Returns the current version of the tracking library.
|
|
47
|
+
- `coveoua('init', <COVEO_API_KEY>, <ENDPOINT>)`: Initializes the library with the given api key and endpoint. The following parameters are accepted
|
|
48
|
+
- COVEO_API_KEY (mandatory): A valid api key.
|
|
49
|
+
- ENDPOINT (optional): A string specifying the desired analytics endpoint. The default value is https://analytics.cloud.coveo.com/rest/ua. In case your organization is HIPAA enabled, you should override with https://analyticshipaa.cloud.coveo.com/rest/ua.
|
|
50
|
+
- `coveoua('init', <COVEO_API_KEY>, {endpoint: <ENDPOINT>, plugins: <PLUGINS>})`: Initializes the library with the given api key, endpoint and plugins. The following parameters are accepted
|
|
51
|
+
- COVEO_API_KEY (mandatory): A valid api key.
|
|
52
|
+
- ENDPOINT (optional): An object string specifying the desired analytics endpoint. The default value is https://analytics.cloud.coveo.com/rest/ua. In case your organization is HIPAA enabled, you should override with https://analyticshipaa.cloud.coveo.com/rest/ua.
|
|
53
|
+
- PLUGINS (optional): An array of known plugin names. See [plugins](#plugins) for more information.
|
|
54
|
+
- `coveoua('set', <NAME>, <VALUE>)`: Attempts to inject an attribute with given name and value on every logged event, overriding any existing value. Some payloads may reject attributes they do not support.
|
|
55
|
+
- `coveoua('set', <OBJECT>)`: Attempts to inject all attributes and values of the given object on every logged event, overriding any existing value. Some payloads may reject attributes they do not support.
|
|
56
|
+
- `coveoua('set', 'custom', <OBJECT>)`: Attempts to inject all attributes and values of the given object in the custom section of an object, overriding any existing value. Use this call to pass customer specific parameters on the payload.
|
|
57
|
+
- `coveoua('onLoad', <CALLBACK>)`: Calls the specified function immediately, library initialization is not required.
|
|
58
|
+
- `coveoua('reset')`: Resets the state of the logger to the state before initialization.
|
|
33
59
|
|
|
34
|
-
|
|
60
|
+
### Sending events
|
|
35
61
|
|
|
36
|
-
|
|
62
|
+
- `coveoua('send', <EVENT_NAME>, <EVENT_PAYLOAD>)`: Sends an event with a given name and payload to the analytics endpoint.
|
|
37
63
|
|
|
38
|
-
|
|
39
|
-
<script>
|
|
40
|
-
(function(c,o,v,e,O,u,a){
|
|
41
|
-
a='coveoua';c[a]=c[a]||function(){(c[a].q=c[a].q|| []).push(arguments)};
|
|
42
|
-
c[a].t=Date.now();u=o.createElement(v);u.async=1;u.src=e;
|
|
43
|
-
O=o.getElementsByTagName(v)[0];O.parentNode.insertBefore(u,O)
|
|
44
|
-
})(window,document,'script','https://static.cloud.coveo.com/coveo.analytics.js/2/coveoua.js')
|
|
45
|
-
// Replace "2" in the script url with the latest release
|
|
64
|
+
### Plugin control
|
|
46
65
|
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
contentIdValue: <PERMANENT_ID_VALUE>, // Replace <PERMANENT_ID_VALUE> with a unique value from your page.
|
|
51
|
-
contentType: 'product', // Optional
|
|
52
|
-
// ... more information ...
|
|
53
|
-
});
|
|
54
|
-
</script>
|
|
55
|
-
```
|
|
66
|
+
- `coveoua('provide', <PLUGIN_NAME>, <PLUGINCLASS>)`: Registers a given pluginClass with the analytics library under the provided name.
|
|
67
|
+
- `coveoua('require', <PLUGIN_NAME>)`: Explicitly loads the plugin with the given name.
|
|
68
|
+
- `coveoua('callPlugin', <PLUGIN_NAME>, <FUNCTION>, <PARAMS>)`: Executes the specified function with given arguments on the given plugin name. Can be shorthanded using a plugin action prefix `coveoua(<PLUGINNAME>:<FUNCTION>, <PARAMS>)`.
|
|
56
69
|
|
|
57
|
-
|
|
70
|
+
## Plugins
|
|
58
71
|
|
|
59
|
-
|
|
60
|
-
| -------------- | ------------------------------------------------------------------- |
|
|
61
|
-
| contentIdKey | The Coveo index field name that will be used to identify the item. |
|
|
62
|
-
| contentIdValue | The Coveo index field value that will be used to identify the item. |
|
|
63
|
-
| contentType | [Optional] The type of the item to be tracked (e.g., 'Article'). |
|
|
72
|
+
Coveoua is set up in a modular way with different plugins providing functionality that may be specific to a given usecase. This allows you to customize some of its behavior dynamically. By default, the following plugins are loaded at library initialization:
|
|
64
73
|
|
|
65
|
-
|
|
74
|
+
- `ec`: eCommerce plugin which takes care of sending eCommerce specific events.
|
|
75
|
+
- `svc`: Service plugin which takes care of sending customer service specific events.
|
|
66
76
|
|
|
67
|
-
|
|
77
|
+
Plugin actions extend the set of available actions. They can be executed either via the `callPlugin` action above, or via the shorthand. For example, to call the function `addImpression` on the `ec` plugin, you'd specify `coveoua('ec:addImpression', ...)`.
|
|
68
78
|
|
|
69
|
-
|
|
79
|
+
It is possible to disable loading of any plugins by explicitly initializing the library with an empty list of plugins using `coveoua('init', <API_KEY>, {plugins:[]})`.
|
|
70
80
|
|
|
71
|
-
|
|
81
|
+
## Sending basic usage analytics events
|
|
72
82
|
|
|
73
|
-
|
|
83
|
+
In most common integration usecases, you will be using Coveo pre-wired components (e.g. jsui, headless or atomic) to handle communication with the Coveo backend. These components have their own specific apis to handle event logging.
|
|
74
84
|
|
|
75
|
-
|
|
85
|
+
When you are not using any specific Coveo web component, you need to send these events payloads explicitly, use the `send` action to transmit an assembled payload to the usage analytics backend. See the [Usage Analytics Events](https://docs.coveo.com/en/2949/analyze-usage-data/usage-analytics-events) documentation for description of the payload contents. The following event types are supported in coveoua:
|
|
76
86
|
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
a='coveoua';c[a]=c[a]||function(){(c[a].q=c[a].q|| []).push(arguments)};
|
|
83
|
-
c[a].t=Date.now();u=o.createElement(v);u.async=1;u.src=e;
|
|
84
|
-
O=o.getElementsByTagName(v)[0];O.parentNode.insertBefore(u,O)
|
|
85
|
-
})(window,document,'script','https://static.cloud.coveo.com/coveo.analytics.js/2/coveoua.js') // Replace "2" in the script url with the latest release
|
|
86
|
-
coveoua('init', <COVEO_API_KEY>); // Replace <COVEO_API_KEY> with your real key
|
|
87
|
-
</script>
|
|
88
|
-
```
|
|
87
|
+
- `search`: sends a [client side search](https://docs.coveo.com/en/1502/build-a-search-ui/log-search-events) event.
|
|
88
|
+
- `click`: sends a [click event](https://docs.coveo.com/en/2064/build-a-search-ui/log-click-events).
|
|
89
|
+
- `view`: sends a [view event](https://docs.coveo.com/en/2651/build-a-search-ui/log-view-events).
|
|
90
|
+
- `custom`: sends a [custom event](https://docs.coveo.com/en/2650/build-a-search-ui/log-custom-events).
|
|
91
|
+
- `collect`: sends a [collect event](https://docs.coveo.com/en/l41i0031/build-a-search-ui/log-collect-events) payload. We strongly recommend you use the simplified api in the ecommerce plugin [to send these events instead](#sending-commerce-specific-events).
|
|
89
92
|
|
|
90
|
-
|
|
93
|
+
For example, in order to send a click event after a user has interacted with a Coveo provided result, first initialize the library with an api key and then send a click event with the appropriate payload. Refer to the [click event documentation](https://docs.coveo.com/en/2064/build-a-search-ui/log-click-events) for up to date information on event payloads.
|
|
91
94
|
|
|
92
95
|
```js
|
|
93
|
-
coveoua('send', 'click', {
|
|
96
|
+
coveoua('send', 'click', {...});
|
|
94
97
|
```
|
|
95
98
|
|
|
96
|
-
|
|
99
|
+
You should be able to observe the click event being transmitted to the Coveo backend at `https://analytics.cloud.coveo.com/rest/ua/click` in the Developer tool's **Network** tab of your browser of choice.
|
|
97
100
|
|
|
98
|
-
|
|
101
|
+
## Sending commerce specific events
|
|
99
102
|
|
|
100
|
-
|
|
103
|
+
Commerce specific events such as product selections, shopping cart modifications and transactions are sent to Coveo in the compact [collect protocol](https://docs.coveo.com/en/l41i0031/build-a-search-ui/log-collect-events). Rather than explicitly assembling these payloads by hand, the eCommerce plugin provides apis to assemble and transmit the payloads. There are two event names that are specific to the eCommerce plugin:
|
|
101
104
|
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
(function(c,o,v,e,O,u,a){
|
|
105
|
-
a='coveoua';c[a]=c[a]||function(){(c[a].q=c[a].q|| []).push(arguments)};
|
|
106
|
-
c[a].t=Date.now();u=o.createElement(v);u.async=1;u.src=e;
|
|
107
|
-
O=o.getElementsByTagName(v)[0];O.parentNode.insertBefore(u,O)
|
|
108
|
-
})(window,document,'script','https://static.cloud.coveo.com/coveo.analytics.js/2/coveoua.js') // Replace "2" in the script url with the latest release
|
|
109
|
-
coveoua('init', <COVEO_API_KEY>); // Replace <COVEO_API_KEY> with your real key
|
|
110
|
-
</script>
|
|
111
|
-
```
|
|
105
|
+
- `event`: A generic event, which has been assembled through different plugin actions.
|
|
106
|
+
- `pageview`: An ecommerce specific pageview event which is automatically populated with the current page context.
|
|
112
107
|
|
|
113
|
-
|
|
108
|
+
See the [Send an Event](https://docs.coveo.com/en/l3am0254/coveo-for-commerce/send-an-event) page for more information on the expected payloads for both of these.
|
|
114
109
|
|
|
115
|
-
|
|
110
|
+
The eCommerce plugin supports adding product data (`ec:addProduct`), product impression data (`ec:addImpression`) as well as setting the [appropriate event action](https://docs.coveo.com/en/l29e0540/coveo-for-commerce/commerce-events-reference#product-action-type-reference) through `ec:setAction`. These calls can be used in series to assemble different types of payloads:
|
|
111
|
+
|
|
112
|
+
- A [product detail view](https://docs.coveo.com/en/3188/coveo-for-commerce/commerce-data-health-implementation-guide#measuring-a-product-details-view)
|
|
113
|
+
- An [addition to the cart](https://docs.coveo.com/en/l3jg0266/coveo-for-commerce/measure-cart-page-events#measure-an-increase-in-item-quantity-in-cart)
|
|
114
|
+
- A [removal from the cart](https://docs.coveo.com/en/l3jg0266/coveo-for-commerce/measure-cart-page-events#measure-a-decrease-in-item-quantity-in-cart)
|
|
115
|
+
- A [cart purchase](https://docs.coveo.com/en/l39m0327/coveo-for-commerce/measure-a-purchase)
|
|
116
|
+
- An [event on a search-driven listing-page](https://docs.coveo.com/en/l41a1037/coveo-for-commerce/measure-events-on-a-listing-or-search-page)
|
|
117
|
+
|
|
118
|
+
As a sample, here is how an [addition to the cart interaction](https://docs.coveo.com/en/l3jg0266/coveo-for-commerce/measure-cart-page-events#measure-an-increase-in-item-quantity-in-cart) is measured:
|
|
119
|
+
|
|
120
|
+
1. First use the `ec:addProduct` action to include the [relevant product data](https://docs.coveo.com/en/l29e0540/coveo-for-commerce/commerce-events-reference#product-data-fields-reference) in the event you’re about to send
|
|
116
121
|
```js
|
|
117
122
|
coveoua('ec:addProduct', <PRODUCT_DATA>);
|
|
118
123
|
```
|
|
119
|
-
2. Then use the `ec:setAction`
|
|
124
|
+
2. Then use the `ec:setAction` action to specify that the [action done on this data](https://docs.coveo.com/en/l29e0540/coveo-for-commerce/commerce-events-reference#product-action-type-reference) is an addition to the cart.
|
|
120
125
|
```js
|
|
121
126
|
coveoua('ec:setAction', 'add');
|
|
122
127
|
```
|
|
123
|
-
3. Finally, use the `send`
|
|
128
|
+
3. Finally, use the `send` action to send the generic event to Coveo Usage Analytics. The payload is implicit in this case, and has been generated by the plugin.
|
|
124
129
|
```js
|
|
125
130
|
coveoua('send', 'event');
|
|
126
131
|
```
|
|
127
132
|
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
All supported actions are also listed in the [**Possible Actions** section of the **Tracking Commerce Events** page](https://docs.coveo.com/en/3188/coveo-solutions/tracking-commerce-events#possible-actions).
|
|
133
|
+
# Developer information
|
|
131
134
|
|
|
132
|
-
|
|
135
|
+
Information for contributors or Coveo developers developing or integrating coveoua.
|
|
133
136
|
|
|
134
|
-
|
|
137
|
+
## Setup
|
|
135
138
|
|
|
136
139
|
```bash
|
|
137
|
-
|
|
140
|
+
git clone
|
|
141
|
+
npm install
|
|
142
|
+
npm run build
|
|
138
143
|
```
|
|
139
144
|
|
|
140
|
-
|
|
141
|
-
import {CoveoAnalyticsClient} from 'coveo.analytics';
|
|
145
|
+
## Running and observing the code
|
|
142
146
|
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
147
|
+
There are two ways to run your code locally:
|
|
148
|
+
|
|
149
|
+
1. Run `npm run start` and open your browser on http://localhost:9001
|
|
150
|
+
|
|
151
|
+
2. Debugging through VSCode debugger with the `Debug: Start Debugging` command, using the `Launch Chrome` configuration.
|
|
152
|
+
|
|
153
|
+
To test out your changes, add `coveoua` function calls in the `public/index.html` file and check the payload in the `Developer Console` section of your browser.
|
|
154
|
+
|
|
155
|
+
## Running tests
|
|
152
156
|
|
|
153
|
-
|
|
157
|
+
1. From the command line through `npm run test`.
|
|
158
|
+
2. Debugging through VSCode debugger with the `Debug: Start Debugging` command, using the `Jest All` configuration.
|
|
154
159
|
|
|
155
|
-
|
|
156
|
-
|
|
160
|
+
## Storage and persistence
|
|
161
|
+
|
|
162
|
+
Coveo.analytics.js tracks interactions from the same browser client, through a client side provided uuid called a `clientId`. This clientId is initialized on first use and there are multiple options for persisting it's value:
|
|
163
|
+
|
|
164
|
+
- Cookie storage, which supports top level domain storage. This means that the clientId for a.foo.com will be identical to the one on b.foo.com.
|
|
165
|
+
- Local storage, which allows to store much more information client side, but has the drawback of not being able to access data across multiple top level domains.
|
|
166
|
+
- Session storage, which has roughly the same limitation and capability as Local storage, except that it is cleared when the web browser tab is closed.
|
|
167
|
+
|
|
168
|
+
By default, coveoua will use both local storage and cookie storage to persist its clientId. If your environment does not support local persistence, it's possible to write your own storage abstraction.
|
|
169
|
+
|
|
170
|
+
## Using coveo.analytics.js with React Native
|
|
171
|
+
|
|
172
|
+
Since React Native does not run inside a browser, it cannot use cookies or the local/session storage that modern browsers provide. You must provide your own Storage implementation. Thankfully, there exist multiple packages to store data:
|
|
157
173
|
|
|
158
174
|
- [React native community AsyncStorage](https://github.com/react-native-async-storage/async-storage) (recommended)
|
|
159
175
|
- [React native AsyncStorage](https://reactnative.dev/docs/asyncstorage) (deprecated)
|
|
160
176
|
- [Expo Secure Store](https://docs.expo.dev/versions/latest/sdk/securestore/)
|
|
161
177
|
|
|
178
|
+
A sample React native storage class implementation could look as follows
|
|
179
|
+
|
|
162
180
|
```js
|
|
163
181
|
import {CoveoAnalyticsClient, ReactNativeRuntime} from 'coveo.analytics/react-native';
|
|
164
182
|
// Use any React native storage library or implement your own.
|
|
@@ -177,7 +195,7 @@ class ReactNativeStorage implements WebStorage {
|
|
|
177
195
|
}
|
|
178
196
|
}
|
|
179
197
|
|
|
180
|
-
// Create an API client
|
|
198
|
+
// Create an API client with a specific runtime
|
|
181
199
|
const client = new CoveoAnalyticsClient({
|
|
182
200
|
token: 'YOUR_API_KEY',
|
|
183
201
|
runtimeEnvironment: new ReactNativeRuntime({
|
|
@@ -185,6 +203,7 @@ const client = new CoveoAnalyticsClient({
|
|
|
185
203
|
storage: new ReactNativeStorage(),
|
|
186
204
|
}),
|
|
187
205
|
});
|
|
206
|
+
|
|
188
207
|
// Send your event
|
|
189
208
|
client.sendCustomEvent({
|
|
190
209
|
eventType: 'dog',
|
|
@@ -193,47 +212,11 @@ client.sendCustomEvent({
|
|
|
193
212
|
});
|
|
194
213
|
```
|
|
195
214
|
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
There are 3 available storage types you can use to store view events client side.
|
|
199
|
-
|
|
200
|
-
- Cookie storage, which supports top level domain storage. This means that events from a.foo.com will be available from b.foo.com. Cookies have the limitation of not being able to store a lot of data, especially if your stored page views are long.
|
|
201
|
-
|
|
202
|
-
- Local storage, which allows to store much more information client side, but has the drawback of not being able to access data across multiple top level domains.
|
|
203
|
-
|
|
204
|
-
- Session storage, which has roughly the same limitation and capability as Local storage, except that it is cleared when the web browser tab is closed.
|
|
205
|
-
|
|
206
|
-
By default, the local storage option will automatically be chosen as the default storage, unless manually specified.
|
|
207
|
-
|
|
208
|
-
### Contributing
|
|
215
|
+
## Contributing
|
|
209
216
|
|
|
210
217
|
See [CONTRIBUTING.md](CONTRIBUTING.md)
|
|
211
218
|
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
```bash
|
|
215
|
-
git clone
|
|
216
|
-
npm install
|
|
217
|
-
npm run build
|
|
218
|
-
```
|
|
219
|
-
|
|
220
|
-
#### Running the project
|
|
221
|
-
|
|
222
|
-
There are two ways to run your code locally:
|
|
223
|
-
|
|
224
|
-
1. run `npm start` and open your browser on http://localhost:9001
|
|
225
|
-
|
|
226
|
-
2. run through VSCode debugger with the `Debug: Start Debugging` command, using the `Launch Chrome` configuration.
|
|
227
|
-
|
|
228
|
-
To test out your changes, add `coveoua` function calls in the `public/index.html` file and check the payload in the `Developer Console` section of your browser.
|
|
229
|
-
|
|
230
|
-
#### Running tests
|
|
231
|
-
|
|
232
|
-
```bash
|
|
233
|
-
npm run test
|
|
234
|
-
```
|
|
235
|
-
|
|
236
|
-
### License
|
|
219
|
+
## License
|
|
237
220
|
|
|
238
221
|
MIT license (see [LICENSE](LICENSE)).
|
|
239
222
|
|