open-index/open-npm huggingface dataset:
npm package: @flownet/form-dialog
Description: @flownet/form-dialog is a project source code primarily written in React. From an end-user perspective, its main purpose revolves around rendering a specific layout or presentation of interface components within a given application.
Latest version: 0.2.6

# @flownet/form-dialog

@flownet/form-dialog is a project source code primarily written in React. From an end-user perspective, its main purpose revolves around rendering a specific layout or presentation of interface components within a given application.

This project source code uses an imported Layout object from '@flownet/react-layout-asya', which is likely a layout engine or a pre-designed layout component. This suggests that the main intention is to create a clean and intuitive user interface.

Essentially, it's a wrapper utility that provides a uniform layout arrangement to house various front-end components. The user should be able to interact with the elements contained within the layout, although the specifics of these elements and their functionalities are largely dependent on the properties ('props') passed to the Layout component.

**End-user impact**: The implementation of @flownet/form-dialog significantly positively impacts the end-user experience. While the internal workings might appear complex, end-users benefit from a consistently structured, intuitive, and user-friendly interface across various areas of an application. 

**Key Functionality**: From an end-user perspective, the primary functionality is to present the application's interface elements in a well-organized, aesthetic manner ensuring optimized interaction and engagement.

It's important to note, since the source code defines this as a default export, it implies that this module can be involved or implemented in other components or sections across the application, providing a consistent layout structure in all the places it's used.
npm package: @flownet/form-in-progress
Description: The primary purpose of the @flownet/form-in-progress project lies in facilitating the development of user interfaces in React applications. More specifically, it creates a form interface setup that provides visual feedback to users regarding the completio
Latest version: 0.2.6

# @flownet/form-in-progress

The primary purpose of the @flownet/form-in-progress project lies in facilitating the development of user interfaces in React applications. More specifically, it creates a form interface setup that provides visual feedback to users regarding the completion or progress status of a particular form-related operation.

## Form Progress Indication

One of the significant **functionalities** of the @flownet/form-in-progress is to display a progress bar. The use of '@mui/material/LinearProgress' indicates that this is a Material-UI Linear progress bar being utilized. This kind of progress bar is typically used to show the completion state for tasks that take a considerable amount of time, such as form submission or data loading.

When a user submits a form or triggers an operation, the LinearProgress bar will provide users with visual cues, informing them about the status of the process. This way, users can be assured that the operation is in progress and not stalled or failed, improving the overall user experience.

## Layout and Style

The project incorporates the '@flownet/react-layout-asya' and '@mui/material/Box' approaches to manage the layout and styling of the application interface. '@flownet/react-layout-asya' appears to be a specific layout package used to structure the components. 

Meanwhile, the '@mui/material/Box' component is a utility from Material-UI that serves as a wrapper component. It conveniently allows for the styling of its child components via props, in this case, it provides a 100% width to the child LinearProgress component. 

## Usage in User Interface

This project would be beneficial for developers aiming to enhance the user experience on their applications, particularly where form submission or data loading is involved. The form-in-progress feature informs users about the progress of their request, fostering a smoother and more engaging user interaction within the application.
npm package: @flownet/form-net-promote-score
Description: The @flownet/form-net-promote-score project is a **React-based application** designed to create an interactive scoring system interface. The primary focus of this application is to enhance user interaction by providing a slider which the end-user can mani
Latest version: 0.2.6

# @flownet/form-net-promote-score

The @flownet/form-net-promote-score project is a **React-based application** designed to create an interactive scoring system interface. The primary focus of this application is to enhance user interaction by providing a slider which the end-user can manipulate to reflect their scoring preference.

## Description of Functionality

The application uses several key components from the Material UI library, including Slider, Typography, and Box components, along with a custom Layout component, to create an interactive user interface.

The main element in this project is a **slider**. The slider has a default value of 50 (midway) and steps of 10 (though these can be overwritten through the properties passed into the component). The slider is marked along the way, interprets different values as percentages, and has an active label display to give instant feedback and improve the user's interaction.

Besides, the application presents **text descriptions** at both ends of the slider to give context to the extremities of the user’s scoring selection. This is implemented through the elements "Not likely at all" and "Extremely likely", which serve as visual references for the end-user when they wish to score an item.

