open-index/open-npm huggingface dataset:
npm package: @gurupras/file-icons-js
Description: File specific icons for the browser from Atom File-icons, https://github.com/file-icons/atom. Forked from https://github.com/websemantics/file-icons-js.
Author: Guru Prasad Srinivasa
Latest version: 1.1.0
Deprecated: Package moving to @gurupras/svg-file-icons

```
╭───────╮                    ╭────╮
│    ╭──╯╭───╮╭───╮╭──────╮  ├────┤╭──────╮╭──────╮╭────┬─╮╭──────╮
│    ╰──╮├───┤│   ││  ──  │  │    ││   ╭──╯│   ╭╮ ││      ││  ────┤
│    ╭──╯│   ││   ││      │  │    ││   ╰──╮│   ││ ││   ╭╮ ││      │
│    │   │   ││   ││  ────┤  │    ││      ││   ╰╯ ││   ││ │├────  │
╰────╯   ╰───╯╰───╯╰──────╯  ╰────╯╰──────╯╰──────╯╰───╯╰─╯╰──────╯
╭─╮  ╭─╮  ┬─╮         ┬  ╭─╮  ┬  ┬  ╭─╮  ╭─╮  ╭─╮  ┬─╮  ┬  ╭─╮  ╭┬╮
├┤   │ │  ├┬╯         │  ├─┤  ╰╮╭╯  ├─┤  ╰─╮  │    ├┬╯  │  ├─╯   │
┴    ╰─╯  ┴╰─       ╰─╯  ┴ ┴   ╰╯   ┴ ┴  ╰─╯  ╰─╯  ┴╰─  ┴  ┴     ┴
```
> File specific icons for the browser from Atom File-icons, https://github.com/file-icons/atom

<img alt="Icon previews" width="850" src="https://raw.githubusercontent.com/file-icons/atom/6714706f268e257100e03c9eb52819cb97ad570b/preview.png" />

## Install

Use `npm` to install as follows,

```bash
npm i @gurupras/file-icons-js
```

## Getting Started

Include `css` styles from `css/style.css` in the header of an html document.

Get an instance of `FileIcons` class,

```js
var icons = window.FileIcons;
```

Get the class name of the icon that represent a filename (for example `text-icon`),

```js
var filename = 'src/app.js';
var class_name = icons.getClass(filename);
```

You can also get a class name of the associated icon color,

```js
var  filename = 'README.md';
var class_name = icons.getClassWithColor(filename);
```

Use the class name to generate html, for example,

```js
document.body.innerHTML = "<a><i class=" + class_name + "></i>$filename</a>";
```

