open-index/open-npm huggingface dataset:
npm package: @jitesoft/async-array
Description: Array wrapper with async methods.
Author: Johannes Tegnér
Latest version: 1.0.4

# async-array

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/async-array)](https://www.npmjs.com/package/@jitesoft/async-array)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/async-array/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/async-array)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/async-array/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/async-array/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/async-array/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/async-array/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/async-array)](https://www.npmjs.com/package/@jitesoft/async-array)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

Array wrapper with async methods.

There are multiple ways to use this package:

## Static functions

Import the static methods which are possible to use on any array type object:


````js
import {map} from '@jitesoft/async-array';
import {doFunStuffAsync} from './async-functions';

(async () => {
let result = await map(['a', 'b', 'c'], async (value, index, list) => {
  let somethingSomething = await doFunStuffAsync(value);
});
})();
````

The following methods are available to import directly for usage:

* `every`
* `find`
* `findIndex`
* `forEach` 
* `forEachSeries`
* `map`
* `some`

## AsyncArray class

The `AsyncArray` class is a class which extends the Array class. All the standard methods that the array class have is 
available on the `AsyncArray`. The following methods are overriden to introduce async functionality:

* `.every`
* `.find`
* `.findIndex`
* `.forEach`
* `.series`
* `.map`
* `.some`

## Convert Array

It's also possible to import the simple `async` and `sync` methods directly from the package to convert a normal array into
async or async array into normal.

```js
import {sync, async} from '@jitesoft/async-array';

let array = [];       // Array
array = async(array); // AsyncArray
array = sync(array);  // Array
```
npm package: @jitesoft/audit-for-gitlab
Description: Minimal application to convert npm audit report into gitlab-ci vulnerability report format.
Author: Johannes Tegnér
Latest version: 4.0.1

# Audit for GitLab

This is a small script to add a `npm audit` GitLab dependency scanner.  
It generates a JSON audit via npm and converts it to the format that gitlab expects as dep scan report.  

In case a vulnerability equal or higher to `moderate` is found, it will exit with exit code 1, i.e., fail.  
While generating the report, it will also output number of vulnerabilities found (and types) in stdout.


**Observe:**  
The scanner will _currently_ only work with npmjs versions which makes use of audit report v2.  
GitLab report specification supported is [15.0.2](https://gitlab.com/gitlab-org/security-products/security-report-schemas/-/blob/5778ed0c8f9996f3a809439fc61a0b5272b26a0a/dist/dependency-scanning-report-format.json)

## Usage

Easiest way to use the scanner is to add it as a include in your .gitlab-ci.yml file, such as:

```yaml
include:
  - https://gitlab.com/jitesoft/open-source/javascript/audit-for-gitlab/raw/master/scan.yml
```

This will run the scanning on your project on all events as long as it is disabled via env variables.

If you wish to customize it a bit more, you can extend or write your own:

```yaml
npm-audit_dependency_scanning:
  image: registry.gitlab.com/jitesoft/open-source/javascript/audit-for-gitlab:1
  script:
    - audit-for-gitlab
  artifacts:
    reports:
      dependency_scanning: gl-dependency-scanning-report.json
```

If you wish to just use the scanner in one of your current scripts, the easiest way to do this, is to just install it via NPM:

```sh
npm i --global @jitesoft/audit-for-gitlab
cd /my/project/dir
audit-for-gitlab
cat gl-dependency-scanning-report.json
```

## Dockerfile

The dockerfile is rebuilt on each new version of the scanner released, each build is released for ARM64 and AMD64.  

## Env variables

The following env variables can be used to configure the behaviour of the application slightly:

`SECURE_LOG_LEVEL` - Will change the log level to report more or less output.  
Available levels are: `fatal`, `error`, `warn`, `info`, `debug`though only debug, info and fatal are used in the application.  
The debug level is basically only used for debugging purposes and development. `info` is default.

`SCAN_EXIT_CODE` - Will force a specific exit code in case of a moderate, high or critical vulnerability is found.  
In case this is not set, exit code `1` will be used in the cases above, else `0`.
npm package: @jitesoft/babel-preset-react
Description: Babel preset for react with configurations for jitesoft projects.
Author: Johannes Tegnér
Latest version: 4.4.0

# @jitesoft/babel-preset-react

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/babel-preset-react)](https://www.npmjs.com/package/@jitesoft/babel-preset-react)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/babel-preset-react/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/babel-preset-react)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/babel-preset-react/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/babel-preset-react/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/babel-preset-react)](https://www.npmjs.com/package/@jitesoft/babel-preset-react)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

React preset for Jitesoft javascript projects which uses babel.

Includes the following presets and plugins:

```
@jitesoft/preset-main
@babel/plugin-transform-react-display-name
@babel/plugin-transform-react-jsx
@babel/plugin-syntax-jsx

@babel/plugin-transform-react-inline-elements *
@babel/plugin-transform-react-constant-elements *
@babel/plugin-transform-react-jsx-compat *
```

_* Packages will only be used if they are added to the `include` array of the options object._

If babel is in development mode, the following plugins will be enabled:

```
@babel/plugin-transform-react-jsx-source
@babel/plugin-transform-react-jsx-self
```

Requires `corejs (v 3+)` and `@babel/core`.

## Options

Other than the default presets in [`@jitesoft/babel-preset-main`](https://gitlab.com/jitesoft/open-source/javascript/babel-preset-main), the following options
are available:

* `useBuiltIns` (boolean) - Use built ins instead of polyfill. Uses same value as passed for the main preset (defaults to `false`).
* `include` (array) - Addition for the three plugins marked with `*` in the above list (defaults to empty array).

The following options are prefixed with 'react' and corresponds to the options of the `transform-react-jsx` plugin.  
(Prefixed with `react.` since v2.0.0).

* `react.useSpread` (boolean) - Uses js props spread instead of babel helper. Defaults to `false`.
* `react.throwIfNamespace` (boolean) - Makes babel throw an error if using xml namespaces. Defaults to `true`.
* `react.runtime` (string) - `classic` or `automatic`, defaults to `classic`.

if runtime is set to `classic` (default) the following options are available:

* `react.pragma` (string) - Defines which create element method to use. Defaults to `React.createElement`.
* `react.pragmaFrag` (string) - Defines which Fragment component to use. Defaults to `React.Fragment`.

if runtime is set to `automatic` the following options are available:

* `react.importSource` (string) - defaults to `react`.
npm package: @jitesoft/dbal
Description: Interfaces for minimal database implementations.
Author: Johannes Tegnér
Latest version: 1.0.3

# @jitesoft/dbal

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/dbal)](https://www.npmjs.com/package/@jitesoft/dbal)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/dbal/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/dbal)
[![pipeline status](https://gitlab.com/jitesoft/open-source/node/dbal/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/node/dbal/commits/master)

Super simple database abstraction layer for nodejs.

## Intention

This project is intended as an interface for very very simple db wrappers.  
The only required methods to implement for a new implementation are the following:

* create (table)
* insert (one or many)
* select (one or many)
* update (one or many)
* delete (one or many)

That means, the `database` does not have to be a full database engine, rather just a single database in which tables can
be manipulated.

Currently, no implementations exists, only the abstract interface, which is intended to be used with WebPack and `import`.
npm package: @jitesoft/eslint-config
Description: Semi-standard bundled for simple modification by Jitesoft org.
Author: Johannes Tegnér
Latest version: 4.2.7

# @jitesoft/eslint-config

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/eslint-config)](https://www.npmjs.com/package/@jitesoft/eslint-config)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/eslint-config/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/eslint-config)
[![npm](https://img.shields.io/npm/dt/@jitesoft/eslint-config)](https://www.npmjs.com/package/@jitesoft/eslint-config)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

Semi-standard shareable config to make it easier to modify by Jitesoft organization.

Installation:

```bash
npm i --save-dev @jitesoft/eslint-config

yarn add --dev @jitesoft/eslint-config
```

## Configurations

There are four configurations available:

`default`, `node`, `browser`, `jsx` and `jest`.  
 
As expected, the Node and Browser configurations are set to use globals for the environment.
The `default` configuration is a mixed node/web configuration, while the `jest` configuration
is created for code which uses the `jest` test framework.  
 
## Usage

To extend the base/default config, just use the scoped name as such:

```json
{
  "extends": "@jitesoft"  
}
```

To be able to use the other configurations, the whole name have to be included:

```json
{
  "extends": "@jitesoft/eslint-config/jest"
}
```

## QA

Q:   
Why?
  
A:   
For an organization it's easier to keep a bundle of configurations than using a million little packages in each package.json file.
This package contains all the standards used by Jitesoft.  
Further more, if we wish to change any rules, it's a lot easier to do that in our own package than propagate it through settings files in all
repositories!

Q:  
Why hard versions in the package.json file?

A:  
To make sure that all the packages are in the exact version that we thought they where at each publish, the versions
of the sub-packages have been set to exact versions. It's hard to test and make sure that everything works as intended in case
some users use later or earlier versions (even if it is patch versions!) without knowing.

Q:  
Why semistandard and not just standard?!

A:  
Cause semicolon is best. Thats why!

Q:  
Why spaces instead of tabs?!

A:  
....
npm package: @jitesoft/group-by
Description: Makes all entries of an array - which returns a given key from callback - grouped under its key in resulting object.
Author: Johannes Tegnér
Latest version: 1.9.7

# Group By

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/group-by)](https://www.npmjs.com/package/@jitesoft/group-by)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/group-by/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/group-by)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/group-by/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/group-by/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/group-by/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/group-by-by/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/group-by)](https://www.npmjs.com/package/@jitesoft/group-by)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

Simple method to group an array by a given key in the array. The method uses a callback function to choose the 
value to group the values by and returns an object which have all the ordered values in an array under the given key name.

## Example:

```js
import groupBy from '@jitesoft/group-by';

let array = [ { "id": "abc", "value": "abc" },
              { "id": "abc", "value": "def" },
              { "id": "abc", "value": "ghi" },
              { "id": "def", "value": "abc" },
              { "id": "def", "value": "def" },
              { "id": "ghi", "value": "abc" } ];

let result = groupBy(array, (obj) => obj.id);

// Output:
let obj = {
       abc: [
         { "id": "abc", "value": "abc" },
         { "id": "abc", "value": "def" },
         { "id": "abc", "value": "ghi" }
       ],
       def: [
         { "id": "def", "value": "abc" },
         { "id": "def", "value": "def" }
       ],
       ghi: [
         { "id": "ghi", "value": "abc" }
       ]
};
```
npm package: @jitesoft/microtest
Description: Minimal test lib.
Author: Johannes Tegnér
Latest version: 0.1.0

# MicroTest

No framework test framework!

This is actually just a few methods throwing errors in case of test failures. No test counting, no coverage
no nothing, just test!

## Why?

During automated client-side testing, we required a minimal test helper to throw errors on failures.  

## What?
  
MicroTest exposes the following methods on the `MicroTest` object:

```javascript
throws
throwsSync
notThrows
notThrowsSync
isType
isInstance
isEqual
```

There are three files you may use to test:

* `dist/index.js`, built to run on latest JS engines (latest 1 version of chrome and firefox).
* `dist/index-compat.js`, built to run on most modern browsers.
* `src/index.js`, original source. 

## When?

June 8'th 4:30 PM. Not before, not after.

# How?

If including it as source via `import`, use the exported methods right away:

```javascript
import {throws} from '@jitesoft/microtest';
await throws(() => {
  throw new Error('Error plx!');
})
```

If using one of the dist files, the `MicroTest` object is populated with all of the methods:

```javascript
await MicroTest.throws(() => {
  throw new Error('Error plx!');
});
```
npm package: @jitesoft/npm-boilerplate
Description: Boilerplate for quick initialization of npm packages. Includes webpack, babeljs and some other base packages.
Author: Johannes Tegnér
Latest version: 2.0.5

# Boilerplate

Simple JavaScript package boilerplate generator.

This package is mainly intended to be used by the Jitesoft org, while it's okay to use it by anyone that wishes to!  

## What it does:

Creates a new project with pre-filled files to get you started right away!  
The following configuration files will be added to the project on initialization:

  * .babelrc.json  
  * .eslintrc.json
  * webpack.config.js
  * .gitlab-ci.yml

It will also add your license, a gitignore file and set up a standard directory structure.

### Important note

When the initialization runs, the package will download some external files, which are used as templates, the following URI's are accessed:

  * https://raw.githubusercontent.com/github/gitignore/master/Node.gitignore
  * https://api.github.com/licenses
  * https://api.github.com/licenses/LICENSE
  * https://gist.githubusercontent.com/JiteBot/fe9a847ef01239f86df00f337b8bc63e/raw/VERSION/_package.json
  * https://gist.githubusercontent.com/JiteBot/fe9a847ef01239f86df00f337b8bc63e/raw/VERSION/_gitlab.yml
  * https://gist.githubusercontent.com/JiteBot/fe9a847ef01239f86df00f337b8bc63e/raw/VERSION/_webpack.js

Where `VERSION` is depending on the version of this package that is used and `LICENSE` depends on which license you decide to use.

I recommend that you double-check the URI's that the program accesses and also check all the files afterwards to make sure that nothing is
wrong or odd, as you should with everything a third party downloads!

## Commands

To create a new project, run:

```bash
npx @jitesoft/npm-boilerplate init <package-name>
```

And answer the questions.  

If you run the `help init` command you will be able to get information about all possible optional parameters that the
generator honours.

### License

```text
MIT License

Copyright (c) 2018 Jitesoft

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```
npm package: @jitesoft/order-by
Description: Makes all entries of an array - which returns a given key from callback - ordered under its key in resulting object.
Author: Johannes Tegnér
Latest version: 1.0.3
Deprecated: This package have a name which does not describe its usage. Please use the new and actively maintained package at @jitesoft/group-by.

# Order By

Simple method to order an array by a given key in the array. The method uses a callback function to choose the 
value to order the items by and returns an object which have all the ordered values in an array under the given key name.

## Example:

```js
import orderBy from '@jitesoft/order-by';

let array = [ { "id": "abc", "value": "abc" },
              { "id": "abc", "value": "def" },
              { "id": "abc", "value": "ghi" },
              { "id": "def", "value": "abc" },
              { "id": "def", "value": "def" },
              { "id": "ghi", "value": "abc" } ];

let result = orderBy(array, (obj) => obj.id);

// Output:
let obj = {
       abc: [
         { "id": "abc", "value": "abc" },
         { "id": "abc", "value": "def" },
         { "id": "abc", "value": "ghi" }
       ],
       def: [
         { "id": "def", "value": "abc" },
         { "id": "def", "value": "def" }
       ],
       ghi: [
         { "id": "ghi", "value": "abc" }
       ]
};

```
npm package: @jitesoft/random-string
Description: Cross environment random string generator.
Author: Johannes Tegnér
Latest version: 1.4.7

# @jitesoft/random-string

Random string generator with a shared api for both node and web.

Usage:

```javascript
import random from '@jitesoft/random-string';
const randomString = random(128, { minSpecial: 5 }); 
console.log(randomString);
// random string with a minimum of 5 special characters and a full length of 128 characters.
```

If you wish to access the specific files by absolute paths, they are located at `@jitesoft/random-string/dist/index.node.js` and `@jitesoft/random-string/dist/index.web.js`.

## Information

### Randomness

The random generator for the node version uses the `crypto` library to generate random characters while the web version
uses the web `crypto` api. If web crypto api is not available, it will fallback to using the `Math.random` function.  
The `Math.random` function is NOT a cryptographically secure algorithm, the randomness should be good enough, but do not
use the fallback in cases where high security is a must.

### Characters

The following characters are used (char codes):

Alpha: `65-90` & `97-122`  
Numbers: `48-57`  
Special: `33-47` & `58-64` & `91-96` & `123-126`

## Options

The following options (with defaults shown) can be passed as an object as the second argument of the function:

```json
{
    "special": true,
    "numbers": true,   
    "alpha": true,
    "minSpecial": 0,
    "minNumbers": 0,
    "minAlpha": 0
}
```

This allows for a bit more specific generation of strings, default values are used for anything not set when parsing the options.

## Source

The source code is kept intact under the `src` directory in the package. This is so that you may use the code directly if you wish to convert
it with your own bundler or converter.
npm package: @jitesoft/sprintf
Description: Sprintf function for javascript.
Author: Johannes Tegnér
Latest version: 2.1.7

# Sprintf

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/sprintf)](https://www.npmjs.com/package/@jitesoft/sprintf)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/sprintf/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/sprintf)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/sprintf/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/sprintf/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/sprintf/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/sprintf/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/sprintf)](https://www.npmjs.com/package/@jitesoft/sprintf)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

JS implementation of the useful `sprintf` c-function.  
We try to keep the API as close to the original implementation as possible, while some features might be hard to implement in
JavaScript the following features are available:

## Placeholder support.

```text
%i: Integer (decimal)
%d: Integer (decimal)
%o: Octal
%x: Hex (lower case)
%X: Hex (upper case)
%e: Scientific notation (lower case)
%E: Scientific notation (upper case)
%f: Float
%a: Hex float (lower case)
%A: Hex float (upper case)
%c: Char
%s: String
%j: Json (object which will be stringified if possible)
 ```

## Precision support for float.

By using the `%.<number>f` syntax, you are able to specify precision for float types (`f`, `a`, `A`). If 
precision is higher than the value passed, 0's will be appended to the result and it will not be rounded, while
if the value is longer (char count) than the precision value, it will cut the result at the specific point.

Example:

```javascript
const floatP  = sprintf('abc %.5f', 1.12345678); // 'abc 1.12345'
const floatP2 = sprintf('abc %.5f', 1.12);       // 'abc 1.12000'
```

## Left-padding support for integer.

The same syntax as for floats can be used to pad integers (`d`, `i`) with 0's.  
If the pad value is lower than the length of the integer, nothing will happen.

```javascript

const intP  = sprintf('abc %.5s', 123); // 'abc 00123'
const intP2 = sprintf('abc %.1s', 123); // 'abc 123'
```

## Sub-strings 

The same syntax as for integer and floats can be used to substring strings.  
If the string is shorter than the value, nothing will be changed.

```javascript

const stringP  = sprintf('abc %.5s', 'abc123abc');     // 'abc abc12'
const stringP2 = sprintf('abc %.10000s', 'abc123abc'); // 'abc abc123abc'
```

## Missing features to be implemented in future versions:

* Flags
    * `%.*` precision specifier
    * `width` specifier
    * `*width` specifier
    * `%-` left justify
    * `%+` right justify
    * `%space` pad, 
    * `%#` prefix for octal and hex
    * `%0` 0-pad
* Specifiers
    * `g`, `G` for shortest rep of `%e/%f` & `%E/%F`.
npm package: @jitesoft/yolog-file-plugin
Description: File logging plugin for @jitesoft/yolog.
Author: Johannes Tegnér
Latest version: 1.4.6

# Yolog File Plugin

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/yolog-file-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-file-plugin)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/yolog-file-plugin/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/yolog-file-plugin)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/file/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/file/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/file/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/file/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/yolog-file-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-file-plugin)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

