open-index/open-npm huggingface dataset:
npm package: @ralphsmith80/react-scripts
Description: Configuration and scripts for Create React App.
Latest version: 2.1.7

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://facebook.github.io/create-react-app/docs/getting-started) – How to create a new app.
- [User Guide](https://facebook.github.io/create-react-app/) – How to develop apps bootstrapped with Create React App.
npm package: @ralphwetzel/node-red-ds2482-mcu
Description: DS2482 I2C 1-Wire Master controller for Node-RED w/ MCU support
Author: Ralph Wetzel
Latest version: 1.1.0

# node-red-ds2482-mcu
DS2482 I2C 1-Wire Master controller for Node-RED with MCU support

### Currently supported 1-Wire devices types:

- [x] DS18B20 / Family Code 28
- [x] DS2408 / Family Code 29
- [x] DS2438 / Family Code 26

Additional devices may be added on request or by contribution.

### Disclaimer
Please be adviced that this node currently focuses on supporting [node-red-mcu](https://github.com/phoddie/node-red-mcu), thus has no functionality (yet) for standard Node-RED.
npm package: @ralphwetzel/node-red-systeminformation
Description: Node-RED interface to systeminformation, the System Information Library for Node.JS
Author: Ralph Wetzel
Latest version: 1.2.0

# @ralphwetzel/node-red-systeminformation
<img alt="node" src="resources/node.png"
    style="min-width: 212px; width: 212px; align: center; border: 1px solid lightgray;"/>

Node-RED interface to [systeminformation](https://systeminformation.io/), the System Information Library for Node.JS

Citing @sebhildebrandt, the creator of [systeminformation](https://github.com/sebhildebrandt/systeminformation#the-systeminformation-project):
> Started as a small project [...], it now has > 15,000 lines of code, > 600 versions published, up to 8 mio downloads per month, > 220 mio downloads overall. **#1 NPM ranking for backend packages**. 

This node lets you call one of the functions provided by `systeminformation`. The result of each call will be returned as `msg.payload`.

There are two ways to select the function to be called:

### Static configuration via the node property editor
You may configure the to-be-called function via the nodes property editor.

<img src="resources/systeminformation.png"
    style="min-width: 432px; width: 432px; align: center; border: 1px solid lightgray;"/>

Functions are arranged in groups, following the `systeminformation` documentation.

In case a function expects additional parameters, those may be defined as required.

Additionally, the node may be configured to observe the selected function by polling at a given rate. If polling is enabled, you may decide to let the node emit a `msg` only if the function call returned changed values.

### Dynamic mode
You may trigger the call of a `systeminformation` function as well by sending to the node a `msg` that is configured accordingly:

`topic`: name of the `systeminformation` function to be called.

`payload`: optional `<object>` with parameters to be passed to the function. The keys of the objects properties have to match the names of the parameters as defined by the `systeminformation` documentation, e.g:

```
{
    topic: 'versions',
    payload: {
        apps: 'npm, php, postgresql'
    }
}
```

> The dynamic mode may be used in addition & parallel to a static configuration, as shown in the provided example.
npm package: @raltea/rms-sdk
Description: ## 1-Configure the service you want to use Let s take the example of UIS. Modify the UIS configuration at the start of your application: ```ts import { UISConfig } from '@raltea/rms-sdk/dist';
Latest version: 0.0.6

# How to use this package

## 1-Configure the service you want to use
Let s take the example of UIS.
Modify the UIS configuration at the start of your application:
```ts
import { UISConfig } from '@raltea/rms-sdk/dist';

UISConfig.url = 'http://your-uis-instance.com'
UISConfig.apiKey = 'your_RMS_api_key';
```

## 2-Use the service
```ts
import { UISAuth } from '@raltea/rms-sdk/dist';

const [result, error] = await UISAuth.register(email, password, 'pool');
```
npm package: @raluce/raluce
Description: Raluce API for JavaScript
Author: Raluce LLC
Latest version: 0.4.3

# Raluce JS library

Javascript API (Node & browser) to easily interact with Raluce services.

Raluce JS library primary purpose right now is to let developers obtain information about a specific franchise (e.g catalog, schedule) and to create shopping carts without needing to use the Raluce ordering website.

In future releases, this package will contain a more complete JS API to intereact with all the other Raluce resources.

### Installing

Install the package with npm:

```
npm install @raluce/raluce --save
```

### Usage

Start by importing the package and creating an instance. You will then have access to functions to interact with Raluce.

#### Getting a brand by id

```Javascript
// Node
var Raluce = require('raluce').default;
var raluce = new Raluce();

var brand = await raluce.getBrandById("brand id");
```

```Typescript
// Typescript
import Raluce from 'raluce';
let raluce = new Raluce();

let brand = await raluce.getBrandById("brand id");
```


#### Getting a franchise by id

```Javascript
// Node
var Raluce = require('raluce').default;
var raluce = new Raluce();

var franchise = await raluce.getFranchiseById("franchise id");
```

```Typescript
// Typescript
import Raluce from 'raluce';
let raluce = new Raluce();

let franchise = await raluce.getFranchiseById("franchise id");
```

#### Creating a shopping cart

```Javascript
// Node
var Raluce = require('raluce').default;
var raluce = new Raluce();

// See docs for shoppingCart schema
var result = await raluce.createShoppingCart(shoppingCart);

console.log(result); // { id: 'shopping cart id', url: 'url to pay for this shopping cart' }
```

```Typescript
// Typescript
import Raluce from 'raluce';
let raluce = new Raluce();

// See docs for shoppingCart schema
let result = await raluce.getFranchiseById(shoppingCart);

console.log(result); // { id: 'shopping cart id', url: 'url to pay for this shopping cart' }
```

## Running unit tests

To run the tests, simply run the following command:


```
npm test
```

## Contributing

If you would like to help, feel free to fork `dev` branch and submit a pull request with your changes. We will review the changes and work with you to get it published.


## Reporting a bug

If you encounter a bug, please submit an issue and we will follow up on it.

> **Note:** If you want to report a security vulnerability, please **do not report it in an issue**, instead email us the details to security@raluce.com. We will work with you in getting the issues solved ASAP.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE) file for details.
npm package: @ram-singh/footer
Description: Stencil Component Starter
Latest version: 0.0.2



## Using this component

### Script tag
- Put a script tag similar to this `<script src='https://unpkg.com/@ram-singh/footer@0.0.1/dist/footer.js'></script>` in the head of your index.html
- Then you can use the element anywhere in your template, JSX, html etc
    <footer-component logo='https://anatta.io/_nuxt/icons/icon_64.523b75.png' company='Anatta'></footer-component>

### Node Modules
- Run `npm i @ram-singh/footer --save`
- Put a script tag similar to this `<script src='node_modules/@ram-singh/footer/dist/footer.js'></script>` in the head of your index.html
- Then you can use the element anywhere in your template, JSX, html etc
    <footer-component logo='https://anatta.io/_nuxt/icons/icon_64.523b75.png' company='Anatta'></footer-component>


### Reference:
1. Creating and Publishing Web Components with Stencil :  https://www.twilio.com/blog/2018/02/creating-and-publishing-web-components-with-stencil.html
2. https://stenciljs.com/docs/my-first-component
npm package: @ram-stack/composition-root
Description: Babel macro to define application composition root
Author: InvictusMB
Latest version: 2.0.0

# ram-stack/composition-root macro

`composition-root` is a [Babel macro](https://github.com/kentcdodds/babel-plugin-macros) for defining an application composition root and autowiring.
 It is intended to streamline setting up a convention based application structure and automate populating of a [Dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) container.

Application structure is represented as a set of rules describing where to locate the files, how to get exported things from them and, eventually, how to register those things in a container. All the files following the configured convention will be automatically picked by Babel during compilation.

See [Sample app](../ram-sample-app/README.md) for a reference setup of [React](https://reactjs.org/) [Awilix](https://github.com/jeffijoe/awilix#readme) [MobX](https://mobx.js.org/) application.
npm package: @ram-stack/core
Description: React Awilix MobX app core dependencies and utilities
Author: InvictusMB
Latest version: 3.0.0

# ram-stack/core

This package hosts an opinionated set of dependencies for a typical [React](https://github.com/facebook/react) [Awilix](https://github.com/jeffijoe/awilix) [MobX](https://github.com/mobxjs/mobx) app.

Examples of usage are available in [Sample App](https://github.com/InvictusMB/ram-stack/tree/master/packages/ram-sample-app) 

## Composition root

Composition root is a place where all the application components are loaded into.

```tsx
import {createCompositionRoot} from '@ram-stack/core';

const root = createCompositionRoot<InjectedDependencies>({
  onReady: () => console.log('ready'),
});
```

`InjectedDependencies` is a type containing all the things injected by a DI container.
`onReady` is a callback invoked when `load` operation completes. If [Hot Module Replacement](https://webpack.js.org/concepts/hot-module-replacement/) is enabled, `onReady` will be invoked every time any module is updated.

Arbitrary objects or values can be registered in a container within composition root

```tsx
import {di} from '@ram-stack/core';

root.container.register({
  foo: di.asValue('foo'),         // will be resolved as value
  bar: di.asClass(BarClass),      // will be resolved as class instance
  baz: di.asFuntion(() => 'baz'), // will be resolved as function return value
});
```

## Rendering root component

```tsx
import {view} from '@ram-stack/core';

const MyComponent = root.container.resolve('MyComponent');

view.renderDom((
  <MyComponent />
), document.getElementById('root'));
```

## Using hooks

```tsx
import {hooks} from '@ram-stack/core';

export function MyComponent() {
  const [foo, setFoo] = hooks.useState(true);
}

```

## Using router components

```tsx
import {router} from '@ram-stack/core';

export function MyRedirectComponent() {
  return (
    <router.Redirect to={'/some/route'} />
  );
}

export function MyLinkComponent() {
  return (
    <router.Link to={'/some/route'}>
      My Link
    </router.Link>
  );
}
```
npm package: @ram-stack/import-replacer-helper
Description: A helper to create import replacing macros
Author: InvictusMB
Latest version: 1.0.1

# Import replacer helper

This package provides a helper for creating [Babel macros](https://github.com/kentcdodds/babel-plugin-macros) that expand namespace imports into direct imports.
It is useful for consuming libraries like [Material-UI](https://github.com/mui-org/material-ui) which bundle a large number of standalone modules.

For these libraries using a namespace import (`import * as MUI from '@material-ui/core'`) compromises build performance and bundle size (see [tree-shaking](https://webpack.js.org/guides/tree-shaking/)). 

A macro such as [`@ram-stack/material-ui.macro`](../material-ui.macro/README.md) prevents above mentioned issues by replacing namespace import with only a necessary subset of direct imports.
Doing that proactively helps the compiler and bundler to exclude unused code and avoid extra work.

## Installation

This module is distributed via [npm](https://www.npmjs.com/) which is bundled with [node](https://nodejs.org/) and should be installed as one of your project's `dependencies`:

```bash
npm install --save @ram-stack/import-replacer-helper
```

## Usage 

`import-replacer-helper` API consists of a single function: `createReplacerMacro`.
`createReplacerMacro` takes replacer function `getPath` and preferred default namespace import statement `defaultNamespaceImport` and returns an instance of a macro that can be exported and consumed by [`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros).

### Example

```es6
const {createReplacerMacro} = require('@ram-stack/import-replacer-helper');
const {name: packageName} = require('./package');

module.exports = createReplacerMacro({
  getPath: name => `@material-ui/core/${name}`,
  defaultNamespaceImport: `import MUI from '${packageName}'`,
});
```

### TypeScript usage

If a package targeted by the macro provides TypeScript type definitions it is recommended to reexport those definitions from the macro package itself.
In order to achieve this, a typings file should be created. For example, `macro.d.ts`:

```typescript
/* macro.d.ts */
export * from '@material-ui/core';
export {default} from '@material-ui/core';
```

Then it has to be referenced in `package.json`:
```diff
+  "types": "macro.d.ts",
```

## See also

[`@ram-stack/material-ui.macro`](../material-ui.macro/README.md)
[`@ram-stack/material-ui-cons.macro`](../material-ui-icons.macro/README.md)

[`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros)

## License

[MIT](LICENSE)
npm package: @ram-stack/material-ui-icons.macro
Description: Macro helper for importing Material UI icons
Author: InvictusMB
Latest version: 1.0.1

# Material UI Icons macro

A macro for expanding [Material-UI](https://github.com/mui-org/material-ui) Icons imports. 

Material-UI encourages usage of direct deep imports.

```es6
// Material-UI suggested import
import CheckBox from '@material-ui/icons/CheckBox';
```

While that is motivated by impact on bundle size and build performance it might cause certain aesthetic and readability issues.

This macro enables the usage of namespace import without harming either.

The transformation:

```es6
import MuiIcons from '@ram-stack/material-ui-icons.macro';

function Component() {
  return (
    <span>
      <MuiIcons.Checkbox /> some text
    </span>
  );
}
      ↓ ↓ ↓ ↓ ↓ ↓
import MuiIcons_Checkbox from '@material-ui/icons/Checkbox';

function Component() {
  return (
    <span>
      <MuiIcons_Checkbox /> some text
    </span>
  );
}
```

## Installation

This module is distributed via [npm](https://www.npmjs.com/) which is bundled with [node](https://nodejs.org/) and
should be installed as one of your project's `devDependencies`:

```bash
npm install --save-dev @ram-stack/material-ui-icons.macro
```

Assuming the project has `babel-plugin-macros` already configured (such as Create React App v2+ projects) no further action is required.
Otherwise see [`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros) guide first.

## Usage 

This macro is a drop in replacement for `@material-ui/icons` imports.
Replacing `import * as MuiIcons from '@material-ui/icons'` with `import MuiIcons from '@ram-stack/material-ui-icons.macro` is the only thing needed.

The `MuiIcons` identifier can be renamed arbitrarily. The macro does not care about names.

### TypeScript usage

No extra setup is required. This package reexports the typings from `@material-ui/icons` and the typechecking works as if no substitution happened. 

## See also

[`@ram-stack/material-ui.macro`](../material-ui.macro/README.md)
[`@ram-stack/import-replacer-helper`](../import-replacer-helper/README.md)

[`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros)

## License

[MIT](LICENSE)
npm package: @ram-stack/material-ui.macro
Description: Macro helper for importing Material UI components
Author: InvictusMB
Latest version: 1.0.1

# Material UI macro

A macro for expanding [Material-UI](https://github.com/mui-org/material-ui) imports. 

Material-UI encourages usage of direct deep imports.

```es6
// Material-UI suggested import
import Button from '@material-ui/core/Button';
```

While that is motivated by impact on bundle size and build performance it might cause certain aesthetic and readability issues.

This macro enables the usage of namespace import without harming either.

The transformation:

```es6
import MUI from '@ram-stack/material-ui.macro';

function Component() {
  return (
    <MUI.Button>
      <MUI.Typography>
        Caption
      </MUI.Typography>
    </MUI.Button>
  );
}
      ↓ ↓ ↓ ↓ ↓ ↓
import MUI_Button from '@material-ui/core/Button';
import MUI_Typography from '@material-ui/core/Typography';

function Component() {
  return (
    <MUI_Button>
      <MUI_Typography>
        Caption
      </MUI_Typography>
    <MUI_Button>
  );
}
```

## Installation

This module is distributed via [npm](https://www.npmjs.com/) which is bundled with [node](https://nodejs.org/) and
should be installed as one of your project's `devDependencies`:

```bash
npm install --save-dev @ram-stack/material-ui.macro
```

Assuming the project has `babel-plugin-macros` already configured (such as Create React App v2+ projects) no further action is required.
Otherwise see [`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros) guide first.

## Usage 

This macro is a drop in replacement for `@material-ui/core` imports.
Replacing `import * as MUI from '@material-ui/core'` with `import MUI from '@ram-stack/material-ui.macro` is the only thing needed.

The `MUI` identifier can be renamed arbitrarily. The macro does not care about names.

### TypeScript usage

No extra setup is required. This package reexports the typings from `@material-ui/core` and the typechecking works as if no substitution happened. 

## See also

[`@ram-stack/material-ui-cons.macro`](../material-ui-icons.macro/README.md)
[`@ram-stack/import-replacer-helper`](../import-replacer-helper/README.md)

[`babel-plugin-macros`](https://github.com/kentcdodds/babel-plugin-macros)

## License

[MIT](LICENSE)
npm package: @rama-developer/common-components
Description: ramahis common component
Latest version: 1.1.1

<!--
Get your module up and running quickly.

Find and replace all on all files (CMD+SHIFT+F):
- Name: Ramahis Common Component
- Package name: @ramahis/common-components
-->

# Ramahis Common Component

[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]
[![License][license-src]][license-href]
[![Nuxt][nuxt-src]][nuxt-href]


## Quick Setup

1. Add `@deverloprama/common-components` dependency to your project

```bash
# Using pnpm
pnpm add -D @deverloprama/common-components

# Using yarn
yarn add --dev @deverloprama/common-components

# Using npm
npm install --save-dev @deverloprama/common-components
```

2. Add `my-module` to the `modules` section of `nuxt.config.ts`

```js
export default defineNuxtConfig({
  modules: [
    '@deverloprama/common-components'
  ]
})
```

That's it! You can now use My Module in your Nuxt app ✨

## Development

```bash
# Install dependencies
npm install

# Generate type stubs
npm run dev:prepare

# Develop with the playground
npm run dev

# Build the playground
npm run dev:build

# Run ESLint
npm run lint

# Run Vitest
npm run test
npm run test:watch

# Release new version
npm run release
```

<!-- Badges -->
[npm-version-src]: https://img.shields.io/npm/v/my-module/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
[npm-version-href]: https://npmjs.com/package/my-module

[npm-downloads-src]: https://img.shields.io/npm/dm/my-module.svg?style=flat&colorA=18181B&colorB=28CF8D
[npm-downloads-href]: https://npmjs.com/package/my-module

[license-src]: https://img.shields.io/npm/l/my-module.svg?style=flat&colorA=18181B&colorB=28CF8D
[license-href]: https://npmjs.com/package/my-module

[nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
[nuxt-href]: https://nuxt.com
npm package: @rama41222/node-logger
Description: Nodejs logger based on winston for express and koa js
Author: rama41222
Latest version: 1.0.1

### NODEJS Logger

#### Installation

```
npm i @rama41222/node-logger
```

#### Usage

```
const { log, ExpressAPILogMiddleware } = require('@rama41222/node-logger');
```

#### Configuration

```
const loggerOptions = { 
    label: 'user-service', # service label 
    console: true, # shows logs in console
    file: true # shows logs in file 
};

const apiLoggerOptions = { 
    response: true, # show response logs 
    request: true, # show request logs
};

```

##### Getting a logger instance
```
const logger = log({ label: 'user-service' , console: true, file: true });

```

###### Express
```
app.use(ExpressAPILogMiddleware(logger, { response: true, request: true }));
```

###### Koa

```
app.use(KoaAPILogMiddleware(logger, { response: true, request: true }));
```