open-index/open-npm huggingface dataset:
npm package: @msidolphin/vue-progress
Description: vue进度条组件
Author: msidolphin
Latest version: 1.0.3

# v-progress
vue进度条组件

## 安装

```bash
npm install @msidolphin/vue-progress
```

## 使用

```js
import Vue from 'vue'

import VueProgress from '@msidolphin/vue-progress'

Vue.use(VueProgress)
```

```vue
<script>
export default {
  name: 'App',
  data () {
    return {
      percent: 0.8
    }
  },
  mounted () {
    this.timer = setInterval(() => {
      this.percent = Math.random()
    }, 1000)
  },
  beforeDestroy () {
    clearInterval(this.timer)
  }
}
</script>

<template>
  <div id="app">
    <v-linear-progress
      className="hover"
      :chunks="20"
      :colors="['red', 'blue', 'orange']"
      :percent="percent"
      curve="linear"
    />
    <br/>
    <v-linear-progress
      className="hover"
      :chunks="44"
      :percent="percent"
    />
  </div>
</template>

<style scoped>
.hover {
  width: 360px;
  height: 36px;
  border-color: #000;
}
.hover:hover {
  border-color: red;
}
</style>
```
## 配置

### v-linear-progress

|  属性   | 类型  |  默认值   | 说明  |
|  ----  | ----  | ----  | ----  |
| percent | number | 0  | 进度所占比例 [0 - 1] |
| chunks  | number | 20  | 分块数量 |
| chunkGaps  | number | 1  | 分块间距 |
| chunkColor  | string | rgba(0,0,0,.2) | 分块的背景色 |
| colors  | array<string> | ['#56D6C7', '#409BFF'] | 进度条背景色 |
| duration  | number | 300  | 动画时长 |
| curve  | string | easeInQuad  | 动画缓动函数 |


### 缓动函数可选值

* linear
* easeInQuad
* easeOutQuad
* easeInOutQuad
* easeInCubic
* easeOutCubic
* easeInOutCubic
* easeInQuart
* easeOutQuart
* easeInOutQuart
* easeInQuint
* easeOutQuint
* easeInOutQuint
* easeInSine
* easeOutSine
* easeInOutSine
* easeInExpo
* easeOutExpo
* easeInOutExpo
* easeInCirc
* easeOutCirc
* easeInOutCirc
* easeInElastic
* easeOutElastic
* easeInOutElastic
* easeInBack
* easeOutBack
* easeInOutBack
* easeInBounce
* easeOutBounce
* easeInOutBounce
npm package: @msidolphin/webpack-aliyun-oss-plugin
Description: webpack阿里云oss上传插件
Author: msidolphin
Latest version: 1.0.1

# webpack-aliyun-oss-plugin
webpack上传阿里云oss插件，能够在文件输出到output.path之后自动将静态资源发布到阿里云

注意：这个插件应该在生产环境使用

## 安装

```bash
npm install @msidolphin/webpack-aliyun-oss-plugin --save-dev
```

## 使用

```js
const WebpackAliyunOssPlugin = require('@msidolphin/webpack-aliyun-oss-plugin')

module.exports = {
    /// ...
    plugins: [
        new WebpackAliyunOssPlugin({
            accessKeyId: 'your access key',
            accessKeySecret: 'your access key secret',
            /// 应该包含的文件
            include: './dist/static/**',
            /// 需要剔除的文件
            exclude: [/\.html$/],
            region: 'your region',
            bucket: 'your bucket',
            /// 阿里云oss发布路径
            /// 最终文件的访问地址为：https://[bucket].[region].aliyuncs.com/[publicPath]/[file]
            publicPath: '/www',
            /// 静态资源路径 默认/static
            assetsSubDirectory: '/static',
            /// 文件上传超时时间 单位ms 默认60000
            timeout: 60000
        }),
        /// ...
    ]
    /// ...
}
```
npm package: @msigrupo-develop/node-red-contrib-parquet
Description: Read and write parquet format files
Author: MSI
Latest version: 1.1.0

