open-index/open-npm huggingface dataset:
npm package: @mobdata/classification-banner
Description: A React component for displaying the classification of data in a web application.
Latest version: 1.0.1

# classification-banner

A simple React component to put a classification banner at the top and bottom of an app.

## Features

Provides the generally accepted colors for unclassified, confidential, secret, top secret and
top secret//sci markings.

## Install

````bash
npm install --save '@mobdata/classification-banner'
````

## Usage

````js
import React, { Component } from 'react';
import ClassificationBanner from '@mobdata/classification-banner';
import logo from './logo.svg';
import './App.css';

class App extends Component {
  render() {
    return (
      <div className="App">
        <ClassificationBanner classification="unclassified"/>
        <div style={{ paddingTop: '100px' }}>
          <header className="App-header">
            <img src={logo} className="App-logo" alt="logo" />
            <h1 className="App-title">Welcome to React</h1>
          </header>
          <p className="App-intro">
            To get started, edit <code>src/App.js</code> and save to reload.
          </p>
        </div>
      </div>
    );
  }
}

export default App;
````

## License

`classification-banner` is released under the MIT license.
npm package: @mobdata/classy
Description: Module for comparing classifications
Latest version: 1.0.1

# classy
Module for comparing intelligence community classifications.

## Install


Testing

````bash
npm install --save '@mobdata/classy'
````

## Usage

The module exports several functions which makes testing them easier but most everyone will only
need one, the `bannerEqOrMoreSecureThan`.

Given two classification strings, or "banners", this function returns `true` when the first banner
is at least secure as the second banner.

In a prototypical example, you have a document classified as "SECRET" and person X has asked to
see it. Person X's clearance gives them access to "CONFIDENTIAL" information. In this case, Person
X does not have the clearance to view the document! Their clearance is not "equal or more secure
than" the document's classification.


````js
import { bannerEqOrMoreSecureThan } from '@mobdata/classy';

var document = 'SECRET';
var personX = 'CONFIDENTIAL';

if (bannerEqOrMoreSecureThan(document, personX) === true) {
  // do something cool
} else {
  // don't let personX see it!
}
````

Additional notes about `bannerEqOrMoreSecureThan`:

* The parameters are case-insensitive.
* The parameters may be of arbitrary complexity.
* The parameters may be any accepted banner line marking found in the "Marking of Classified
  Information" manual 5200.01, Volume 2 for the DoD.
* This includes classifications, disseminations and any number of sci's.
* Abbreviations such as found in portion markings, `S//REL`, `C//FRD`, etc, are _not_ supported.
* Not supported: non-U.S. documents markings, joint classification markings, Atomic Energy Act
  markings.

Mobdata is a project under Jacobs
npm package: @mobdata/mobnode
Description: A library that provides an interface for setting up replication rules among CouchDb databases across many servers. 
Author: MobData Team
Latest version: 1.0.0

# Mobnode

Web interface for defining rules to control outbound replication.

## Usage

Below are instructions to build Mobnode for both development and production.

### Environment Variables

Each of the directories require their own respective environment variables. Please reference the `README.md` of each directory.

### Development

The current directory structure includes both the client Javascript application and the Node/Express API, located in `client/` and `server/` respectively.

This means that each directory has their own respective `package.json` which dictates the application's dependencies. This means you must `npm install` or `yarn install` in each respective directory.

```shell
$ yarn install
...
$ cd client
$ yarn install
...
$ cd ../server
$ yarn install
```

While this is cumbersome for the time-being, this will soon be changed when the server APIs for both Mobnode and Mobboss are unified. More specifically, Mobnode will become strictly a client side application that interactes with a generic Mobdata API built to the user's specification.

## Server

For information on the Mobnode server, please visit [here](./server/README.md).

## Client

For information on the Mobnode client, please visit [here](./client/README.md).
npm package: @mobecher/rollup-plugin-glslang
Description: reads a directory of shaders, compiles them and outputs to another directory
Latest version: 0.2.0

