open-index/open-npm huggingface dataset:
npm package: @pubcore/generator-storybook-mui
Description: generates storybook with material-ui
Author: pubcore
Latest version: 1.5.0

## generates storybook with material-ui and styled components

The generated storybook can be used to develop, test, review and find
react components which, once exported in index.js, can be directly imported in
some react app. Corresponding app(s), which depends on this package, should be
part of a npm workspaces setup.

If apps are build with Unidirectional Data Flow paradigm, this can help to segregate
usage of local state (e.g. by react useState hook): It will not (or rarely)
occure within app's code.

Also styling efforts will not (or rarely) occure in app's code.

The code of app's views is more focused on behaviour.

#### localization

i18next and [react-i18next](https://react.i18next.com) is used for localization

#### prerequisite

- git
- latest node and npm

#### usage

1. Change into you scope directory, where your packages (of corrsesponding scope) are.
2. Create a directory with name of your package. Convention is lower case and
   hyphen-separated, for instance "your-package-name":

```
mkdir your-package-name
```

3. Change into this directory

```
cd your-package-name
```

4. Create the scaffolding. You will be asked for some global settings, which will
   be saved in package.json:

```
npx -p @pubcore/generator-storybook-mui -p yo yo @pubcore/storybook-mui
```

5. start storybook, If TLS is required (https), enable it in .env file

```
npm start
```

#### References

- https://medium.com/encode/setting-up-storybook-with-material-ui-and-styled-components-5bdacb6db866
- [storybook decorator, preview.js](https://storybook.js.org/docs/addons/introduction/)
- https://material-ui.com/guides/interoperability/
  https://yeoman.io
- [uniderectional data flow](<https://en.wikipedia.org/wiki/Unidirectional_Data_Flow_(computer_science)>)
npm package: @pubcore/generator-ui
Description: create ui package scaffolding
Author: pubcore
Latest version: 1.6.3

[![Build Status](https://travis-ci.org/pubcore/generator-ui.svg?branch=master)](https://travis-ci.org/pubcore/generator-ui)

## Commandline tool to scaffold a new user interface component

### Prerequisites
* latest version of nodejs
* latest version of npm
* optional (Install will succeed without this, too):  
@pubcore/node-composition installed and context_path is added in config.json

### It will create/setup minimum package structure to support
* eslint
* transpiler for ECS6 with spread operator
* webpack for bundeling js and css
* react
* redux

### Install it global
	npm install -g yo @pubcore/generator-ui

### How to use
1) create a directory (convention lower case and dash-separated)

		mkdir new-project

2) and change into it

		cd new-project

3) execute

		yo @pubcore/ui
npm package: @pubcore/gitlab-event-receiver
Description: pubcore component to support gitlab webhooks
Author: pubcore
Latest version: 1.1.4

## Pubcore component to receive gitlab webhooks
This package can be used in context of @pubcore/node-composition.

#### Prerequisites
* latest versions of nodejs installed
* knowledge of expressjs

#### Example usage in context of a @pubcore/node-composition

	import {login, resources, gilabEvent} from '@pubcore/gitlab-event-receiver'

	//process gitlab event data
	const process = ({gitlabEvent, package_scope, package_name}) =>  
		new Promise((res, rej) => {... do something with given data ...})

	export default {
		login,
		resources,
		public:false,
		http: [
			{
				routePath: '/',
				map: gitlabEvent(process),
				method: 'POST',
				accepted: ['application/json']
			}
		],
		webhook_secret_path:'/path/to/authentication/token',
		config_module:'/path/to/compositions/domains/example.com/config.js'
	}


#### Tested features

	default export "pubcore component object" express middleware
	✓ denies access, without valid token
	✓ respond valid http

	named exports
	✓ login
	✓ gitlabEvent
	✓ resources

	gitlabEvent function returning express middleware
	✓ uses "processEvent" function to process gitlab event
	✓ creates middleware, which does create valid http resonse

	resources loader
	✓ loads secret for webhook
	✓ rejects, if load failes
npm package: @pubcore/http-client
Description: http client based on axios
Author: pubcore
Latest version: 2.6.1

## http request promise (based on axios http client)

#### Install

	npm i --save @pubcore/http-client

#### Example

	import request from '@pubcore/http-client'

	//a get request
	request({uri:'https://example.com', query:{id: 42}}).then(
		result => {
			//do something with result ...
		},
		err => {
			//do someging with error ...
		}
	)

	//post some json, with basic auth
	request({uri:'https://example.com', method:'post', username:'foo', password:'...', data:{name:'T-Bone'}, query:{id:42}}).then(
		res => {
			//show feedback
		},
		err => {
			//do someging with error ...
		}
	)


#### Features (test descriptions)

	✓ defaults to method get and accept application/json
	✓ rejects to {code:"REQUEST_ERROR", ...}, e.g. on timeout
	✓ rejects 4xx or 5xx to {code:"HTTP_ERROR", ...} (this is expected, not an exception)
	✓ serializes query params in "qs" package default format
	✓ has "authorization" argument to forward authentication
	✓ exports function to create basic-auth value for "authorization" agrument
	✓ has usernaame, password arguments for basic authentication
	✓ has userAgent argument to define own one
	✓ has "data" argument, treated as json (default) for post and put
	✓ has "contentType" argument, if set to "urlEncoded" data is converted accordingly
	✓ supports optional headers
	✓ "__Host-Csrf-Token" cookie is forwarded via HTTP header "X-Csrf-Token" for POST, PUT and DELETE requests

#### rejected error object

Example if request failed (no response exists)

	{
		code:'REQUEST_ERROR',
		details: {
			message: 'timeout',
			uri: 'https://example.com/foo?id=12',
			method: 'get'
		}
	}

Example if request succeeded, but there is a http error (response exists)

	{
		code:'HTTP_ERROR',
		details:{
			body:{status:{code:'ERROR'}},
			headers:{'content-type': 'application/json'},
			message:'Request failed with status code 500',
			status:500,
			method:'get',
			uri:'https://www.example.com/500'
		}
	}

#### If there is a response, the promise is resolved to following result object
Example for "json" response:

	{
		status: 200,
		headers: {'Content-Type': 'application/json' //,...}
		body: {foo: bar}
	}

#### References
[CQRS protection](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html)
["__Host-" cookie prefix](https://tools.ietf.org/html/draft-west-cookie-prefixes-05)
npm package: @pubcore/knex-auth
Description: Functions to persist authentication state to a RDMS via knex
Author: pubcore
Latest version: 1.0.11

## Functions to persist authentication state to a RDMS via [knex](https://knexjs.org)

#### DDL
		CREATE TABLE `user` (
		`pk` int(10) unsigned NOT NULL AUTO_INCREMENT,
		`username` varchar(50) NOT NULL,
		`password` varchar(255) NOT NULL,
		`password_secondary` varchar(255) DEFAULT NULL,
		`password_expiry_date` datetime DEFAULT NULL,
		`login_expiry_date` datetime DEFAULT NULL,
		`created_time` datetime DEFAULT NULL,
		`deactivate` varchar(3) NOT NULL DEFAULT 'no',
		`password_new` varchar(64) DEFAULT NULL,
		`last_login` datetime DEFAULT NULL,
		`type` enum('HUMAN','SYSTEM') NOT NULL DEFAULT 'HUMAN',
		`login_failed_count` int(10) unsigned DEFAULT 0,
		`last_login_failed` datetime DEFAULT NULL,
		PRIMARY KEY (`pk`),
		UNIQUE KEY `unique_1` (`username`)
		) ENGINE=InnoDB DEFAULT CHARSET=utf8
npm package: @pubcore/knex-create-test-db
Description: helper for unittest to create database table with knex
Author: pubcore
Latest version: 1.1.13

## Helper to create on-the-fly sql database tables to test knex with mocha

#### Prerequisite
* mocha used for tests
* knex used for database (RDMS) persitence functions to test

#### Example
```
import {expect} from 'chai'
import createKnex from '@pubcore/knex-create-test-db'

var rows = [
    {author:'king', published:new Date(), sold:42}
  ],
  table = 'books',
  dbTypes = {author:'string', published:'dateTime', sold:'integer'}

describe('create test db', () => {
  //The test table will be created and droped for each "it" ("beforeEach" callback)
  //Knex will be destroyed after "describe" block finished ("after" callback)

  var knex = createKnex({table, rows, beforeEach, after, dbTypes})

  it('can be used to test some functionality dealing with a knex api', () => {
    expect( bookAvailable({author:'king'}, {db:{knex}}) ).to.be.true
  })
})
```
npm package: @pubcore/logger
Description: log to stdout with some basic info like loglevel, timestamp or filename
Author: pubcore
Latest version: 1.2.5

## simple log to stdout

## install
npm i --save @pubcore/logger

## examples
```
const {info} = require('@pubcore/logger')
var x = {foo:'bar'}
info('X=', x)
//will produce this output to stdout:
2020-01-24T20:25:05+0000 @myScope/package [1536,,41930752] INFO [file.js:3] X={"foo":"bar"}
//      timestamp           component      [pid,,memory]  level [file:line] log string object
```
configuration example
```
// log.js
const {log} = require('@pubcore/logger')
module.exports = log({component:'@initScope/init-package'})
```
```
// use configured logger somewhere in the project
const {debug} = require('./log')
debug('test log')
2020-03-04T13:57:14+0000 @initScope/init-package [2189,,41851849] DEBUG [file.js:3] test log
```


## available log level
var {debug, info, notice, warning, error, emergency} = require('@pubcore/logger')
npm package: @pubcore/node-docker-build
Description: Scripts to build and deploy pubcore compositions
Author: pubcore
Latest version: 3.7.1

## functions to build and deploy to a docker swarm, based on configuration

#### Prerequisites
* latest docker installed (deamon is running and docker-compose does work)
* latest nodejs/npm installed
* git client installed
* ssh access (optional over jump host) to deployment target, docker manager host

#### Configuration example: domain-config module (config.js)
```
'use strict'

module.exports = {
	baseImage:'node:10.15.1-alpine'
	compositions:['test'], //compostions of subdomains e.g. test.example.com
	target:{ //optional, target system (deploy)
		host:{host:'manager.example.com', key:'/home/admin/.ssh/id_rsa', user:'admin'},
		jump:{host:'connect.example.com', key:'~/.ssh/id_rsa', user:'admin'},
		home:'/home/admin',
		stackName: 'example',
		sudo:false //optional, prepend "sudo", if required for docker commands
	},
	configs:{ //optional, will be transfered to create docker config (deploy)
		'verdaccio-conf-v2':'verdaccio/conf/config.yaml'
	},
	detach: true //optional, if false std-out/-err is piped to current shell,
	push: true //optional, if false no docker-compose push will be executed,
	update: false //optional, if true "npm update" is used, else "npm install",
	forcePull: false //optional, if true --pull flag is set for docker build,
	buildKit: false //optional, if true docker build kit is enabled for build,
	retryOptions: {retries:1, minTimeout:30000} //retry options for updatePackages
}
```

#### Examples
1) In context of an CI/CD server:
Build, push and deploy some images on a dev system composition (dev.example.com)
Execution is done in background (spawn a script).
If there is already running one, it will be killed.
Output is piped to file within defined "logPath".
```
import {buildDeploy} from '@pubcore/node-docker-build'

buildDeploy({
	repo:'git@github.com:your-scope/compositions.git',
	domain:'dev.example.com',
	logPath:'~/'
})
```

In context of local compositions package, on developers machine:
Build and push some images of a domain.
Execution runns in foreground (detach=false), stdout to console
```
const {build} = require('@pubcore/node-docker-build')
build({
	configModule: resolve(__dirname, 'domains', 'host.docker.internal' , 'config'),
	detach: false,
})
```
npm package: @pubcore/node-server-docker
Description: express based http server
Latest version: 2.1.0

## Package to create an Node.js web server based on express
The package's purpose is to offer a foundation for express based web apps,
with general, none functional behaviour regarding security, logging and
performance beeing integrated.

### install
```
npm i @pubcore/node-server-docker
```

### Example
```
'use strict'
const {app} = require('@pubcore/node-server-docker')
app.use((req, res) => res.send('Hello world!'))
```

### Configuration environment variables with (default) value
* APP_PORT (0)  
Application's ports
* NODE_ENV (production)  
Type of environment, either 'development' or 'production'
* RATE_WIN (3000), RATE_MAX (300)  
Rate limit values, see https://www.npmjs.com/package/express-rate-limit
* TLS_KEY_DIR (/run/secrets)  
Path to the place where the TLS (SSL) key files for used domain are located.
Required files: ssl-key, ssl-cert, ssl-dhparam
* TLS_KEY_SOURCE (FILES)  
If set to "devcert" and corresponding npm package is installed, it is used to
auto-generate a selfsigned certificate for localhost. Only in development mode
possible (NODE_ENV == "development").
* TOOBUSY_ENABLED (0), TOOBUSY_MAX_LAT (300), TOOBUSY_INTERVALL (1500)  
https://www.npmjs.com/package/toobusy-js
* HTTP (false)  
If set to "true" TLS is disabled (not recommended)  
* ACCESS_LOG_ENABLED (true)  
If set to "false" access log of requests is disabled.

### Health check via HEAD request to /healthcheck
npm package: @pubcore/pubcore-react-datatable
Description: stateless react components for HTML tables
Latest version: 1.0.2
Deprecated: this package has been deprecated

## Stateless react components to render HTML tables

### Installation

	npm install --save pubcore-react-datatable

### Examples

	import Datatable from 'pubcore-react-datatable'

	const rows = [
		{a:'11', b:'12'},
		{a:'21', b:'22'}
	],
		cols = ['a', 'b']

	//table without head row
	<Datatable {...{rows}}/>

	//table with head row, columns order based on "cols"
	<Datatable {...{rows, cols}}/>

## customize table view

	//some more components to import
	import Datatable, {Head, HeadRow, Cell, Body, Row} from 'pubcore-react-datatable'

	//table with individual header row(s)
	<Datatable {...{rows, cols}}>
	    <Head>
	        <HeadRow>{({col}) =>
	            <Cell key={col}>
	                {col} <button onClick={e => alert('info')} type="button">i</button>
	            </Cell>
	        }</HeadRow>
	        <HeadRow {...{cols:cols.map((col, i) => i)}}/>
	    </Head>
	</Datatable>

	//change view of column's data
	<Datatable {...{rows, cols}} >
	    <Body>
	        <Row>{({col, row}) => ({'b' :
	            <Cell data={(new Date(row[col])).toLocaleDateString()} key={col}/>
	            }[col] ||
	            <Cell key={col} data={row[col]}/>
	        )}</Row>
	    </Body>
	</Datatable>
npm package: @pubcore/react-datatable
Description: stateless react components for HTML tables
Latest version: 1.3.4

[![Build Status](https://travis-ci.org/pubcore/reactDatatable.svg?branch=master)](https://travis-ci.org/pubcore/reactDatatable)

## Stateless react components to render HTML tables

### Installation

	npm install --save @pubcore/react-datatable

### Examples

	import Datatable from '@pubcore/react-datatable'

	const rows = [
		{a:'11', b:'12'},
		{a:'21', b:'22'}
	],
		cols = ['a', 'b']

	//table without head row
	<Datatable {...{rows}}/>

	//table with head row, columns order based on "cols"
	<Datatable {...{rows, cols}}/>

## customize table view

	//some more components to import
	import Datatable, {Head, HeadRow, Cell, Body, Row} from '@pubcore/react-datatable'

	//table with individual header row(s)
	<Datatable {...{rows, cols}}>
	    <Head>
	        <HeadRow>{({col, isHead, key}) =>
	            <Cell {...{key, isHead}} >
	                {col} <button onClick={e => alert('info')} type="button">i</button>
	            </Cell>
	        }</HeadRow>
	        <HeadRow {...{cols:cols.map((col, i) => i)}}/>
	    </Head>
	</Datatable>

	//change view of column's data
	<Datatable {...{rows, cols}} >
	    <Body>
	        <Row>{({col, row, index, key}) => ({'b' :
	            <Cell {...{data:(new Date(row[col])).toLocaleDateString(), key}}/>
	            }[col] ||
	            <Cell {...{data:`# ${index}`, key}}/>
	        )}</Row>
	    </Body>
	</Datatable>
npm package: @pubcore/redux-browser-history
Description: maintain browser URI in state in redux style
Author: pubcore
Latest version: 1.1.6

Maintain browser's URI in state based on redux  

## Prerequisites
* Knowledge of redux-actions and -reducers
* thunk-middleware is applied to redux-store

## Features
* Supports arbitrary sliceKey (default is "uri")  
* Supports base-path, initialized by a carrier on import of reducer  
* Updates state, if browser-uri changes  
* Offers action to update browser's URI and/or query params  
* Offers param "replace", if true history's "replaceState" is used.
* Adds origin if needed for location.href  

## Example

#### State

	{
	 	uri:{
			basePath:'/todolist'
			subPath:'/items',
			query:{
				id: 1
			}
		}
	}

#### app's main

	import {createStore, combineReducers, applyMiddleware} from 'redux'
	import thunkMiddleware from 'redux-thunk'
	import uri, {listenUri, init} from '@pubcore/redux-browser-history'

	// optional, required if key is not 'uri' and not on first level of state
	// init({sliceKey:'ui.uri'})

	var {dispatch, getState} = createStore(combineReducers({
		uri
	}), {}, applyMiddleware(thunkMiddleware))

	//watch changes of browser's uri
	listenUri(dispatch)

#### action to navigate between app's screens

	import {updateUriAction} from '@pubcore/redux-browser-history'

	export default navigate = page => dispatch => {
		dispatch(updateUriAction({subPath: '/' + page}))
		//...
	}

#### update some query params
	import get from 'lodash.get'
	import {updateUriAction} from '@pubcore/redux-browser-history'
	//[...]

	const current = get(getState(), 'uri.query')
	//[...]

	//updateUriAction's query param must be "complete" => ther 's no merge
	updateUriAction({ query:{...current, id: 3} })

	// to remove all query params
	// updateUriAction({ query:{} })

	// to remove some query params, use "undefined"
	// updateUriAction({ query:{..current, foo: undefined, bar: undefined} })

	// to use history's replaceState (instead of pushState)
	// updateUriAction({ query:{}, replace:true})
npm package: @pubcore/redux-progressify
Description: progressify any promise and reduce progress to state
Author: pubcore
Latest version: 1.0.7


Simple, redux based way to maintain progress of asynchronous functions (promises).
Used in context of user-interfaces, this state can be used to show some "wait spinner".  

If there are further, nested progressified promisses, progress is increase by one
for each pending promise, and decrease by one for each resolved or rejected.

## Prerequisite
Knowledge of redux-actions and -reducers, usage of middleware for promises

## Example
#### progressify an asynchronous action

	import progressify from '@pubcore/redux-progressify'

	//assume we have a promise "loadSomeData"

	//We may implement an action the loadSomeData-promise is used in.
	//To get info about its progress within state, we just cover the
	//call with "progressify":
	export default dispatch => progressify(dispatch,
		loadSomeData.then(mapResult, mapError)
	)

#### reducer

	import {combineReducers} from 'redux'
	import {progress} from '@pubcore/redux-progressify'

	export default combineReducers({
		progress
	})

	//this will lead to this initial state:
	{
		progress: 0
	}
npm package: @pubcore/redux-slicify
Description: let work actions and reducers relative to a state-slice
Author: pubcore
Latest version: 1.0.6

Helper functions to create reducers and actions, which can be re-used multiple times within a state. The action-types will be prefixed by slice key (sk), where the slices has to be stored in.

## Prerequisite
Knowledge of redux-actions and -reducers

## Example

#### state

	{
		a:{},
		table:{
			page:0
		},
		anOtherTable:{
			page:0
		}
		b:{
			m:{
				page:0
			}
		}
	}

#### reducer

	import {createReducerSk, combineReducerSk} from '@pubcore/redux-slicify'

	//example slice reducer
	const page = (sk, initState=0) => createReducerSk(
		initState,
		{
			NEXT: (s, action) => s + action.step,
			BACK: (s, action) => s - action.step
		},
		sk
	)

	//slicified combined reducer, beware returning array
	const table = [sk => combineReducerSk(
		{
			page
		},
		sk
	)]

	//slicified root reducer
	export default combineReducerSk({
		a: s => s||{},     //trivial reducer
		table,
		anOtherTable: table,
		b:{
			m: table //table some where in state
		}
	})

#### action
	import slicify from '@pubcore/redux-slicify'


	const next = step => ({type:'NEXT', step})
	const back = step => ({type:'BACK', step})

	//let there be the redux "dispatch" function

	//this will change to next page of table in state.b.m
	dispatch( slicify('b.m', next(1)) )

	//and this will change to previous page of anOtherTable:
	dispatch( slicify('anOtherTable', back(1)) )
npm package: @pubcore/state
Description: access global state properties by dot-notation string
Author: pubcore
Latest version: 1.2.4

[![Build Status](https://travis-ci.org/pubcore/state.svg?branch=master)](https://travis-ci.org/pubcore/state)

### Access property of global state by dot-notation string

#### Install

	npm install --save @pubcore/state

#### How to use example, in context with a redux store

Initialization in main script is required

	import {setStore} from '@pubcore/state'

	//we expect a reduxStore has been created before
	setStore(reduxStore)

If we want to read a property of global State ...

	import S from '@pubcore/state'

	var book = S('room.shelf.b1')

	//returns undefined if a key does not exist
	S('key.does.not.exist') === undefined

Since 1.1.0 it uses lodash.get internal. You can now use same string notation like in lodash.get. Have a look at the [lodash documentation](https://lodash.com/docs/#get).
npm package: @pubcore/ui-asset
Description: supports developer synchronizing asset-keys used in source-code and default resource files
Author: pubcore
Latest version: 1.0.3

# Supports developer synchronizing asset-keys used in source-code and default asset.json file
Map asset keys to asset uris, returns asset uri..


# Configuration
```
import {initEnvIsDev, initDefaults, initAutoupdateDefaults} from '@pubcore/ui-asset'

//initial asset.json content is a empty json object {}
import defaultAsset from '../asset.json'

//if isDev is true then system will throw exceptions on wrong default data
initEnvIsDev(isDev)

// enables asset-key sync feature
initDefaults(defaultAsset)

// postUri points on a service which will write asset-key with asset uris to asset.json file
initAutoupdateDefaults({
	postUri:'/service/asset
})
```

## Examples
```
import uiAsset from '@pubcore/ui-asset'
var A = {
	logo:uiAsset(A,'logo','/image/logo.png'})
	keyvisual:uiAsset(A,'keyvisual','/image/keyvisual.png'})
}

//Will log /img/logo.png and if postUri service exists on dev will also write
//a default {logo:{uri:'/image/l.png'}} into asset.json file
console.log(
	uiAsset(
		A,
		'logo',
		{logo:{uri:'/image/l.png'} //default which will be written in asset.json file, only on dev system
	)
)
```
npm package: @pubcore/ui-resource
Description: supports developer synchronizing config-keys used in source-code and default resource files
Author: pubcore
Latest version: 1.0.4

# Supports developer synchronizing config-keys used in source-code and default resource files
Map resource keys to resource definition and returns resource json.
It can be used for config data.

# Configuration
```
import {initEnvIsDev, initDefaults, initAutoupdateDefaults} from '@pubcore/ui-resource'

//initial config.json content is a empty json object {}
import defaultConfig from '../config.json'

//if isDev is true then system will throw exceptions on wrong default data
initEnvIsDev(isDev)

// enables resource-key sync feature
initDefaults(defaultConfig)

// postUri points on a service which will write config-key with json data to config.json file
initAutoupdateDefaults({
	postUri:'/service/config
})
```

## Examples
```
import uiConfig from '@pubcore/ui-resource'
var C = {
	key1: {obj:'test'},
	key2: [4,5,6],
	key3: 'a,b,c'
}
//Will log [4,5,6] and if postUri service exists on dev will also write
//a default {key1:[1,2,3]} into config.json file
console.log(
	uiConfig(
		C,
		'key1',
		[1,2,3] //default which will be written in config.json file, only on Dev system
	)
)
```
npm package: @pubcore/vite-storybook-mui
Description: Storybook for react components based on MUI
Author: pubcore
Latest version: 0.27.1

## Storybook of MUI (Material-UI v5) based react components

- MUI (react)
- TypeScript
- react-hook-form
- i18nNext for localization
- eslint
- prettier (default settings)
- eslint for react-hooks
- pre-commit hook for linting
- vite build

#### Prerequistes

- node 14, 16
- npm 7, 8
- git client

#### Install

Note (2021-10-17)
Vulnarabilities shown after install are based on dependencies of storybook.
One opinion about this: https://overreacted.io/npm-audit-broken-by-design/

```
git clone git@github.com:pubcore/vite-storybook-mui.git && \
cd ./vite-storybook-mui && \
npm i && \
npm run storybook
```

#### Install as starting point for new project

Find a name for «your-project» in "Kebab case" (this-is-kebab-case). A directory
with this name will be created. Change into your scope/group directory and
execute commands below.
(npm version >= 7 is required to auto install peer dependencies)

```
# If `npx degit` does not work, just clone this repo and delete .git dir
npx degit pubcore/vite-storybook-mui «your-project»
cd «your-project»
git init && \
npm i && \
git add . && git commit -m "init" && \
npm run storybook
```

#### Build package bundle of components

```
npm run build
```

#### Watch: auto build, if code changes

```
npm run watch
```
npm package: @pubean/stylelint-config
Description: Stylelint shareable config for Pubean Inc.
Author: Pubean Inc.
Latest version: 0.7.0

# @pubean/stylelint-config

> Stylelint shareable config for Pubean Inc.

## Installation

```bash
# Install with npx
$ npx install-peerdeps --dev @pubean/stylelint-config
```