open-index/open-npm huggingface dataset:
npm package: @rapid1978/shared-elements
Description: Shared UI components, layouts, utilities, and styles for Rapid Static Site Template
Latest version: 1.0.60

# shared-elements

> ⚠️ **Experimental & Private Use Only**  
> This library is under active, internal refactoring. **Do not use in production.**  
> APIs and features may change without notice.

---

## Purpose

`shared-elements` has been a rapid-prototyping experiment in “vibe-coding” a codebase to see how brittle and legacy-style it becomes in a short time.
If you want to hack on this, I supposed you could use this project to:

- Explore ADR-driven refactoring patterns
- Measure CI/CD and test-cycle trade-offs
- Demonstrate how technical debt accumulates at scale

---

## ⚠️ Warning

- **Not Stable**: Breaking changes may land at any time.
- **Private Use Only**: Intended for internal experiments—**not** a supported public library.
- **No Backwards Compatibility**: Upgrades are not guaranteed.

---
npm package: @rapida/rest-calls
Description: An abstraction helper for http calls that returns api endpoints for each entity you create in a consistent way
Author: Yahia Refaiea
Latest version: 1.3.2
Deprecated: Rapida REST Calls has been deprecated and it's no longer maintained.

![Rapida Logo](https://user-images.githubusercontent.com/13030990/71755098-db251e80-2e91-11ea-8ce9-25349e6c087f.png)

**Rapida REST Calls** - An abstraction helper for http calls that returns api endpoints for each entity you create in a consistent way.

**Warning** - Rapida REST Calls has been deprecated and it's no longer maintained.

This package is part of [Rapida](https://github.com/yahiarefaiea/rapida).

## Usage
In your project directory, install `@rapida/rest-calls` by running:
```
npm i @rapida/rest-calls --save
```

Import `@rapida/rest-calls` to your project:
```js
const Api = require('@rapida/rest-calls')
```

Then create a new instance of the `Api`, and use it to create a new entity:
```js
const api = new Api('http://localhost:3000')

// you can create a single entity
api.createEntity('book')

// or multiple entities
api.createEntities(['book', 'author'])
```

And then you can use it in your app. Let's do a `getAll` method:
```js
api.endpoints.book.getAll()
```

To handle the response and catch the errors, you can chain the `then` and the `catch` keywords after calling the method:
```js
api.endpoints.book.getAll()
  .then(data => console.log(data))
  .catch(error => console.log(error))
```

## Methods
The available methods are:
```js
// default params: {}, default config: {}
api.endpoints.book.getAll(params, config)

// payload is required, default config: {}
api.endpoints.book.post(payload, config)

// id is required, default config: {}
api.endpoints.book.get(id, config)

// id is required, payload is required, default config: {}
api.endpoints.book.patch(id, payload, config)

// id is required, default config: {}
api.endpoints.book.delete(id, config)
```

## Advanced Usage
You can create an abstract api and use it all around your project by creating a file called `api.js` that contains the following:
```js
// api.js
const Api = require('@rapida/rest-calls')

const api = new Api('http://localhost:3000')
api.createEntities(['book', 'author'])

module.exports = api.endpoints
```

And with this, you will have a shorter and more self-descriptive constant to use anywhere in your project:
```js
// anywhere.js
const api = require('./path/to/api')

api.book.getAll()
```

## Demo
To run a working demo, run the following command:
```
npm start -s
```

You can find the demo inside `demo/index.js`.

## What happens behind the scene?
We use [axios](https://github.com/axios/axios) behind the scene to excite the http calls which's a promise based HTTP client.

## License
Copyright (c) 2020 Nuotron.
Released under the [MIT license](https://github.com/github/choosealicense.com/blob/gh-pages/LICENSE.md).
npm package: @rapidaim/credence
Description: Credential management using DynamoDB.
Author: Stefan Aichholzer
Latest version: 1.7.3

## Environment variables

`Set` and `get` environmental variables in and from DynamoDB.<br />
Variable values are encrypted using a KMS key.

```
$> npm i
$> AWS_PROFILE=... \
   AWS_REGION=... \
   node /app \
   --action={action} \
   --env={file_name} \
   --out={file_name} \
   --kms={kms_key} \
   --force
```

* `AWS_PROFILE`: The `AWS_PROFILE` to be used (assuming a `.aws/credentials` file exists with the given profile name)
* `AWS_REGION`: The `AWS_REGION` which will be used for the operations. Defaults to `ap-southeast-2`.
* `KMS_KEY`: The `KMS KEY` (ID) used for KMS operations.
---------------------
* `action`: Either `set` or `get`
* `env`: The file where the environment (table, context and keys) is described. (See `./env.json` for an example.)
* `out`: (Optional) File where values will be written (on `get`). Defaults to the `table` in `env.json`.
* `kms`: (Optional) If a KMS key ID is provided, values will be encrypted/decrypted using that key.
* `force`: (Optional) Will overwrite existing key/value pairs in the table (on `set`).

**Note:** `Creedence` will determine the output format from the `out` filename's extension.
npm package: @rapidaim/rassm
Description: ``` $> npm i $> AWS_PROFILE=... AWS_REGION=... node ./app/index {action} {definition} {output} ```
Author: Stefan Aichholzer
Latest version: 1.0.0

## SSM parameter store

```
$> npm i
$> AWS_PROFILE=... AWS_REGION=... node ./app/index {action} {definition} {output}
```

* `AWS_PROFILE`: The `AWS_PROFILE` to be used (assuming a `.aws/credentials` file exists with the given profile name)
* `AWS_REGION`: The `AWS_REGION` which will be used for the operations. Defaults to `ap-southeast-2`.

---------------------

* `action`: Either `set` or `get`
* `definition`: The file where the parameters are described. (See `./env.json` for an example.)
* `output`: (Optional) File where values will be written (on `action` = `get`). Defaults to the `service` value in `env.json`.

Parameters can be overwritten by starting the value with `!`.<br />
Parameters `.data` and `.type` default to "text" and "SecureString", respectively.

---------------------

https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_PutParameter.html
npm package: @rapidajs/cannon-worker
Description: **Note: See this issue to track progress of the creation of an "official" `cannon-worker` package - https://github.com/pmndrs/use-cannon/issues/327**
Author: Isaac Mason
Latest version: 0.0.14

# cannon-worker

**Note: See this issue to track progress of the creation of an "official" `cannon-worker` package - https://github.com/pmndrs/use-cannon/issues/327**

**Development on this package is paused in favour of contributing over at pmndrs**.

**rapida is under active alpha development and is not yet battle-tested and stable. We don't recommend using rapida in production just yet, but watch this space!**

`cannon-worker` makes adding cannon physics to your three.js scenes easy!

- [x] Runs in a web worker
- [x] Supports instancing
- [x] Easy integration with three.js 

```
> yarn add @rapidajs/cannon-worker
```

## How it works

1. Get all the imports that you need.

```ts
import { CannonWorker } from '@rapidajs/cannon-worker';
import { Mesh, BoxGeometry, MeshBasicMaterial, ... } from 'three';
```

2. Create a physics world.

```ts
const cannon = new CannonWorker({
  gravity: [0, -10, 0],
});
```

3. Create a three object, it could be a mesh, line, gltf, anything.

```ts
const geometry = new BoxGeometry(1, 1, 1);
const material = new MeshBasicMaterial();
const boxMesh = new Mesh(geometry, material);
```

4. Pick a shape that suits your objects contact surface, it could be a box, plane, sphere, etc. Give it a mass, too. Then also provide the three object.

```ts
const { api } = cannon.create.box(() => {
  mass: 1,
}, boxMesh);
```

5. You can interact with it by using the api, which lets you apply positions, rotations, velocities, forces and impulses.

```ts
api.position.set(Math.sin(clock.getElapsedTime()) * 5, 0, 0));
```

6. You can use the body api to subscribe to properties to get updates on each physics step.

```ts
const unsubscribe = api.velocity.subscribe((velocity) => console.log(velocity));
```
npm package: @rapidajs/postprocessing
Description: simple postprocessing effects for three js - powered by vanruesc/postprocessing
Author: Isaac Mason
Latest version: 0.1.1
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# @rapidajs/postprocessing

`@rapidajs/postprocessing` is a thin wrapper around [vanruesc/postprocessing](https://github.com/vanruesc/postprocessing) with typed methods for creating effects. This package is used in `@rapidajs/rapida`, but can also be used standalone.

---

**rapida is under active alpha development and is not yet battle-tested and stable. We don't recommend using rapida in production just yet, but watch this space!**

---

See the `vanruesc/postprocessing` docs for more documentation on the post processing effects included in this package - [`vanruesc/postprocessing`](https://vanruesc.github.io/postprocessing/public/docs/)

Over time this package will become simpler - this primarily hinges on types being added to `vanruesc/postprocessing`.

## Usage with `@rapidajs/three`

Install `@rapidajs/three`, `three` and this package:

```
$ yarn add @rapidajs/three @rapidajs/postprocessing three
```

Use `@rapidajs/postprocessing` to add post processing effects to rapida views

1. Gather necessary imports

```ts
import { WebGLRenderer } from '@rapidajs/three';
import { Scene, PerspectiveCamera } from 'three';
import { Effects } from '@rapidajs/postprocessing';
```

2. Create a @rapidajs/three webgl renderer and append it to the dom

```ts
const renderer = new WebGLRenderer();
document.getElementById('app').appendChild(renderer.domElement);
```

3. Create a scene

```ts
const scene = new Scene();
```

4. Create a camera and a view

```ts
const camera = new PerspectiveCamera();
const view = renderer.create.view({
  scene,
  camera,
  useEffectComposer: true, // make sure to include `useEffectComposer: true`
});
```

5. Add a post processing effect with `Effects`

```ts
view.composer.add.effects(Effects.bloom({ ... bloom effect params ... }));
```

6. Render your scene

```ts
renderer.render(timeElapsed);
```
npm package: @rapidajs/rapida
Description: A library that helps you create 3D content for the web
Author: Isaac Mason
Latest version: 0.0.13
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# @rapidajs/rapida

`@rapidajs/rapida` is a javascript package that makes creating interactive 3d content for the web with three.js easy!

Visit the [rapidajs website](https://rapidajs.dev/) for documentation and examples.

- [x] Build out your 3D scenes with [three.js](https://threejs.org/)
- [x] Add physics to your world with [cannon-worker](https://gitlab.com/rapidajs/rapida/-/tree/main/packages/cannon-worker), which runs [cannon-es](https://github.com/pmndrs/cannon-es) in a web worker
- [x] Add complex logic to your world with the rapida Entity Component System
- [x] Simple API for handling multiple renderers and multiple views within renderers

**rapida is under active alpha development and is not yet battle-tested and stable. We don't recommend using rapida in production just yet, but watch this space!**

## Installation

To get started using rapida, install `@rapidajs/rapida` and `three`.

```bash
> yarn add @rapidajs/rapida three
```
npm package: @rapidajs/rapida-physics
Description: web worker wrapped cannon-es
Author: Isaac Mason
Latest version: 0.0.8
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# @rapidajs/rapida-physics

`@rapidajs/rapida-physics` is a javascript package that makes adding physics to your three.js scenes easy!

**rapida is under active alpha development and is not yet battle-tested and stable. We don't recommend using rapida in production just yet, but watch this space!**

- [x] Physics provided by the javascript library [cannon-es](https://github.com/pmndrs/cannon-es)
- [x] Easy integration with three.js
- [x] Runs in a web worker!
- [x] Supports running on node.js! (not well tested *yet*)

```bash
> npm install @rapidajs/rapida-physics

# or yarn

> yarn add @rapidajs/rapida-physics
```
npm package: @rapidajs/three
Description: goodies for three.js
Author: Isaac Mason
Latest version: 0.5.0

# @rapidajs/three

`@rapidajs/three` is a javascript package that provides some utilities for three.js

- [x] Simple API for handling multiple views within renderers
- [x] Post processing effects
- [x] Loaders for assets

**rapida is under active alpha development and is not yet battle-tested and stable. We don't recommend using rapida in production just yet, but watch this space!**

## Installation

To get started install `@rapidajs/three` and `three`.

```bash
> yarn add @rapidajs/three three
```

`@rapidajs/three` currently cannot be used without a bundler. A basic example of using `@rapidajs/three` with parcel can be found here: https://gitlab.com/rapidajs/rapida-typescript-parcel/-/blob/main/package.json

Visit the [rapidajs website](https://rapidajs.dev/) for documentation and examples.

## Example Usage

Let's use `@rapidajs/three` to create a view with postprocessing effects.

1. Gather necessary imports

```ts
import { Effects, WebGLRenderer } from '@rapidajs/three';
import { Scene, PerspectiveCamera } from 'three';
```

2. Create a @rapidajs/three webgl renderer and append it to the dom

```ts
const renderer = new WebGLRenderer();
document.getElementById('app').appendChild(renderer.domElement);
```

3. Create a scene

```ts
const scene = new Scene();
```

4. Create a camera and a view

```ts
const camera = new PerspectiveCamera();
const view = renderer.create.view({
  scene,
  camera,
  useEffectComposer: true, // make sure to include `useEffectComposer: true`
});
```

5. Add a post processing effect with `Effects`

```ts
view.composer.add.effects(Effects.bloom({ ... bloom effect params ... }));
```

6. Render your scene

```ts
renderer.render(timeElapsed);
```
npm package: @rapidappio/rapidapp-node
Description: Node.js client for Rapidapp
Author: Rapidapp
Latest version: 1.0.1

# RapidApp Node.js Client

A Node.js client library for RapidApp, allowing you to manage and interact with RapidApp services programmatically.

## Installation

```bash
npm install rapidapp-node
```

## Prerequisites

- Node.js (v12 or higher)
- A RapidApp API key which you can generate one [here](https://rapidapp.io)

## Configuration

Set your RapidApp API key as an environment variable:

```bash
export RAPIDAPP_API_KEY='your-api-key-here'
```

## Usage

Here's a basic example of how to use the RapidApp Node.js client:

```typescript
import { RapidappClient } from 'rapidapp-node';

// Initialize the client
const client = new RapidappClient({
    apiKey: process.env.RAPIDAPP_API_KEY,
    insecure: false,
});

// Create a new Postgres database
const postgres = await client.createPostgres('my-database');

// Get database details
const database = await client.getPostgres(postgres.getId());

// List all databases
const databases = await client.listPostgres();

// Delete a database
await client.deletePostgres(postgres.getId());
```

## Features

- Create Postgres databases
- Retrieve database information
- List all databases
- Delete databases
- Secure API key management
- TypeScript support

## Error Handling

The client includes built-in error handling. Always wrap your API calls in try-catch blocks:

```typescript
try {
    const postgres = await client.createPostgres('my-database');
    console.log('Database created:', postgres.toObject());
} catch (error) {
    console.error('Error:', error);
}
```
npm package: @rapideditor/mapillary_sprite_source
Description: Source repository of `svg` files to generate sprites for mapillary.com
Latest version: 1.8.0

# mapillary_sprite_source

Source repository of `svg` files to generate sprites for mapillary.com

>
> 👋 <br/>
> This is just a copy of the archived mapillary_sprite_source repo that can be found at https://github.com/mapillary/mapillary_sprite_source <br/>
> This repository contains the icons only and will recieve limited maintenance. <br/>
>
npm package: @rapideditor/pixi-texture-allocator
Description: Pixi.js texture allocator
Latest version: 7.4.0

# pixi-texture-allocator

>
> 👋 <br/>
> This is just a copy of the awesome texture-allocator repo that can be found at https://github.com/ShukantPal/pixi-essentials/tree/master/packages/texture-allocator <br/>
> You probably want that instead. <br/>
> We are keeping this copy pinned to the latest version of PixiJS, to avoid issues with bundling multiple versions of PixiJS. <br/>
>
npm package: @rapidev/ui
Description: Components Library for Modern Web Apps, powered by Vue & Tailwind.
Author: Bassin Agency
Latest version: 0.0.3

# Rapide UI

[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]
[![License][license-src]][license-href]

Components Library for Modern Web Apps, powered by Vue & Tailwind.

## Installation

```
npm install @rapidev/ui
```
npm package: @rapidevelop/prettier-config
Description: A shared Prettier config
Author: Iman Vafadarnezhad
Latest version: 1.0.1

# A shared Prettier config

## Installation

To install this package run the following command in the terminal in the root directory of your application.

```
npm install --save-dev @rapidevelop/prettier-config
```

**OR**

```
yarn add --dev @rapidevelop/prettier-config
```

## Usage

Add a key in your **package.json** file.

```
"prettier": "@rapidevelop/prettier-config"
```

**OR**

Create a **.prettierrc** , **.prettierrc.yaml** , **.prettierrc.yml** or **.prettierrc.json** file and export a string.

```
"@rapidevelop/prettier-config"
```

**OR**

Create a **prettier.config.js** or **.prettierrc.js** file and export an object.

```
module.exports = {
  ...require("@rapidevelop/prettier-config"),
  // endOfLine: 'lf', // to overwrite the property
};
```
npm package: @rapidevelop/xml2json
Description: XML2JSON is a library to convert a XML file or XML text string to JSON.
Author: Iman Vafadarnezhad
Latest version: 1.3.0

# XML2JSON is a library to convert a XML file or XML text string to JSON.

[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)

## Installation
To install this package run the following command in the terminal in the root directory of your application.
```
npm install --save @rapidevelop/xml2json
```

## Commands
Bumps the package version.
```
npm run version:[major|minor|patch]
```
Commits changes using commitizen.
```
npm run git:commit
```
Generates an ECMAScript compatible version of TypeScript files.
```
npm run build:es
```
Generates documentation.
```
npm run build:docs
```