open-index/open-npm huggingface dataset:
npm package: @rolangom/wincred
Description: wincred
Author: @rolangom
Latest version: 1.0.0

﻿# wincred

This node.js package is used to get credentials from the "Windows Credential Manager" using a Python3 script.
So, you need to have installed python>=3 and node>=8.

This package is based on this gist python script: https://gist.github.com/mrh1997/717b14f5783b49ca14310419fa7f03f6

How to install it using npm:

    npm i wincred -S

How to use it?

```javascript
import { getCredential } from 'wincred';

async function run() {
	const cred = await getCredential('credentialTarget'/*, 'c:/path-to/pythonLaucher' */); // optional, 'python' as default
	//... use the credential as { username: string, password: string }
}
```
npm package: @rolasotelo/milpa-ruleset
Description: set of rules for milpa card-game
Author: Rolando Sotelo
Latest version: 0.1.0

# Ruleset for Milpa card-game

<p align="center">
    <a href="https://codecov.io/gh/rolasotelo/milpa-ruleset">
        <img src="https://codecov.io/gh/rolasotelo/milpa-ruleset/branch/main/graph/badge.svg?token=UWGDSA60I4"/>
    </a>
    <a href="https://circleci.com/gh/rolasotelo/milpa-ruleset/tree/main"><img src="https://circleci.com/gh/rolasotelo/milpa-ruleset/tree/main.svg?style=svg"></a>
</p>

