open-index/open-npm huggingface dataset:
npm package: @pinelab/vendure-plugin-promotion-extensions
Description: A collection of different promotion actions and conditions for Vendure
Author: Martijn van de Brug
Latest version: 0.2.0

# Vendure Promotion Extensions

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-promotion-extensions)

A collection of different promotion actions and conditions for Vendure. See documentation below for more information on each action and condition.

# Getting started

This plugin doesn't install any promotion actions or conditions. All you do is import them from the plugin, and include them in your Vendure config.

This is the full list of actions and conditions that are available:

```ts
import { buyMinMaxOfTheSpecifiedProductsCondition } from '@pinelab/vendure-plugin-promotion-extensions';

// vendure-config.ts

    promotionOptions: {
      promotionConditions: [
        buyMinMaxOfTheSpecifiedProductsCondition
      ],
    },

```

## Buy min/max of specified products - `Buy at least {min} and at most {max} of the specified products`

A condition that allows you to set a min-max range for the quantity of products that can be bought. This is useful when you want to create stacked discounts.
For example:

1. For 5 to 10 products, you get 10% off each product
2. For 11 to 20 products, you get 20% off each product
3. For 21 or more products, you get 30% off each product
npm package: @pinelab/vendure-plugin-public-customer-groups
Description: Determines if a customer group is publicly visible
Author: Surafel Melese Tariku
Latest version: 1.4.0

# Vendure Public Customer Groups

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-public-customer-groups)

This plugin adds a custom field `isPublic` to `CustomerGroup`s, so that we can determine if a `CustomerGroup` is publicly available. It also adds a GraphQL field `Customer.customerGroups` that returns the public customerGroups to the Shop API.

## Getting started

Add the plugin to your `vendure-config.ts`:

```ts
import { PublicCustomerGroupsPlugin } from '@pinelab/vendure-plugin-public-customer-groups';
plugins: [PublicCustomerGroupsPlugin];
```

Run a database migration to add the `isPublic` custom field to Customer Group.

In the admin UI, under customer groups, you can now expose a customer group by setting `isPublic=true`.
npm package: @pinelab/vendure-plugin-sendcloud
Description: Vendure plugin for syncing orders with SendCloud
Author: Martijn van de Brug
Latest version: 1.6.0

# Vendure SendCloud plugin

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-sendcloud)

This plugin syncs orders to the SendCloud fulfillment platform.

## Getting started

1. Add the plugin to your `vendure-config.ts`:

```ts
plugins: [
  SendcloudPlugin.init({}),
  ...
]
```

2. Add the SendCloud Ui to the Vendure admin:

```ts
AdminUiPlugin.init({
  port: 3002,
  route: 'admin',
  app: compileUiExtensions({
    outputPath: path.join(__dirname, '__admin-ui'),
    extensions: [SendcloudPlugin.ui],
  }),
}),
```

3. Run a DB [migration](https://www.vendure.io/docs/developer-guide/migrations/) to add the new SendCloudConfigEntity to
   the database.
4. Go to your SendCloud account and go to `Settings > Integrations` and create an integration.
5. Write down the `secret` and `publicKey` of the created integration
6. For the same integration, add the webhook `https://your-vendure-domain.io/sendcloud/webhook/your-channel-token`. This
   will update orders when the status changes in SendCloud.
7. Start Vendure and login as admin
8. Make sure you have the permission `SetSendCloudConfig`
9. Go to `Settings > SendCloud`
10. You can fill in your SendCloud `secret` and `public key` here and click save.
11. Additionally, you can set a fallback phone number, for when a customer hasn't filled out one. A phone number is
    required by Sendcloud in some cases.

Now, when an order is placed, it will be automatically fulfilled and send to SendCloud.

## Additional configuration

You can choose to send additional info to SendCloud: `weight`, `hsCode`, `origin_country` and additional parcel items.
Parcel items will show up as rows on your SendCloud packaging slips.

```ts
import 'SendCloudPlugin, getNrOfOrders';

from;
('vendure-plugin-sendcloud');
plugins: [
  SendcloudPlugin.init({
    /**
     * Implement the weightFn to determine the weight of a parcel item,
     * or set a default value
     */
    weightFn: (line) =>
      (line.productVariant.product?.customFields as any)?.weight || 5,
    /**
     * Implement the hsCodeFn to set the hsCode of a parcel item,
     * or set a default value
     */
    hsCodeFn: (line) =>
      (line.productVariant.product?.customFields as any)?.hsCode || 'test hs',
    /**
     * Implement the originCountryFn to set the origin_country of a parcel item,
     * or set a default value
     */
    originCountryFn: (line) => 'NL',
    /**
     * Implement the additionalParcelItemsFn to add additional rows to the SendCloud order.
     * This example adds the nr of previous orders of the current customer to SendCloud
     */
    additionalParcelItemsFn: async (ctx, injector, order) => {
      additionalInputs.push(await getNrOfOrders(ctx, injector, order));
      return additionalInputs;
    },
  }),
];
```
npm package: @pinelab/vendure-plugin-shipmate
Description: Vendure plugin for integration with Shipmate
Author: Martijn van de Brug
Latest version: 1.6.0

# Vendure Shipmate Plugin

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-shipmate)

