open-index/open-npm huggingface dataset:
npm package: @mcintyre94/spl-account-compression
Description: JavaScript client for the Spl Account Compression program
Latest version: 0.0.4

# JavaScript client

A generated JavaScript library for the Spl Account Compression program.

## Getting started

To build and test your JavaScript client from the root of the repository, you may use the following command.

```sh
pnpm clients:js:test
```

This will start a new local validator, if one is not already running, and run the tests for your JavaScript client.

## Available client scripts.

Alternatively, you can go into the client directory and run the tests directly.

```sh
# Build your programs and start the validator.
pnpm programs:build
pnpm validator:restart

# Go into the client directory and run the tests.
cd clients/js
pnpm install
pnpm build
pnpm test
```

You may also use the following scripts to lint and/or format your JavaScript client.

```sh
pnpm lint
pnpm lint:fix
pnpm format
pnpm format:fix
```
npm package: @mciparelli/cz-conventional-changelog
Description: Commitizen adapter following the conventional-changelog format.
Author: Jim Cummins
Latest version: 0.3.0

# cz-conventional-changelog

Status:
[![npm version](https://img.shields.io/npm/v/cz-conventional-changelog.svg?style=flat-square)](https://www.npmjs.org/package/cz-conventional-changelog)
[![npm downloads](https://img.shields.io/npm/dm/cz-conventional-changelog.svg?style=flat-square)](http://npm-stat.com/charts.html?package=cz-conventional-changelog&from=2015-08-01)
[![Build Status](https://img.shields.io/travis/commitizen/cz-conventional-changelog.svg?style=flat-square)](https://travis-ci.org/commitizen/cz-conventional-changelog)

Part of the [commitizen](https://github.com/commitizen/cz-cli) family. Prompts for [conventional changelog](https://github.com/conventional-changelog/conventional-changelog) standard.
npm package: @mcity/mcity-tx-browser
Description: Standalone MCity Transmission file browser
Author: Jack Bowman, Ryan D. Lewis, Tyler Worman
Latest version: 1.1.7

# Mcity-tx-browser

[npm package](https://www.npmjs.com/package/@mcity/mcity-tx-browser)

To publish to NPM, update the version in `package.json` and use the following commands:

```
npm login
npm publish --access public
```

File browser vue component for transmission.um.city. The component must be used as shown with the following props:

```vue
<TxBrowser setShare="DATA" standAlone />

import TxBrowser from '@mcity/mcity-tx-browser/TxBrowser'
```

Where setShare specifies a share defined by its URL (eg. Working Group Data's url is https://transmission.um.city/l/WGDATA, and the setShare value would be 'WGDATA').

standAlone is a bool that lets the component know it's not being used on transmission.um.city and that it doesn't have access to certain data.

Your project must be using vuetify v2 for the browser to display properly.
npm package: @mcity/mcity-vue-shared
Description: Shared files for Mcity vue projects
Author: Jack Bowman, Brandon Lyons, & Tyler Worman
Latest version: 2.0.8

# Mcity-vue-shared
Common vue files/themed components used across projects

# Usage
## Toolbar
1. Import the `McityToolbar` component with
`import McityToolbar from '@mcity/mcity-vue-shared/components/McityToolbar'`
2. Include the toolbar component in the template for `app.vue` with `<mcity-toolbar><mcity-toolbar/>`
3. Pass the following required props
    - fullname
    - username
    - presentation-text
    - isUserAdmin
    - title
4. There is a named slot available titled "buttons" when any app-specific toolbar buttons can be placed (see example below).
5. There is another slot, "overflow-buttons" which maps to inside the ellipses menu on the far right of the toolbar.

### Example:
```
<mcity-toolbar
  :fullname="fullname"
  :username="username"
  :presentation-text="presentationText"
  :isUserAdmin="isUserAdmin"
  title="Project Tracking"
>
  <template v-slot:buttons>
    <v-btn
      v-if="isUserAdmin"
      flat
      :to="{name: 'New'}"
      data-cy="new-project-btn">
      New Project
    </v-btn>
  </template>
</mcity-toolbar>
```
npm package: @mciureanu/forge-library
Description: A minimal TypeScript library for UiPath Studio Forge
Author: UiPath
Latest version: 1.0.0

# Forge Library

A minimal TypeScript library for UiPath Studio Forge with utility functions for mathematical operations, string manipulation, and logging.

## Installation

```bash
npm install @uipath/forge-library
```

## Usage

```typescript
import { MathUtils, StringUtils, Logger } from '@uipath/forge-library';

// Math operations
const sum = MathUtils.add(5, 3); // 8
const product = MathUtils.multiply(4, 6); // 24
const factorial = MathUtils.factorial(5); // 120

// String operations
const capitalized = StringUtils.capitalize('hello world'); // 'Hello world'
const reversed = StringUtils.reverse('typescript'); // 'tpircsepyt'
const isPal = StringUtils.isPalindrome('racecar'); // true

// Logging
Logger.setLogLevel('debug');
Logger.info('Application started');
Logger.debug('Debug information');
Logger.warn('Warning message');
Logger.error('Error occurred');
```

## API Reference

### MathUtils

- `add(a: number, b: number): number` - Adds two numbers
- `multiply(a: number, b: number): number` - Multiplies two numbers
- `factorial(n: number): number` - Calculates factorial (throws error for negative numbers)

### StringUtils

- `capitalize(str: string): string` - Capitalizes first letter
- `reverse(str: string): string` - Reverses a string
- `isPalindrome(str: string): boolean` - Checks if string is palindrome

### Logger

- `setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): void` - Sets log level
- `debug(message: string): void` - Logs debug message
- `info(message: string): void` - Logs info message
- `warn(message: string): void` - Logs warning message
- `error(message: string): void` - Logs error message

## License

MIT
npm package: @mcius/otomatik
Description: A blank schematics
Latest version: 0.0.1

# Getting Started With Schematics

This repository is a basic Schematic implementation that serves as a starting point to create and publish Schematics to NPM.

### Testing

To test locally, install `@angular-devkit/schematics-cli` globally and use the `schematics` command line tool. That tool acts the same as the `generate` command of the Angular CLI, but also has a debug mode.

Check the documentation with

```bash
schematics --help
```

### Unit Testing

`npm run test` will run the unit tests, using Jasmine as a runner and test framework.

### Publishing

To publish, simply do:

```bash
npm run build
npm publish
```

That's it!
npm package: @mcjumaah/ext-svg-colorize
Description: Vue component to easily change external SVGs' color
Author: Mark Jumar Perez
Latest version: 1.0.6

# ext-svg-colorize

Vue component to easily change external SVGs' color. This component utilizes CSS masking to apply colors to an SVG file.

https://www.npmjs.com/package/@mcjumaah/ext-svg-colorize

### The Problem:

When we use external SVG files, we need to use the <img> tag to insert the SVG. The problem with the HTML IMG tag is that we can't its color with the typical use of CSS, e.g. changing the `color:` property.

### Reference

My reference to the approach I utilized in this component is the article by Hasan TEZCAN:

- https://dev.to/hasantezcan/how-to-colorize-svg-image-1kc8

### Note:

- Only applies one color, can't apply multiple colors
- If the original SVG file have multiple colors, it will be masked over with one color instead

## Get started

**External SVG Colorize**

Install:

```bash
npm install @mcjumaah/ext-svg-colorize
```

Then, import and register the component.

The component itself does not include any CSS. You'll need to include it separately for the component to work properly:

```js
// main.ts or main.js

import { createApp } from "vue";
import App from "./App.vue";

import ExtSvgColorize from "@mcjumaah/ext-svg-colorize";
import "@mcjumaah/ext-svg-colorize/styles.css";

createApp(App)
    .use(ExtSvgColorize);
    .mount("#app");
```

It is recommended to pass the SVG file to the component in this method:

```vue
<script setup>
// app.vue
import SampleSvg from "./assets/sample.svg";
</script>

<template>
	<div>
		<ExtSvgColorize :src="SampleSvg" color="black" />
	</div>
</template>
```

### Props

| Prop        | Description                               | Type                      | Default |
| ----------- | ----------------------------------------- | ------------------------- | ------- |
| src         | external SVG file's path (REQUIRED)       | './path/of/your/file.svg' | -       |
| customClass | custom class                              | `string`                  | -       |
| color       | new color to apply for the SVG file       | `string`                  | -       |
| width       | new width size to apply for the SVG file  | `number`                  | 40      |
| height      | new height size to apply for the SVG file | `number`                  | 40      |
npm package: @mck-p/async-iterables
Description: A way to deal with everything as async iterables
Latest version: 0.0.1-ALPHA-3

# @mck-p/async-iterables

## Overview

This package houses all of the building blocks to deal with
_most_ things as Async Iterables. This allows you to take
Arrays, Sets, Objects, and even primitives and turn them into
a common interface that you can `map`, `flatMap`, and more.

## Usage

```ts
import { utils, operators } from '@mck-p/async-iterables'

/**
 *
 * Given _some_ value, createAsyncIterator will create an
 * async iterator out of the value. This works with
 * 
 * - Read/Duplex/Transorm Streams
 * - Arrays
 * - Objects
 * - Maps
 * - Sets
 * - Primitive Values (All but `undefined`)
 * - Async Iterators
 * - Generator Functions
 * - Async Generator Functions
 * 
 */
const {
  createAsyncIterator
} = utils

const readStream = createReadStream()
const iterable = utils.createAsyncIterator(readStream)

for await (const value of iterable) {
  console.log(value.toString()) // this will log for each value emitted from the read stream
}

const {
/**
 * 
 * Given a value that can be given to createAsyncIterator,
 * it returns an array of the values of the async iterator.
 * Should be used to await the completion of the iteration
 * and to group all of the items together.
 * 
 */
  toArray,
/**
 * 
 * Given an iterator, return a Readstream. This allows
 * backwards compatability with interfaces that need
 * a stream of data instead of an iterator
 * 
 */
  iteratorToStream,
/**
 * 
 * Given a Read/Duplex/Transform stream, return an iterator
 * of the values
 * 
 */
  streamToIterator,
  is : {
    /**
     * 
     * Given a value, returns true if it can be used as an async iterator
     * 
     */
    asyncIterator,
    /**
     * 
     * Given a value, returns true if it can be used as an iterator
     * 
     */
    iterator,
    /**
     * 
     * Given a value, returns true if it can be used as a Readable stream
     * 
     */
    readableStream
  }
} = utils

const { 
  map,
  flatMap,
  filter,
  equals
} = operators

const baseIterator = [1, 2, 3]
const mapped = map(x => x * 2, baseIterator) // Iterator<1, 2, 3>
const filtered = filter(x => x > 2, baseIterator) // Iterator<3>
const flatMapped = flatMap(x => createAsyncIterator(x * 2)) // Iterator<1, 2, 3>

// equals uses === comparison by default
equals(mapped, flatMapped) // true
equals(baseIterator, map(x => x, baseIterator)) // true

// equals also allows for complex comparison
const users1 = [{ id: 1 }]
const users2 = [{ id: 1 }]
equals(users1, users2, (a, b) => a.id === b.id) // true
```

## Docs

# TODO