open-index/open-npm huggingface dataset:
npm package: @symbol-blockchain-community/symbol-rest-client
Description: symbol rest client package
Author: ym.u.ichiro@gmail.com
Latest version: 1.0.2

# Symbol REST Client

Client package supporting interaction with Symbol Node. It is automatically generated from publicly available OpenAPI.

You can easily start interacting with Node with the following simple introduction.

## Installation

```shell
npm install @symbol-blockchain-community/symbol-rest-client
```

## Usage

```javascript
const {Configuration,NodeRoutesApi} = require("@symbol-blockchain-community/symbol-rest-client");

const config = new Configuration({
  basePath: "https://symbolnode.blockchain-authn.app:3001",
})

const nodeRoutesApi = new NodeRoutesApi(config);
nodeRoutesApi.getNodeInfo().then(console.log);
/*
// result example
{
  version: 16777990,
  publicKey: '55B9B62A6EF89EF57ECBC5FD0928CB5B4A28B443C2BE6EEF781E544BCDF57C4B',
  networkGenerationHashSeed: '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6',
  roles: 3,
  port: 7900,
  networkIdentifier: 104,
  friendlyName: 'faunsu19000',
  host: 'symbolnode.blockchain-authn.app',
  nodePublicKey: 'D144195E31C5EB60A4D26887E1AD913452847D8181EA5F8D2A9DF1ACB6EE31E3'
}
*/
```

## Contributing

`symbol-rest-client` is an open-source project. Contributions are welcome. Please refer to the GitHub repository for details.

## License

This software is provided under the [MIT License](../../LICENSE).

## Contact

For questions or feedback, please contact us through the GitHub repository.

## External sites