Plugin for the [`@jitesoft/yolog`](https://www.npmjs.com/package/@jitesoft/yolog) logger to write to files.

Due to the filesystem requirement a FS module is needed, this is not available in the browser, so this plugin
is not suitable in the browser!

If you wish to log json strings in common json log format to file, be sure to check out the [yolog json plugin](https://github.com/jitesoft/yolog-json-plugin)!

Usage:

Install with your favorite package manager!

```bash
npm i @jitesoft/yolog-file-plugin --save
yarn add @jitesoft/yolog-file-plugin
```

Import and use just as with any other yolog plugin!

```js
import logger from '@jitesoft/yolog';
import FilePlugin from '@jitesoft/yolog-file-plugin';
logger.addPlugin(new FilePlugin('path/to/log/dir', 'debug.log'));
```
npm package: @jitesoft/yolog-json-plugin
Description: Plugin for @jitesoft/yolog to output logs as JSON.
Author: Johannes Tegnér
Latest version: 1.1.6

# Yolog JSON Plugin

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/yolog-json-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-json-plugin)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/yolog-json-plugin/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/yolog-json-plugin)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/json/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/json/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/json/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/json/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/yolog-json-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-json-plugin)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)

Plugin for the [`@jitesoft/yolog`](https://www.npmjs.com/package/@jitesoft/yolog) logger create logs in json format.  
When running in the browser, all the data will be printed to the console, while, when using the nodejs version
the data can either be pushed to a file or to the stdout/stderr of the application.

## Usage:

Install with your favorite package manager!

```bash
npm i @jitesoft/yolog-json-plugin --save
yarn add @jitesoft/yolog-json-plugin
```

Import and use just as with any other yolog plugin!

```js
import logger from '@jitesoft/yolog';
import JsonPlugin from '@jitesoft/yolog-json-plugin';
logger.addPlugin(new JsonPlugin('file.txt'));
```

To import it in a browser environment, the `src/browser` (or `/dist/browser` for precompiled) suffix have to be added:

```js
import logger from '@jitesoft/yolog';
import JsonPlugin from '@jitesoft/yolog-json-plugin/src/browser';
logger.addPlugin(new JsonPlugin()); // No file!
```

## Data format

Each line in the output is a single JS Object notation, that is, the full file is not an array of json objects, but each
line should be parsed as its own.  

Example: 

```json
{"tag": "emergency", "timestamp": 123123123, "message": "abc123!!", "error":  { "message": "error message!", "stack": [ "callstack here." ] }}
{"tag": "warning", "timestamp": 123123124, "message": "abc123"}
```

That means that when parsing the file (or output), each line should be parsed as its own object.
npm package: @jitesoft/yolog-sentry-plugin
Description: Plugin for @jitesoft/yolog to output errors and messages to sentry.
Author: Johannes Tegnér
Latest version: 1.4.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Yolog Sentry plugin

[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/yolog-sentry-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-sentry-plugin)
[![Known Vulnerabilities](https://snyk.io/test/npm/@jitesoft/yolog-sentry-plugin/badge.svg)](https://snyk.io/test/npm/@jitesoft/yolog-sentry-plugin)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/sentry/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/sentry/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/sentry/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/sentry/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/yolog-sentry-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-sentry-plugin)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)


Plugin for the [`@jitesoft/yolog`](https://www.npmjs.com/package/@jitesoft/yolog) logger to post logs and errors to Sentry.

## Usage:

Install with your favorite package manager!

```bash
npm i @jitesoft/yolog-sentry-plugin --save
yarn add @jitesoft/yolog-sentry-plugin
```

The plugin uses the `@sentry/minimal` package to make sure that it works on both browser and node alike.
You have to install the sentry plugin required for your current environment (`@sentry/node`, `@sentry/browser`) 
and set it up as you wish.  
When that is done, the `yolog-sentry-plugin` will be able to send its logs and errors to sentry.

```js
import logger from '@jitesoft/yolog';
import SentryPlugin from '@jitesoft/yolog-sentry-plugin';
import * as Sentry from '@sentry/node (or browser)';

Sentry.init({
  dsn: 'some-dsn-to-connect-to-sentry'
});

logger.addPlugin(new SentryPlugin());
logger.alert('Oh no!');
```

It is possible to add `tags`, `extras` and `user` to the data sent to sentry, the way to do this is to
add a `provider` to the plugin statically.  
The providers are callback functions which will be used to fetch the data required. The `tags` and `extras` providers
should return objects with standard key-value pairs while the `userProvider` should return a user object. For more documentation on what values are expected and/or 
what will happen to them, refer to the Sentry [documentation](https://docs.sentry.io/platforms/javascript/#adding-context).

Currently, the `fingerprint` is the full message that is passed through the logger.
npm package: @jitesoft/yolog-slack-plugin
Description: Plugin for @jitesoft/yolog to output logs to slack.
Author: Johannes Tegnér
Latest version: 2.0.6

# Yolog Slack plugin


[![npm (scoped)](https://img.shields.io/npm/v/@jitesoft/yolog-slack-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-slack-plugin)
[![Known Vulnerabilities](https://dev.snyk.io/test/npm/@jitesoft/yolog-slack-plugin/badge.svg)](https://dev.snyk.io/test/npm/@jitesoft/yolog-slack-plugin)
[![pipeline status](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/slack/badges/master/pipeline.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/slack/commits/master)
[![coverage report](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/slack/badges/master/coverage.svg)](https://gitlab.com/jitesoft/open-source/javascript/yolog-plugins/slack/commits/master)
[![npm](https://img.shields.io/npm/dt/@jitesoft/yolog-slack-plugin)](https://www.npmjs.com/package/@jitesoft/yolog-slack-plugin)
[![Back project](https://img.shields.io/badge/Open%20Collective-Tip%20the%20devs!-blue.svg)](https://opencollective.com/jitesoft-open-source)


Plugin for the [`@jitesoft/yolog`](https://www.npmjs.com/package/@jitesoft/yolog) logger to post logs to Slack.

This plugin makes use of the slack WebHooks, hence it is only supported on the server side and not browser.

![Example view](https://raw.githubusercontent.com/jitesoft/yolog-slack-plugin/master/example.png)

## Usage:

Install with your favorite package manager!

```bash
npm i @jitesoft/yolog-slack-plugin --save
yarn add @jitesoft/yolog-slack-plugin
```

Import and use just as with any other yolog plugin!

```js
import logger from '@jitesoft/yolog';
import SlackPlugin from '@jitesoft/yolog-slack-plugin';
logger.addPlugin(new SlackPlugin('https://webhook/uri'));
```

The constructor of the slack plugin takes a slack webhook uri, (please check the slack documentation on how to acquire
one of those) and an optional channel with the `#` prefix (or user with the `@` prefix). If the channel argument is not 
set, it will use the default channel set up with the webhook.

### Notification

The notification text can be changed with the `notificationText` setter. It defaults to `A log message with the tag '%s' was logged!` where `%s` will be changed the tag name.  
You may also add another `%s` (check the [`@jitesoft/sprintf`](https://www.npmjs.com/package/@jitesoft/sprintf) module for more info about the placeholders) which will be changed to the log message.

### Call stack

In case the message is one of the 'higher level' logging types (error, critical, alert or emergency), the call stack (from the yolog #log method as of now) will be printed as an extra section in the message.
npm package: @jitforms/astro
Description: Astro component and client helper for JitForms — drop-in <JitForm> for .astro files.
Author: El Mehdi El fatihi
Latest version: 0.1.0

# @jitforms/astro

Astro integration for [JitForms](https://jitforms.com). Works in both static and island (`client:*`) modes.

## Installation

```bash
npm install @jitforms/astro
```

## Usage

### Using the Astro Component

```astro
---
import JitForm from '@jitforms/astro/JitForm.astro';
---

<JitForm formHash="abc123" honeypot redirect="/thank-you">
  <label>Email <input name="email" type="email" required /></label>
  <span data-jitform-error="email"></span>
  <button type="submit">Subscribe</button>
  <p data-jitform-success style="display:none">Thanks!</p>
</JitForm>
```

### Using the Client Helper Directly

```astro
<form id="contact" data-jitform="abc123">
  <input name="email" />
  <button type="submit">Send</button>
</form>

<script>
  import { initForm } from '@jitforms/astro';
  const form = document.getElementById('contact') as HTMLFormElement;
  initForm(form, 'abc123');
</script>
```

### Auto-Initialization

Any form with a `data-jitform` attribute is automatically initialized when using the `JitForm.astro` component or calling `initAll()`:

```astro
<script>
  import { initAll } from '@jitforms/astro';
  document.addEventListener('DOMContentLoaded', initAll);
</script>
```

## Props

| Prop       | Type      | Default | Description                          |
| ---------- | --------- | ------- | ------------------------------------ |
| `formHash` | `string`  | —       | Your JitForms form hash (required)   |
| `baseUrl`  | `string`  | —       | Custom API base URL                  |
| `honeypot` | `boolean` | `false` | Enable honeypot spam protection      |
| `redirect` | `string`  | —       | URL to redirect to after submission  |
| `class`    | `string`  | —       | CSS class for the form element       |

## CSS Classes

The form element receives these classes automatically during submission:

- `jf-loading` — while the submission is in progress
- `jf-success` — after a successful submission
- `jf-error` — after a validation error

## Data Attributes

- `data-jitform-error="fieldName"` — element to display validation errors for a field
- `data-jitform-success` — element shown on successful submission (initially hidden with `display:none`)

## License

MIT
npm package: @jithen/circleci-v2-sdk
Description: Typescript SDK for v2 CircleCI API
Author: Jithen Shriyan
Latest version: 1.1.0

# @jithen/circleci-v2-sdk

> The Typescript CircleCI V2 SDK for Browsers and Node.js.
> The `@jithen/circleci-v2-sdk` package integrates pipelines, workflows, and jobs from CircleCI

- Coming Soon: Insights, Project, Schedule, and User API Support

## Features

- **Universal**. Works in all modern browsers and [Node.js](https://nodejs.org/)
- **Tested**. All modules have extensive test coverage.
- **Typed**. All modules have TypeScript declarations.

## [Docs](https://jithenshriyan.github.io/circleci-v2-sdk/)
npm package: @jithinjz/easy-react
Description: Create a Vite + React app preconfigured with Tailwind CSS and optional packages (Axios, Redux Toolkit, Zustand, React Query) with a Next.js-style CLI.
Author: Jithin JZ
Latest version: 1.0.6

# easyreact

A clean, Next.js–style CLI that spins up a **Vite + React** project with **Tailwind CSS** (only) and optional dev-friendly packages:

- Axios
- Redux Toolkit
- Zustand
- React Query (@tanstack/react-query)

## Usage

```bash
npx easyreact
# or locally during development
npm link
easyreact
```

## What it does

- Creates a Vite + React app
- Installs and configures **Tailwind CSS** with Vite (using `@tailwindcss/vite`)
- Replaces default boilerplate with a clean welcome screen
- Sets up folders: `components/`, `pages/`, `hooks/`, `store/`, `utils/`, `assets/`
- Optionally wires up Axios, Redux Toolkit, Zustand, and/or React Query
npm package: @jithyan/git-branch-manager
Description: Simple CLI to avoid typing out full git branch names for switching or deleting branches.
Author: jithyan
Latest version: 3.0.3

# git-branch-manager

Simple CLI to conveniently switch, remove and checkout remote branches without having to type out full branch names.
It also has a few other shorthand commands that I find helpful.

As of v3, it is written in Rust.

## Get started

> This will only will work with Node 16 and above

```bash
npm install -g @jithyan/git-branch-manager
```

Now you can run it by calling `gbm`.

## How to use

1. `cd` into a `git` repo.
2. Run `gbm <command>`

## Available commands

### switch (sw)

Allows you to select a local branch to switch to. Equivalent to running `git checkout <selected_branch_name>`.

Example:

`gbm switch`

![switch example](./img/switch.png)

### remove (rm)

Allows you to select a branch that is checked out locally to remove. Equivalent to running `git branch -D <selected_branch_name>`.

Example:

`gbm remove`

![remove example](./img/remove.png)

### add

Allows you to filter branches from remote and select a branch to checkout locally. Equivalent to running `git fetch && git checkout <selected_branch_name>`.

Example:

`gbm add`

![add example](./img/add.png)

### rb <branch_name>

Equivalent to running `git fetch && git pull origin <branch_name> -r`

Example:

`gbm rb main`

![stash example](./img/rb.png)

### pff

Equivalent to running `git fetch && git pull --ff-only`

Example:

`gbm pff`

![stash example](./img/pff.png)

### ct <branch_name>

Transfer **all** changes in the current branch (tracked and untracked) to a new branch and commit it with the message "initial commit".

Equivalent to running:

```sh
git add .
git stash
git checkout -b <branch_name>
git stash pop
git add .
git commit -m "initial commit"
```

Example:

`gbm ct fix-bug`

![stash example](./img/ct.png)
npm package: @jithyan/git-branch-manager-darwin-x64
Description: Simple CLI to avoid typing out full git branch names for switching or deleting branches.
Author: jithyan
Latest version: 3.0.3

# `@jithyan/git-branch-manager-darwin-x64`

This is the **x86_64-apple-darwin** binary for `@jithyan/git-branch-manager`
npm package: @jithyan/git-branch-manager-linux-x64-gnu
Description: Simple CLI to avoid typing out full git branch names for switching or deleting branches.
Author: jithyan
Latest version: 3.0.3

# `@jithyan/git-branch-manager-linux-x64-gnu`

This is the **x86_64-unknown-linux-gnu** binary for `@jithyan/git-branch-manager`
npm package: @jithyan/git-branch-manager-win32-x64-msvc
Description: Simple CLI to avoid typing out full git branch names for switching or deleting branches.
Author: jithyan
Latest version: 3.0.3

# `@jithyan/git-branch-manager-win32-x64-msvc`

This is the **x86_64-pc-windows-msvc** binary for `@jithyan/git-branch-manager`