open-index/open-npm huggingface dataset:
npm package: @rifo/ngx-ace
Description: Ace editor for Angular
Author: Ofir Fridman
Latest version: 0.0.5

# Angular Ace Editor 

This library bring the great Ace editor from Cloud9 to Angular

Ace is a code editor written in JavaScript with a great performance and have a lot of features.

# Getting started

## Install

`npm i @rifo/ngx-ace`

# Original JavaScript Ace Library
[Ace Playground](https://ace.c9.io/build/kitchen-sink.html)

[More about Ace](https://github.com/ajaxorg/ace)
npm package: @rifo/pulse-loader
Description: angular pulse loader
Author: Ofir Fridman
Latest version: 0.0.4

# PulseLoader

```
              _                _                 _
  _ __  _   _| |___  ___      | | ___   __ _  __| | ___ _ __
 | '_ \| | | | / __|/ _ \_____| |/ _ \ / _` |/ _` |/ _ \ '__|
 | |_) | |_| | \__ \  __/_____| | (_) | (_| | (_| |  __/ |
 | .__/ \__,_|_|___/\___|     |_|\___/ \__,_|\__,_|\___|_|
 |_|
```

<p align="center">
    <img src="https://media.giphy.com/media/M9IRI3CpCTEGSvkmOw/giphy.gif">
</p>

## [Demo](https://ofirrifo.github.io/pulse-loader)

## [Example](https://stackblitz.com/edit/pulse-loader-example)

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)

## Installation
```sh
npm i @rifo/pulse-loader 
```

## Usage

**IMPORT MODULE**
```js

// import PulseLoaderModule
import { PulseLoaderModule } from '@rifo/pulse-loader';

@NgModule({
  imports:      [ BrowserModule, PulseLoaderModule ],
  declarations: [ AppComponent ],
  bootstrap:    [ AppComponent ]
})
export class AppModule { }

```

**COMPONENT USAGE**
```js

import { Component } from '@angular/core';

@Component({
  selector: 'my-app',
  template: `	<ngx-pulse-loader [color]="color" [width]="width"></ngx-pulse-loader>`,
  styleUrls: ['./app.component.scss']
})
export class AppComponent {
    color = '#1abc9c';
    width = '13px';
}
```
npm package: @rifo/rxjs-polling
Description: RxJS HTTP Polling
Author: Ofir Fridman
Latest version: 1.0.0

# RxjsPolling
This library come to aid when we need to do polling requests.
The library take care to do the polling when data is resolved.
This strategy help us to prevent send requests before the previous request return.


## Prerequisites
project have dependencies that require rxjs 6.4.0 or higher.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Demo](https://ofirrifo.github.io/rxjs-polling)
- [Example](https://stackblitz.com/edit/rxjs-polling-example-1?file=src/app/app.component.ts)

## Installation
```sh
npm i @rifo/rxjs-polling 
```

## Usage
```js
import { Component } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { pollingOnResolved } from '@rifo/rxjs-polling';

@Component({
  selector: 'app-root',
  templateUrl: `<div>{{response$ | async}}</div>`,
  styleUrls: ['./app.component.scss']
})
export class AppComponent {
  response$: Observable<string>;
  constructor(private http: HttpClient) {
     const httpRequest$ = this.http.get(`https://blockchain.info/ticker`);
     this.response$ = pollingOnResolved(httpRequest$, 2_000);
  }
}
```
npm package: @rifqiadityaa/providers-clone
Description: Package that contains all the providers of movie-web
Author: movie-web
Latest version: 1.0.0

# @movie-web/providers

package that holds all providers of movie-web.
Feel free to use for your own projects.

features:
- scrape popular streaming websites
- works in both browser and server-side

Visit documentation here: https://movie-web.github.io/providers/

## How to run locally or test my changes

These topics are also covered in the documentation, [read about it here](https://movie-web.github.io/providers/extra-topics/development).
npm package: @riftlinks/sdk
Description: Rift web SDK — deep link click tracking and resolution
Latest version: 0.1.1

# @riftlinks/sdk

Rift web SDK — automatic deep link click tracking with zero configuration per link.

## Install

```bash
npm install @riftlinks/sdk
```

## Usage

```typescript
import { Rift } from '@riftlinks/sdk';

Rift.init("pk_live_YOUR_KEY", { domain: "go.yourcompany.com" });
```

That's it. Every `<a href="https://go.yourcompany.com/...">` on your page is automatically tracked. No attributes, no event handlers, no per-link setup.

### Script tag

```html
<script src="https://api.riftl.ink/sdk/rift.js"></script>
<script>
  Rift.init("pk_live_YOUR_KEY", { domain: "go.yourcompany.com" });
