open-index/open-npm huggingface dataset:
npm package: @talmobi/faucet
Description: human-readable TAP summarizer
Author: James Halliday
Latest version: 0.0.3

# faucet

human-readable TAP summarizer

# example

Pipe TAP text into the `faucet` command, get back pretty results:

![piping tap](images/test.gif)

You can use any runner you want to generate the TAP output. Here we'll use
[tape](https://npmjs.org/package/tape):

![tape runner](images/falafel.gif)

You can give the `faucet` command a list of files:

![list of files](images/gutter.gif)

or if you just type `faucet`, any js files in `test/` or `tests/` will be run
using the `tape` command internally:

![implicit test/ directory](images/dnode.gif)

# install

To get the `faucet` command, with [npm](https://npmjs.org) do:

```
npm install -g faucet
```

# generating TAP

The great thing about TAP is that it's inherently serializable on stdout, so you
can use whichever libraries you wish to generate it.

Many test libraries have ways to get TAP output.

[tape](https://npmjs.org/package/tape) and [tap](https://npmjs.org/package/tap)
will give you TAP output by default.

With a [tape](https://npmjs.org/package/tape) test, you would just write
a `test.js` like:

``` js
var test = require('tape');

test('beep boop', function (t) {
    t.plan(2);
    
    t.equal(1 + 1, 2);
    setTimeout(function () {
        t.deepEqual(
            'ABC'.toLowerCase().split(''),
            ['a','b','c']
        );
    });
});
```

and then just run the file with `node test.js` to get the TAP output:

```
TAP version 13
# beep boop
ok 1 should be equal
ok 2 should be equivalent

1..2
# tests 2
# pass  2

# ok
```

or if you have a directory of files, you can use the `tape` command that you get
when you `npm install -g tape`:

```
$ tape test/*.js
TAP version 13
# stream in a stream
ok 1 should be equivalent
# expand a streams1 stream
ok 2 should be equivalent
# expand a streams2 stream
ok 3 should be equivalent
# expand a streams2 stream with delay
ok 4 should be equivalent

1..4
# tests 4
# pass  4

# ok

```

To get TAP out of [mocha](https://npmjs.org/package/mocha), do `mocha -R tap`:

```
$ mocha -R tap
1..17
ok 1  shim found
ok 2  core shim not found
ok 3  false file
ok 4  false module
ok 5  local
ok 6  index.js of module dir
ok 7  alternate main
ok 8  string browser field as main
ok 9  string browser field as main - require subfile
ok 10  object browser field as main
ok 11  object browser field replace file
ok 12  object browser field replace file - no paths
ok 13  replace module in browser field object
ok 14  replace module in object browser field with subdirectory
ok 15  replace module in object browser field with subdirectory containing
package.json
ok 16  replace module in object browser field with subdirectory containing
package.json with string browser field as main
ok 17  replace module in object browser field with subdirectory containing
package.json with object browser field as main
# tests 17
# pass 17
# fail 0
```

Once you've got a way to get TAP out of your tests, just pipe into `faucet`:

![mocha pipe](images/mocha.gif)

# usage

```
usage:
  faucet [FILES]
  command | faucet
```

# license

MIT
npm package: @talmobi/rollup-watch
Description: Watch files for changes and perform incremental rebuilds with Rollup
Author: Rich Harris
Latest version: 4.0.2

# rollup-watch

This module is used by the [Rollup](https://rollupjs.org) command line interface to enable automatic incremental rebuilds.

Install it to your project like so...

```bash
npm install --save-dev rollup-watch
```

...then invoke it by adding the `--watch` flag (or `-w`) to the command that starts Rollup. In this example, `npm run dev` will create your bundle then recreate it whenever its sources change:

```js
// package.json
{
  // ...
  "scripts": {
    "build": "rollup -c",
    "dev": "rollup -c -w"
  }
}
```
npm package: @talmobi/yt-play
Description: play youtube video id with electron
Author: talmobi
Latest version: 0.0.7

[![npm](https://img.shields.io/npm/v/@talmobi/yt-play.svg?maxAge=3600&style=flat-square)](https://www.npmjs.com/package/@talmobi/yt-play)
[![npm](https://img.shields.io/npm/l/@talmobi/yt-play.svg?maxAge=3600&style=flat-square)](https://github.com/talmobi/yt-play/blob/master/LICENSE)

#  @talmobi/yt-play
DEPRECATED! Package renamed to [yt-play-cli](https://www.npmjs.com/package/yt-play-cli)

![](https://thumbs.gfycat.com/OrnateWeirdCollie-size_restricted.gif)

## Simple to use
```bash
npm install -g @talmobi/yt-play

# play known video id directly
yt-play rnQBF2CIygg
```

or

```bash
npm install -g @talmobi/yt-play

# enter interactive search and select mode
yt-play
```

## About
Play youtube videos ( music only ) from the CLI using [electron](https://github.com/electron/electron).

Uses [yt-search](https://github.com/talmobi/yt-search) and [node-fzf](https://github.com/talmobi/node-fzf) to search for videos to play if no CLI videoId argument is provided.

## Why
To test/try/play around with electron.

## How
Using [electron](https://github.com/electron/electron) we simply go to the youtube page and play
the video.. and attach some video event listeners and block ads.

Leaving video id cli argument empty you will enter search and select mode using [yt-search](https://github.com/talmobi/yt-search) and [node-fzf](https://github.com/talmobi/node-fzf)

## Arguments
```bash
$ yt-play [youtube-video-id]
```
If no video id is provided you will enter interactive search and select mode.

## Installation
```bash
npm install -g @talmobi/yt-play
```

## Test
No tests..
npm package: @talos-group/dynamic-controls
Description: This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
Author: Talos
Latest version: 1.0.0

# TalosControls

This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.

## Code scaffolding

Run `ng generate component component-name --project talos-controls` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project talos-controls`.
> Note: Don't forget to add `--project talos-controls` or else it will be added to the default project in your `angular.json` file. 

## Build

Run `ng build talos-controls` to build the project. The build artifacts will be stored in the `dist/` directory.

## Publishing

After building your library with `ng build talos-controls`, go to the dist folder `cd dist/talos-controls` and run `npm publish`.

## Running unit tests

Run `ng test talos-controls` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
npm package: @talqui-oss/tiptap-extension-variable
Description: Variable extension for tiptap by Talqui
Latest version: 0.0.6

# tiptap-extension-variable

## Introduction

Tiptap is a headless wrapper around [ProseMirror](https://ProseMirror.net) – a toolkit for building rich text WYSIWYG editors, which is already in use at many well-known companies such as _New York Times_, _The Guardian_ or _Atlassian_.

## Official Documentation

Documentation can be found on the [Tiptap website](https://tiptap.dev).

## License

Tiptap is open sourced software licensed under the [MIT license](https://github.com/ueberdosis/tiptap/blob/main/LICENSE.md).

## Usage

```javascript
//es-6
import { VueRenderer } from "@tiptap/vue-3";
import tippy from "tippy.js";
import VariableList from "./VariableList.vue";

new Editor({
  extensions: [
    Variable.configure({
      suggestion: {
        render: () => {
          let component;
          let popup;

          return {
            onStart: (props) => {
              component = new VueRenderer(VariableList, {
                props,
                editor: props.editor,
              });

              if (!props.clientRect) {
                return;
              }

              popup = tippy("body", {
                getReferenceClientRect: props.clientRect,
                content: component.element,
                showOnCreate: true,
                interactive: true,
                trigger: "manual",
                placement: "bottom-start",
              });
            },

            onUpdate(props) {
              component.updateProps(props);

              if (!props.clientRect) {
                return;
              }

              popup[0].setProps({
                getReferenceClientRect: props.clientRect,
              });
            },

            onKeyDown(props) {
              if (props.event.key === "Escape") {
                popup[0].hide();

                return true;
              }

              return component?.ref?.onKeyDown(props);
            },

            onExit() {
              popup[0]?.destroy();
              component.destroy();
            },
          };
        },
      },
    }),
  ]
});
```