# node-red-contrib-parquet
Converts between a PARQUET string and its JavaScript object representation, in either direction.

### Installation
It can be installed from the Node-RED palette, or by executing the following command in the Node-RED installation directory:
```sh
npm install @msigrupo-develop/node-red-contrib-parquet
```

### Dependencies
This package depends on the following libraries:
- [parquetjs-lite][1]

### Usage
Read or write mode must be selected.

##### Read mode
It will parse a single Buffer object from a parquet file to its JavaScript object representation. It is intended to be used together with the file reading node.
- A single message per row
- A single message [array]

By default, the output is sent to msg.payload bu it can be configured.
An [example][2] is ready to use.

##### Write mode
It will parse a JavaScript object to a Parqute single Buffer object. It is intended to be used together with the file writting node.
The columns names and types to be processed from the input must be configured. The input must be an array of objects with the names and values of the columns.
The output returns a single Buffer object in msg.payload.
An [example][3] is ready to use.

### Changelog
Changes can be followed [here][4]

### Credits
This project receives funding in the European Commission’s Horizon 2020 Research Programme under Grant Agreement Number 870062

### License
[MIT][5]


[1]:https://www.npmjs.com/package/parquetjs-lite
[2]:https://github.com/msigrupo/node-red-contrib-parquet/blob/master/examples/ReadParquet.json
[3]:https://github.com/msigrupo/node-red-contrib-parquet/blob/master/examples/WriteParquet.json
[4]:https://github.com/msigrupo/node-red-contrib-parquet/blob/master/CHANGELOG.md
[5]:https://github.com/msigrupo/node-red-contrib-parquet/blob/master/LICENCE
npm package: @msikma/wiki-ly
Description: A WikiMedia Parsoid fork for parsing wikitext into a Javascript object
Latest version: 0.1.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

