open-index/open-npm huggingface dataset:
npm package: @strangebytes/pouchdb-orm
Description: A simple ORM for validating and storing data in PouchDB
Author: Strange Bytes
Latest version: 0.0.15

# Pouchdb ORM
This is a simple ORM/ODM for storing and fetching data in PouchDB using Zod for schema definition and validation.

## Example
```typescript
import PouchDB from 'pouchdb'
import pouchFind from 'pouchdb-find'
import {z} from 'zod'
import {Collection} from '@strangebytes/pouchdb-orm'

const pouchDB = new PouchDB('example')
PouchDB.plugin(pouchFind)

// All schema's require _id and _rev
const baseSchema = z.object({
    _id: z.string(),
    _rev: z.string().optional()
})
const exampleSchema = baseSchema.extend({
    foo: z.string(),
})
const exampleCollection = new Collection(pouchDB, 'example', exampleSchema)

// Create a document
const {ok, id, rev} = await exampleCollection.put({
    _id: 'hello',
    foo: 'bar',
})

// Update a document by specifying id and revision
await exampleCollection.put({
    _id: id,
    _rev: rev,
    foo: 'baz',
})

// Find documents in a collection
// See documentation in PouchDB/CouchDB for querying
// https://pouchdb.com/api.html#query_index
const examples = await exampleCollection.find()

// Find a document
const example = await exampleCollection.findById('hello')

// Update an existing document without needing to manually pass a revision
await exampleCollection.update({
    _id: 'hello',
    foo: 'something else',
})

// Remove a document by ID
await exampleCollection.removeById('hello')
```

## Under the hood
This project aims to be as lightweight of a wrapper around PouchDB as is possible.
Collections add a type of "$collection" in order to enable querying by collection, and that's about it.

## Roadmap
- [x] Creating documents with validation
- [x] Fetching documents with validation
- [x] Support Mango queries
- [ ] Migration System
- [ ] Fancy data viewer
- [ ] Graceful error handling
- [ ] Live Queries
npm package: @strangebytes/vue-dexie-live-query
Description: Dexie integration for Vue 3
Author: Strange Bytes
Latest version: 0.1.0

