open-index/open-npm huggingface dataset:
npm package: @sector-labs/lingui-multi
Description: Command line utility to compile multiple catalogs from a single js-lingui messages.json file.
Author: Ahmed Belal Hashmi
Latest version: 2.0.2

# Lingui Multi
[![CircleCI](https://circleci.com/gh/SectorLabs/lingui-multi/tree/master.svg?style=svg)](https://circleci.com/gh/SectorLabs/lingui-multi/tree/master)

This is a command line utility for generating multiple catalog files from a single (unified) messages JSON file using [js-lingui cli api](https://www.npmjs.com/package/@lingui/cli). Please ensure your application uses js-lingui before attempting to use this utility.

# Setup
Add the following to your project's package.json file:
```json
 "lingui-multi": {
    "sub_catalog_name": {
        "srcPathIgnorePatterns": [
            "<ignore_folder>",
            "<ignore_folder_2>"
            ...
        ]
    },
    "sub_catalog_2_name": {
        "srcPathIgnorePatterns": [
            "<ignore_folder_3>",
            "<ignore_folder_4>"
            ...
        ]
    }
 }
```

Each sub-catalog will include all the i18n translations used in the source paths defined for lingui in the package.json file minus the ignore patterns defined either in the lingui configuration, the lingui-multi sub-catalog configuration or in the environment variable named `LINGUI_MULTI_IGNORE_PATTERNS` (regular expression string, for example `"ignore_folder_2|ignore_folder_3"`).


**Note: Lingui multi requires your existing messages.json file to be in `minimal` format. If it is in any other format please convert to the minimal format before using this utility**

# Usage
You can extract new translations and metadata by executing the command provided by the package like so:
```shell
$ lingui-multi extract [path-to-application-package.json] [path-to-locale-directory]
```

The extract command will extract new messages/translations to your messages.json file as well as create a messages.metadata.json file that is used in translation include/exclude logic during the sub-catalog assembly in the compile command.

Sub-catalog compilation can be done by executing:
```shell
$ lingui-multi compile [path-to-application-package.json] [path-to-locale-directory]
```

The compile command uses messages.metadata.json file to figure out which translations to include/exclude from messages.json file based on the different sub-catalog configurations.

**Please do not edit the messages.metadata.json file manually. All your changes/additions to the translations must only be done in messages.json file. No changes or translations from messages.metadata.json file is carried over to the compiled JS catalogs.**

The default value for package.json path is: `./package.json`

The default value for locales directory is: `./locale`

The utility will pick up lingui configuration and lingui-multi configuration from the package.json file and spit out catalog files in the locale directory with the format `<sub_catalog>.messages.js` for each sub-catalog and a `messages.js` catalog with all translations excluding only those that are defined in the `lingui` settings in `package.json` file of the application.
npm package: @sector-labs/mini-manifest-webpack-plugin
Description: Generate a small manifest with all chunks.
Author: Sector Labs
Latest version: 2.0.1

# mini-manifest-webpack-plugin

[![License](https://img.shields.io/:license-mit-blue.svg)](http://doge.mit-license.org)
![lint](https://github.com/SectorLabs/mini-manifest-webpack-plugin/workflows/lint/badge.svg)

Modified version of `@loadable/webpack-plugin` that only keeps a minimal amount of stats such as preloaded chunks and mappings from bundle names to their real paths.

## Installation

    yarn add -D @sector-labs/mini-manifest-webpack-plugin

## Usage

    const MiniManifestPlugin = require("@sector-labs/mini-manifest-webpack-plugin");

    module.exports = {
        plugins: [
            new MiniManifestPlugin({
                filename: "stats.json",
            }),
       ],
    };
npm package: @sector-labs/postcss-inline-class
Description: Inline the declarations of other CSS classes in your CSS classes.
Author: Sector Labs
Latest version: 0.0.9

[![verify](https://github.com/SectorLabs/postcss-inline-class/actions/workflows/verify.yml/badge.svg)](https://github.com/SectorLabs/postcss-inline-class/actions/workflows/verify.yml)

# postcss-inline-class

A PostCSS plugin to inline CSS classes in other CSS classes using PostCSS.

## Installation

```
yarn add -D @sector-labs/postcss-inline-class
```

## Usage

Just add `postcss-inline-class` in the list of the PostCSS plugins

```js
plugins: [
    require('@sector-labs/postcss-inline-class')(),
]
```

## Resolving files

`postcss-inline-class` uses [resolve](https://github.com/browserify/resolve) under the hood to support file resolving.

```js
plugins: [
    require('@sector-labs/postcss-inline-class')({
        paths: [
            path.join(process.cwd(), '/theme/dark'),
            path.join(process.cwd(), '/theme/default'),
        ],
    }),
],
```

## Examples

### Minimal example

```css
.a {
    color: red;
}

.b {
    @inline .a;
    font-size: 14px;
}
```
becomes
```css
.a {
    color: red;
}

.b {
    color: red;
    font-size: 14px;
}
```

### Multiple blocks

```css
.a {
    color: red;
}

.a, .b {
    font-size: 14px
}

.c {
    @inline .a;
}
```
becomes
```css
.a {
    color: red;
}

.a, .b {
    font-size: 14px
}

.c {
    color: red;
    font-size: 14px;
}
```

### Different files

```css
/* foo.css */

.a {
    color: red;
}

/* bar.css */

.b {
    @inline .a from './foo.css';
    font-size: 14px;
}
```
becomes
```css
/* foo.css */

.a {
    color: red;
}

/* bar.css */

.b {
    color: red;
    font-size: 14px;
}
```

### Nested

```css
.foo + div.a {
    color: red;
}

.b {
    @inline .a;
    font-size: 14px;
}
```
becomes 
```css
.foo + div.a {
    color: red;
}

.b {
    font-size: 14px;
}

.foo + div.b {
    color: red;
}
```

### Media queries

```css
.a {
    color: red;
}

@media (min-width: 240px) {
    .a {
        color: green;
    }
}

.b {
    @inline .a;
    font-size: 14px;
}
```
becomes
```css
.a {
    color: red;
}

@media (min-width: 240px) {
    .a {
        color: green;
    }
}

.b {
    color: red;
    font-size: 14px;
}

@media (min-width: 240px) {
    .b {
        color: green;
    }
}
```
npm package: @sector-labs/postcss-to-rtl
Description: PostCSS plugin to convert CSS to RTL
Latest version: 0.1.1

# PostCSS to Rtl [![Build Status][ci-img]][ci]

[PostCSS] plugin to convert (left to right) CSS to RTL.

Enables projects that serve their CSS inlined in a style tag in the documents to build smaller, separate RTL and LTR CSS files for the LTR and RTL pages.

Use this instead of [postcss-inline-rtl] or other postcss pluging that produce
a big CSS files containing rules for both directions.

To get even smaller files, use [css-byebye] to further strip the rules with the wrong direction from the resulting CSS.

[PostCSS]: https://github.com/postcss/postcss
[ci-img]:  https://travis-ci.org/jakob101/postcss-inline-rtl.svg
[ci]:      https://travis-ci.org/jakob101/postcss-inline-rtl
[postcss-inline-rtl]: https://github.com/jakob101/postcss-inline-rtl
[css-byebye]: https://github.com/AoDev/css-byebye

## Recommendation
Always have a `dir="ltr"` or `dir="rtl"` in your HTML tag.

## Examples

```css
/*  Normal code */
.class {
  color: red;
}

/*  => no change */
```

```css
.class{
  border-left: 10px;
  color: red;
}

/*  Converts to: */
.class {
  border-right: 10px
  color: red;
}
```

## Usage

```js
postcss([ require('postcss-to-rtl') ])
```

## Cred
+1 for [rtlcss](https://github.com/MohammadYounes/rtlcss), [postcss-inline-rtl] as this wouldn't exist without these!

See [PostCSS] docs for examples for your environment.
npm package: @sector-labs/react-chartist-trends
Description: React component for @sector-labs/chartist-trends
Author: Sector Labs
Latest version: 1.0.1

# react-chartist-trends

Fork of [fraserxu/react-chartist](https://github.com/fraserxu/react-chartist). React component for [@sector-labs/chartist-trends](https://github.com/SectorLabs/chartist-trends).

## Changes from upstream

* Switched from `chartist` to `@sector-labs/chartist-trends`
* Prefixed unsafe lifecycle methods with `UNSAFE_`

## Install

```
npm install @sector-labs/react-chartist-trends
```

## License

MIT
npm package: @sector-labs/react-image-gallery
Description: React carousel image gallery component with thumbnail and mobile support
Author: Sector Labs
Latest version: 1.0.1

# react-image-gallery

Fork of [xiaolin/react-image-gallery](https://github.com/xiaolin/react-image-gallery). React carousel image gallery component with thumbnail and mobile support.

## Changes from upstream

* Fix crash when gallery is empty
* Add callback on items change
* Add support for not lazy-loading next image
* Improve swipe performance on mobile
* Fix resize handler not updating state with zero value
* Rename `componentWillReceiveProps` to `UNSAFE_componentWillReceiveProps`

## Install

```
npm install @sector-labs/react-image-gallery
```

## Usage

```jsx
import ImageGallery from '@sector-labs/react-image-gallery';

const images = [
  {
    original: 'https://example.com/image1.jpg',
    thumbnail: 'https://example.com/thumb1.jpg',
  },
  {
    original: 'https://example.com/image2.jpg',
    thumbnail: 'https://example.com/thumb2.jpg',
  },
];

<ImageGallery items={images} />
```

### Style import

```scss
@import "~@sector-labs/react-image-gallery/styles/scss/image-gallery.scss";
```

Or without icons:

```scss
@import "~@sector-labs/react-image-gallery/styles/scss/image-gallery-no-icon.scss";
```

## License

MIT
npm package: @sector-labs/react-redux-ab
Description: A simple A/B testing library for React and Redux that can work in any environment
Author: Mikaël Gourlaouen
Latest version: 1.3.0-sl.2

# react-redux-ab

**react-redux-ab** is a simple A/B testing library that stores the active variants in a reducer for easy access accross the whole application. It is universal, as it can run on the client side, browser side or any kind of application where redux can run.

[API docs](docs/api.md)

Compared to prior libraries (such as [](), it offers the following advantages:
- The availability in the store by default makes it possible to have one experiment with effects in several places in the application, even widely separated.
- Ability to A/B test not only visual elements but also anything that has access to the store. You can for instance A/B test async action creators for speed tests.
- Weighted variants out of the box. You can create an experiment with 4 variants but decide that one will be used by 60% of the traffic, one by 20% and the remaining two by 10% each.

## Basic client side use case

1. Create experiments and add them to the root reducer:

```javascript
import { combineReducers } from 'redux'
import { createExperiments } from 'react-redux-ab'

const rootReducer = combineReducers({
	/* Your stuff here */
	experiments: createExperiment(sb{
		'buttons': {
			variants: [
				{name: 'blue'},
				{name: 'red', weight: 5}
			]
		},
		'callToAction': {
			variants: [
				{name: 'original'},
				{name: 'suggestion1'},
				{name: 'suggestion2'}
			]
		}
	})
})
```

2. Load them from the cookies at laod time (use any cookie library you want, we love [js-cookie](https://github.com/js-cookie/js-cookie) but you can use any other function that returns a dictionnaries of all key/values in the cookies:

```javascript
import { createStore } from 'redux'
import { digestCookies } from 'react-redux-ab'
import Cookies from 'js-cookie'
import rootReducer from './reducer'

const initalState = {
	experiments: digestCookies(Cookies.get())
}
const store = createStore(rootReducer, initialState)
```

3. Connect the cookie updater to the store:

```javascript
import { bakeCookies } from 'react-redux-ab'
import Cookies from 'js-cookie'
store.subscribe(() => {
	bakeCookies(store.getState(), Cookies.set)
})
```


4. Use experiments in your components:

```jsx
import React from 'react'
import { Experiment, Variant } from 'react-redux-ab'

export default function MyApp (props) {
	return <Experiment name="callToAction">
			<Variant name="original">
				<button>Boring button</button>
			</Variant>
			<Variant name="suggestion2">
				<a href="#">Awesome link</a>
			</Variant>
		</Experiment>
}
```

## Recipes
- [Use react-redux-ab on the server side](docs/recipes/serverside.md)

Check out more details on parameters and possibilities in the [API docs](docs/api.md)
npm package: @sector-labs/react-swipeable
Description: Swipe bindings for react
Author: Sector Labs
Latest version: 5.0.0

# react-swipeable

Fork of [dogfessional/react-swipeable](https://github.com/dogfessional/react-swipeable). Swipe bindings for React.

## Changes from upstream

* Fix `preventDefault` timing to prevent unwanted scrolling during swipe on non-Chrome mobile browsers and iOS

## Install

```
npm install @sector-labs/react-swipeable
```

## Usage

```js
import Swipeable from '@sector-labs/react-swipeable'

class SwipeComponent extends React.Component {
  render() {
    return (
      <Swipeable
        onSwiping={(e, deltaX, deltaY) => console.log('Swiping...', deltaX, deltaY)}
        onSwiped={(e, deltaX, deltaY, isFlick) => console.log('Swiped', deltaX, deltaY)}
        onSwipedLeft={(e, absX) => console.log('Swiped left', absX)}>
        You can swipe here!
      </Swipeable>
    )
  }
}
```

## Props

### Event Props

| Prop | Signature |
|------|-----------|
| `onSwiping` | `(e, deltaX, deltaY, absX, absY, velocity)` |
| `onSwiped` | `(e, deltaX, deltaY, isFlick, velocity)` |
| `onSwipingUp/Right/Down/Left` | `(e, delta)` |
| `onSwipedUp/Right/Down/Left` | `(e, delta, isFlick)` |
| `onTap` | `(e)` |

### Config Props

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `flickThreshold` | `number` | `0.6` | Max velocity before considered a flick |
| `delta` | `number` | `10` | px threshold before firing events |
| `preventDefaultTouchmoveEvent` | `bool` | `false` | Prevent browser touchmove |
| `stopPropagation` | `bool` | `false` | Stop event propagation |
| `nodeName` | `string` | `'div'` | HTML element to render |
| `trackMouse` | `bool` | `false` | Track mouse swipes |
| `disabled` | `bool` | `false` | Disable swipe tracking |
| `innerRef` | `func` | — | Access inner DOM node ref |
| `rotationAngle` | `number` | `0` | Rotation angle for swipe direction |

## License

MIT
npm package: @sector-labs/redux-batched-subscribe
Description: redux store enhancer which allows batching subscribe notifications.
Author: Terry Appleby
Latest version: 0.1.7-sl

redux-batched-subscribe
=====================

[![build status](https://img.shields.io/travis/tappleby/redux-batched-subscribe/master.svg?style=flat-square)](https://travis-ci.org/tappleby/redux-batched-subscribe)
[![npm version](https://img.shields.io/npm/v/redux-batched-subscribe.svg?style=flat-square)](https://www.npmjs.com/package/redux-batched-subscribe)

Store enhancer for [redux](https://github.com/rackt/redux) which allows batching of subscribe notifications that occur as a result of dispatches.

```js
npm install --save redux-batched-subscribe
```

## Usage

The `batchedSubscribe` store enhancer accepts a function which is called after every dispatch with a `notify` callback as a single argument. Calling the `notify` callback will trigger all the subscription handlers, this gives you the ability to use various techniques to delay subscription notifications such as: debouncing, React batched updates or requestAnimationFrame.

Since `batchedSubscribe` overloads the dispatch and subscribe handlers on the original redux store it is important that it gets applied before any other store enhancers or middleware that depend on these functions; The [compose](https://github.com/rackt/redux/blob/master/docs/api/compose.md) utility in redux can be used to handle this:

```js
import { createStore, applyMiddleware, compose } from 'redux';
import { batchedSubscribe } from 'redux-batched-subscribe';

const enhancer = compose(
  applyMiddleware(...middleware),
  batchedSubscribe((notify) => {
    notify();
  })
)

// Note: passing enhancer as the last argument to createStore requires redux@>=3.1.0
const store = createStore(reducer, initialState, enhancer);
```

*Note: since `compose` applies functions from right to left, `batchedSubscribe` should appear at the end of the chain.*

The store enhancer also exposes a `subscribeImmediate` method which allows for unbatched subscribe notifications.

## Examples

### Debounced subscribe handlers:

```js
import { createStore } from 'redux';
import { batchedSubscribe } from 'redux-batched-subscribe';
import debounce from 'lodash.debounce';

const debounceNotify = debounce(notify => notify());
// Note: passing batchedSubscribe as the last argument to createStore requires redux@>=3.1.0
const store = createStore(reducer, intialState, batchedSubscribe(debounceNotify));
```

### React batched updates

```js
import { createStore } from 'redux';
import { batchedSubscribe } from 'redux-batched-subscribe';

// React >= 0.14
import { unstable_batchedUpdates } from 'react-dom';

// Note: passing batchedSubscribe as the last argument to createStore requires redux@>=3.1.0
const store = createStore(reducer, intialState, batchedSubscribe(unstable_batchedUpdates));
```

## Thanks

Thanks to [Andrew Clark](https://github.com/acdlite) for the clean library structure.
npm package: @sector-labs/seo-slip
Description: Catches SEO regressions by sampling and checking a website against a set of rules
Author: Cristi Ingineru
Latest version: 1.0.9

[![CircleCI](https://circleci.com/gh/SectorLabs/seo-slip/tree/master.svg?style=svg)](https://circleci.com/gh/SectorLabs/seo-slip/tree/master)

# About

## What this is

-   A library to be used on writing tests to prevent SEO regression
-   An extensible collection of customizable checkers for SEO
-   A simple crawler that can be used to sample a website

## What this isn't

-   GUI tool for SEO
-   SEO general purpose checker or hint provider
-   An in-depth crawler or exhaustive analyzer

## Who is expected to use it

-   Software engineers
-   Automation testers
-   SEO specialists with medium JS and RegExp experience

# Simple example

```javascript
const { statusCodeChecker } = require('@sector-labs/seo-slip').checkers;
const { crawlPath } = require('@sector-labs/seo-slip').crawler;

const statusCodeRules = {
    code: 200,
    exceptions: {
        '/': 301,
        '/agents/': 301,
        '/new-projects': 301,
        '/mybayut': 301,
    },
};
const checkers = [
    statusCodeChecker(statusCodeRules),
];

const fullPath = 'https://www.bayut.com';
const maxDepth = 2;
const crawlerVariables = {};
crawlPath(fullPath, maxDepth, crawlerVariables, checkers, (results) => {
    results.messages.forEach(message => console.log(message));
});
```

# Complex example

See how this library is used for a real website [here](https://github.com/SectorLabs/bayut-seo-slip)

# Documentation

See documentation [here](DOCUMENTATION.md)
npm package: @sector-labs/wdio-junit-reporter
Description: A WebdriverIO reporter that creates Jenkins compatible XML based JUnit reports
Author: Sector Labs
Latest version: 10.0.0

# wdio-junit-reporter

Fork of [@wdio/junit-reporter](https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-junit-reporter). A WebdriverIO reporter that creates Jenkins compatible XML based JUnit reports.

## Changes from upstream

* Add GitHub repo link and step names for test cases
* Add validator script for XML consistency checking
* Update to v9

## Installation

```
npm install @sector-labs/wdio-junit-reporter
```

Import the reporter class directly in your wdio config instead of using the `'junit'` string shorthand:

```js
import JunitReporter from '@sector-labs/wdio-junit-reporter'
```

## Development

Source lives in `src/`, compiled output goes to `build/` via TypeScript.

The `build/` folder is committed to the repo because this package is installed via git URL. Yarn/npm do not reliably run the `prepare` script for git dependencies, so the compiled output must be checked in.

**After making changes to `src/`:**

```sh
npm run build
git add build/ src/
git commit
git push
```

### Validating XML output with `normalize-results.js`

Every time the reporter is updated, verify the XML output is still consistent:

```sh
node normalize-results.js old-results/ > old.txt
node normalize-results.js new-results/ > new.txt
diff old.txt new.txt
```

The script extracts every test case from all XML files in a directory, normalizes them into a canonical sorted format, and outputs a deterministic text file.

**To pick up changes in the consuming repo:**

```sh
yarn upgrade wdio-junit-reporter
```

## Configuration

```js
import JunitReporter from '@sector-labs/wdio-junit-reporter'

// wdio.conf.js
module.exports = {
    reporters: [
        'dot',
        [JunitReporter, {
            outputDir: './',
            outputFileFormat: function(options) {
                return `results-${options.cid}.${options.capabilities}.xml`
            }
        }]
    ],
};
```

### Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `outputDir` | `String` | required | Directory for XML files |
| `outputFileFormat` | `Function` | — | Custom filename function |
| `suiteNameFormat` | `Regex` | `/[^a-zA-Z0-9@]+/` | Regex for formatting suite names |
| `addFileAttribute` | `Boolean` | `false` | Add file attribute to each testcase |
| `packageName` | `String` | — | Break out packages by additional level |
| `errorOptions` | `Object` | `{ error: "message" }` | Error notification mapping |

## License

MIT
npm package: @sector-labs/webpack-fallback-directory-resolver-plugin
Description: Webpack Resolver plugin to resolve modules and files through a fallback chain at compile time.
Author: Sector Labs
Latest version: 2.0.1

# webpack-fallback-directory-resolver-plugin

Fork of [kije/webpack-fallback-directory-resolver-plugin](https://github.com/kije/webpack-fallback-directory-resolver-plugin). Webpack resolver plugin to resolve modules and files through a fallback directory chain at compile time.

## Changes from upstream

* Correct `Object.assign` usage for copying default options
* Add support for Webpack v5

## Install

```
npm install @sector-labs/webpack-fallback-directory-resolver-plugin
```

## Usage

Add the plugin to the `resolve.plugins` array in your `webpack.config.js`:

```js
const FallbackDirectoryResolverPlugin = require('@sector-labs/webpack-fallback-directory-resolver-plugin');
const path = require('path');

module.exports = {
    resolve: {
        plugins: [
            new FallbackDirectoryResolverPlugin({
                prefix: 'fallback',
                directories: [
                    path.resolve(__dirname, 'js/dir2'),
                    path.resolve(__dirname, 'js/dir1')
                ]
            })
        ]
    }
};
```

Import paths use the `#<prefix>#/` format:

```js
import something from "#fallback#/my-module";
```

### Options

| Option | Default | Description |
|--------|---------|-------------|
| `prefix` | `"fallback"` | Prefix used in import paths (`#<prefix>#/...`) |
| `directories` | `[]` | Array of directory paths to search in order |
| `extensions` | `[]` | File extensions to resolve automatically (e.g. `['.js', '.jsx']`) |
| `getRegex` | `` (prefix) => `^#${prefix}#/` `` | Custom function to generate the matching regex |

## License

MIT
npm package: @sector/babel-plugin-package-import
Description: Babel plugin to rewrite package imports from their package name to their resolved `web_modules` URL. Uses the `import-map.json` file contained in each `web_modules/` directory to map each package.
Latest version: 0.3.1

# @sector/babel-plugin-package-import

Babel plugin to rewrite package imports from their package name to their
resolved `web_modules` URL. Uses the `import-map.json` file contained in each
`web_modules/` directory to map each package.

```
npm install --save-dev @sector/babel-plugin-package-import
```

```js
// babel.config.json / .babelrc
"plugins": [["@sector/babel-plugin-package-import", { /* options */ }]]
```

## Plugin Options

> Note: All config options are optional.

- `webModulesUrl`: The hosted URL path reference for web_modules imports. Can
  be:
  - An absolute path ("/web_modules"). This is the default.
  - An absolute URL ("https://foobar.com/web_modules/")
  - A relative path prefix ("./web_modules", "../web_modules"). NOTE: Relative
    paths are relative from the current working directory / Babel's "root".
- `webModulesDir`: The web_modules installed location on disk. Can be an
  absolute path, or relative to the current working directory.
  - Defaults to "\${cwd}/web_modules".
- `importMap`: The name/location of the "import-map.json" file generated by
  Breadbox.
  - Defaults to "\${webModulesDir}/import-map.json".
- `moduleResolution`: Control how the plugin rewrites relative/local imports.
  Defaults to "none".
  - `"none"`: Leave relative imports untouched.
  - `"node"`: Rewrite all relative paths to use node's built-in resolution,
    resolving things like missing file extensions and directory imports. This is
    useful to assist migrating an older, bundled project to Breadbox.
- `ignore`: Array of import specifiers to ignore and leave untouched / bare.
npm package: @sector/breadbox
Description: Pre-bundle npm modules for ESM use in the browser
Latest version: 0.0.4

<p align="center">
  <img alt="Logo" src="./img/logo.png" height="240">
</p>

<p align="center">
   <strong>Breadbox</strong><br/> Build web applications with less tooling. No bundler required.
</p>

```bash
npm install --save-dev @sector/breadbox
```

1. Instead of bundling on every change, just run Breadbox **once** right after
   `npm install`.
2. Breadbox re-installs your dependencies as single JS files to a new
   `web_modules/` directory.
npm package: @sector/toast
Description: The best place to Stack your JAM
Author: Christopher Biscardi
Latest version: 0.0.4

# toast

The best place to Stack your JAM

[![Version](https://img.shields.io/npm/v/toast.svg)](https://npmjs.org/package/toast)

<!-- toc -->

- [toast](#toast)
- [Usage](#usage)
- [Commands](#commands)
  <!-- tocstop -->

# Usage

<!-- usage -->

```sh-session
$ npm install -g @sector/toast
$ toast COMMAND
running command...
$ toast (-v|--version|version)
@sector/toast/0.0.1 darwin-x64 node-v11.15.0
$ toast --help [COMMAND]
USAGE
  $ toast COMMAND
...
```

<!-- usagestop -->

# Commands

<!-- commands -->

- [`toast bake`](#toast-bake)
- [`toast chai`](#toast-chai)
- [`toast help [COMMAND]`](#toast-help-command)
- [`toast incremental`](#toast-incremental)
- [`toast shake`](#toast-shake)

## `toast bake`

Bake your application

```
USAGE
  $ toast bake

DESCRIPTION
  * Don't bundle
  * Render HTML
```

_See code:
[src/commands/bake.js](https://github.com/ChristopherBiscardi/toast/blob/v0.0.1/src/commands/bake.js)_

## `toast chai`

Brew some chai and get developing.

```
USAGE
  $ toast chai

DESCRIPTION
  * watches files, does stuff
```

_See code:
[src/commands/chai.js](https://github.com/ChristopherBiscardi/toast/blob/v0.0.1/src/commands/chai.js)_

## `toast help [COMMAND]`

display help for toast

```
USAGE
  $ toast help [COMMAND]

ARGUMENTS
  COMMAND  command to show help for

OPTIONS
  --all  see all commands in CLI
```

_See code:
[@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v2.2.3/src/commands/help.ts)_

## `toast incremental`

Incremental your application

```
USAGE
  $ toast incremental

DESCRIPTION
  * Don't bundle
  * Render HTML
```

_See code:
[src/commands/incremental.js](https://github.com/ChristopherBiscardi/toast/blob/v0.0.1/src/commands/incremental.js)_

## `toast shake`

The part before the bake.

```
USAGE
  $ toast shake

DESCRIPTION
  * Fetch data
  * Prepare dependencies (run snowpack)
```

_See code:
[src/commands/shake.js](https://github.com/ChristopherBiscardi/toast/blob/v0.0.1/src/commands/shake.js)_

<!-- commandsstop -->
npm package: @secture/adonis-apollo-server
Description: Production-ready Node.js GraphQL server for AdonisJS
Author: Chimezie Enyinnaya
Latest version: 1.0.3

# adonis-apollo-server

This package integrates Apollo GraphQL Server with the AdonisJS framework. It allows you to use Apollo server in your AdoinsJS app.

> **NOTE:** This package requires [@adonisjs/bodyparser](https://github.com/adonisjs/adonis-bodyparser)

## Installation

```bash
adonis install adonis-apollo-server
```

### Registering provider

Make sure to register the provider inside `start/app.js` file.

```js
const providers = [
    'adonis-apollo-server/providers/ApolloServerProvider'
]
```

That's all!

## Usage

Now you can use the provider by pulling it from IoC container

```js
// start/routes.js

'use strict'

const Route = use('Route')
const ApolloServer = use('ApolloServer')
const { makeExecutableSchema } = require('graphql-tools')

const typeDefs = `
    type Query {
        testString: String
    }
`

const resolvers = {
    Query: {
        testString () {
            return 'Seems to be working!'
        }
    }
}

const schema = makeExecutableSchema({ typeDefs, resolvers })

Route.route('/graphql', ({ request, response }) => {
    return ApolloServer.graphql({ schema }, request, response)
}, ['GET', 'POST'])

Route.get('/graphiql', ({ request, response }) => {
    return ApolloServer.graphiql({ endpointURL: '/graphql' }, request, response)
})
```
npm package: @secture/exponea-client
Description: client for the exponea API
Author: Secture
Latest version: 1.0.23

# 💬🎥 exponea-client
client for exponea API.

## Usage

### Import
```
const { ExponeaAPI } = require("exponea-client");

// or

import { ExponeaAPI } from "exponea-client";
```

### Create an instance
```
const api = new ExponeaAPI(
    "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "api-key",
    "api-secfret"
);

```

### Methods (WIP)
- getSystemTime
```
const response = await api.getSystemTime();

// 1655825898.9565847
```
- updateCustomerProperties
- addEvent
```
const eventResponse = await api.addEvent({
    customer_ids: {
        email: "test@email.com"
    },
    properties: {
        valid_until: new Date(2022, 12, 31).toString(),
        action: "accept",
        category: "brand",
        source: "web",
    },
    timestamp: new Date().getTime(),
    event_type: "consent",
});
```
- batchCommand
- retrieveCustomerAttributes
- exporAlltCustomer
- exportCustomer
- exportEvent