open-index/open-npm huggingface dataset:
npm package: @lindas/env-node
Description: RDF/JS Environment for Node.js
Author: Zazuko GmbH
Latest version: 3.0.3

# [RDF/JS Environment](https://github.com/rdfjs-base/environment) with NodeJs support

This package extends [@zazuko/env](https://npm.im/@zazuko/env) by adding support for NodeJs.

It includes [`@zazuko/rdf-utils-fs`](@zazuko/rdf-utils-fs) and [`@rdfjs/fetch-lite`](https://npm.im/@rdfjs/fetch-lite)
and bundles the default set of parsers and serializers.

## Using different serializers

It is possible to switch the formats by importing them from a different package. For example,
using the pretty-printing package.

```js
import rdf from '@zazuko/env-node'
import formats from '@rdfjs-elements/formats-pretty'

rdf.formats.import(formats)
```
npm package: @lindas/rdf-parser-csvw
Description: CSVW Parser
Author: Zazuko GmbH
Latest version: 0.17.1

# rdf-parser-csvw

A CSV on the Web parser with [RDFJS Stream interface](https://github.com/rdfjs/representation-task-force/).

⛓️‍💥 Fork of rdf-ext/rdf-parser-csvw converted to ESM, including some tweaks and fixes
    
## Usage

The package exports the parser as a class, so an instance must be created before it can be used.
The `.import` method, as defined in the [RDFJS specification](http://rdf.js.org/#sink-interface), must be called to do the actual parsing.
It expects a stream of strings.
The method will return a stream which emits the parsed quads.

The constructor accepts an `options` object with the following optional keys:

- `metadata`: Use the metadata to convert the CSV to RDF.
  The metadata must be given as a Dataset using the CSV on the Web ontology.
  This options is required.
- `baseIRI`: Use the IRI to create Named Nodes.
  The value must be a String.
  This options is required.
- `factory`: Use an alternative RDFJS data factory.
  By default the [reference implementation](https://github.com/rdfjs/data-model/) us used.
- `timezone`: Use an alternative timezone to parse date and time values.
  The value must be given as a String as defined in the [Luxon documentation](https://moment.github.io/luxon/docs/manual/zones.html#specifying-a-zone).
  By default `local` will be used.
- `relaxColumnCount`: Don't throw an error if a row has a column count which doesn't match the headers column count.
- `skipLinesWithError`: Skip lines with error instead of throwing an error and stop parsing.
  This is mainly useful for debugging and should not be used in production environments.
- `skipEmptyLines`: Ignore empty lines in the CSV file.
- `trimHeaders`: Remove whitespace from the beginning and end of the column names.

It's also possible to pass options as second argument to the `.import` method.
The options from the constructor and the `.import` method will be merged together.

## Compliance with the CSVW specification

### Dates and times

- Date/Time formats are generally supported with possible issues around the timezone specifier `X` and the exact formatting of the timezone offset.
- [RFC2822 dates](https://datatracker.ietf.org/doc/html/rfc2822#page-14) are supported via explict 'RFC2822' datatype format (case insensitive).
- Time formats are implemented but the output will always be normalised to UTC.
npm package: @lindas/rdf-parser-csvw-xlsx
Description: A CSV on the Web based XLSX parser with RDF/JS Stream interface
Author: Zazuko GmbH
Latest version: 1.0.1

# rdf-parser-csvw-xlsx

A CSV on the Web based XLSX (Excel file format) parser with [RDF/JS Stream interface](https://github.com/rdfjs/representation-task-force/).

⛓️‍💥 Fork of rdf-ext/rdf-parser-csvw converted to ESM, including some tweaks and fixes

Consult the [@zazuko/rdf-parser-csvw](https://github.com/zazuko/rdf-parser-csvw) documentation about usage, which provides the technical foundation of this parser.

Note that this parser is much slower and needs more memory than the pure CSV based parser. If you need peformance, convert the data to CSV first and use the [@zazuko/rdf-parser-csvw](https://github.com/zazuko/rdf-parser-csvw) parser.
npm package: @lindas/rdf-utils-fs
Description: RDF Filesystem Utilities
Author: Thomas Bergwinkl
Latest version: 3.3.2

# @zazuko/rdf-utils-fs

![Build Status](https://github.com/zazuko/rdf-utils-fs/actions/workflows/ci.yaml/badge.svg?branch=master)
[![npm version](https://badge.fury.io/js/@zazuko%2Frdf-utils-fs.svg)](https://badge.fury.io/js/@zazuko%2Frdf-utils-fs)

File system utils for RDF/JS.

## Usage with `@zazuko/env-node` (preferred)

[@zazuko/env-node](https://npm.im/@zazuko/env-node) package extends [@zazuko/env](https://npm.im/@zazuko/env) by including
the fs utils and default parsers/serializers for simplest possible usage in node environment.

```js
import rdf from '@zazuko/env-node'
        
// parse
const dataset = await env.dataset().import(env.fromFile(`/path/to/data.nt`))

// serialise
await env.toFile(dataset, `/path/to/data.json`)
```

## Extend `@zazuko/env` yourself

```js
import Environment from '@zazuko/env/Environment.js'
import baseEnv from '@zazuko/env`
import { FsUtilsFactory } from '@zazuko/rdf-utils-fs'
import fromStream from 'rdf-dataset-ext/fromStream.js'
import formats from '@rdfjs/formats'

// create an environment by adding FsUtilsFactory
const env = new Environment([FsUtilsFactory], { parent: baseEnv })
// add parsers+serializers
env.formats.import(formats)

// parse
const dataset = await env.dataset().import(env.fromFile(`/path/to/data.nt`))

// serialise
await env.toFile(dataset.toStream(), `/path/to/data.json`)
```

## Usage with an existing environment

Same as above, but the RDF/JS Environment is provided as first argument. 
That environment must implement RDF/JS DataFactory, [FormatsFactory](https://github.com/rdfjs-base/formats/tree/master/Factory.js).

```js
import rdf from 'rdf-ext'
import { fromFile, toFile } from 'rdf-utils-fs'
import formats from '@rdfjs/formats'

// add parsers+serializers
rdf.formats.import(formats)

// parse
const parserStream = fromFile(rdf, `/path/to/data.nt`)
const dataset = await rdf.dataset().import(parserStream)

// serialise
await env.toFile(rdf, dataset, `/path/to/data.json`)
```
    
## Functions

### fromFile(filename, options)

Returns a quad stream for the given `filename`.

By default, the file is parsed without a base IRI. If you want to use the file's IRI as base, pass `{ implicitBaseIRI: true }` as options.

### async toFile(stream, filename, options)

Writes the given quad stream to `filename`.