The slider and texts are encapsulated in the Layout container provided by the `@flownet/react-layout-asya` package, giving a well-structured look to the scoring system.

In terms of its overall purpose, the main functionality of this React component is to provide a scoring system, which could be used to **gauge user sentiment** or **gather user feedback** in a visually engaging manner with real-time adjustments and feedback.
npm package: @flownet/form-rating
Description: The primary purpose of the project titled as `@flownet/form-rating` is to provide end-users with a means to display and utilize an interactive star rating system within a webpage or application. This project leverages React.js, a popular JavaScript librar
Latest version: 0.2.6

# @flownet/form-rating

The primary purpose of the project titled as `@flownet/form-rating` is to provide end-users with a means to display and utilize an interactive star rating system within a webpage or application. This project leverages React.js, a popular JavaScript library, for its execution.

## Overview

Users can interact with the `@flownet/form-rating` component (such as clicking on the star elements) to denote a particular rating. It is built with a responsive design approach, allowing versatile usage across devices with differing screen sizes.

**Input Values and Precision**: The project uses initialValue and inputPrecision to control the basic functionality of the form-rating component. The initialValue represents the default rating displayed. The inputPrecision controls the increment value for the rating system.

### Ratings Component

The core functionality of the project hinges on a component sourced from the '@mui/material/Rating' library. The project uses React state hooks to drive its behavior. The 'defaultValue' and 'precision' properties of the Rating component are used to handle the user's input, and their choices determine the displayed rating.

### Layout Component

The `@flownet/react-layout-asya` library is used to control the layout or the appearance of the form-rating component on the screen, ensuring it fits seamlessly into the overall design of the webpage or application where it's utilized.

In conclusion, `@flownet/form-rating` serves as an easy-to-implement, user-friendly solution that enables end-users to rate an item, review, or experience, adding an interactive element to the content. The precision and flexible layout reflect the careful consideration of the user's expectations, making it a valuable tool for enhancing user engagement.
npm package: @flownet/form-text
Description: The project consists of a modern and user-friendly text input form that is built on top of the popular library React.js. The text form, developed via `@flownet/form-text`, focuses on providing an effortless and effective user engagement channel.
Latest version: 0.2.6

# @flownet/form-text

The project consists of a modern and user-friendly text input form that is built on top of the popular library React.js. The text form, developed via `@flownet/form-text`, focuses on providing an effortless and effective user engagement channel.

## Key Features

The text form is **intuitive and easily configurable**, with key functionalities including:

- **Text Input**: Users can input text into the form field. This text can be a single line or multiple lines.

- **Contain Redo Functionality**: When any modification is made to the value of the field, a change event is triggered and the new value is set.

- **Clipboard Functionality**: Users have the ability to copy all text entered into the input field. The 'Copy to Clipboard' functionality is provided as an end adornment of the input field, represented by an icon button. On copying, a notification pops up conveying the success of the copy operation.

- **Styling and Customization**: The look and feel of the text field can be easily modified according to the requirements as styling can be applied to the text input form. The customization allows control over properties like type, multiline, rows, required, placeholder, and variant. These properties define how the text field behaves and appears.

- **Read-only Mode**: The text input field can be made read-only, preventing any modifications.

- **Form Export**: The form allows external handling of setting values, being particularly useful when you need to update the form fields' value from outside the component.

Overall, this project creates a **versatile and user-friendly** text form mechanism contributing to improved user experience.
npm package: @flownet/lib-bpmn-from-flow
Description: **@flownet/lib-bpmn-from-flow** is a source code that provides a comprehensive approach to convert workflows into Business Process Model and Notation (BPMN) diagrams. Primarily, it serves as a BPMN generation tool for coding workflows in the 'flownet' env
Latest version: 0.1.10

# @flownet/lib-bpmn-from-flow

**@flownet/lib-bpmn-from-flow** is a source code that provides a comprehensive approach to convert workflows into Business Process Model and Notation (BPMN) diagrams. Primarily, it serves as a BPMN generation tool for coding workflows in the 'flownet' environment, where workflows are described as 'flows'. 

