open-index/open-npm huggingface dataset:
npm package: @jpex-js/babel-plugin
Description: Babel plugin for jpex
Author: Jack Ellis
Latest version: 1.9.0

# babel

Babel plugin for jpex

## usage

Jpex uses a babel plugin to infer type interfaces. Your babel config should look something like this:

```js
{
  presets: [ '@babel/preset-typescript' ],
  plugins: [ 'jpex/babel-plugin' ]
}
```

## options

### identifier

```ts
string | string[]
```

The variable name of your `jpex` instance that the babel plugin should look for. By default it is just `jpex`.

For example in your app you may have something like:

```ts
const ioc = jpex.extend();

ioc.factory<Foo>(fooFn);
```

Then you should set the identifier property to `'ioc'` or `[ 'ioc', 'jpex' ]`

### publicPath

```ts
string | boolean;
```

The default behavior when creating string literals for types is to use the file path + the type name.

For example, if you import `MyDep` from `'src/types/common'`, jpex will name it `type:/src/types/common/MyDep`.

However, sometimes this is not ideal, such as when creating a node module package. (When you import a type from a node module, jpex will just use the package name as the file path)

`publicPath` allows you to set the path prefix. For example, setting it to `myPackageName` would result in a naming scheme of `type:/myPackageName/MyDep`.

If you set `publicPath` to `true`, it will attempt to load your `package.json` and read the `name` property.

### pathAlias

```ts
{
  [key: string]: string
}
```

Creates aliases for certain paths. This is currently a very basic implementation. If an import starts with a pathAlias, it'll replace it with the given alias.

For example:

```js
{
  '@': '/src'
}
```

Will convert

```ts
import { MyService } from "@/services";
```

into

```ts
import { MyService } from "/src/services";
```

This is only in terms of resolving a dependency's name, it doesn't actually update the import path.

### omitIndex

```ts
boolean;
```

When registering a dependency in an index file, the index will be omitted.

For example:

```ts
// /src/services/index.ts

type MyService = any;

jpex.service<MyService>(myService);
```

This would normally produce a type name of `type:/src/services/index/MyService`. With omitIndex it will create `type:/src/services/MyService`.
npm package: @jpex-js/rollup-plugin
Description: Rollup plugin for jpex
Author: Jack Ellis
Latest version: 1.0.0

# @jpex/rollup-plugin
Rollup plugin for jpex

## usage
```js
// rollup.config.js
import typescript from 'rollup-plugin-typescript2';
import jpex from '@jpex-js/rollup-plugin';

{
  // ...
  plugins: [
    jpex(opts),
    typescript()
  ]
}
```

## options
### identifier
```ts
string | string[]
```
The variable name of your `jpex` instance that the plugin should look for. By default it is just `jpex`.

For example in your app you may have something like:

```ts
const ioc = jpex.extend();

ioc.factory<Foo>(fooFn);
```

Then you should set the identifier property to `'ioc'` or `[ 'ioc', 'jpex' ]`

### publicPath
```ts
string | boolean
```
The default behavior when creating string literals for types is to use the file path + the type name.

For example, if you import `MyDep` from `'src/types/common'`, jpex will name it `type:/src/types/common/MyDep`.

However, sometimes this is not ideal, such as when creating a node module package. (When you import a type from a node module, jpex will just use the package name as the file path)

`publicPath` allows you to set the path prefix. For example, setting it to `myPackageName` would result in a naming scheme of `type:/myPackageName/MyDep`.

If you set `publicPath` to `true`, it will attempt to load your `package.json` and read the `name` property.
npm package: @jpex-js/vite-plugin
Description: This is a vite plugin to enable jpex transformations during the build process.
Author: Jack Ellis
Latest version: 1.0.1

# @jpex-js/vite-plugin

This is a vite plugin to enable jpex transformations during the build process.

## Usage
```ts
import jpexPlugin from '@jpex-js/vite-plugin';

export default {
  // ...vite config
  plugins: [
    jpexPlugin()
  ]
}
```

The plugin accepts all of the same arguments as the babel plugin: https://github.com/jpex-js/babel-plugin#options
npm package: @jpex-js/webpack-loader
Description: Webpack loader for jpex
Author: Jack Ellis
Latest version: 1.0.0

# @jpex/webpack-loader
Webpack loader for jpex

## usage
```js
// webpack.config.js
{
  module: {
    rules: [{
      test: /\.tsx?$/,
      use: [
        'awesome-typescript-loader',
        {
          loader: '@jpex/webpack-loader',
          options: {},
        }
      ]
    }]
  }
}
```

## options
### identifier
```ts
string | string[]
```
The variable name of your `jpex` instance that the plugin should look for. By default it is just `jpex`.

For example in your app you may have something like:

```ts
const ioc = jpex.extend();

ioc.factory<Foo>(fooFn);
```

Then you should set the identifier property to `'ioc'` or `[ 'ioc', 'jpex' ]`

### publicPath
```ts
string | boolean
```
The default behavior when creating string literals for types is to use the file path + the type name.

For example, if you import `MyDep` from `'src/types/common'`, jpex will name it `type:/src/types/common/MyDep`.

However, sometimes this is not ideal, such as when creating a node module package. (When you import a type from a node module, jpex will just use the package name as the file path)

`publicPath` allows you to set the path prefix. For example, setting it to `myPackageName` would result in a naming scheme of `type:/myPackageName/MyDep`.

If you set `publicPath` to `true`, it will attempt to load your `package.json` and read the `name` property.
npm package: @jpfdev/vue3-treeview
Description: A simple vue js 3 treeview component
Author: Tristan Fontaine
Latest version: 0.4.24

## vue3-treeview

![build](https://github.com/N00ts/vue3-treeview/actions/workflows/build.yml//badge.svg) ![tests](https://github.com/N00ts/vue3-treeview/actions/workflows/tests.yml//badge.svg) ![Statements](https://img.shields.io/badge/statements-97.31%25-brightgreen.svg) [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)

![Screenshot](./public/screenshot.png)

Vue3 treeview is a treeview project.

[Documentation](https://n00ts.github.io/vue3-treeview)

__Features:__

- Made with vue3
- Fully reactive
- Typings
- Normalized data (not deeply nested)
- Full composition API
- Lazy load
- Editable text
- Events for all actions
- Node slots
- Loading slot
- Keyboard navigation
- Checkboxes (auto / manual)
- Drag and drop
- Customizable style
- Customizable icons

## Installation

```shell
npm install vue3-treeview
yarn add vue3-treeview
```

## Play with repo

* Clone this repository
* `yarn install`
* `yarn dev`

## License

[MIT](https://github.com/N00ts/vue3-treeview/blob/master/LICENSE)
npm package: @jpfulton/net-sms-notifier-cli
Description: A Twilio-based SMS notifier CLI for network administration.
Author: J. Patrick Fulton
Latest version: 1.0.9

# net-sms-notifier-cli

[![ci](https://github.com/jpfulton/net-sms-notifier-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/jpfulton/net-sms-notifier-cli/actions/workflows/ci.yml)
[![npm version](https://badge.fury.io/js/%40jpfulton%2Fnet-sms-notifier-cli.svg)](https://www.npmjs.com/package/@jpfulton/net-sms-notifier-cli)
![License](https://img.shields.io/badge/License-MIT-blue)
![Visitors](https://visitor-badge.laobi.icu/badge?page_id=jpfulton.net-sms-notifier-cli)

A [Twilio](https://www.twilio.com)
based SMS notifier command line utility for network administrators.