open-index/open-npm huggingface dataset:
npm package: @forthlaw/email
Description: ## Environment Variables ``` POSTMARK_TOKEN EMAIL_ON EMAIL_FROM ``` ### Notes
Latest version: 1.1.0

# @forthlaw/email

## Environment Variables
```
POSTMARK_TOKEN
EMAIL_ON
EMAIL_FROM
```
### Notes

## Methods
```
sendPlainText({ From, To, Subject, TextBody })
```
For more information on what is possible, refer to Postmark documentation at <https://github.com/wildbit/postmark.js/wiki/Email-sending>.
npm package: @forthlaw/sms
Description: ## Environment Variables ``` TWILIO_ACCOUNT_SID TWILIO_AUTH_TOKEN SMS_ON SMS_FROM ``` ### Notes
Latest version: 1.0.1

# @forthlaw/sms

## Environment Variables
```
TWILIO_ACCOUNT_SID
TWILIO_AUTH_TOKEN
SMS_ON
SMS_FROM
```
### Notes

## Methods
```
sendSMS({ from, to, body })
```
For more information on what is possible, refer to Postmark documentation at <https://github.com/wildbit/postmark.js/wiki/Email-sending>.
npm package: @forthlaw/styles
Description: ### Notes Front end styling for the Forthlaw suite of Vue projects.
Latest version: 1.0.1

# @forthlaw/styles

### Notes
Front end styling for the Forthlaw suite of Vue projects.

## Example: Styles.Default
This simply returns the filepath for the ```scss``` file that can be used to compile/required back into the Vue project. In your ```nuxt.config.js```:
```
import styles from '@forthlaw/styles'

export default {
	
	...,

  css: [
    '@/static/app.css',
    '@/assets/app.scss',
    styles.Default,
  ],

}
```
This way, you can override the default styling, but have it as your base in any Vue project.
npm package: @forthright48/simplecss
Description: A simple css library using flexbox for layout
Author: Mohammad Samiul Islam
Latest version: 1.3.0

# SimpleCSS

A simple minimalistic CSS framework that uses flexbox grid.

Please, do not expect anything from the framework, cause I am not sure what I am doing.

## Normalize.css

