open-index/open-npm huggingface dataset:
npm package: @paulrobertlloyd/mf2tojf2
Description: Convert MF2 to JF2
Author: Paul Robert Lloyd
Latest version: 3.0.0

# MF2 to JF2

[![Test status](https://github.com/getindiekit/mf2tojf2/workflows/test/badge.svg)](https://github.com/getindiekit/mf2tojf2/actions)

Convert [MF2](https://microformats.org/wiki/microformats2-parsing) to [JF2](https://jf2.spec.indieweb.org).

JF2 is a simpler JSON serialization of microformats2 intended to be easier to consume than the standard [microformats JSON representation](https://microformats.org/wiki/microformats2).

## Requirements

- [Node.js](https://nodejs.org) v22+

## Usage

### Simple (synchronous)

```js
import { mf2tojf2 } from "mf2tojf2";

const mf2 = {
  items: [
    {
      type: ["h-card"],
      properties: {
        name: ["Paul Robert Lloyd"],
        url: ["https://paulrobertlloyd.com"],
      },
    },
  ],
};

const jf2 = mf2tojf2(mf2);

console.log(jf2);
```

Returns:

```js
{
  type: "card",
  name: "Paul Robert Lloyd",
  url: "https://paulrobertlloyd.com"
}
```

### With references (asynchronous)

JF2 can include [a `references` property](https://jf2.spec.indieweb.org/#using-references) to exclude any non-authoritative data from the defined object.

```js
import { mf2tojf2referenced } from "mf2tojf2";

const mf2 = {
  items: [
    {
      type: ["h-entry"],
      properties: {
        name: ["What my friend ate for lunch yesterday"],
        published: ["2019-02-12T10:00:00.000+00:00"],
        url: ["https://my-website.example/bookmarks/lunch"],
        "bookmark-of": ["https://their-website.example/notes/lunch"],
        "mp-syndicate-to": "https://example.social/@username",
      },
    },
  ],
};

const jf2WithReferences = await mf2tojf2referenced(mf2);

console.log(jf2WithReferences);
```

Returns:

```js
{
  type: "entry",
  name: "What my friend ate for lunch yesterday",
  published: "2019-02-12T10:00:00.000+00:00",
  url: "https://my-website.example/bookmarks/lunch",
  "bookmark-of": "https://their-website.example/notes/lunch",
  "mp-syndicate-to": "https://example.social/@username",
  references: {
    "https://their-website.example/notes/lunch": {
      type: "entry",
      name: "What I ate for lunch",
      published: "2019-01-12T15:55:00.000+00:00",
      url: "https://their-website.example/notes/lunch",
      content: {
        text: "I ate a cheese sandwich, which was nice.",
        html: "<p>I ate a cheese sandwich, which was nice.</p>"
      },
      category: ["Food", "Lunch", "Sandwiches"]
    }
  }
}
```

> [!NOTE]\
> Values for `audio`, `photo`, `url`, `video` and any property prefixed with `mp-`, are excluded from referencing.

## Testing

`npm test`

## Releasing a new version

`npm run release`

## Credits

Based on [mf2tojf2.py](https://github.com/microformats/mf2tojf2.py).
npm package: @paulrosania/electron-redux
Description: Keep your store in sync across processes
Author: Paul Rosania
Latest version: 2.0.1

# electron-redux

[![package version](https://img.shields.io/badge/@paulrosania%2felectron--redux-v2.0.0-afbdf7.svg)](https://npmjs.com/package/@paulrosania/electron-redux)
[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)

![electron-redux data flow](https://cloud.githubusercontent.com/assets/307162/20675737/385ce59e-b585-11e6-947e-3867e77c783d.png)

Keeps your state in sync across all of your Electron processes by playing your actions
in all of them.

```javascript
// in the main process
import { syncMain } from '@paulrosania/electron-redux';
const store = createStore(reducer, applyMiddleware(syncMain));
```

```javascript
// in the renderer processes
import { syncRenderer, wrapRendererReducer } from '@paulrosania/electron-redux';
const store = createStore(wrapRendererReducer(reducer), applyMiddleware(syncRenderer));
```

That's it! Just add each middleware to where you initialize your store, and wrap
the renderer reducer so it can receive state from the main process. As long as
your reducers are pure/deterministic (which they already should be) your state
should be reproduced accurately across all of the processes.

## Actions

Actions **MUST** be [FSA](https://github.com/acdlite/flux-standard-action#example)-compliant,
i.e. have a `type` and `payload` property. Any actions not passing this test will
be ignored and simply passed through to the next middleware.

> NB: `redux-thunk` is not FSA-compliant out of the box, but can still produce compatible actions once the async action fires.

Actions **MUST** be serializable

- Objects with enumerable properties
- Arrays
- Numbers
- Booleans
- Strings

### Local actions

By default, all actions are played in all processes. If an action should only be
played in the current thread, then you can set the scope meta property to local.

```javascript
const myLocalActionCreator = () => ({
  type: 'MY_ACTION',
  payload: 123,
  meta: {
    scope: 'local', // only play the action locally
  },
});
```

We also provide a utility function for this

```
import { stopForwarding } from "@paulrosania/electron-redux";
dispatch(stopForwarding(action));
```

## Contributors

- [McKayla Washburn](https://github.com/partheseas)
- [Burkhard Reffeling](https://github.com/hardchor)
- [Charlie Hess](https://github.com/CharlieHess)
- [Roman Paradeev](https://github.com/sameoldmadness)
npm package: @paulshestakov/linaria-swc
Description: An SWC-plugin to support [Linaria](https://linaria.dev/) v3.
Latest version: 1.0.0

# Linaria SWC

An SWC-plugin to support [Linaria](https://linaria.dev/) v3.

I've suspended work on this plugin, because it seems SWC might run Babel plugins soon: https://github.com/swc-project/swc/pull/1465
npm package: @paulshryock/testing-react-components
Description: ## Getting started
Author: Paul Shryock
Latest version: 1.3.3

# Testing React Components

## Getting started

```bash
npm ci
npm start
```

- Slides: http://localhost:8080
  - Navigate slides with left and right arrow keys
- Storybook: http://localhost:6060
- Website using the React component: http://localhost:8080/site

## File structure

```bash
.
├── config  // Configuration files.
├── docs    // Documentation.
├── src     // Source code.
├── stories // Storybook stories.
└── tests   // Tests.
```

## Running tests

```bash
npm test

 PASS  tests/app.test.js
 PASS  tests/components/Button.test.js
 PASS  tests/lib/sum.test.js
----------------|---------|----------|---------|---------|-------------------
File            | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
----------------|---------|----------|---------|---------|-------------------
All files       |   94.73 |      100 |      75 |   94.44 |
 js             |   91.66 |      100 |      50 |   91.66 |
  app.js        |      90 |      100 |      50 |      90 | 8
  components.js |     100 |      100 |     100 |     100 |
  lib.js        |     100 |      100 |     100 |     100 |
 js/components  |     100 |      100 |     100 |     100 |
  Button.js     |     100 |      100 |     100 |     100 |
 js/lib         |     100 |      100 |     100 |     100 |
  sum.js        |     100 |      100 |     100 |     100 |
----------------|---------|----------|---------|---------|-------------------

Test Suites: 3 passed, 3 total
Tests:       9 passed, 9 total
Snapshots:   0 total
Time:        1.363 s
Ran all test suites.
```
npm package: @paulsmith/cronmatch
Description: A simple cron expression parser. Compares a given date to a cron expression to see if it matches. BYOT(imer).
Author: Paul Smith
Latest version: 1.1.3

# cronmatch

![npm (scoped)](https://img.shields.io/npm/v/%40paulsmith/cronmatch)
![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/blinkylights23/cronmatch/node.js.yml)
![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/npm/%40paulsmith%2Fcronmatch)
![npms.io (maintenance)](https://img.shields.io/npms-io/maintenance-score/%40paulsmith/cronmatch)
![npms.io (maintenance)](https://img.shields.io/npms-io/quality-score/%40paulsmith/cronmatch)


`Cronmatch` is a simple cron expression parser. It compares a provided date string or `Date` object with a cron expression to see if it matches.

## Installation

For use in Node:
```
npm install @paulsmith/cronmatch
```

For use in the browser:
```
<script src="https://unpkg.com/@paulsmith/cronmatch/dist/cronmatch.js"></script>
```

## Usage

```

const cronmatch = require('cronmatch');

var cronExpr = '*/2 * * * *'; // Every even minute
var date1 = new Date('January 20, 2020 12:00:00');
var date2 = new Date('January 20, 2020 12:01:00');

cronmatch(cronExpr, date1);   // true
cronmatch(cronExpr, date2);   // false

```

minute: [0, 59]
hour: [0, 23]
day: [1, 31]
month: [1, 12]
dayOfWeek: [0, 6]



## Limitations

* `cronmatch` does not yet understand 6-field cron expressions with seconds
* It does not yet validate cron expressions
* Does not yet support JAN-DEC for month or MON-SUN for dayOfWeek
npm package: @paultaku/angular-schematics
Description: A blank schematics
Author: paultaku
Latest version: 0.0.5-beta

# Getting Started With Schematics

This repository is a basic Schematic implementation that serves as a starting point to create and publish Schematics to NPM.

### Testing

To test locally, install `@angular-devkit/schematics-cli` globally and use the `schematics` command line tool. That tool acts the same as the `generate` command of the Angular CLI, but also has a debug mode.

Check the documentation with
```bash
schematics --help
```

### Unit Testing

`npm run test` will run the unit tests, using Jasmine as a runner and test framework.

### Publishing

To publish, simply do:

```bash
npm run build
npm publish
```

That's it!