open-index/open-npm huggingface dataset:
npm package: @jenil94/plugin-sdk
Description: SDK for building Harness plugins with React
Latest version: 0.2.0

# @jenil94/plugin-sdk

SDK for building Harness plugins with React. Provides communication utilities, context management, and routing synchronization for plugins running in iframes.

## Installation

```bash
npm install @jenil94/plugin-sdk
```

## Peer Dependencies

This package requires the following peer dependencies:

- `react` (^18.0.0 || ^19.0.0)
- `react-dom` (^18.0.0 || ^19.0.0)
- `react-router-dom` (^6.0.0 || ^7.0.0)

## Usage

### Basic Setup

```tsx
import { PluginAPI, PluginContextProvider, PluginRouter } from '@jenil94/plugin-sdk'

// Initialize the plugin as early as possible
PluginAPI.init()

function App() {
  return (
    <PluginContextProvider>
      <PluginRouter>
        {/* Your app routes here */}
      </PluginRouter>
    </PluginContextProvider>
  )
}
```

### Using Plugin Context

```tsx
import { usePluginContext } from '@jenil94/plugin-sdk'

function MyComponent() {
  const context = usePluginContext()

  if (!context) {
    return <div>Loading...</div>
  }

  return (
    <div>
      <p>Theme: {context.theme}</p>
      <p>Location: {context.location}</p>
    </div>
  )
}
```

### Proxy Fetch (for authenticated API calls)

```tsx
import { PluginAPI } from '@jenil94/plugin-sdk'

async function fetchData() {
  const response = await PluginAPI.proxyFetch('/api/some-endpoint')
  const data = await response.json()
  return data
}
```

## API Reference

### PluginAPI

Static class for communication with the host application.

- `PluginAPI.init()` - Signals to the host that the plugin is ready
- `PluginAPI.getContext()` - Retrieves the current plugin context
- `PluginAPI.proxyFetch(url, init?)` - Proxies fetch requests through the host

### PluginContextProvider

React context provider that manages plugin context state.

### usePluginContext()

Hook to access the current plugin context.

### PluginRouter

Router component that synchronizes with the parent page's URL.

### useParentRoutingSync()

Hook for manual route synchronization with the parent page.

## Development

```bash
# Install dependencies
npm install

# Build the package
npm run build

# Watch mode
npm run dev
```

## License

MIT
npm package: @jenil_121/ga-bridge
Description: Twinalyze GA Bridge (GA → Twinalyze event forwarding)
Author: jenil
Latest version: 1.0.8

# Twinalyze GA Bridge

A lightweight bridge to forward Google Analytics (`gtag.js`) events to Twinalyze automatically.

This allows you to use Google Analytics as the source of truth and mirror the same events into Twinalyze without modifying existing tracking code.

---

## 🚀 Features

- Forward GA events (`gtag('event', ...)`) to Twinalyze
- Uses **GA callback-based forwarding** 
- Ensures:
  - If GA event succeeds → Twinalyze receives it
  - If GA event fails → Twinalyze does NOT receive it
- No fallback (strict dependency on GA)
- Automatic installation
- Debug mode support
- Adds `__from_bridge: true` flag to all forwarded events

---

## 📦 Installation

### CDN (Recommended)

```html
<script src="https://cdn.jsdelivr.net/npm/@jenil_121/ga-bridge@1.0.8/dist/twinalyze-ga-bridge.min.js"></script>
npm package: @jenjs/preactsc
Description: Preact Server Components - Standalone implementation
Latest version: 0.1.0

# Preact Server Components (PRSC)

A standalone Node.js tool for building Preact applications with server and client component separation.

## Quick Start

```bash
npm install
npm run example:build
npm run start
```

Visit `http://localhost:3000`

## CLI

### `preactsc dev <entry.server.jsx>`

Start dev server with hot reload.

```bash
preactsc dev src/App.server.jsx
```

### `preactsc build <entry.server.jsx> --out <dir>`

Build for production.

```bash
preactsc build src/App.server.jsx --out dist
```

### `preactsc start <outdir>`

Run production build.

```bash
preactsc start dist
```

## File Conventions

- `.server.jsx` - Server-only components (can use fs, db, secrets)
- `.client.jsx` - Client-only components (can use hooks, events)

Server components can import client components.
Client components cannot import server components or Node modules.

## Example

See `examples/app/` for a working example.

