open-index/open-npm huggingface dataset:
npm package: @jobinsjp/vue3-datatable
Description: DataTable component with basic pagination, search filters etc for Vue3
Author: Puncoz Nepal
Latest version: 1.0.15

# DataTable - Vue3 Component

> Basic DataTable component for Vue3 in typescript and Composition API. It has basic functionality such as Filter/Search, pagination etc.

[![NPM](https://img.shields.io/npm/v/@jobinsjp/vue3-datatable.svg)](https://www.npmjs.com/package/@jobinsjp/vue3-datatable)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
[![Build](https://img.shields.io/travis/JoBinsJP/vue3-datatable?logo=travis)](https://travis-ci.org/JoBinsJP/vue3-datatable)

## [Demo](https://vue3-datatable.netlify.app/)

![DataTable Demo](demo.png)

## Install

```bash
npm install --save @jobinsjp/vue3-datatable

or,

yarn add @jobinsjp/vue3-datatable
```

## Usage

```vue
    <data-table :rows="data"/>
```

## License

MIT © [https://github.com/JoBinsJP/vue3-datatable](https://github.com/JoBinsJP/vue3-datatable)
npm package: @jobkhy/img-converter
Description: This project is a Rust library for Node.js that allows you to convert images to different formats using napi-rs. It supports converting images from files or directly from buffers, making it easy to use in web applications or real-time processing.
Author: JobKhy
Latest version: 1.0.7

# Image Converter

Image Converter is a high-performance image conversion library written in Rust and exposed to Node.js using `napi-rs`. It allows you to convert images between multiple formats efficiently, either from file paths or buffers.

## Features

- 🚀 Fast image conversion powered by Rust
- 🎨 Supports multiple formats: **PNG, JPEG, BMP, GIF, TIFF**
- 🔧 Simple API for file-based and buffer-based conversions
- 🛠️ Built with `napi-rs` for seamless Node.js integration

## Installation

<!-- Ensure you have **Node.js** and **Rust** installed. -->

```sh
npm i @jobkhy/img-converter
```

## Usage

### CommonJS

```js
const { convertImage, convertImageFile } = require("image-converter");

// Convert an image file
convertImage("input.jpg", "output.png", "png");

// Convert an image buffer
const fs = require("fs");
const inputBuffer = fs.readFileSync("input.jpg");
const outputBuffer = convertImageFile(inputBuffer, "png");
fs.writeFileSync("output.png", outputBuffer);
```

### ES Modules

```js
import { convertImage, convertImageFile } from "image-converter";

await convertImage("input.jpg", "output.png", "png");

import fs from "fs";
const inputBuffer = fs.readFileSync("input.jpg");
const outputBuffer = convertImageFile(inputBuffer, "png");
fs.writeFileSync("output.png", outputBuffer);
```

## API

### `convertImage(inputPath: string, outputPath: string, format: string): Promise<void>`

Converts an image file to the specified format and saves it to disk.

### `convertImageFile(inputData: Buffer, format: string): Buffer`

Converts an image buffer to the specified format and returns a new buffer.

## Supported Formats

- PNG
- JPEG / JPG
- BMP
- GIF
- TIFF
- WEBP

## Requirements

<!-- - Rust and `cargo` installed -->

- Node.js 16+ (with N-API support)

## License

MIT
npm package: @joblift/babel-plugin-transform-require-ignore
Description: ignore the required file by extension type
Latest version: 0.2.0

## babel-plugin-transform-require-ignore

This is a fork from https://github.com/morlay/babel-plugin-transform-require-ignore, which adds an option to exlude patterns.

Since https://nodejs.org/api/globals.html#globals_require_extensions deprecated.

We have to find another way to ignore the extensions for webpack usage and make it work in node environment.

Configure it in `.babelrc` for node, we could ignore the requirement when run test in node or build server render app.

Then we run babel with `BABEL_ENV=node` will active this plugin;


```js
{
  "env": {
    "node": {
      "plugins": [
        [
          "babel-plugin-transform-require-ignore",
          {
            "extensions": [".less", ".sass"]
          }
        ]
      ]
    }
  }
}

```

or use with `babel-register` in require-hooks

```
require('babel-register')({
  'plugins': [
    [
      'babel-plugin-transform-require-ignore',
      {
        extensions: ['.scss']
      }
    ]
  ]
});

```

Or with cli like other plugin used.

Notice:

Only ignore `import './some.less';` or `require('./some.less');`

If assign to some variable, means that may use css-module,
please use https://github.com/css-modules/css-modules-require-hook instead.
npm package: @joblocal/aws-cfn-deployment
Description: Makes creating or updating of AWS CloudFormations so easy your build & deployment pipelines can do it.
Author: joblocal GmbH
Latest version: 1.0.1

# AWS CloudFormation Deployment

![Downloads](https://img.shields.io/npm/dt/@joblocal\/aws-cfn-deployment.svg)

The Project provides a CLI tool for create and/or update an AWS CloudFormation.
`aws-cfn-deployment` simplifies keeping your AWS infrastructure in sync with your CloudFormation templates by integrating into your existing build & deployment pipelines.

## Requirements
- AWS environment configuration
- Yarn or npm
- Node

## Installation

Using yarn for global usage:
```sh
$ yarn global add @joblocal/aws-cfn-deployment
```

Using npm for global usage:

```sh
$ npm install -g @joblocal/aws-cfn-deployment
```

Installing as a local dependency using yarn:
```sh
$ yarn add @joblocal/aws-cfn-deployment
```

Installing as a local dependency using npm:

```sh
$ npm install @joblocal/aws-cfn-deployment
```

### Usage
Before you can use this package you need to configure your AWS environment
variables. The easiest way is to use [AWS CLI](https://aws.amazon.com/de/cli/).

After installing `aws-cfn-deployment` you can use it as follows.

```sh
$ aws-cfn-deployment
  --region {region}
  --stackName {stack name}
  --templatePath {path to your CloudFormation File}
  --{cfn parameter name} {cfn parameter value}
  --{cfn parameter name} {cfn parameter value}
  ...
```

### Parameters
The parameters **region**, **stackName** and **templatePath** are required.
All required parameters for your CloudFormation file are attached (see example).

### Example

AWS CloudFormation file (bucket.yaml):
```yaml
---
AWSTemplateFormatVersion: '2010-09-09'
Description: Creates a S3 bucket.
Parameters:
  BucketName:
    Description: Name of your S3 bucket.
    Type: String
Resources:
  DeploymentBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub ${AWS::AccountId}-{BucketName}
```

Command:
```sh
$ aws-cfn-deployment
  --region $AWS_DEFAULT_REGION
  --stackName MyBucket
  --templatePath bucket.yaml
  --BucketName AwesomeBucket
```

## Built with
* [Yarn](https://yarnpkg.com/lang/en/) - Dependency Management
* [Jest](https://facebook.github.io/jest/) - Test Runner

## Contributing
Please read through our [contributing guidelines](https://github.com/joblocal/aws-cfn-deployment/blob/master/CONTRIBUTING.md). Included are directions for opening issues, coding standards, and feature requests.


## Authors
* **Joblocal GmbH** - *Initial work* - [Joblocal](https://github.com/joblocal)

See also the list of [contributors](https://github.com/joblocal/aws-cfn-deployment/contributors) who participated in this project.
npm package: @joblocal/aws-move-queue-messages
Description: This tool can move queue message from an AWS SQS Queue to an other AWS SQS Queue.
Author: joblocal GmbH
Latest version: 1.1.0

# AWS move Queue messages

![Downloads](https://img.shields.io/npm/dt/@joblocal\/aws-move-queue-messages.svg)

This Project provides a CLI tool for moving messages from one AWS SQS queue to another.
For example to run failed messages from your deadletter queues again.

## Requirements
- AWS environment configuration
- Yarn or npm
- Node

## Installation

Using yarn:
```sh
$ yarn global add @joblocal/aws-move-queue-messages
```

Using npm:

```sh
$ npm install -g @joblocal/aws-move-queue-messages
```

### Usage
Before you can use this package you need to configure your AWS environment
variables. The easiest way is to use [AWS CLI](https://aws.amazon.com/de/cli/).

After installing the package you can use it as follows.

```sh
$ aws-move-queue-messages
```

With all optional CLI arguments:

```sh
$ aws-move-queue-messages <from-queue-url> <to-queue-url> -r [AWS-REGION] -y
```

Any CLI argument or option you do not specify will fallback to a CLI prompt. The `-y` CLI option will answer the confirmation prompt automatically with "yes".

### Parameter
Use the **Source Url** parameter to specify the source queue from which the messages are to be read.
Use the **Target Url** parameter to specify the target queue in which the messages are written.

## Built with
* [Yarn](https://yarnpkg.com/lang/en/) - Dependency Management
* [Jest](https://facebook.github.io/jest/) - Test Runner

## Contributing
Please read through our [contributing guidelines](https://github.com/joblocal/aws-move-queue-messages/blob/master/CONTRIBUTING.md). Included are directions for opening issues, coding standards, and feature requests.


## Authors
* **Joblocal GmbH** - *Initial work* - [Joblocal](https://github.com/joblocal)

See also the list of [contributors](https://github.com/joblocal/aws-move-queue-messages/contributors) who participated in this project.
npm package: @joblocal/serverless-invoke-local-environment
Description: Overwrite serverless environment to enable local development.
Author: Joblocal GmbH
Latest version: 1.1.0

# Serverless Invoke Local Environment Plugin

This [serverless](https://serverless.com/) plugin allows you to overwrite a functions `process.env` when invoking locally, allowing you to simulate AWS services using docker and connect to those containers for an easier development workflow.

## Installation

Using yarn:

```sh
$ yarn add --dev @joblocal/serverless-invoke-local-environment
```

Using npm:

```sh
$ npm install --save-dev @joblocal/serverless-invoke-local-environment
```

### Usage

After installation you can configure the plugin like so:

```yaml
# serverless.yml

plugins:
  - '@joblocal/serverless-invoke-local-environment'

custom:
  invokeLocalEnvironment: ${file(.env)}
```

```
# .env
ENVIRONMENT_VARIABLE=value
```
.env (compatible with [dotenv](https://github.com/motdotla/dotenv))

After configuration, whenever you invoke your lambda function

```sh
$ serverless invoke local -f functionName
```

your `.env` will be accessible via `process.env`.


## Built with

- [Yarn](https://yarnpkg.com/lang/en/) - Dependency Management
- [Jest](https://facebook.github.io/jest/) - Test Runner
- and ♥

## Contributing

Please read through our [contributing guidelines](https://github.com/joblocal/serverless-invoke-local-environment/blob/master/CONTRIBUTING.md). Included are directions for opening issues, coding standards, and feature requests.

## Authors

- **Joblocal GmbH** - _Initial work_ - [Joblocal](https://github.com/joblocal)

See also the list of [contributors](https://github.com/joblocal/serverless-invoke-local-environment/contributors) who participated in this project.
npm package: @jobmatchme/bee-dance-core
Description: Small runtime and validator layer for the Bee Dance protocol
Latest version: 0.1.5

# `@jobmatchme/bee-dance-core`

`bee-dance-core` is the small runtime layer that sits on top of
`@jobmatchme/bee-dance-schema`.

Where the schema package only defines the message contract, this package adds
the practical pieces needed by applications that want to speak the Bee Dance
protocol in real systems: schema loading, validation, helper builders, parsing,
dispatching, and capability negotiation.

## What this package is for

Agent systems usually need two things at the same time:

- a protocol that stays explicit and reviewable at the schema level
- a small implementation layer that makes the protocol easy to use in code

`bee-dance-core` covers the second part. It is intentionally narrow in scope so
that transport adapters, gateways, sidecars, and agent runtimes can all reuse
the same protocol mechanics without inheriting each other's infrastructure
choices.

## What this package contains

- AJV setup for the Bee Dance schemas
- compiled validators for envelopes and payload types
- TypeScript types for envelopes, actors, items, and capabilities
- helper functions for constructing common protocol messages
- parsing and assertion helpers
- a tiny dispatcher for routing messages by name
- capability negotiation helpers

## What this package does not contain

- transport code such as NATS, HTTP, WebSockets, or Slack bindings
- queueing or orchestration logic
- agent execution logic
- persistence or session storage

Those concerns belong in higher-level packages.

## Design intent

The goal is to keep the protocol runtime small, predictable, and portable. A
gateway should be able to use it to validate and emit messages. A sidecar
should be able to use it to adapt between systems. An agent runtime should be
able to use it without importing UI or transport concerns.

That separation makes protocol evolution easier. The schema package can change
deliberately, and this runtime can follow with focused updates, while
application packages remain thinner and more replaceable.

## Typical usage

Applications normally use this package together with the schema package to:

- validate inbound envelopes before acting on them
- build outbound envelopes with helper functions
- negotiate supported protocol features between peers
- dispatch messages to handlers based on message names

## Publishing

The package is intended for public npm publication from GitHub Actions. A tag
such as `v0.1.3` is expected to match the `package.json` version. The GitHub
workflow then installs dependencies with `npm ci`, builds the package, and
publishes it to npm using an `NPM_TOKEN` repository secret.

## License

MIT
npm package: @jobmatchme/bee-dance-schema
Description: JSON Schemas for the Bee Dance agent communication protocol
Latest version: 0.2.4

# `@jobmatchme/bee-dance-schema`

`bee-dance-schema` is the schema layer for the Bee Dance communication protocol.

The package exists for systems that want agents or user
interfaces to exchange structured messages without hard-coding one concrete
transport or one concrete runtime. Instead of coupling every participant to one
implementation, Bee Dance describes the protocol as JSON Schemas for envelopes,
commands, responses, events, items, and capability negotiation.

## What this package contains

- the version manifest for the protocol schema set
- JSON Schemas for the top-level envelope
- JSON Schemas for protocol handshake messages
- JSON Schemas for turn lifecycle messages
- JSON Schemas for item, action, and approval events
- shared schema fragments such as actors, capabilities, and item parts

## Why a schema package exists at all

Distributed agent systems tend to evolve quickly. New transports appear, new
clients want to render richer outputs, and runtimes often need to be replaced
without rewriting every connected component. A dedicated schema package helps by
making the wire contract explicit and versioned.

That has a few practical benefits:

- producers and consumers can validate messages independently
- gateways and sidecars can adapt between protocol versions more safely
- tooling can generate validators, fixtures, documentation, or test harnesses
- protocol review can happen at the contract level before implementation details
  are fixed

## Design intent

Bee Dance is meant for conversational and tool-using agents that do more than
return one final string. The protocol therefore separates:

- envelope metadata such as message identity, sender, session, thread, and turn
- capability negotiation for compatible protocol use
- commands such as starting or cancelling a turn
- streamed events such as run lifecycle updates, appended items, and approval
  requests
- structured content parts, so that text, status information, approvals, diffs,
  artifacts, and forms can travel in the same message model

The schemas are transport-agnostic. They do not prescribe NATS, HTTP, Slack, or
any other integration surface. They only define the message shapes.

## Typical usage

This package is usually paired with a small protocol runtime that:

- loads these schemas
- validates incoming and outgoing envelopes
- provides helpers for building valid protocol messages

Applications can then use the runtime while keeping the schema source of truth
separate and easy to review.

## License

MIT

## Publishing

The package is set up to publish publicly to npm from GitHub Actions using npm
Trusted Publishing via GitHub OIDC.

A release tag such as `v0.2.1` is expected to point to a commit whose
`package.json` version matches the tag. The workflow then installs dependencies
with `npm ci`, builds the package, and publishes it to npm without a long-lived
publish token.

For this to work, the package must be configured on npm with a trusted
publisher that points to the matching GitHub repository and workflow filename.
npm package: @jobmatchme/bee-gate
Description: Transport-neutral gateway runtime for the Bee Dance protocol
Latest version: 0.1.7

# `@jobmatchme/bee-gate`

`bee-gate` is a transport-neutral gateway runtime for systems that want to send
user input into Bee Dance compatible agents and turn the resulting event stream
back into UI-facing updates.

It sits above `@jobmatchme/bee-dance-core` and below adapter packages such as
Slack, web chat, or other channel-specific integrations.

## What this package does

`bee-gate` provides the runtime pieces that are specific to gateway behavior:

- a normalized gateway contract for inbound user turns
- a NATS-backed Bee Dance client
- a generic engine that processes Bee Dance events
- rendering support for streamed `item.*` updates
- session helpers for turn and conversation tracking
- a local blob store abstraction for attachments and artifacts

## Why this package exists

UI adapters and agent runtimes should not have to agree on every transport and
orchestration detail directly. A gateway layer gives them a stable middle
ground:

- adapters normalize inbound messages into one gateway input model
- gateways speak the Bee Dance protocol to backend workers or sidecars
- adapters only have to implement a small output sink for visible messages and
  artifacts

That keeps the chat surface thin while still allowing richer turn lifecycle
handling than a simple request/response API.

## Design intent

`bee-gate` is intentionally not Slack-specific, web-specific, or agent-specific.
It owns gateway concerns:

- turn submission
- protocol handshake
- event stream consumption
- timeout handling
- cancellation
- UI-facing message progression

It does not own the chat transport itself and it does not execute agent logic.

## Typical usage

Applications usually pair this package with:

- a Bee Dance capable backend reachable over NATS
- a chat or UI adapter that maps user messages into the gateway contract
- a transport sink that knows how to post and update messages in the target UI

## Publishing

The package is intended for public npm publication from GitHub Actions using npm
Trusted Publishing via GitHub OIDC.

## License

MIT
npm package: @jobmatchme/bee-gate-test
Description: Local fake Bee Dance agent for testing Bee Gate integrations
Latest version: 0.1.3

# `@jobmatchme/bee-gate-test`

`bee-gate-test` is a lightweight fake backend for local and automated testing of
Bee Gate based integrations.

It is not a production agent runtime. Instead, it behaves like a predictable
Bee Dance peer that can answer the protocol handshake, accept turns, emit a
small stream of events, and react to cancellation. That makes it useful when
you want to exercise adapters, gateways, and protocol plumbing without bringing
up a real agent implementation.

## What this package does

- listens on NATS subjects used by Bee Gate
- answers the Bee Dance protocol handshake
- emits deterministic `run.*` and `item.*` events
- supports test cancellation paths
- logs invalid protocol messages instead of silently swallowing them

## Typical usage

This package is mainly intended for:

- local end-to-end testing of chat adapters and gateways
- contract testing of Bee Dance event handling
- development environments where a real agent backend is not available yet

## Docker

A container image can run the fake agent directly and only needs the same
environment variables as the Node.js process:

- `BEE_GATE_TEST_SUBJECT` to choose the base NATS subject
- `BEE_GATE_TEST_NATS_SERVERS` to override the NATS server list when needed

The bundled `Dockerfile` installs the published npm package and starts the test
agent with the defaults that fit the in-cluster `nats` service.

## Helm

A minimal Helm chart is provided in `charts/bee-gate-test`.

The chart intentionally does not create or require a Secret. Its only
application-level setting is `subject`, which is mapped to
`BEE_GATE_TEST_SUBJECT`. The chart also defaults `BEE_GATE_TEST_NATS_SERVERS`
to `nats://nats.nats.svc.cluster.local:4222` and `BEE_GATE_TEST_NATS_NAME` to
`bee-gate-test`, matching the container defaults for in-cluster deployments.

## Publishing

The package is intended for public npm publication from GitHub Actions using npm
Trusted Publishing via GitHub OIDC.

## License

MIT
npm package: @jobmatchme/bee-worker-sidecar
Description: NATS to Unix socket bridge for Bee Dance speaking workers
Latest version: 0.1.2

# `@jobmatchme/bee-worker-sidecar`

`bee-worker-sidecar` bridges Bee Dance speaking workers on a local Unix socket to
Bee Dance subjects on NATS.

It is designed for deployments where the actual agent process should stay small
and local to the pod, while the surrounding system communicates over NATS. The
sidecar does not implement agent behavior itself. It only adapts transports.

## What this package does

- subscribes to Bee Dance protocol and command subjects on NATS
- forwards Bee Dance envelopes to a local worker socket using framed JSON
- forwards worker event envelopes back to NATS session event subjects
- keeps reconnecting until the worker socket becomes available
- keeps the public Bee Dance transport separate from the worker runtime

## Design intent

This package exists for the common case where an agent can speak Bee Dance, but
should not know about NATS directly.

That split has a few practical benefits:

- the worker can focus on local execution and protocol semantics
- the sidecar can own NATS connection management and subject routing
- deployments can keep the familiar two-container pod shape
- later agents that speak Bee Dance natively over NATS can skip the sidecar
  without changing Bee-facing clients

## Wire model

The sidecar expects the following NATS subjects for a worker subject root such as
`bee.agent.pi.default`:

- `bee.agent.pi.default.protocol`
- `bee.agent.pi.default.command`
- `bee.agent.pi.default.session.<sessionId>.event`

On the local socket, the sidecar exchanges framed Bee Dance envelopes with the
worker. A `protocol.hello` received on NATS is forwarded to the worker socket
and the resulting `protocol.welcome` is sent back over the NATS reply subject.
Command envelopes are forwarded one-way, while worker event envelopes are
published to the session event subject.

## Configuration

The process reads its configuration from `BEE_WORKER_SIDECAR_CONFIG`.

Example:

```json
{
  "nats": {
    "servers": "nats://nats:4222",
    "name": "bee-worker-sidecar"
  },
  "workerSubject": "bee.agent.pi.default",
  "worker": {
    "socketPath": "/var/run/bee/worker.sock",
    "requestTimeoutMs": 10000,
    "connectRetryMs": 250,
    "maxConnectRetryMs": 5000
  }
}
```

## Publishing

The package is intended for public npm publication from GitHub Actions using npm
Trusted Publishing via GitHub OIDC.

## Container image

A Dockerfile is included for runtime image builds. Build it locally with:

```bash
docker build -t bee-worker-sidecar:local .
```

Run it with a mounted config file:

```bash
docker run --rm \
  -v "$(pwd)/config.json:/config/config.json:ro" \
  bee-worker-sidecar:local
```

The container entrypoint expects `BEE_WORKER_SIDECAR_CONFIG=/config/config.json`.

## License

MIT
npm package: @jobnimbus/angular-mentions
Description: Angular mentions for text fields.
Author: Michael Moffet
Latest version: 0.0.5

# Angular Mentions

Simple Angular mentions inspired by [Ment.io](https://github.com/jeff-collins/ment.io).

[Click here for a Demo](http://dmacfarlane.github.io/angular-mentions/)

Provides auto-complete suggestions for @mentions in text input fields, text areas,
and content editable fields. Not fully browser tested and comes without warranty!

To install and start the demo application:

    git clone https://github.com/dmacfarlane/angular-mentions.git
    cd angular-mentions
    npm install
    ng serve

### Usage

Add the package as a dependency to your project using:

    npm install --save angular-mentions

Add the CSS to your index.html:

    <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">

Add the module to your app.module imports:

    import { MentionModule } from 'angular-mentions/mention';
    ...

    @NgModule({
        imports: [ MentionModule ],
        ...
    })

Add the `[mention]` directive to your input element:

    <input type="text" [mention]="items">

Where `items` is a string array of the items to suggest. For example:

    items: string[] = ["Noah", "Liam", "Mason", "Jacob", ...

#### Configuration Options

The following optional configuration items can be used.

| Option        | Default  | Description |
| ---           | ---      | ---         |
| triggerChar   | @        | The character that will trigger the menu behavior. |
| maxItems      |          | Limit the number of items shown in the pop-up menu. The default is no limit. |
| mentionSelect |          | An optional function to format the selected item before inserting the text. |
| labelKey      | 'label'  | The field to be used as the item label (when the items are objects). |
| filterKeys    | ['label']| The field(s) to search on, if the items are objects. |
| showListHeader | false   | Show or hide a header for the search list. |
| maxHeight     | 300      | Option to set a max height for the search list, in pixels. |
| minWidth      | 250      | Option to set a minimum width for the search list, in pixels. |
| maxWidth      | 500      | Option to set a max width for the search list, in pixels. |
| positionType  | 'cursor' | Specify the position of the list. Options are cursor, above, below, or detect. |
| xPos          | 0        | Option to specify a specific x-offset, in pixels. |
| yPos          | 0        | Option to specify a specific y-offset, in pixels. |
| listItemHeight  | 26     | Option to specify a particular line-item height, in pixels. (only needed if using an advanced custom template for the list items) |
| disableSearch | false    | Disable internal filtering (only useful if async search is used). |

For Example: 

    <input type="text" [mention]="items" [mentionConfig]="{triggerChar:'#', maxItems:10, labelKey:'name', positionType: 'above', showListHeader: true}">

#### Output Events

- `(searchTerm)=""` event emitted whenever the search term changes. Can be used to trigger async search.
npm package: @jobnimbus/ionic-angular
Description: A powerful framework for building mobile and progressive web apps with JavaScript and Angular
Latest version: 3.9.5-201905100400

## Ionic Framework

The official npm package for [Ionic](https://ionicframework.com/), complete with pre-built ES5 bundles, TypeScript definitions, Sass files, CommonJS ES5 files, and more.

To get started with Ionic, please read the [Installation Guide](https://ionicframework.com/docs/intro/installation/).

[Ionic Documentation](https://ionicframework.com/docs/)

### Source files

In the root of the package are ES5 sources in the CommonJS module format, their associated Typescript type definition files, and the Ionic Sass entry files. The Javascript sources are meant to be used by a bundler such as Webpack, SystemJS Builder, or Browserify. The type definitions provide support to Typescript tooling for things like type checking and code completion.

Usually, the only import required by the user is `ionic-angular`, as everything from Ionic is exported by the package:

```
  import { App, NavController } from 'ionic-angular';
```

### Bundles

Minified and unminified CommonJS and System.register module format bundles, as well as compiled CSS stylesheets for both Ionic iOS and Material Design are located `bundles/`. The SystemJS bundle is  primarily meant to be included in a `<script>` tag for demos, tests and Javascript playgrounds like [Plunker](https://plnkr.co/).

### Installation and More

To use Ionic, we recommend installing and utilizing the [Ionic CLI](https://ionicframework.com/docs/intro/installation/) which will help you create pre-configured Ionic apps.

For full instructions on using Ionic, please visit the [Ionic Documentation](https://ionicframework.com/docs/)