Create shipments in Shipmate on every order placed, to automate your order fulfillment process.

## Getting started

1. Add the plugin to your `vendure-config.ts`

```ts
import { ShipmatePlugin } from '@pinelab/vendure-plugin-shipmate';

...
plugins: [
  ShipmatePlugin.init({
    apiUrl: 'https://api.shipmate.co.uk/v1.2', // Or https://api-staging.shipmate.co.uk/v1.2 for the testing environment
    shouldSendOrder: function ( ctx: RequestContext, order: Order): Promise<boolean> | boolean {
      // Sample implementation that only sends orders with less than 5 items to Shipmate
      return order.totalQuantity < 5;
    }
  }),
  AdminUiPlugin.init({
    port: 3002,
    route: 'admin',
    app: compileUiExtensions({
      outputPath: path.join(__dirname, '__admin-ui'),
      extensions: [
        ShipmatePlugin.ui
        ... // your other plugin UI extensions
      ],
    }),
  }),
... // your other plugins
]

```

2. [Compile the admin UI](https://docs.vendure.io/guides/extending-the-admin-ui/getting-started/#setup) to include the Shipmate configuration page
3. Log in to your Shipmate account.
4. Note down your API key from Profile > Settings > API Keys
5. Create two webhooks. One with trigger `Tracking Status updates to Collected` and one with `Tracking Status updates to Delivered`, pointing to url `https://<your Vendure server>/shipmate`. Set `JSON` as format. This will make sure your Vendure Order is synced when the shipment is being Shipped or Delivered.
6. Start Vendure, log in, and navigate to Settings > Shipmate
7. Fill in your API Key, username and password. The plugin will authenticate as the given user when creating shipments.
8. Fill in both Auth tokens from the created webhooks that were created in Shipmate. You can find it on the webhook detail screen. The plugin uses this token to validate if incoming events are really from Shipmate.
9. Click 'Save'

### Test the plugin

1. Place a test order.
npm package: @pinelab/vendure-plugin-shipping-by-weight-and-country
Description: Vendure plugin for selecting a shipping method based on the total weight and the shipping address of an order.
Author: Martijn van de Brug
Latest version: 1.1.1

# Deprecated: Moved to [@pinelab/vendure-plugin-shipping-extensions](https://www.npmjs.com/package/@pinelab/vendure-plugin-shipping-extensions)
npm package: @pinelab/vendure-plugin-stock-monitoring
Description: Vendure plugin for monitoring stock levels per variant. View low stock in your dashboard or get notified through an event.
Author: Martijn van de Brug
Latest version: 2.1.0

# Vendure stock monitoring plugin

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-stock-monitoring)

This plugin helps you monitor the stock levels in two ways:

1. A dashboard widget that displays variants that have stock level's below their threshold
2. An event is emitted when a variant's stock level drops below a given threshold after each placed order.

## Getting started

1. Add the plugin to your `vendure-config.ts` to expose a `productVariantsWithLowStock` query in the admin API.

```ts
import { StockMonitoringPlugin } from '@pinelab/vendure-plugin-stock-monitoring';
import { AdminUiPlugin } from '@vendure/admin-ui-plugin';

plugins: [
  StockMonitoringPlugin.init({
    globalThreshold: 10,
    uiTab: 'My Admin UI Tab',
  }),
  // Add the widget to the admin ui
  AdminUiPlugin.init({
    port: 3002,
    route: 'admin',
    app: compileUiExtensions({
      outputPath: path.join(__dirname, '__admin-ui'),
      extensions: [StockMonitoringPlugin.ui],
    }),
  }),
];
```