* [Symbol Community Web](https://symbol-community.com)
* [Symbol Document](https://docs.symbol.dev/ja/index.html)
* [Symbol Rest Gateway](https://docs.symbol.dev/api.html)
* [Symbol/NEM Discord](https://discord.gg/xymcity)
npm package: @symbol-it/nuxtjs-notification-module
Description: Notification module for NuxtJS
Author: Deplanque Tony
Latest version: 0.0.6

# @Symbol-it/nuxtjs-notification-module

> Notification module for nuxtjs

## Features

    - Notification store
    
## Installation

Npm

``npm i @symbol-it/nuxtjs-notification-module --save``

Declare the module in ``./nuxt.config.js``

```
  modules: [
    ...
    '@symbol-it/nuxtjs-notification-module'
    ...
  ],
```

    
## Methods

Client side use `this.$notification.<method>`

Server side use `$notification.<method>`

| Methods        | Description |
| ------------- |-------------:|
| addNotification(type, message) | Push notification in store |
| addSuccess(message) | Push success notification in store | 
| addError(message) | Push error notification in store | 
| addInfo(message) | Push info notification in store | 
| addWarning(message) | Push warning notification in store | 
| resetNotification() | Clear notification in store | 
| getType() | Retrieve default types notification | 

## Implementations

- Create your vue notification component

```
<template>
  <v-alert :type="type">
    {{ message }}
  </v-alert>
</template>

<script>

export default {
  name: 'Notification',
  props: {
    message: {
      type: String,
      required: true
    },
    type: {
      type: String,
      default: () => 'info',
      validator (value) {
        return [
          'success',
          'warning',
          'info',
          'error'
        ].includes(value)
      }
    }
  }
}
</script>
```

- Add your component in your layout

```
<template>
  <v-app>
    <v-main>
      <v-container>
        <notification v-if="notification" :type="notification.type" :message="notification.message" />
        <nuxt />
      </v-container>
    </v-main>
  </v-app>
</template>

<script>
import Notification from '../components/notification/Notification.vue'

export default {
  components: {
    Notification,
  },
  computed: {
    notification () {
      return this.$notification.getNotification()
    }
  },
  watch: {
    '$route' (to, from) {
      this.$notification.resetNotification()
    }
  }
}
</script>
```

- Push notification

```
<template>
   <form-login @submit="login" />
</template>
<script>
import FormLogin from '../components/form/FormLogin.vue'
export default {
  components: {
    FormLogin
  },
  methods: {
    async login (form) {
      try {
        await this.$strapi.login({ identifier: form.email, password: form.password })
        await this.$router.push({ path: '/dashboard' })
      } catch (e) {
        this.$notification.addError('my error')
      }
    },
  },
}
</script>

```
npm package: @symbolic/paragon-connect
Description: paragon connect npm package
Latest version: 1.0.1

<p align="center">
  <a href="https://www.useparagon.com/" target="blank"><img src="https://raw.githubusercontent.com/useparagon/aws-on-prem/master/assets/paragon-logo-dark.png" width="150" alt="Paragon Logo" /></a>
</p>

<p align="center">
  <b>
    The embedded integration platform for developers.
  </b>
</p>

---

Paragon is an embedded integration platform that 100+ software companies rely on to rapidly accelerate development of native product integrations with 3rd party SaaS apps such as Salesforce, Slack, and QuickBooks. This allows their engineering teams to avoid the heavy costs and risks that come with building and maintaining dozens of their own integrations.

## Usage

To install the Paragon SDK, run this command in your project to add it as a dependency:

```sh
npm install @useparagon/connect
```

This package is intended for usage in your frontend application to embed the Paragon connection experience. After importing the **[Paragon SDK](https://docs.useparagon.com/getting-started/installing-the-connect-sdk)**, you can:

- Display the **[Connect Portal](https://docs.useparagon.com/connect-portal/connect-portal-customization)**, a prebuilt UI component for your users to connect third-party app accounts
- Trigger [**Workflows**](https://docs.useparagon.com/workflows/building-workflows), which are observable, durable jobs you define to sync integration data
- Send [**Connect API**](https://docs.useparagon.com/api/making-api-requests) requests to access integration data in realtime from your app
- Render a custom integrations UI using the [**Headless Connect Portal**](https://docs.useparagon.com/connect-portal/headless-connect-portal)

```typescript
import { paragon } from '@useparagon/connect';

// Authenticate your user with the SDK
await paragon.authenticate(projectId, paragonUserToken);

// Launch the Connect Portal for Salesforce in your app
paragon.connect('salesforce');
```

## Documentation

To start using the Paragon SDK, you will need to [sign up and register for an account](https://dashboard.useparagon.com/signup).

For details on getting started and a reference on all available SDK functions, please see [our documentation](https://docs.useparagon.com/getting-started/introduction).
npm package: @symbolism/cli
Description: Coverage assertions for specific code tokens.
Author: Kevin Decker
Latest version: 0.3.0

# symbolism

Typescript symbol inspection/assertion tools.

```console
npm install -g @symbolism/cli
symbolism --help
```

## Features

### Call static argument resolution (beta)

Document all of the inputs to a function. Evaluates the function call hierarchy and resolves all of the static arguments.

```console 
symbolism callInputs ./packages/test/src/dump-symbol.ts Schema
```

### Code use test coverage

Ensure that critical code in your project has test coverage based on what is is rather than where it is. Test all of your analytics calls, critical API usage, etc. without resorting to requiring 100% coverage.

```console
symbolism coverage
```

Output for [`defineSymbol`](https://github.com/kpdecker/symbolism/blob/cdaca7281de99bd64ab66ee96cbde632695a1263/packages/definitions/src/index.ts#L239).

```shell
defineSymbol: 85.19% covered (23/27)
  Missing:
    defineSymbol: ./packages/definitions/src/class.ts:33:14
    defineSymbol: ./packages/definitions/src/index.ts:166:12
    defineSymbol: ./packages/definitions/src/jsx.ts:17:12
    defineSymbol: ./packages/definitions/src/jsx.ts:23:12
```

See config section below for setup details.

### Static schema extraction

Document the schema of your typescript data types. Calculates the final schema for your data types, merged interfaces.


```console
symbolism dumpSchema ./packages/test/src/dump-symbol.ts Schema
```

Output:
```shell
{
  bar: "bar" | "bat";
  merged: number;
};
```

For a machine JSON Schema readable format, use the `--json` flag.

## Config

WIP

```json
{
  "tokens": [
    "function-call",
    "function-call-with-args",
    { "name": "myOtherFunction", "min": 0.9 }
  ],
  "min": 1
}
```

- `tokens`: A list of tokens to assert coverage for. Objects may be used to override the default config for those tokens. Any top-level config value may be set here.
- `min`: \[0-1\] The minimum percentage of token references required for the assertion to pass.


https://github.com/facebook/jest/issues/11188