open-index/open-npm huggingface dataset:
npm package: @gandi-ide/gandi-ui
Description: gandi 组件库
Latest version: 1.0.13

# gandi-ui

A component library for the Gandi Editor service

[![NPM version](https://img.shields.io/npm/v/gandi-ui.svg?style=flat)](https://npmjs.org/package/gandi-ui)
[![NPM downloads](http://img.shields.io/npm/dm/gandi-ui.svg?style=flat)](https://npmjs.org/package/gandi-ui)

## Usage

[<img height="180" src="https://m.ccw.site/community/images/desktop/gandi-logo.png">](https://gandi-ui.ccw.site/)

## Development

```bash
# install dependencies
$ yarn install

# develop library by docs demo
$ yarn start

# build library source code
$ yarn run build

# build library source code in watch mode
$ yarn run build:watch

# build docs
$ yarn run docs:build

# Locally preview the production build.
$ yarn run docs:preview

# check your project for potential problems
$ yarn run doctor
```

```jsx | pure
import React from 'react';

// 1. Introduce the `GandiProvider` component.
import { GandiProvider } from '@gandi-ide/gandi-ui';

function App() {
  // 2. Wrap the GandiProvider around the root of your application
  return (
    <GandiProvider>
      <TheRestOfYourApplication />
    </GandiProvider>
  );
}
```

## LICENSE

MIT
npm package: @gandini/vue-csv-import-ptpt
Description: Vue.js component to handle CSV uploads with field mapping. Forked from vue-csv-import, updated for PT-PT localization and to remove an unwanted checkbox
Author: Gandini
Latest version: 1.0.0

## Fork from vue-csv-import (https://github.com/jgile/vue-csv-import) for european Portuguese support, the "has header" checkbox has also been removed in this version.

## Please head to the original repository for the readme and documentation.
npm package: @gandlaf21/bc-ur
Description: A JS implementation of the Uniform Resources (UR) specification from Blockchain Commons
Author: gandlaf21
Latest version: 1.1.12

# BC-UR

Fork from `@ngraveio/bc-ur` implementing blockchain commons unified resources in typescript. 

## Installing

To install, run:
```bash
yarn add @gandlaf21/bc-ur
```

## Quick Start

### Encode a message

```js
import {UR, UREncoder} from '@gandalf21/bc-ur'

const message = {any: 'property'}
const messageBuffer = Buffer.from(JSON.stringify(message))

// First step is to create a UR object from a Buffer
const ur = UR.fromBuffer(messageBuffer)

// Then, create the UREncoder object

// The maximum amount of fragments to be generated in total
// For NGRAVE ZERO support please keep to a maximum fragment size of 200
const maxFragmentLength = 200

// The index of the fragment that will be the first to be generated
// If it's more than the "maxFragmentLength", then all the subsequent fragments will only be
// fountain parts
const firstSeqNum = 0

// Create the encoder object
const encoder = new UREncoder(ur, maxFragmentLength, firstSeqNum)

// Keep generating new parts, until a condition is met; for example the user exits the page, or clicks "DONE"
while(!stop) {
  // get the next part in the sequence
  let part = encoder.nextPart()

  // get the part as a string containing the cbor payload and display it with whatever way
  // the part looks like this:
  // ur:bytes/1-9/lpadascfadaxcywenbpljkhdcahkadaemejtswhhylkepmykhhtsytsnoyoyaxaedsuttydmmhhpktpmsrjtdkgslpgh

  displayPart(part)
}
```

### Decode a message

```js
import {URDecoder} from '@gandalf21/bc-ur'

// Create the decoder object
const decoder = new URDecoder()

do {
  // Scan the part from a QRCode
  // the part should look like this:
  // ur:bytes/1-9/lpadascfadaxcywenbpljkhdcahkadaemejtswhhylkepmykhhtsytsnoyoyaxaedsuttydmmhhpktpmsrjtdkgslpgh
  const part = scanQRCode()

  // register the new part with the decoder
  decoder.receivePart(part)

  // check if all the necessary parts have been received to successfully decode the message
} while (!decoder.isComplete())

// If no error has been found
if (decoder.isSuccess()) {
  // Get the UR representation of the message
  const ur = decoder.resultUR()

  // Decode the CBOR message to a Buffer
  const decoded = ur.decodeCBOR()

  // get the original message, assuming it was a JSON object
  const originalMessage = JSON.parse(decoded.toString())
}
else {
  // log and handle the error
  const error = decoder.resultError()
  console.log('Error found while decoding', error)
  handleError(error)
}

```
npm package: @gandlaf21/blind-signature
Description: `@gandlaf21/blind-signature` is a JavaScript Module implementing blind signatures using `@noble/secp256k1` elliptic curve.
Author: gandlaf21
Latest version: 1.0.7

# Blinded Signatures
`@gandlaf21/blind-signature` is a JavaScript Module implementing blind signatures using `@noble/secp256k1` elliptic curve. 

## Usage 

__install:__

```shell
npm i @gandlaf21/blind-signature
```

__use:__ 

Take a look at this example for the complete flow:

```javascript
import { SigningAuthority, BlindedMessage } from "@gandlaf21/blind-signature";
//Mint(Alice)
const mint: SigningAuthority = new SigningAuthority();

//Wallet(Bob)
const message: BlindedMessage = new BlindedMessage()
const B_ = await message.createBlindedMessageFromString("secret")

//Mint
const C_ = mint.createBlindSignature(B_)

//Wallet
const {C, secret} = message.unblindSignature(C_, mint.publicKey)

//Mint
const aY  = await mint.calculateCVerify(secret)

//if C===aY, the message was signed by the mint with private key a 
```

In the most likely case, the Signing Authority is not running alongside the creator of the blinded messages. We can serialize and deserialize the points, to hex strings, for simplified data transfer:

```javascript
import { hexToPoint, pointToHex } from "@gandlaf21/blind-signature";

//serialize
const b_ = pointToHex(B_)

//deserialize
const B_dec: = hexToPoint(b_)
```
npm package: @gandlaf21/cashu-crypto
Description: Basic cashu crypto functions
Author: gandlaf21
Latest version: 0.2.6

# Cashu Crypto

![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/gandlafbtc/cashu-crypto-ts/node.js.yml)
![GitHub issues](https://img.shields.io/github/issues/gandlafbtc/cashu-crypto-ts)
![GitHub package.json version](https://img.shields.io/github/package-json/v/gandlafbtc/cashu-crypto-ts)
![npm](https://img.shields.io/npm/v/@gandlaf21/cashu-crypto)
![npm type definitions](https://img.shields.io/npm/types/@gandlaf21/cashu-crypto)
![npm bundle size](https://img.shields.io/bundlephobia/min/@gandlaf21/cashu-crypto)
[code coverage](https://gandlafbtc.github.io/cashu-crypto-ts/coverage)


Basic crypto operations for cashu wallets and mints written in TypeScript
npm package: @gandlaf21/cashu-ts
Description: cashu library for communicating with a cashu mint
Author: gandlaf21
Latest version: 0.8.0-rc.14

# Cashu TS

![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/cashubtc/cashu-ts/node.js.yml)
![GitHub issues](https://img.shields.io/github/issues/cashubtc/cashu-ts)
![GitHub package.json version](https://img.shields.io/github/package-json/v/cashubtc/cashu-ts)
![npm](https://img.shields.io/npm/v/@cashu/cashu-ts)
![npm type definitions](https://img.shields.io/npm/types/@cashu/cashu-ts)
![npm bundle size](https://img.shields.io/bundlephobia/min/@cashu/cashu-ts)

⚠️ **Don't be reckless:** This project is in early development, it does however work with real sats! Always use amounts you don't mind loosing.

Cashu TS is a JavaScript library for [Cashu](https://github.com/cashubtc) wallets written in Typescript.

Wallet Features:

- [x] connect to mint (load keys)
- [x] request minting tokens
- [x] minting tokens
- [x] sending tokens (get encoded token for chosen value)
- [x] receiving tokens
- [x] melting tokens
- [x] check if tokens are spent
- [ ] ...

Implemented [NUTs](https://github.com/cashubtc/nuts/):

- [x] [NUT-00](https://github.com/cashubtc/nuts/blob/main/00.md)
- [x] [NUT-01](https://github.com/cashubtc/nuts/blob/main/01.md)
- [x] [NUT-02](https://github.com/cashubtc/nuts/blob/main/02.md)
- [x] [NUT-03](https://github.com/cashubtc/nuts/blob/main/03.md)
- [x] [NUT-04](https://github.com/cashubtc/nuts/blob/main/04.md)
- [x] [NUT-05](https://github.com/cashubtc/nuts/blob/main/05.md)
- [x] [NUT-06](https://github.com/cashubtc/nuts/blob/main/06.md)
- [x] [NUT-07](https://github.com/cashubtc/nuts/blob/main/07.md)
- [x] [NUT-08](https://github.com/cashubtc/nuts/blob/main/08.md)
- [x] [NUT-09](https://github.com/cashubtc/nuts/blob/main/09.md)

Supported token formats:

- [x] v1 read
- [x] v2 read (deprecated)
- [x] v3 read/write

## Usage

Go to the [docs](https://cashubtc.github.io/cashu-ts/) for detailed usage.

### Install

```shell
npm i @cashu/cashu-ts
```

### Import

```typescript
import { CashuMint, CashuWallet, getEncodedToken } from '@cashu/cashu-ts';

const wallet = new CashuWallet(new CashuMint('{MINT_URL}'));

const { pr, hash } = await wallet.requestMint(200);

//pay this LN invoice
console.log({ pr }, { hash });

async function invoiceHasBeenPaid() {
	const proofs = await wallet.requestTokens(200, hash);
	//Encoded proofs can be spent at the mint
	const encoded = getEncodedToken({
		token: [{ mint: '{MINT_URL}', proofs }]
	});
	console.log(encoded);
}
```

## Contribute

Contributions are very welcome.

If you want to contribute, please open an Issue or a PR.
npm package: @gandlaf21/cashu-ts-nostr-req
Description: Custom request for proxying requests through nostr relays
Latest version: 0.0.1

# Cashu-ts plugin for requests proxied through [proxley]() [based on cashu-proxy by @gudnuf](https://github.com/gudnuf/cashu-proxy)

Extracted and refactored to work as a module from [here](https://github.com/gudnuf/cashu-proxy-tester)

## Build

```
deno install
./_build_npm.ts 0.0.1
```

### Bonus

Along with the custom request, cashu-ts allows us to use any string as a `mintUrl`, so we can just initialize a mint with their pubkey in place of a URL.

This means tokens can be created with a pubkey in place of the mint url. Then when this token is sent the recipient can just query nostr for the corresponding kind `11111`