```jsx
// App.server.jsx
import Counter from "./Counter.client.jsx";

export default function App() {
  return (
    <div>
      <h1>Hello PRSC</h1>
      <Counter initial={5} />
    </div>
  );
}
```

```jsx
// Counter.client.jsx
import { useState } from "preact/hooks";

export default function Counter({ initial }) {
  const [count, setCount] = useState(initial);
  return <button onClick={() => setCount(count + 1)}>Count: {count}</button>;
}
```

## Architecture

- `src/cli/` - CLI command handling
- `src/compiler/` - Component analysis and bundling
- `src/runtime/` - Server and client runtime
- `src/server/` - Dev and production servers
- `src/shared/` - Shared utilities
npm package: @jenjs/types
Description: TypeScript type definitions for Jen.js framework
Author: Jen.js Contributors
Latest version: 1.7.0

# @types/jenjs

TypeScript type definitions for [Jen.js](https://github.com/kessud2021/Jen.js).

Jen.js is a TypeScript-first framework for building static and server-rendered applications with Preact.

## Installation

```bash
npm install --save-dev @types/jenjs
```

## Type Definitions

This package provides comprehensive TypeScript type definitions for:

- **Core Configuration**: `FrameworkConfig`, `RenderMode`
- **Route System**: `RouteModule`, `LoaderContext`, `RouteEntry`
- **Middleware**: `Middleware`, `MiddlewareContext`, `RouteMiddleware`
- **API Routes**: `ApiRouteModule`, `ApiRouteContext`, `ApiHandler`
- **Build System**: `SSGPipeline`, `ProductionBuilder`, `PageRenderer`
- **Islands Architecture**: `Island`, `IslandRegistry`
- **Authentication**: JWT and Session types
- **Database**: Unified DB interface (JDB, SQLite, MySQL, PostgreSQL)
- **Caching**: In-memory and Redis cache store interfaces
- **GraphQL**: Schema and resolver types
- **i18n**: Internationalization configuration
- **Plugins**: Plugin system types
- **Runtime**: Client-side hydration and SSR types

## Example

```typescript
import type {
  FrameworkConfig,
  RouteModule,
  ApiRouteModule,
  LoaderContext,
} from "jenjs";

// Route module with loader
export const loader: RouteModule["loader"] = async (ctx: LoaderContext) => {
  return { message: "Hello" };
};

export default function Page({ data }: { data: any }) {
  return <div>{data.message}</div>;
}

// API route
export const GET: ApiRouteModule["GET"] = async (ctx) => {
  return { message: "API response" };
};
```

## References

- [Jen.js Documentation](https://github.com/kessud2021/Jen.js)
- [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped)

## License

MIT
npm package: @jenk-jack/edu-test-cli-one
Description: 第一个单简脚手架
Author: 张建
Latest version: 1.0.2


<!-- toc -->
* [Usage](#usage)
* [Commands](#commands)
<!-- tocstop -->
# Usage
<!-- usage -->
```sh-session
$ npm install -g @geekymedic/cli
$ gkm COMMAND
running command...
$ gkm (-v|--version|version)
@geekymedic/cli/0.0.5 win32-x64 node-v10.16.3
$ gkm --help [COMMAND]
USAGE
  $ gkm COMMAND
...
```
<!-- usagestop -->
# Commands
<!-- commands -->
* [`gkm help [COMMAND]`](#gkm-help-command)
* [`gkm new [PROJECTNAME]`](#gkm-new-projectname)

## `gkm help [COMMAND]`

display help for gkm

```
USAGE
  $ gkm help [COMMAND]

ARGUMENTS
  COMMAND  command to show help for

OPTIONS
  --all  see all commands in CLI
```

_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v2.2.1/src\commands\help.ts)_

## `gkm new [PROJECTNAME]`

create new project

```
USAGE
  $ gkm new [PROJECTNAME]

OPTIONS
  -f, --force
  -h, --help   show CLI help
```
<!-- commandsstop -->
npm package: @jenkins-cd/blueocean-pipeline-editor
Description: Pipeline editor plugin for Jenkins Blue Ocean
Author: Josh McDonald
Latest version: 1.0.0-alpha.1

# Blue Ocean Pipeline Editor

This repository houses the [Jenkins](https://jenkins.io/) plugin for creating and editing Pipeline jobs within the [Blue Ocean](https://jenkins.io/projects/blueocean/) user interface.

![Pipeline Editor Screenshot](doc/editor-ss.png)

:exclamation: **Important!** This software is a work-in-progress and is not complete.

## Running Locally

To start a new jenkins and run this plugin for development purposes:

```
# Start a local Jenkins
mvn hpi:run
```

And in another term,
```
# Watch and build the JS
npm run bundle:watch
```


## Running in another development Jenkins Instance

```
# Link this as a plugin into your Blue Ocean Jenkins' hpi:run server
mvn hpi:hpl -DjenkinsHome=<path-to-blueocean-home/blueocean/work>
```
npm package: @jenkins-cd/blueocean-web
Description: This module mostly contains middleware for serving up "/blue" GUI. In general, you shouldn't need to modify stuff in for plugins or features as it is infrastructure. Move along.
Latest version: 1.0.0-alpha.1

# Web middleware

This module mostly contains middleware for serving up "/blue" GUI.
In general, you shouldn't need to modify stuff in for plugins or features as it is infrastructure. Move along.

Look for blueocean.js for excitement.

## how this works with Javascript

All runtime JavaScript artifacts are generated during the build and added to the plugin HPI.

If you wish to make JavaScript changes during development and have them picked while using the HPI plugin (`mvn hpi:run`),
then you will need to run `npm run bundle` after each change. Alternative, you can run `npm run bundle:watch` to "watch"
for changes and automatically run `npm run bundle`. This applies to all Blue Ocean modules/plugins.
npm package: @jenkins-cd/design-language
Description: Styles, assets, and React classes for Jenkins Design Language
Author: Josh McDonald
Latest version: 1.10.4

# Jenkins Design Language (JDL)

Reusable [React] components and design elements that adhere to the Jenkins Design Language (Blue Ocean edition).

## Developing
```
npm install
npm run gulp
npm run build-storybook
npm run site-server
```

> License is MIT. Other licenses in /licenses

__[Docs Site](http://jenkinsci.github.io/jenkins-design-language/docs)__
npm package: @jenkins-cd/diag
Description: Jenkins client-side diagnostics
Author: Tom Fennelly
Latest version: 0.0.2

# Jenkins client-side Diagnostics
 
## Installation

```
npm install --save @jenkins-cd/diag
```

## logger(category)
Get a `LOGGER` for the specified category.

```javascript
var LOGGER = require('@jenkins-cd/diag').logger('sse');
 
// Log messages etc . See below.
```

### error(message [, other-args])

```javascript
var LOGGER = require('@jenkins-cd/diag').logger('sse');

LOGGER.error('Invalid SSE event message format.', event);
```

Error logs are always logged, so no configuration needed here.

### debug(message [, other-args])

Currently, this module uses the [enabled] package for logging debug messages.

> __NOTE__: One slight terminology difference between this package and the [enabled] package is that this package uses the term "category" (log "category") where [enabled] uses the term "namespace"/"name". Aside from that, everything else is the same.

```javascript
var LOGGER = require('@jenkins-cd/diag').logger('sse');

LOGGER.debug(`SSE event ${event.jenkins_channel}/${event.jenkins_event}:`, event);
```

Please see the [enabled] (and [env-variable]) docs for how to turn on/off debug logging in the Browser.

### isDebugEnabled()

Returns true if debug logging is enabled for the category associated with the logger instance.
 
[enabled]: https://www.npmjs.com/package/enabled
[env-variable]: https://www.npmjs.com/package/env-variable
npm package: @jenkins-cd/es-extensions-api
Description: > Provides an extension API for es5+ applications.
Latest version: 0.0.4

# ES Extensions API
> Provides an extension API for es5+ applications.

[![npm version](https://badge.fury.io/js/%40imeredith%2Fes-extensions-api.svg)](https://badge.fury.io/js/%40imeredith%2Fes-extensions-api)


One to two paragraph statement about your product and what it does.

![](header.png)

## Installation

```sh
npm i -S @imeredith/es-extensions-api
```


## Usage example

### Registering an Extension
```javascript
import { ExtensionStore } from '@imeredith/es-extensions-api';

ExtensionStore.register('extensionPointId', function (context) {
    // Do whatever.
})

```

## Development setup

```sh
npm i
```

## Release History

* 0.0.3
    * Work in progress

## Meta

Distributed under the MIT license. See ``LICENSE`` for more information.
npm package: @jenkins-cd/es-extensions-store
Description: > Provides an extension API for es5+ applications based on Jenkins [JEP-204](https://github.com/jenkinsci/jep/tree/master/jep/204)
Latest version: 0.5.0

# ES Extensions API
> Provides an extension API for es5+ applications based on Jenkins [JEP-204](https://github.com/jenkinsci/jep/tree/master/jep/204)

[![npm version](https://badge.fury.io/js/%40imeredith%2Fes-extensions-api.svg)](https://badge.fury.io/js/%40imeredith%2Fes-extensions-api)

## Installation

```sh
npm i -S @imeredith/es-extensions-api
```


## Usage example
Extensions are just functions that take some context as a parameter, and do something. It is totally up to the application that wants to use extensions implemented by plugins to define the contract for the plugins to implement.


### Example extension

* Extension Point identifier - 'example.ext'
* Extension Context
  * container - Html Div element to render into.
  * name - Name to render

#### Example Extesnion Impl
```javascript
import { ExtensionStore } from '@imeredith/es-extensions-api';

ExtensionStore.register('example.ext', function (context) {
    context.container.innerHTML = '<h1> Hello ' + context.name + '</h1>';
})
```

#### Example Extension Usage 
```javascript
import stores from '@imeredith/es-extensions-api';

const container = document.getElementbyId('ext_container');

const extension = ExtensionStore.getExtensions('example.ext')[0]
if(extension) {
    extension({container, name: 'World!'})
}
```

## Development setup

```sh
npm i
```

## Release History

* 0.0.3
    * Work in progress

## Meta

Distributed under the MIT license. See ``LICENSE`` for more information.
npm package: @jenkins-cd/eslint-config-jenkins
Description: Jenkins JavaScript ESLint configuration
Author: Tom Fennelly
Latest version: 0.0.2

[ESLint](http://eslint.org/) configurations for Jenkins JavaScript projects.

We are hoping that people will try taking these and using them as they are. It would be nice
for all Jenkins related JavaScript code to follow the same standards as much as possible.

> __Note__: If using `@jenkins-cd/js-builder`, there's typically no need to specify a `.eslintrc` file. `@jenkins-cd/js-builder` will automatically lint using one of the following configurations, using the builder instance `lang` setting (default `es6`), or will use `react` if it detects `.jsx` files in the builder source paths. 

# ES6

`.eslintrc`:
```javascript
{
    "extends": "@jenkins-cd/jenkins/es6"
}
```

> __Note__: Applied by default if using `@jenkins-cd/js-builder` i.e. no need to specify the `.eslintrc` file. 

# ES5

`.eslintrc`:
```javascript
{
    "extends": "@jenkins-cd/jenkins/es5"
}
```

> __Note__: Applied by `@jenkins-cd/js-builder` if the builder instance lang is `es5` (`builder.lang('es5')`). 

# React

`.eslintrc`:
```javascript
{
    "extends": "@jenkins-cd/jenkins/react"
}
```

> __Note__: Applied by `@jenkins-cd/js-builder` if the builder instance lang is `react` (`builder.lang('react')`), or if `.jsx` files are detected in any of the source paths.
npm package: @jenkins-cd/js-builder-jest
Description: Adds support for running tests with Jest via Jenkins js-builder
Author: Cliff Meyers
Latest version: 0.0.4

# Jest support for Jenkins JS Builder

Run your tests with Jenkins JS Builder using the "Jest" test runner.

# Setup

1. Add a gulpfile with the following line:

    `const jsb = require('@jenkins-cd/js-builder');`

2. Install the `@jenkins-cd/js-builder-jest` dependency.

3. Setup npm scripts

    It is convenient to invoke js-builder-jest via npm scripts. Add the following to the "scripts" block in package.json:

    ```
    "test": "gulp test",
    "test:fast": "gulp test:fast",
    "test:debug": "node --debug-brk ./node_modules/.bin/gulp test:debug",
    ```

# Defaults

The default location for tests is the `test` folder. This can be overridden by calling `builder.tests(<new-path>` in the gulpfile.

The file names need to match the pattern `*-spec.js` or `*-test.js`; the `jsx` extension is also supported.

# 'test' Task

Run the tests and produces test and coverage reports.

You can limit the tests that are run via the `test` parameter. This is a pattern that is passed to Jest's [testPathPattern](https://facebook.github.io/jest/docs/cli.html#testpathpattern-regex) CLI parameter.

JUnit test reports are stored in `target/jest-reports/` and coverage reports in `target/jest-coverage/`.
Note that coverage is only measured for .js and .jsx files in the source directories (default: `src`).

# 'test:fast" Task

```
npm run test:fast
```

Runs the tests but skips generation of reports and coverage. 
This is good for local development.

# 'test:debug' Task

```
npm run test:debug
```

Runs the tests in debug mode on default port 5858.
Test execution will be paused until the debugger is attached and execution is resumed.

# Running specific tests

Run a single test.

```
npm run test -- --test test/src/js/foo/bar/foobar-spec
```

Runs any test with 'calculator' in the path or name.

```
npm run test -- --test calculator
```

Run any test inside of a 'math' folder.

```
npm run test -- --test /math/
```

# Using custom configuration

## Jest configuration

Jest's command line runner supports custom configuration placed in a ["jest" property in package.json](https://facebook.github.io/jest/docs/configuration.html#content). `js-builder-jest` will automatically add these configuration options if they are defined.

## Jest CLI Options

Jest also supports [useful CLI options](https://facebook.github.io/jest/docs/cli.html#options). These can be used in two ways:

### In npm scripts

```
"test:fast": "gulp test:fast --updateSnapshot",
```

### From command line

```
npm run test:fast -- --updateSnapshot
```

Note the double dash above.
npm package: @jenkins-cd/js-test
Description: NPM module containing JavaScript utilities for testing Jenkins CI modules.
Author: Tom Fennelly
Latest version: 1.2.3

# Jenkins JS Test

This package provides some test utilities.

Install Package:

```
npm install --save-dev @jenkins-cd/js-test
```

> Also see [js-modules] and [js-builder].

# onPage
This utility allows you to test some content using [jsdom] (a lightweight "headless" browser).

Here's an example from the [Twitter Bootstrap](https://github.com/jenkinsci/js-libs/tree/master/bootstrap) [Framework lib].

```javascript
var jsTest = require("@jenkins-cd/js-test");

var JENKINS_PAGE = '<html><head resURL="/jenkins"></head><body><div id="divOnPage">Bootstrap is everywhere</div></body></html>';

describe("bootstrap3.js", function () {

    it("- test", function (done) {
        jsTest.onPage(function() {
            var bootstrap3 = require("../js/bootstrap3");
            var $bootstrap = bootstrap3.getBootstrap();

            expect($bootstrap('#divOnPage').text()).toBe('Bootstrap is everywhere');
            
            done();
        }, JENKINS_PAGE);
    });
});
```

> Note the call to `done();`. This is a [Jasmine] "thing". It marks the end of an async test flow.

# requireSrcModule
This utility makes it a bit easier to load the modules under test.

Without using `requireSrcModule`, tests would need to load source modules in an ugly/brittle path
(like in the above Bootstrap example) e.g.

```javascript
var mathUtil = require('../../../src/js/utils/mathUtil');
```

Using `requireSrcModule`, the above code would be:
 
```javascript
var jsTest = require("@jenkins-cd/js-test");

var mathUtil = jsTest.requireSrcModule('utils/mathUtil');
```

> NOTE: This is integrated with [js-builder]. It will resolve the module being `require`d based on [src/test builder configuration](https://github.com/jenkinsci/js-builder#setting-src-and-test-spec-paths).
  
# Examples
See the examples in [js-samples](https://github.com/jenkinsci/js-samples), especially `step-07-jsdom-tests` and `step-08-zombie-tests`.
  

[jsdom]: https://github.com/tmpvar/jsdom
[js-modules]: https://github.com/jenkinsci/js-modules
[js-builder]: https://github.com/jenkinsci/js-builder
[Framework lib]: https://github.com/jenkinsci/js-libs
[Jasmine]: http://jasmine.github.io/
[bundle]: https://github.com/jenkinsci/js-modules/blob/master/FAQs.md#what-is-the-difference-between-a-module-and-a-bundle
npm package: @jenkins-cd/logging
Description: Jenkins client-side logging
Author: Tom Fennelly
Latest version: 0.0.6

# Jenkins client-side Logging

Client-side Logging APIs for Jenkins.
 
## Installation

```
npm install --save @jenkins-cd/logging
```

## API Documentation

See [API Documentation](https://tfennelly.github.io/jenkins-js-logging/).

## Browser Configuration

All `ERROR` logs are printed to the browser console by default. All other log configurations needs to be done through the Browser Developer Tools. For more on that, [see the following documentation](https://tfennelly.github.io/jenkins-js-logging/index.html#browser-config).
npm package: @jenkins-cd/preferences
Description: Jenkins BlueOcean preference storage via localStorage
Author: Thorsten Scherler
Latest version: 0.0.5

# Jenkins client-side preferences

Client-side Preferences APIs for Jenkins.
 
## Installation

```
npm install --save @jenkins-cd/preferences
```

## API Documentation

See [API Documentation](https://jenkinsci.github.io/js-preferences/).
npm package: @jenkins-cd/storage
Description: Browser storage for Jenkins JavaScript libraries
Author: Tom Fennelly
Latest version: 0.0.6

Jenkins client-side storage JavaScript API, providing a simple API on top of the HTML5 [Storage] (Web Storage API).

# Install

```
npm install --save @jenkins-cd/storage
```

# Documentation

See [API Documentation](https://tfennelly.github.io/jenkins-js-storage/).

[Storage]: https://developer.mozilla.org/en-US/docs/Web/API/Storage
npm package: @jenkins-x-plugins/jx-lens
Description: Lens extension to visualize Kubernetes resources and their relations
Latest version: 1.0.18

# Lens Extension for working with Jenkins X

This extension improves the UX around working with pipelines and preview environments.

## Install

```sh
mkdir -p ~/.k8slens/extensions
git clone https://github.com/jenkins-x-plugins/jx-lens.git
ln -s $(pwd)/jx-lens ~/.k8slens/extensions/jx-lens
```

## Build

To build the extension you can use `make` or run the `npm` commands manually:

```sh
cd jx-lens
make build
```

OR

```sh
cd jx-lens
npm install
npm run build
```
 
### Incremental building

If you want to watch for any source code changes and automatically rebuild the extension you can use:

```sh
npm start
```
       
Once the extension has been rebuilt inside `Lens` you can click on the `View -> Reload` menu item (or `R' keypress) to reload to see the new changes.

## Test

Open Lens application and navigate to a cluster. You should see "Certificates" in a menu.

## Uninstall

```sh
rm ~/.k8slens/extensions/jx-lens
```

Restart Lens application.
npm package: @jenkinsci/gatsby-plugin-jenkins-layout
Description: Shared layout for jenkins.io based gatsby sites
Author: Gavin Mogan
Latest version: 1.7.0

# gatsby-plugin-jenkins-layout

Shared layout for jenkins.io based gatsby sites

## Usage

gatsby-config.js

```javascript
module.exports = {
    siteMetadata: {
        siteUrl: 'https://stories.jenkins.io',
        githubRepo: 'jenkins-infra/stories',
    },
    plugins: [
        {
            resolve: '../gatsby-plugin-jenkins-layout/',
            options: {
                siteUrl: 'https://stories.jenkins.io',
            },
        },
    ]
}
```
npm package: @jenkinsci/jenkins-io-components
Description: Random parts shared between jenkins.io
Author: Gavin Mogan
Latest version: 1.41.0

# Welcome to Jenkins.io Web Components

This is an attempt to build web components that can be used across various jenkins.io based projects

## Setup

Install dependencies:

```bash
npm i
```

## Build

This sample uses the TypeScript compiler to produce JavaScript that runs in modern browsers.

To build the JavaScript version of your component:

```bash
npm run build
```

To watch files and rebuild when the files are modified, run the following command in a separate shell:

```bash
npm run build:watch
```

Both the TypeScript compiler and lit-analyzer are configured to be very strict. You may want to change `tsconfig.json` to make them less strict.

## Testing

This sample uses modern-web.dev's
[@web/test-runner](https://www.npmjs.com/package/@web/test-runner) for testing. See the
[modern-web.dev testing documentation](https://modern-web.dev/docs/test-runner/overview) for
more information.

Tests can be run with the `test` script, which will run your tests against Lit's development mode (with more verbose errors) as well as against Lit's production mode:

```bash
npm test
```

For local testing during development, the `test:dev:watch` command will run your tests in Lit's development mode (with verbose errors) on every change to your source files:

```bash
npm test:watch
```

Alternatively the `test:prod` and `test:prod:watch` commands will run your tests in Lit's production mode.

## Dev Server

To run the dev server and open the project in a new browser tab:

```bash
npm run storybook
```

## Editing

If you use VS Code, we highly recommend the [lit-plugin extension](https://marketplace.visualstudio.com/items?itemName=runem.lit-plugin), which enables some extremely useful features for lit-html templates:

- Syntax highlighting
- Type-checking
- Code completion
- Hover-over docs
- Jump to definition
- Linting
- Quick Fixes

The project is setup to recommend lit-plugin to VS Code users if they don't already have it installed.

## Linting

Linting of TypeScript files is provided by [ESLint](eslint.org) and [TypeScript ESLint](https://github.com/typescript-eslint/typescript-eslint). In addition, [lit-analyzer](https://www.npmjs.com/package/lit-analyzer) is used to type-check and lint lit-html templates with the same engine and rules as lit-plugin.

The rules are mostly the recommended rules from each project, but some have been turned off to make LitElement usage easier. The recommended rules are pretty strict, so you may want to relax them by editing `.eslintrc.json` and `tsconfig.json`.

To lint the project run:

```bash
npm run lint
```

## Formatting

[Prettier](https://prettier.io/) is used for code formatting. It has been pre-configured according to the Lit's style. You can change this in `.prettierrc.json`.

Prettier has not been configured to run when committing files, but this can be added with Husky and and `pretty-quick`. See the [prettier.io](https://prettier.io/) site for instructions.
npm package: @jenko.uros/ngrx-module
Description: A blank schematics
Author: Uroš Jenko
Latest version: 1.0.4

# Prerequisite

Installed packages:

- @ngrx/effects
- @ngrx/store
- @ngrx/store-devtools

To install use:
`npm install -s @ngrx/store @ngrx/effects @ngrx/store-devtools`

# Installation

`npm install --save-dev '@jenko.uros/ngrx-module'`

# Run schematics

`ng add '@jenko.uros/ngrx-module' your-module-name`

# Arhitecture

![alt text](https://github.com/jenkouros/scaffolding-ngrx-module/blob/master/Ngrx.jpg?raw=true)
npm package: @jenkshiny/webpack-html-inject-plugin
Description: A webpack plugin that inject some variables to entry html.
Author: Jenkin Tang
Latest version: 1.0.1
Deprecated: dasdsad

﻿# webpack-html-inject-plugin
> A webpack plugin that inject some variables to entry html.

## Usage

First, install `webpack-html-inject-plugin` as a development dependency:

```shell
npm i -D @jenkshiny/webpack-html-inject-plugin
```

Then, add it to your `webpack.config.js`:

```javascript
const HtmlInjectPlugin = require('webpack-html-inject-plugin');

webpackOptions.plugins.push(new HtmlInjectPlugin({
  filename: 'index.html',
  data: {
           ENV_DEBUG: false,
           ENV_DEV: true,
           token: 'zawQrZL963RGtXrd2rYmLmUOeckesAaLlYgtNVA89'
  }
}));
```

## Before
```html
<script>
  window.token = {{token}};
  window.ENV_DEBUG = {{ENV_DEBUG}};
  window.ENV_DEV = {{ENV_DEV}};
</script>
```
## After
```html
<script>
  window.ENV_DEBUG = false;
  window.ENV_DEV = true;
  window.token = 'zawQrZL963RGtXrd2rYmLmUOeckesAaLlYgtNVA89';
</script>
```

## API
### new HtmlInjectPlugin([options])

#### options
Type: `object`

##### filename
Type: `String`
###### The file to write the HTML to.

##### data
Type: `object`

###### Declara some variables to html.
npm package: @jenniesh/eslint-config-vue
Description: ESLint and Prettier Config for Vue2
Author: Jennie Shao
Latest version: 1.1.0

# Eslint and Prettier Setup for Vue2

This package provides my Eslint and Prettier config.

## Usage

### 1. Install package
- npm

```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue
```

- yarn 
```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue -Y
```
Make sure that the dependencies of your configuration package may also be installed.


### 2. Add `"@jenniesh/eslint-config-vue"` to `extends` in your `.eslintrc`

```json=
// .eslintrc.js

{
  extends: [ "@jenniesh/eslint-config-vue" ]
}
```


## VS Code Settings

### 1. Install the [Eslint Extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)

### 2. Add `settings.json` file in `.vscode` folder

```json=
// settings.json

{
    // These are all my auto-save configs
    "editor.formatOnSave": true,
    // turn it off for JS and JSX, we will do this via eslint
    "[javascript]": {
    "editor.formatOnSave": false
    },
    "[javascriptreact]": {
    "editor.formatOnSave": false
    },
    // show eslint icon at bottom toolbar
    "eslint.alwaysShowStatus": true,
    // tell the ESLint plugin to run on save
    "editor.codeActionsOnSave": {
    "source.fixAll": true
    }
}
```

### 3. Restart VS Code
npm package: @jenniesh/eslint-config-vue-typescript
Description: ESLint and Prettier Config for Vue2 with TypeScript
Author: Jennie Shao
Latest version: 1.0.0

# Eslint and Prettier Setup for Vue2 with TypeScript

This package provides my Eslint and Prettier config.

## Usage

### 1. Install package
- npm

```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue-typescript
```

- yarn 
```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue-typescript -Y
```
Make sure that the dependencies of your configuration package may also be installed.


### 2. Add `"@jenniesh/eslint-config-vue-typescript"` to `extends` in your `.eslintrc`

```json=
// .eslintrc.js

{
  extends: [ "@jenniesh/eslint-config-vue-typescript" ]
}
```


## VS Code Settings

### 1. Install the [Eslint Extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)

### 2. Add `settings.json` file in `.vscode` folder

```json=
// settings.json

{
    // These are all my auto-save configs
    "editor.formatOnSave": true,
    // turn it off for JS and JSX, we will do this via eslint
    "[javascript]": {
    "editor.formatOnSave": false
    },
    "[javascriptreact]": {
    "editor.formatOnSave": false
    },
    // show eslint icon at bottom toolbar
    "eslint.alwaysShowStatus": true,
    // tell the ESLint plugin to run on save
    "editor.codeActionsOnSave": {
    "source.fixAll": true
    }
}
```

### 3. Restart VS Code
npm package: @jenniesh/eslint-config-vue3
Description: ESLint and Prettier Config for Vue3
Author: Jennie Shao
Latest version: 1.0.0

# Eslint and Prettier Setup for Vue3

This package provides my Eslint and Prettier config.

## Usage

### 1. Install package
- npm

```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue3
```

- yarn 
```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue3 -Y
```
Make sure that the dependencies of your configuration package may also be installed.


### 2. Add `"@jenniesh/eslint-config-vue3"` to `extends` in your `.eslintrc`

```json=
// .eslintrc.js

{
  extends: [ "@jenniesh/eslint-config-vue3" ]
}
```


## VS Code Settings

### 1. Install the [Eslint Extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)

### 2. Add `settings.json` file in `.vscode` folder

```json=
// settings.json

{
    // These are all my auto-save configs
    "editor.formatOnSave": true,
    // turn it off for JS and JSX, we will do this via eslint
    "[javascript]": {
    "editor.formatOnSave": false
    },
    "[javascriptreact]": {
    "editor.formatOnSave": false
    },
    // show eslint icon at bottom toolbar
    "eslint.alwaysShowStatus": true,
    // tell the ESLint plugin to run on save
    "editor.codeActionsOnSave": {
    "source.fixAll": true
    }
}
```

### 3. Restart VS Code
npm package: @jenniesh/eslint-config-vue3-typescript
Description: ESLint and Prettier Config for Vue3 with TypeScript
Author: Jennie Shao
Latest version: 1.0.0

# Eslint and Prettier Setup for Vue3 with TypeScript

This package provides my Eslint and Prettier config.

## Usage

### 1. Install package
- npm

```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue3-typescript
```

- yarn 
```bash=
npx install-peerdeps --dev @jenniesh/eslint-config-vue3-typescript -Y
```
Make sure that the dependencies of your configuration package may also be installed.


### 2. Add `"@jenniesh/eslint-config-vue3-typescript"` to `extends` in your `.eslintrc`

```json=
// .eslintrc.js

{
  extends: [ "@jenniesh/eslint-config-vue3-typescript" ]
}
```


## VS Code Settings

### 1. Install the [Eslint Extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)

### 2. Add `settings.json` file in `.vscode` folder

```json=
// settings.json

{
    // These are all my auto-save configs
    "editor.formatOnSave": true,
    // turn it off for JS and JSX, we will do this via eslint
    "[javascript]": {
    "editor.formatOnSave": false
    },
    "[javascriptreact]": {
    "editor.formatOnSave": false
    },
    // show eslint icon at bottom toolbar
    "eslint.alwaysShowStatus": true,
    // tell the ESLint plugin to run on save
    "editor.codeActionsOnSave": {
    "source.fixAll": true
    }
}
```

### 3. Restart VS Code