## Main functionalities
The primary purpose of this code is to automatically **generate graphical visualization of workflow diagrams** based on defined data structures. It embodies specific algorithms to convert workflows into BPMN diagrams, a standard for defining business processes in the form of a graphical flowchart. The BPMN diagrams help in visualizing an entire sequence of processes, from the start event to the end event. 

To establish this, the code fie uses the **DAGRE algorithm** (directed acyclic graph rendering algorithm) to establish BPMN layouts. It also uses the **bpmn-moddle** library to create and manipulate BPMN 2.0 xml diagrams.

Every 'node' in the workflow is converted into an element of a BPMN diagram using a set of conventions, attributes, and properties. The code can handle different workflow structures, including simple workflows to complex workflows with switches, sub-workflows, and modules. 

Notably, it also creates 'virtual nodes' to facilitate the conversion into BPMN diagrams. For instance, if a workflow node has multiple sequence flows going from it, a virtual 'switch' node is created to represent decision-making. 

The code also allows for creating 'subprocess nodes' to represent contained processes within a larger workflow. These subprocess nodes can themselves be broken down further into their internal nodes and flows, enabling a detailed analysis of the workflow at multiple levels. 

The generation of the BPMN diagram is not a one-step operation. Instead, the code uses a series of functions that handle different aspects of the BPMN diagram, including flow nodes, sequence flows, subprocess nodes, and overall layout and diagram arrangement. 

## End-User Perspective 
From an **end-user's perspective**, this code enables users to generate BPMN diagrams for existing workflows without any manual drawing. This can help end-users visualize, understand, and optimally manage workflow-based business processes. It can also facilitate documentation, review and improvement of the workflows.
npm package: @flownet/lib-load-browser-script-url
Description: The "@flownet/lib-load-browser-script-url" project is essentially a JavaScript library aimed to dynamically load external scripts into a browser environment.
Latest version: 0.2.3

# @flownet/lib-load-browser-script-url

The "@flownet/lib-load-browser-script-url" project is essentially a JavaScript library aimed to dynamically load external scripts into a browser environment. 

This piece of code provides a mechanism for loading and managing JavaScript resources in an HTML-based application dynamically. It generates a promise-based function, which allows asynchronous handling and offers a pipeline for error or success events.

## Functionality

### Dynamic Script Loading
The essence of this project's functionality is the ability to **dynamically load a script from a provided URL**. This might be useful in cases where applications might need to load scripts based on certain actions or conditions that arise during the runtime.

### Script Tag Management
Another central aspect is the **script tag management** functionality. The function checks whether a script with a given ID already exists in a document and creates a new script tag if it doesn't. This efficiently avoids unnecessary duplications of the same script.

### Error Handling
The script also includes **robust error handling** capabilities. It validates the input parameters and provides user-friendly error messages if invalid inputs are given. Also, it listens for error events that occur while loading the script. If such an event occurs, the function rejects the promise with the reason for the error.

### Event Handling
The project has built-in event handling abilities. When a script is successfully loaded, an 'onload' event is dispatched, and the promise is resolved. The original 'onload' event is retained and fired alongside the newly attached event. 

### Script Tag Attribute Management
The function also facilitates **script tag attribute management**, allowing the end-user to determine whether the script should be executed asynchronously with the 'async' attribute or deferred until the page has finished parsing with the 'defer' attribute. It also allows the addition of arbitrary attributes to the script tag. 

### Script Source Assignment & Append
After all the setup, the function then assigns the script source and appends the script tag to the document head. This allows the browser to load and execute the script in the context of the currently loaded document.
npm package: @flownet/lib-parse-node-url
Description: The project is essentially a URL parsing library built with a primary focus on handling and parsing URLs, making it significantly easier for developers to extract specific components of a URL. It uses the popular 'url-parse' module, which provides extensi
Latest version: 0.1.18

# @flownet/lib-parse-node-url

The project is essentially a URL parsing library built with a primary focus on handling and parsing URLs, making it significantly easier for developers to extract specific components of a URL. It uses the popular 'url-parse' module, which provides extensive functionalities for URL parsing.

## Functionality

Upon feeding a URL into the module's primary function, the software separates the URL into its various components, such as protocol, host, port, pathname, query, and fragment. This parsing functionality becomes critical when a developer needs to manipulate URLs or isolate particular sections from them. 