</script>
```

## API

### `Rift.init(publishableKey, opts?)`

Initialize the SDK. Pass `domain` to enable automatic click tracking.

| Param | Type | Description |
|-------|------|-------------|
| `publishableKey` | `string` | Your publishable key (`pk_live_` prefix) |
| `opts.domain` | `string` | Your custom link domain (e.g. `go.yourcompany.com`) |
| `opts.baseUrl` | `string` | API base URL (default: `https://api.riftl.ink`) |

### `Rift.click(linkId, opts?)`

Manually record a click. Not needed when using domain-based auto-tracking.

| Param | Type | Description |
|-------|------|-------------|
| `linkId` | `string` | The link ID to track |
| `opts.domain` | `string` | Custom domain for clipboard URL |

### `Rift.getLink(linkId, opts?)`

Fetch link data (metadata, destinations, agent context) without navigating.

```typescript
const link = await Rift.getLink("summer-sale");
console.log(link.agent_context);
```

## How it works

1. `Rift.init()` registers a click listener on `document`
2. When a user clicks any `<a>` tag whose `href` matches your domain, the SDK fires a `sendBeacon` to record the click
3. Navigation proceeds normally — Universal Links open the app if installed, otherwise the landing page loads
4. Click tracking is fire-and-forget and never blocks navigation

## Links

- [Documentation](https://www.riftl.ink/docs/web-sdk)
- [API Reference](https://www.riftl.ink/api-reference)
- [GitHub](https://github.com/saltyskip/rift)
npm package: @riftresearch/otc-api
Description: TypeScript clients for Rift RFQ and OTC APIs
Latest version: 0.2.0

# @riftresearch/otc-api

TypeScript clients for Rift's RFQ and OTC APIs.

## Install

```bash
npm install @riftresearch/otc-api
```

## Usage

```ts
import { RfqClient, OtcClient, exactInput, BTC, CBBTC_BASE } from '@riftresearch/otc-api'

const rfq = new RfqClient({ baseUrl: 'https://rfq.rift.trade' })
const otc = new OtcClient({ baseUrl: 'https://otc.rift.trade' })

const quote = await rfq.requestQuote(
  {
    from: BTC,
    to: CBBTC_BASE,
    mode: exactInput(100_000),
  },
  {
    protocolFeeBps: 0,
    apiSecret: process.env.RFQ_API_SECRET,
  },
)

const swap = await otc.createSwap({
  quote: quote.quote,
  destination_address: '0x...',
  refund_address: 'bc1q...',
})
```
npm package: @rifttech/xcell
Description: [![npm version](https://badge.fury.io/js/%40rifttech%2Fxcell.svg)](https://badge.fury.io/js/%40rifttech%2Fxcell)
Latest version: 0.0.7

# XCELL - ALPHA-26 format converter

[![npm version](https://badge.fury.io/js/%40rifttech%2Fxcell.svg)](https://badge.fury.io/js/%40rifttech%2Fxcell)

## How to use

### Install

`npm install @rifttech/xcell`

or...

`yarn add @rifttech/xcell`

### Example
Well, it's pretty straightforward.

```js
import {
    getIndexFromColumnName,
    getColumnNameFromIndex
} from "@rifttech/xcell";

console.log(getIndexFromColumnName("A")); // prints 0
console.log(getColumnNameFromIndex(0)); // prints A
```
npm package: @rigby-software-house/medusa-plugin-webhook
Description: Medusa webhook plugin
Author: Rigby
Latest version: 0.1.1

# Medusa Webhook Plugin

### Usage with Next.js

```ts
// app/api/webhook/route.ts
import { revalidateTag } from "next/cache";
import { type NextRequest, NextResponse } from "next/server";
import { verifyWebhook } from "@rigby-software-house/medusa-webhook";

export async function POST(req: NextRequest) {
  try {
    const secret = process.env.MEDUSA_WEBHOOK_SECRET;
    if (!secret) {
      return new Response(
        "Missing environment variable MEDUSA_WEBHOOK_SECRET",
        { status: 500 }
      );
    }

    const { isValidSignature, tags } = await verifyWebhook(req, secret);

    if (!isValidSignature) {
      const message = "Invalid signature";
      return new Response(JSON.stringify({ message }), {
        status: 401,
      });
    } else if (!Array.isArray(tags) || !tags.length) {
      const message = "Bad Request";
      return new Response(JSON.stringify({ message, tags }), { status: 400 });
    }

    tags.forEach((tag) => {
      revalidateTag(tag);
    });

    return NextResponse.json({ tags });
  } catch (err) {
    console.error(err);
    return new Response((err as Error).message, { status: 500 });
  }
}
```