open-index/open-npm huggingface dataset:
npm package: @struct-ui/icons
Description: A set of 16x16 pixel-perfect icons designed by the designers & developers for the designers & developers.
Author: Gagan Biswas
Latest version: 1.0.5

# Struct Icons

A set of 16x16 pixel-perfect icons designed by the designers & developers for the designers & developers.

Visit [icons.struct-ui.com](https://icons.struct-ui.com) to browse the icons.

## Documentation

All icons are available as individual React components.

Install Recon Icons from npm:

```shell
npm install @struct-ui/icons
```

Import the icons into your React project:

```jsx
import { ArrowRight, Sun } from "@struct-ui/icons";

function MyComponent() {
  return (
    <div>
      <ArrowRight />
      <Sun />
    </div>
  );
}
```

## Authors

- Gagan Biswas ([@gaganbiswas](https://github.com/gaganbiswas))

## License

Licensed under the [MIT License](https://github.com/gaganbiswas/struct-icons/blob/main/LICENSE), Copyright © 2023-present.
npm package: @structal/form
Description: ![skhma](./logo.png)
Latest version: 1.10.1

![skhma](./logo.png)



## Basic Usage

### Initialize the Form System

First, initialize the form system by defining your form components. This can be done in a standalone file:

```ts
// src/form.tsx
import initStructalForm from '@structal/form';
import structalChakraComponents from '@structal/form/adapters/chakra';

export const { makeForm } = initStructalForm({
  components: {
    ...structalChakraComponents,
  },
});
```

A `makeForm` function will be exposed in this initialization file, which will be referenced by other parts of your application wherever form inputs are needed.

### Create Structal Form

Next, create a structured form by defining its fields. using the initialized form system.

```ts
import { makeForm } from 'src/form.tsx';

const { Form } = makeForm({
  // the available components will be passed in as the first parameter
  fields: (c) => ({
    name: c.text({ label: 'Name' }),
    age: c.number({ label: 'Age' }),
  }),
});
```

### Render the Form

Finally, render the form in your component.

```tsx
const MyFormComponent = () => {
  return (
    <Form
      onSubmit={(values) => {
        // values: { name: string, age: number }
      }}
    >
      <Form.Field name="name" />
      <Form.Field name="age" />
      <button type="submit">Submit</button>
    </Form>
  );
};

export default MyFormComponent;
```
npm package: @structify-cli/cli
Description: A CLI tool for structuring your project
Author: Mahmoud Saber & Ashraf Mohamed
Latest version: 1.2.2

# 📖 Structify — Modern Project Scaffolding CLI

[![npm version](https://img.shields.io/npm/v/@structify-cli/cli?color=blue)](https://www.npmjs.com/package/@structify-cli/cli)  
[![npm downloads](https://img.shields.io/npm/dm/@structify-cli/cli?color=green)](https://www.npmjs.com/package/@structify-cli/cli)  
[![license](https://img.shields.io/github/license/Structify-CLI/structify)](LICENSE)  
[![build](https://img.shields.io/github/actions/workflow/status/Structify-CLI/structify/ci.yml?branch=main)](https://github.com/Structify-CLI/structify/actions)

**Structify** is a developer-friendly CLI tool that helps you **quickly scaffold modern web applications** with clean, opinionated project structures.  
It provides ready-to-use templates for popular frameworks like **React (Vite)** and **Next.js**, so you can focus on building instead of configuring.

---

## 📦 Installation

You don’t need to install Structify globally. Just use `npx`:

```bash
npx @structify-cli/cli create-app
```

Or install globally:

```bash
npm install -g @structify-cli/cli
structify create-app
```

---

## 🛠 Usage

### Create app

```bash
npx @structify-cli/cli create-app
structify  create-app
```

### Options

| Flag             | Description                        | Default |
| ---------------- | ---------------------------------- | ------- |
| `create-app`     | Choose template: `react` or `next` | react   |

---

## 📂 Example Project Structure

When you generate a project, Structify sets up a clean, modern structure with best practices.

**React + Vite + TypeScript example:**

```text
my-app/
│
├── src/
│   ├── components/
│   ├── pages/
│   └── App.tsx
│
├── public/
├── package.json
├── tsconfig.json
└── vite.config.ts
```

---

## 🤝 Contributing

Contributions are welcome!

1. Fork the repo
2. Create a new branch (`git checkout -b feature/awesome-feature`)
3. Commit changes (`git commit -m 'Add awesome feature'`)
4. Push branch (`git push origin feature/awesome-feature`)
5. Open a Pull Request 🎉

---

## 📜 License

MIT — free to use, modify, and share.
npm package: @structs/compose
Description: Compose two or more functions together
Latest version: 0.0.4


# compose

[![Build Status][travis-image]][travis-url]
[![NPM version][npm-image]][npm-url]
[![Dependency Status][david-image]][david-url]
[![License][license-image]][license-url]
[![Test coverage][coveralls-image]][coveralls-url]
[![Js Standard Style][standard-image]][standard-url]

Compose two or _more_ functions together.

![Function Composition](./docs/composition.png)

## What is it?

If you aren't familiar with function composition you can read all about it [here](http://scott.sauyet.com/Javascript/Talk/Compose/2013-05-22/#slide-0).

## Installation

```bash
$ npm install @structs/compose
```

## Example

```js
var times2plus1 = compose(plus1, times2)
// times2plus1(3) -> 7

function plus1 (x) {
  return x + 1
}

function times2 (x) {
  return x * 2
}
```

## Usage

Documentation is available [here](./docs/index.md).

## Tests

```bash
$ npm test
```

## License

[MIT][license-url]

[npm-image]: https://img.shields.io/npm/v/@structs/compose.svg?style=flat-square
[npm-url]: https://npmjs.org/package/@structs/compose

[david-image]: http://img.shields.io/david/structs/compose.svg?style=flat-square
[david-url]: https://david-dm.org/structs/compose

[license-image]: http://img.shields.io/npm/l/@structs/compose.svg?style=flat-square
[license-url]: ./license

[travis-image]: https://img.shields.io/travis/structs/compose.svg?style=flat-square
[travis-url]: https://travis-ci.org/structs/compose

[coveralls-image]: https://img.shields.io/coveralls/structs/compose/master.svg?style=flat-square
[coveralls-url]: https://coveralls.io/r/structs/compose?branch=master

[standard-image]: https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square
[standard-url]: https://github.com/feross/standard
npm package: @structure-codes/cli
Description: cli tool for generating directory structure from a .tree file
Latest version: 0.0.6

# struct cli
`struct` is a tool for generating trees from a user's file system as well as building structures in the file system from an existing tree

Install it with:
```
npm i -g @structure-codes/cli
```

### Configuration
By default, the cli will ignore certain directories which you are unlikely to want to include in tree output. This configuration will be stored in `.treerc` in your home directory (determined by either `$HOME` or `$USERPROFILE`). By default, the below directories are ignored:
```
.git
node_modules
```
If a `.treerc` file is not found when running the tool, you will be prompted to create one.
### Generating structure from a directory
Running `struct` will output a tree from your current directory by default. You can also specify a path to a target directory and different output options.
```
Usage: struct [options] [command] [directory]

Arguments:
  directory                       directory to build structure from (default: ".")

Options:
  -o, --output-file <outputFile>  file to put tree structure in
  -i, --ignore <ignore>           ignore these patterns (default: [])
  -c, --config-ignore             include patterns that are ignored by config
  -j, --json                      print tree in json format
  -e, --editor                    open structure in new vscode window
  -s, --silent                    do not print anything to the console

Examples:
  Output tree ignoring dist to file new.tree
  $ struct -i dist -o new.tree
```

### Building structure from a tree file
If you already have a tree that you want to mimic in your file system, you can build it with `struct build <file>`. You can specify the output path to build in with `-d`.

```
Usage: struct build [options] <file>

Arguments:
  file                         .tree file to build structure from

Options:
  -d, --directory <directory>  output directory to build structure in (default: ".")
  -h, --help                   display help for command

  Examples:    
    Build structure from src.tree in directory new-project
    $ struct build ./src.tree -o new-project
```
npm package: @structure-codes/is-nondot
Description: A library to test if a filename is considered a to be a standard non-dotted dotfile
Author: structure-codes
Latest version: 1.1.2

# is-nondot
A library to test if a filename is considered a to be a standard non-dotted dotfile

### installation
```
npm install nondot
```

### Usage

Typescript
```typescript
import isNondot from "@structure-codes/is-nondot"

console.log(isNondot("minecraft")); // => false
console.log(isNondot("Makefile")); // => true
```

JavaScript
```javascript
const isNondot = require("@structure-codes/is-nondot");

console.log(isNondot("minecraft")); // => false
console.log(isNondot("Makefile")); // => true
```

### Supported files
See the [non-dotted-dotfiles.json](https://github.com/structure-codes/non-dotted-dotfiles/blob/main/src/non-dottted-dotfiles.json) for the full list of files.
npm package: @structure-codes/utils
Description: A library containing utilities to convert tree structures between JSON and string formats
Author: structure-codes
Latest version: 0.0.3

This repo contains the tree parsing functions which are used in multiple repos throughout the project.

## treeStringToJson
This parses a tree output into JSON for further use. Sample JSON format is below. Node names are stored in the keys and children are stored as an object in the value.
```json
[
  {
    "name": "AboutView",
    "children": [],
  },
  {
    "name": "App",
    "children": [
      {
        "name": "Header",
        "children": [
          {
            "name": "index.tsx",
            "children": [],
          }
        ]
      },
      {
        "name": "index.tsx",
        "children": [],
      },
      {
        "name": "style.ts",
        "children": [],
      }
    ]
  }
]
```

## treeJsonToString
This is used to convert the JSON back to a formatted string for logging or storing in a file.
```tree
├── AboutView
└── App
  ├── Header
  │  └── index.tsx
  ├── index.tsx
  └── style.ts
```
npm package: @structure-js/datastructure
Description: javascript data structures
Author: structure-js
Latest version: 1.1.1

# datastructure
> datastructure is a library of data structures available in JavaScript.

### Demo

#### [Visualization demo site](http://structure-js-visualization.s3-website.ap-northeast-2.amazonaws.com/)
![demo](https://github.com/structure-js/images/blob/master/visualization.gif)

### Overview

* [Linked list](https://github.com/structure-js/datastructure/wiki/List)
* [Stack](https://github.com/structure-js/datastructure/wiki/Stack)
* [Queue](https://github.com/structure-js/datastructure/wiki/Queue)
* [Deque](https://github.com/structure-js/datastructure/wiki/Deque)
* [Heap](https://github.com/structure-js/datastructure/wiki/Heap)
* [PriorityQueue](https://github.com/structure-js/datastructure/wiki/PriorityQueue)
* [Graph](https://github.com/structure-js/datastructure/wiki/Graph)
* [Tree](https://github.com/structure-js/datastructure/wiki/Tree)
* [BinarySearchTree](https://github.com/structure-js/datastructure/wiki/BinarySearchTree)
* [Btree](https://github.com/structure-js/datastructure/wiki/BTree)

### Repo Structure
* `lib/` - data structure library
* `test/` - test
* `index.js` - index

### Installation and Settings
#### Build requirements
* `Node.js 6.x+`

#### Installation
```
npm i @structure-js/datastructure
```

#### How to use
```
const List = require('@structure-js/datastructure').List;
const Graph = require('@structure-js/datastructure').Graph;
const BST = require('@structure-js/datastructure').BinarySearchTree;

let list = new List();
let graph = new Graph();
let bst = new BST();

...
```

### Contributors
korsejong, HeechanYang

### License
```
MIT License

Copyright (c) 2018 structure-js

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.
```