@rdfx/serializer 0.0.51

package/README.md

@@ -0,0 +1,5 @@
+# @rdfx/serializer
+
+Bundles serializers for common RDF formats alongside convenience functions.
+
+Adapted from [@rdfjs/formats](https://github.com/rdfjs-base/formats) (MIT license).

package/dist/N3Serializer.d.ts

@@ -0,0 +1,15 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { Sink, Stream } from "@rdfjs/types";
+import { type MimeFormat } from "n3";
+export type SerializerOptions = {
+    prefixes?: PrefixMap;
+    end?: boolean;
+};
+export default class N3Serializer implements Sink<Stream, Stream> {
+    private readonly options;
+    constructor(options: SerializerOptions & {
+        format: MimeFormat;
+    });
+    import(input: Stream, options?: SerializerOptions): Stream;
+}
+//# sourceMappingURL=N3Serializer.d.ts.map

package/dist/N3Serializer.js

@@ -0,0 +1,24 @@
+import { StreamWriter } from "n3";
+export default class N3Serializer {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    import(input, options) {
+        options = { ...this.options, ...options };
+        const { prefixes: prefixMap, ...otherOptions } = options;
+        let prefixes;
+        if (prefixMap) {
+            // N3 expects a Record<string, NamedNode> and PrefixMap is a Map<string, NamedNode>
+            prefixes = {};
+            for (const entry of prefixMap.entries()) {
+                prefixes[entry[0]] = entry[1];
+            }
+        }
+        const writer = new StreamWriter({ ...otherOptions, prefixes });
+        input.on("error", (err) => writer.emit("error", err));
+        input.pipe(writer);
+        return writer;
+    }
+}
+//# sourceMappingURL=N3Serializer.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { serializers as default } from "./serializers.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { serializers as default } from "./serializers.js";
+//# sourceMappingURL=index.js.map

package/dist/parseSync.d.ts

@@ -0,0 +1,10 @@
+import type { DataFactory, Quad } from "@rdfjs/types";
+import type { UncompressedRdfFormat } from "@rdfx/format";
+import { type ParserOptions as N3ParserOptions, type PrefixCallback } from "n3";
+import { Either } from "purify-ts";
+export declare function parseSync(input: string, { dataFactory, prefixCallback, ...otherOptions }: {
+    dataFactory: DataFactory;
+    format?: Exclude<UncompressedRdfFormat["mimeType"], "application/ld+json">;
+    prefixCallback?: PrefixCallback;
+} & Omit<N3ParserOptions, "factory" | "format">): Either<Error, readonly Quad[]>;
+//# sourceMappingURL=parseSync.d.ts.map

package/dist/parseSync.js

@@ -0,0 +1,9 @@
+import { Parser as N3Parser, } from "n3";
+import { Either } from "purify-ts";
+export function parseSync(input, { dataFactory, prefixCallback, ...otherOptions }) {
+    return Either.encase(() => {
+        const n3Parser = new N3Parser({ ...otherOptions, factory: dataFactory });
+        return n3Parser.parse(input, undefined, prefixCallback);
+    });
+}
+//# sourceMappingURL=parseSync.js.map

package/dist/serialize.d.ts

@@ -0,0 +1,25 @@
+import type { SerializerOptions as JsonLdSerializerOptions } from "@rdfjs/serializer-jsonld-ext";
+import type { SerializerOptions as RdfjsSerializerOptions } from "@rdfjs/serializer-rdfjs";
+import type { SerializerOptions as TurtleSerializerOptions } from "@rdfjs/serializer-turtle";
+import type { Quad } from "@rdfjs/types";
+import type { SerializerOptions as N3SerializerOptions } from "./N3Serializer.js";
+type SerializeOptions = ({
+    format: "application/ld+json";
+} & JsonLdSerializerOptions) | {
+    format: "";
+} | {
+    format: "application/n-quads";
+} | {
+    format: "application/n-triples";
+} | ({
+    format: "application/trig";
+} & N3SerializerOptions) | ({
+    format: "text/javascript";
+} & RdfjsSerializerOptions) | ({
+    format: "text/n3";
+} & N3SerializerOptions) | ({
+    format: "text/turtle";
+} & TurtleSerializerOptions);
+export declare function serialize(input: Iterable<Quad>, options: SerializeOptions): Promise<import("purify-ts").Either<unknown, string>>;
+export {};
+//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.js

@@ -0,0 +1,35 @@
+import { iterableToStream, streamToString } from "@rdfx/stream";
+import { EitherAsync } from "purify-ts";
+import { serializers as serializersFactory } from "./serializers.js";
+export async function serialize(input, options) {
+    return EitherAsync(async ({ liftEither }) => {
+        const serializersOptions = {};
+        switch (options.format) {
+            case "application/ld+json":
+                serializersOptions.jsonLd = options;
+                break;
+            case "application/n-quads":
+            case "application/n-triples":
+                break;
+            case "application/trig":
+                serializersOptions.trig = options;
+                break;
+            case "text/javascript":
+                serializersOptions.rdfjs = options;
+                break;
+            case "text/n3":
+                serializersOptions.n3 = options;
+                break;
+            case "text/turtle":
+                serializersOptions.turtle = options;
+                break;
+        }
+        const serializers = serializersFactory(serializersOptions);
+        const stream = serializers.import(options.format, iterableToStream(input));
+        if (stream === null) {
+            throw new RangeError(`unsupported format: ${options.format}`);
+        }
+        return await liftEither(await streamToString(stream));
+    });
+}
+//# sourceMappingURL=serialize.js.map

package/dist/serializeSync.d.ts

@@ -0,0 +1,7 @@
+import type { Quad } from "@rdfjs/types";
+import type { UncompressedRdfFormat } from "@rdfx/format";
+import { Either } from "purify-ts";
+export declare function serializeSync(input: Iterable<Quad>, options: {
+    format: Extract<UncompressedRdfFormat["mimeType"], "application/n-quads" | "application/n-triples">;
+}): Either<Error, string>;
+//# sourceMappingURL=serializeSync.d.ts.map

package/dist/serializeSync.js

@@ -0,0 +1,13 @@
+import { Writer as N3Writer } from "n3";
+import { Either } from "purify-ts";
+export function serializeSync(input, options) {
+    return Either.encase(() => {
+        const ntriples = [];
+        const n3Writer = new N3Writer(options);
+        for (const quad of input) {
+            ntriples.push(n3Writer.quadToString(quad.subject, quad.predicate, quad.object, quad.graph));
+        }
+        return ntriples.join("\n");
+    });
+}
+//# sourceMappingURL=serializeSync.js.map

package/dist/serializers.d.ts

@@ -0,0 +1,16 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import { type SerializerOptions as JsonLdSerializerOptions } from "@rdfjs/serializer-jsonld-ext";
+import { type SerializerOptions as RdfjsSerializerOptions } from "@rdfjs/serializer-rdfjs";
+import { type SerializerOptions as TurtleSerializerOptions } from "@rdfjs/serializer-turtle";
+import SinkMap from "@rdfjs/sink-map";
+import { type SerializerOptions as N3SerializerOptions } from "./N3Serializer.js";
+export declare function serializers(options?: {
+    baseIRI?: string;
+    prefixes?: PrefixMap;
+    jsonLd?: JsonLdSerializerOptions;
+    n3?: N3SerializerOptions;
+    rdfjs?: RdfjsSerializerOptions;
+    trig?: N3SerializerOptions;
+    turtle?: TurtleSerializerOptions;
+}): SinkMap<import("@rdfjs/types").Stream<import("@rdfjs/types").Quad>, import("events")<[never]>>;
+//# sourceMappingURL=serializers.d.ts.map

package/dist/serializers.js

@@ -0,0 +1,42 @@
+import JsonLdSerializer from "@rdfjs/serializer-jsonld-ext";
+import NTriplesSerializer from "@rdfjs/serializer-ntriples";
+import RdfjsSerializer from "@rdfjs/serializer-rdfjs";
+import TurtleSerializer from "@rdfjs/serializer-turtle";
+import SinkMap from "@rdfjs/sink-map";
+import N3Serializer from "./N3Serializer.js";
+export function serializers(options) {
+    const commonSerializerOptions = {
+        baseIRI: options?.baseIRI,
+        prefixes: options?.prefixes,
+    };
+    return new SinkMap([
+        [
+            "application/ld+json",
+            new JsonLdSerializer({ ...commonSerializerOptions, ...options?.jsonLd }),
+        ],
+        ["application/n-quads", new NTriplesSerializer()],
+        ["application/n-triples", new NTriplesSerializer()],
+        [
+            "application/trig",
+            new N3Serializer({
+                ...commonSerializerOptions,
+                ...options?.trig,
+                format: "application/trig",
+            }),
+        ],
+        ["text/javascript", new RdfjsSerializer(options?.rdfjs)],
+        [
+            "text/n3",
+            new N3Serializer({
+                ...commonSerializerOptions,
+                ...options?.n3,
+                format: "text/n3",
+            }),
+        ],
+        [
+            "text/turtle",
+            new TurtleSerializer({ ...commonSerializerOptions, ...options?.turtle }),
+        ],
+    ]);
+}
+//# sourceMappingURL=serializers.js.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "dependencies": {
+    "@rdfx/format": "0.0.51",
+    "@rdfx/stream": "0.0.51",
+    "@rdfjs/prefix-map": "~0.1.2",
+    "@rdfjs/serializer-jsonld-ext": "~4.0.2",
+    "@rdfjs/serializer-ntriples": "~2.0.1",
+    "@rdfjs/serializer-rdfjs": "0.1.3",
+    "@rdfjs/serializer-turtle": "~1.1.5",
+    "@rdfjs/sink-map": "~2.0.1",
+    "@rdfjs/types": "~2.0.1",
+    "@types/n3": "~1.26.0",
+    "@types/rdfjs__prefix-map": "~0.1.5",
+    "@types/rdfjs__serializer-jsonld-ext": "~4.0.1",
+    "@types/rdfjs__serializer-ntriples": "~2.0.6",
+    "@types/rdfjs__serializer-rdfjs": "0.1.6",
+    "@types/rdfjs__serializer-turtle": "~1.1.0",
+    "@types/rdfjs__sink-map": "~2.0.5",
+    "@types/readable-stream": "~4.0.23",
+    "n3": "~1.26.0",
+    "purify-ts": "~2.1.4",
+    "readable-stream": "^4.7.0"
+  },
+  "devDependencies": {},
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/serializer",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck --ignores=\"@tsconfig/*,vitest,vitest-fetch-mock\" .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run packages/serializer/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.51"
+}