For more configuration options regarding the admin
ui, [check the docs](https://www.vendure.io/docs/plugins/extending-the-admin-ui/).

When you start the server and login, you can find `stock-levels` under the `add widgets` button.

### Caveats

1. This plugin doesn't use the `StockLocationStrategy` because of performance reasons. Instead, it fetches the stock level for each variant from the database and calculates its absolute stock based on the `stockOnHand` and `stockAllocated` fields.
2. Stock notifications are only emitted after an order is placed. Manual stock changes via the admin UI will not trigger a notification.
npm package: @pinelab/vendure-plugin-validate-cart
Description: Vendure plugin for validating the cart before checkout
Author: Martijn van de Brug
Latest version: 1.1.0

# Vendure Validate Cart Plugin

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-validate-cart)

A very lightweight plugin to have custom cart validation rules before proceeding to checkout. For example to check current stock, or check for limited products. You can implement your own validation rules by implementing the `CartValidatorStrategy` interface.

## Getting started

Add the plugin to your config:

```ts
import {
  ValidateCartPlugin,
  DefaultStockValidationStrategy,
} from '@pinelab/vendure-plugin-validate-cart';

// In your plugins array, in vendure-config.ts
plugins: [
  ValidateCartPlugin.init({
    // This is just the sample strategy that checks if the cart has enough stock for the items in the cart.
    validationStrategy: new DefaultStockValidationStrategy(),
  }),
];
```

This will add a `validateActiveOrder` mutation to the shop API.

## Storefront usage

Depending on your validation strategy, you probably want to call the `validateActiveOrder` mutation in the cart page, and again on the payment page:

```gql
mutation ValidateActiveOrderMutation {
  validateActiveOrder {
    message
    errorCode
    relatedOrderLineIds
  }
}
```

If any validation errors are returned, you can display the error to the user with the corresponding order lines. You could even automatically remove the items from the cart based on the `relatedOrderLineIds`.

This action is a mutation rather than a query, because your custom validation logic might need to modify the order, for example to 'lock' an order after validation until payment is completed.

## Custom validation rules

You can implement your own validation rules by implementing the `CartValidatorStrategy` interface. For example, to check if active promotions are still valid for the items in the cart.

```ts
import {
  ValidateCartStrategy,
  ActiveOrderValidationError,
} from '@pinelab/vendure-plugin-validate-cart';

export class PromotionValidator implements ValidateCartStrategy {
  // Tell the plugin to pre-load the promotions for the order
  loadOrderRelations: RelationPaths<Order> = ['promotions'];

  // Validate the order based on your custom logic
  async validate(ctx: RequestContext, activeOrder: Order, injector: Injector) {
    const errors: ActiveOrderValidationError[] = [];
    for (const promotion of activeOrder.promotions) {
      if (!isPromotionValid(promotion)) {
        errors.push({
          message: `Promotion ${promotion.name} is not valid`,
          errorCode: `INVALID_PROMOTION`,
        });
      }
    }
    return errors;
  }
}
```
npm package: @pinelab/vendure-plugin-variant-bulk-update
Description: Vendure plugin to bulk update all variants of a product
Author: Martijn van de Brug
Latest version: 1.6.0

# Vendure Plugin for bulk updating all variants of a product

[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-variant-bulk-update)

Tiny plugin that allows you to update the prices and/or custom fields of all variants for a given product. Useful for when all your variants have the same price for example.

## Bulk updating price

This example shows you how to update the price of all variants of a product. E.g. updating the price of a product to €10, will set the price of all it's variants to €10. This setup needs a DB migration, because it adds a custom field to Product.

1. Add the plugin config to your `vendure-config.ts`:

```ts
import {VariantBulkUpdatePlugin} from '@pinelab/vendure-plugin-variant-bulk-update';

plugins: [
        VariantBulkUpdatePlugin.init({
          // Allow bulk updating of price
          enablePriceBulkUpdate: true,
          // This example doesn't update any custom fields
          bulkUpdateCustomFields: []
        }),
  ...
];
```