Package to be used alongside [milpa-online](https://github.com/rolasotelo/milpa-online)
and [milpa-server](https://github.com/rolasotelo/la-milpa-server) to make the online card-game work.

```shell
$ npm i @rolasotel/milpa-ruleset
```

---

## Class Diagram

The model implemented in this package can be seen here:

<p align="center">
    <a href="https://milpa-ruleset-rola.wunderbucket.dev/">
        <img src="https://milpa-ruleset-rola.wunderbucket.dev/diagrams/a74bf0e3699da3f8e58beeb19b53e20a.svg"/>
    </a>
    
</p>

---

## Repo diagram 📈

![diagram](./diagram.svg)

---
npm package: @rolatech/angular-ai
Description: `angular-ai` is a packaged Angular chat surface with:
Latest version: 20.3.3-beta.2

# angular-ai

`angular-ai` is a packaged Angular chat surface with:

- `AiChatPage` for a full ChatGPT-style page shell
- `AiChatThread`, `AiChatMessage`, and `AiChatBox` as reusable UI primitives
- typed rich-message models for markdown, text, images, videos, and grouped cards
- `angularAiRoutes` for a route-ready entrypoint
- `AiChatDemoContext` for local demo orchestration

## Running unit tests

Run `nx test angular-ai` to execute the unit tests.
npm package: @rolatech/angular-automation
Description: This library was generated with [Nx](https://nx.dev).
Latest version: 20.3.3-beta.2

# angular-automation

This library was generated with [Nx](https://nx.dev).

## Theming

Automation pages and badges read CSS variables from `@rolatech/angular-theming`, so light/dark palettes flow through automatically. Make sure the host app imports one of the prebuilt themes (for example in `styles.scss`):

```scss
@use '@rolatech/angular-theming/prebuilt/rolatech.scss' as theming;
```
npm package: @rolatech/angular-onboarding
Description: Dedicated Angular onboarding UI/state package for PrimeCasa and Rolatech.
Latest version: 20.3.3-beta.2

# @rolatech/angular-onboarding

Dedicated Angular onboarding UI/state package for PrimeCasa and Rolatech.

## Scope

Owns:
- onboarding pages
- onboarding route definitions
- onboarding facades/signals/forms
- onboarding reusable components
- apply flow UI
- applicant dashboard UI
- admin review UI

Does not own:
- HTTP transport logic
- API DTO definitions
- backend request/response contracts
- auth/session transport
- organization provisioning logic

Transport and contracts are consumed from `@rolatech/angular-services`.

## Route Exports

- `AGENT_APPLY_ROUTES`
- `AGENT_ONBOARDING_ROUTES`
- `ADMIN_ONBOARDING_ROUTES` for the admin list, detail, and review pages

## Integration Example

```ts
import { Routes } from '@angular/router';
import {
  ADMIN_ONBOARDING_ROUTES,
  AGENT_APPLY_ROUTES,
  AGENT_ONBOARDING_ROUTES,
} from '@rolatech/angular-onboarding';

export const routes: Routes = [
  {
    path: 'agents/apply',
    children: AGENT_APPLY_ROUTES,
  },
  {
    path: 'onboarding',
    children: AGENT_ONBOARDING_ROUTES,
  },
  {
    path: 'onboarding/applications',
    children: ADMIN_ONBOARDING_ROUTES,
  },
];
```
npm package: @rolatech/angular-theming
Description: Provides shared SCSS theming for Rolatech apps, including prebuilt Angular Material palettes with light/dark CSS variables.
Latest version: 20.3.3-beta.2

# angular-theming

Provides shared SCSS theming for Rolatech apps, including prebuilt Angular Material palettes with light/dark CSS variables.

## Usage

- Default Rolatech theme (Sass): `@use '@rolatech/angular-theming';`
- Prebuilt CSS in global styles: `@import '@rolatech/angular-theming/prebuilt/rolatech.css';` (swap `rolatech` for other prebuilt themes)
npm package: @rolemodel/image-diff
Description: Image Difference tool that compares pixel by pixel
Author: RoleModel Software
Latest version: 1.0.0

# Image Diff

Real-time image diffing in the browser, powered by WebGL.

## Installing

```shell
npm install @rolemodel/image-diff
```

or

```shell
yarn add @rolemodel/image-diff
```

## Usage

```javascript
import ImageDiff from "@rolemodel/image-diff"

const originalImage = document.getElementById('base-image')
const newImage = document.getElementById('new-image')
const outputCanvas = document.getElementById('output-canvas')
const outputContext = outputCanvas.getContext('2d')
const imageDiff = new ImageDiff(originalImage, newImage)

const result = imageDiff.update({
  diffColor: { r: 1, g: 0, b: 0 },
  diffThreshold: 0.2,
  backgroundAlpha: 1.0
})

// result is an offscreen canvas
outputContext.drawImage(result, 0, 0)

imageDiff.dispose()
```

Calling `update()` again will re-render the diff. Make sure to call `dispose()` to clean up WebGL resources.

## Acknowledgments

**image-diff** is [MIT-licensed](LICENSE), open-source software from [RoleModel Software][rms]. It was initially based on [pixelmatch](https://github.com/mapbox/pixelmatch), using a similar algorithm ported to WebGL.

[RoleModel Software][rms] is a world-class, collaborative software development team dedicated to delivering the highest quality custom web and mobile software solutions while cultivating a work environment where community, family, learning, and mentoring flourish.

[rms]: https://rolemodelsoftware.com/
npm package: @rolemodel/rolemodel-design-system
Description: The design system RoleModel uses to kickstart projects with a consistent starting point
Author: RoleModel Software
Latest version: 0.1.3-beta
Deprecated: This package has been renamed and now exists at https://www.npmjs.com/package/@rolemodel/optics

# Rolemodel Design System

RoleModel Design System is a scss package that provides base styles and components that can be integrated and customized in a variety of projects.

## Installation

### NPM

```sh
npm install @rolemodel/rolemodel-design-system
```

### Yarn

```sh
yarn add @rolemodel/rolemodel-design-system
```

### Import

If you are using webpack to compile, you can add this import to the top of your root level `scss` file.

```scss
@import '@rolemodel/rolemodel-design-system';
```

If you are using a different compiler such as Dart Sass, you may need to reference the scss file directly.

```scss
@import '@rolemodel/rolemodel-design-system/dist/scss/rolemodel-design-system';
```

## Documentation

We use [Storybook](https://storybook.js.org/docs/html/get-started/introduction) as a way to provide informative and interactive documentation.

It can be found here [RoleModel Design System Documentation](https://rolemodel.github.io/rolemodel-design-system)

## Tokens

Tokens are defined in `src/core/tokens`

- All core tokens are defined in `src/core/tokens/base_tokens.scss`
- Basic color tokens are defined in `src/core/tokens/example_color_tokens.scss`
- Color scale tokens are defined in `src/core/tokens/scale_color_tokens.scss`
- Alert color tokens are defined in `src/core/tokens/alert_color_tokens.scss`
- Dark mode tokens are defined in `src/core/tokens/dark_mode_tokens.scss`

There are also a few component specific tokens that are defined in their respective component file, but those are not indented to be global or used outside of that file.

There is a JSON file in `docs/token_structure.json` that lists all the current tokens in one place and shows how the names indicate organization.

## License

[MIT](LICENSE)
npm package: @rolemodel/tailored-select
Description: Tailored Select is a Web Component built to be a searchable select box. Inspired by tom-select.js to provide a framework agnostic autocomplete widget with native-feeling keyboard navigation. Useful for tagging, contact lists, etc.
Author: RoleModel Software
Latest version: 0.0.4

# Overview

## Name and aliases

The project is named Tailored Select. Some will refer to it as Bob Select or Yoinker™️.

## Purpose

Tailored Select is a Web Component built to be a searchable select box. Inspired by tom-select.js to provide a framework agnostic autocomplete widget with native-feeling keyboard navigation. Useful for tagging, contact lists, etc.

## Technologies

### Chosen

- [Web Components](https://developer.mozilla.org/en-US/docs/Web/API/Web_components) As the foundational technology.
- [Lit](https://lit.dev/) for easily creating Web Components.
- [Vite](https://vitejs.dev/) for a fast development environment that handles developing, building, and publishing the project.

## Technology relationships

- Web Component
- Simple Form Component (TODO: link to rolemodel rails)
- Capybara test helper (TODO: link to rolemodel rails)
- Optics addon (TODO: link to optics)

## Supported browsers

This project is supported in all modern browsers.

# How to set up the project

## External tool installation

`yarn install`

## How to run locally

`yarn vite`

## How to run tests

TODO: Add tests

## Editor plugins

- TODO: Maybe add prettier?

## Testing Strategy

### Unit tests

Due to the nature of this application, unit tests are prominent and handle most of the confidence building and documentation needs of the system below the user interface.

## Testing tools

TODO: Which tools are we using?

## Branching strategy

To begin a new feature run, `git checkout -b <branchname>`.
When finished with the feature and the code has been reviewed, the commits should be squashed before merging. See [RoleModel Best Practices](https://github.com/RoleModel/BestPractices) for more information.

## Deployment

A Github Action is set up to build and deploy the project to NPM and Github packages. The deployment uses the `main` branch and is triggered by creating a release.

### Local build

To build the project locally, run `yarn build`.

## Copyright & licensing

Copyright (c) 2024 Open Source @RoleModel Software
npm package: @rolesvillesoftware/fancy-drop
Description: This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 6.0.0.
Latest version: 2.2.0

# FancyDrop

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 6.0.0.

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

## Running unit tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).
npm package: @rolesvillesoftware/tools
Description: A tools set utilized by Rolesville Software LLC
Author: Rolesville Software LLC
Latest version: 4.2.2



# Rolesville Software LLC - Tool
NPM module containing routine and shared components for Angular and NodeJS programs and components writen by Roleville Software LLC.
## Installation

    npm install --save @rolesvillesoftware/tools
   
## **isNumeric**

Checks to verify if an object is numeric or not.

    import { isNumeric } from "@rolesvillesoftware/tools/dist";
    describe("Test isNumber", () => {
	    it("test", () => {
	        expect(isNumeric("32342")).toBeTruthy();
	        expect(isNumeric("234A23")).toBeFalsy();
	    });
    });

## SafePromise
SafePromise was designed to properly handle async and await in TypeScript and to reduce the warnings that are given when a promise is not properly caught. This was written by our team to have a common way to report successful and error promises. 

    import { SafePromise } from "@rolesvillesoftware/tools/dist";
    
    describe("Test SafePromise", () => {
      it("Test Successful", done => {
        SafePromise.run(() => Promise.resolve(true))
          .then(data => {
            expect(data.isError).toBeFalsy();
            expect(data.isSuccessful).toBeTruthy();
    
            const results = data.value;
            expect(data.value).toBeTruthy();
            done();
          })
          .catch(error => fail);
      });
    
      it("Test Failure", done => {
        SafePromise.run(() => Promise.reject("some error")).then(data => {
          expect(data.isError).toBeTruthy();
          expect(data.isSuccessful).toBeFalsy();
    
          const error = data.error;
          const results = data.value;
    
          expect(results).toBeNull();
          expect(error).toEqual("some error");
          done();
        });
      });
    });

Using within TypeScript:

    import { SafePromise } from "@rolesvillesoftware/tools/dist";
    
    export class SafePromiseExample {
    
        public async doSomething(promise: () => Promise<any>) {
            var results = await SafePromise.run(promise);
            if (results.isError) { throw new Error(results.error); }
            
            const result = results.value;
            /*** do other stuff now... */
        }
    }

 

> Written with [StackEdit](https://stackedit.io/).
npm package: @roleup/eslint-config
Description: ESLint config for RoleUp
Author: Eric Hacke
Latest version: 3.0.1

# @roleup/eslint-config

ESLint rules for xtrct.io

## Installation

You'll first need to install [ESLint](http://eslint.org):

```
$ npm i -D eslint
```

Next, install `@roleup/eslint-config`:

```
$ npm i -D @roleup/eslint-config
```

### Peer Dependencies
You'll also need to install the following peer dependencies:
```
$ npm i -D eslint-config-airbnb-base eslint-plugin-import eslint-plugin-mocha
```

**Note:** If you installed ESLint globally (using the `-g` flag) then you must also install `@roleup/eslint-config` globally, as well as it's peer dependencies.

## Usage

Add `@roleup/eslint-config` to the extends section of your `.eslintrc` configuration file. 

```json
{
    "extends": [
        "@roleup/eslint-config"
    ]
}
```
npm package: @roleup/rerror
Description: RoleUp error class
Author: Eric Hacke
Latest version: 2.0.3

# rerror
roleup.io error class

## Install
```bash
npm i -S @roleup/xerror
```

## Use
```javascript
const RError = require('@roleup/rerror');

// Throws error which inheirits from Error and has a default http code of 500 INTERNAL_SERVER_ERROR
const throws = () => { throw new RError('boom'); };

// Throw with a different http code
// XError.HTTP_STATUS is just the 'http-status' package
const throwsWithHttpError = () => { throw new RError('boom', RError.HTTP_STATUS.BAD_REQUEST); };

// Throw with special data
const throwsWithData = () => { throw new RError('boom', undefined, {foo: 'bar'}); };
```

<a name="RError"></a>

## RError
**Kind**: global class  
<a name="new_RError_new"></a>

### new RError(message, [code], [data])

| Param | Type | Default | Description |
| --- | --- | --- | --- |
| message | <code>string</code> |  | error message |
| [code] | <code>number</code> | <code>500</code> | http error code |
| [data] | <code>any</code> |  | any extra data to attach to the error |
npm package: @rolexjs/core
Description: RoleX Core - AI Agent Role Management Framework
Latest version: 1.6.3

# @rolexjs/core

RoleX Core - AI Agent Role Management Framework

## Installation

```bash
bun add @rolexjs/core
```

## Usage

```typescript
import { createRole } from "@rolexjs/core";

const role = createRole();
console.log(role);
```

## License

MIT
npm package: @roleypoly/rpc
Description: This package includes automatically generated files based on protobuf definition files. Currently, gRPC Go, gRPC-Web JS and TS definitions exist here. Nothing here is a functional part of an app, just data wiring.
Author: Katie Thornhill
Latest version: 1.9.3

# roleypoly rpc

This package includes automatically generated files based on protobuf definition files. Currently, gRPC Go, gRPC-Web JS and TS definitions exist here. Nothing here is a functional part of an app, just data wiring.

Versioning is done automatically via semantic-release, and no stability guarantees will be made in 1.x.

## Importing

- **Go:** `go get -u github.com/roleypoly/rpc`
- **JS/TS:** `yarn add @roleypoly/rpc`

In both cases, you may directly import a sub-directory, e.g. `@roleypoly/rpc/discord` or `github.com/roleypoly/rpc/discord`, which resolves to the generated protobuf file.

## Developing

### With Docker

Make your changes **only** to .proto files, run `./generate.sh` or `./generate.ps1`. You must have Docker installed and available on PATH.

If you need more fresh NPM packages, you can build the docker image locally with `docker build . -t sometag`, and use the `docker run` command within `./generate.ps1`. This should be automatically done during normal CI/CD processes.

### Without Docker

Make your changes **only** to .proto files, run `go generate` to update definitions. All `index.js` and `index.d.ts` files are generated for you.

To update definitions, you'll need to run `yarn` for **protoc-gen-ts**, and fetch **protoc**, and **protoc-gen-go** on your own.

### Making new packages

All packages for this repo need to have a protobuf file, and `.genconfig` with every generator needed on separate lines.

For instance, a shared gRPC-Web and gRPC-Go package will want to have a `.genconfig` with the following contents:
```
go
js
ts
```

These are automatically configured to these arguments to protoc:
- `ts` => `--ts_out=services=true:.`
- `js` => `--js_out=import_style=commonjs,binary:.`
- `go` => `--go_out=plugins=grpc:.`
- `--noService` => Disables service generation for shared libraries without RPCs

If more are needed, please add them to `./hack/gen.go`.

## Using

You are free to use my definitions as you see fit. They might be useful in your app, or they might not.
npm package: @rolfkoenders/react-daterange-picker
Description: A react date range picker using Material Design
Author: Rolf Koenders
Latest version: 1.0.7

# react-daterange-picker

A react date range picker using material-ui components.

<a href='https://www.npmjs.com/package/@rolfkoenders/react-daterange-picker'>
    <img src='https://img.shields.io/npm/v/@rolfkoenders/react-daterange-picker.svg' alt='Latest npm version'>
</a>

## Live Demo: https://flippingbitss.github.io/react-daterange-picker/

## Usage

```bash
npm install @rolfkoenders/react-daterange-picker --save
# or with yarn
yarn add @rolfkoenders/react-daterange-picker
```

![Screenshot](/screenshot_1.png?raw=true "Screenshot")

## Basic Example

```tsx
import React from "react";
import {
  DateRangePicker,
  DateRange,
} from "@rolfkoenders/react-daterange-picker";

type Props = {};
type State = {
  open: boolean;
  dateRange: DateRange;
};

class App extends React.Component<Props, State> {
  state = {
    open: true,
    dateRange: {},
  };

  render() {
    return (
      <DateRangePicker
        open={this.state.open}
        onChange={(range) => this.setState({ dateRange: range })}
      />
    );
  }
}

export default App;
```

## Basic example using hooks

```tsx
import React from "react";
import {
  DateRangePicker,
  DateRange,
} from "@rolfkoenders/react-daterange-picker";

type Props = {};

const App: React.FunctionComponent<Props> = (props) => {
  const [open, setOpen] = React.useState(false);
  const [dateRange, setDateRange] = React.useState<DateRange>({});

  return (
    <DateRangePicker open={open} onChange={(range) => setDateRange(range)} />
  );
};

export default App;
```

## Types

```ts
interface DateRange {
  startDate?: Date;
  endDate?: Date;
}

interface DefinedRange {
  label: string;
  startDate: Date;
  endDate: Date;
}
```

## Props

| Name               | Type                  | Required   | Default value | Description                                        |
| :----------------- | :-------------------- | :--------- | :------------ | :------------------------------------------------- | ------------------------- |
| `initialDateRange` | `DateRange`           |            | `{}`          | initially selected date range                      |
| `minDate`          | `Date                 | string`    |               | 10 years ago                                       | min date allowed in range |
| `maxDate`          | `Date                 | string`    |               | 10 years from now                                  | max date allowed in range |
| `onChange`         | `(DateRange) => void` | _required_ | -             | handler function for providing selected date range |
| `definedRanges`    | `DefinedRange[]`      |            | -             | custom defined ranges to show in the list          |
npm package: @rolilink/redux-entity-sagas
Description: An entity saga is a `redux-saga` that is able to fetch, create or update an entity or a group of entities from an api and update the  redux state to reflect the network operation done. It also provides lifecycle hooks, conditional execution, rollback on c
Author: Rolando
Latest version: 1.0.0

# network-entity-sagas
An entity saga is a `redux-saga` that is able to fetch, create or update an entity or a group of entities from an api and update the 
redux state to reflect the network operation done. It also provides lifecycle hooks, conditional execution, rollback on cancellation
and rollback on error.

## installation
```
yarn add @rolilink/redux-entity-saga
```
or
```
npm install --save @rolilink/redux-entity-saga
```

## usage
To generate the redux entity saga you will need to require `createEntitySaga`:

```
const createEntitySaga = require('@rolilink/redux-entity-saga');

makeReduxEntitySaga(
  { // api calls functions
    dispatchApiCall, // crud api call to the endpoint it should yield a response.
    rollbackApiCall, // rollback operation in case of error or task cancellation.
  },
  { // action creators
    dispatchActionCreator, // action creator that returns the action that adds, create or updates the state.
    rollbackActionCreator, // action creator that rollbacks the state to the previos state.
  },
  { // http hooks
    createRequest, // a function that yields a request object.
    completeRequest, // a function that changes the request status to complete.
    errorRequest, // a function that changes the request status to errored.
    cancelRequest, // a function that changes the request status to cancelled.
  },
);
```

This will return a generator function that can be used as a redux saga.

### Lifecycle hooks
TODO

### Http hooks
TODO

### Creating a CRUD module with axios and @rolilink/redux-network
TODO
npm package: @rolilink/redux-network
Description: A group of actions, reducers and selectors to handle networking on redux
Author: Rolando Perez
Latest version: 1.0.5

# network-redux
A group of actions, reducers and selectors to handle networking on redux. Uses redux-toolkit.

## installation
```
yarn add @rolilink/redux-network
```
or
```
npm add @rolilink/redux-network
```

### usage
To generate the redux duck you will need to require `makeReduxNetwork`:

```
const { makeReduxNetwork } = require('@rolilink/redux-network');

makeReducer('organization');
```

This will return a duck object like this
```
{
  actions, // a object with the actions returned by redux-toolkit
  reducer, // the reducer function
  selectors, // an object with the selectors returned by redux-toolkit
  caseReducers, // an object with the case reducers returned by redux-toolkit
}
```