open-index/open-npm huggingface dataset:
npm package: @safsof/expo-chucker
Description: Chucker wrapper in expo react native
Author: Seif Rashad
Latest version: 1.4.0

# expo-chucker

A [Chucker](https://github.com/ChuckerTeam/chucker) wrapper for Expo.

Kudos to ChuckerTeam for providing this great library. It allows HTTP(S) inspector on Android devices, useful for network debugging when in release mode. At the time I wrote this library, there's no easy way to integrate Chucker with React Native especially in Expo project.

This will ONLY works on Android, and there's no plan to support iOS, as the Chucker does.

### Compatible Version

| expo-chucker | expo | chucker |
| :----------: | :--: | :-----: |
|    1.3.0     | >=52 |  4.1.0  |
|    0.1.5     |  51  |  4.0.0  |

### Add the package to your npm dependencies

```bash
npm install expo-chucker

```

or

```bash
yarn add expo-chucker

```

### Add the Expo config-plugin

Add the plugin to your `app.json` / `app.config.ts` file.

```js
...
plugins: [
  'expo-chucker',
]

```

If you want to enable it only for staging, not the production build (obviously), there's an `enabled` props you can use. For example:

```js
plugins: [
  [
    "expo-chucker",
    {
      enabled: process.env.APP_ENV === "staging", // Only enable Chucker on staging environment
    },
  ],
];
```

Don't forget to prebuild your app each time you made changes to the config.

### Example App

1. Clone this repo
2. Run `pnpm install` to install the dependencies
3. Run `pnpm build` to build the expo plugin
4. Goto `example` directory
5. Run `pnpm install` to install the dependencies for the example app
6. Run `pnpm prebuild --clean --no-install` to prebuild the app
7. Run `pnpm android --no-build-cache` to run the app on android device or emulator

### Contributing

Contributions are very welcome!.
npm package: @saftswap/sdk
Description: Following buckets are available:
Author: 134dd3v
Latest version: 0.5.1

# Saft Swap SDK

Following buckets are available:

- ipfs (contains methods for adding data to ipfs or retrieving)
- metamask (contains method for getting enc key and decryption using metamask)
- saft (saft info object, add to ipfs and query)
- shamir (setup and decrypt)
- utils (useful utils)

## IPFS

```ts
import { ipfs, utils } from '@saftswap/sdk';
import { ethers } from 'ethers';

const cid = await ipfs.addFile('Hello');

// gives bytes32 value that should be stored in sc
const bytes32 = utils.cidToDigest(cid);
const cid = utils.digestToCID(bytes32); // back to CID format

const rawData = await ipfs.getFile(cid); // gives Uint8Array
ethers.utils.toUtf8String(rawData); // parse data as UTF8
```

## Metamask

```ts
import { metamask, utils } from '@saftswap/sdk';

// triggers metamask popup
await window.ethereum.enable();
const encKey = await metamask.getEncryptionPublicKey(window.ethereum); // passing a EIP-1193 provider works

// or
const provider = new ethers.providers.Web3Provider(window.ethereum);
const encKey = await metamask.getEncryptionPublicKey(provider); // passing a ethers provider works

const cipherText = utils.encryptData(encKey, 'Hello');

// triggers metamask popup
const data = await metamask.decryptCipherText(window.ethereum);
```

## Shamir

```ts
import { shamir } from '@saftswap/sdk';

const { encryptedShares, fileEncryptionKey } = await shamir.setup(
  publicKeysFromMetamask
);
const cipherText = utils.encryptData(fileEncryptionKey, file);

// later
const decryptedFile = await shamir.decrypCipherText(shares.slice(0, 2), cipher);
```

## Saft

```ts
import { saft, SaftInfo } from '@saftswap/sdk';

const info: SaftInfo = {
  name: 'hello',
  description: 'world',
  image: 'https://i.imgur.com/8oLKVUV.jpeg',
  properties: {
    prospectus: 'https://i.imgur.com/8oLKVUV.jpeg',
    purchasePrice: parseUnits('1000', 6),
    vestingType: 'hello',
    deliverySchedule: 'hello',
    nextDataOfDelivery: 'hello',
  },
};

const cid = await saft.addInfoToIPFS(info);
const resp = await saft.getInfoFromIPFS(cid);
```

## Contracts

```ts
const { saftManager, accountManager } = await getContracts(arbtest);
```
npm package: @safwanganz/orbitsync
Description: Synchronize state across tabs, clients, and contexts with ease.
Author: SafwanGanz
Latest version: 1.1.0



# OrbitSync 🌌

**Synchronize state across tabs, clients, and contexts with ease.**

![npm](https://img.shields.io/npm/v/orbitsync) ![license](https://img.shields.io/npm/l/orbitsync) ![downloads](https://img.shields.io/npm/dt/orbitsync)

OrbitSync is a lightweight, powerful tool to keep your app’s state in perfect harmony—whether across browser tabs, server-client connections, or different parts of your codebase. Launch your state into orbit and let it sync seamlessly.

---

## ✨ Features

- **Cross-Tab Sync**: Real-time state updates across multiple browser tabs.
- **Persistence**: Store state in `localStorage` or customize your own adapter.
- **Event-Driven**: Subscribe to changes with a simple, intuitive API.
- **Framework Agnostic**: Works with plain JS, React, Vue, Node.js, and more.
- **Lightweight**: Minimal dependencies, maximum flexibility.

---

## 🚀 Installation

```bash
npm install @safwanganz/orbitsync
```

---

## 🛠️ Usage

```javascript
const { OrbitSync } = require('@safwanganz/orbitsync');

const orbit = new OrbitSync({
  storage: 'localStorage',
  channel: 'my-app-state',
});

orbit.set({ user: 'Alice', count: 0 });

orbit.subscribe((state) => {
  console.log('State in orbit:', state);
});

orbit.update('count', (prev) => prev + 1);
```

Open multiple tabs, tweak the state, and watch it sync instantly! 🌍

---

## 📚 API

### `new OrbitSync(options)`
- `options.storage`: `'localStorage'` or `null` (default: `null`).
- `options.channel`: Unique string for sync (default: `'default-channel'`).
- `options.initialState`: Object to seed the state (default: `{}`).

### Methods
- `orbit.get(path)`: Retrieve a value by dot-separated path (e.g., `'user.name'`).
- `orbit.set(keyOrObj, value)`: Set a single key or merge an object into state.
- `orbit.update(key, updater)`: Update a key with a function.
- `orbit.subscribe(callback)`: Listen for state changes; returns an unsubscribe function.

---

## 🌟 Why OrbitSync?

- **Simple**: Intuitive API, no steep learning curve.
- **Scalable**: Ready for small scripts or massive apps.
- **Open-Source**: Free forever under MIT license.

---

## 🛠️ Development

1. Clone the repo:
   ```bash
   git clone https://github.com/SafwanGanz/orbitsync.git
   cd orbitsync
   ```
2. Install dependencies:
   ```bash
   npm install
   ```
3. Link locally:
   ```bash
   npm link
   ```

---

## 📜 License

MIT

---

## 🌌 Get Involved

- ⭐ Star us on [GitHub](https://github.com/SafwanGanz/orbitsync)!
- 🐛 Report bugs or suggest features in [Issues](https://github.com/SafwanGanz/orbitsync/issues).
- 📩 Reach out for questions or collabs!

---
npm package: @safwansabit/junior-js
Description: A lightweight, zero-dependency framework.
Author: Safwan Sabit
Latest version: 1.0.0

# JuniorJS 🚀
A clean, core-JS framework for building file-based routing without a complex build step.

## Features
- **File-based routing:** `/home` automatically loads `/pages/home.html`.
- **Zero Dependencies:** No heavy node_modules required.
- **Lightweight:** Under 2kb minified.

## Installation
```bash
npm install junior-js
npm package: @safwanyp/json-schema-to-dts
Description: Convert JSON Schema to TypeScript types with JSDoc annotations
Author: Safwan Parkar
Latest version: 0.1.4

# @safwanyp/json-schema-to-dts

A robust TypeScript package that converts complex JSON Schema files to TypeScript type definitions (.d.ts).

**_Disclaimer: AI assistance was used in the development of this project_**

**Key Features:**

- Handles deeply nested schemas and definitions
- Resolves references (`$ref`) accurately
- Supports `oneOf`, `anyOf`, and `allOf` combinators
- Preserves directory structure

## Requirements

- Node.js >= 14.14.0

## Installation

```bash
pnpm add @safwanyp/json-schema-to-dts
# or
npm install @safwanyp/json-schema-to-dts
```

## Usage

```typescript
import { toTypes } from "@safwanyp/json-schema-to-dts";

// Convert all JSON Schema files in a directory to TypeScript definition files
await toTypes({
  pathToJsonSchemas: "./schemas",
  pathToOutputDirectory: "./src/types",
  generatedTypesExportsFormat: 'ROOT_ONLY' // or 'UNIQUE_EXPORTS'
});
```

The function preserves the directory structure from input to output. For example:

- Input: `schemas/programme.schema.json` → Output: `src/types/programme.d.ts`
- Input: `schemas/v2/offer.schema.json` → Output: `src/types/v2/offer.d.ts`

## Examples

### Complex Schema Support

Input (`user.schema.json`):

```json
{
  "title": "User",
  "type": "object",
  "properties": {
    "id": { "type": "string" },
    "role": { "oneOf": [{ "const": "ADMIN" }, { "const": "USER" }] },
    "meta": {
      "type": "object",
      "properties": {
        "created": { "type": "string" }
      }
    }
  }
}
```

Output (`user.d.ts`):

```typescript
interface User {
  id?: string;
  role?: "ADMIN" | "USER";
  meta?: UserMeta;
}

interface UserMeta {
  created?: string;
}

export { User };
export { UserMeta };
```

## API

### `toTypes(config: ToTypesConfig): Promise<void>`

**Parameters:**

- `config.pathToJsonSchemas` (string): Absolute or relative path to the directory containing `.json` schema files.
- `config.pathToOutputDirectory` (string): Absolute or relative path to the directory where `.d.ts` files will be written.
- `config.generatedTypesExportsFormat` (string): Determines how generated types are exported in the output `.d.ts` files. Accepted values for now are 'UNIQUE_EXPORTS' and 'ROOT_ONLY'.

## Development

```bash
# Install dependencies
pnpm install

# Build
pnpm run build

# Run tests
pnpm test
```

## License

MIT