open-index/open-npm huggingface dataset:
npm package: @fromage/cli-plugin-unit-jest
Description: unit-jest plugin for vue-cli
Author: Evan You
Latest version: 5.0.79

# @fromage/cli-plugin-unit-jest

> unit-jest plugin for vue-cli

## Injected Commands

- **`vue-cli-service test:unit`**

  Run unit tests with Jest. Default `testMatch` is `<rootDir>/(tests/unit/**/*.spec.(js|jsx|ts|tsx)|**/__tests__/*.(js|jsx|ts|tsx))` which matches:

  - Any files in `tests/unit` that end in `.spec.(js|jsx|ts|tsx)`;
  - Any js(x)/ts(x) files inside `__tests__` directories.

  Usage: `vue-cli-service test:unit [options] <regexForTestFiles>`

  All [Jest command line options](https://facebook.github.io/jest/docs/en/cli.html) are also supported.

## Debugging Tests

Note that directly running `jest` will fail because the Babel preset requires hints to make your code work in Node.js, so you must run your tests with `vue-cli-service test:unit`.

If you want to debug your tests via the Node inspector, you can run the following:

```sh
# macOS or linux
node --inspect-brk ./node_modules/.bin/vue-cli-service test:unit

# Windows
node --inspect-brk ./node_modules/@fromage/cli-service/bin/vue-cli-service.js test:unit
```

## Configuration

Jest can be configured via `jest.config.js` in your project root, or the `jest` field in `package.json`.

## Installing in an Already Created Project

```sh
vue add @fromage/unit-jest
```

## Transform dependencies from `/node_modules`

By default, jest doesn't transform anything from `/node_modules`.

Since jest runs in node, we also don't have to transpile anything that uses modern ECMAScript features as Node >=8 already supports these features, so it's a sensible default. cli-plugin-jest also doesn't respect the `transpileDependencies` option in `vue.config.js` for the same reason.

However, we have (at least) three cases where we do need to transpile code from `/node_modules` in jest:

1. Usage of ES6 `import`/`export` statements, which have to be compiled to commonjs `module.exports`
2. Single File Components (`.vue` files) which have to be run through `vue-jest`
3. Typescript code

To do this, we need to add an exception to the `transformIgnorePatterns` option of jest. This is its default value:

```javascript
transformIgnorePatterns: ['/node_modules/']
```

We have to add exceptions to this pattern with a RegExp negative lookahead:

```javascript
transformIgnorePatterns: ['/node_modules/(?!name-of-lib-o-transform)']
```

To exclude multiple libraries:

```javascript
transformIgnorePatterns: ['/node_modules/(?!lib-to-transform|other-lib)']
```
npm package: @fromage/cli-plugin-unit-mocha
Description: mocha unit testing plugin for vue-cli
Author: Evan You
Latest version: 5.0.79

# @fromage/cli-plugin-unit-mocha

> unit-mocha plugin for vue-cli

## Injected Commands

- **`vue-cli-service test:unit`**

  Run unit tests with [mocha-webpack](https://github.com/zinserjan/mocha-webpack) + [chai](http://chaijs.com/).

  **Note the tests are run inside Node.js with browser environment simulated with JSDOM.**

  ```
  Usage: vue-cli-service test:unit [options] [...files]

  Options:

    --watch, -w   run in watch mode
    --grep, -g    only run tests matching <pattern>
    --slow, -s    "slow" test threshold in milliseconds
    --timeout, -t timeout threshold in milliseconds
    --bail, -b    bail after first test failure
    --require, -r require the given module before running tests
    --include     include the given module into test bundle
    --inspect-brk Enable inspector to debug the tests
  ```

  Default files matches are: any files in `tests/unit` that end in `.spec.(ts|js)`.

  All [mocha-webpack command line options](http://zinserjan.github.io/mocha-webpack/docs/installation/cli-usage.html) are also supported.

## Installing in an Already Created Project

``` sh
vue add @fromage/unit-mocha
```
npm package: @fromage/cli-ui
Description: Before starting a local cli-ui instance, consider following the [contributing guide](https://github.com/vuejs/vue-cli/blob/dev/.github/CONTRIBUTING.md) in order to download all required dependencies of vue-cli's packages.
Author: Guillaume Chau
Latest version: 5.0.79

# @fromage/cli-ui

### Local development

Before starting a local cli-ui instance,
consider following the [contributing guide](https://github.com/vuejs/vue-cli/blob/dev/.github/CONTRIBUTING.md)
in order to download all required dependencies of vue-cli's packages.

Just after, you should build once then serve `@fromage/cli-ui-addon-webpack` by running:
```bash
cd ../cli-ui-addon-webpack
yarn build # just do once
yarn serve
```

Then you start the ui server (based on Apollo):

```
cd ../cli-ui
yarn run apollo
```

And then in another terminal, you should serve the ui web app:

```
yarn run serve
```

#### Testing

For running E2E tests, you just need to run:

```
yarn run test:e2e
```

This will open a new [Cypress](https://www.cypress.io/) window.
You can now run all or specific integration tests.
npm package: @fromage/cli-ui-addon-widgets
Description: ``` yarn install ```
Latest version: 5.0.79

# cli-ui-addon-widgets

## Project setup
```
yarn install
```

### Compiles and hot-reloads for development
```
yarn run serve
```

### Compiles and minifies for production
```
yarn run build
```

### Lints and fixes files
```
yarn run lint
```
npm package: @fromage/eslint-config-airbnb
Description: eslint-config-airbnb for vue-cli
Author: Evan You
Latest version: 5.0.79

# @fromage/eslint-config-airbnb

> eslint-config-airbnb for vue-cli

This config is specifically designed to be used by `vue-cli` setups
and is not meant for outside use (it can be used but some adaptations
on the user side might be needed - for details see the config file).

A part of its design is that this config may implicitly depend on
other parts of `vue-cli` setups, such as `eslint-plugin-vue` being
extended in the same resulting config.
npm package: @fromage/eslint-config-prettier
Description: eslint-config-prettier for vue-cli
Author: Evan You
Latest version: 5.0.79

# @fromage/eslint-config-prettier

> eslint-config-prettier for vue-cli

This config is specifically designed to be used by `vue-cli` setups
and is not meant for outside use (it can be used but some adaptations
on the user side might be needed - for details see the config file).

A part of its design is that this config may implicitly depend on
other parts of `vue-cli` setups, such as `eslint-plugin-vue` being
extended in the same resulting config.
npm package: @fromage/eslint-config-typescript
Description: eslint-config-typescript for vue-cli
Author: Evan You
Latest version: 5.0.79

# @fromage/eslint-config-typescript

> eslint-config-typescript for vue-cli

See [@typescript-eslint/eslint-plugin](https://typescript-eslint.io/eslint-plugin) for available rules.

This config is specifically designed to be used by `vue-cli` setups
and is not meant for outside use (it can be used but some adaptations
on the user side might be needed - for details see the config file).

A part of its design is that this config may implicitly depend on
other parts of `vue-cli` setups, such as `eslint-plugin-vue` being
extended in the same resulting config.
npm package: @fromdeno/cache
Description: Simple API for Deno cache.
Author: Wojciech Pawlik
Latest version: 0.1.10

<!-- deno-fmt-ignore-file -->
# `@fromdeno/cache`

Simple [API] for Deno cache.

Differences from https://deno.land/x/cache or https://npm.im/deno-cache :

- High-level `readCache` and `fetchCache` return [`Response`], akin to `fetch`.

- Low-level `CacheEntry` can resolve where a file is (or would be) cached
  without performing IO.

[API]: https://doc.deno.land/https/deno.land/x/fromdeno_cache/src/mod.ts
[`Response`]: https://developer.mozilla.org/en-US/docs/Web/API/Response
npm package: @fromdeno/test
Description: Minimal test runner for @deno/shim-deno-test
Author: Wojciech Pawlik
Latest version: 0.4.0

# `@fromdeno/test`

Minimal test runner for https://npm.im/@deno/shim-deno-test.

[![cli](https://badgen.net/badge/icon/terminal?icon=terminal&label&labelColor=blue)](https://github.com/fromdeno/test/blob/main/src/cli_help.txt)
[![api](https://img.shields.io/static/v1?label&message=api&color=08C&logo=Node.js&logoColor=white)](https://github.com/fromdeno/test/blob/main/src/api.d.ts)
[![install size](https://packagephobia.com/badge?p=@fromdeno/test)](https://packagephobia.com/result?p=@fromdeno/test)

```js
// @filename: test/example_test.js
const assert = require("assert/strict");
const { test } = require("@deno/shim-deno-test");

test("example", () => {
  assert.equal(2 + 2, 4);
});
```

```sh
$ npm install --save-dev @fromdeno/test
$ fdt test/example_test.js
```

[Insights from dogfooding](https://github.com/fromdeno/test/discussions/1)
npm package: @fromjs/cli
Description: To run FromJS install it with `npm install -g @fromjs/cli` and then run `fromjs`.
Author: Matt Zeunert
Latest version: 3.0.11

# FromJS CLI

To run FromJS install it with `npm install -g @fromjs/cli` and then run `fromjs`.

For more information, check out the [main FromJS repo readme](https://github.com/mattzeunert/FromJS) or use `fromjs --help`.
npm package: @fromnibly/hallpass
Description: Class based express router wiring for typescript
Author: from-nibly
Latest version: 0.3.0

# hallpass

hallpass is a class based express router wiring for nodejs written in typescript.

## Getting Started

First lets show a very simple example of a class with a get request.

```typescript
import { Method, Path } from '@fromnibly/hallpass';
export class HelloWorldHandler {
  @Method('get')
  @Path('/hello')
  handleGetHello(req: Request, res: Response): void {
    req.status(202).send('Hello World');
  }
}
```

The equivilent of this using bare express would be

```typescript
import * as express from 'express';
export function initApp(app: express.Application) {
  app.get('/hello', (req: Request, res: Response) => {
    req.status(200).send('Hello World');
  });
}
```

### wiring it up

Once you have created all of your classes you will need to wire them up to your router.

```typescript
import * as express from 'express';

let server = express();

let classRouter = new ClassRouter(server);

classRouter.registerRouteHandler(new HelloWorldHandler());

classRouter.initializeRoutes();

server.listen(8080, () => {
  console.log('server started on port 8080');
});
```

One important thing to note is that the registerRouteHandler function takes an instantiated class. This means that the construction can be left up to something else like a dependency injection framework like `inversify`. The only requirement of a given class is that it has a constructor with a name.

more in depth information in the [wiki](https://github.com/from-nibly/hallpass/wiki)
npm package: @fromscratch/store
Description: The simplest store
Author: Didier Franc
Latest version: 1.0.2

# @fromscratch/store

```sh
yarn add @fromscratch/store
```

# Usage

## Example with react

```js
import React, { Component } from "react";
import Store from "@fromscratch/store";

const store = new Store();

// Some value update from anywhere in the codebase
store.set('someValue', {
  someList: [...]
})

export default class App extends Component {
  componentDidMount() {
    this.unsubscribe = store.subscribe("someValue", this.handleUpdate);
  }

  componentWillUnmount() {
    this.unsubscribe();
  }

  handleUpdate = data => {
    this.setState({ data });
  };

  deleteItem = index => () => {
    const currentValue = store.get("someValue", []);
    store.set("someValue", [
      ...currentValue.slice(0, index),
      ...currentValue.slice(index + 1)
    ]);
  };

  deleteAll = () => {
    store.delete("someValue");
  };

  render() {
    const { data } = this.state;
    return (
      <>
        <button onClick={this.deleteAll}>Remove all</button>
        <ul>
          {data.someList.map((item, index) => (
            <li>
              {item.label} <button onClick={this.deleteItem(index)}>x</button>
            </li>
          ))}
        </ul>
      </>
    );
  }
}
```

# API

```ts
class Store {
  get: (key: string, defaultValue?: any) => any;
  set: (key: string, value: any) => void;
  delete: (key: string) => void;
  subscribe: (key: string, fn: (value: any) => void) => () => void;
}
```
npm package: @fromscratchcode/ozark
Description: ![Ozark](https://raw.githubusercontent.com/fromscratchcode/ozark/main/demo.gif)
Latest version: 0.2.5

# Ozark

![Ozark](https://raw.githubusercontent.com/fromscratchcode/ozark/main/demo.gif)

## Introduction

Ozark lets you inspect Python from source to bytecode. It is built with React and powered by [Memphis](https://github.com/fromscratchcode/memphis), a Python interpreter written from scratch in Rust.

Ozark does not aim to replicate the full CPython [dis module](https://docs.python.org/3/library/dis.html), but rather an in-progress [feature set](https://github.com/fromscratchcode/memphis/blob/main/docs/SUPPORTED.md).

An embedded version can be found on [From Scratch Code](https://fromscratchcode.com/ozark/).

## Local Development

```bash
npm install
npm run dev
```

## License

The software is granted under the terms of the MIT License. For details see the file LICENSE included with the source distribution. All copyrights are owned by their respective authors.
npm package: @fronik/envman
Description: A security-first CLI for environment variable management with AES-256 encryption, secret scanning, health diagnostics, auto-backups, and safe sync.
Author: fronik
Latest version: 3.0.1

# 🛡️ Envman — Secure Environment Manager

<p align="center">
  <img src="https://img.shields.io/npm/v/@fronik/envman?style=for-the-badge" />
  <img src="https://img.shields.io/npm/dt/@fronik/envman?style=for-the-badge" />
  <img src="https://img.shields.io/github/license/Tech-Whisper/envman?style=for-the-badge" />
  <img src="https://img.shields.io/github/stars/Tech-Whisper/envman?style=for-the-badge" />
</p>

<p align="center">
  <b>🔐 Secure • ⚡ Fast • 🧠 Smart Env Management CLI</b>
</p>

> A modern CLI to manage `.env` files with encryption, secret scanning, backups, and health checks.

---

## 🚀 Overview

Envman is a security-first CLI tool for managing `.env` files safely and efficiently.

It helps developers:

- 🔐 encrypt sensitive environment variables
- 🔍 detect exposed secrets before they leak
- 🩺 run health checks on `.env` setups
- 📦 create backups before changes
- 📄 generate `.env.example` files for safer sharing

---

## ✨ Features

- AES-256 encryption for `.env` files
- Secret scanning for API keys, tokens, and credentials
- Doctor command for environment validation
- Automatic backups before edits
- `.env.example` generation
- Interactive CLI mode
- Clean and developer-friendly workflow

---

## 🤔 Why Envman?

Managing `.env` files is usually:

- insecure
- messy
- hard to maintain
- easy to break

Envman solves this by giving you a clean workflow for security and environment management in one CLI.

---

## 📦 Installation

Install globally:

```bash
npm install -g @fronik/envman or npx @fronik/envman