open-index/open-npm huggingface dataset:
npm package: @matthewroach/lit-components
Description: Set of Web Components
Author: Matthew Roach
Latest version: 0.1.3

# Lit Components

A collection of Web Components

## Installing

As the package is published to the GitHub packages it requires an `.npmrc` file configured to the GitHub registry for the scope `@matthewroach` and a personal GitHub access code

```
# .npmrc
@matthewroach:registry=https://npm.pkg.github.com/

//npm.pkg.github.com/:_authToken=${AUTH_TOKEN}

```

Install the package

```
npm i @matthewroach/lit-components --save-dev
```

## Versioning

Version is handling with `npm` and uses [semver](https://semver.org)

Use the correct `npm run version:{type}` command to bump the version

- `major` - Used for created a breaking change release - 1.0.0 -> 2.0.0
- `minor` - Increase the minor version - 1.1.0 -> 1.2.0
- `patch` - Small backwards compatible changes/bug fixes - 1.0.1 -> 1.0.2
- `prerelease` - Allows the release of a future version - 1.0.1 -> 1.0.1-prerelease.0

## Publishing

Publishing happens automatically with GitHub actions when a new tag is create

### Manual Publishing

Package is published to GitHub packages. This requires `npm` configuration updates and an `authToken`.

Publish happens with `npm publish` command.

Before publishing a new version needs to be created. Not creating a new version with the `npm run version:{type}` script will result in an error - `409 Conflict`

```
# .npmrc
@matthewroach:registry=https://npm.pkg.github.com/

//npm.pkg.github.com/:_authToken=${AUTH_TOKEN}
```
npm package: @matthewscharles/multitouch-mapper
Description: Detect touch / pointer events across multiple layers in the DOM.
Author: Charles Matthews
Latest version: 1.2.9

# multitouch-mapper

This is work in progress and not really intented for external projects just yet!


## purpose

- To pick up multitouch more effectively for digital musical instruments, where conventional DOM interactions might be restrictive.

- To enable canvas-based interactions with DOM elements sitting underneath (in an "underlay" layer) to support screen reader interactions.

## CSS tip
To avoid issues with multitouch scrolling/pinching on mobile, incorporate this in the document body or appropriate container...
```css
container{
    -webkit-touch-callout: none; 
    touch-action: none;
}
```

On iOS, this should allow up to four fingers to be used for multitouch before the default system behaviour (e.g. app switching) kicks in.


## process

An instance of MultitouchMapper stores a buffer of items categorised by CSS selectors or strings (assuming, at present, that it is easiest to pick up the location of an object on the dom rather than fixed coordinates or other methods).


~~To make this happen, the object will:~~

- ~~Assign "pointer-events:none" to all items that might get in the way, including the overlay canvas.~~
- ~~Assign "pointer-events:auto" to items to pick up~~
- Assign itself as an event listener to the document

My preferred way of working with touch is to use an overlay e.g. a canvas as a blanket to prevent touch interactions, and also to provide a layer for annotations, animations etc. to happen over the relevant elements.

We may choose to have multiple instances of the object (or eventually, cover multiple targets within the same object)...for example if several canvas overlays are present on the page. 

At the moment, the best way to implement appears to be to cover the whole document as the target.  I would usually prefer to use a canvas as a target for picking up mouse / touch events, but this becomes problematic as pointer events need to be detected on said target, and therefore conflict with the object's search for the frontmost element.
npm package: @matthewscharles/screen-instrument
Description: Class for screen-based musical instruments on the web
Author: Charles Matthews
Latest version: 1.1.3

# screen-instrument
A class for quickly building screen-based musical instruments on the web.

Work in progress -- only used in a couple of projects so far. 
This library is not well documented, and probably not fit for public use just yet.  Explore at your own risk!

To see this library in action, please see the [Sound Ideas](https://blurringtheboundaries.github.io/sound-ideas/) project page.

# What this does
This class describes an object that can be used to create a screen-based musical instrument.  It can be used to create a keyboard, a guitar, or any other instrument that can be represented as a grid of notes.

A corresponding layer of buttons is placed in a separate container for screen reader access.

# Dependencies

- Currently relies on Tone.js for sound generation.

- Chord library by [@tombatossals](https://www.npmjs.com/package/@tombatossals/chords-db) -- this seems to push the size of the package up quite a bit, so I may remove it in the future.

and some of my own packages currently in development:

- multitouch-mapper (or touch-pickup, name tbd)
- keyboard-mapper
- midi-mapper
- status-vo (screenreader access)

# Instructions

Temporary -- currently troubleshooting!  This project is forcing me to learn how to use npm and webpack. As a result I'm fighting with / refactoring some old habits...

```JavaScript
import { ScreenInstrument } from '@matthewscharles/screen-instrument'
```

I suggest importing the ScreenInstrument class as Instrument, as this will be the name of the class in the future.  Except this doesn't seem to work, currently:

```javascript
import { Instrument } from '@matthewscharles/screen-instrument'
```

or, if using the standalone version in the dist folder:


```javascript
window.Instrument = ScreenInstrument.ScreenInstrument;
```

Then, create a new instance of the class:

```javascript   
var instrument = new Instrument(noteArray, document.querySelector('#instrument__underlay'), false, 'instrument', {}, false, false);
``` 

## Arguments: 
- noteArray: an array of note objects. 
- container: the container element for the screen reader accessible layer.
- presetName (optional): the name of a preset to load.  
- instrumentName: the name of the instance in case needed for reference later.
- soundLibrary: a dictionary of preset names and associated filenames (using samples for now)
- actuator: 'synth' or 'player' (defaults to synth)
- drone: boolean, used in cases where fixed notes are faded rather than definite on/off

Yes, this is definitely a work in progress.

Proper instructions in a future version!

---

# Credits

Guitar sound: [https://freesound.org/people/Kyster/packs/7398/](Notes on nylon strings by Kyster) -- released under the CC attribution license

---

Charles Matthews 2023
npm package: @matthewscharles/socket-mapper
Description: Mapping sockets for remote music
Author: Charles Matthews
Latest version: 1.0.2

# socket-mapper
 
Handle MIDI-style messages over a socket connection, using similar processes to midi-mapper, multitouch-mapper, keyboard-mapper, etc.

Currently investigating sending samples over the socket connection, as well as MIDI-style messages.

This is not currently intended for public use. It is a work in progress.

CM 2024