open-index/open-npm huggingface dataset:
npm package: @jlguenego/schematics
Description: A blank schematics
Latest version: 0.0.3

# What is it?

A collection of schematics that extends the default one.

I did it for making simpler my daily work with Angular.
Its only purpose is to improve DX.



# Getting Started 

```
ng new my-project
cd my-project
npm i @jlguenego/schematics
```

Edit `angular.json`, and add 

```
{ 
    // rest of the file
    "cli": {
        "defaultCollection": "@jlguenego/schematics"
    }
}
```

Done!

# Using schematics

Create a routing module `hello`.
```
ng g routing hello
```

Create a route `home`
```
ng g route hello/home ""
```

Create a page `success`

```
ng g page hello/success
```

# Schematics Reference

## routing

Create a routing module.

1. Create a module if it does not exist.
2. Create the associated routing module.

## route

1. Find the module A where to create the route.
2. Create the routing module B if not already present.
3. Create the route component and declare it in the module A.
4. Create the route with the path specified in the routing module B.

Example:

```
ng g route hello world
```

Create the HomeComponent in the AppModule.
Configure the route as:

```
const routes: Routes = [
    // ...
    { path: "world", component: HelloComponent }
];
```

## page

1. Create a component with suffix `PageComponent`.
2. Declare it inside a module in `entryComponents` section.

Options are same as the @schematics/angular component.

# Author

Jean-Louis GUENEGO <jlguenego@gmail.com> - 2019.
npm package: @jlinc/did-auth
Description: Authorization using JLINC DIDs
Author: Victor Grey
Latest version: 1.0.4

# JLINC DID Auth

## Actors and prerequisites
The actors in this protocol are an entity requesting authentication ( the ***requester*** ),
a software agent for the requestor ( the ***agent*** ), and a service that authenticates the
requester ( the ***verifier*** ).

Each of these parties must have their own DID.

The ***agent*** must have access to the requester's
signing key (the private or secret part of the signing keypair) in order to sign requests on its behalf,
as well as their own signing key to validate their JWS's.

The ***verifier*** must have access to their own signing key for JWS validation.

Both the ***agent*** and the ***verifier*** should keep a whitelist of acceptable counter-party's DIDs and
associated public keys.

## Protocol

1. The agent forms a request for authorization on behalf or the requester using `jlincDidAuth.request` and transmits the resulting JWS to the verifier's API endpoint.

2. The verifier decodes and validates the request using `jlincDidAuth.verifyReq`. They check that the agent DID is white-listed, and cache the authID with the requester DID.

3. The verifier forms a challenge JWS using `jlincDidAuth.createChallenge` and transmits it to the agent's API endpoint.

4. The agent decodes and validates the challenge using `jlincDidAuth.verifyChallenge` and checks that the authID and all DIDs are as expected.

5. The agent then signs the resulting challengeObject using `jlincDidAuth.signChallenge` and and sends the requester to the verifier's authentication page with the signed challenge JWS.

6. The verifier decodes and validates the signed challenge JWS using `jlincDidAuth.verifyChallengeSignature`, and inspects the resulting data object for the correct authID and DIDs. If all is well, the verifier authorizes the requester.


## Expected Usage

Checkout our [expected usage mocha spec](./test/expectedUsage.spec.js) for
a basic usage example.


## Terms

### `JWS`