2. Run a database migration to add the price field on a product.
3. Start Vendure, login and go to a product.
4. Set the field `price` of a product to €300 and save the product.
5. All variants of the product will now be €300.

If you only want to update variants once, you should clear the `product.customFields.price` field again. When
the `price` field has a value, and a product is updated, all variants will be updated again.

The bulk update is async, so you might need to refresh your product page to see the updated variants.

## Bulk updating custom fields

This example shows you how to bulk update any custom field on all variants of a product. This example uses the custom field `noLongerAvailable`, but it can be any custom field.

1. Make sure you have a custom field `noLongerAvailable` configured on **both the Product and ProductVariant**
2. Add the plugin to your config

```ts
import {VariantBulkUpdatePlugin} from '@pinelab/vendure-plugin-variant-bulk-update';

plugins: [
        VariantBulkUpdatePlugin.init({
          enablePriceBulkUpdate: false,
          bulkUpdateCustomFields: ['noLongerAvailable']
        }),
  ...
];
```

3. Start the server, and set a product's `noLongerAvailable` to true.
4. All variants should now also have `noLongerAvailable=true`;

The bulk update is async, so you might need to refresh your product page to see the updated variants.
npm package: @pinemach/obj-permute
Description: Iterate permutations described by a states object.
Latest version: 1.0.0

# @pinemach/obj-permute

[![Coverage Status][coverage-image]][coverage-url]
[![Build Status][travis-image]][travis-url]
[![NPM version][npm-version-image]][npm-url]
[![MIT License][license-image]][license]

**@pinemach/obj-permute** is a small JavaScript package which can be used
to iterate the list of objects representing every combination of attribute
values as specified by an input object whose attributes refer to lists of
possible values.

