open-index/open-npm huggingface dataset:
npm package: @oct16/code-formatter
Description: a code automatically formatter
Author: oct16
Latest version: 1.0.9

## Code Formatter ![](https://travis-ci.org/oct16/code-formatter.svg?branch=master)

### A code automatically formatting tool

![Preview](screen-recording.gif)


### Install
```bash
$ yarn add @oct16/code-formatter
$ npm install @oct16/code-formatter
```


### Feature

- Simple, Robust and Easy to use
- Custom RC formatters (via e.g. prettierrc)
- Supports a variety of type formatting


### Usage

```bash
// In root dir (Directory of rc files)

$ code-formatter

// installed in local
$ npx code-formatter
```

### Options

`--file_type`
describe: Specify the file type   
default: `ts`   
choices: `ts` `js` `all`

`--change_type`
describe: Specify the change type   
default: `all`   
choices: `cached` `all`

`--path`
describe: Specify the path for the files include   
default: `src`

`--exclude`  
describe: Specify the path for the files exclude   
default: `node_modules`


### License

MIT License

Copyright (c) 2019 oct16

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: @octabits-io/drizzle-test
Description: Drizzle ORM test utilities with testcontainers for PostgreSQL
Latest version: 0.1.4

# @octabits-io/drizzle-test

Integration test utilities for Drizzle ORM with PostgreSQL via Testcontainers. Spins up a real Postgres container, runs migrations, and provides per-test isolation.

## Setup

**`vitest.config.ts`:**

```ts
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    globalSetup: './src/global-setup.ts',
  },
});
```

**`global-setup.ts`:**

```ts
import { createGlobalSetup } from '@octabits-io/drizzle-test';

const { setup, teardown } = createGlobalSetup({
  migrationsFolder: './drizzle/migrations',
  image: 'postgres:17-alpine', // optional, default
});

export { setup, teardown };
```

**Test file:**

```ts
import { setupTestDatabase, cleanupTestDatabase, resetDatabase } from '@octabits-io/drizzle-test';
import * as schema from './schema';

let db: Awaited<ReturnType<typeof setupTestDatabase<typeof schema>>>;

beforeAll(async () => {
  db = await setupTestDatabase({ schema });
});

afterAll(async () => {
  await cleanupTestDatabase();
});

beforeEach(async () => {
  await resetDatabase(db, [schema.users, schema.posts]); // truncate with CASCADE
});
```

## API

| Function | Description |
|---|---|
| `createGlobalSetup(opts)` | Creates Vitest `setup`/`teardown` hooks that start a Postgres container and run Drizzle migrations |
| `setupTestDatabase(opts)` | Connects to the container and returns a typed `NodePgDatabase<TSchema>` |
| `cleanupTestDatabase()` | Closes the connection pool |
| `resetDatabase(db, tables)` | Truncates tables with `RESTART IDENTITY CASCADE` |
npm package: @octabits-io/pii
Description: PII encryption and tokenization utilities
Latest version: 0.1.4

# @octabits-io/pii