# useDexieLiveQuery
[Dexie](https://dexie.org) integration for Vue 3

### Install
```shell
npm install @strangebytes/vue-dexie-live-query
```

## Examples

```typescript
import {useDexieLiveQuery} from '@strangebytes/vue-dexie-live-query'


const allTodos = await useDexieLiveQuery(() => db.todos.toArray())

```

## Acknowledgement
Based on implementation from [devweissmikhail](https://github.com/devweissmikhail/useDexieLiveQuery)
Modified to enable async initial load
npm package: @strangelytyped/w1temp
Description: Measure temperature through DS18B20 sensor connected to 1wire to Raspberry PI with node.js
Author: Petr Kolář
Latest version: 4.0.2

# w1temp
Measure temperature through DS18B20 sensor connected to 1wire to Raspberry PI with `node.js`

## Instalation
`npm install w1temp`

## Dependencies
W1 configuration:

1. at the end of file /boot/config.txt add `dtoverlay=w1-gpio,gpiopin=<gpiopin>` where &lt;gpiopin&gt; is pin where is connected w1 data channel
2. run `modprobe w1-gpio && modprobe w1-therm` (it can be at cron too: `@reboot sudo modprobe w1-gpio && sudo modprobe w1-therm`)

## Methods

### W1Temp.setGpioPower(*gpioPinNumber*)
Turn on any gpio pin as W1 power.

### W1Temp.setGpioData(*gpioPinNumber*)
Set any gpio pin to use as W1 data channel (required root permissions).

### W1Temp.getSensorsUids()
Return Promise which returns list of available sensors uids, catch if fails.

### W1Temp.getSensor(*sensorUid*, *enablePolling* _= true_)
Return Promise which returns sensor instance, catch if fails.
The *enablePolling* argument controls whether the sensor will emit *change* events by monitoring the sensor value in the background. Defaults to enabled.

### &lt;sensor_instance&gt;.getTemperature()
Returns actual temperature on sensor.

### &lt;sensor_instance&gt;.getTemperatureAsync()
Return Promise which returns temperature on sensor.

### &lt;sensor_instance&gt;.on('change', *callback(temp)*)
Event on change temperature.

## Example
```javascript
var W1Temp = require('w1temp');

// turn on gpio pin 13 as W1 power if you want to
W1Temp.setGpioPower(13);

// set gpio pin 6 to use as W1 data channel
// if is not set by instructions above (required root permissions)
W1Temp.setGpioData(6);

// print list of available sensors uids (ex.: [ '28-00000636a3e3' ])
W1Temp.getSensorsUids().then(function (sensorsUids) {
  console.log(sensorsUids);
});

// get instance of temperature sensor
W1Temp.getSensor('28-00000636a3e3').then(function (sensor) {

  // print actual temperature
  var temp = sensor.getTemperature();
  console.log('Actual temp:', temp, '°C');

  // print actual temperature on changed
  sensor.on('change', function (temp) {
    console.log('Temp changed:', temp, '°C');
  });

});
```
npm package: @strangemood/evm
Description: ``` # Download and install foundry curl -L https://foundry.paradigm.xyz | bash
Author: Evan Conrad
Latest version: 0.4.0

# strangemood-eth

```
# Download and install foundry
curl -L https://foundry.paradigm.xyz | bash

# Setup foundry
foundryup

# Install dependencies
forge install

# Run tests
forge test
```
npm package: @strangerlabs/tantivy
Description: NodeJS bindings for Tantivy
Author: Stranger Labs
Latest version: 0.1.1

# tantivy

[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)

> NodeJS bindings for Tantivy

TODO: Fill out this long description.

## Semver Notice

Please note this is an unstable API. Until 1.0.0 is released, breaking changes may be published without a major version increment.

## Table of Contents

- [Install](#install)
- [Usage](#usage)
- [API](#api)
- [Maintainers](#maintainers)
- [Contributing](#contributing)
- [License](#license)

## Install

Clone this repository.

Then run the following in the project's root directory.

```sh
npm i
npm run build

# for for use with electron
npm run build-electron
```

## Usage

```js
const { Search, SchemaBuilder, TopDocs, QueryParser } = require('@strangerlabs/tantivy')

let search = new Search()
let schemaBuilder = new SchemaBuilder()

schemaBuilder.addTextField("_id", ["STRING"] )
let title = schemaBuilder.addTextField("title", ["TEXT", "STORED"] )
let year = schemaBuilder.addTextField("year", ["TEXT", "STORED"] )
let authors = schemaBuilder.addTextField("authors", ["TEXT", "STORED"] )
let url = schemaBuilder.addTextField("url", ["TEXT", "STORED"] )

search.buildSchema(schemaBuilder)
search.defaultSearchFields([title, year, authors, url])

search.createIndex('./data')
search.createIndexWriter(100000000)

let document = {
  _id: "1",
  title: "The Economic History of the Fur Trade: 1670 to 1870",
  year: "2008",
  authors: ["Ann M. Carlos, University of Colorado", "Frank D. Lewis, Queen’s University"],
  url: "http://eh.net/encyclopedia/the-economic-history-of-the-fur-trade-1670-to-1870/"
}

search.addDoc(JSON.stringify(document))

search.commit()
search.loadSearchers()

let queryParser = new QueryParser(search, [title, year, authors, url])
let query = queryParser.parse("fur")
let collector = new TopDocs(10)

let results = search.topSearch(query, collector)

console.log(results)
```

## API

Please browse to the examples folder for line-by-line documentation of the API.

## Maintainers

StJohn Giddy [@thecallsign](https://github.com/thecallsign)

## Contributing

PRs accepted.

Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.

## License

MIT © 2019 Stranger Labs, Inc.
npm package: @strangesecrets/rbac
Description: Simple role based access control (RBAC) library.
Author: strangesecrets
Latest version: 0.0.2

# Role based Access Control
This module provides a simple [role-based access control](https://en.wikipedia.org/wiki/Role-based_access_control)
implementation for use by client and server code.

Each user is assigned a role that determines what they can and can't do within an
application. The application describes each role to the module and then queries the
RBAC for authorization when performing actions on the users behalf.

# Installation
To make use of this module, install it with npm using:
```
npm install --save @strangesecrets/rbac
```
# Usage
Once installed to your project, you may create a simple role:
```ecmascript 6
import Rbac from '@strangesecrets/rbac';

const role = Rbac.createRole('my_role');
```
Once created, we may obtain the role using the get method:
```ecmascript 6
const role = Rbac.get('my_role');
```
####  Resources
A resource describes a point where access can be managed, conceptually it could be a file or the entire file system. Simply put
it is a 'resource' that may be accessed by a user. Each resource contains several permissions that may or may not be granted
to a particular role. If a role is granted a permission, then it may perform the related action.

If a resource contains no permissions at all, then it is considered to have administrative access and gains all permissions.

For example, given a role, we add two resources. The first grants two permission 'read' and 'write', whilst the second creates
a resource with administrative access:
```ecmascript 6
role.allow('file_system', ['read', 'write']);
role.allow('project', 'edit');
role.allow('display');
```
We can determine whether or not a role has certain permissions by using the checkPermission method. If a role was created
with administrative access it will return true for all permission checks. We may also supply an array of permissions, in
this case the checkPermission call will only return true if the role contains all of the specified permissions.

```ecmascript 6
role.checkPermission('file_system', 'read'); // True
role.checkPermission('file_system', ['read', 'write']); // True
role.checkPermission('file_system', ['read', 'write', 'edit']); // False

role.checkPermission('project', 'read'); // False
role.checkPermission('project', 'edit'); // True

role.checkPermission('display', ['read', 'write']); // True
role.checkPermission('display', 'edit'); // True
```
Because the 'file_system' resource was not created with administrative privileges, if we now deny the read and write permissions
the entire resource is removed.
```ecmascript 6
role.deny('file_system', ['read', 'write']);
role.checkPermission('file_system', 'read'); // False
```
# Building
Unit tests are provided for the module, automated builds should run the unit tests prior to uploading a new revision to
the repository store with the command:
```
npm test
```
npm package: @strangestraw/electron-overlay-window
Description: Library for creating overlay windows, intended to complement the Electron.
Author: Alexander Drozdov
Latest version: 1.0.9

## electron-overlay-window

Library for creating overlay windows, intended to complement the Electron.

Responsible for:
  - Finding target window by title
  - Making overlay window a child of target
  - Keeping position and size of overlay window with target in sync
  - Emits lifecycle events

Important notes:
  - You can initialize library only once (overlay window must never die, and title by which target window is searched cannot be changed)
  - You can have only one overlay window
  - Found target window remains "valid" even if its title has changed
  - Correct behavior is guaranteed only for top-level windows *(A top-level window is a window that is not a child window, or has no parent window (which is the same as having the "desktop window" as a parent))*
  - Windows: target window must have the same or lower privilege level than overlay window
  - X11: library relies on EWHM, more specifically `_NET_ACTIVE_WINDOW`, `_NET_WM_STATE_FULLSCREEN`, `_NET_WM_NAME`

Supported backends:
  - Windows (7 - 10)
  - Linux (X11)

Recommended dev utils
- Windows: AccEvent (accevent.exe) and Inspect Object (inspect.exe) from Windows SDK
- X11: xwininfo, xprop, xev
npm package: @stranothus/patience
Description: Lets timeouts be set for greater than the 2147483647 millisecond JS limit
Author: Quinn Gibson
Latest version: 1.0.1

# Patience

Patience is tool for creating longer waits than allowed in default JavaScript. A `setTimeout` can only wait for 2147483647 milliseconds, at maximum, which is about 25 days. That's fine in some cases, but large scale projects might need longer waits.

Patience uses `longTimeout`, a command nearly exactly like `setTimout`, but without any time limit by combining multiple `setTimeout`s for you in a quick and efficient manner. You can use the function just like `setTimeout`.

## Install

`npm install @stranothus/patience`

## Usage

```JS
longTimeout(() => {
    console.log("50 days later");
}, 2147483647 * 2);

// prints "50 days later" to the console after about fifty days
```
npm package: @strantalis/workset
Description: Go CLI for multi-repo workspaces with linked worktrees
Latest version: 0.3.1

# Workset

[![test](https://github.com/strantalis/workset/actions/workflows/test.yml/badge.svg)](https://github.com/strantalis/workset/actions/workflows/test.yml)
[![lint](https://github.com/strantalis/workset/actions/workflows/lint.yml/badge.svg)](https://github.com/strantalis/workset/actions/workflows/lint.yml)
[![release](https://github.com/strantalis/workset/actions/workflows/release.yml/badge.svg)](https://github.com/strantalis/workset/actions/workflows/release.yml)
[![docs](https://github.com/strantalis/workset/actions/workflows/docs.yml/badge.svg)](https://github.com/strantalis/workset/actions/workflows/docs.yml)

All your repos. One place.

A **workset** is a collection of repos that belong together. When you start a feature, you create a **thread** that spins up linked worktrees across all of them. No duplicate clones, no losing track of which branches go together. Desktop app and CLI included.

<p align="center">
  <img src=".github/workset-model.svg" alt="Workset model: worksets group repos, threads create linked worktrees across them" width="680">
</p>

- **Desktop app**: embedded terminals, diff views, PR management, and GitHub workflows in one window.
- **GitHub workflows**: create PRs, view status, read review comments, and generate PR descriptions.
- **AI-powered**: generate PR text and commit messages with pluggable agents (Codex, Claude).
- **Safe defaults**: no destructive actions without explicit flags.

> [!NOTE]
> Workset is under active development; interfaces and behavior may change without notice.

## Quickstart

Install (recommended):

```bash
brew tap strantalis/homebrew-tap
brew install workset
```

Upgrade (Homebrew):

```bash
brew update
brew upgrade --cask workset
```

Install (npm):

```bash
npm install -g @strantalis/workset@latest
```

Alternative (Go install):

```bash
go install github.com/strantalis/workset/cmd/workset@latest
```

Create a thread and add repos:

```bash
workset new demo
workset repo add git@github.com:your/org-repo.git -t demo
workset status -t demo
```

Worksets (reusable repo bundles):

```bash
workset repo registry add platform git@github.com:org/platform.git
workset repo registry add api git@github.com:org/api.git
workset new auth-spike --workset platform-core --repo platform --repo api
```

## Docs

Docs are built with **Astro + Starlight**. The site config is `docs-site/astro.config.mjs`, content lives in `docs-site/src/content/docs/`, and the published site is [workset.dev](https://workset.dev).

Local dev:

```bash
make docs-serve
```