First of all, include normalize.css file from src in the project to normalize browser behavior. Refer to [Normalize.css](https://necolas.github.io/normalize.css/) for more details.

## Row, Column, Tower and Container

The whole flexbox system depends on the following four classes: `container, tower, row, col`.

'container' is a vertical flex-container. Originally it was a class to determine the width of the site, but later turned into flex only for one reason: sticky footer. The container should be used to create stick-footer only. It should appear right after body tag only and no where else.

In case we need vertical flex-container, we can use `tower`. It is a flex-container and if nested in another container will also act as flex item.

`row` is a horizontal flex-container, which can act as a container if nested.

`item` is flex-item only.

## `one`, `two`, `three` ... `twelve` and `any`

The literal numbers `one`, `two` and such forms the basis of the flex items. `any` means there is no fixed basis, it will dynamically allocate the basis like a normal flexbox.

## Sticky Footer
Based on the article [Sticky Footer](https://philipwalton.github.io/solved-by-flexbox/demos/sticky-footer/), the following will create sticky footer:

```
<div class="container">

  <header class="row">
  </header>

  <main class="u-flex">
  </main>

  <footer class="row">
  </footer>

</div>
```

Note the `u-flex` class on main tag. That class forces the main tag to use up all the empty space around, thus pushing the footer to bottom.
npm package: @forthtilliath/tailwind-plugins
Description: Set of plugins for tailwind, such as text-shadow, scrollbar, etc
Author: Forthtilliath
Latest version: 1.1.0

# Tailwind Plugins

> Set of plugins for tailwind, such as text-shadow, scrollbar, etc

Install the plugin from npm:

```
$ npm install tailwind-plugins
```

Then add the plugin to your `tailwind.config.js` file:

```js
// tailwind.config.js
import { textShadowPlugin } from '@forthtilliath/tailwind-plugins';

module.exports = {
  // ...
  plugins: [textShadowPlugin()]
};
```

This plugin will generate following CSS:

```css
/* ... */
*, ::before, ::after {
  --tw-text-shadow-x: 0px;
  --tw-text-shadow-y: 0px;
  --tw-text-shadow-blur: 0px;
  --tw-text-shadow-color: #000;
}
.text-shadow-base {
  text-shadow: var(--tw-text-shadow-x) var(--tw-text-shadow-y) var(--tw-text-shadow-blur) var(--tw-text-shadow-color);
}
.text-shadow-outline {
  text-shadow: 
    -1px -1px var(--tw-text-shadow-blur) var(--tw-text-shadow-color),  
     0px -1px var(--tw-text-shadow-blur) var(--tw-text-shadow-color),  
     1px -1px var(--tw-text-shadow-blur) var(--tw-text-shadow-color), 
    -1px  0px var(--tw-text-shadow-blur) var(--tw-text-shadow-color),  
     0px  0px var(--tw-text-shadow-blur) var(--tw-text-shadow-color),  
     1px  0px var(--tw-text-shadow-blur) var(--tw-text-shadow-color), 
    -1px  1px var(--tw-text-shadow-blur) var(--tw-text-shadow-color),  
     0px  1px var(--tw-text-shadow-blur) var(--tw-text-shadow-color),  
     1px  1px var(--tw-text-shadow-blur) var(--tw-text-shadow-color)
}
.text-shadow-x-[spacing] {
  --tw-text-shadow-x: [spacing];
}
.text-shadow-y-[spacing] {
  --tw-text-shadow-y: [spacing];
}
.text-shadow-blur-[spacing] {
  --tw-text-shadow-blur: [spacing];
}
.text-shadow-[color] {
  --tw-text-shadow-color: [color];
}
/* ... */
```

## License

Tailwind Plugins is licensed under the MIT License.
npm package: @fortify-ts/fallback
Description: Fallback pattern for graceful degradation in @fortify-ts
Latest version: 0.2.1

# @fortify-ts/fallback

Fallback pattern for the Fortify-TS resilience library.

## Installation

```bash
npm install @fortify-ts/fallback
# or
pnpm add @fortify-ts/fallback
```

## Features

- **Default Values**: Return fallback on failure
- **Alternative Operations**: Execute backup operation on failure
- **Custom Predicates**: `shouldFallback` callback
- **Notifications**: `onFallback` and `onSuccess` callbacks

## Usage

### Basic Usage

```typescript
import { Fallback } from '@fortify-ts/fallback';

const fallback = new Fallback<User>({
  fallback: () => ({ id: 0, name: 'Guest' }),
});

// Returns Guest user if operation fails
const user = await fallback.execute(async (signal) => {
  return fetchUser(userId, { signal });
});
```

### With Error Context

```typescript
const fallback = new Fallback<Response>({
  fallback: (error) => {
    console.log(`Falling back due to: ${error.message}`);
    return cachedResponse;
  },
});
```

### Custom Fallback Condition

```typescript
const fallback = new Fallback<Response>({
  fallback: () => defaultResponse,

  // Only fallback on network errors
  shouldFallback: (error) => {
    return error instanceof NetworkError;
  },
});
```

### Configuration Options

```typescript
const fallback = new Fallback<Data>({
  // Fallback function (required)
  fallback: (error) => defaultData,

  // Custom fallback condition
  shouldFallback: (error) => error instanceof NetworkError,

  // Notification on fallback
  onFallback: (error) => {
    metrics.increment('fallback.activated');
  },

  // Notification on success
  onSuccess: (result) => {
    metrics.increment('primary.success');
  },

  // Optional logger
  logger: myLogger,
});
```

### Async Fallback

```typescript
const fallback = new Fallback<Data>({
  fallback: async (error) => {
    // Fallback to cache
    return await cache.get('backup-data');
  },
});
```

## Configuration Reference

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `fallback` | function | required | Fallback function |
| `shouldFallback` | function | - | Custom condition |
| `onFallback` | function | - | Fallback callback |
| `onSuccess` | function | - | Success callback |
| `logger` | FortifyLogger | - | Optional logger |

## License

MIT
npm package: @fortify-ts/retry
Description: Retry pattern with backoff strategies for Fortify TS resilience library
Latest version: 0.2.1

# @fortify-ts/retry

Retry pattern with configurable backoff strategies for the Fortify-TS resilience library.

## Installation

```bash
npm install @fortify-ts/retry
# or
pnpm add @fortify-ts/retry
```

## Features

- **Backoff Policies**: Exponential, linear, and constant
- **Configurable Delays**: Initial delay, max delay, multiplier
- **Jitter Support**: Prevent thundering herd
- **Custom Predicates**: `isRetryable` callback
- **Retry Notifications**: `onRetry` callback

## Usage

### Basic Usage

```typescript
import { Retry } from '@fortify-ts/retry';

const retry = new Retry<Response>({
  maxAttempts: 3,
  initialDelay: 100,
});

const result = await retry.execute(async (signal) => {
  return fetch('/api/data', { signal });
});
```

### Configuration Options

```typescript
const retry = new Retry<Response>({
  // Maximum attempts (including initial)
  maxAttempts: 5,

  // Initial delay between retries (ms)
  initialDelay: 100,

  // Maximum delay between retries (ms)
  maxDelay: 10000,

  // Backoff policy
  backoffPolicy: 'exponential', // 'exponential' | 'linear' | 'constant'

  // Delay multiplier for exponential/linear
  multiplier: 2.0,

  // Add random jitter to delays
  jitter: true,

  // Custom retry condition
  isRetryable: (error) => {
    if (error instanceof NetworkError) return true;
    if (error instanceof ValidationError) return false;
    return true;
  },

  // Retry notification
  onRetry: (error, attempt) => {
    console.log(`Retry ${attempt}: ${error.message}`);
  },

  // Optional logger
  logger: myLogger,
});
```

### Backoff Policies

```typescript
// Exponential: delay = initialDelay * (multiplier ^ attempt)
// 100ms → 200ms → 400ms → 800ms → 1600ms
const exponential = new Retry({ backoffPolicy: 'exponential' });

// Linear: delay = initialDelay * (multiplier * attempt)
// 100ms → 200ms → 300ms → 400ms → 500ms
const linear = new Retry({ backoffPolicy: 'linear' });

// Constant: delay = initialDelay
// 100ms → 100ms → 100ms → 100ms → 100ms
const constant = new Retry({ backoffPolicy: 'constant' });
```

### Marking Errors as Retryable

```typescript
import { asRetryable, asNonRetryable } from '@fortify-ts/core';

// In your code, mark errors explicitly
if (isTemporary) {
  throw asRetryable(new Error('Temporary failure'));
} else {
  throw asNonRetryable(new Error('Permanent failure'));
}
```

## Configuration Reference

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `maxAttempts` | number | 3 | Maximum attempts |
| `initialDelay` | number | 100 | Initial delay (ms) |
| `maxDelay` | number | - | Maximum delay (ms) |
| `backoffPolicy` | string | 'exponential' | Backoff policy |
| `multiplier` | number | 2.0 | Delay multiplier |
| `jitter` | boolean | false | Add jitter |
| `isRetryable` | function | - | Custom retry check |
| `onRetry` | function | - | Retry callback |
| `logger` | FortifyLogger | - | Optional logger |

## License

MIT
npm package: @fortify-ts/timeout
Description: Timeout pattern for Fortify TS resilience library
Latest version: 0.2.1

# @fortify-ts/timeout

Timeout pattern for the Fortify-TS resilience library.

## Installation

```bash
npm install @fortify-ts/timeout
# or
pnpm add @fortify-ts/timeout
```

## Features

- **Default and Per-Operation Timeouts**: Configure default with override capability
- **Abort Signal Integration**: Proper cancellation support
- **Timeout Notifications**: `onTimeout` callback

## Usage

### Basic Usage

```typescript
import { Timeout } from '@fortify-ts/timeout';

const timeout = new Timeout<Response>({
  defaultTimeout: 5000, // 5 seconds
});

try {
  const result = await timeout.execute(async (signal) => {
    return fetch('/api/data', { signal });
  });
} catch (error) {
  if (error instanceof TimeoutError) {
    console.log('Request timed out');
  }
}
```

### Per-Operation Timeout

```typescript
// Use default timeout
await timeout.execute(operation);

// Override with specific timeout
await timeout.executeWithTimeout(operation, 10000); // 10 seconds
```

### Configuration Options

```typescript
const timeout = new Timeout<Response>({
  // Default timeout in milliseconds
  defaultTimeout: 5000,

  // Timeout notification
  onTimeout: (duration) => {
    console.log(`Operation timed out after ${duration}ms`);
  },

  // Optional logger
  logger: myLogger,
});
```

### With External Signal

```typescript
const controller = new AbortController();

// Both timeout and external signal can cancel
const result = await timeout.execute(
  async (signal) => fetch('/api/data', { signal }),
  controller.signal
);

// Cancel from external code
controller.abort();
```

## Configuration Reference

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `defaultTimeout` | number | 30000 | Default timeout (ms) |
| `onTimeout` | function | - | Timeout callback |
| `logger` | FortifyLogger | - | Optional logger |

## License

MIT
npm package: @fortionfortune/noderavel
Description: Laravel-NodeJs Queue Sync. This package is clone of Movilizame.
Author: FortionFortune
Latest version: 0.0.2

## Noderavel

Queue sync between NodeJS and Laravel using Redis driver. You can process Jobs dispatched from Laravel in NodeJS or biceversa. 

### Install

```bash
npm install @movilizame/noderavel --save
```

### Usage

* Listen for jobs on NodeJS:

```javascript
const Noderavel = require('@movilizame/noderavel');
const redis = require('redis');

redisCliente = redis.createClient(6379, 'localhost'); 

class TestJob {
    constructor(a, b) {
        this.a = a;
        this.b = b;
    }
}

let queueWorker = new Noderavel({
    client: redisCliente,
    driver: 'redis',
    scope: {
        'App\\Jobs\\TestJob': TestJob
    }
});

queueWorker.on('job', ({name, data}) => {
    console.log(name, data);
    // Proccess your jobs here.
});

queueWorker.listen();
```


* Schedule a job to be run in Laravel from NodeJS:

```javascript
const Noderavel = require ('@movilizame/noderavel');
const redis = require('redis');

const redisHost = 'localhost';
const redisPort = 6379;
redisCliente = redis.createClient(redisPort, redisHost); 

class TestJob {
    constructor(a, b) {
        this.a = a;
        this.b = b;
    }
}

let queueWorker = new Noderavel({
    client: redisCliente,
    driver: 'redis',
    scope: {
        'App\\Jobs\\TestJob': TestJob
    }
}); 

for (let i = 0; i < 10; i++) {
    let job = new TestJob('param1', i);
    queueWorker.redisPush('App\\Jobs\\TestJob', job);
}
```

__TestJob__ in Laravel: 

```php
<?php

namespace App\Jobs; 
use Illuminate\Contracts\Queue\ShouldQueue;

class TestJob extends Job implements ShouldQueue
{
    public $a, $b;
    public function __construct ($a, $b) {
        $this->a = $a;
        $this->b = $b;
    }

    function handle () {
        \Log::info('TestJob ' . $this->a . ' '. $this->b);
    }
}

```