open-index/open-npm huggingface dataset:
npm package: @mgalbis/remark-prefix-links
Description: Prefix relative paths with a prefix URL.
Author: Maria Galbis
Latest version: 1.0.2


[![Build][build-badge]][build]
[![Coverage][coverage-badge]][coverage]


# remark-prefix-links

[**remark**](https://github.com/remarkjs/remark) plugin to prefix relative paths with a prefix.

## Installation

```
npm install @mgalbis/remark-prefix-links
```

## Usage

Say we have the following file `example.md`:

```markdown
[I'm an inline-style link](https://www.example.com)
[I'm an inline-style link with title](example.com "Example's Homepage")
[I'm a reference-style link][Arbitrary case-insensitive reference text]
![I'm a relative reference to an image](static/image.png)
[You can use numbers for reference-style link definitions][1]
Or leave it empty and use the [link text itself].

[arbitrary case-insensitive reference text]: static/link
[1]: static/link
[link text itself]: static/link
```

And our module `example.js` looks as follows:

```js
const fs = require('fs')
const html = require("remark-html")
const remark = require("remark")
const plugin = require("@mgalbis/remark-prefix-links")
remark()
    .use(plugin, { pathPrefix: "test" })
    .use(html)
    .process(fs.readFileSync('example.md'), (err, file) => {
        if (err) throw err
        console.log(String(file))
    })
```

Now running `node example.js` yields:

```html
<p>
  <a href="https://www.example.com">I'm an inline-style link</a>
  <a href="test/example.com" title="Example&#x27;s Homepage">I'm an inline-style link with title</a>
  <a href="test/static/link">I'm a reference-style link</a>
  <img src="test/static/image.png" alt="I'm a relative reference to an image">
  <a href="test/static/link">You can use numbers for reference-style link definitions</a>
  Or leave it empty and use the <a href="test/static/link">link text itself</a>.
</p>
```

## API
### `remark.use(plugin[, options])`
* `options.pathPrefix` (**required**) - the path prefix that will be prepended to the begging of links.


## Contributions
If you are interested in contributing to this project, please open an issue with a description of what you would like to add.

## License
[MIT](LICENSE) © [Maria Galbis](https://github.com/mgalbis)



[build-badge]: https://github.com/mgalbis/remark-prefix-links/workflows/main/badge.svg
[build]: https://github.com/mgalbis/remark-prefix-links/actions
[coverage-badge]: https://img.shields.io/codecov/c/github/mgalbis/remark-prefix-links.svg
[coverage]: https://codecov.io/github/mgalbis/remark-prefix-links
npm package: @mgalihpp/vexis-win32-x64
Description: Windows x64 CLI distribution for Vexis Trading Agents
Latest version: 0.6.2
Deprecated: Renamed to vexis-trading-agents. Please install vexis-trading-agents@latest

# vexis-win32-x64

Windows x64 npm package for the `vexis` CLI.

## Requirements

- Windows (win32)
- x64 CPU
- Node.js >= 20

## Usage

```bash
npx @mgalihpp/vexis-win32-x64@latest
```

or

```bash
npm i -g @mgalihpp/vexis-win32-x64@latest
```

after install run:

```bash
vexis
```

## Notes

- This package is Windows-only.
- Runtime config is loaded from `~/.vexis/config.yaml`.
npm package: @mgalos999/d2-mapper
Description: Generates images of Diablo 2 map data
Author: mgalos999
Latest version: 0.7.0

# d2-mapper

Diablo 2 maps are randomly generated based on a seed value and difficulty.  
There is another project which uses Diablo 2 to generate JSON payloads describing the layout of these maps.
This repo takes that data and creates PNGs and HTML pages showing maps visually.

Refer to this project for more info <https://github.com/blacha/diablo2/tree/master/packages/map>

This repo uses the above project as a backend server to generate data based on a given seed/difficulty.
If you don't have that project setup to fetch JSON data, this repo comes with a few sample payloads you can try.

At the moment this project is setup to take one sample output `src/public/data/26396577_Hell.json` and generate images from it.

## Examples

##### Durance of hate level 2

![Durance of hate level 2](duranceofhate.png)

##### Arcane Sanctuary

![Arcane Sancutuary](arcanesanctuary.png)

## Setup backend

This repo does not include the backend server.
Please refer to <https://github.com/blacha/diablo2/tree/master/packages/map>

However to get the above project working:

* Install Diablo 2 LOD 1.14b
* Install Project Diablo 2
* Install docker

```bash
docker pull blacha/diablo2
docker run -it -v "/E/Games/Diablo II":/app/game docker.io/blacha/diablo2:latest /bin/bash
wine regedit /app/d2.install.reg
wine bin/d2-map.exe game --seed 10 --level 1 --difficulty 0
```

The last wine command tests that it's working

This command will run a REST API server on port 8899:

```bash
docker run -v "/E/Games/Diablo II":/app/game -p 8899:8899 docker.io/blacha/diablo2:latest
```

### Install

```bash
npm install
npm build
```

### Execute example

```bash
npm run generate
```

```bash
npm run generate <seed> <difficulty>
npm run generate 26396577 2
```


This will generate HTML for every level in `./public/<seed>/<difficulty>` folder.
You can open these HTML pages in any browser.

`npm run generate` has a default seed value, but you can pass a seed value `npm run generate <seed>`

This repo has an already cached response for 26396577/Hell and 1294978398/Hell so you can run this without a backed for those 2 settings.

### Usage

This is published as a package that can be used to generate images from raw JSON.
It also has an API server, which is really used for demo purposes.

#### REST API

`npm run serve` will run an API server, where you could fetch images this way:

```typescript
imageUrl = `http://localhost:3001/v1/map/${seedDecimal}/${selectedDifficulty}/${mapId}/image`;
```

### Notes

* Purple box for exits
* Red dot for monsters
* Yellow box for waypoint.

## TODO

* Getting an isometric perspective to work is tricky to get right, it's a flat top down perspective for now
* Special icons/markings for exits and special items to be improved (bosses, special chests etc)
npm package: @mgansler/cypress-graphql
Description: Simplify intercepting GraphQL calls with cypress.
Author: Martin Gansler
Latest version: 0.0.3

# Cypress GraphQL

This library aims to simplify interception GraphQL calls with Cypress.

## Examples

A simple fetch:

```typescript jsx
cy.graphql('fixture.json').as('fetch')

// make the call
cy.findByRole('button', { name: 'Fetch it!' }).click()

cy.wait('@fetch')
```

Filter for some text in the GraphlQL query:

```typescript jsx
cy.graphql('user-info.json', { filter: 'User' }).as('fetch-user')
cy.graphql('something.json', { filter: 'Something' }).as('fetch-something')

// make the calls
cy.findByRole('button', { name: 'Load user info!' }).click()
cy.wait('@fetch-user')

cy.findByRole('button', { name: 'Load something' }).click()
cy.wait('@fetch-something')
```

Intercept mutations:

```typescript jsx
cy.graphql('mutation-response.json', { operationType: 'mutation' }).as('mutation')

// make the call
cy.findByRole('button', { name: 'Update data' }).click()

cy.wait('@mutation')
```
npm package: @mgansler/nx-compose
Description: Often times you need to run multiple targets at the same time. This plugin helps with that. The difference to `dependsOn` is that `compose` can handle long-running tasks.
Author: Martin Gansler
Latest version: 0.0.1

# Nx plugin to compose targets

Often times you need to run multiple targets at the same time. This plugin helps with that. The difference
to `dependsOn` is that `compose` can handle long-running tasks.

## Example

```json
{
  "compose": {
    "executor": "@mgansler/nx-compose:compose",
    "options": {
      "targets": [
        "app-backend:serve",
        "app-web:serve"
      ]
    },
    "configurations": {
      "production": {}
    }
  }
}
```
npm package: @mgansler/nx-cypress-ct
Description: Nx Plugin for Cypress component tests
Author: Martin Gansler
Latest version: 0.0.2

# Cypress Component Testing configuration

[Cypress Component Testing](https://docs.cypress.io/guides/component-testing/introduction) is awesome!
And with Nx it is so easy to get started. All you need is a tiny bit of configuration, and you are ready to go.

Just run `nx generate @mgansler/nx-cypress-ct:config <project>` and you can create your first component test:

```typescript jsx
import { mount } from '@cypress/react'

describe('Your Component', () => {
  it('should have a heading', () => {
    mount(<h1>Hello World!</h1>)

    cy.findByRole('heading').should('contain.text', 'Hello World!')
  })
})
```

It works just like the regular Cypress target, the default configuration is great for CI while with the watch mode you
can actually see how your component looks and behaves in a browser.
npm package: @mgansler/nx-prisma
Description: Nx Plugin for Prisma
Author: Martin Gansler
Latest version: 0.0.2

# Nx Plugin for prisma

This plugin helps with the usage of [Prisma](https://www.prisma.io) in a Nx workspace.

## How to use

Put this into `targets` of your `project.json`.

```json
{
  "format": {
    "executor": "@mgansler/nx-prisma:format"
  },
  "generate": {
    "executor": "@mgansler/nx-prisma:generate"
  }
}
```

Your schema should be located at `<sourceRoot>/libs/schema.prisma`

Running `nx run <projectName>:generate` will generate the Prisma client under `libs/client`. This directory can be added
to your `.gitignore`.

You may want a `src/index.ts` with the following content:

```typescript
export * from './lib/client/index'
```

Also, don't forget to add `"src/lib/client/**"` to the `ignorePatterns` of your `.eslintrc.json`.

## Options

`schema`: Path to `schema.prisma` relative to the `sourceRoot` of the application/library. Default
is `libs/schema.prisma`
npm package: @mgansler/nx-remix
Description: Remix Plugin for Nx
Author: Martin Gansler
Latest version: 0.7.0

# Nx plugin for Remix

## Generators

### Application

`nx generate @mgansler/nx-remix:application <app-name> [--express]`

#### Options

- `--express` (optional): Prepare the build artifact to be served via express

## Executors

### build

`nx build <app-name>`

#### Options

| Name    | Default | Options                              | Description                                                 |
| ------- | ------- | ------------------------------------ | ----------------------------------------------------------- |
| express | `false` | `true` or name of custom `server.js` | Should prepare the build artifact to be served via express. |

### serve

`nx serve <app-name>`