open-index/open-npm huggingface dataset:
npm package: @linkcs/directory-tree
Description: Convert Directory Tree to JS object
Author: Ayc0
Latest version: 0.1.0

# TL;DR

Create a list of a given path:

<!-- `━┃┏┓┗┛┣┫┳┻╋` -->

```
folder/
   ┣━━ foo/
   ┃    ┗━━ bar/
   ┃         ┗━━ javascript.js
   ┃         ┗━━ python.py
   ┃         ┗━━ database.sql
   ┃
   ┣━━ paz/
   ┃
   ┗━━ ska/
        ┗━━ ignore.txt
```

```js
const getTree = require("@linkcs/directory-tree");

getTree("./folder");
// {
//   foo: {
//     bar: {
//       "javascript.js": null,
//       "python.py": null,
//       "database.sql": null
//     }
//   },
//   ska: {
//     "ignore.txt": null
//   }
// }

getTree("./folder", { extensions: ".py" });
// {
//   foo: {
//     bar: {
//       "javascript.js": null,
//       "python.py": null,
//       "database.sql": null
//     }
//   },
//   ska: {
//     "ignore.txt": null
//   }
// }

getTree("./folder", { includeFiles: false });
// {
//   foo: {
//     bar: { }
//   },
//   ska: { }
// }
```

## Options


| option           | description                            | default value  |
| ---------------- | -------------------------------------- | -------------- |
| extensions       | Only include files of these extensions | '.*'           |
| ignoreExtensions | Exclude files of these extensions      | null           |
| ignoreFiles      | Regex to ignore certain files          | '\\..*'        |
| ignoreFolders    | Regex to ignore certain folders        | 'node_modules' |
| includeFiles     | Should list files in the tree          | true           |
};
npm package: @linkcs/props-injecter
Description: Check if a room number is valid
Author: ayc0
Latest version: 0.1.1

# Props-Injecter

React component that injects props to its children.

## How to Use

The two following codes are equivalent:

```js
import React from "react";
import PropsInjecter from "@linkcs/props-injecter";

const App = () => (
  <React.Fragment>
    <Foo loading counter={5} />
    <Bar loading counter={5}>
      <Foobar loading counter={5} />
    </Bar>
  </React.Fragment>
);
```

```js
import React from "react";
import PropsInjecter from "@linkcs/props-injecter";

const App = () => (
  <PropsInjecter loading counter={5}>
    <Foo />
    <Bar>
      <Foobar />
    </Bar>
  </PropsInjecter>
);
```
npm package: @linkcs/room-checker
Description: Check if a room number is valid
Latest version: 1.1.4

# TL;DR

Expose dans npm un packet qui s'appelle `room_checker_cesal`, et qui expose une
fonction :

```javascript
> const roomChecker = require('@linkcs/room-checker');

// Détecte si la chambre existe ou non
> roomChecker('2D1G')
true

> roomChecker('5a1aze')
false
```

Et si jamais vous avez juste besoin de la regex associée :

```javascript
> const roomChecker = require('room_checker_cesal');

> roomChecker.regex
/.../
```
npm package: @linkdacademy/neo-name-service-sdk
Description: A SDK for the Neo Name Service (Neo N3) that allows you to interact with the NNS smart contract.
Author: Ricardo Prado @ Linkd Academy
Latest version: 0.1.4

# Neo Name Service SDK for JavaScript

This is the JavaScript SDK for the Neo Name Service (NNS) on the Neo blockchain. It provides a simple way to interact with the NNS smart contract. The SDK is written in TypeScript and can be used in both TypeScript and JavaScript projects.

## Installation

To install the SDK, use the following command:

```bash
npm install @linkdacademy/neo-name-service-sdk
```

## Usage

### Client Initialization

Import the SDK and initialize the client:

```typescript
// Initialize the client using RPC address and an account (optional)
const client = new NNSClient();
await client.init("https://mainnet2.coz.io", testAccount)

// Alternatively, initialize an NeonInvoker instance and pass it to the client
const invoker = await NeonInvoker.init({ "https://mainnet2.coz.io", testAccount })
const client = new NNSClient(invoker);
```

### Using the SDK

Use the SDK to perform read operations on the NNS smart contract. The following examples demonstrate how to get the owner of a domain name and the resolver address of a domain name.

```typescript
const name = "linkdacademy.neo";
const owner = await client.getOwner(name);
console.log(`The owner of ${name} is ${owner}`); // Na4VGtfNcJmgAXyREZ4WfDqnRZor4woga5
```

The transaction is not sent to the blockchain, so it does not require a signature.

### Write Operations

Write operations require a signer parameter to sign the transaction. The account used as the signer must match the one used to initialize the client.

```typescript
let name = 'test999.neo';
const signer: Signer = { account: testAccount.scriptHash, scopes: 'CalledByEntry' };
let result = await client.buyName(name, testAccount.scriptHash, signer, false, false); // Returns the transaction hash
```

The last two parameters in write operations are optional. Send `true` for the fourth parameter to submit the transaction to the blockchain. Using false will return a test invocation result. The fifth parameter is used to specify whether the client should wait for the transaction to be confirmed.

### NNS Transaction Builder

The SDK provides a class to build NNS invocation scripts. Use it to create custom transactions or execute multiple operations in a single transaction.

```typescript
// Returns a ContractInvocation object with the script and parameters
const invocation = NNSTransactionBuilder.getPropertiesInvocation(name);

//Execute the transaction (test invocation)
const resp = await this.invoker?.testInvoke({
    invocations: [invocation],
    signers: []
});
```

## Documentation

For more information on Neo Name Service, visit the [official documentation](https://docs.neo.link/).

Made with ❤️ by [Linkd Academy](https://linkd.academy)