[JSON Web Signature](https://en.wikipedia.org/wiki/JSON_Web_Signature)

### `JWT`

[JSON Web Token](https://en.wikipedia.org/wiki/JSON_Web_Token)
npm package: @jlinc/did-client
Description: A node implementation of a JLINC DID client
Author: JLINC Labs
Latest version: 1.0.1

# Node JLINC

A node client for the JLINC DID Server

Specs:

- https://did-spec.jlinc.org/
- https://w3c.github.io/did-core/

Specifically: https://did-spec.jlinc.org/#6-operations

## Nomenclature

### Entity

An entity is a specific DID record with its corresponding keys and secrets. It looks like this:

```js
const entity = {
  did: 'did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM',
  signingPublicKey: 'dnhZF0DuRgsrCQMUzUZoxLHgZ0wetY4S7yxosEmbIYM',
  signingPrivateKey: 'g2eFkXQO5EeBnTS_FdcbVV_ttiw53sHHENlXCZl5xH5rqwGVWwo9jLG-B61jhLvKCysJAxTNRmjEvGiwSZshgw',
  encryptingPublicKey: 'BK478lOPXtO9J2KsWq_M_opXcVqCiAYd0TWOJcATjX8',
  encryptingPrivateKey: '4LMoOgJQMq2NYWAb7RAkCA0cnMN7QCGZQJROgWmCEdI',
  registrationSecret: '929afc44b7f692ac8fb615467e5eb910325b73d3adb1c504fd46a77edef22235'
};
```

### DID

A DID: `did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM` is the unique Decentralized Identifier.


### DID Document

A DID Document is a JSON objected sent to and received by the JLINC DID Server. It looks like this

```json
{
  "@context": "https://w3id.org/did/v1",
  "id": "did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM",
  "created": "2019-01-08T21:12:36.505Z",
  "publicKey": [
    {
      "id": "did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM#signing",
      "type": "ed25519",
      "owner": "did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM",
      "publicKeyBase64": "dnhZF0DuRgsrCQMUzUZoxLHgZ0wetY4S7yxosEmbIYM"
    },
    {
      "id": "did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM#encrypting",
      "type": "curve25519",
      "owner": "did:jlinc:dnhZF0DuRHgZ0wetY4S7ygsrCQMUzUZoxLxosEmbIYM",
      "publicKeyBase64": "BK478lOPXtO9J2KsWq_M_opXcVqCiAYd0TWOJcATjX8"
    },
  ],
}
```

## Expected Usage

```js
const { DidClient } = require('jlinc-did-client');

// point the client to a did server
DidClient.setConfig({
  didServerUrl: 'http://did.jlinc.test',
})

async function example(){
  const entity = await DidClient.register();
  // Persist all of these values
  entity.did;
  entity.signingPublicKey;
  entity.signingPrivateKey;
  entity.encryptingPublicKey;
  entity.encryptingPrivateKey;
  entity.registrationSecret;

  const didDocument = await DidClient.resolve({ did: entity.did });

  // supersede a did
  const entityTwo = await DidClient.supersede({ entity });

  // get a history of the DIDs behind this did
  const history = await DidClient.history({ did: entityTwo.did });
}
```
npm package: @jlinse/plasticity
Description: A lightweight neural network and simulator for evolutionary models
Author: Jeff Linse
Latest version: 0.1.2

[![Build Status](https://travis-ci.com/jefflinse/plasticity.svg?branch=master)](https://travis-ci.com/jefflinse/plasticity) [![dependencies Status](https://david-dm.org/jefflinse/plasticity/status.svg)](https://david-dm.org/jefflinse/plasticity) [![devDependencies Status](https://david-dm.org/flexdinesh/npm-module-boilerplate/dev-status.svg)](https://david-dm.org/jefflinse/plasticity?type=dev)

# Plasticity

Plasticity is a framework for running artificial evolution simulations. It provides a flexible perceptron (a type of neural network) implementation and a simulation framework for working with populations of individuals that can change over time.

## Installation

_Not yet available. If you'd like to play with this library at the moment, please clone the repository._

## Usage
_This project is still very much a work in progress and I will add detailed usage and examples soon. In the meantime, feel free to reach out with questions!_

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)
npm package: @jliuhtonen/nightvision
Description: Implementation of Lenbrook Service Discovery Protocol
Author: Janne Liuhtonen
Latest version: 0.2.4

# Nightvision

[![Nightvision CI](https://github.com/jliuhtonen/nightvision/actions/workflows/workflow.yml/badge.svg)](https://github.com/jliuhtonen/nightvision/actions/workflows/workflow.yml)

Lenbrook Service [Discovery](https://youtu.be/xBTqRd09y3E) Protocol implementation for Node.js. See [specification](https://content-bluesound-com.s3.amazonaws.com/uploads/2022/07/BluOS-Custom-Integration-API-v1.5.pdf).

This library provides you with a client and server implementation for the protocol that allows you to send and receive messages to discover supported devices and their capabilities as well as announce and delete services.

As mentioned in the specification, the guideline is to send startup messages 7 times within certain time interval and delays.
This is considered out of scope for this library.

Also note that many BluOS devices might send the same UDP broadcast every n seconds in addition to query responses.

## Example

```javascript
import { createConnection } from "nightvision"
const conn = await createConnection()

conn.onData((err, result) => {
  if (err) {
    console.error(err)
    return
  }
  console.log(JSON.stringify(result, null, 2))
})

await conn.sendMessage({
  type: "query",
  messageType: "standard",
  classIds: ["0001"],
})
```
npm package: @jlius/m-cli
Description: taro微信小程序自动发版工具。
Author: jlius
Latest version: 1.0.1

# taro 微信小程序自动发版工具，包含以下功能：

1. 支持编译、发布体验版、发布预览版
2. 支持发布后自动推送小程序二维码功能
3. 支持动态打包到不同的 appid。
4. 支持定制化内容打包等。

# 使用详解

        program
        .version(pack.version, "-v,--version")

        .description("taro微信小程序动态编译发布")

        /**
        * 项目名称：如HCB(红池坝),BDH(北戴河),LT(联通)；默认standard(标准版);
        * 该参数用于动态设置taro小程序appid，动态打包不同appid所对应的个性化定制内容等;
        * 对应于项目中的config/appConfig.json文件。
        */
        .option("-n,--name", "待发布的小程序的名称")

        /**
        * 操作类型：publish(发布体验版并发送二维码消息)、preview(预览版并发送二维码消息)、build(仅编译)、dev(编译并监听变化)。
        */
        .option("-t,--type", "类型：publish|preview|build|dev", "preview")

        /**
        * 服务器类型：标识所连接的服务器地址等
        */
        .option("-s,--server", "服务器类型：dev|test|pre|prod", "test")

        /**
        * 当发布体验版(type为publish)时，需要定义版本号。
        * 如果不传入该参数则按规则自增版本号。
        * 如果发布成功则更新config/appConfig.json中的版本号信息
        */
        .option("-pv, --publishVersion", "发布体验版时版本号如:v1.1.1")

        /**
        * 版本号自增规则:major(大版本：大改动或出现不兼容时)、minor(次版本：功能性改动或新增)、revise(修复版本：内容修复);
        * 在原始版本上自增1。
        * 如果发布成功则更新config/appConfig.json中的版本号信息
        */
        .option("-r, --versionRule", "发布体验版时版本号自增规则：major|minor|revise")

# 使用方式

1. m-cli -t publish -s test //发布测试环境体验版
2. m-cli -n BDH -t preview -s test //发布北戴河(定制版本)测试环境预览版
npm package: @jljljl/my-vue-component
Description: A Vue component with encrypted source code
Author: jljljl
Latest version: 1.0.4

# my-vue-component

一个加密的Vue组件，可通过npm安装使用。

## 安装

```bash
npm install my-vue-component
# 或
 yarn add my-vue-component
```

## 使用方法

### 1. 全局注册（Vue 2.x）

```javascript
import Vue from 'vue';
import MyComponent from 'my-vue-component';

Vue.use(MyComponent);
```

### 2. 全局注册（Vue 3.x）

```javascript
import { createApp } from 'vue';
import App from './App.vue';
import MyComponent from 'my-vue-component';

const app = createApp(App);
app.use(MyComponent);
app.mount('#app');
```

### 3. 局部注册

```javascript
import { MyComponent } from 'my-vue-component';

export default {
  components: {
    MyComponent
  }
};
```

### 4. 在模板中使用

```vue
<template>
  <div>
    <my-component 
      :title="'自定义标题'" 
      :message="'自定义消息'"
      @click="handleClick"
    />
  </div>
</template>

<script>
export default {
  methods: {
    handleClick(data) {
      console.log(data); // '按钮被点击了'
    }
  }
};
</script>
```

## 组件属性

| 属性名 | 类型 | 默认值 | 说明 |
|-------|------|-------|------|
| title | String | '我的组件' | 组件标题 |
| message | String | '这是一个加密的Vue组件' | 组件消息内容 |

## 组件事件

| 事件名 | 参数 | 说明 |
|-------|------|------|
| click | String | 点击按钮时触发的事件 |

## 注意事项

1. 此组件源代码已加密，无法查看原始Vue文件
2. 支持Vue 2.6+ 和 Vue 3.0+
3. 组件已进行代码压缩和混淆处理

## 开发构建

如需修改组件并重新构建：

```bash
# 安装依赖
npm install

# 开发模式（监视文件变化）
npm run dev

# 构建生产版本（包含加密）
npm run build
```