[![MIT license](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT) [![npm version](https://badge.fury.io/js/@msikma%2Fwiki-ly.svg)](https://badge.fury.io/js/@msikma%2Fwiki-ly)

# Wiki.ly

Wiki.ly is a fork of Mediawiki's [Parsoid](https://github.com/wikimedia/parsoid) project. It's a PEG-based parser that converts wikitext to a Javascript object.

This particular version of Wiki.ly is a fork of [the original by @dan1wang](https://github.com/dan1wang/wiki.ly) to change the interface for package consumers, and to enable pre-compiling the tokenizer.

## Usage

To add this package to your project:

```
npm i --save "@msikma/wiki-ly"
```

### Example

A minimal example of running the parser with the default options:

```js
const { createParser } = require('@msikma/wiki-ly')

const input = `Hello [[world]]!`
const parser = createParser()
const output = parser.parse(input)

console.log(output)
```

This results in the following output:

```js
[
  'Hello ',
  SelfclosingTagTk {
    type: 'SelfclosingTagTk',
    name: 'wikilink',
    attribs: [ KV { k: 'href', v: [ 'world' ], vsrc: 'world' } ],
    dataAttribs: { tsr: [ 6, 15 ], src: '[[world]]' }
  },
  '!',
  EOFTk { type: 'EOFTk' }
]
```

It's possible to pass an object of environment options to the parser, but this is not documented right now. See `lib/env.js` for more information.

## License

This project is a fork of Wikimedia's [Parsoid](https://github.com/wikimedia/parsoid), which is licensed under the GPL v2.0.

[The port by @dan1wang](https://github.com/dan1wang/wiki.ly) is licensed under the MIT license.
npm package: @msimerson/dependency-version-checker
Description: Check for newer versions of dependencies.
Author: Tadeusz Makuch
Latest version: 1.1.2

# Dependency Version Checker

This library allows you to run a check for newer versions against your development and production dependencies, both npm and `git://`/`git+ssh://`.

## Motivation
Internal libraries or other dependencies should be as easy to verify as those published to npm. And you should have one tool for that.

## Prerequisites
For git, if you're able to clone the repo, you're able to check the tags.

For npm, there's no support for custom, manual repositories. If you're using custom repository, make it work without any additional parameters. 

Configure your npm, git and ssh if you have private repos.

## Disclaimer
This is "for dev by dev" tool. They may be some assumptions made, so do not hesitate to look into verbose logs if something seems not right.

Still, I'll try to list all assumptions in this file.
* Tags are in semver, if they do not pass semver parsing they do not show in the list.   

## Installation
`npm install -g dependency-version-checker`

## Usage
Run in your project (you do not need to be exactly in root):

```
dep-versions --help
dep-versions check [rule] //checks dependencies and prints them in table
dep-versions update [rule] //checks dependencies and update them in found package.json
```

#### Rule parameter
* Rule parameter is a string by which successful match against the dependencies.
* Rule parameter may be omitted, but check will be executed against all the dependencies.
  
#### Example

```
$dep-versions check lod
Performing dependency updates check for project: D:\Documents\Projects\depdency-version-checker\spec\package.json.
Check will be performed for dependencies matching this regex: /lod/.

You could update 1 dependency(/-ies).

Dependency  Type  Current Version  Latest Minor  Latest Major  
==========  ====  ===============  ============  ============  
lodash      Prod  3.0.0            3.10.1        4.17.11     
```

#### Debugging

Run `dep-versions <command> --help` to see additional flags.
npm package: @msinnes/babel-plugin-dom-jsx
Description: A dom jsx plugin for transpiling jsx into a renderable format.
Author: msinnes
Latest version: 0.0.19-alpha.0

# `@msinnes/babel-plugin-dom-jsx`

A babel plugin for converting JSX to core JS syntax. Makes JSX compatible with the library `@msinnes/dom`. Install the library using your prefered node package manager, and reference the plugin in your babel configuration. This plugin requires activation of jsx syntax in the babel parser, so `@babel/plugin-syntax-jsx` is necessary to have any affect on the code you want to transform.

Install with npm

```bash
npm install --save-dev @babel/plugin-syntax-jsx @msinnes/babel-plugin-dom-jsx
```

Install with yarn

```bash
yarn add -D @babel/plugin-syntax-jsx @msinnes/babel-plugin-dom-jsx
```

Example .babelrc
```json
{
  "plugins": ["@babel/plugin-syntax-jsx", "@msinnes/babel-plugin-dom-jsx"]
}
```


# Syntax conversion

The following AST nodes are transformed in this plugin: `JSXElement` and `JSXFragment`.

## JSXElement

Will convert a JSX element into an `@msinnes/dom` render. Renders have a signature, props, and children. If the signature is a recognized html tag, then the signature will process as a string for writing to the dom; otherwise, the signature will be a variable descriptor.

## JSXFragment

Will convert a JSX fragment to an array of JSX elements.
npm package: @msinnes/babel-preset-dom-jsx
Description: A babel preset for use in the msinnes/dom* libraries.
Author: msinnes
Latest version: 0.0.19-alpha.0

# `@msinnes/babel-preset-msinnes-dom`

A babel preset for implementing jsx and advanced JavaScript features for development in the `@msinnes/dom` environment. It combines `@babel/preset-env`, `@babel/plugin-syntax-jsx`, and `@msinnes/babel-plugin-dom-jsx` for faster development and simpler configuration. Simple install using your favorite package manager and add reference it in your babel configuration.

Install with npm

```bash
npm install --save-dev @msinnes/babel-preset-msinnes-dom
```

Install with yarn

```bash
yarn add -D @msinnes/babel-preset-msinnes-dom
```

Example .babelrc

```json
{
  "presets": ["@msinnes/babel-preset-msinnes-dom"]
}
```
npm package: @msinnes/dom-testing-library-jest
Description: A set of jest helpers for @msinnes/dom-testing-library.
Author: msinnes
Latest version: 0.0.23-alpha.0

# `@msinnes/dom-testing-library-jest`

Jest dependent helpers for use in conjunction with `@msinnes/dom-testing-library`. The library will not work outside of a jest environment.

# Screen Assertions

the `render` function in the `@msinnes/dom-testing-library` returns a screen objects, and this library adds some jest matching extensions. Matchers can be run against elements on the screen.

## - `toBeOnScreen`

Checks an element against a screen.

```TypeScript
const screen = render(/*some application render*/);
const element = screen.getByText('text');

expect(element).toBeOnScreen(screen);
```

Will pass the assertion if the element is found on the screen, and will throw an assertion error if the element is not found on the screen.

## - `toHaveAttribute`

Checks an html element for an attribute.

```TypeScript
const screen = render(/*some application render*/);
const element = screen.getByText('text');

expect(element).toHaveAttribute('class', 'my-class');
```

## - `toHaveAttributes`

Checks an html element for a map of attributes.

```TypeScript
const screen = render(/*some application render*/);
const element = screen.getByText('text');

expect(element).toHaveAttribute({
  class: 'my-class',
  id: 'element-id',
});
```
npm package: @msitko/ml-levenberg-marquardt
Description: Curve fitting method in javascript
Author: Miguel Asencio
Latest version: 1.0.5

# levenberg-marquardt

[![NPM version][npm-image]][npm-url]
[![build status][travis-image]][travis-url]
[![Test coverage][codecov-image]][codecov-url]
[![David deps][david-image]][david-url]
[![npm download][download-image]][download-url]

Curve fitting method in javascript

## Installation

`$ npm install ml-levenberg-marquardt`

## [API Documentation](https://mljs.github.io/levenberg-marquardt/)

This algorithm is based on the article [Brown, Kenneth M., and J. E. Dennis. "Derivative free analogues of the Levenberg-Marquardt and Gauss algorithms for nonlinear least squares approximation." Numerische Mathematik 18.4 (1971): 289-297.](https://doi.org/10.1007/BF01404679)

In order to get a general idea of the problem you could also check the [Wikipedia article](https://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm).

## Example

```js
// import library
import LM from 'ml-levenberg-marquardt';
// const LM = require('ml-levenberg-marquardt').default;

// function that receives the parameters and returns
// a function with the independent variable as a parameter
function sinFunction([a, b]) {
  return (t) => a * Math.sin(b * t);
}

// array of points to fit
let data = {
  x: [
    /* x1, x2, ... */
  ],
  y: [
    /* y1, y2, ... */
  ]
};

// array of initial parameter values
let initialValues = [
  /* a, b, c, ... */
];

// Optionally, restrict parameters to minimum & maximum values
let minValues = [
  /* a_min, b_min, c_min, ... */    
];
let maxValues = [
  /* a_max, b_max, c_max, ... */    
];

const options = {
  damping: 1.5,
  initialValues: initialValues,
  minValues: minValues,
  maxValues: maxValues,
  gradientDifference: 10e-2,
  maxIterations: 100,
  errorTolerance: 10e-3
};

let fittedParams = LM(data, sinFunction, options);
```

Or test it in [Runkit](https://runkit.com/npm/ml-levenberg-marquardt)

## License

[MIT](./LICENSE)

[npm-image]: https://img.shields.io/npm/v/ml-levenberg-marquardt.svg?style=flat-square
[npm-url]: https://npmjs.org/package/ml-levenberg-marquardt
[travis-image]: https://img.shields.io/travis/mljs/levenberg-marquardt/master.svg?style=flat-square
[travis-url]: https://travis-ci.org/mljs/levenberg-marquardt
[codecov-image]: https://img.shields.io/codecov/c/github/mljs/levenberg-marquardt.svg?style=flat-square
[codecov-url]: https://codecov.io/gh/mljs/levenberg-marquardt
[david-image]: https://img.shields.io/david/mljs/levenberg-marquardt.svg?style=flat-square
[david-url]: https://david-dm.org/mljs/levenberg-marquardt
[download-image]: https://img.shields.io/npm/dm/ml-levenberg-marquardt.svg?style=flat-square
[download-url]: https://npmjs.org/package/ml-levenberg-marquardt
npm package: @msiviero/knit-di
Description: Simple typescript dependency injection container and decorators
Latest version: 1.0.0
Deprecated: Moved to https://github.com/msiviero/knit

Typescript lightweight dependency injection container

## Installation

```
yarn add @msiviero/knit-di
```

## Example of usage

Base usage is simple as:

```typescript
import { Container, component } from "@msiviero/knit-di";

@component()
class EmailService {
  public sendEmail(recipient: string) {
    // omitted
  }
}

@component()
class MyApplication {

  constructor(private readonly emailService: EmailService) { }

  public run() {
    this.emailService.sendEmail("example@gmail.com");
  }
}

const app = Container.getInstance().resolve(MyApplication);

app.run();
```

Note that all instances all singleton by default

## Injection scope

Pass desired scope as decorator parameter

```typescript

@component(Scope.Prototype)
class EmailService {
  public sendEmail(recipient: string) {
    // omitted
  }
}
```

## Register custom provider

```typescript

const container = Container.getInstance();

class EmailService {
  public sendEmail(recipient: string) {
    // omitted
  }
}

container.provide(EmailService, () => new EmailService());

@component()
class MyApplication {
  constructor(public readonly emailService: EmailService) { }
}
```

## Register interface provider

```typescript

const container = Container.getInstance();

interface EmailService {
  sendEmail: (recipient: string) => void;
}

container.provide("EmailService", () => ({
  sendEmail: (recipient: string) => {
    // omitted
  }
}));

@component()
class MyApplication {
  constructor(@inject("EmailService") public readonly emailService: EmailService) { }
}
```
npm package: @msiviero/knit-di-express
Description: Knit dependency injection bindings for express
Latest version: 0.3.0
Deprecated: Moved to https://github.com/msiviero/knit

Typescript lightweight dependency injection container for express

## Installation

```
yarn add @msiviero/knit-di-express
```

## Example of usage

Base usage:

```typescript
import * as express from "express";
import { 
  ApiContainer, 
  api,
  component, 
  Container, 
  Exchange,
  get
} from "@msiviero/knit-di-express";

const app = express();
const apiContainer = ApiContainer.getInstance();

@component()
class Greeter {
  public greet(who: string) {
    return `Hello ${who}`;
  }
}

@api("/api/v1")
class ApiController {

  constructor(private readonly greeter: Greeter) { }

  @get("/hello")
  public hello(exchange: Exchange) {
    const who: string = exchange.request.query.who || "Nobody";
    exchange.response.json({
      message: this.greeter.greet(who),
    });
  }
}

apiContainer.registerApi(app, ApiController);
app.listen(3000);
```

## Mocking dependencies

Registering mock dependencies for unit tests can be easily achieved via:

```typescript
const app = express();
const apiContainer = ApiContainer.withContainer(Container.newContainer());

@component()
class Greeter {
  public greet(who: string) {
    return `Hello ${who}`;
  }
}

class CustomGreeter extends Greeter {
  public greet(who: string) {
    return `Custom Hello ${who}`;
  }
}

apiContainer.container.provide(Greeter, () => new CustomGreeter());

@api("/api/v1")
class ApiController {

  constructor(private readonly greeter: Greeter) { }

  @get("/hello")
  public hello(exchange: Exchange) {
    const who: string = exchange.request.query.who || "Nobody";
    exchange.response.json({
      message: this.greeter.greet(who),
    });
  }
}

apiContainer.registerApi(app, ApiController);
```
npm package: @msiviero/kv-storage
Description: Simple pure node key value embedded database
Latest version: 0.0.1

# KV Storage

> A simple on disk key value storage for nodejs
---

## Description

The implementation is done using an append only log where every value is stored in binary format and the keys are pointers to disk segments,
similar to the bitcask engine, so the keys should fit in memory.

## Installation

```shellscript
npm i @msiviero/kv-storage
```

## Usage

- [Basic usage](#basic-usage)
- [Log compaction](#log-compaction)
- [Iterate records](#iterate-records)

### Basic usage

```typescript

import { FileSystemStorage } from "@msiviero/kv-storage";

interface User {
  email: string;
  id: number;
}

// create a store. The directory will be created if doesn't exist
const storage = await FileSystemStorage.create<User>("directory to store data in");

await storage.put("mykey", {
  id: 1,
  email: "user@example.com",
});

/*
The result contains the stored data in the .data field, and a
metadata object containing:
- checksum: an md5 checksum of the stored buffer
- timestamp: timestamp of insertion
- key: the original key
*/
const result = await storage.get("mykey");

const user = result?.data;

```

### Log compaction

The log compaction logic is left to the user, as it's different based on the application. To compact the log call the compact() method

```typescript

await storage.compact();

```

### Iterate records

```typescript

// Using an async generator
for await (const it of storage.iterator()) {
 // do something with the record
 console.log(it);
}

// using a stream
storage
  .stream()
  .on("data", (result: Readonly<Result<User>>) => console.log(result))
  .on("end", () => console.log("finished"));

```
npm package: @msjumbu/app-works
Description: AppWorks Schematics
Author: Senthilkumar Murugesan
Latest version: 0.0.27

# AppWorks Angular startup kit - in the foot steps of schematics 
This will read the given WSDL url, generate ts interfaces for the messages and elements in the WSDL. Then generate angular services to call the web services, and a component for the service in angular.

The idea is only code generation, to reduce the time required to write the code required to work with AppWorks webservices. 

Anytime this is run, it will always create new code. The existing code cannot be modified by this tool. As stated earlier the intended usage is to reduce the time required to get started with AppWorks webservices. 


## WSDL parser
The wsdl parser will read the given AppWorks wsdl url, using resolve externals parameter, and create a denormalized flat structures for all the complex types, simple types, elements and messages. This is mainly internal and used by the interface and service generators.

## Interface generator
1. This will generate interfaces for the messages and elements used by the messages. This generates multiple interfaces based on the elements in the wsdl, and these interfaces are used in other interfaces where they are referenced. This gives the benefits of directly creating and using inner types rather than accessing everything from the message. 
2. Every time this is run, it will generate a new Interface file, merging with existing interfaces for reusing and reduce clutter is developer responsibility. 

## Service generator
1. This should generate a service file for the given wsdl. 
2. This will import interfaces generated during the particular execution, changing it to use already generated in previous executions is developer's responsibility. 
3. This should generate service to call the webservice using angular httpclient and convert to and from xml & json, respecting the wsdl contract. 
4. The service endpoint must be read from a config file, rather than using from the wsdl. 
5. The authentication will be both otds & samlart cookie based, if the cookie is not present or if received authentication error, we must raise an error. I need to investigate if this can be some common exception like the java exceptions. 
6. Abstraction will not be provided by hiding httpclient and xmljs, developer is free to change the generated code. 
7. The code generator will always create new code and cannot modify existing code. 

## Component generator 
1. Create component file using reactive form, template file using clarity design 
2. Identify update service or use appworks convention to determine update service. 
3. For updating data, the formgroup raw value will be sent as input.
npm package: @msk_robin/my-first-package
Description: Sapmle package: Node.js for newbees
Author: robin
Latest version: 1.1.1

# Sample package: Node.js for beginners

This is a sample package to learn how to publish packages in npm.

## Installation

```bash
npm install @msk_robin/my-first-package
```

## Usage

```js
import { sum, multiply } from "@msk_robin/demo-package";
console.log(sum(1, 2));
console.log(multiply(5, 2));
```