open-index/open-npm huggingface dataset:
npm package: @monolayer/cli
Description: monolayer CLI
Author: Marcos Essindi
Latest version: 1.0.4

# Monolayer CLI

Command-line interface for Monolayer control plane operations.

Documentation: https://monolayer.dev/docs/cli/overview

Current command surface:

- `projects:list`
- `deployments:deploy`

## Install

```bash
npm install -g @monolayer/cli
```

Or run without global install:

```bash
npx @monolayer/cli@latest --help
```

## Quick Start

Set your control plane URL:

```bash
export MONOLAYER_BASE_URL="https://control-plane-domain"
```

List projects:

```bash
export MONOLAYER_AUTH_TOKEN="token_xxx"
mnlyr projects:list --limit 10
```

Trigger a deployment:

```bash
export MONOLAYER_DEPLOYMENT_TOKEN="deploy_token_xxx"
mnlyr deployments:deploy --project-id proj-1 --branch-name main
```

## Configuration

Base URL:

- `--base-url`
- `MONOLAYER_BASE_URL`

Auth token (`projects:list`):

- `--auth-token`
- `MONOLAYER_AUTH_TOKEN`

Deployment token (`deployments:deploy`):

- `--auth-token`
- `MONOLAYER_DEPLOYMENT_TOKEN`
- must start with `deploy_token_`

## Commands

### `projects:list`

Lists projects with cursor-based pagination.

Flags:

- `--base-url <url>`
- `--auth-token <token>`
- `--cursor <cursor>`
- `--limit <n>` (default: `50`)

Output:

- JSON to stdout

Example:

```bash
mnlyr projects:list --base-url https://control-plane-domain --auth-token token_xxx --limit 10
```

### `deployments:deploy`

Triggers a deployment and streams status/log updates.

Flags:

- `--base-url <url>`
- `--auth-token <deploy_token_...>`
- `--project-id <id>` (required)
- `--branch-name <name>` (optional; defaults to current git branch)
- `--poll-interval-ms <n>` (default: `2000`)

Behavior:

- rejects branch names with `refs/heads/` or `branch/` prefixes
- uses incremental polling (`x-next-since`)
- suppresses blank log lines
- exits non-zero when deployment reaches `Failed`

Example:

```bash
mnlyr deployments:deploy \
  --base-url https://control-plane-domain \
  --auth-token deploy_token_xxx \
  --project-id proj-1 \
  --branch-name main
```

## Help

```bash
mnlyr --help
mnlyr projects:list --help
mnlyr deployments:deploy --help
```

## Contributing

For maintainer and development workflow details, see [DEVELOPMENT_GUIDE.md](./DEVELOPMENT_GUIDE.md).

## License

MIT
npm package: @monolayer/create-pg
Description: Create monolayer-pg inside a project
Author: Marcos Essindi
Latest version: 2.0.0

# Welcome to monolayer-pg

