open-index/open-npm huggingface dataset:
npm package: @rbtechdev/ngx-datatable
Description: ngx-datatable is an Angular table grid component for presenting large and complex data.
Author: Swimlane
Latest version: 20.0.2

# ngx-datatable

[![Join the chat at https://gitter.im/swimlane/ngx-datatable](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/swimlane/ngx-datatable?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Code Climate](https://codeclimate.com/github/swimlane/ngx-datatable/badges/gpa.svg)](https://codeclimate.com/github/swimlane/ngx-datatable)
[![Test Coverage](https://codeclimate.com/github/swimlane/ngx-datatable/badges/coverage.svg)](https://codeclimate.com/github/swimlane/ngx-datatable/coverage)
[![npm version](https://badge.fury.io/js/%40swimlane%2Fngx-datatable.svg)](https://badge.fury.io/js/%40swimlane%2Fngx-datatable)
[![npm downloads](https://img.shields.io/npm/dm/@swimlane/ngx-datatable.svg)](https://npmjs.org/@swimlane/ngx-datatable)

`ngx-datatable` is an Angular component for presenting large and complex data. It has all the features you would expect from any other table but in a light package with _no external dependencies_. The table was designed to be extremely flexible and light; it doesn't make any assumptions about your data or how you: filter, sort or page it.

It was built for modern browsers using _TypeScript, CSS3 and HTML5_ and Angular `8.0.0`. This is the sister project of the [angular-data-table](https://github.com/swimlane/angular-data-table) that is designed for Angular 1.x.

Check out the [documentation](https://swimlane.gitbook.io/ngx-datatable/) & [demos](http://swimlane.github.io/ngx-datatable/) for more information!

See the [changelog](https://github.com/swimlane/ngx-datatable/blob/master/docs/changelog.md) for recent changes.

## Features

- Handle large data sets ( Virtual DOM )
- Expressive Header and Cell Templates
- Horizontal & Vertical Scrolling
- Column Reordering & Resizing
- Client/Server side Pagination & Sorting
- Intelligent Column Width Algorithms ( Force-fill & Flex-grow )
- Integrated Pager
- Cell & Row Selection ( Single, Multi, Keyboard, Checkbox )
- Fixed AND Fluid height
- Left and Right Column Pinning
- Row Detail View
- Decoupled theme'ing with included Google Material theme
- Light codebase / No external dependencies
- AoT Compilation Support
- Universal Support

## Installation

To use ngx-datatable in your project install it via [npm](https://www.npmjs.com/package/@swimlane/ngx-datatable):

```
npm i @swimlane/ngx-datatable --save
```

## Credits

`ngx-datatable` is a [Swimlane](http://swimlane.com) open-source project; we believe in giving back to the open-source community by sharing some of the projects we build for our application. Swimlane is an automated cyber security operations and incident response platform that enables cyber security teams to leverage threat intelligence, speed up incident response and automate security operations.

[SecOps Hub](http://secopshub.com) is an open, product-agnostic, online community for security professionals to share ideas, use cases, best practices, and incident response strategies.
npm package: @rbuljan/eur2hr
Description: Convert EUR value to Croatian words
Author: Roko C. Buljan
Latest version: 1.1.0

# EUR 2 HR - Convert EURO (€) value to Croatian words (*višerječnice*)

Useful when in need to show the money amount in words like i.e:

> **Iznos:** *121024.05 €*  
> **Slovima:** *stodvadesetjednatisućadvadesetčetiri eura i pet centi*

## Install

```sh
npm i @rbuljan/eur2hr
```

## Usage

```js
import eur2hr from "@rbuljan/eur2hr";
const words = eur2hr(1042.31);

console.log(words);
```

> jednatisućačetrdesetdva eura i tridesetjedan cent

```js
import eur2hr from "@rbuljan/eur2hr";
const words = eur2hr(1042.31, { simple: true });
```

> tisućučetrdesetdva eura i tridesetjedan cent

```js
import eur2hr from "@rbuljan/eur2hr";
const words = eur2hr(1042.31, { simple: true, delimiter: " " });
```

> tisuću četrdeset dva eura i trideset jedan cent

## Syntax

```js
eur2hr(number [, {options}])
```

Returns a **String**, with the the Croatian representation of money as words.   
Returns String `"Error"` if the input number is greater than `1e13` (`10_000_000_000_000.00`) 

## Arguments

#### number (String|Number)

`number` is a float **String** or **Number**

#### options (Object)

| Property  | Type    | Default | Description                                                                  |
| --------- | ------- | ------- | ---------------------------------------------------------------------------- |
| delimiter | String  | `""`    | Use i.e. `" "` to delimit words with space                                        |
| simple    | Boolean | `false` | Set to true to remove unnecessary *"jedan/na"* for round *thousands* numbers |

## Test

To create a readable `test.txt` file with your test results, edit the `test.js` variables and run:  

```sh
node test  # Find the results in ./test.txt
```

## Licence

MIT
npm package: @rbwsam/pi-exa
Description: Pi extension integrating the Exa API for web search and content retrieval
Author: Sam Leavens
Latest version: 1.0.0

# pi-exa

A minimal Pi extension integrating the [Exa API](https://exa.ai/) for web search and content retrieval.

## Features

- Web search with optional content extraction
- Retrieve text from specific URLs
- Find similar pages based on a URL
- Secure API key management

## Installation

### From npm (recommended)

```bash
pi install npm:@rbwsam/pi-exa
```

Or try without installing:

```bash
pi -e npm:@rbwsam/pi-exa
```

### From source

```bash
git clone https://github.com/rbwsam/pi-exa ~/.pi/agent/extensions/exa
cd ~/.pi/agent/extensions/exa
npm install
```

### Configure API key

Once installed, run the configuration command:

```bash
/exa-config
```

Enter your Exa API key when prompted. Your API key will be saved to `~/.pi/config/exa-api-key` with restricted file permissions (mode 0600).

## Usage

Once configured, Pi can search the web and access current information. Just ask naturally:

- "Search for recent AI developments"
- "What's the latest news on quantum computing?"
- "Get the full text from this URL"
- "Find similar pages to this GitHub repository"

Pi automatically uses the following tools when appropriate:

- [Web Search](https://docs.exa.ai/reference/search) - Search the web with optional content extraction
- [Content Fetching](https://docs.exa.ai/reference/get-contents) - Retrieve text from specific URLs
- [Find Similar](https://docs.exa.ai/reference/find-similar-links) - Discover related web pages

No commands needed—just ask naturally.

## Development

```bash
npm run check  # Type check TypeScript
```

**Dependencies:**
- `exa-js` - Exa API client
- `@sinclair/typebox` - Type validation
- `@mariozechner/pi-tui` - Pi TUI components

**Dev Dependencies:**
- `typescript` - Type checking
- `@types/node` - Node.js type definitions

## Troubleshooting

**API key not configured:**
Run `/exa-config` to set your API key.

**Search failed:**
Verify your API key is valid and has quota remaining at [exa.ai](https://exa.ai/).

## License

MIT

## References

- [Exa API Documentation](https://docs.exa.ai/)
- [Pi Coding Agent](https://github.com/badlogic/pi-mono)
npm package: @rbwsam/zhi
Description: Concurrent web crawler that detects slow pages, broken links, and unhealthy HTTP status codes across your site
Author: Sam Leavens
Latest version: 1.0.0

# zhi 🕷️

A concurrent web crawler that detects slow pages, broken links, and unhealthy HTTP status codes across your site.

## Features

- **Concurrent crawling** - Process multiple pages simultaneously (default: 10 workers)
- **Comprehensive reporting** - Identifies slow responses, broken links, and HTTP errors
- **Smart link extraction** - Crawls HTML pages, CSS stylesheets, images, and scripts
- **Same-domain filtering** - Only crawls pages on the starting domain
- **Configurable limits** - Control concurrency and maximum URLs to crawl

## Requirements

- Node.js 20.0.0 or higher

## Installation

### From npm (Recommended)
```bash
npm install -g @rbwsam/zhi
zhi <url> [options]
```

### From source (Development)
```bash
git clone https://github.com/rbwsam/zhi.git
cd zhi
npm install
npm run build
node dist/index.js <url> [options]
```

## Quick Start

```bash
# Basic usage (https is assumed if no protocol specified)
zhi example.com

# With explicit protocol
zhi https://example.com
zhi http://example.com

# With custom concurrency
zhi example.com -c 20

# Limit total URLs to crawl
zhi example.com -m 500

# Combine options
zhi example.com -c 15 -m 1000
```

## Usage

```
zhi <url> [options]

Arguments:
  url                    The starting URL for the crawl

Options:
  -c, --concurrency <n>  Maximum number of concurrent requests (default: 10)
  -m, --max-urls <n>     Maximum number of unique URLs to crawl (default: 2000)
  -h, --help             Show this help message
  -V, --version          Show version number
```

## Reports

The tool generates a health report with three main sections:

### Slow Responses
Pages taking longer than 350ms to load. Sorted by latency (slowest first).

### Unhealthy Status Codes
Pages returning HTTP status codes > 299 or network errors.

### Summary
Total URLs processed and overall site health.

## Example Output

```
Starting crawl on https://example.com with 10 concurrent workers and max 2000 URLs.

======================================================
         🌐 Website Health Report for example.com
======================================================
Total URLs Processed: 42

## 🐢 Slow Responses (> 350ms) (3 found)
┌─────────────────────┬───────┬────────┬──────────────┐
│ URL                 │ Type  │ Status │ Latency (ms) │
├─────────────────────┼───────┼────────┼──────────────┤
│ https://example.com │ page  │ 200    │ 523          │
└─────────────────────┴───────┴────────┴──────────────┘

---

✅ All processed links returned healthy status codes (<= 299).

======================================================
```

## Development

### Build
```bash
npm run build
```

### Build and test
```bash
npm run build
node dist/index.js https://example.com
```

## License

MIT
npm package: @rbxts-js/diff-sequences
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/diff-sequences
Latest version: 3.16.0-ts.1

# diff-sequences

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/diff-sequences

Compare items in two sequences to find a longest common subsequence.

---

### :pencil2: Notes
* :x: Property tests and performance tests from upstream are not included.
* :warning: Lua does not allow indexing into strings, the consumer is expected to handle the input types in `isCommon` and `foundSubsequence`.
    * A `stringToArray` function is implemented to convert input strings to arrays for tests.
    * Substring tests are done using arrays of characters instead. The substring comparison methods are omitted.
* Lua is 1 indexed so array indices are replaced with `index + 1`.
* Uses of `NOT_YET_SET` are replaced with just a 0 since this is a JS-specific workaround.
* Lua treats `0` as a true value so `nChange || baDeltaLength` needs to be written as `nChange ~= 0 and nChange or baDeltaLength`.
npm package: @rbxts-js/jest
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest
Latest version: 3.16.0-ts.1

# jest

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest

This package exports the `Jest` object used in Jest. The main entrypoint to the test framework should be `JestGlobals`. You can find its documentation in the [Jest documentation](https://roblox.github.io/jest-roblox-internal).

---

### :pencil2: Notes
npm package: @rbxts-js/jest-benchmark
Description: *No upstream. Roblox only.*
Latest version: 3.16.0-ts.1

# jest-benchmark

*No upstream. Roblox only.*

This package exports a collection of Luau utilities that can be used alongside Jest to provide structure for writing benchmarks. You can find its documentation in the [Jest documentation](https://roblox.github.io/jest-roblox-internal/jest-benchmark).
npm package: @rbxts-js/jest-config
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-config
Latest version: 3.16.0-ts.1

# jest-config

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-config

---

### :pencil2: Notes

* since Lua projects don't store external modules in `node_modules` directory `testPathIgnorePatterns` will not include this directory by default
* running tests concurrently is not supported at the moment

#### Todo

- [ ] support for `globalSetup` and `globalTeardown` options
- [ ] support for `coverageReporters` option

#### API deviation

* `projects` option needs to receive a list of `Instance` objects
*  `rootDir` options needs to receive an `Instance`

#### Unsupported global [config options](https://jestjs.io/docs/configuration)

* `changedFilesWithAncestor`
* `collectCoverage`
* `collectCoverageFrom`
* `collectCoverageOnlyFrom`
* `coverageDirectory`
* `coveragePathIgnorePatterns`
* `coverageProvider`
* `coverageReporters`
* `coverageThreshold`
* `detectLeaks`
* `detectOpenHandles`
* `findRelatedTests`
* `forceExit`
* `globalTeardown`
* `lastCommit`
* `logHeapUsage`
* `noSCM`
* `notifyMode`
* `onlyChanged`
* `onlyFailures`
* `replname`
* `reporters`
* `snapshotFormat`
* `errorOnDeprecated`
* `testResultsProcessor`
* `testSequencer`
* `useStderr`
* `watch`
* `watchAll`
* `watchman`
* `watchPlugins`

#### Unsupported global [config options](https://jestjs.io/docs/configuration)

* `cache`
* `cacheDirectory`
* `coveragePathIgnorePatterns`
* `cwd`
* `dependencyExtractor`
* `detectLeaks`
* `detectOpenHandles`
* `errorOnDeprecated`
* `extensionsToTreatAsEsm`
* `extraGlobals`
* `forceCoverageMatch`
* `globalSetup`
* `globalTeardown`
* `globals`
* `haste`
* `moduleDirectories`
* `moduleFileExtensions`
* `moduleLoader`
* `moduleNameMapper`
* `modulePathIgnorePatterns`
* `modulePaths`
* `prettierPath`
* `resolver`
* `setupFiles`
* `setupFilesAfterEnv`
* `skipNodeResolution`
* `snapshotResolver`
* `snapshotFormat`
* `testRunner`
* `testURL`
* `transform`
* `transformIgnorePatterns`
* `watchPathIgnorePatterns`
* `unmockedModulePathPatterns`

#### Unsupported CLI [options](https://jestjs.io/docs/cli)

* `cache`
* `cacheDirectory`
* `changedFilesWithAncestor`
* `collectCoverage`
* `collectCoverageFrom`
* `collectCoverageOnlyFrom`
* `coverageDirectory`
* `coveragePathIgnorePatterns`
* `coverageReporters`
* `coverageThreshold`
* `findRelatedTests`
* `forceExit`
* `globalSetup`
* `globalTeardown`
* `haste`
* `lastCommit`
* `logHeapUsage`
* `moduleFileExtensions`
* `moduleNameMapper`
* `modulePathIgnorePatterns`
* `modulePaths`
* `notifyMode`
* `onlyChanged`
* `onlyFailures`
* `prettierPath`
* `resolver`
* `setupFiles`
* `setupFilesAfterEnv`
* `testResultsProcessor`
* `testRunner`
* `testSequencer`
* `testURL`
* `transform`
* `transformIgnorePatterns`
* `unmockedModulePathPatterns`
* `useStderr`
* `watch`
* `watchAll`
* `watchman`
* `watchPathIgnorePatterns`
npm package: @rbxts-js/jest-diff
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-diff
Latest version: 3.16.0-ts.1

# jest-diff

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-diff

Display differences clearly so people can review changes confidently.

The `diff` named export serializes **values**, compares them line-by-line, and returns a string which includes comparison lines.

Two named exports compare **strings** character-by-character:

- `diffStringsUnified` returns a string.
- `diffStringsRaw` returns an array of `Diff` objects.

Three named exports compare **arrays of strings** line-by-line:

- `diffLinesUnified` and `diffLinesUnified2` return a string.
- `diffLinesRaw` returns an array of `Diff` objects.

---

### :pencil2: Notes
* `CleanupSemantic.lua` is adapted from the Lua version of [`diff-match-patch`](https://github.com/google/diff-match-patch/blob/master/lua/diff_match_patch.lua) to resemble the upstream [`cleanupSemantics.ts`](https://github.com/facebook/jest/blob/v27.4.7/packages/jest-diff/src/cleanupSemantic.ts) instead of being a direct port of it.
    * Tests for it are added, which are not included in the upstream `jest-diff
* Changes to tests:
    * Snapshots in `Diff.spec.lua` have their leading `<g>`, `<r>`, `<d>`, and `<y>` ANSI style codes manually removed.
    * Color formatting specific tests are omitted.
    * `changeColor` is assigned to a function that imitates `chalk.inverse` so we can test `diffStringsUnified`.
    * `Array[]`, `Object{}` are changed to `Table{}`.
npm package: @rbxts-js/jest-each
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-each
Latest version: 3.16.0-ts.1

# jest-each

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-each

A parameterized testing library for Jest. You can find its documentation in the [Jest documentation](https://roblox.github.io/jest-roblox-internal).

---

### :pencil2: Notes
* Deviations:
    * Tagged templates are not available in Lua. As an alternative, a headings string must be used with a list of arrays containing the same amount of items as headings.
    Example:
    ```lua
    each("a | b | expected",
        { 0, 0, 0 },
        { 0, 1, 1 },
        { 1, 1, 2 }
    ).it("returns $expected when given $a and $b",
        function(ref)
            local a: number, b: number, expected = ref.a, ref.b, ref.expected
            jestExpect(a + b).toBe(expected)
        end
    )
    ```
    * Use `NIL` provided constant instead of nil when passing values to each
    ```lua
    each("expected", { NIL }).it(
		"templates properly convert $expected to nil before running the tests",
		function(ref)
			jestExpect(ref.expected).toBe(nil)
		end
	)
    ```
    * TestEZ methods are supported (`*FOCUS`, `*SKIP`), however, these may be dropped at some point in favor of jest's callable objects(`it`, `it.only`, `it.skip`), which are supported too
npm package: @rbxts-js/jest-fake-timers
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-fake-timers
Latest version: 3.16.0-ts.1

# jest-fake-timers

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-fake-timers

This package contains the fake timers implementation for Jest. It can be activated by calling `jest.useFakeTimers()`. You can find its documentation in the [Jest documentation](https://roblox.github.io/jest-roblox-internal).

The following timers are mocked:
* `delay`
* `tick`
* `time`
* `os`
    * `os.time`
	* `os.clock`
* `task.delay`
    * `task.delay`
	* `task.cancel`
	* `task.wait`
* `DateTime`

---

### :pencil2: Notes
:exclamation: The fake timer API in Jest Roblox is aligned with the "modern" fake timer implementation in Jest. However, the actual implementation of fake timers in Jest Roblox under the hood massively deviates from upstream so that it works natively with the Roblox ecosystem.

Similar to how Jest fake timers work by mocking the native timer functions (i.e. `setTimeout`, `setInterval`, `clearTimeout`, `clearInterval`) and `Date`, Jest Roblox fake timers work by mocking the native timer functions in Roblox (i.e. `delay`, `tick`), the Roblox `DateTime` and the Lua native timer methods `os.time` and `os.clock`.
Additionally, Jest Roblox fake timers support a configurable engine frame time. By default, the engine frame time is 0 (i.e. continuous time), but if set, Jest Roblox fake timers will be processed by multiples of frame time. If engine frame time is set, then timers will be processed in the first frame after they are triggered.
npm package: @rbxts-js/jest-get-type
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-get-type
Latest version: 3.16.0-ts.1

# jest-get-type

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-get-type

A utility function to get the type of a value, including Luau and Roblox types.

Types supported:

* Lua Primitives - `nil`, `table`, `number`, `string`, `function`, `boolean`, `userdata`, `thread`
* [Luau Polyfill](https://github.com/Roblox/luau-polyfill) types - `symbol`, [`regexp`](https://github.com/Roblox/luau-regexp), `error`, `set`
* Roblox datatypes - `DateTime`, and other [`builtin`](https://developer.roblox.com/en-us/api-reference/data-types) types

---

### :pencil2: Notes
* Lua makes no distinction between tables, objects, and arrays. We always return `table` at this level and consumers are expected to check at a higher level.
* Lua makes no distinction between `null` and `undefined` so we only return `nil`.
* Lua lacks the following primitives: `bigint`, `symbol`.
* Lua lacks the following built-in types: `RegExp`, `Map`, `Set`, `Date`.
* `JestGetType` deviates and exposes an `isRobloxBuiltin` method to check whether a value is a Roblox builtin type
npm package: @rbxts-js/jest-globals
Description: Upstream: https://github.com/jestjs/jest/tree/v27.4.7/packages/jest-globals
Latest version: 3.16.0-ts.1

# jest-globals

Upstream: https://github.com/jestjs/jest/tree/v27.4.7/packages/jest-globals

This package exports all the "global" methods used by Jest. You can find its documentation in the [Jest documentation](https://roblox.github.io/jest-roblox-internal).

---

### :pencil2: Notes
npm package: @rbxts-js/jest-jasmine2
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-jasmine2
Latest version: 3.16.0-ts.1

# jest-jasmine2

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-jasmine2

---

### :pencil2: Notes
* Our upstream, Jest, doesn't include any test files for the files in this directory, `jest-jasmine2/src/jasmine/`, so we look to the upstream that Jest is based off of Jasmine, for the test files
* The tests for CallTracker and SpyStrategy are copied off of the upstream files but the `createSpy.ts` file doesn't actually have a direct upstream equivalent in Jasmine so we copy some tests from `SpySpec` instead, leaving out the majority of tests that aren't yet relevant
* We expose `andAlso` in addition to the typical `and` for createSpy since `and` is a built in keyword for Lua so we can't cleanly chain fields (i.e. we can't get `var.and` to work so we allow for `var.andAlso`)
* We use the [Roblox Lua Promise](https://github.com/evaera/roblox-lua-promise) library in this module in a number of places to more closely mirror the asynchronous tests in Jasmine
npm package: @rbxts-js/jest-matcher-utils
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-matcher-utils
Latest version: 3.16.0-ts.1

# jest-matcher-utils

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-matcher-utils

This package's exports are mainly used by `expect`'s `utils`.

---

### :pencil2: Notes
* We don't provide support for `bigint` types
* We don't provide a translation for the `chalk` library. This also means we omit certain tests that rely on comparing output that is colored differently.
* Changed type annotations in upstream that were `unknown` to `any` because Luau doesn't have support for an `unknown` type
* In many of the tests, there is differentiation between types such as `Array` and `Map`, however in Lua all of these are treated identically as `table`. The tests were translated to use the `table` type and some tests were left out if they became identical to other tests or were highly redundant.
* Luau does not yet have functionality to use generics in function signatures and functions so those type annotations are left out
npm package: @rbxts-js/jest-message-util
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-message-util
Latest version: 3.16.0-ts.1

# jest-message-util

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-message-util

---

### :pencil2: Notes
npm package: @rbxts-js/jest-mock
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-mock
Latest version: 3.16.0-ts.1

# jest-mock

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-mock

This package implements the various function and module mocking capabilities used by Jest. You can find its documentation in the [Jest documentation](https://roblox.github.io/jest-roblox-internal).

---

### :pencil2: Notes
* As of right now, only a minimal set of functionality for jest-mock has been ported. The only externally facing functions that are supported are:
	* Creating an instance of the `ModuleMockerClass` via constructor (i.e. importing jest-mock and calling `.new()` on the import)
	* And then these functions are supported on an instance of the `ModuleMockerClass`:
		* `fn()` - create a function that can help in unit testing to confirm expectations on number of calls, returns, call arguments, etc. (currently this is mainly useful for the spyMatchers)
	    * `clearAllMocks()`
	    * `resetAllMocks()`
	    * `restoreAllMocks()`
npm package: @rbxts-js/jest-mock-genv
Description: *No upstream. Roblox only.*
Latest version: 3.16.0-ts.1

# jest-mock-genv

*No upstream. Roblox only.*

This module houses the `GlobalMocker` class, the type definitions used for global
mocking utilities, and the `MOCKABLE_GLOBALS` constant which determines the global
environment members that are allowed to be mocked.

## :pencil2: Notes

- **Changing `MOCKABLE_GLOBALS` should be done with care.**
    - By whitelisting a new global to be mocked, you may subtly affect any code
      which uses that global, or allow users to do the same.
        - Jest only generates mock functions for the globals that are
          whitelisted, and doesn't generate anything for globals that are not
          whitelisted. This can subtly change how a global appears to user code.
        - Possible breakage will need to be investigated.
    - Adding a new global to this list is not breaking, but removing a global
      from this list *is* breaking.
        - It is better to be selective than to be generous, because if the
          whitelisting causes breakage, it's might be hard to undo.
        - We also don't want to encourage bad practice, and mocking certain
          globals could lead to unintended use cases which aren't idiomatic or
          cause problems for ourselves later.
    - Certain globals are not safe to mock right now, including task scheduling
      functions and `require()`, because they already have customised
      implementations in Jest that would be bypassed.
        - This can probably be fixed down the line if there's a pressing need to
          do it, but it would introduce more complexity.
    - **Above all else, come talk to us first - we will help you 🙂** 
- The `GlobalMocker` class does not implement any mocking capabilities itself;
  instead, mock functions are stored in `GlobalMocker` by a `ModuleMocker`.
- Globals should *always* be mocked whenever a test is running, because the
  test's sandbox environment redirects to these mock functions at all times -
  even if the user has not used `spyOn`.
    - This ensures that all modules can see mocked implementations, even if they
      are required later than the call to `spyOn` which mocks the global.
npm package: @rbxts-js/jest-mock-rbx
Description: *No upstream. Roblox only.*
Latest version: 3.16.0-ts.1

# jest-mock-rbx

*No upstream. Roblox only.*

This package implements Jest's data model mocking capabilities for Roblox:

* `InstanceProxy`, used for constructing objects that act like an existing
  instance, except actions can be intercepted and mocked.
* `DataModelMocker`, provides higher-level proxies that can interact with each
  other as part of a fake data model.

---

### :pencil2: Notes
* Right now, only a limited subset of data model mocking features are
  implemented and available for use.
* `DataModelMocker` should be used for constructing instance mocks, not
  `InstanceProxy`.
	* The `InstanceProxy` class is a minimal, self-contained implementation with
	no special behaviour.
	* The `DataModelMocker` class allows proxies to be reused, and provides
	useful default mock behaviour like returning proxied descendants or ancestry.
* `InstanceProxy` intentionally only implements some of an `Instance`'s
  capabilities.
	* It is assumed that the instance proxy is being used on normal, idiomatic
	code that would correctly function if given an `Instance`.
	* Instance proxies have normal reference-based equality. They are not equal
	to the original instance, nor to any other proxies of that instance.
	* Instance proxies can't be consumed by functions expecting a "proper
	Instance".
		* In particular, calls to C such as `x:IsAncestorOf(InstanceProxy)` will
		  error as these calls are not mockable.
npm package: @rbxts-js/jest-react
Description: A Roblox Lua port of the jest-react package re-exported from React. It provides Jest matchers and utilities for testing React Test Renderer.
Latest version: 17.3.7-ts.1

# jest-react
A Roblox Lua port of the jest-react package re-exported from React. It provides Jest matchers and utilities for testing React Test Renderer.

Status: ✔️ Ported

Source: https://github.com/facebook/react/tree/master/packages/jest-react
npm package: @rbxts-js/jest-snapshot-serializer-raw
Description: Upstream: https://github.com/ikatyang/jest-snapshot-serializer-raw/tree/v1.2.0
Latest version: 3.16.0-ts.1

# jest-util

Upstream: https://github.com/ikatyang/jest-snapshot-serializer-raw/tree/v1.2.0

---

### :pencil2: Notes
npm package: @rbxts-js/jest-test-result
Description: Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-test-result
Latest version: 3.16.0-ts.1

# jest-test-result

Upstream: https://github.com/facebook/jest/tree/v27.4.7/packages/jest-test-result

---

### :pencil2: Notes
npm package: @rbxts-js/luau-regexp
Description: A regular expression library for Luau. Adapted from a regex implementation by github user Blockzez (https://github.com/Blockzez).
Latest version: 0.2.2-ts.1

# RegExp for Luau
A regular expression library for Luau. Adapted from a regex implementation by github user Blockzez (https://github.com/Blockzez).

## API
Create a regex with the `new` function:
`RegExp.new(pattern: string, flags: string) -> RegularExpression`

A resulting RegularExpression has the following methods:
* `RegularExpression:exec(str: string) -> Match`
* `RegularExpression:test(str: string) -> boolean`

The `Match` object resulting from `exec` has the following fields:
* `[1..n]` - The array potion of the `Match` object contains captured groups
* `n` - The length of the array of resulting captured groups
* `index` - The index in the original string where the match begins
* `input` - The original string passed into `exec`

### Flags
The following flags can be provided via the second argument to `RegExp.new`:
* "i" - ignoreCase
* "g" - global
* "m" - multiline
npm package: @rbxts-js/picomatch-lua
Description: Status: :heavy_check_mark: Ported
Latest version: 0.4.0-ts.1

# picomatch

Status: :heavy_check_mark: Ported

Source: https://github.com/micromatch/picomatch/tree/2.3.1

Version: v2.3.1

---

### :pencil2: Notes

### :x: Excluded


### :package: [Dependencies](https://github.com/micromatch/picomatch/blob/2.3.1/package.json)

| Package | Version | Status | Notes |
| ------- | ------- | ------ | ----- |
npm package: @rbxts-js/react
Description: A Roblox Lua port of the `react` package from React. This is the main React package
Latest version: 17.3.7-ts.1

# react
A Roblox Lua port of the `react` package from React. This is the main React package

Status: 🔨 Port in progress

Source: https://github.com/facebook/react/tree/master/packages/react

---

### ✏️ Notes
* Includes some relatively significant deviations in `ReactBaseClasses.lua` to accommodate Lua idioms for objects, constructors, and inheritance.
* Exports React-related type definitions from DefinitelyTyped, like `ReactElement<Props>`, used by Apollo GraphQL and jest. These are the types users of the library should prefer to use.
* Exports React-related type definitions that are built-in to flowtype. Only used by the framework internals itself, and some sibling projects like VirtualizedList. It is not recommended to use these types in application code.

### ❌ Excluded
npm package: @rbxts-js/react-cache
Description: <!-- Upstream: https://github.com/facebook/react/blob/faa697f4f9afe9f1c98e315b2a9e70f5a74a7a74/packages/react-cache/README.md -->
Latest version: 17.3.7-ts.1

<!-- Upstream: https://github.com/facebook/react/blob/faa697f4f9afe9f1c98e315b2a9e70f5a74a7a74/packages/react-cache/README.md -->

# react-cache

A basic cache for React applications. It also serves as a reference for more
advanced caching implementations.

This package is meant to be used alongside yet-to-be-released, experimental
React features. It's unlikely to be useful in any other context.

**Do not use in a real application.** We're publishing this early for
demonstration purposes.

**Use it at your own risk.**

# No, Really, It Is Unstable

The API ~~may~~ will change wildly between versions.
npm package: @rbxts-js/react-devtools-core
Description: A React DevTools bridge implementation for React Lua. The implementation of this package deviates heavily from the upstream version.
Latest version: 17.3.7-ts.1

# `react-devtools-core`

A React DevTools bridge implementation for React Lua. The implementation of this package deviates heavily from the upstream version.

## API

Requiring this package is similar to requiring `react-devtools`, but provides several configurable options. Unlike `react-devtools`, requiring `react-devtools-core` doesn't connect immediately but instead exports a function:

```luau
local ReactDevtoolsCore = require(Packages.ReactDevtoolsCore)
local connectToDevtools = ReactDevtoolsCore.connectToDevtools
connectToDevTools(config)
```

Run `connectToDevTools()` in the same context as React to set up a connection to DevTools.
Be sure to run this function before importing *any* React package -- e.g. `react`, `react-roblox`.

The `config` object may contain:

- `host: string` (defaults to "localhost") - Websocket will connect to this host.
- `port: number` (defaults to `8097`) - Websocket will connect to this port.
- `useHttps: boolean` (defaults to `false`) - Websocket should use a secure protocol (wss).
- `resolveRNStyle: (style: number) => ?Object` - Used by the React Native style plug-in.
- `isAppActive: () => boolean` - If provided, DevTools will poll this method and wait until it returns true before connecting to React.
npm package: @rbxts-js/react-globals
Description: This package is unique to react-lua. It houses React's global environment variables in a way that can be scoped to each copy of React running inside the application.
Latest version: 17.3.7-ts.1

# react-globals

This package is unique to react-lua. It houses React's global environment variables in a way that can be scoped to each copy of React running inside the application.
npm package: @rbxts-js/react-is
Description: A Roblox Lua port of the `react-is` package from React, which provides constants and runtime check functions for the various valid types of elements that can be created.
Latest version: 17.3.7-ts.1

# react-is
A Roblox Lua port of the `react-is` package from React, which provides constants and runtime check functions for the various valid types of elements that can be created.

Status: ✔️ Ported

Source: https://github.com/facebook/react/tree/master/packages/react-is

---

### ✏️ Notes
* Includes some guards where we confirm that values are tables before 

### ❌ Excluded
npm package: @rbxts-js/react-noop-renderer
Description: A Roblox Lua port of the react-noop-renderer package from React.
Latest version: 17.3.7-ts.1

# ReactNoopRenderer
A Roblox Lua port of the react-noop-renderer package from React.

Original source: https://github.com/facebook/react/tree/master/packages/react-noop-renderer

## Status

### Ported
Files:
* `src/createReactNoop.js` -> `src/createReactNoop.lua`
* `src/ReactNoop.js` -> `src/ReactNoop.lua`

The entire implementation of the NoopRenderer, plus an entry point that exports all the relevant members.

### Not Ported
Files:
* `src/ReactNoopFlightClient.js`
* `src/ReactNoopFlightServer.js`
* `src/ReactNoopServer.js`

Serves additional entry points that enable use with the `react-client` and `react-server` packages. We can revisit this if we port those

Files:
* `src/ReactNoopPersistent.js`

A version of the NoopRenderer that's created with `useMutation = false`. If this is needed at some point, it'll be trivial to port.

### Intentional Deviations
Currently, we're not supporting JSX or an equivalent markup syntax. Select parts of `createReactNoop.lua` are only partially translated and are commented out.
npm package: @rbxts-js/react-reconciler
Description: A Roblox Lua port of the `react-reconciler` package from React, which contains the core reconciler logic that drives the various renderers that can be attached.
Latest version: 17.3.7-ts.1

# react-reconciler
A Roblox Lua port of the `react-reconciler` package from React, which contains the core reconciler logic that drives the various renderers that can be attached.

Status: 🔨 Port in progress

Source: https://github.com/facebook/react/tree/master/packages/react-reconciler

---

### ✏️ Notes

#### Profiling

```
src/SchedulingProfiler.js
src/__tests__/SchedulingProfiler-test.internal.js
```

Profiling logic used for debugging the Scheduler. Includes tests that produce flamegraphs of processed tasks. This functionality is gated behind the `enableProfiling` flag defined in `SchedulerFeatureFlags.js`. Additional functionality is gated behind the enableSchedulingProfiler in ReactFeatureFlags. When enabling the Scheduling Profiler, you'll need to plug in a table with a `mark` function to the `_G.performance` global, like this:
```lua
_G.performance = {
	mark = function(str)
		debug.profileBegin(str)
		debug.profileEnd(str)
}
```

#### Debug Tracing

```
src/DebugTracing.js
src/__tests__/DebugTracing-test.internal.js
```

Debug Tracing is enabled with the enableDebugTracing ReactFeatureFlag. The current Lua implementation outputs using Lua `print`, and strips out the color and styling versus upstream. We may want to more deeply customize this based on real-world use cases of Roblox UI developers.


### ❌ Excluded

```
src/__tests__/ReactSuspenseList-test.js
```

The initial release of Roact 17 includes support for Suspense, but not the unstable SuspenseList API. This was purely to pull in the delivery schedule and narrow the support surface for the initial release.
npm package: @rbxts-js/react-refresh
Description: This package implements the wiring necessary to integrate Fast Refresh into bundlers. Fast Refresh is a feature that lets you edit React components in a running application without losing their state. It is similar to an old feature known as "hot reloadin
Latest version: 17.3.7-ts.1

# react-refresh

This package implements the wiring necessary to integrate Fast Refresh into bundlers. Fast Refresh is a feature that lets you edit React components in a running application without losing their state. It is similar to an old feature known as "hot reloading", but Fast Refresh is more reliable and officially supported by React.

This package is primarily aimed at developers of bundler plugins. If you’re working on one, here is a [rough guide](https://github.com/facebook/react/issues/16604#issuecomment-528663101) for Fast Refresh integration using this package.
npm package: @rbxts-js/react-shallow-renderer
Description: A Roblox Lua port of the react-shallow-reconciler package re-exported from React. Used to run integration-level tests in `react-dom`. Will likely be useful with the Roblox renderer when it's more thoroughly integrated.
Latest version: 17.3.7-ts.1

# react-shallow-renderer
A Roblox Lua port of the react-shallow-reconciler package re-exported from React. Used to run integration-level tests in `react-dom`. Will likely be useful with the Roblox renderer when it's more thoroughly integrated.

Status: ✔️ Ported

Source: https://github.com/NMinhNguyen/react-shallow-renderer/

---

### ✏️ Notes
* Includes some minor adjustments to the shallow renderer interface to better facilitate its translation
	* Most member functions use `:` function calls instead of `.` to avoid having to explicitly bind them to self. We could revisit this to align it more directly.
	* Implementation for `useState` returns multiple values instead of an array. This will likely be carried over to the full implementation in the reconciler as well
	* Context narrowing via `contextTypes` is only available on class components (since functions cannot have fields in Luau)
	* PropTypes are unsupported for now

### ❌ Excluded

```
src/__tests__/ReactShallowRendererMemo-test.js
```

Small test that didn't seem critical to port right now.
npm package: @rbxts-js/react-test-renderer
Description: A Roblox Lua port of the react-test-reconciler package re-exported from React. Used to run integration-level tests in `react-dom`. Will likely be useful with the Roblox renderer when it's more thoroughly integrated.
Latest version: 17.3.7-ts.1

# react-test-renderer
A Roblox Lua port of the react-test-reconciler package re-exported from React. Used to run integration-level tests in `react-dom`. Will likely be useful with the Roblox renderer when it's more thoroughly integrated.

Status: 🔨 Partially Ported

Source: https://github.com/facebook/react/tree/master/packages/react-test-renderer

---

### ✏️ Notes
* For now, only includes configs for testing with the noop renderer,

### ❌ Excluded

```
src/__tests__/ReactTestRenderer-test.internal.js
src/__tests__/ReactTestRenderer-test.js
src/__tests__/ReactTestRendererAct-test.js
src/__tests__/ReactTestRendererAsync-test.js
src/__tests__/ReactTestRendererTraversal-test.js
src/ReactTestRenderer.js
```

Actual test renderer impl is excluded for now.

```
src/__tests__/ReactShallowRenderer-test.js
src/__tests__/ReactShallowRendererHooks-test.js
src/__tests__/ReactShallowRendererMemo-test.js
```

These tests appear to be copied from the shallow renderer, which react depends upon and re-exports via `react-test-renderer`
npm package: @rbxts-js/roact-compat
Description: A thin compatibility layer connecting Roact 1.4.0 to the new roact alignment effort (often referred to as "Roact 17").
Latest version: 17.3.7-ts.1

# roact-compat
A thin compatibility layer connecting Roact 1.4.0 to the new roact alignment effort (often referred to as "Roact 17").

This does _not_ match an upstream package. Its purpose is to encapsulate any deviations whose sole purpose is to provide compatibility with production Roact during the transition.
npm package: @rbxts-js/roblox-lua-promise
Description: An implementation of `Promise` similar to Promise/A+.
Latest version: 3.5.0-ts.2

<div align="center">
	<h1>Roblox Lua Promise</h1>
	<p>An implementation of <code>Promise</code> similar to Promise/A+.</p>
	<a href="https://eryn.io/roblox-lua-promise/"><strong>View docs</strong></a>
</div>


## Why you should use Promises

The way Roblox models asynchronous operations by default is by yielding (stopping) the thread and then resuming it when the future value is available. This model is not ideal because:

- Functions you call can yield without warning, or only yield sometimes, leading to unpredictable and surprising results. Accidentally yielding the thread is the source of a large class of bugs and race conditions that Roblox developers run into.
- It is difficult to deal with running multiple asynchronous operations concurrently and then retrieve all of their values at the end without extraneous machinery.
- When an asynchronous operation fails or an error is encountered, Lua functions usually either raise an error or return a success value followed by the actual value. Both of these methods lead to repeating the same tired patterns many times over for checking if the operation was successful.
- Yielding lacks easy access to introspection and the ability to cancel an operation if the value is no longer needed.

This Promise implementation attempts to satisfy these traits:

* An object that represents a unit of asynchronous work
* Composability
* Predictable timing

## Example
`Promise.new` returns synchronously.

```lua
local HttpService = game:GetService("HttpService")

-- A light wrapper around HttpService
-- Ideally, you do this once per project per async method that you use.
local function httpGet(url)
	return Promise.new(function(resolve, reject)
		local result = HttpService:JSONDecode(HttpService:GetAsync(url))

		if result.ok then
			resolve(result.data)
		else
			reject(result.error)
		end
	end)
end

-- Usage
httpGet("https://some-api.example")
	:andThen(function(body)
		print("Here's the web api result:", body)
	end)
	:catch(function(err)
		warn("Web api encountered an error:", err)
	end)
```
npm package: @rbxts-js/scheduler
Description: A Roblox Lua port of the `scheduler` package from React, which is used under the hood by the Fiber Reconciler logic.
Latest version: 17.3.7-ts.1

# scheduler
A Roblox Lua port of the `scheduler` package from React, which is used under the hood by the Fiber Reconciler logic.

Status: ✔️ Ported

Source: https://github.com/facebook/react/tree/master/packages/scheduler

---

### ✏️ Notes
* The upstream implementation of min-heap does not include tests. To validate the port, `src/__tests__/SchedulerMinHeap.spec.lua` was added
* The scheduler contains two sets of tests
	* A small, basic set of tests using the real scheduler and mock timers.
	* A more thorough test suite that uses `MockSchedulerHostConfig.lua`, which mocks the entire HostConfig interface and provides functionality to manipulate it within tests.

#### Profiling

```
src/SchedulerProfiling.js
src/__tests__/SchedulerProfiling-test.js
```

Profiling logic used for debugging the Scheduler. Includes tests that produce flamegraphs of processed tasks. This functionality is gated behind the `enableProfiling` flag defined in `SchedulerFeatureFlags.js`. Additional functionality is gated behind the enableSchedulingProfiler flag in ReactFeatureFlags. When enabling the Scheduling Profiler, you'll need to plug in a table with a `mark` function to the `_G.performance` global, like this:
```lua
_G.performance = {
	mark = function(str)
		debug.profileBegin(str)
		debug.profileEnd(str)
}
```

We may customize this for deeper integration with the Roblox Studio profiler in the future, based on specific performance optimization workflow needs.


### ❌ Excluded

#### Post Task

```
unstable_post_task.js
src/SchedulerPostTask.js
src/__tests__/SchedulerPostTask-test.js
```

An alternate implementation of the Scheduler interface based on the new postTask browser API. There are relatively recent commits to these files, as well, suggesting new or ongoing development. Since the underlying browser API isn't relevant to the Roblox environment, this logic has been excluded.