You can read the full API documentation at 
**[pineapplemachine.github.io/obj-permute-js/](https://pineapplemachine.github.io/obj-permute-js/)**.

[license-image]: http://img.shields.io/badge/license-MIT-blue.svg
[license]: https://github.com/pineapplemachine/obj-permute-js/blob/master/LICENSE

[travis-url]: https://travis-ci.org/pineapplemachine/obj-permute-js
[travis-image]: https://travis-ci.org/pineapplemachine/obj-permute-js.svg?branch=master

[npm-url]: https://www.npmjs.com/package/@pinemach/obj-permute
[npm-version-image]: https://badge.fury.io/js/%40pinemach%2Fobj-permute.svg

[coverage-url]: https://coveralls.io/github/pineapplemachine/obj-permute-js?branch=master
[coverage-image]: https://coveralls.io/repos/github/pineapplemachine/obj-permute-js/badge.svg?branch=master

## Installation

You can install this package with the package manager of your choice. For example,

```
npm install @pinemach/obj-permute
```

You can then import and use the module like so:

``` js
// CommonJS
const getObjectPermutations = require("@pinemach/obj-permute").getObjectPermutations;
```

``` js
// ES6 modules
import getObjectPermutations from "@pinemach/obj-permute";
```

## Usage

This package exports the **getObjectPermutations** function, which
accepts an object whose attributes associate keys with lists of values.

The function returns an iterator which enumerates objects representing
every combination of attribute values within those lists.

For example, the states object input `{x: [0, 1], y: [2, 3]}` corresponds
to the list of permutations containing the objects
`{x: 0, y: 2}`, `{x: 1, y: 2}`, `{x: 0, y: 3}`, and `{x: 1, y: 3}`.

``` js
import getObjectPermutations from "@pinemach/obj-permute";

// Get an iterator for every combination of attribute values
const permutations = getObjectPermutations({
    x: [0, 1],
    y: [2, 3],
});

// Get an array from that iterator
const permutationsArray = permutations.array();

// Verify that each expected item is present
assert(permutationsArray.length === 4);
assert(permutationsArray.find(
    result => result.x === 0 && result.y === 2
));
assert(permutationsArray.find(
    result => result.x === 1 && result.y === 2
));
assert(permutationsArray.find(
    result => result.x === 0 && result.y === 3
));
assert(permutationsArray.find(
    result => result.x === 1 && result.y === 3
));
```
npm package: @pinemach/truncate-date
Description: Truncate date values, reducing their precision.
Latest version: 1.0.0

# @pinemach/truncate-date

[![Coverage Status][coverage-image]][coverage-url]
[![Build Status][travis-image]][travis-url]
[![NPM version][npm-version-image]][npm-url]
[![MIT License][license-image]][license]

**@pinemach/truncate-date** is a small JavaScript package with a single concern:
truncating datetime inputs to remove all precision past a given time unit.

You can read the full API documentation at 
**[pineapplemachine.github.io/truncate-date-js/](https://pineapplemachine.github.io/truncate-date-js/)**.

[license-image]: http://img.shields.io/badge/license-MIT-blue.svg
[license]: https://github.com/pineapplemachine/truncate-date-js/blob/master/LICENSE

[travis-url]: https://travis-ci.org/pineapplemachine/truncate-date-js
[travis-image]: https://travis-ci.org/pineapplemachine/truncate-date-js.svg?branch=master

[npm-url]: https://www.npmjs.com/package/@pinemach/truncate-date
[npm-version-image]: https://badge.fury.io/js/%40pinemach%2Ftruncate-date.svg

[coverage-url]: https://coveralls.io/github/pineapplemachine/truncate-date-js?branch=master
[coverage-image]: https://coveralls.io/repos/github/pineapplemachine/truncate-date-js/badge.svg?branch=master

## Installation

You can install this package with the package manager of your choice. For example,

```
npm install @pinemach/truncate-date
```

You can then import and use the module like so:

``` js
const truncateDate = require("@pinemach/truncate-date").truncateDate; // CommonJS
```

``` js
import {truncateDate} from "@pinemach/truncate-date"; // ES6 modules
```

## Usage

This package exports the **truncateDate** function, which accepts a Date
object or other time value input and a time unit to truncate that value to.

Truncation occurs in the UTC timezone.

``` js
import {truncateDate} from "@pinemach/truncate-date";

const myDate = new Date("2020-04-15T12:30:15.123Z");

// Logs "2020-04-15T12:30:15.000Z"
console.log(truncateDate("second", myDate));

// Logs "2020-04-15T12:00:00.000Z"
console.log(truncateDate("hour", myDate));

// Logs "2020-04-15T00:00:00.000Z"
console.log(truncateDate("day", myDate));

// Logs "2020-01-01T00:00:00.000Z"
console.log(truncateDate("year", myDate));
```
npm package: @pinemz/safe-storage
Description: Electron-like encryption/decryption API for Node and browsers
Author: Pine Mizune
Latest version: 0.1.1

# safe-storage

![NPM Version](https://img.shields.io/npm/v/%40pinemz%2Fsafe-storage)
[![Test](https://github.com/pine/safe-storage/actions/workflows/test.yml/badge.svg)](https://github.com/pine/safe-storage/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/pine/safe-storage/graph/badge.svg?token=mrSLYH77nf)](https://codecov.io/gh/pine/safe-storage)

> Electron-like encryption/decryption API for Node.js and browsers

## Features

- Only ESM is supported as a module system (CJS is not supported)
- Supports Node.js (>= v19.0.0) and modern browsers
- Provides TypeScript type definitions as default

## Getting started
### Install

First, install this package as follows:
```bash
# For npm users
$ npm install --save @pinemz/safe-storage

# For yarn users
$ yarn add @pinemz/safe-storage

# For pnpm users
$ pnpm add @pinemz/safe-storage
```

### Usage
After installation, use the CLI to encrypt any text:

```bash
# Encrypts using a password stored in the OS keychain.
# (If none exists, it will be generated automatically and stored in the OS keychain)
$ safe-storage encrypt -s <service> -a <account> <text to encrypt>
```

Finally, decrypt the encrypted text in your script:
```js
import { Keychain, SafeStorage } from '@pinemz/safe-storage'

const keychain = new Keychain('<service>', '<account>')
const safeStorage = new SafeStorage(await keychain.getOrCreatePassword())

const decryptedText = safeStorage.decryptString('<encrypted text>')
console.log(decryptedText)
```

## References
### CLI

```bash
$ safe-storage --help
Usage: safe-storage <command> <options> <inputs>

Encryption command:
  Encryption requires -s and -a or -p.
  If you use -s and -a, save your password in your keychain beforehand,
  otherwise a new password will be generated and saved.

  $ safe-storage encrypt -s <service> -a <account> <plainText>
  $ safe-storage encrypt -p <password> <plainText>

Decryption command:
  Decryption requires -s and -a or -p.
  If you use -s and -a, save your password in your keychain beforehand,
  otherwise a new password will be generated and saved.

  $ safe-storage decrypt -s <service> -a <account> <encryptedText>
  $ safe-storage decrypt -p <password> <encryptedText>

Options:
  -s/--service  : Specify keychain service
  -a/--account  : Specify keychain account
  -p/--password : Specify password directly in plain text
  -v/--version  : Show package version
  -h/--help     : Show help
```

## API
- [API Reference](https://pine.github.io/safe-storage/)

## FAQ
### Q. Is this library only available for macOS?
No, it is also available for Linux and Windows.

This library uses _[keytar](https://www.npmjs.com/package/keytar)_ to access keychain when running on Node.js.
_keytar_ supports not only macOS, but also Linux and Windows.

## License
MIT &copy; Pine Mizune
npm package: @pinerohit11/testwidget
Description: This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
Author: Mukul
Latest version: 0.2.128

This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
npm package: @pinetrie/angular-signaturepad
Description: Angular Component wrapper for szimek / signature_pad [fork from discontinued wulfsolter / angular2-signaturepad via @ortegaangelo/angular-signaturepad]
Author: PINETRIE DOO
Latest version: 18.0.0

# angular2-signaturepad
Angular 17 component for [szimek/signature_pad](https://www.npmjs.com/package/signature_pad).

# New maintained version
The original project is no longer maintained. See wulfsolter / angular2-signaturepad.
I created a fork and will maintain it in the future.

## Install
`npm install https://gitlab.com/ortegaangelo/angular-signaturepad --save`

## Usage example

API is identical to [szimek/signature_pad](https://www.npmjs.com/package/signature_pad).

Options are as per [szimek/signature_pad](https://www.npmjs.com/package/signature_pad) with the following additions:
* canvasWidth: width of the canvas (px)
* canvasHeight: height of the canvas (px)
  The above options are provided to avoid accessing the DOM directly from your component to adjust the canvas size.

```typescript

// import into app module

import { SignaturePadModule } from '@ortegaangelo/angular-signaturepad';

...

@NgModule({
  declarations: [ ],
  imports: [ SignaturePadModule ],
  providers: [ ],
  bootstrap: [ AppComponent ]
})

// then import for use in a component

import { Component, ViewChild } from 'angular2/core';
import { SignaturePad } from '@ortegaangelo/signature-pad';

@Component({
  template: '<signature-pad [options]="signaturePadOptions" (onBeginEvent)="drawStart()" (onEndEvent)="drawComplete()"></signature-pad>'
})

export class SignaturePadPage{

  @ViewChild(SignaturePad) signaturePad: SignaturePad;

  signaturePadOptions: Object = { // passed through to szimek/signature_pad constructor
    'minWidth': 5,
    'canvasWidth': 500,
    'canvasHeight': 300
  };

  constructor() {
    // no-op
  }

  ngAfterViewInit() {
    // this.signaturePad is now available
    this.signaturePad.set('minWidth', 5); // set szimek/signature_pad options at runtime
    this.signaturePad.clear(); // invoke functions from szimek/signature_pad API
  }

  drawComplete() {
    // will be notified of szimek/signature_pad's onEnd event
    console.log(this.signaturePad.toDataURL());
  }

  drawStart() {
    // will be notified of szimek/signature_pad's onBegin event
    console.log('begin drawing');
  }
}
```
npm package: @pinetrie/ng-cron-editor
Description: A cron expression generator to be used in Angular applications. This is a fork of https://github.com/claudiuconstantin/cron-editor via https://github.com/ShawinMendis/cron-editor to support Angular 18
Author: PINETRIE DOO
Latest version: 18.0.0

ng-cron-editor
===

`ng-cron-editor` is library that helps the user graphically build a CRON expression (quartz format only) in an Angular application. A cron expression generator to be used in Angular applications. This is a fork of https://github.com/claudiuconstantin/cron-editor via https://github.com/ShawinMendis cron-editor to support Angular 18.

To run the app just run `npm install`, then `npm run start` and go to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Demo

A quick demo of this app can be found at the original repo [here](https://claudiuconstantin.github.io/cron-editor/).

## License:
Licensed under the MIT license