open-index/open-npm huggingface dataset:
npm package: @probablyup/esbuild-plugin-yaml
Description: Convert YAML files to ES6 modules, with watch mode support.
Author: Marton Lederer
Latest version: 0.1.0

# esbuild-plugin-yaml

Use YAML files as ES6 modules with `esbuild`.

## Install

```sh
yarn add -D esbuild-plugin-yaml
```

or

```sh
npm i -D esbuild-plugin-yaml
```

## Usage

Add to your esbuild plugins list:

```js
const esbuild = require("esbuild");
const { yamlPlugin } = require("esbuild-plugin-yaml");

esbuild.build({
  ...
  plugins: [
    yamlPlugin()
  ]
  ...
});
```

## Options

You can add your own custom configuration of options to `esbuild-plugin-yaml`:

```js
yamlPlugin({
  // options
});
```

### `loadOptions`

LoadOptions by [`js-yaml`](https://www.npmjs.com/package/js-yaml).

### `transform`

A function which can mutate parsed YAML. It should return an `object` or `undefined` (that will make no changes to the parsed YAML).

```js
  transform(data, filePath) {
    // transform the yaml file
    // the file content will be in the "data" field
    // the file path will be in the "filePath" field
    return { filePath, data };
  }
```
npm package: @probablyup/mock-private-registry
Description: Mock of a private npm registry, useful for testing npm-related stuff
Author: Espen Hovlandsdal
Latest version: 1.1.0

# @probablyup/mock-private-registry

Mock of a private npm registry, useful for testing npm-related stuff. This is a fork of "mock-private-registry" with support for mocking multiple packages.

## Installation

```
npm install --save-dev @probablyup/mock-private-registry
```

## Usage

```js
const registry = require('@probablyup/mock-private-registry');
const got = require('got');

const token = 'MySecretToken';

// make the tarballs by running `npm pack` in it
const packages = [
  ['my-package', '/absolute/path/to/private/package/tarball.tar.gz'],
  ['my-other-package', '/absolute/path/to/other/private/package/tarball.tar.gz'],
];

registry({ packages, port: 18888, token }, function(err, server) {
  if (err) {
    throw err;
  }

  const opts = { headers: { Authorization: 'Bearer ' + token }, json: true };

  got('http://localhost:18888/@mockscope%2Ffoobar', opts)
    .then(function(res) {
      console.log('Package manifest: ', res.body);
    })
    .catch(function(err) {
      console.error(err);
    })
    .then(function() {
      server.close();
    });
});
```

Basically, call the module to spin up a server, and specify whatever you want to use as the valid authorization token. Second argument is a callback, which provides access to the server that is listening. This allows you to call `close()` on it when you're done.

## Options

- `port` - Port number for the server. Default: `63142`

- `hostname` - Hostname the server should listen on. Default: `127.0.0.1`

- `token` - The token that valid requests should use. Default: `MySecretToken`

- `tokenType` - Type of token. Usually `Bearer` or `Basic`. Default: `Bearer`

- `packages` - A two dimensional array of package data and tarball path, e.g.

  ```
  [['foo-package', '/local/path/to/foo-package.tar.gz']]
  ```

  or

  ```
  [[{name: 'foo-package'}, '/local/path/to/foo-package.tar.gz']]
  ```

  In object form, you're basically supplying the contents of `package.json`.

- `debug` - Boolean. Set to true in order to have the registry mock spit back whatever is not matching, for instance the expected vs received token. Default: `false`

## Promise API

There is an alternative promise API available if you require `@probablyup/mock-private-registry/promise`. Usage is the same except there is no callback. Instead, the function will return a promise.

## Why

For testing. Lots of stuff interacts with the NPM registry, but often has bugs when authorizing against private registries. Trying to mock the whole private registry flow can be difficult, so I created this.

## License

MIT
npm package: @probat/react
Description: React SDK for Probat experimentation — CTR tracking, variant assignment, and more
Author: Probat AI
Latest version: 0.4.9

# @probat/react

React SDK for Probat A/B testing. Automatic impression and click tracking with zero boilerplate.

## Install

```bash
npm install @probat/react
```

## Quick Start

Wrap your app root with the provider (Next.js App Router example):

```tsx
// app/providers.tsx
"use client";
import { ProbatProviderClient } from "@probat/react";

export function Providers({ children }: { children: React.ReactNode }) {
  return (
    <ProbatProviderClient customerId={user.id}>
      {children}
    </ProbatProviderClient>
  );
}
```

Create a thin experiment wrapper — one per experiment:

```tsx
// components/CTAButton/CTAButton.experiment.tsx
"use client";
import { Experiment } from "@probat/react";
import { CTAButton } from "./CTAButton";
import { CTAButtonAI } from "./CTAButton.ai-v1";

export function CTAButtonExperiment() {
  return (
    <Experiment
      id="cta-copy-test"
      control={<CTAButton />}
      variants={{ ai_v1: <CTAButtonAI /> }}
    />
  );
}
```

That's it. Impressions (50% visible for 250ms) and clicks are tracked automatically.

## Custom Metrics

```tsx
const { capture } = useProbatMetrics();
capture("purchase", { revenue: 42 });
```

## Run the Example

```bash
cd packages/probat-react/example
node mocks/server.ts &     # mock API on :3001
npx next dev                # app on :3000
```

## Docs

See [SPEC.md](./SPEC.md) for the full event schemas, assignment rules, dedupe logic, and edge cases.
npm package: @probcomp/genstudio
Description: [![PyPI version](https://badge.fury.io/py/genstudio.svg)](https://badge.fury.io/py/genstudio)
Author: Matthew Huebert
Latest version: 2025.4.1

[![PyPI version](https://badge.fury.io/py/genstudio.svg)](https://badge.fury.io/py/genstudio)

# Gen Studio
_Visualization tools for GenJAX._

-----

`genstudio.plot` provides a composable way to create interactive plots using [Observable Plot](https://observablehq.com/plot/).

Key features:

- Functional, composable plot creation built on Observable Plot (with near 1:1 API correspondence between Python and JavaScript)
- Support for sliders & animations
- Works in Jupyter / Google Colab
- HTML mode which persists plots across kernel restart/shutdown, and a Widget mode which supports Python<>JavaScript interactivity
- Terse layout syntax for organizing plots into rows and columns
- Hiccup implementation for interspersing arbitrary HTML

For detailed usage instructions and examples, refer to the [Gen Studio User Guide](https://studio.gen.dev).

## Development

Run `yarn watch` to compile the JavaScript bundle.

### CI Workflows

The project has several CI workflows:
- **Tests**: Runs JavaScript and Python unit tests
- **WebGPU Screenshots**: Tests 3D WebGPU rendering capabilities by capturing screenshots in headless Chrome
- **Docs**: Builds and deploys documentation
- **Pyright**: Runs type checking for Python code
- **Ruff**: Runs code formatting and linting

## Credits

- [AnyWidget](https://github.com/manzt/anywidget) provides a nice Python<>JavaScript widget API
- [pyobsplot](https://github.com/juba/pyobsplot) was the inspiration for our Python->JavaScript approach