open-index/open-npm huggingface dataset:
npm package: @hansekontor/wallet-sdk
Description: This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
Latest version: 1.5.0

# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:

```js
export default tseslint.config([
  globalIgnores(['dist']),
  {
    files: ['**/*.{ts,tsx}'],
    extends: [
      // Other configs...

      // Remove tseslint.configs.recommended and replace with this
      ...tseslint.configs.recommendedTypeChecked,
      // Alternatively, use this for stricter rules
      ...tseslint.configs.strictTypeChecked,
      // Optionally, add this for stylistic rules
      ...tseslint.configs.stylisticTypeChecked,

      // Other configs...
    ],
    languageOptions: {
      parserOptions: {
        project: ['./tsconfig.node.json', './tsconfig.app.json'],
        tsconfigRootDir: import.meta.dirname,
      },
      // other options...
    },
  },
])
```

You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:

```js
// eslint.config.js
import reactX from 'eslint-plugin-react-x'
import reactDom from 'eslint-plugin-react-dom'

export default tseslint.config([
  globalIgnores(['dist']),
  {
    files: ['**/*.{ts,tsx}'],
    extends: [
      // Other configs...
      // Enable lint rules for React
      reactX.configs['recommended-typescript'],
      // Enable lint rules for React DOM
      reactDom.configs.recommended,
    ],
    languageOptions: {
      parserOptions: {
        project: ['./tsconfig.node.json', './tsconfig.app.json'],
        tsconfigRootDir: import.meta.dirname,
      },
      // other options...
    },
  },
])
```
npm package: @hanselio_public/react-native-hansel
Description: React Native wrapper for Hansel iOS SDK
Author: Hansel
Latest version: 8.2.0

# react-native-hansel

## Getting started

`$ npm install react-native-hansel --save`

### Mostly automatic installation

`$ react-native link react-native-hansel`

### Manual installation


#### iOS

1. In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
2. Go to `node_modules` ➜ `react-native-hansel` and add `HanselRn.xcodeproj`
3. In XCode, in the project navigator, select your project. Add `libHanselRn.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
4. Run your project (`Cmd+R`)<

## Usage
```javascript
import {NativeModules} from 'react-native';
 
// TODO: You can access Hansel SDK classes this way.
NativeModules.HanselConfigsRn;
NativeModules.HanselTrackerRn;
NativeModules.HanselUserRn;
NativeModules.HanselRn;
```
npm package: @hanseltime/compose-types
Description: Docker compose specification converted into a typescript type for type-checking
Latest version: 1.1.0

# Typescript definitions for docker compose

Simple package that exposes the v3 compose specification as transformed by 
[json-schema-to-typescript](https://www.npmjs.com/package/json-schema-to-typescript).

Basic Usage:

```typescript
import { v3 } from '@hanseltime/compose-types'

const spec: v3.ComposeSpecification = {
    services: [
        // your services, etc.
    ]
}
```

Usage with custom `x-` prefixed properties:

```typescript

import { v3 } from '@hanseltime/compose-types'

type CustomKeys = 'foo' | 'bar'

const spec: v3.ComposeSpecification<CustomKeys> = {
    services: [
        {
            'x-bar': 'someValue',
        }
    ],
    'x-foo': 'anotherValue',
}
```

[Typedoc](./docs/api)
npm package: @hanseltime/dev-npm-registry-tools
Description: Simple collection of scripts to allow for local cross repository development
Latest version: 1.0.0

# dev-npm-registry-tools

This package presents tools for developing packages between repositories locally.
This is particularly important when you are trying to change a package whose most
affected use case is in another repo. Rather than going through full release cycles,
you can set up a local developer registry and then publish and load from it.

**Important** - This package currently only supports yarn v2. Please contribue yarn v1/npm
equivalents when necessary.

# Setting up a local registry

These scripts rely on the repository that you're supposed to clone and run a registry
from. [Registry Project](https://github.com/hanseltime/development-verdaccio)

You will also need to create a user and password (if you don't want to use the default "admin":"admin")

[Creating a user](https://verdaccio.org/docs/setup-npm#creating-user)

# Publishing your package locally

If you are in a package that you would like to package to the local repo for pulling into your supporting
project, you will need to run:

```shell
yarn local-publish
```

Please check the help for other options.
npm package: @hanseltime/jsp-ws-connection
Description: This library is for specfic implementaions of the janus-simple-command  package's Connection interface that uses the `ws` websocket library.
Latest version: 1.0.1

# `jsp-ws-connection`

This library is for specfic implementaions of the janus-simple-command 
package's Connection interface that uses the `ws` websocket library.

Currently supported

- Node

---

Node usage example

```bash
yarn add @hanseltime/janus-simple-command @hanseltime/jsp-ws-connection
```

```typescript
import { NodeWebSocketConnection } from '@hanseltime/jsp-ws-connection'
import { HandlerReturn, Server } from '@hanseltime/janus-simple-command'

const app = express()

const server = app.listen(PORT)
const wss = new WebSocketServer({
  server: server,
  path: process.env.ROOT_PATH ?? '/',
})

let serv: Server<Commands, CommandMap, StatusMap> | undefined = undefined
wss.on('connection', async (ws) => {
  debug('INFO', 'ws connected')
  const connection = new NodeWebSocketConnection(ws, 'server', console.log)

  serv = new Server<Commands, CommandMap, StatusMap>({
    maxSenderInactivity: 10000,
    maxAckRetries: 3,
    ackRetryDelay: 10000,
    connection,
    debug: (msg: string) => console.log(msg),
  })

  serv.setMessageHandlerWithIntermediate('cmd', {
    handler: async (msg, inter): Promise<HandlerReturn<StatusMap['cmd']>> => {
      runbot(msg)
    },
  })

  await serv.open()
})
```

See JSP Readme for more

https://github.com/hanseltime/hanseltime-janus-simple-command/tree/master/packages/janus-simple-command#usage
npm package: @hanseltime/pkgtest
Description: This is a js/ts package publishing test framework that you can use to verify that you packages work in different module systems.
Latest version: 1.4.0

# pkgtest

This is a js/ts package publishing test framework that you can use to verify that you packages work in different module systems.

[Docs Site](https://hanseltimeindustries.github.io/pkgtest/)