open-index/open-npm huggingface dataset:
npm package: @sendsafely/sendsafely
Description: The SendSafely JavaScript SDK for Node.js lets you integrate SendSafely secure data transfer capabilities directly into your Node.js application.
Author: SendSafely
Latest version: 3.0.3


# SendSafely JavaScript API for Node.js

The SendSafely JavaScript API for Node.js lets you integrate SendSafely secure data transfer capabilities directly into your Node.js application. 

## Requirements

- **Node.js**: v24 or higher *(required starting from SDK v3.0.0)*

Please ensure you upgrade to Node v24 to take advantage of the latest features and maintain compatibility with our SDK v3.0.0 and later.

## Quickstart
The example below shows you how to install the package and use it as a CommonJS module.

Install with npm
```console
npm install @sendsafely/sendsafely
```

Include the SendSafely class to start making your API calls.

```javascript
var SendSafely = require('@sendsafely/sendsafely');
//var sendSafely = new SendSafely("https://demo.sendsafely.com", "exAPIkeyxyz", "exAPIsecretxyz");
var sendSafely = new SendSafely("https://ORGANIZATION_HOST", "API_KEY", "API_SECRET");

sendSafely.verifyCredentials(function(email)  {
	console.log("Connected to SendSafely as user "  +  email);
});

```

*You will need to generate your own API_KEY and API_SECRET from the API Keys section of your Profile page when logged into your SendSafely portal.*

## Examples
Please refer to our [Developer Website](https://sendsafely.github.io) to familiarize yourself with the core SendSafely API and common operations. See our [examples](https://github.com/SendSafely/JavaScript-Node-Client-API/tree/master/examples/CreateNewPackage) in GitHub for working examples of how to use the SendSafely JavaScript API for Node.js.  

## Support
For support, please contact support@sendsafely.com.
npm package: @sendspin/sendspin-js
Description: TypeScript client library for the Sendspin synchronized audio protocol
Author: Sendspin Protocol Authors
Latest version: 3.0.1

# sendspin-js

[![npm](https://img.shields.io/npm/v/@sendspin/sendspin-js.svg)](https://www.npmjs.com/package/@sendspin/sendspin-js)

TypeScript client library implementing the [Sendspin Protocol](https://www.sendspin-audio.com) for clock-synchronized audio streaming.

See the SDK website to see Sendspin JS in action: https://sendspin.github.io/sendspin-js/

[![A project from the Open Home Foundation](https://www.openhomefoundation.org/badges/ohf-project.png)](https://www.openhomefoundation.org/)

## Example

```typescript
import { SendspinPlayer } from '@sendspin/sendspin-js';

const player = new SendspinPlayer({
  playerId: 'my-player-id',
  baseUrl: 'http://your-server:8095',
  clientName: 'My Web Player',
  // Optional: "sync" (default), "quality" (no pitch shifts; not recommended for bad networks),
  // or "quality-local" (best for unsynced playback)
  correctionMode: 'sync',
  onStateChange: (state) => {
    // Local player state
    console.log('Playing:', state.isPlaying);
    console.log('Volume:', state.volume, 'Muted:', state.muted);

    // Server state (metadata, controller info)
    if (state.serverState?.metadata) {
      const meta = state.serverState.metadata;
      console.log('Track:', meta.title, '-', meta.artist);
    }

    // Group state (playback state, group info)
    if (state.groupState) {
      console.log('Group:', state.groupState.group_name);
      console.log('Playback:', state.groupState.playback_state);
    }
  }
});

// Connect to server
await player.connect();

// Local volume control (affects this player only)
player.setVolume(80);
player.setMuted(false);

// Send commands to server (controls the source)
player.sendCommand('play');
player.sendCommand('pause');
player.sendCommand('stop');
player.sendCommand('next');
player.sendCommand('previous');
player.sendCommand('volume', { volume: 50 });
player.sendCommand('mute', { mute: true });
player.sendCommand('shuffle');
player.sendCommand('unshuffle');
player.sendCommand('repeat_off');
player.sendCommand('repeat_one');
player.sendCommand('repeat_all');
player.sendCommand('switch');  // Switch group

// Disconnect with reason (optional)
player.disconnect('user_request');
```

## Local development

```
yarn dev-server
```

Then browse to http://localhost:6001
npm package: @sendstreak/revalidating-cache
Description: In-memory cache with a self revalidating approach
Author: sendstreak.com
Latest version: 1.1.0

# revalidating-cache

In-memory cache for node.js with a self (re)validating approach. Originally implemented for [SendStreak](https://www.sendstreak.com), but made available to the public.

## Installation

This is a node.js package available through npmjs, so you can install it using the [`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):

```console
$ npm install --save-exact @sendstreak/revalidating-cache
```

## Usage

```js
// Import
const { Cache } = require('@sendstreak/revalidating-cache');

// ...

const userCache = new Cache({
    /**
     * Arbitrary name of your cache. Will be used to retrieve this cache instance
     * from the manager later.
     */
    name: 'USER_CACHE',

    /**
     * Controls wether the cache should store nullish values or not. This is a great way
     * to mitigate DDoS attacks on auth endpoints.
     */
    storeNil: true,

    /**
     * The validity of the entries in the cache in ms.
     */
    ttlMs: 10000,

    /**
     * The validator function that is invoked automatically when we don't have a reference to a cache entry
     * or when it's outdated in there.
     */
    validatorFn: async(key) => {
        /**
         * Here you need to implement the required function to fetch the entry to be cached.
         *
         * This is a vanilla postgres example, but feel free to use your preferred method.
         */
        return (await db.query('select * from users where id = ?', [ key ]))[ 0 ];
    }
});

/**
 * Then either use the reference to the cache you created to get an entry
 * This will return the requested user even if it's not cached yet, as it will
 * invoke the validatorFn to fetch it from the database (if the user exists, of couse).
 */
const user = await userCache.get('ab45d4398');

/**
 * Or use the cache manager to get a reference to your cache first.
 */
const { cacheManager } = require('@sendstreak/revalidating-cache');

const userCache = cacheManager.get('USER_CACHE');
const user = await userCache.get('ab45d4398');
```
npm package: @sendstreak/sendstreak-node
Description: Node.js SDK for SendStreak
Author: sendstreak.com
Latest version: 4.0.0

# SendStreak Node.js SDK

[SendStreak](https://www.sendstreak.com) is a simple interface that lets you integrate quickly to Amazon SES, Gmail or any other SMTP server to send your transactional emails easily and pretty much for FREE.

## New package!

Now with no dependencies and scoped package name!

## Installation

```sh
$ npm install --save-exact @sendstreak/sendstreak-node
```

## Usage

```javascript
const SendStreak = require('@sendstreak/sendstreak-node');
const sendStreak = new SendStreak('YOUR_API_KEY');

// Push your contacts to SendStreak with as many attributes as you want
await sendStreak.updateContact({
    email: 'johndoe@example.com',
    firstName: 'John',
    lastName: 'Doe',
    onboarded: false
});

// Send them emails using predefined templates
await sendStreak.sendMail('johndoe@example.com', 'customer-welcome-email', {
    username: 'john_doe'
});

// Send emails with attachments
await sendStreak.sendMail('johndoe@example.com', 'customer-welcome-email', {
    username: 'john_doe'
}, [{
    content: (await fs.readFile('[YOUR_FILE_PATH1]')).toString('base64'),
    filename: 'text.txt'
}, {
    content: (await fs.readFile('[YOUR_FILE_PATH1]')).toString('base64'),
    filename: 'image.png'
}]);
```