# rollup-plugin-glslang
Rollup plugin that uses [@webgpu/glslang](https://www.npmjs.com/package/@webgpu/glslang) to compile shaders from glsl to SPIR-V

This project was forked from [@javascribble/rollup-plugin-glslang](https://www.npmjs.com/package/@javascribble/rollup-plugin-glslang) to fix module imports

```
import { glslang } from '@javascribble/rollup-plugin-glslang';

export default {
  ...options,
  plugins: [
    glslang({
      source: './',
      target: './'
    })
  ]
}
```
npm package: @mobecher/rollup-plugin-quicktype
Description: Rollup plugin to run quicktype
Author: Moritz Becher
Latest version: 0.1.1

# rollup-plugin-quicktype

🍣 A Rollup plugin to integrate [quicktype](https://www.npmjs.com/package/quicktype)

## Installation

`npm install @mobecher/rollup-plugin-quicktype --save-dev`

## Example

rollup.config.js

```js
import  quicktype from '@mobecher/rollup-plugin-quicktype';
export default {
    input: 'src/main.js',
    output: {
        dir: "dist",
        format: 'umd'
    },
    plugins: [
        quicktype({
            src: ['./schema/pokedex.schema.json'],
            srcLang: 'schema',
            lang: 'javascript',
            out: './src/pokedex.js'
        })
    ]
};

```

## Options
Same as the options of [quicktype](https://www.npmjs.com/package/quicktype) `quicktype --help`

## Limitations
At the moment the plugin simply passes the options to the quicktype cli.
npm package: @mobelux/next-apollo
Description: React higher-order component for using the Apollo GraphQL client inside Next.js
Author: Adam Soffer
Latest version: 2.0.1

Next Apollo [![Build Status](https://travis-ci.org/adamsoffer/next-apollo.svg?branch=master)](https://travis-ci.org/adamsoffer/next-apollo)
=========================
## Installation
```
npm install --save next-apollo
```

## Documentation
Create an Apollo configuration object (check out the [Apollo Client API](https://www.apollographql.com/docs/react/basics/setup.html#ApolloClient) for more configuration options). Pass the configuration object to the `withData` higher-order component and export the returned component.

```jsx
import { withData } from 'next-apollo'
import { HttpLink } from 'apollo-link-http'

// can also be a function that accepts a `context` object (SSR only) and returns a config
const config = {
  link: new HttpLink({
    uri: 'https://api.graph.cool/simple/v1/cixmkt2ul01q00122mksg82pn', // Server URL (must be absolute)
    opts: {
      credentials: 'same-origin' // Additional fetch() options like `credentials` or `headers`
    }
  })
}

export default withData(config)
```
Inside your Next.js page, wrap your component with your exported higher order component.

```jsx
import withData from '../lib/apollo'

export default withData(props => (
  <div>Hello World</div>
))

```
That's it!

## How Does It Work?

Next-apollo integrates Apollo seamlessly with Next by wrapping our pages inside a higher-order component (HOC). Using a HOC pattern we're able to pass down a central store of query result data created by Apollo into our React component hierarchy defined inside each page of our Next application.

On initial page load, while on the server and inside `getInitialProps`, the Apollo method, `getDataFromTree`, is invoked and returns a promise; at the point in which the promise resolves, our Apollo Client store is completely initialized.

## Custom Cache

SSR will cease to function if you pass in your own Cache.
It is highly suggested that you do not pass in your own Cache in
the config unless you want it to drop the SSR functionality.

Instead, to use a custom cache, pass in a `createCache` function.
For example, to use a cache with [fragment matching],

```jsx
import { withData } from 'next-apollo'
import { HttpLink } from 'apollo-link-http'
import { InMemoryCache, IntrospectionFragmentMatcher } from 'apollo-cache-inmemory'

import introspectionQueryResultData from './fragmentTypes'

const createCache = () => {
  const fragmentMatcher = new IntrospectionFragmentMatcher({
    introspectionQueryResultData
  })

  return new InMemoryCache({fragmentMatcher})
}

const config = {
  link: new HttpLink({
    uri: 'https://api.graph.cool/simple/v1/cixmkt2ul01q00122mksg82pn'
  }),
  createCache
}

export default withData(config)
```

[fragment matching]: https://www.apollographql.com/docs/react/recipes/fragment-matching.html

## License

MIT
npm package: @mobeuv/react-native-check-ip
Description: test
Author: Mobeuv
Latest version: 1.3.0

<p align="center">
  <img src="./assets/banner.png" alt="i18n">
</p>
<p align="center">
  <a href="https://tldrlegal.com/license/mit-license"><img src="https://img.shields.io/:License-MIT-blue.svg" alt="MIT License"></a>
</p>

Get public IP address using trusted APIs in React Native.

## Installation

```sh
npm install react-native-check-ip
```

## Usage

```js
import { getIp } from 'react-native-check-ip';

// ...
const result = await getIp();
```

## Response

|            | Parameter                                                                                                                                | Support     | Type    |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ------- |
| message    | Returns success message or error message explaining the reason.                                                                          | Android/IOS | String  |
| ipv4       | Returns a public or local ipv4.                                                                                                          | Android/IOS | String  |
| isError    | Returns positive if there was an error to obtain the public ip.                                                                          | Android/IOS | Boolean |
| isPublicIp | Returns true if the ipv4 is a public ip, this only occurs if no errors have occurred.                                                    | Android/IOS | Boolean |
| isLocalIp  | Returns true if the ipv4 is a local ip, this only occurs if it has not been possible to obtain the public ip using all the apis + retry. | Android/IOS | Boolean |
| origin     | Returns who was responsible for providing ipv4. This can be AWS, IPIFY or Local (In case there was an error and ipv4 is localhost)       | Android/IOS | String  |

## Workflow

This lib tries to get public ipv4 using two public apis, having the AWS api as a priority and IPIFY as a secondary one, if both return an error or are unavailable, a new attempt will be made by calling the AWS API again. If all calls result in errors, Localhost IPv4 (127.0.0.1) is returned.

In the future we can add new APIs as a fallback, but we must always guarantee the highest availability rate and use APIs without usage limits.

## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## License

MIT

---

Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
npm package: @mobeuv/react-native-i18n
Description: test
Author: Mobeuv
Latest version: 1.1.2

<p align="center">
  <img src="./assets/banner.png" alt="i18n">
</p>
<p align="center">
  <a href="https://tldrlegal.com/license/mit-license"><img src="https://img.shields.io/:License-MIT-blue.svg" alt="MIT License"></a>
</p>

## The Package

This package is a fork of (https://github.com/AlexanderZaytsev/react-native-i18n). All rights to the fork go to the proper authors under the MIT license (https://github.com/AlexanderZaytsev) We created this fork to make the package available with future fixes and new features.

## Installation

```bash
yarn add @mobeuv/react-native-i18n
```

## Usage

```bash
# i18N.ts

import i18n from '@mobeuv/react-native-i18n';
import ptBr from './translations/pt.json';
import en from './translations/en.json';

// Enable fallbacks if you want `en-US`
// and `en-GB` to fallback to `en`
i18n.defaultLocale = 'pt-BR';
i18n.fallbacks = true;
i18n.translations = {
  'pt-BR': ptBr,
  en,
};

export default i18n;

```

```bash
# Using in rendering
import * as React from 'react';
import {View, Text } from 'react-native';
import I18n from './i18n';

export default function App() {
  return (
    <View>
      <Text>{I18n.t(['HomeScreen', 'welcome'])}</Text>
    </View>
  );
}
```

## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## License

MIT

---
npm package: @mobeuv/react-native-user-agent
Description: Use to retrieve the UserAgent in React Native.
Author: Mobeuv
Latest version: 2.0.0

# @mobeuv/react-native-user-agent

Use to retrieve the UserAgent in React Native.

## Installation

```sh
npm install @mobeuv/react-native-user-agent
```

## Usage


```js
import { multiply } from '@mobeuv/react-native-user-agent';

// ...

const result = await multiply(3, 7);
```


## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## License

MIT

---

Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
npm package: @mobi-aliyun/runtime-embed-javascript
Description: - src：string 类型，必填，被集成的魔笔应用的 URL。 - data：对象类型，可选，用于向魔笔应用分享数据，需要与魔笔应用内的"宿主应用数据"配合使用。 - messageHandler：函数类型，可选，用于接收魔笔应用推送的消息，需要与魔笔应用内的`mobi.hostApp.postMessage`配合使用。 - auth：对象类型，可选，用于实现静默登录，需要自行获取 JWT 令牌，并在魔笔应用中启用"JWT 令牌鉴权"。 - iframeOptions：对象类型，可选，用于定制 ifr
Latest version: 0.0.3

### **JavaScript SDK 属性参考**

- src：string 类型，必填，被集成的魔笔应用的 URL。
- data：对象类型，可选，用于向魔笔应用分享数据，需要与魔笔应用内的"宿主应用数据"配合使用。
- messageHandler：函数类型，可选，用于接收魔笔应用推送的消息，需要与魔笔应用内的`mobi.hostApp.postMessage`配合使用。
- auth：对象类型，可选，用于实现静默登录，需要自行获取 JWT 令牌，并在魔笔应用中启用"JWT 令牌鉴权"。
- iframeOptions：对象类型，可选，用于定制 iframe 的`sandbox`和`allow`属性，为保证魔笔应用可以正常运行，SDK 会默认注入两个`sandbox`属性：`allow-script`和`allow-same-origin`。
- style： **字符串类型** ，可选，用于定制 iframe 的样式。
- customRouterHandler：对象类型，可选，作为魔笔 Copilot 应用内的功能路由回调，集成魔笔 Web 应用时，此配置项无效。
  - navigateTo?: (routerKey: string, routerParams: Record<string, any>) => void;
  - onNavigateError?: (routerKey: string, error: any) => void;
npm package: @mobi-aliyun/runtime-embed-react
Description: - src：string 类型，必填，被集成的魔笔应用的 URL。 - data：对象类型，可选，用于向魔笔应用分享数据，需要与魔笔应用内的"宿主应用数据"配合使用。 - messageHandler：函数类型，可选，用于接收魔笔应用推送的消息，需要与魔笔应用内的`mobi.hostApp.postMessage`配合使用。 - auth：对象类型，可选，用于实现静默登录，需要自行获取 JWT 令牌，并在魔笔应用中启用"JWT 令牌鉴权"。 - iframeOptions：对象类型，可选，用于定制 ifr
Latest version: 0.0.3

### **React SDK 属性参考**

- src：string 类型，必填，被集成的魔笔应用的 URL。
- data：对象类型，可选，用于向魔笔应用分享数据，需要与魔笔应用内的"宿主应用数据"配合使用。
- messageHandler：函数类型，可选，用于接收魔笔应用推送的消息，需要与魔笔应用内的`mobi.hostApp.postMessage`配合使用。
- auth：对象类型，可选，用于实现静默登录，需要自行获取 JWT 令牌，并在魔笔应用中启用"JWT 令牌鉴权"。
- iframeOptions：对象类型，可选，用于定制 iframe 的`sandbox`和`allow`属性，为保证魔笔应用可以正常运行，SDK 会默认注入两个`sandbox`属性：`allow-script`和`allow-same-origin`。
- style：对象类型，可选，用于定制 iframe 的样式。
- customRouterHandler：对象类型，可选，作为魔笔 Copilot 应用内的功能路由回调，集成魔笔 Web 应用时，此配置项无效。
  - navigateTo?: (routerKey: string, routerParams: Record<string, any>) => void;
  - onNavigateError?: (routerKey: string, error: any) => void;
npm package: @mobi-aliyun/runtime-embed-vue
Description: - src：string 类型，必填，被集成的魔笔应用的 URL。 - data：对象类型，可选，用于向魔笔应用分享数据，需要与魔笔应用内的"宿主应用数据"配合使用。 - message-handler：函数类型，可选，用于接收魔笔应用推送的消息，需要与魔笔应用内的`mobi.hostApp.postMessage`配合使用。 - auth：对象类型，可选，用于实现静默登录，需要自行获取 JWT 令牌，并在魔笔应用中启用"JWT 令牌鉴权"。 - iframe-options：对象类型，可选，用于定制 i
Latest version: 0.0.3

### **Vue SDK 属性参考** {#acf3650628ri8}

- src：string 类型，必填，被集成的魔笔应用的 URL。
- data：对象类型，可选，用于向魔笔应用分享数据，需要与魔笔应用内的"宿主应用数据"配合使用。
- message-handler：函数类型，可选，用于接收魔笔应用推送的消息，需要与魔笔应用内的`mobi.hostApp.postMessage`配合使用。
- auth：对象类型，可选，用于实现静默登录，需要自行获取 JWT 令牌，并在魔笔应用中启用"JWT 令牌鉴权"。
- iframe-options：对象类型，可选，用于定制 iframe 的`sandbox`和`allow`属性，为保证魔笔应用可以正常运行，SDK 会默认注入两个`sandbox`属性：`allow-script`和`allow-same-origin`。
- style：对象类型，可选，用于定制 iframe 的样式。
- customRouterHandler：对象类型，可选，作为魔笔 Copilot 应用内的功能路由回调，集成魔笔 Web 应用时，此配置项无效。
  - navigateTo?: (routerKey: string, routerParams: Record<string, any>) => void;
  - onNavigateError?: (routerKey: string, error: any) => void;