open-index/open-npm huggingface dataset:
npm package: @jfhbrook/fake-progress-not-frozen
Description: a shitpost-y fake progress bar
Author: Josh Holbrook
Latest version: 1.1.0

# FAKE PROGRESS: (NOT frozen)

![](https://i.imgur.com/QtQUZUo.png)

a ridiculous fake progress bar to show that the app is still working

## example

this is a full example, which you can also run with `node ./example.js` in
this repo:

```js
var chalk = require('chalk');
var Ticker = require('./');

var ticker = new Ticker();

function log(message) {
  console.log(chalk.green('info') + ':   ' + message);
}

log('about to do something that will take a while...');

var SECONDS = 1000;
var howLong = 15 * SECONDS;

ticker.start();

setTimeout(function () {
  ticker.stop(function (err) {
    if (err) throw err;
    log('all done!');
  });
}, howLong);
```

this example was used to generate the above screenshot.

## license

MIT!
npm package: @jfhbrook/just
Description: a wrapper for casey/just
Author: Josh Holbrook
Latest version: 1.0.0

# @jfhbrook/just

a wrapper for [casey/just](https://github.com/casey/just).

I like using just to coordinate running pipelines of *mostly* shell code,
something node is mediocre for at best. but I sometimes want to use it from
wrapper scripts, which may have more sophisticated options parsing, configure
environments, and so on. other times, I want to have tighter integration
between [gulp](https://gulpjs.com/) and just. this lil library helps.

## examples

### running a just recipe

suppose you bundle a `justfile` in your node app:

```justfile
# ./justfile

set dotenv-load := false

hello message:
  echo "{{message}}"
```

here's how you can execute `just hello world` from nodejs:

```js
// ./index.js

const path = require('path');
const { Just } = require('@jfhbrook/just');

(async function main() {
  const just = new Just(path.join(__dirname, 'justfile'));

  // just hello world
  await just.run('hello', 'world');
})();
```

### calling just recipes from gulp (beta)

here's how you can get gulp-cli to run just recipes:

```js
const path = require('path');

const { registry, series } = require('gulp');

const { JustRegistry } = require('@jfhbrook/just/gulp');

registry(new JustRegistry(path.join(__dirname, 'justfile')));

exports.default = series('just:task');
```

I haven't figured out how to pass parameters to just in a reasonable way yet,
so expect this to change quite a bit.

## install

in order for this to work, you'll need to install just. your package manager
probably has it, and cargo definitely has it. I might bundle a few builds
in the future but haven't decided to yet.

afterwards, run `npm install @jfhbrook/just` and you should be off to the
races.

## api

### Just

```js
const just = new Just(JUSTFILE);
```

create a new just instance with the supplied `justfile`.

### just.run

```js
await just.run(...args)
```

run a just command, using the instance's `justfile`. stdio are inherited and
non-zero exits will throw an error.

my needs don't require piping the output elsewhere and finding an ergonomic
child process api in node is a yak I am NOT shaving today.

### just.dump

```js
const dump = await just.dump();
```

runs `just --unstable --dump --dump-format json` and parses and returns the
results. note the `--unstable` flag - I've historically had to install a
beta version of `just` to get it working. idk if that's still required today
because I haven't messed with it in a while!

## development

I actually wrote tests!! you can run them with `npm test`.

no linting or prettifier. I think my code is pretty.

## license

MIT!
npm package: @jfhbrook/viu
Description: viu - the rust terminal image viewer - distributed on npm
Author: Josh Holbrook
Latest version: 1.4.8

# an npm distribution and wrapper for viu

## what

[viu](https://github.com/atanunq/viu) is a terminal image viewer written in
rust that is pretty nice! this package distributes and wraps viu with npm.

## how?

give this a shot:

```bash
npx @jfhbrook/viu ./buddy.jpg
```

or, call the API:

```js
const viu = require('@jfhbrook/viu');

(async () => {
  await viu('buddy.jpg');
})();
```

## no, I mean *how??*

before publishing, I download and unpack an official release tarball for viu and
use [cross](https://github.com/cross-rs/cross) to build viu for common
architectures:

- linux x64
- linux aarch64
- linux arm32 (targeting raspberry pi)
- windows x64

then, after install, if there isn't a matching pre-built binary, npm will
attempt to build viu from source.

finally, at runtime, if a viu binary can't be found - either pre-built or built
on install - we check the `PATH` to see if viu is already installed for the
user as a last-ditch effort.

## why?!

"but josh, why don't you use [sidre sorhus's terminal-image](https://github.com/sindresorhus/terminal-image),
which is in pure javascript?

terminal-image is great, but it has fewer features than viu - namely, viu supports
[kitty's](https://sw.kovidgoyal.net/kitty/graphics-protocol/) graphics protocol
in addition to iterm's.

on the other hand, this package is a little chonky - it includes a bunch of
binary builds after all - and will fail when an architecture is unsupported
and cargo isn't installed.

if you want the best of both worlds, consider installing *both*, trying viu
first, and using terminal-image as a fallback.

## version info

ideally, the version of this package will be the same as the version of viu
that it includes. however, intermediate changes at the package level will require
bumping the patch version when publishing to npm. in other words, the patch
version may be ahead of viu's, but the major and minor should match.

I haven't had a need to make sweeping changes to this module; if/when I do,
I'll revisit this strategy.

## license

This wrapper is released under an MIT license, as is viu.
npm package: @jfhector/reverse-sentence
Description: Some info
Author: J.F. Hector-Labram
Latest version: 0.1.0

## Install

```sh

npm install @jfhector/reverse-sentence

```

## API

```js

require("reverse-sentence") => Function

reverse(sentence) => String

```

## Example

```js

const reverseSentence = require("reverse-sentence");

const sentence = "Hello Beth!";

const reversed = reverseSentence(sentence);

console.log(reversed) // Beth! Hello

```

## License

MIT
npm package: @jfierro/utils
Description: para utilidades y pruebas de concepto
Latest version: 0.5.0

# @jfierro/utils

An amazing lib.

## Install

```bash
npm install @jfierro/utils
```

## Use

```typescript
import { sum } from '@jfierro/utils';

console.log(sum(1, 2)); // 3
```

## CHANGELOG

View [CHANGELOG.md](./CHANGELOG.md)