The library offers more versatility by giving you the option of feeding in a base URL. In such cases, the input URL is considered relative to this base URL. This is crucial when handling relative URLs, i.e., URLs that are incomplete or relate to a certain web address.

**isNull**: The function returns null if the input is not a valid URL, which could be beneficial in validating and sanitizing URL inputs.

The parser argument allows users to specify a custom parsing function, which can override the default parsing behavior. This feature could be handy when the users have specific parsing requirements that are not covered by the standard parsing behavior.

The library is relatively simple but can significantly streamline tasks that involve handling and manipulating URLs and provide custom parsing methods to adequately cater to unique requirements.
npm package: @flownet/lib-upload-files-to-gcs
Description: The @fnet/files-to-gcs project is fundamentally a **file uploader**. This utility primarily works by moving files from a local system directly onto Google's Cloud Storage platform. The code can not only organize and manage file uploads, but it also provid
Latest version: 0.3.7

# @fnet/files-to-gcs

The @fnet/files-to-gcs project is fundamentally a **file uploader**. This utility primarily works by moving files from a local system directly onto Google's Cloud Storage platform. The code can not only organize and manage file uploads, but it also provides configurable options that cater to different use-cases. 

## Core Functionality

The main functionality of this application revolves around the handling and manipulation of **file uploads**. The upload process starts by browsing and selecting files from the local file system, after which they can be set for transfer to Google Cloud Storage according to specific criteria and preferences set by the user.

In terms of versatile utilisation, the program allows for an optional **dry-run** mode, which essentially means that files are prepared for upload but are not actually transmitted to Google Cloud Storage. This feature is essentially used for testing and validation purposes. The results obtained in the dry-run mode can be verified, and only when they meet satisfaction, actual file uploading can be conducted. This provides users the convenience of ensuring everything is correct before committing to the upload, and it also avoids unnecessary data transfer.

Another crucial attribute of this piece of software is its ability to generate and assign URLs to uploaded files. It provides two types of URLs. By default, the URLs assigned to each file are hosted directly by Google Cloud Storage. However, users also have the option to assign custom domain names to these URLs if need be. 

The code also assigns **metadata** to uploaded files, such as the file's content type. Furthermore, it provides the ability for users to pass custom metadata during the file upload process. This metadata then gets attached to files and can be accessed later for reference or management purposes.

Lastly, a **verbose** option is available in the software, which when set to true, logs details about each file upload operation. This helps users track file uploads and verify whether each file has been successfully uploaded.

In summary, @fnet/files-to-gcs is a useful utility for users who need to transfer files from a local system onto Google Cloud Storage. The code's added functionality helps users adjust settings to meet their needs, makes sure the upload process is smooth, ensures that the files are organized and manageable, and guarantees that users have control over the upload right down to the file metadata.
npm package: @flownet/node-abcd
Description: The project comprised in the source code primarily functions as a **random nickname generator**. Its primary purpose is to create distinctive and humorous nicknames achieved by an artful combination of a random adjective and a random noun. The resulting n
Latest version: 0.1.2

# Node-1: Random Nickname Generator

The project comprised in the source code primarily functions as a **random nickname generator**. Its primary purpose is to create distinctive and humorous nicknames achieved by an artful combination of a random adjective and a random noun. The resulting nicknames are not only fun but also extremely unique by virtue of the randomized selection process.

## Functionality

Users can use this nickname generator to procure one or many random nicknames, where each nickname represents a combination of one noun and one adjective. The adjective and noun are selected randomly from a predefined list of 40 words (20 adjectives and 20 nouns) containing varying descriptions and species representations, effectively ensuring the **uniqueness of each nickname generated**.

### Number of Nicknames

The user can also determine the total count of nicknames needed. By default, if the user does not specify a count, the function will return one nickname. However, if a specific count is provided, the function will return an array containing the defined number of nicknames.

### Varied Nicknames

The function is designed to ensure extreme diversity in the nicknames provided to the user. This is achieved by meticulous selection of an adjective and a noun from two separate arrays, which means the total possible combination of nicknames, from an end-user's perspective, is the total size of adjective array times the total size of noun array (in this case, 20*20=400 unique possible nicknames).

### Output