[monolayer-pg](https://monolayer.github.io/pg-docs/) is a [PostgreSQL](https://www.postgresql.org) database schema manager for [TypeScript](https://www.typescriptlang.org) projects built on top of [`kysely`](https://kysely.dev) with:

- Declarative, type-safe database schema definition.
- Schema management without migrations.
- Type-safe database client(s) for [`kysely`](https://kysely.dev) (no *codegen* :tada:).
- Data migrations decoupled from your schema management.
- Support for multiple databases.
- Support for multiple schemas per database.
- Effortless [`Prisma`](https://www.prisma.io) integration.
- Comprehensive [Zod](https://zod.dev) validations for all supported data types (no *codegen* :tada:) for [`kysely`](https://kysely.dev).

To get started, open a new shell and run:

```sh
npx @monolayer/create-pg@latest
```

Then follow the prompts you see in your terminal.
npm package: @monolayer/create-workloads
Description: Create @monolayer/workloads inside a project
Author: Marcos Essindi
Latest version: 1.0.0-prerelease-4

# @monolayer/create-workloads

To get started, open a new shell and run:

```sh
npx @monolayer/create-workloads@latest
```

Then follow the prompts you see in your terminal.
npm package: @monolayer/dsdk
Description: TypeScript SDK interact with the Docker Engine API
Author: Marcos Essindi
Latest version: 1.0.1

# DSDK

`DSDK` is a type-safe SDK you can use to access the Docker Engine API.

## Quick start

### Installation

```bash
npm install @monolayer/dsdk
```

### Configuration

`DSDK` will access the Docker Engine API by connecting to the Docker daemon of your choice.

All you need to do is to configure `DSDK` to use an existing [Docker context](https://docs.docker.com/engine/manage-resources/contexts/) with [setContext](https://monolayer.dev/dsdk-docs/reference/api/config/functions/setContext.html#function-setcontext).

```ts
import { setContext } from "@monolayer/dsdk/config";

// Will use credentials from the default Docker context
await setContext("default");
```

:tada: That's it. You're ready to go!

::: info
`DSDK` supports Unix sockets and SSH connections.

You have can interact with Docker Engine API endpoints except:

- /_ping
- /session
:::

See selected [examples](https://monolayer.dev/dsdk-docs/guide/examples.html) to interact with the Docker Engine API.

## Debug API calls

To debug API calls, set the environment variable `DEBUG` to `trace`.

\
Full documentation is available here: [DSDK Documentation](https://monolayer.dev/dsdk-docs/)
npm package: @monolayer/dw
Description: Write Dockerfiles programatically.
Author: Marcos Essindi
Latest version: 1.1.1

# Dockerfile Writer

Write Dockerfiles in TypeScript.

Docs are [here](https://monolayer.github.io/dw-docs/).

## Installation

```bash
npm install @monolayer/dw
```

## Writing Dockerfiles

```ts
import { Dockerfile } from "@monolayer/dw";

const df = new Dockerfile();

df.banner("App image");

df.FROM("node:20-alpine", { as: "runner" })

df.comment(
  "Add libc6-compat package (required for use of process.dlopen)",
);
df.RUN("apk add --no-cache gcompat=1.1.0-r4");

df.WORKDIR("/app");

df.group(() => {
  df.COPY("index.js, "./")
  df.COPY("index.js.map, "./")
});

df.ENV("NODE_ENV", "production");

df.CMD(["index.js"]);

df.blank()

df.ENTRYPOINT("node");

df.save("./app.Dockerfile");
```
npm package: @monolayer/pg
Description: Database schema management for PostgreSQL
Author: Marcos Essindi
Latest version: 2.0.0-beta.1

# Welcome to monolayer-pg

[monolayer-pg](https://monolayer.github.io/pg-docs/) is a [PostgreSQL](https://www.postgresql.org) database schema manager for [TypeScript](https://www.typescriptlang.org) projects built on top of [`kysely`](https://kysely.dev) with:

- Declarative, type-safe database schema definition.
- Schema management without migrations.
- Type-safe database client(s) for [`kysely`](https://kysely.dev) (no *codegen* :tada:).
- Data migrations decoupled from your schema management.
- Support for multiple databases.
- Support for multiple schemas per database.
- Effortless [`Prisma`](https://www.prisma.io) integration.
- Comprehensive [Zod](https://zod.dev) validations for all supported data types (no *codegen* :tada:) for [`kysely`](https://kysely.dev).

## Documentation

For documentation about monolayer-pg, please visit our [website](https://monolayer.github.io/pg-docs/).
npm package: @monolayer/sdk
Description: Build and deploy full-stack applications with zero infrastructure overhead.
Author: Marcos Essindi
Latest version: 1.2.3

<!-- markdownlint-disable MD033 -->
<!-- markdownlint-disable MD001 -->
# Workloads

Build and deploy full-stack applications with zero infrastructure overhead.
Use the sdk alongside your full-stack React framework, such as [Next.js](https://nextjs.org).

## Features

#### Stateful and stateless workloads

Define and run locally a diverse set of workloads for your web application.

- Stateful: Databases, key value stores, object storage, etc.
- Stateless: Scheduled tasks, cron jobs, real-time server-browser communication.

#### A Dev Environment That Just Works

Spin up dev and test environments for your workloads with zero-config.

Spend less time configuring and more time coding.

## Documentation

Documentation is [here](https://monolayer.dev/sdk-docs/).
npm package: @monolayer/task-bullmq-adapter
Description: BullMQ adapter for tasks workloads (@monolayer/workloads)
Author: Marcos Essindi
Latest version: 1.0.0-pre-4

# task-bullmq-adapter

BullMQ adapter for task workloads from `@monolayer/workloads`.

## Requirements

- `@monolayer/workloads` package.
- Redis server.

## Usage

- Add package

  ```bash
  npm install @monolayer/task-bullmq-adapter
  ```

- Set `MONO_TASK_MODE` environment variable to `bull`

  ```bash
  export MONO_TASK_MODE=bull
  ```

- Set `MONO_TASK_REDIS_URL` environment variable with the Redis instance connection string

  ```bash
  export MONO_TASK_REDIS_URL=redis-connection-string
  ```

### Dispatcher

Run your application with the task workload.

### Worker

Wrap your task in a worker script.

```js
import { Worker } from "@monolayer/task-bullmq-adapter";
import task from "/path/to/task.js" // Build output from workloads build

new Worker(task.default);
```

You can stop the worker with:

```js
worker.stop()
```
npm package: @monolayer/task-sqs-adapter
Description: SQS adapter for tasks workloads (@monolayer/workloads)
Author: Marcos Essindi
Latest version: 1.0.0-pre-19

# task-sqs-adapter

AWS SQS adapter for task workloads from `@monolayer/workloads`.

## Requirements

- `@monolayer/workloads` package.
- Redis server.

## Usage

- Add package

  ```bash
  npm install @monolayer/task-sqs-adapter
  ```

### Dispatcher

- Set `TASK_DISPATCHER` environment variable to `@monolayer/task-sqs-adapter`

  ```bash
  export TASK_DISPATCHER="@monolayer/task-sqs-adapter"
  ```

- Set the environment variable with the SQS queue URL associated with the task.

  For a task with the following id: `send-email`:

  ```bash
  export ML_TASK_SEND_EMAIL_SQS_QUEUE_URL=sqs-queue-url
  ```

  Each task has a unique environment variable associated with for its queue: `ML_TASK_${snakeCase(taskId).toUpperCase()}_SQS_QUEUE_URL`

- Run your application with the task workload.

### Worker

Wrap your task in a worker script.

```js
import { Worker } from "@monolayer/task-sqs-adapter";
import task from "/path/to/task.mjs" // Build output from workloads build

new Worker(task.default);
```

You can stop the worker with:

```js
worker.stop()
```
npm package: @monolayer/workflow-aws-world
Description: AWS World implementation for the Workflow DevKit
Author: Marcos Essindi
Latest version: 1.0.0-canary.31

# workflow-aws-world

## Environment variables

- WORKFLOW_TABLE
- IDEMPOTENCY_TABLE_NAME
- WORKFLOW_WORKFLOW_QUEUE_URL
- WORKFLOW_QUEUE_URL = WORKFLOW_WORKFLOW_QUEUE_URL
- WORKFLOW_STEP_QUEUE_URL
- WORKFLOW_DEPLOYMENT_ID
- WORKFLOW_STREAM_BUCKET
npm package: @monolithed/class-namer
Description: A lightweight npm package designed to simplify the process of creating CSS class chains based on a key-value object.
Latest version: 0.0.2

# class-namer (cn)

The class-namer is a lightweight npm package designed to simplify the process of creating CSS class chains based on 
a key-value object. With just 10 lines of code, the class-namer offers a minimalistic and efficient solution for generating 
concatenated strings of CSS classes.

The example usage below perfectly illustrates the power of the class-namer:

```javascript
import cn from '@monolithed/class-namer';

const classNames = cn({
    foo: true,
    bar: false,
    baz: true
});

console.log(classNames);
// Output: "foo baz"
```

As demonstrated, the class-namer intelligently composes a chain of CSS classes based on the provided object.
It selectively includes the class if the associated boolean value is true and excludes it if false.
The resulting string is returned, ready for immediate use in your styles.

### What about React?

The class-namer elegantly integrates with React components:

```javascript
import cn from '@monolithed/class-namer';

type Props = {active: boolean};

const Example: React.FunctionComponent<Props> = ({active}) => {
    const classNames = cn({foo: active});
    
    return <div clasName={classNames}>Wow!</div>
};

<Example active={true} /> 

// Output: <div class="foo">Wow!</div>
```

### What about CSS-in-JS (CSS Modules)?

If you're a fan of CSS Modules, you'll love what the class-namer has to offer.<br />
The class-namer seamlessly integrates with CSS Modules, providing a seamless solution for managing class names within your modules.


```css
.foo {...}
```

```javascript
import cn from '@monolithed/class-namer';

type Props = {active: boolean};

const Example: React.FunctionComponent<Props> = ({active}) => {
    const classNames = cn({[styles.foo]: active});
    
    return <div clasName={classNames}>Wow!</div>
};

<Example active={true} /> 

// <div class="foo">Wow!</div>
```

Empower your development workflow with the class-namer and enjoy the simplicity of creating CSS class chains effortlessly.<br />
Say goodbye to cumbersome concatenations and embrace the power of the class-namer - your go-to solution for managing CSS classes with ease.


## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/class-namer
```

**Yarn**:

```
yarn add @monolithed/class-namer
```

## Contributing
   
Feel free to submit a pull request if you find any bugs. 
Please make sure all commits are properly documented.

## Tests

```
npm test
```

## Publishing

```
npm publish --access public --verbose
```

## License

MIT
npm package: @monolithed/error-boundary-component
Description: ErrorBoundary component
Author: Alexander Abashkin
Latest version: 0.0.3

# @monolithed/error-boundary-component

[![Build Status](https://travis-ci.org/monolithed/error-boundary-component.png)](https://travis-ci.org/monolithed/error-boundary-component)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt)

[ErrorBoundary](https://reactjs.org/docs/error-boundaries.html) component.

## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/error-boundary-component --save
```

**Yarn**:

```
yarn add @monolithed/error-boundary-component
```

## Basic usage

```typescript
import React, {
    FunctionComponent,
    Suspense,
    lazy
} from 'react';

import {useScript} from '@monolithed/use-script-hook';
import {componentLoader} from '@monolithed/remote-component-loader';
import {ErrorBoundary} from '@monolithed/error-boundary-component';

type Props = {
    src: string;
    scope: string;
    module: string;
};

const LazyService: FunctionComponent<Props> = ({children, src, scope, module}): JSX.Element => {
    const {loaded, failed} = useScript({src});
    const remoteModule = componentLoader({scope, module});

    const RemoteComponent = lazy(remoteModule);

    return (
        <ErrorBoundary>
            <Suspense fallback="loading...">
                <RemoteComponent>{...children.props}</Component>
            </Suspense>
        </ErrorBoundary>
    );
};
```

## Options

```typescript
type Props = {
    fallback?: () => JSX.Element;
};
```

* **fallback** (optional)

## Event

Use the following subscription to log error information.

```typescript
import {
    ErrorBoundaryEventDetail,
    ErrorBoundaryEventType
} from '@monolithed/error-boundary-component';

globalThis.addEventListener(ErrorBoundaryEventType, ({detail}: CustomEvent<ErrorBoundaryEventDetail[]>) => {
    const {error, info} = detail;

    console.log({error, info});
});
```

## Publishing

```
npm publish --access public --verbose
```

## License

MIT

## Contributing
   
Feel free to submit a pull request if you find any bugs. <br /> 
Please make sure all commits are properly documented.
npm package: @monolithed/lazy-service
Description: Lazy Service is a wrapper around several scripts to support the Module Federation conception
Author: Alexander Abashkin
Latest version: 0.0.3

# @monolithed/lazy-service

[![Build Status](https://travis-ci.org/monolithed/lazy-service.png)](https://travis-ci.org/monolithed/lazy-service)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt)

Lazy Service is a wrapper around several scripts to support the Module Federation conception.

## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/lazy-service --save
```

**Yarn**:

```
yarn add @monolithed/lazy-service
```

## Basic usage

```typescript
import React, {
    FunctionComponent,
    Suspense,
    lazy
} from 'react';

import {
    useScript,
    componentLoader,
    ErrorBoundary
} from '@monolithed/lazy-service';

type Props = {
    src: string;
    scope: string;
    module: string;
};

const LazyService: FunctionComponent<Props> = ({children, src, scope, module}): JSX.Element => {
    const {loaded, failed} = useScript({src});
    const remoteModule = componentLoader({scope, module});

    const RemoteComponent = lazy(remoteModule);

    return (
        <ErrorBoundary>
            <Suspense fallback="loading...">
                <RemoteComponent>{...children.props}</Component>
            </Suspense>
        </ErrorBoundary>
    );
};
```

## Publishing

```
npm publish --access public --verbose
```

## License

MIT

## Contributing
   
Feel free to submit a pull request if you find any bugs. <br /> 
Please make sure all commits are properly documented.
npm package: @monolithed/logger
Description: A simple logger
Author: Aleksandr A
Latest version: 1.0.0

# @monolithed/logger

[![Build Status](https://travis-ci.org/monolithed/logger.png)](https://travis-ci.org/monolithed/logger)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt)

A simple logger

## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/logger --save
```

**Yarn**:

```
yarn add @monolithed/logger
```

## Synopsis

## Basic usage

```typescript
import {Logger} from '@monolithed/logger';

const logger = new Logger({title: 'Hello'});

logger.info('World'); // Hello World
```

## Options

```typescript
type Options = {
    title?: string;
    debug?: boolean;
    format?: (...messages: unknown[]) => unknown[];
};
```

### title 

```typescript
import {Logger} from '@monolithed/logger';

const logger = new Logger({title: 'Hello'});

logger.info('World'); // Hello World
```

### debug 

```typescript
import {Logger} from '@monolithed/logger';

const logger = new Logger({debug: true});

logger.info('Hello', 'World'); // 01.07.2021, 02:05:34 Hello World
```

### silent 

Use the silent option to suppress console output. All messages will be captured in the global event "@monolithed/logger"

```typescript
import {Logger} from '@monolithed/logger';

const logger = new Logger({silent: true});

logger.info('Hello'); // This message is not visible
```

### format 

```typescript
const logger = new Logger({
    format(...message) {
        return ['Hello', ...message]
    }
});

logger.info('World'); // Hello World
```

### Methods

```typescript
type Methods = 'debug' | 'error' | 'info' | 'log' | 'warn';
```

A wide variety of [Console API](https://developer.mozilla.org/en-US/docs/Web/API/Console) methods are available out of the box.

```typescript
import {Logger} from '@monolithed/logger';

const logger = new Logger({title: 'Hello'});

logger.error('World'); // Hello World
```

### Event

```typescript
import {Logger} from '@monolithed/logger';

const messages = [];
const logger = new Logger({silent: true});

globalThis.addEventListener(Logger.EVENT_TYPE, ({detail}: CustomEvent<string[]>) => {
    messages.push(detail);
});

logger.log('Hello');

console.log(messages); // ["Hello"] 
```

## Contributing
   
Feel free to submit a pull request if you find any bugs. 
Please make sure all commits are properly documented.

## Tests

```
npm test
```

## Publishing

```
npm publish --access public --verbose
```

## License

MIT
npm package: @monolithed/remote-component-loader
Description: A Webpack module for dynamically loading remote components
Author: Alexander Abashkin
Latest version: 1.0.1

# @monolithed/remote-component-loader

[![Build Status](https://travis-ci.org/monolithed/remote-component-loader.png)](https://travis-ci.org/monolithed/remote-component-loader)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt)

A Webpack module for dynamically loading remote components

## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/remote-component-loader --save
```

**Yarn**:

```
yarn add @monolithed/remote-component-loader
```

## Basic usage

```typescript
import React, {
    FunctionComponent,
    Suspense,
    lazy
} from 'react';

import {useScript} from '@monolithed/use-script-hook';
import {componentLoader} from '@monolithed/remote-component-loader';

type Props = {
    src: string;
    scope: string;
    module: string;
};

const LazyService: FunctionComponent<Props> = ({children, src, scope, module}): JSX.Element => {
    const {loaded, failed} = useScript({src});
    const remoteModule = componentLoader({scope, module});
   
    const RemoteComponent = lazy(remoteModule);

    return (
        <Suspense fallback="loading...">
            <RemoteComponent>{...children.props}</Component>
        </Suspense>
    );
};
```

## Options

* **scope** (required)
* **module** (required)

## Publishing

```
npm publish --access public --verbose
```

## License

MIT

## Contributing
   
Feel free to submit a pull request if you find any bugs. 
Please make sure all commits are properly documented.
npm package: @monolithed/sri
Description: A Subresource Integrity generator
Author: Alexander Abashkin
Latest version: 1.0.0

# @monolithed/sri

[![Build Status](https://travis-ci.org/monolithed/sri.png)](https://travis-ci.org/monolithed/sri)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt)


A [Subresource Integrity (SRI)](https://w3c.github.io/webappsec-subresource-integrity/#toc) generator.

## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/sri --save
```

**Yarn**:

```
yarn add @monolithed/sri
```

## Synopsis

```ts
generate(file: string, {algorithm: string}): Promise<string>;
```

## Basic usage

```typescript
import {generate} from '@monolithed/sri';

generate('file.js')
    .then((integrity) => {
            // sha512-z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg==
    })
    .catch((error) => {
        console.error(error);
    });
```

Weak signature algorithms like 'md5', 'sha1' or 'des' are not allowed.

## API

### algorithm

Response verification algorithms:

```typescript
import {generate} from '@monolithed/sri';

await generate('file.js', {algorithm: 'sha256'})
// sha256-47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=
```

## Contributing
   
Feel free to submit a pull request if you find any bugs. 
Please make sure all commits are properly documented.

## Tests

```
npm test
```

## Publishing

```
npm publish --access public --verbose
```

## License

MIT
npm package: @monolithed/use-script-hook
Description: A React hook to dynamically load scripts
Author: Alexander Abashkin
Latest version: 0.1.1

# @monolithed/use-script-hook

[![Build Status](https://travis-ci.org/monolithed/use-script-hook.png)](https://travis-ci.org/monolithed/use-script-hook)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt)

A React hook to dynamically load scripts

## Installation

Install with npm or Yarn:

**npm**:

```
npm install @monolithed/use-script-hook --save
```

**Yarn**:

```
yarn add @monolithed/use-script-hook
```

## Basic usage

```typescript
import React, {FunctionComponent} from 'react';
import {useScript} from '@monolithed/use-script-hook';

type Props = {
    src: string;
};

const LazyService: FunctionComponent<Props> = ({src}): JSX.Element => {
    const {loaded, failed, script} = useScript({src});
   
    return <div>script {script.src} is {loaded}</div>;
};
```

## Attributes

**async** (default is true)
**src** (required)

```typescript
const {loaded, failed} = useScript({src, async});
```

## Options

**verbose** — a boolean indicator of sending states to the console

```typescript
const {loaded, failed} = useScript({src}, {verbose: true});
```

## Tests

```
npm test
```

## Publishing

```
npm publish --access public --verbose
```

## License

MIT

## Contributing
   
Feel free to submit a pull request if you find any bugs. 
Please make sure all commits are properly documented.
npm package: @monolithmtl/locomotive-scroll
Description: ```js // gatsby-node.js
Latest version: 1.3.35

# SSR & SSG

```js
// gatsby-node.js

exports.onCreateWebpackConfig = ({ stage, loaders, actions }) => {
  if (stage === 'build-html' || stage === 'develop-html') {
    actions.setWebpackConfig({
      module: {
        rules: [
          {
            test: /locomotive-scroll/,
            use: loaders.null(),
          },
        ],
      },
    })
  }
}
```

## Use Scroll Events

The instance can be defined without any parameters in order to call event anywhere.

```js
const scroll = new LocomotiveScroll()

scroll.on('call', (func) => {
  // Event
})
```