open-index/open-npm huggingface dataset:
npm package: @sigmacomputing/babel-plugin-lodash
Description: Modular Lodash builds without the hassle.
Author: Graeme Yeates
Latest version: 3.3.5

# @sigmacomputing/babel-plugin-lodash

A simple transform to cherry-pick Lodash modules so you don’t have to.

Combine with [lodash-webpack-plugin](https://www.npmjs.com/package/lodash-webpack-plugin)
for even smaller cherry-picked builds!

@sigmacomputing/babel-plugin-lodash is forked from
[babel-plugin-lodash](https://github.com/lodash/babel-plugin-lodash) which has
since been abandoned.

## Install

NPM

```shell
$ npm install --save lodash
$ npm install --save-dev babel-plugin-lodash @babel/cli @babel/preset-env
```

Yarn

```shell
$ yarn add lodash
$ yarn add @sigmacomputing/babel-plugin-lodash @babel/cli @babel/preset-env -D
```

## Example

Transforms

```js
import _ from 'lodash';
import { add } from 'lodash/fp';

const addOne = add(1);
_.map([1, 2, 3], addOne);
```

roughly to

```js
import _add from 'lodash/fp/add';
import _map from 'lodash/map';

const addOne = _add(1);
_map([1, 2, 3], addOne);
```

## Usage

###### .babelrc

```json
{
  "plugins": ["@sigmacomputing/babel-plugin-lodash"],
  "presets": [["@babel/env", { "targets": { "node": 6 } }]]
}
```

Set plugin options using an array of `[pluginName, optionsObject]`.

```json
{
  "plugins": [
    [
      "@sigmacomputing/babel-plugin-lodash",
      { "id": "lodash-compat", "cwd": "some/path" }
    ]
  ],
  "presets": [["@babel/env", { "targets": { "node": 6 } }]]
}
```

The `options.id` can be an array of ids.

```json
{
  "plugins": [
    ["@sigmacomputing/babel-plugin-lodash", { "id": ["async", "lodash-bound"] }]
  ],
  "presets": [["@babel/env", { "targets": { "node": 6 } }]]
}
```

###### Babel CLI

```sh
$ babel --plugins @sigmacomputing/babel-plugin-lodash --presets @babel/es2015 script.js
```

###### Babel API

```js
require('babel-core').transform('code', {
  plugins: ['@sigmacomputing/babel-plugin-lodash'],
  presets: [['@babel/env', { targets: { node: 6 } }]],
});
```

###### webpack.config.js

```js
'module': {
  'loaders': [{
    'loader': 'babel-loader',
    'test': /\.js$/,
    'exclude': /node_modules/,
    'query': {
      'plugins': ['@sigmacomputing/babel-plugin-lodash'],
      'presets': [['@babel/env', { 'targets': { 'node': 6 } }]]
    }
  }]
}
```

## FAQ

> Can this plugin produce ES2015 imports rather than CommonJS imports?

This plugin produces ES2015 imports by default. The
[`@babel/plugin-transform-modules-commonjs`](https://www.npmjs.com/package/@babel/plugin-transform-modules-commonjs)
plugin, which is included in the [`@babel/preset-es2015`](https://www.npmjs.com/package/@babel/preset-es2015)
preset, transforms ES2015 `import` statements to CommonJS. Omit it from your
preset to preserve ES2015 style imports.

## Limitations

- You must use ES2015 imports to load Lodash
- Babel < 6 & Node.js < 4 aren’t supported
- Chain sequences aren’t supported. See [this blog post](https://medium.com/making-internets/why-using-chain-is-a-mistake-9bc1f80d51ba) for alternatives.
- Modularized [method packages](https://www.npmjs.com/browse/keyword/lodash-modularized) aren’t supported
npm package: @sigmacomputing/node-embed-sdk
Description: Node.js SDK for Sigma Computing with encryption/decryption utilities
Author: sigmacomputing
Latest version: 0.3.0

# Sigma Node.js Embed SDK

This package provides Node.js utilities for working with Sigma Computing's Embed API.

## Getting Started

To use the node-embed-sdk in your project, you can install it using your node package manager.

**Using npm:**

```code
npm install @sigmacomputing/node-embed-sdk
```

**yarn:**

```code
yarn add @sigmacomputing/node-embed-sdk
```

**pnpm:**

```code
pnpm add @sigmacomputing/node-embed-sdk
```

## Features

### Token Encryption and Decryption

The SDK provides utilities for encrypting and decrypting OAuth tokens using AES-256-GCM encryption.

See our documentation on [embedding with JWTS](https://help.sigmacomputing.com/docs/create-an-embed-api-with-json-web-tokens) for more information.

Sigma expects you to encrypt OAuth tokens using the same embed secret used to sign the embed.

#### Example Usage

##### Asynchronous

```typescript
import { encrypt, decrypt } from "@sigmacomputing/node-embed-sdk/promises";

// Encrypt an OAuth token
const encryptedToken = await encrypt("your-embed-secret", "your-oauth-token");

// Decrypt an encrypted token
const decryptedToken = await decrypt("your-embed-secret", encryptedToken);
```

##### Synchronous

```typescript
import { encrypt, decrypt } from "@sigmacomputing/node-embed-sdk";

// Encrypt an OAuth token
const encryptedToken = encrypt("your-embed-secret", "your-oauth-token");

// Decrypt an encrypted token
const decryptedToken = decrypt("your-embed-secret", encryptedToken);
```
npm package: @sigmacomputing/plugin-types
Description: Plugin client api
Latest version: 0.7.63
Deprecated: This package is deprecated as of v1.0.0. All plugin types have been moved to the @sigmacomputing/plugin package

# @sigmcomputing/plugin-types

## Deprecation Notice

This package has been deprecation as of v1.0.0 of @sigmacomputing/plugin. All
types have been moved into @sigmacomputing/plugin and this package is no longer
necessary.

## Gettting Started

### Install

```sh
yarn add @sigmacomputing/plugin-types -D
// or
npm install --save-dev @sigmacomputing/plugin-types
```
npm package: @sigmadigital/configs
Description: common JS configs for eslint, prettier, babel and stylelint
Author: Paul van Zyl
Latest version: 0.3.5

# Configs
this is specifically a single importable npm package that centralises our common configs for javascript development, including:

* eslint
* babel
* prettier
* stylelint

It also contains basic config files, that should be placed in the root of the project when installed.

## Get Started
While your project will require some root dependencies to be installed, this package should vastly simplify the rather arduous task of setting this up and maintaining these configs across multiple projects.

### Requirements
```bash
  #devDependencies
   @babel/cli@">= 7.0.0"
   @babel/core@">= 7.0.0"
   eslint@">= 5"
   jest@">= 24"
   prettier@">= 1.16.1"
   flow-bin@">= 0.91"
   
   # dependencies
   @babel/polyfill@">= 7.0.0"
   @babel/runtime@">= 7.3"
```

### Install
you can either just install this package:
```bash
npm install --save-dev @sigmadigital/configs
```

or alternatively, install this package with all its dependencies with the following commands.

```bash
npm install --save-dev @babel/cli@">=7.0.0" @babel/core@">=7.0.0" eslint@">=5" jest@">=24" prettier@">=1.16.1" flow-bin@">=0.91" @sigmadigital/configs 

npm install --save @babel/polyfill@">=7.0.0"  @babel/runtime@">= 7.3"
```

### Config files
If config files don't exist, they will be added to the project root, alternatively, you can use the following presets:

```js
// .babelrc
@sigmadigital/configs/presets/babel

// .babelrc (next JS after babel/next)
@sigmadigital/configs/presets/babel/next

// .stylelintrc
@sigmadigital/configs/presets/stylelint

// .eslint.json
@sigmadigital/eslint-config-kitchensink

// .prettierrc.js 
module.exports = require('@sigmadigital/configs/presets/prettier');

```

you can inspect the default project config files that should be used in the root in the **./configFiles** directory.


## Example Scripts
it will be useful to add these to the scripts section of your `package.json`:

```json
{
  "scripts": {
    "lint": "npm run lint:js && npm run lint:scss",
    "lint:js": "eslint \"assets/js/**\"",
    "lint:scss": "stylelint \"assets/scss/*.scss\"",
    "codestyle": "npm run codestyle:fix && npm run codestyle:prettier",
    "codestyle:fix": "npm run codestyle:fix:js && npm run codestyle:fix:scss",
    "codestyle:fix:js": "eslint --fix \"assets/**/*.js\"",
    "codestyle:fix:scss": "stylelint \"assets/**/*.scss\" --fix",
    "codestyle:prettier": "npm run codestyle:prettier:js && npm run codestyle:prettier:scss",
    "codestyle:prettier:js": "prettier --write \"assets/**/*.js\"",
    "codestyle:prettier:scss": "prettier --write \"assets/**/*.scss\""
  }
}
```

## Use At Your Own Risk
While this is openly available and licensed under MIT, we have developed it solely for our own purposes, and provide zero warranties, or guarantees of any kind.

## Contributing
If you find a bug, have a suggestion, or would like to contribute, head on over the issues section on the github repo.
npm package: @sigmadigital/eslint-config-kitchensink
Description: All weather eslint connfig for JS projects
Author: Paul van Zyl
Latest version: 0.1.8

# Eslint Config Kitchensink
an extensive, highly opinionated general, purpose `eslint` config that can be included independently. (NB: this is already included via our configs module).

## This includes:
* Airbnb
* Prettier
* Flow & Flow-errors
* React / JSX
* Jest

This config uses the `babel-loader` and sets a number of custom warnings, configured as per our particular preferences, and experience on recent projects.
npm package: @sigmadigital/redux-helpers
Description: utilities for reducing redux boilerplate code
Author: Paul van Zyl
Latest version: 1.2.0
Deprecated: WARNING THIS WADS ONLY A PRERELEASE.  THE FINAL VERSION HAS BEEN RENAMED TO @sigmadigital/duxedo

# SigmaDigital Redux Helpers
A tiny set of utilities to reduce redux boilerplate, and help your write cleaner code.

## What does it do?
Take a single object definition of actions and how state changes, and produce an object containing  **immutable action constants**, an object containing **consistent action creators** and a **reducer function** that can be included easily in your store configuration.

## Motivation
Managing state with redux requires quite a bit of boilerplate code, especially when you begin to use consistent patterns for action creators for example, you end up repeating yourself a great deal. Secondly as your app grows, recalling which actions do what, and how becomes a hunt through growing switch statements, and  multiple files. Not to mention that this growing API for your local application state, can increase the time it takes to on-board new team members.

* DRY<span><sup>>TM</sup></span> out your code by defining actions, action creators and reducers with a single definition.
* Consistency through a predefined opinionated structure, and single reliable pattern for action objects
* Improve Readability and Maintainability by clearly defining actions and how state should change in a single place.


# Enough Talk, Lets Code 

```js
// src/store/lib/counter.js
import reduxGen from '@sigmadigital/redux-helpers';

const defaultState = { count: 0 };

// test input data
const definition = {
  INCREMENT: state => ({ ...state, count: state.count + 1 }),
  DECREMENT: state => ({ ...state, count: state.count - 1 }),
  SET: (state, { payload }) => ({ ...state, count: payload.count }),
  RESET: state => ({ ...state, count: 0 }),
};

// this exports an object containing reducer, constants, actions
export default  reduxGen({ definition, defaultState });

// src/store/configure.js
import { createStore, combineReducers } from 'redux';
import { reducer } from './lib/counter'

export default  () => createStore(combineReducers(reducer));
```
the `reduxGen` function, takes the definition as above, and the default state, that you would usually pass to your reducer function. it redturns an object:

```js
{
  reducer, // function to be passes to the store
  actions, // object containing action creator functions, the action names have been transformed to camelCase
  constants, // the actions in original case, as an object 
}
```

Have a look at the expample folder, the tests, and sourcecode for more.
npm package: @sigmais/payload-parsers
Description: >Biblioteca para converter payloads da Sigfox de hexadecimal para dados legiveis, baseado em um FRAME e um TEMPLATE. --- ### Traduzindo um payload em um objeto
Latest version: 1.8.6

# PAYLOAD PARSERS

>Biblioteca para converter payloads da Sigfox de hexadecimal para dados legiveis, baseado em um FRAME e um TEMPLATE.
---
### Traduzindo um payload em um objeto

```typescript
import { Parse } from '@sigmais/payload-parsers';
const parse = new Parse();
const parameters = [ {
    label: 'frame',
    bytes: [0],
    bits: { offset: 0, length: 8 },
    type: 'int',
  },
  {
    label: 'timestamp',
    bytes: [1, 2, 3, 4],
    bits: { offset: 0, length: 32 },
    type: 'int',
  },
  {
    label: 'timezone',
    bytes: [5],
    bits: { offset: 0, length: 8 },
    type: 'intSigned',
  },
  {
    label: 'battery',
    bytes: [6, 7],
    bits: { offset: 0, length: 16 },
    type: 'percentage',
  },
  {
    label: 'lqi',
    bytes: [8],
    bits: { offset: 0, length: 8 },
    type: 'int',
  }]
  const result = parse.decoder('00630E57E6FC014D01C002B4', parameters);
  console.log(result);
  /*
      frame: 0,
      timestamp: 1661884390,
      timezone: -4,
      battery: 3.33,
      lqi: 1
    */
```
### Convertendo um objeto em um payload

```typescript 
import { Parse } from '@sigmais/payload-parsers';
const parse = new Parse();
const template = [{
    bits: {
      length: 7,
      offset: 0,
    },
    byte: 0,
    label: 'header',
    type: 'int',
    value: '00',
  },
  {
      bits: {
      length: 7,
      offset: 0,
    },
    byte: 1,
    label: 'sense',
    type: 'int',
    value: '30',
  },
  {
    bits: {
      length: 7,
      offset: 0,
    },
    byte: 2,
    label: 'timestampSyncPeriod',
    type: 'timeUnit',
    value: {
      unit: 'HOURS', //SECONDS | MINUTES | HOURS
      value: 12,
    },
  }]
  const result = parse.encoder(template, 12, true)
  //12 é o tamanho do payload em bytes.
  //true é para indicar que deve ser gerado CRC e adicionado ao ultimo byte.
  console.log(result); 
  //00008C00000000000000000067
```

### Traduzindo um payload Sigmeter

```typescript
import { Sigmeter } from '@sigmais/payload-parsers';
const sigmeter = new Sigmeter();
const event = sigmeter.decode('0137006DDB003354FA0004B5');
console.log(event);

/*
{
  frame: 2,
  config: false,
    data: {
      reset: false,
      lastLog: false,
        count1: 7143479,
        count2: 3342555,
        timeCount1: 348064,
        timeCount2: 1205,
     },
}
*/
```
---
### Convertendo um objeto em um payload BSHM

```typescript
import { BSHM } from '@sigmais/payload-parsers';
const bshm = new BSHM();
const config = [
  timestampSyncPeriod: {
    value: 6,
    unit: 'HOURS',
  },
  downlinkPeriod: {
    value: 1,
    unit: 'DAYS',
  }]

const payload = bshm.encode(config,12,true); 
// 12 é o tamanho do payload em bytes e true é para indicar 
// que deve ser gerado CRC e adicionado ao ultimo byte.

console.log(payload);
/* 0086C1000000000000000058 */
```
npm package: @sigmalabs-ai/cortex
Description: Persistent memory for AI agents. Knowledge graph, hybrid search, entity tracking. By Sigma Labs.
Author: Wayne Vaughan
Latest version: 0.0.1

# cortex-ai

Persistent memory for AI agents. File-based, git-tracked, zero-LLM.

Built by [Sigma Labs](https://github.com/sigmalabs-ai).

- **Mind** — Behavioral memory with decay, reinforcement, and consolidation
- **Vault** — Document store with hybrid search
- **Observer** — Automatic memory extraction from conversations
- **Search** — BM25 + semantic + temporal

## Links

- GitHub: [sigmalabs-ai/cortex](https://github.com/sigmalabs-ai/cortex)
- Original v1: [waynevaughan/cortex](https://github.com/waynevaughan/cortex)
- License: MIT
npm package: @sigmaott/nestjs-agenda
Description: agenda for nest.js
Author: Alex Chen, Anh Luu
Latest version: 3.1.1

# nestjs-agenda

This repo base on [nestjs-agenda](https://github.com/hanFengSan/nestjs-agenda) and wrap decorator agenda job defined
[Agenda](https://github.com/agenda/agenda) module for [Nestjs](https://github.com/nestjs/nest)

Agenda version is `^4.1.3`

# Installation

```
npm i @sigmaott/nestjs-agenda
```

# Dependencies

Thank for @golevelup build the easy way to implement Dynamic Module and Discovery Module

# Usage

**1. Import `AgendaModule`:**

_Sync register_:

```TypeScript
import { AgendaModule } from '@sigmaott/nestjs-agenda';

@Module({
  imports: [AgendaModule.forRoot(AgendaModule, { db: { address: 'mongodb://xxxxx' }})], // Same as configuring an agenda
  providers: [...],
})
export class FooModule {}
```

_Async register_:

```TypeScript
import { AgendaModule } from '@sigmaott/nestjs-agenda';

@Module({
  imports: [
    AgendaModule.forRootAsync(AgendaModule, {
      imports: [ConfigModule],
      useFactory: async (config: ConfigService) => ({
        db: { address: config.get('MONGODB_URI') },
      }),
      inject: [ConfigService],
    }),
  ],
  providers: [...],
})
export class FooModule {}
```

**2. Inject `AgendaService` (AgendaService is a instance of Agenda):**

```TypeScript
import { Injectable } from '@nestjs/common';
import { AgendaService } from '@sigmaott/nestjs-agenda;

@Injectable()
export class FooService {
  constructor(private readonly agenda: AgendaService) {
    // schedule a job
    this.agenda.schedule('10 seconds from now', 'TEST_JOB', {});
  }

  @AgendaHandler({
    name: 'TEST_JOB',
    lockLifetime: 10000
  })
  private async testJob(job: any, done: any): Promise<void> {
    console.log('a job');
    await job.remove();
    done();
  }
}
```
npm package: @sigmaott/nestjs-ksqldb-client
Description: ksqldb-client for nestjs
Author: Luu Viet Anh
Latest version: 1.0.1

# nestjs-ksqldb-client

This repo base on [ksqldb-client](https://github.com/hanFengSan/nestjs-agenda) and wrap decorator agenda job defined
[Agenda](https://github.com/agenda/agenda) module for [Nestjs](https://github.com/nestjs/nest)

Agenda version is `^4.1.3`

# Installation

```
npm i @sigmaott/nestjs-ksqldb-client
```

# Dependencies

Thank for @golevelup build the easy way to implement Dynamic Module and Discovery Module

# Usage

**1. Import `KsqldbModule`:**

_Sync register_:

```TypeScript
import { KsqldbModule } from '@sigmaott/nestjs-ksqldb-client';

@Module({
  imports: [KsqldbModule.forRoot(KsqldbModule, { host: 'http://', port: 8088})], // Same as configuring an agenda
  providers: [...],
})
export class FooModule {}
```

_Async register_:

```TypeScript
import { KsqldbModule } from '@sigmaott/nestjs-ksqldb-client';

@Module({
  imports: [
    KsqldbModule.forRootAsync(KsqldbModule, {
      imports: [ConfigModule],
      useFactory: async (config: ConfigService) => ({
        ...config.get('ksqldb'),
      }),
      inject: [ConfigService],
    }),
  ],
  providers: [...],
})
export class FooModule {}
```

**2. Inject `KsqldbModule` (AgendaService is a instance of Agenda):**

```TypeScript
import { Injectable } from '@nestjs/common';
import { KsqldbClientService } from '@sigmaott/nestjs-agenda;

@Injectable()
export class FooService {
  constructor(private readonly ksqldbClient: KsqldbClientService) {
    // schedule a job
  }

  private async testClient(job: any, done: any): Promise<void> {
    ksqldbClient
  }
}
```
npm package: @sigmaott/schematics
Description: Sigma OTT platform resource service (@schematics)
Latest version: 1.3.4

<p align="center">
  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo_text.svg" width="320" alt="Nest Logo" /></a>
</p>

  <p align="center">A progressive <a href="http://nodejs.org" target="blank">Node.js</a> framework for building efficient and scalable server-side applications.</p>
    <p align="center">
<a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/v/@nestjs/schematics.svg" alt="NPM Version" /></a>
<a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/l/@nestjs/schematics.svg" alt="Package License" /></a>
<a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/dm/@nestjs/schematics.svg" alt="NPM Downloads" /></a>
  <a href="https://coveralls.io/github/nestjs/nest?branch=master" target="_blank"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#9" alt="Coverage" /></a>
<a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
<a href="https://opencollective.com/nest#backer" target="_blank"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
<a href="https://opencollective.com/nest#sponsor" target="_blank"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
  <a href="https://paypal.me/kamilmysliwiec" target="_blank"><img src="https://img.shields.io/badge/Donate-PayPal-ff3f59.svg"/></a>
  <a href="https://twitter.com/nestframework" target="_blank"><img src="https://img.shields.io/twitter/follow/nestframework.svg?style=social&label=Follow"></a>

## Description

The Nest CLI is a command-line interface tool that helps you to initialize, develop, and maintain your Nest applications. It assists in multiple ways, including scaffolding the project, serving it in development mode, and building and bundling the application for production distribution. It embodies best-practice architectural patterns to encourage well-structured apps. Read more [here](https://docs.nestjs.com/cli/overview).

## Installation

```
$ npm install -g @nestjs/schematics
```

## Usage

Learn more in the [official documentation](https://docs.nestjs.com/).

## Stay in touch

- Website - [https://nestjs.com](https://nestjs.com/)
- Twitter - [@nestframework](https://twitter.com/nestframework)

## License

Nest is [MIT licensed](LICENSE).
npm package: @sigmaott/ssai-tracking-web-sdk
Description: **Table of Contents**
Latest version: 0.0.2

# ssai-tracking

**Table of Contents**

## Install

```markdown
npm i @sigmaott/ssai-tracking
```

## ****Usage****

```jsx
import SSAITracking from '@sigmaott/ssai-tracking'

const video = document.getElementById('video')
// get tracking url and source
const domain = `<<domain>>`
const sessionUrl = `${domain}/manifest/manipulation/session/628e8331-d3b2-4e89-a151-10003ed76286/origin04/scte35-av4s-clear/master.m3u8`
const data = await fetch(sessionUrl)
    .then(response => response.json()) as { manifestUrl: string; trackingUrl: string }
const videoSrc = `${domain}${data.manifestUrl}`const trackingUrl = `${domain}${data.trackingUrl}`
// init tracking before play video
const ssaiPlugin = new SSAITracking({ trackingUrl, video, intervalTracking: 10000 })
ssaiPlugin.init()

//destroy before not use
ssaiPlugin.destroy()
```

## API

- SSAITracking.constructor(params:Obj)

      Call when init instance.

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| params | Obj | true |  | Setting params when init instance.       |

****supported  params:****

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| trackingUrl | string | true |  | Url tracking        |
| video | HTMLVideoElement | true |  | HTMLVideoElement |
| intervalTracking | number | true | 10000  | Interval tracking (unit: ms ) |
| disableErrLog | boolen | false | false | if value is false enable log when call api error |
- SSAITracking.init()
    
    Call  before play video.
    
- SSAITracking.destroy()
    
    Call before not use instance