The function’s output will be either a single nickname string (if count is 1) or an array of nicknames if the count relates to more than one. In every single instance, the user will have a fun and unique nickname to use.
npm package: @flownet/temp-reverse-text
Description: This code is a module in JavaScript that provides **text analysis functionality**. From an end-user's perspective, it helps users to analyze English text and extracts various pieces of information about the composition of the text.
Latest version: 0.1.1

# Text Analysis

This code is a module in JavaScript that provides **text analysis functionality**. From an end-user's perspective, it helps users to analyze English text and extracts various pieces of information about the composition of the text.

### Counting Vowels and Consonants

Primarily, the module counts the number of **vowels** and **consonants** in the given text. It does this by iterating through each character in the entered text string. If the character is included in the predefined list of vowels or consonants, it increases the corresponding count. In terms of casing, both lower and upper case characters are considered, making this function case-insensitive.

### Building a Character Histogram

Moreover, the code also builds a **histogram** of all alphabet characters (both lower and upper case) found in the text. This histogram is a representation of the letter distribution in the text. Each distinct alphabetic character found in the text is made a key in the histogram object, and its corresponding value gets incremented each time that character is encountered in the text.

### Returnstatement

Finally, the function returns an object containing the vowel count, the consonant count, and the histogram. This implies that the result of the function is easily accessible and can be further manipulated or displayed for end-users, thereby enabling a deeper understanding of the text composition.

The result gives a comprehensive summary of the text, providing users with an insight into the frequency of letters used in their text, including the comparative ratio of vowels to consonants. This could be useful in fields like linguistics, cryptography or even for plain text analysis.
npm package: @flownform/expo-mixpanel-analytics
Description: Mixpanel integration for use with React Native apps built on Expo 41.
Latest version: 1.3.1

Expo Mixpanel Analytics
=========

Mixpanel integration for use with React Native apps built on Expo.

Forked from `@bothrs/expo-mixpanel-analytics` to add support for Expo 41.

## Installation

```
npm install @flownform/expo-mixpanel-analytics --save
```

## Import

Your React Native app's screen resolution, app name, app ID, app version, device information will be automatically resolved and sent with each event.
```
import ExpoMixpanelAnalytics from '@benawad/expo-mixpanel-analytics';
```

## Usage
```
const analytics = new ExpoMixpanelAnalytics('5224da5bbbed3fdeaad0911820f1bf2x', { clientId: 'generatedClientId' });

analytics.init(); // returns a promise

analytics.identify('13793');

analytics.register({ email: 'bob@bob.com' }); // super props sent on every request and persisted in AsyncStorage

analytics.track('Signed Up', { 'Referred By': 'Friend' });

analytics.people_set({ '$first_name': 'Joe', '$last_name': 'Doe', '$email': 'joe.doe@example.com', '$created': '2013-04-01T13:20:00', '$phone': '4805551212', 'Address': '1313 Mockingbird Lane', 'Birthday': '1948-01-01' });

analytics.people_set_once({ 'First login date': '2013-04-01T13:20:00' });

analytics.people_unset([ 'Days Overdue' ]);

analytics.people_increment({ 'Coins Gathered': 12 });

analytics.people_append({ 'Power Ups': 'Bubble Lead' });

analytics.people_union({ 'Items purchased': ['socks', 'shirts'] });

analytics.people_delete_user();

analytics.reset();

```

## References
https://mixpanel.com/help/reference/http
npm package: @flownote/command-history
Description: Framework-agnostic command-pattern undo/redo history manager.
Latest version: 0.2.0

# @flownote/command-history

Framework-agnostic command-pattern undo/redo history manager.

Versioning: experimental `0.x` (breaking changes can ship in minor releases).

## Install

```bash
npm i @flownote/command-history
```

## API

- `Command` interface
- `History` class: `push`, `undo`, `redo`, `clear`, `canUndo`, `canRedo`
- Constructor options: `{ maxSize?: number }`

## Example

```ts
import { History, type Command } from "@flownote/command-history";

const history = new History({ maxSize: 200 });

const cmd: Command = {
  description: "Toggle flag",
  execute() {},
  undo() {},
};

history.push(cmd);
```
npm package: @flownote/core-geometry
Description: Framework-agnostic camera transforms and geometry helpers for canvas apps.
Latest version: 0.2.0

# @flownote/core-geometry

