# @rdf-esm/sink-map

> Map for RDFJS Sinks including shortcut methods

Latest version **0.5.5** (published 2021-11-29) · MIT license · 0 weekly downloads

## Install

```sh
npm install @rdf-esm/sink-map
pnpm add @rdf-esm/sink-map
yarn add @rdf-esm/sink-map
bun add @rdf-esm/sink-map
```

## Health

**Score 20/100 (F)** — status: abandoned.

Positive: esm support; no vulnerabilities.

Warnings: low downloads; no types; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.5.5 |
| Published | 2021-11-29 |
| First published | 2020-05-17 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | ESM + CommonJS |
| Node | >=12 |
| Dependencies | 1 |
| Unpacked size | 8.9 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 2 |
| Author | Thomas Bergwinkl |
| Maintainers | tpluscode |
| Keywords | map, rdf, rdfjs, sink |

## Links

- npm: https://www.npmjs.com/package/@rdf-esm/sink-map
- Repository: https://github.com/rdf-esm/sink-map
- Issues: https://github.com/rdf-esm/sink-map/issues
- npm.io page: https://npm.io/package/@rdf-esm/sink-map

## Dependencies (1)

- [readable-stream](https://npm.io/package/readable-stream.md) ^3.6.0

## Recent versions

- 0.5.5 (latest) — 2021-11-29
- 0.5.4 — 2020-10-09
- 0.5.3 — 2020-10-09
- 0.5.2 — 2020-06-16
- 0.5.1 — 2020-06-12
- 0.5.0 — 2020-05-17

## README

# @rdf-esm/sink-map

![](https://github.com/rdf-esm/sink-map/workflows/Test/badge.svg)

[![npm version](https://img.shields.io/npm/v/@rdf-esm/sink-map.svg)](https://www.npmjs.com/package/@rdf-esm/sink-map)

Map for [RDFJS Sinks](http://rdf.js.org/#sink-interface) including shortcut methods.

## Fork alert :exclamation:

This package is an ES Modules fork of [@rdfjs/sink-map](https://npm.im/@rdfjs/sink-map)

It also adds the ability to register lazy sinks, which are created on first request. For example to have the respecitve modules imported dynamically. Check the example below.

## Usage

The package provides Map from a string key to a Sink with a shortcut for `.import`.
Typical it's used to store parsers or serializers for specific media types.
As SinkMap extends from the [ECMAScript 2015 Map](https://www.ecma-international.org/ecma-262/6.0/#sec-map-objects) and doesn't overload any standard methods, methods like `set`, `get`, `has` or `delete` can be used as defined in the specification.

### Create a SinkMap
The constructor accepts arrays with key/sink pairs to fill the map:

```javascript
const map = new SinkMap([
  ['text/turtle', new ParserN3()]
])
```

It's also possible to create an empty map and add or extend it later using the `.set()` method:

```javascript
const map = new SinkMap()

map.set('text/turtle') = new ParserN3()
```

### Add a lazy-loaded sink

Sinks can also be added as an async function, for example to dynamically import the module.

Here's an example from [@rdf-esm/formats-common](https://github.com/rdf-esm/formats-common/blob/master/parsers.js):

```javascript
const map = new SinkMap()

map.set('text/turtle', async () => {
  const ParserN3 = (await import('@rdfjs/parser-n3')).default
  return new ParserN3()
})
```

### Find a Sink

The `.get` method searches for the matching Sink and returns it:

```javascript
const map = new SinkMap([...])

const sink = map.get('text/turtle')

if (sink) {
  // found
} else {
  // not found
}
```

### Import shortcut

Usually you want to call the `.import` method of the matching Sink.
The map provides a shortcut for this.
It also has a `.import` method, but requires additionally the key as the first argument.
It returns `null` if no matching sink was found:

```javascript
const map = new SinkMap([...])

const input = fs.createReadStream('..')
const output = map.import('text/turtle', input)

if (output) {
  // found
} else {
  // not found
}
```

### Example

Here is a complete example where the map is used to store parsers and the `.import` shortcut is used to parse a string input:

```javascript
import { SinkMap } from '@rdfjs/sink-map'
import ParserN3 from '@rdfjs/parser-n3'
import stream from 'stream'

const map = new SinkMap([
  ['text/turtle', new ParserN3()]
])

const input = new stream.Readable({
  read: () => {
    input.push(`
      PREFIX s: <http://schema.org/>

      [] a s:Person ;
        s:jobTitle "Professor" ;
        s:name "Jane Doe" ;
        s:telephone "(425) 123-4567" ;
        s:url <http://www.janedoe.com> .
    `)
    input.push(null)
  }
})

const output = map.import('text/turtle', input)

output.on('data', quad => {
  console.log(`${quad.subject.value} - ${quad.predicate.value} - ${quad.object.value}`)
})
```

---
_Source: https://npm.io/package/@rdf-esm/sink-map · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._