open-index/open-npm huggingface dataset:
npm package: @smartorigin/smart-filter
Description: A module that allows smart filtering over js array using SQL-Like where clause.
Author: Smart/Origin
Latest version: 1.0.4

# @smartorigin/smart-filter

[![npm version](https://badge.fury.io/js/%40smartorigin%2Fsmart-filter.svg)](https://badge.fury.io/js/%40smartorigin%2Fsmart-filter)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A module that allows smart filtering over js array using SQL-Like where clause.

## Getting started

    npm install @smartorigin/smart-filter

## Usage

Capabilities of the mobule.

With smart-filter you can test if an object match an SLQ-Like where clause.

It could be used to expose to end user an high level language and to easily process end user expressions in JS.

You can filter/test object using the following syntax : (assuming `propA` and `propB` are properties of a js object)

    propA = 1

    propA = "2"

    propA = true

    propA = 'Hello'
    
    propA = "Hello" OR propA = "Hi"

    propA = "Hello" AND propA = "Hi"

    !(propA = "Hello" AND propA = "Hi")

    propA IN ["Hello","Hi"]

    propA NOTIN ["Hello","Hi"]

    propA <> propB

    propA > 2

    propA < 4

    propA <= 4

    propA >= 4

    1=1 //means keep all

    1!=1 //means keep none

You can also write operator like this :

    = -> ==
    AND -> && 
    OR -> ||
    <> -> !=

This module is build using [JSEP](http://jsep.from.so).


### ES6

_see also /test/index.js_

First import exposed functions :

    import {filter,test} from '@smartorigin/smart-filter'

**function test(obj,expr)**

    let input = {
        "propA":2,
        "propB":"OK",
        "propC":true,
        "propD":4,
        "propE":false,
        "propF":"KO"
    }

    //simple equality
    test(input,'propA == propA') //return true

    //simple comparison
    test(input,'propA > 1') //returns true

    //boolean expr
    test(input,'propB == "OK" && propA == 2') //return true

**function filter(arr,expr)**

    let input = [
        {
            "name":"obj1",
            "propA":2,
            "propB":"OK",
            "propC":true
        },
        {
            "name":"obj2",
            "propA":34,
            "propB":"KO",
            "propC":false
        }
    ];


    filter(input,'name="obj1" OR name="obj2"') // Returns two results

    filter(input,'name="test"')// Returns empty results

#### Non ES6

For non ES6 env just require module

    var smartfilter = require("@smartorigin/smart-filter");

    let input = {"a":"ok"};

    smartfilter.test(input,'a="ok"'); // returns true

    let arr = [{"a":"1"},{"a":"2"}];
    
    smartfilter.filter(a,'a="1"'); // return an array that contains one object.



## Contributing

Before pushing any pull request you must ensure the following points :

- you have new test to your feature / fix and `npm run test` pass.
- `npm run build` is passing
- `npm run prepublish` is passing

## About

Created by [MarcAlx](https://github.com/MarcAlx) for [Smart/Origin](https://github.com/smartorigin)

## Usefull links

https://github.com/flexdinesh/npm-module-boilerplate

## License

MIT License
npm package: @smartos/utils-kit
Description: Enouvo React UIKIT with:
Author: Cinny
Latest version: 0.1.3

# Reactjs UIKIT

Enouvo React UIKIT with:

- Typescript
- React
- Antd

## Description

Package contains the base eslint configuration using for ReactJS project

## How to install

`yarn add @enouvo/react-uikit`
npm package: @smartpartner/postdirekt-autocomplete
Description: this is a branch of netresearch/postdirekt-autocomplete-monorepo which supports building selection when  country, zip, city and street is selected
Author: netresearch
Latest version: 2.0.1

# Smartpartner Autocomplete 
this is a branch of netresearch/postdirekt-autocomplete-monorepo which supports building (house number) selection when country, zip, city and street is selected

## SDK Developer and Contribution Workflow

### Prerequisites

#### Node.js

Before you can start working on the Autocomplete monorepo, you need to have Node.js
installed on your machine. The currently supported versions are `10.0.0` or greater.

To download Node.js visit https://nodejs.org/en/download/.

_NOTE: You can use a tool like [`NVM`](https://github.com/creationix/nvm)
or [`N`](https://github.com/tj/n) to install and manage multiple node versions_

#### Yarn

In addition to Node.js we use `yarn` to facilitate multi package development.

To install `yarn` follow the instructions listed on their website:
https://yarnpkg.com/en/docs/install

#### Verify Prerequisites

You can verify your setup by running the following commands in your terminal:

```bash
$ node -v
$ yarn -v
```

Your Node.js version should be `10.0.0` or greater, your `yarn` version should
be `1.0.0` or greater,

### Install Dependencies

Once you have Node.js and `yarn` installed on your machine and have validated
that you are running the proper version, you can set up the development environment
by running the following at the root of the repo:

```bash
$ yarn
```

Once you have installed all the dependencies, you can build both packages by
running the following command the root of the repo:

```bash
$ yarn build
```

## Packages

### packages/autocomplete-sdk

This folder contains modified _@netresearch/postdirekt-autocomplete-sdk_, responsible for abstracting away the Deutsche Post Direkt Autocomplete 2.0 API.

See [Readme](packages/autocomplete-sdk/README.md).

### packages/autocomplete-library

This folder contains modified _@netresearch/postdirekt-autocomplete-library, responsible for registering input listeners on given input fields (street address, city, postcode and house number) and fetching address suggestions from the Autocomplete API via the autocomplete-sdk package.

See [Readme](packages/autocomplete-library/README.md).

```javscript
    postDirekt = postdirektAutocompleteLib.init(
        document.getElementById('street'),
        document.getElementById('city'),
        document.getElementById('postcode'),
        document.getElementById('house_nr'),
        document.getElementById('country'),
        'DE',
        '_hash_'            
    );
```

## Testing the packages

### Running the Tests

You can run the tests with the command

```bash
$ yarn test
```

To run the linter, do

```bash
$ yarn lint
```

## Building the packages

You can build ES2017 compatible artifacts (this is what's published on npm) with

```bash
$ yarn build
```

You can also build ES5 compatible artifacts (output in `<rootDir>/dist`) with

```bash
$ yarn build:es5
```
npm package: @smartpassk12/eslint-plugin-rxjs-angular
Description: ESLint rules for RxJS and Angular
Author: Nicholas Jamieson
Latest version: 2.0.1

# eslint-plugin-rxjs-angular

[![GitHub License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/cartant/eslint-plugin-rxjs-angular/blob/master/LICENSE)
[![NPM version](https://img.shields.io/npm/v/eslint-plugin-rxjs-angular.svg)](https://www.npmjs.com/package/eslint-plugin-rxjs-angular)
[![Downloads](http://img.shields.io/npm/dm/eslint-plugin-rxjs-angular.svg)](https://npmjs.org/package/eslint-plugin-rxjs-angular)
[![Build status](https://img.shields.io/circleci/build/github/cartant/eslint-plugin-rxjs-angular?token=d3e3fd6613244558287da156fd9e0c4357a2170c)](https://app.circleci.com/pipelines/github/cartant)
[![dependency status](https://img.shields.io/david/cartant/eslint-plugin-rxjs-angular.svg)](https://david-dm.org/cartant/eslint-plugin-rxjs-angular)
[![devDependency Status](https://img.shields.io/david/dev/cartant/eslint-plugin-rxjs-angular.svg)](https://david-dm.org/cartant/eslint-plugin-rxjs-angular#info=devDependencies)
[![peerDependency Status](https://img.shields.io/david/peer/cartant/eslint-plugin-rxjs-angular.svg)](https://david-dm.org/cartant/eslint-plugin-rxjs-angular#info=peerDependencies)

This package contains ESLint versions of the Angular/RxJS rules that are in the [`rxjs-tslint-rules`](https://github.com/cartant/rxjs-tslint-rules) package.

There is no recommended configuration for this package, as all of the rules are opinionated.

# Install

Install the ESLint TypeScript parser using npm:

```
npm install @typescript-eslint/parser --save-dev
```

Install the package using npm:

```
npm install eslint-plugin-rxjs-angular --save-dev
```

Configure the `parser` and the `parserOptions` for ESLint. Here, I use a `.eslintrc.js` file for the configuration:

```js
const { join } = require("path");
module.exports = {
  parser: "@typescript-eslint/parser",
  parserOptions: {
    ecmaVersion: 2019,
    project: join(__dirname, "./tsconfig.json"),
    sourceType: "module"
  },
  plugins: ["rxjs-angular"],
  extends: [],
  rules: {
    "rxjs-angular/prefer-async-pipe": "error"
  }
};
```

# Rules

The package includes the following rules:

| Rule | Description | Recommended |
| --- | --- | --- |
| [`prefer-async-pipe`](https://github.com/cartant/eslint-plugin-rxjs-angular/blob/main/docs/rules/prefer-async-pipe.md) | Forbids the calling of `subscribe` within Angular components. | No |
| [`prefer-composition`](https://github.com/cartant/eslint-plugin-rxjs-angular/blob/main/docs/rules/prefer-composition.md) | Forbids `subscribe` calls that are not composed within Angular components (and, optionally, within services, directives, and pipes). | No |
| [`prefer-takeuntil`](https://github.com/cartant/eslint-plugin-rxjs-angular/blob/main/docs/rules/prefer-takeuntil.md) | Forbids Calling `subscribe` without an accompanying `takeUntil`. | No |
npm package: @smartpay/mixpanel
Description: Mixpanel
Author: Smartpay Solutions PTE. LTD.
Latest version: 1.0.9

## Mixpanel

This module is an in-house minimalism for easily integrating Mixpanel across Consumer and Merchant projects

## Usage

### Initialization

- Pass a `token` and super properties to `Mixpanel.initialize` in your `App.tsx`

```typescript
Mixpanel.initialize({
  token: process.env.REACT_APP_MIXPANEL_TOKEN || '',
  superProps: {
    Product: 'Checkout',
    Platform: 'Web',
  },
});
```

- `urlToScreen` prop is optional to easily define tracking screen name based on current url path

### Track page view and duration

- Add `useTrackPageView` in your screen render method. By default, it will also track a duration the consumer stays on that screen.

```typescript
const LoginScreen: FC<RouteComponentProps> = () => {
  useTrackPageView();

  return (
    ...
  )
};
```

### Track actions

- Call `trackAction` with an item name of that element

```typescript
Mixpanel.trackAction({
  action: 'Click',
  itemName: 'Submit',
});
```

### Track user idenfifer

- Call `setUserID` after initalization with a unique identifier from the Backend

### Register super properties

- Call `registerSuperProperties` to have certain properties that you want to include with each event you send

### Set user properties

- Call `setUserProperties` to explore and segment users by who they are
npm package: @smartpay/sdk-node
Description: Smartpay SDK NodeJS
Author: Smartpay Co. Ltd.
Latest version: 0.9.1

<div id="top"></div>

<br />
<div align="center">
  <a href="https://github.com/smartpay-co/sdk-node">
		<picture>
			<source media="(prefers-color-scheme: dark)" srcset="https://assets.smartpay.co/logo/banner/smartpay-logo-dark.png" />
			<source media="(prefers-color-scheme: light)" srcset="https://assets.smartpay.co/logo/banner/smartpay-logo.png" />
			<img alt="Smartpay" src="https://assets.smartpay.co/logo/banner/smartpay-logo.png" style="width: 797px;" />
		</picture>
  </a>

  <p align="center">
    <a href="https://docs.smartpay.co/"><strong>Explore the docs »</strong></a>
    <br />
    <br />
    <a href="https://github.com/smartpay-co/sdk-node/issues">Report Bug</a>
    ·
    <a href="https://github.com/smartpay-co/sdk-node/issues">Request Feature</a>
  </p>
</div>

# Smartpay Nodejs SDK

The Smartpay Nodejs SDK offers easy access to Smartpay API from applications written in Nodejs.

## Prerequisites

Nodejs v12+

## Installation

```shell
npm install --save @smartpay/sdk-node
# or
yarn add @smartpay/sdk-node
```

## Usage

The package needs to be configured with your own API keys, you can find them on your [dashboard](https://dashboard.smartpay.co/settings/credentials).

```javascript
const Smartpay = require('@smartpay/sdk-node').default;

const smartpay = new Smartpay('<YOUR_SECRET_KEY>', {
  publicKey: '<YOUR_PUBLIC_KEY>',
});
```

If you would like to know how Smartpay payment works, please see the [payment flow](https://docs.smartpay.co/#payment_flow) for more details.

### Create Checkout session

```javascript
(async () => {
  const payload = {
    items: [
      {
        name: 'レブロン 18 LOW',
        amount: 250,
        currency: 'JPY',
        quantity: 1,
      },
    ],

    shipping: {
      line1: 'line1',
      locality: 'locality',
      postalCode: '123',
      country: 'JP',
    },

    // Your internal reference of the order
    reference: 'order_ref_1234567',

    // Callback URLs
    successUrl: 'https://docs.smartpay.co/example-pages/checkout-successful',
    cancelUrl: 'https://docs.smartpay.co/example-pages/checkout-canceled',

    test: true,
  };

  const session = await smartpay.createCheckoutSession(payload);
})();
```

The shape of checkout session payload is described in the [docuement](https://en.docs.smartpay.co/reference/create-a-checkout-session).

### To retreive the session URL

```javascript
const sessionURL = smartpay.getSessionURL(session);
```

We also prepare a more [real-world example](https://github.com/smartpay-co/integration-examples/blob/main/server/node/server.js) for you to refer to.

## Reference

Please check the [reference](docs/Reference.md) document.
npm package: @smartpkg/devtools
Description: Devtools for inspecting Smart Contract function calls
Author: SmartPkg
Latest version: 0.1.1

# SmartPkg Devtools
React components for displaying captured Smart Contract function calls from using Smartpkg client.

## Installation
```shell
npm install @smartpkg/devtools
```

## Usage
In `main.tsx`, import devtool and add the component.

```tsx
// main.tsx
import SmartpkgDevtool from '@smartpkg/devtools';

ReactDOM
  .createRoot(document.getElementById('root') as HTMLElement)
  .render(
    <React.StrictMode>
      <App />
      <SmartpkgDevtool />
    </React.StrictMode>
  );
```
npm package: @smartpkg/sanctions
Description: Check whether a wallet address is sanctioned
Author: smartpkg
Latest version: 0.1.0

# Sanctions
Check whether a wallet address is sanctioned.

## Installation
```shell
npm install @smartpkg/sanctions
```

## Usage
```typescript
import { isSanctioned } from '@smartpkg/sanctions';

const walletAddress = '0x7F367cC41522cE07553e823bf3be79A889DEbe1B';
const chainId = 1;
await isSanctioned(chainId, walletAddress);
```

## Supported Networks
A list of supported networks:
* Ethereum 
* Polygon 
* BNBSmartChain
* Avalanche
* Optimism
* Arbitrum
* Fantom 
* Celo
npm package: @smartpy/originator
Description: ## Requirements
Latest version: 0.12.0

# SmartPy Contract Originator

## Requirements

| Requirement |  version  |
|:-----------:|:---------:|
| NodeJs      | >= v10.x  |


## Install the originator
```sh
npm i -g @smartpy/originator
```

## Originate a contract
```sh
# Using Micheline format (.tz)
smartpy-originator originate-contract --code code.tz --storage storage.tz --rpc https://mainnet.smartpy.io

# Using Michelson format (.json)
smartpy-originator originate-contract --code code.json --storage storage.json --rpc https://mainnet.smartpy.io

# By default, the originator will use a faucet account.
# But you can provide your own private key as an argument
smartpy-originator originate-contract --code code.json --storage storage.json --rpc https://mainnet.smartpy.io --private-key edsk...
```

## Help
```
smartpy-originator help originate-contract
```

<img height="48" href="https://smartpy.io" src="https://smartpy.io/static/img/logo.png">
npm package: @smartpy/ts-syntax
Description: SmartTS Syntax
Latest version: 0.12.0

# Typescript Syntax for SmartML

## Development

### Building

```shell
node scripts/generate-ide-typings.js && npx rollup -c
```

### Testing

**Run tests**
```shell
npm run ci-test
```

### Update Snapshot

```shell
npx jest --updateSnapshot

# CI mode
CI=true TRACE_ERRORS=true npx jest --no-watch --all -u
```
npm package: @smartrecruiters/tsconfig-strict
Description: it provides tsconfig with all strict rules
Author: Sergei Vakhrushev
Latest version: 5.9.0

# @smartrecruiters/tsconfig-strict

Usually it's told that for enabling strict mode for TS just `"strict": true` should be added in `tsconfig.json` of your project. Actually it's not fully truth, there are much many additional options and with this package you don't have to check which options should be enabled for absolutely strict mode. Our tsconfig enables all strict rules and keeps your project type-safety.

For Angular projects, please, use [config for Angular](https://www.npmjs.com/package/@smartrecruiters/tsconfig-strict-angular)

## Installation

There are just two simple steps for starting using strict mode.

**Step 1**. Install an appropriate version of the package, it's really simple - the version of the package should be the same as your TS version without patch version

| Package version | TS version |
| --------------- | :--------- |
| 5.9.x           | 5.9.x      |
| 5.8.x           | 5.8.x      |
| 5.7.x           | 5.7.x      |
| 5.6.x           | 5.6.x      |
| 5.5.x           | 5.5.x      |
| 5.4.x           | 5.4.x      |
| 5.3.x           | 5.3.x      |
| 5.2.x           | 5.2.x      |
| 5.1.x           | 5.1.x      |
| 5.0.x           | 5.0.x      |
| 4.9.x           | 4.9.x      |
| 4.8.x           | 4.8.x      |
| 4.7.x           | 4.7.x      |
| 4.6.x           | 4.6.x      |
| 4.5.x           | 4.5.x      |
| 4.4.x           | 4.4.x      |
| 4.3.x           | 4.3.x      |
| 4.2.x           | 4.2.x      |
| 4.1.x           | 4.1.x      |
| 4.0.x           | 4.0.x      |

```
npm i -D @smartrecruiters/tsconfig-strict@{version}
```

When TypeScript in your project wil be updated don't forget to update the package as well. But anyway, if the current version of the package is not perfectly matches for the new version of TS, there will be a warning in your terminal.

**Step 2**. Configure typescript in your project:

Just add `"extends": "@smartrecruiters/tsconfig-strict/tsconfig.json",` in your main `tsconfig` file. It's also possible to override any rule that the package provides by default, for example

```json
{
  "extends": "@smartrecruiters/tsconfig-strict/tsconfig.json",
  "compilerOptions": {
    "allowUnusedLabels": false
  }
}
```

## License

[MIT](LICENSE)
npm package: @smartregionlab/cop-types
Description: Shared TypeScript types for frontend and backend
Author: HSLU Smart Region Lab
Latest version: 1.0.6

# cop-types
This repository acts as an unpublished npm package that can be consumed by other applications.
It contains a collection of types that are shared among the `cop` applications, using the [cop-backend](https://gitlab.switch.ch/hslu/research/infovis/smartregion/pilots/cop/cop-server-nestjs) application as a baseline.
Any types that are not needed in the backend application will not be published to this repository, and need to be implemented locally. 

## Publishing/Changing types
1. Clone the git repository 
```bash
git clone git@gitlab.switch.ch:hslu/research/infovis/smartregion/pilots/cop/cop-types.git
```
2. Move into the newly downloaded repository
```bash
cd cop-types
```
3. Add/update/remove the type from the `src/*-types.ts` file
```ts
const SamplePodcastSchema = z.object({
  id: z.string(),
  title: z.string(),
  description: z.string(),
  authorId: z.string(),
  createdAt: z.date(),
});

export type SampleZodPodcast = z.infer<typeof SamplePodcastSchema>;
```
(Ensure to update any corresponding exports)

4. If a new file was created, update the exports in `src/index.ts` 

5. Push the new version to the main branch 
```bash
git add .
git commit -m "chore: added podcast type"
```
6. Bump the npm package version ("version": "X.X.X"), using the npm utility:
- For minor changes/bug fixes: ```npm version patch``` (change of 0.0.1)
- For bigger changes/new types: ```npm version minor``` (change of 0.1.0)
- For breaking changes: ```npm version major``` (change of 1.0.0)

> The `npm version` utility updates `package.json`, `package-lock.json` and creates a new git tag with the updated version. It also creates a new git commit locally. 

7. Publish the updated version
```bash
npm publish
```

8. Push the updated files to remote
```bash
git push origin main
git push --tags
```


## Consuming types
1. Install the type package from source
```bash
npm install @smartregionlab/cop-types
```
2. Update an already installed version of the package
```bash 
# Update all packages
npm update

# Pull newest version of only the cop-types package
npm install @smartregionlab/cop-types@latest

# Install specific version i.e. 1.2.3
npm install @smartregionlab/cop-types@1.2.3
````

3. Import and use the type in the current .ts file
```ts
import { SampleZodPodcast } from "@srl/cop-types"

const podcast: SampleZodPodcast = {
  id: "123",
  title: "My Podcast",
  description: "A show about coding",
  authorId: "author-1",
  createdAt: new Date(),
};
```

In this case, Zod will now ensure runtime typesafety through the external cop-types package. If we define something that is not allowed, ie:
```ts
const podcast: SampleZodPodcast = {
  id: "123",
  title: "My Podcast",
  description: "A show about coding",
  authorId: "author-1",
  createdAt: "a string instead of a date",
};
```
Zod will throw an error:
```
error TS2322: Type 'string' is not assignable to type 'Date'.
```
npm package: @smartrent/heretic
Description: An opinionated background job runner. Job payloads, logs, and metadata are backed by Postgres. Job queueing and execution are backed by RabbitMQ.
Author: Ben Youngblood
Latest version: 0.5.2

# Heretic

An opinionated background job runner. Job payloads, logs, and metadata are backed
by Postgres. Job queueing and execution are backed by RabbitMQ.

Also, ES6/7.

### Why?

Lots of job queues are backed by Redis, but in order to leverage Redis's queueing
in a consistent way, you have to write a lot of Lua scripts, and you can still
easily run into issues with jobs getting stuck in [weird, inconsistent states](https://github.com/Automattic/kue/search?q=stuck&type=Issues).

Redis is also not a great option if you want to be able to search and filter
jobs (by type, by payload, etc). It's up to you (or your queueing library) to
implement your own indexing.

### Should I use it?

Probably not. It wouldn't be my first Terrible Idea™.

## Usage

Not implemented yet:

 - Automatic failure retries
 - Tests

### Database Schema

Feel free to add any other triggers/indexes you'd like.

```sql
CREATE TABLE heretic_jobs (
  id SERIAL NOT NULL PRIMARY KEY,
  queue_name text NOT NULL,
  status text DEFAULT 'pending',
  payload jsonb,
  attempt_logs jsonb[] DEFAULT '{}',
  max_attempts int NOT NULL DEFAULT 1,
  created_at timestamptz NOT NULL DEFAULT now(),
  updated_at timestamptz NOT NULL DEFAULT now(),
  last_attempted_at timestamptz
);

CREATE INDEX ON heretic_jobs (queue_name);
CREATE INDEX ON heretic_jobs (status);

CREATE FUNCTION heretic_updated_at_timestamp() RETURNS TRIGGER AS $$
BEGIN
  NEW.updated_at = now();
  RETURN NEW;
END;
$$ LANGUAGE 'plpgsql';

CREATE TRIGGER update_heretic_jobs_updated_at
  BEFORE UPDATE ON heretic_jobs
  FOR EACH ROW EXECUTE PROCEDURE heretic_updated_at_timestamp();
```

### Example

```js
import Promise from 'bluebird';
import Heretic from 'heretic';
import knex from 'knex';

const heretic = new Heretic('amqp://127.0.0.1', knex({
  client : 'pg',
  connection : 'postgres://127.0.0.1',
}));

heretic.process('my.job', function(job, message, done) {
  Promise.resolve()
    .then(() => {
      // do some processing or something. whatever you want!
    })
    .nodeify(done);
});

heretic.process('other.job', function(job, message, done) {
  setTimeout(() => {
    done(new Error('job failed'));
  }, 1000);
});

// the 'jobError' event happens when a job message is published in RabbitMQ that
// can never be handled correctly (malformed JSON, job id doesn't exist in the
// database, etc.). The message will be dead-lettered for later inspection (by you)
heretic.on('jobError', (err) => {
  console.error('Error with job!', err.stack);
});

// the 'jobFailed' event happens when a job fails, but in a recoverable way. it
// will be automatically retried up to the maximum number of retries.
heretic.on('jobFailed', (err) => {
  console.error('Job execution failed!', err.stack);
});

// enqueue a job
heretic.enqueue('email.send', {
  to : 'bob@example.com',
  body : 'Hi',
});
```
npm package: @smartrr/smartrr-ui
Description: A collection of ui-elements for smartrr web applications
Author: erockdotdev
Latest version: 0.2.2

# Smartrr UI

Lorem ipsum blah blah blah

Prereqs
  - tsc
  - node
  - npm account instructions (https://betterprogramming.pub/how-to-create-and-publish-react-typescript-npm-package-with-demo-and-automated-build-80c40ec28aca#a15d)

local development
linking and unlinking

https://dev.to/erinbush/npm-linking-and-unlinking-2h1g
cd in to dist npm link
npm unlink -g

# Getting Started

```bash
npm run qasdfasdf
```

✗ sudo npm rm --global @smartrr/smartrr-ui



TODO
- set up engine/node requirements
- storybook
- import aliasing
- add tests
- add husky for precommit tests to run
- semvar
  - automate semvar update
- lock dependency versions
- audit and update package straty
- go update repo and go through release flow again
- test that package can be installed and used through npm again

- prereqs
  - tsc
  - node


-- Add 3 ui components
-- add storybook
-- 



## Resources
[How to Create and Publish React TypeScript npm Package With Demo and Automated Build](https://betterprogramming.pub/how-to-create-and-publish-react-typescript-npm-package-with-demo-and-automated-build-80c40ec28aca#a15d)

[Semantic Versioning](https://www.freecodecamp.org/news/semantic-versioning-1fd6f57749f7/)

[Creating and publishing public packages](https://docs.npmjs.com/creating-and-publishing-scoped-public-packages)

[Creating and publishing private packages](https://docs.npmjs.com/creating-and-publishing-private-packages)

[Creating a React Component Library by Abstracting a React Component Library](https://benjaminwfox.medium.com/creating-a-react-component-library-by-abstracting-a-react-component-library-45290114d22a)

[Material-UI theme not working in shared-component](https://stackoverflow.com/questions/69072004/material-ui-theme-not-working-in-shared-component)

[Build a component library with React and TypeScript](https://blog.logrocket.com/build-component-library-react-typescript/) - includes storybook and tests & npm

[Hybrid NPM package through TypeScript Compiler (TSC)](https://dev.to/mbarzeev/hybrid-npm-package-through-typescript-compiler-tsc-150c)

[A step-by-step guide to building a shareable components library](https://www.devbridge.com/articles/a-step-by-step-build-to-build-a-sharable-components-library/)

THIS SORT OF WORKED!!!
[Unable to use a shared component library that uses material-ui ](https://github.com/mui/material-ui/issues/16862)