Encryption toolkit for Personally Identifiable Information (PII). Uses [age encryption](https://age-encryption.org/) (X25519 + ChaCha20-Poly1305) with a built-in TypeScript implementation.

## PII Encryption Service

High-level service for encrypting/decrypting PII fields. Inject once with keys, use everywhere.

```ts
import { createPiiEncryptionService, createPiiEncryptionOnlyService } from '@octabits-io/pii';

// Full encrypt + decrypt (backend services with access to the secret key)
const pii = createPiiEncryptionService({
  recipient: 'age1...', // public key
  identity: 'AGE-SECRET-KEY-1...', // private key
});

const encrypted = await pii.encryptString('john@example.com');
const decrypted = await pii.decryptString(encrypted.value);

// JSON values with Zod validation on decrypt
const encJson = await pii.encryptJson({ street: '123 Main St', city: 'Berlin' });
const decJson = await pii.decryptJson(encJson.value, AddressSchema);

// Encrypt-only variant (e.g., ingestion services that don't need to read PII)
const encryptOnly = createPiiEncryptionOnlyService({ recipient: 'age1...' });
```

All methods return `Result<T, PiiEncryptionError | PiiDecryptionError>` and pass through `null`/`undefined` inputs.

## Blind Index

HMAC-SHA256 blind indexes for exact-match search on encrypted fields without exposing plaintext.

```ts
import { createBlindIndexService } from '@octabits-io/pii';

const blindIndex = createBlindIndexService(process.env.BLIND_INDEX_KEY);

// Store alongside encrypted data for lookups
const emailIndex = blindIndex.generateIndex('john@example.com'); // Buffer (HMAC-SHA256)

// Later: WHERE email_blind_index = $1
```

## Master Key Provider

Envelope encryption pattern — encrypt data keys at rest with a master key derived via HKDF-SHA256.

```ts
import { createEnvVarMasterKeyProvider } from '@octabits-io/pii';

const masterKey = createEnvVarMasterKeyProvider(process.env.MASTER_KEY);

const wrapped = await masterKey.encrypt(dataKeyBuffer);
const unwrapped = await masterKey.decrypt(wrapped.value);
```

## Low-Level Primitives

```ts
import { encryptHybrid, decryptHybrid } from '@octabits-io/pii';
import { encryptSymmetric, decryptSymmetric, generateSymmetricKey } from '@octabits-io/pii';

// Age encryption (X25519 + ChaCha20-Poly1305)
const encrypted = await encryptHybrid('plaintext', 'age1...');
const decrypted = await decryptHybrid(encrypted.value, 'AGE-SECRET-KEY-1...');

// AES-256-GCM symmetric encryption
const key = generateSymmetricKey();
const enc = encryptSymmetric('plaintext', key);
const dec = decryptSymmetric(enc.value, key);
```
npm package: @octabyte/gymnasium-ui-kit
Description: Gymnasium UI Kit
Latest version: 2.0.7

# AFP Capital UI Kit

## Features

- [Typescript](https://www.typescriptlang.org)
- Components generators
- Development Environment: [Storybook](https://storybook.js.org/)
- Styles: [Styled Components](https://www.styled-components.com/) with theming configuration
- Lint: [TSLint](https://palantir.github.io/tslint/)
- Tests: [Jest](https://jestjs.io/)

## Quick start

Make sure that you have Node v8 or above installed.

1. Clone this repo using `git clone  git@github.com:leandrooriente/react-ui-kit-boilerplate.git`
2. Move to the appropriate directory: `cd react-ui-kit-boilerplate`.
3. Run `npm ci` in order to install dependencies.
4. At this point you can run `npm run storybook` to see the example Storybook at [http://localhost:6006](http://localhost:6006).

## Creating new components

To add a new component, just run `npm run generate`. This command will generate all the component (Stateless or not) files for you.

## Testing

To test your components run `npm test`.
By default we run tests and lint before any push.

## Deploying storybook

To deploy storybook to Github Pages run `npm run deploy-storybook`.

## License

MIT
npm package: @octabytes/format-phone
Description: Convert phone number into human readable format
Author: OctaByte
Latest version: 1.1.0

# format-phone

Convert phone number into human readable format

# Usage

```js
import formatPhone from "@octabytes/format-phone";

formatPhone("923321234567"); // +92 332-1234567
formatPhone("16505551234"); // 1 (650) 555-1234
```
npm package: @octacondeveloper/ajala
Description: NestJS wrapper for axios for glade finance
Author: Harrys Jil
Latest version: 0.2.3


# NestJS AJALA

## Description
An <a href="https://www.npmjs.com/package/axios" target="blank">axios</a> wrapper  for [Nest](https://github.com/nestjs/nest) originally published as part of the `@nestjs/common` package. This package is a developed for making http calls for glade internal services.

## Installation

```bash
$ npm i --save @octacondeveloper/ajala
```

## Quick Start

Once the installation process is complete, to use the `AjalaService`, first import `AjalaModule`.
```typescript
@Module({
  imports: [AjalaModule],
  providers: [AppService],
})
export class AppModule {}
```
Next, inject `AjalaService` using normal constructor injection.
```typescript
@Injectable()
export class AppService {
  constructor(private readonly ajalaService: AjalaService) {}

  async findAll(): Promise<any>  {
    return await this.ajalaService.get("https://jsonplaceholder.typicode.com/posts/11", [], body, false, null);
  }
//sample payload structure
//this.ajalaService.get(url, header, body, proxy, options)
}
```

Other methods include
```typescript
this.ajalaService.get("https://jsonplaceholder.typicode.com/posts/11",  [], body,  false,  null);
this.ajalaService.delete("https://jsonplaceholder.typicode.com/posts/11",  [], body,  false,  null);
this.ajalaService.put("https://jsonplaceholder.typicode.com/posts/11",  [], body,  false,  null);
this.ajalaService.patch("https://jsonplaceholder.typicode.com/posts/11",  [], body,  false,  null);
this.ajalaService.head("https://jsonplaceholder.typicode.com/posts/11",  [], body,  false,  null);
this.ajalaService.post("https://jsonplaceholder.typicode.com/posts/11",  [], body,  false,  null, files);
```


## License

Ajala is [MIT licensed](LICENSE).
npm package: @octagen/proflock
Description: tool for scanning localized properties, to determine if they are complete
Author: f.huesig
Latest version: 1.2.0

proflock - Property Finder for localized keys
=============================================

Tool for scanning localized properties, to determine if they are complete, using [Node.JS](http://nodejs.org)

Abstract
========

When it comes in the development process to the point of internationalization, not only do you have to setup new configurations or handle the CMS, you also need to create the existing properties in a different language. But at the same time the project keeps on developing, so you need to be sure, that your existing properties file contains all neccessary keys with language specific values. To get a list for your translator, or just to make sure your project has no missing keys, you can use ###proflock###

Installation
============

The easiest installation is through [NPM](http://npmjs.org):

    npm i @octagen/proflock

tested with node 5.12


Usage
=====

Run the following:

    npm run-script proflock <ROOT_DIR> <TARGET_DIR> <FILE_SUFFIX> <EXPORT_SUFFIX> <REGEX> <LEAD_REGEX> <EXCLUDES>

* <ROOT_DIR>
    *   root directory of the project. proflock only scans files in this directory.
* <TARGET_DIR>
    *   if property keys are missing, files containing which keys are missing, will be generated in this directory
* <FILE_SUFFIX>
    *   Suffix of the files to be scanned, e.g. '.properties'
* <EXPORT_SUFFIX>
    *   Suffix of the files to which we will export, e.g. '.csv'
* <REGEX>
    *   Regular Expression, to specify which files should be searched for, e.g. '_XY.properties'
* <LEAD_REGEX>
    *   Regular Expression, to specify which file has all keys. Other file with the same baseName will be compared to this file, to determine which keys are missing
* <EXCLUDES>
    *   Array of Strings, containing path elements which should not be searched in, e.g. '["/.node_modules/"]'
npm package: @octahedroid/create-drupal-decoupled
Description: Scaffold the integration with Drupal in a decoupled frontend
Author: Octahedroid
Latest version: 0.7.0

# create-drupal-decoupled

> A CLI tool that scaffolds Drupal integration for decoupled frontend projects.

## Features

- Automatic detection of frontend frameworks (Next.js, React Router, Remix)
- Scaffolds GraphQL integration with type-safe queries
- Configures authentication and API connection
- Updates project configuration files
- Framework-specific template generation

## Installation

```bash
# Using npm
npx @octahedroid/create-drupal-decoupled

# Using yarn
yarn create @octahedroid/drupal-decoupled

# Using pnpm
pnpm create @octahedroid/drupal-decoupled

# Using bun
bunx @octahedroid/create-drupal-decoupled
```

## Quick Start

Navigate to your existing frontend project and run the scaffolding command:

```bash
# In your project directory
npx @octahedroid/create-drupal-decoupled . --frontend next

# Or specify a different directory
npx @octahedroid/create-drupal-decoupled my-project --frontend react-router
```

## Supported Frameworks

- **Next.js** (`next`) - React framework with server-side rendering
- **React Router** (`react-router`) - Modern React routing library
- **Remix** (`remix`) - Full-stack React framework

## Usage

```bash
create-drupal-decoupled [project-directory] [options]
```

### Arguments

- `project-directory` - Target directory for scaffolding (defaults to current directory)

### Options

- `-f, --frontend <framework>` - Frontend framework to use (required)
- `-v, --version` - Display version number
- `-h, --help` - Display help information

### Examples

```bash
# Scaffold Next.js integration in current directory
npx @octahedroid/create-drupal-decoupled . --frontend next

# Scaffold React Router integration in specific directory
npx @octahedroid/create-drupal-decoupled ./my-app --frontend react-router

# Scaffold Remix integration
npx @octahedroid/create-drupal-decoupled ./remix-app --frontend remix
```

## What Gets Generated

The CLI will add the following to your project:

- GraphQL configuration and type definitions
- Drupal client setup with authentication
- Framework-specific integration files
- Environment variable templates
- Updated `.gitignore` with Drupal-specific entries

## Requirements

- Node.js >= 20.15.1
- Existing frontend project with supported framework
- Package.json file in target directory

## Development

### Setup

```bash
# Install dependencies
yarn install

# Build the package
yarn build

# Development mode with file watching
yarn dev
```

### Local Testing

```bash
# Build the package
yarn build

# Test locally
node dist/index.js . --frontend next
```
npm package: @octahedroid/ui
Description: Octahedroid - UI library
Author: octahedroid
Latest version: 0.2.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Octahedroid-ui

> Octahedroid&#x27;s UI library

[![NPM](https://img.shields.io/npm/v/octahedroid-ui.svg)](https://www.npmjs.com/package/octahedroid-ui) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save octahedroid-ui
```

## Usage

```jsx
import React, { Component } from 'react'

import MyComponent from 'octahedroid-ui'
import 'octahedroid-ui/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [octahedroid](https://github.com/octahedroid)
npm package: @octahedroid/website-components
Description: Octahedriod components
Author: octahedroid
Latest version: 0.0.5
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Octahedroid Website components

This package provides the necessary components and resolvers used for Octahedroid's Website.

## Usage

Components can be used individually or through their component resolver. Import them as such:

```
import { theme, componentResolver } from "@octahedroid/website-components";
```
npm package: @octaive/preset-babel
Description: ## Installation
Latest version: 0.0.4

# Octaive Babel Presets

## Installation

    yarn add @octaive/preset-babel

### Usage

Add the following preset to babel presets

    module:@octaive/preset-babel

The following options are available

 - `typescript = false` - include @babel/preset-typescript
 - `frontend = false` - include various react related frontend plugins
 - `fastRefresh = false` - include react fast refresh
 - `cacheUsing = () => process.env.NODE_ENV` - configure cache function

## babel.config.js example

```
module.exports = (api) => {
  api.cache.using(() => process.env.NODE_ENV);

  return {
    presets: [
      [
        'module:@octaive/preset-babel',
        {
          fastRefresh: true,
          frontend: true,
        },
      ],
    ],
  };
};
```
npm package: @octalmage/electron-notarize
Description: Notarize your Electron app
Author: Samuel Attard
Latest version: 0.1.2

Electron Notarize
-----------

> Notarize your Electron apps seamlessly

## Installation

```bash
# npm
npm i electron-notarize --save-dev

# yarn
yarn add electron-notarize --dev
```

## What is app "notarization"?

From apple's docs, the definition of a "notarized app"

> A notarized app is a macOS app that was uploaded to Apple for processing before it was distributed. When you export a notarized app from Xcode, it code signs the app with a Developer ID certificate and staples a ticket from Apple to the app. The ticket confirms that you previously uploaded the app to Apple.

> On macOS 10.14 and later, the user can launch notarized apps when Gatekeeper is enabled. When the user first launches a notarized app, Gatekeeper looks for the app’s ticket online. If the user is offline, Gatekeeper looks for the ticket that was stapled to the app.

Basically Apple are going to make this a hard requirement soon, may as well get
on the train early.

## API

### Method: `notarize(opts): Promise<void>`

* `options` Object
  * `appBundleId` String - The app bundle identifier your Electron app is using.  E.g. `com.github.electron`
  * `appPath` String - The absolute path to your `.app` file
  * `appleId` String - The username of your apple developer account
  * `appleIdPassword` String - The password for your apple developer account
  * `ascProvider` String (optional) - Your [Team ID](https://developer.apple.com/account/#/membership) in App Store Connect. This is necessary if you are part of multiple teams

#### Prerequisites

For notarization, you need the following things:

1. Xcode 10 or later installed on your Mac.
2. An [Apple Developer](https://developer.apple.com/) account.
3. [An app-specific password for your ADC account’s Apple ID](https://support.apple.com/HT204397).


#### Safety when using `appleIdPassword`

1. Never hard code your password into your packaging scripts, use an environment
variable at a minimum.
2. It is possible to provide a keychain reference instead of your actual password (assuming that you have already logged into
the Application Loader from Xcode).  For example:

```js
const password = `@keychain:"Application Loader: ${appleId}"`;
```

Another option is that you can add a new keychain item using either the Keychain Access app or from the command line using the `security` utility: 

```shell
security add-generic-password -a "AC_USERNAME" -w <app_specific_password> -s "AC_PASSWORD"
```
where `AC_USERNAME` should be replaced with your Apple ID, and then in your code you can use:

```js
const password = `@keychain:AC_PASSWORD`;
```


#### Example Usage

```js
import { notarize } from 'electron-notarize';

async function packageTask () {
  // Package your app here, and code side with hardened runtime
  await notarize({
    appBundleId,
    appPath,
    appleId,
    appleIdPassword,
    ascProvider, // This parameter is optional
  });
}
```