## Resources
- [websemantics/file-icons-js](https://github.com/websemantics/file-icons-js), Original repository from which this was forked.
- [Atom File Icons](https://github.com/file-icons/atom), file specific icons for improved visual grepping.

## Contribution

Contributions to this project are accepted in the form of feedback, bugs reports and even better - pull requests.

## License

[MIT license](https://github.com/gurupras/file-icons-js/)
npm package: @gurupras/font-blast
Description: Converts any icon-font (Font Awesome etc) into individual SVG files for each icon.
Author: gurupras@buffalo.edu
Latest version: 0.7.3

## What is this

This is a clone of [eugene1g's font-blast](https://github.com/eugene1g/font-blast) with minor changes (de-optimizations)
to support [@gurupras/svg-file-icons](https://github.com/gurupras/svg-file-icons).

Icon Fonts are cool - Font Awesome/Foundation/Fontello/etc all have great-looking and well thought out icons.
`font-blast` can extract those cool icons from the font file, and create individual SVG/PNG files for every one of them.

## Why?
 - **Use cool icons outside of web pages**.  If you have individual icons as SVGs, you can import them into Sketch, Illustrator, PowerPoint, or any other app to use for visual mockups/presentations.
 - **Modify & repackage icons**. It's easy to change an individual SVG file, then repackage all images back into an icon-font (with e.g. Font Squirrel)
 - **Get high quality PNGs**. Generate high-res PNGs with a transparent backgrounds to use in native applications, emails, etc.


## Installation
Font-blast does not require PhantomJS or any other native binaries, so it should work pretty much everywhere.

Note: PNG images are generated with the embedded batik-rasterizer, and you will need have java installed to do that. Evil Java is not required for generating SVG files.

    $ npm install font-blast


## CLI usage

You can generate icons from the command line by called the script with two parameters: the SVG file of the font, and the directory where inidivual icons should be placed -
### CLI

    $ wget https://raw.githubusercontent.com/FortAwesome/Font-Awesome/master/fonts/fontawesome-webfont.svg
    $ bin/font-blast.js fontawesome-webfont.svg fa-icons/


### Node
    var fontBlast = require('font-blast');
    fontBlast('font-awesome.svg', 'fa-icons');

## Better Usage
### Smarter filenames
Just using the SVG file it is impossible to tell what the icon represents. Most icon-fonts have a mapping table which gives a human-friendly name to each unicode symbol.
See https://github.com/eugene1g/font-blast-examples
npm package: @gururaj/react-vite-lib
Description: A modern React component library built with Vite.
Author: Your Name
Latest version: 1.0.4

# React Vite Component Library

This project is a modern React component library built with Vite and TypeScript. It supports per-component imports, per-component CSS, and a shared common CSS file for easy integration and tree-shaking.

## Usage

### 1. Install the Library

If published to npm:
```sh
npm install react-vite-lib
```

For local development/testing, see the **Local Development** section below.

### 2. Import Components and CSS

**Per-component import:**
```tsx
import Button from 'react-vite-lib/Button';
import 'react-vite-lib/Button/Button.css';

import Card from 'react-vite-lib/Card';
import 'react-vite-lib/Card/Card.css';

import Alert from 'react-vite-lib/Alert';
import 'react-vite-lib/Alert/Alert.css';
```

**Import shared/common styles:**
```tsx
import 'react-vite-lib/common.css';
```

### 3. TypeScript Support

All components include `.d.ts` type definitions for full TypeScript support.

### 4. External Peer Dependencies

This library does **not** bundle `react`, `react-dom`, or `react/jsx-runtime`. Make sure your project has compatible versions installed:
```sh
npm install react react-dom
```

---

## Local Development & Testing

To test this library in another local app **before publishing**:

### Option A: npm link (symlink)
1. In the library folder:
   ```sh
   npm run build
   npm link
   ```
2. In your test app folder:
   ```sh
   npm link react-vite-lib
   ```

### Option B: file: protocol
1. In your test app's `package.json`:
   ```json
   "dependencies": {
     "react-vite-lib": "file:../path/to/react-vite-lib"
   }
   ```
2. Then run:
   ```sh
   npm install
   ```

---

## Project Structure

- `src/components/Button/` — Button component and styles
- `src/components/Card/` — Card component and styles
- `src/components/Alert/` — Alert component and styles
- `src/components/common.css` — Shared/common styles

---

## Building the Library

```sh
npm run build
```
Outputs ES modules and CSS files for each component in `dist/`.

---

## License
MIT
npm package: @gurushi/simplecomponents
Description: simple components generic components library with beutiful css
Author: masood1
Latest version: 1.2.0

# simplecomponents

> simple components generic components library with beutiful css

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

## Install

```bash
npm install --save simplecomponents
```

## Usage

```tsx
import * as React from 'react'

import MyComponent from 'simplecomponents'

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

## License

MIT © [masood1](https://github.com/masood1)
npm package: @gus_hill/scaffolding
Description: A package that helps creating directories and files out of templates. Useful for creating a initial project setup, or complex components in big projects.
Author: Gustavo.Hillesheim
Latest version: 0.0.3-SNAPSHOT.1

# Scaffolding

Scaffolding is a package created for easy building of directories and files, based on a blueprint.<br>
The package was designed for create reusability, allowing template variables, and CRUD operations for blueprints.

Examples of usage:

```javascript
import { createScaffoldingService } from '@gus_hill/scaffolding';

const scaffoldingService = createScaffoldingService();
scaffoldingService.build({
  blueprint: {
    items: [
      new DirectoryBlueprint('src', [
        new FileBlueprint('index.js', 'console.log("Hello World");'),
      ]),
      new FileBlueprint('package.json', '{ "name": "$packageName" }'),
    ],
  },
  variables: {
    packageName: "sample_package"
  },
  outputDirectory: "C:\\sample_package"
})
  .then(() => console.log("Built blueprint successfully!"))
  .catch((err) => console.error("An error has occurred", err));
```

```javascript
import { createScaffoldingService, createBlueprintService } from '@gus_hill/scaffolding';

const blueprintsStorageDir = "C:\\blueprints";
const blueprintService = createBlueprintService(blueprintsStorageDir);
const scaffoldingService = createScaffoldingService();

blueprintService.loadBlueprint("test_blueprint")
  .then((blueprint) => scaffoldingService.build({ blueprint }));
```

## How to use

The two main classes of the package are `ScaffoldingService`, used for building a blueprint, and `BlueprintService`, used for CRUD operations on blueprints.

### ScaffoldingService

The ScaffoldingService provides the method `build`, which can be used to build a blueprint into actual directories/files. You can also define in which directory the blueprint will be built, as well as variables of the template.

### BlueprintService

The BlueprintService provides useful methods for persisting your blueprints for long-term usage. The available methods are: `saveBlueprint`, `loadBlueprint`, `listBlueprints`, `deleteBlueprint`, `blueprintExists`.
npm package: @gusbueno/js-utils
Description: Javascript utilities that you can use in your day-to-day.
Author: Gustavo Bueno
Latest version: 1.2.0

[![CircleCI](https://circleci.com/gh/gusbueno/js-utils/tree/master.svg?style=svg)](https://circleci.com/gh/gusbueno/js-utils/tree/master)
[![npm version](https://badge.fury.io/js/%40gusbueno%2Fjs-utils.svg)](https://badge.fury.io/js/%40gusbueno%2Fjs-utils)
[![dependencies](https://david-dm.org/gusbueno/js-utils.svg)](https://david-dm.org/gusbueno/js-utils)

# js-utils
Javascript utilities that you can use in your day-to-day development

#### arrayToObject
This function will help you to convert an array of objects to one object(key/value).

Example:
```js
import { arrayToObject } from '@gusbueno/js-utils'

const data = [
  {
    name: 'BTC',
    value: 6000
  }, {
    name: 'XRP',
    value: 0.34
  }
]

const objectData = arrayToObject(data, 'name')

/* RESULT
{
  BTC: {
    name: 'BTC',
    value: 6000
  },
  XRP: {
    name: 'XRP',
    value: 0.34
  }
}
 */
```

#### to
This function will help you to handle errors from **async/await** operator.

Example:
```js
import axios from 'axios'
import { to } from '@gusbueno/js-utils'

const getUsers = async () => {
  const [err, data] = await to(axios.get('http://host.com/api/users'))
  if (err) { // which means that err has value
    return 'An error ocurred on getUsers request'
  }
  // if err has no value then data has value
  return data
}
```
npm package: @guscrawford.com/cleye
Description: An unopinionated cli library
Author: Gus Crawford
Latest version: 1.0.0

# cl👁

**@guscrawford.com/cleye** */k'laɪ/*

The un-opnionated cli-library

## [📃 Docs](./docs/md/README.md)

----

## Off the Cuff Example

```

import { readFile, writeFile } from 'fs';
import { join } from 'path';
import { Templater } from '@guscrawford.com/json-xform';
import { CliApp, StaticOption } from '@guscrawford.com/cleye';
let app = new CliApp({
    {
        commands:{
            default:{
                name:'default',
                options: {
                    'out':{
                        spinalCaseName:'out',
                        flag:'o'
                    }
                },
                arguments:{
                    name:'template'
                },
                run: command
            }
        }
    }
});
function command() {
    console.info(command);
    readFile(join(process.cwd(),(command.args.template as any).value),{encoding:'utf8'},(err, data)=>{
        if (err) throw err;
        try {
            writeFile(
                (command.options.out as any).value||(command.args.template as any).value, 
                JSON.stringify(new Templater(JSON.parse(data)).parse(), null, "  "),
                (err:any)=>{if (err)throw err}
            );
        } catch (e) {
            throw e;
        }
    });
}
```
## Develop & Contribute

```
$>yarn install
$>yarn build
$>yarn test
```

*Docs are generated on build; see **docs***