Framework-agnostic camera transforms and geometry primitives extracted from FlowNote.

Versioning: experimental `0.x` (breaking changes can ship in minor releases).

## Install

```bash
npm i @flownote/core-geometry
```

## API

- Types: `Point`, `Rect`, `WorldBounds`, `Camera`, `ResizeHandle`
- Functions: `screenToWorld`, `worldToScreen`, `getVisibleBounds`, `zoomAtPoint`, `lerp`, `pointInRect`, `aabbIntersects`, `distancePointToSegment`

## Example

```ts
import { screenToWorld, zoomAtPoint } from "@flownote/core-geometry";

const world = screenToWorld(200, 120, { x: 100, y: 80, z: 1.5 });
const nextCamera = zoomAtPoint({ x: 100, y: 80, z: 1.5 }, 200, 120, -100);
```
npm package: @flownote/diagram-core
Description: Framework-agnostic diagram domain logic for FlowNote-style editors.
Latest version: 0.2.0

# @flownote/diagram-core

Framework-agnostic diagram domain primitives extracted from FlowNote.

Versioning: experimental `0.x` (breaking changes can ship in minor releases).

## Install

```bash
npm i @flownote/diagram-core
```

## API

- Types: `DiagramItem`, `DiagramArrow`, `ItemType`, `LineStyle`, `ArrowHead`, `SelectionState`
- Pure helpers: `hitTestItems`, `hitTestArrows`, `resolveArrowEndpoints`, `computeResize`, `computeMarqueeSelection`, `nudgeSelection`, `duplicateItems`
- Mutation commands:
  - item: create, move, resize, delete, edit text, change color, multi-move, multi-delete
  - arrow: create, delete, style change, label edit

## Example

```ts
import {
  computeResize,
  hitTestItems,
  MoveItemCommand,
  type DiagramItem,
} from "@flownote/diagram-core";

const selected = hitTestItems(120, 90, items);
const nextBounds = computeResize({ x: 10, y: 10, w: 120, h: 80 }, "se", { x: 160, y: 130 });
const cmd = new MoveItemCommand(selected as DiagramItem, 10, 10, 30, 30);
```
npm package: @flowpay-io/embed-react
Description: Flowpay SDK - Embed client - React components and hooks
Author: Flowpay
Latest version: 1.2.0

# @flowpay-io/embed-react

React components and hooks for Flowpay embed integration.

## Installation

```bash
npm add @flowpay-io/embed-react
```

## Usage

**Using `useFlowpayEmbed` hook with `FlowpayEmbed` component (recommended):**

```typescript
import { FlowpayModal, useFlowpayEmbed } from "@flowpay-io/embed-react";
import { createSignedLogin } from "@flowpay-io/embed-auth/client";
import { IsoCountryCode } from "@flowpay-io/shared/types";
import { OverlayLoader } from "./components/OverlayLoader";
import "@flowpay-io/embed-react/assets/modal.css";

function App() {
  const flowpay = useFlowpayEmbed({
    embedOrigin: "https://my.flowpay.io",
    getLaunchPayload: async () => {
      return {
        country: IsoCountryCode.CZ,
        merchantId: "merchant-123",
        partnerCode: "partner-abc",
        userId: "user-456",
        regNum: "12345678",
        email: "user@example.com",
        phone: "+420123456789",
        // createdAt is optional - will be auto-generated by the client if autoSetCreatedAt is enabled (default: true)
      };
    },
    getLoginLocale: async () => "cs", // or from state / i18n
    signatureProvider: {
      signPayload: async (payload) => {
        // Use createSignedLogin to canonicalize, encode, and sign the payload
        // It delegates signature generation to your server (recommended)
        return await createSignedLogin(
          payload,
          async (canonicalPayload: string) => {
            const response = await fetch("/api/sign-payload", {
              method: "POST",
              body: JSON.stringify({ payload: canonicalPayload }),
            });
            const { signature } = await response.json();
            return signature;
          }
        );
      },
    },
  });

  return (
    <>
      {/* Open Flowpay button */}
      <button onClick={flowpay.open}>Open Flowpay</button>

      {/* optional: show loading overlay while Flowpay is loading */}
      <OverlayLoader isLoading={flowpay.isLoading} />

      {/* Flowpay modal */}
      <FlowpayModal
        client={flowpay.client}
        {...flowpay.modalProps}
        visible={flowpay.isActive}
      />
    </>
  );
}
```

## Links

- **Homepage**: [https://www.flowpay.io](https://www.flowpay.io)
- **Documentation**: [https://developers.flowpay.io](https://developers.flowpay.io)
npm package: @flowpay-io/offer
Description: Flowpay SDK - Offer calculation utilities
Author: Flowpay
Latest version: 2.2.2

# @flowpay-io/offer

Offer calculation and installment plan utilities.

## Installation

Use your favorite package manager (eg. `npm`) to install the Flowpay.js module:

```sh
$ npm add @flowpay-io/offer
```

## Usage

```js
// JS:
const flowpay = require('@flowpay-io/offer');

// TS:
import { PartnerOffer, ProductType calculateInstallmentPlan } from '@flowpay-io/offer';
```

Calculate installment plan with specified product parameters given provided
financing offer

```js
// JS:
var offer = {
  id: '1',
  products: [
    {
      product: 'M3',
      minAmount: 100000,
      maxAmount: 200000,
      currency: 'CZK',
      ratePerc: 1,
      balloon: true,
      installmentCount: 3,
      prolongationEnabled: true,
      postponeEnabled: false,
      maxPostponeLength: 0,
      maxProlongationLength: 2,
      interestRateMultiplier: 1,
      postponeFeeMultiplier: 1,
      prolongationFeeMultiplier: 1,
    },
  ],
};

var plan = flowpay.calculateInstallmentPlan(
  offer,
  'M3',
  100000,
  new Date('2022-01-03'),
  0,
  false
);

console.log(plan);

// TS:
const offer: PartnerOffer = {
  id: '1',
  products: [
    {
      product: ProductType.M3,
      minAmount: 100000,
      maxAmount: 200000,
      currency: 'CZK',
      ratePerc: 1,
      balloon: true,
      installmentCount: 3,
      prolongationEnabled: true,
      postponeEnabled: false,
      maxPostponeLength: 0,
      maxProlongationLength: 2,
      interestRateMultiplier: 1,
      postponeFeeMultiplier: 1,
      prolongationFeeMultiplier: 1,
    },
  ],
};

const eligible = checkEligibility(offer, ProductType.M3, 100000, 0, false);

const plan = calculateInstallmentPlan(
  offer,
  ProductType.M3,
  100000,
  new Date('2022-01-03'),
  0,
  false
);

console.log(plan);
```

## Links

- **Homepage**: [https://www.flowpay.io](https://www.flowpay.io)
- **Documentation**: [https://developers.flowpay.io](https://developers.flowpay.io)
npm package: @flowpay/flowpay-js
Description: Flowpay.js
Author: Flowpay
Latest version: 2.2.1

# Flowpay.js

## Installation

Use `npm` to install the Flowpay.js module:

```sh
$ npm install --save @flowpay/flowpay-js
```

## Usage

```js
// JS:
const flowpay = require('@flowpay/flowpay-js');

// TS:
import { PartnerOffer, ProductType calculateInstallmentPlan } from '@flowpay/flowpay-js';
```

Calculate installment plan with specified product parameters given provided
financing offer

```js
// JS:
var offer = {
  id: '1',
  products: [
    {
      product: 'M3',
      minAmount: 100000,
      maxAmount: 200000,
      currency: 'CZK',
      ratePerc: 1,
      balloon: true,
      installmentCount: 3,
      prolongationEnabled: true,
      postponeEnabled: false,
      maxPostponeLength: 0,
      maxProlongationLength: 2,
      interestRateMultiplier: 1,
      postponeFeeMultiplier: 1,
      prolongationFeeMultiplier: 1,
    },
  ],
};

var plan = flowpay.calculateInstallmentPlan(
  offer,
  'M3',
  100000,
  new Date('2022-01-03'),
  0,
  false
);

console.log(plan);

// TS:
const offer: PartnerOffer = {
  id: '1',
  products: [
    {
      product: ProductType.M3,
      minAmount: 100000,
      maxAmount: 200000,
      currency: 'CZK',
      ratePerc: 1,
      balloon: true,
      installmentCount: 3,
      prolongationEnabled: true,
      postponeEnabled: false,
      maxPostponeLength: 0,
      maxProlongationLength: 2,
      interestRateMultiplier: 1,
      postponeFeeMultiplier: 1,
      prolongationFeeMultiplier: 1,
    },
  ],
};

const plan = calculateInstallmentPlan(
  offer,
  ProductType.M3,
  100000,
  new Date('2022-01-03'),
  0,
  false
);

console.log(plan);
```
npm package: @flowpilot/sdk
Description: The official TypeScript/JavaScript SDK for Flow Pilot, enabling seamless integration of AI-powered chat capabilities into your applications.
Latest version: 2.0.0-rc-5

# @flowpilot/sdk

The official TypeScript/JavaScript SDK for Flow Pilot, enabling seamless integration of AI-powered chat capabilities into your applications.

## Installation

```bash
npm install @flowpilot/sdk
# or
yarn add @flowpilot/sdk
```

## Quick Start

```typescript
import { FlowPilot } from '@flowpilot/sdk';

// Initialize the SDK
const flowPilot = new FlowPilot({
  apiKey: 'your-sdk-api-key',
  app: {
    id: 'your-app-id',
    environmentId: 'your-environment-id',
    apiBaseURL: 'https://api.your-app.com'
  },
  getAuthToken: async () => {
    // Return your app's auth token
    return 'your-auth-token';
  }
});

// Start chatting
const response = await flowPilot.chat('Hello!');
console.log(response);
```

## Configuration

The SDK requires the following configuration parameters:

| Parameter | Type | Description |
|-----------|------|-------------|
| `apiKey` | `string` | Your Flow Pilot SDK API key |
| `app.id` | `string` | Your application ID |
| `app.environmentId` | `string` | Your environment ID |
| `app.apiBaseURL` | `string` | Base URL for your application's API |
| `getAuthToken` | `() => Promise<string>` | Function that returns your app's authentication token |



## Chat API

The SDK provides a simple chat interface:

```typescript
// Basic chat
const response = await flowPilot.chat('What are today\'s tasks?');

// Chat with thread ID for conversation continuity
const response = await flowPilot.chat('What are today\'s tasks?', {
  threadId: 'unique-thread-id'
});
```

### Thread Management

- If no `threadId` is provided, a new thread is automatically created
- Use the same `threadId` to continue a conversation
- Each thread maintains its own conversation context

## Error Handling

```typescript
try {
  const response = await flowPilot.chat('Hello');
} catch (error) {
  console.error('Chat error:', error);
}
```

## TypeScript Support

The SDK is written in TypeScript and provides full type definitions out of the box.

```typescript
import { FlowPilot, FlowPilotSDKArgs } from '@flowpilot/sdk';

const config: FlowPilotSDKArgs = {
  apiKey: 'your-sdk-api-key',
  app: {
    id: 'your-app-id',
    environmentId: 'your-environment-id',
    apiBaseURL: 'https://api.your-app.com'
  },
  getAuthToken: async () => 'your-auth-token'
};
```

## License

MIT
npm package: @flowplayer/react-flowplayer
Description: Flowplayer React Component
Author: Flowplayer AB
Latest version: 1.2.6

# react-flowplayer
![React version](https://img.shields.io/badge/react->=17.0.2-58c4dc?style=flat)
[![NPM version](https://img.shields.io/npm/v/@flowplayer/react-flowplayer.svg?style=flat)](https://npmjs.com/package/@flowplayer/react-flowplayer) 
[![NPM downloads](https://img.shields.io/npm/dm/@flowplayer/react-flowplayer.svg?style=flat)](https://npmjs.com/package/@flowplayer/react-flowplayer)

<br>
<div>
<a href="https://www.wowza.com">
  <img src="./logo.svg" width="640">
</a>
</div>
<br>

**react-flowplayer** is the preferred way to use Flowplayer with the React framework. 

### Resources
<!-- [Documentation](https://developer.wowza.com/docs/wowza-flowplayer/guides/add-the-player-using-typescript.md/) -->
* [Examples and Guides](https://developer.wowza.com/docs/wowza-flowplayer/player/components/react/)
* [Releases](https://github.com/flowplayer/react-flowplayer/releases)
* [Support](https://www.wowza.com/support)