@rdfx/parser 0.0.51

package/README.md

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./parse.js";
+export { parsers as default } from "./parsers.js";
+export * from "./parseSync.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./parse.js";
+export { parsers as default } from "./parsers.js";
+export * from "./parseSync.js";
+//# sourceMappingURL=index.js.map

package/dist/parse.d.ts

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

package/dist/parse.js

@@ -0,0 +1,25 @@
+import { streamToArray } from "@rdfx/stream";
+import { Parser as SyncN3Parser } from "n3";
+import { EitherAsync } from "purify-ts";
+import { Readable } from "readable-stream";
+import parsers from "./index.js";
+export async function parse(input, { dataFactory, format, prefixCallback, ...otherOptions }) {
+    return EitherAsync(async ({ liftEither }) => {
+        if (format) {
+            const stream = parsers({ ...otherOptions, dataFactory }).import(format, Readable.from([input]));
+            if (stream === null) {
+                throw new RangeError(`unsupported format: ${format}`);
+            }
+            return await liftEither(await streamToArray(stream));
+        }
+        else {
+            const n3Parser = new SyncN3Parser({
+                ...otherOptions,
+                factory: dataFactory,
+                format,
+            });
+            return n3Parser.parse(input, undefined, prefixCallback);
+        }
+    });
+}
+//# sourceMappingURL=parse.js.map

package/dist/parseSync copy.d.ts

@@ -0,0 +1,9 @@
+import type { DataFactory, Quad } from "@rdfjs/types";
+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?: "application/n-quads" | "application/n-triples" | "application/trig" | "text/n3" | "text/turtle";
+    prefixCallback?: PrefixCallback;
+} & Omit<N3ParserOptions, "factory" | "format">): Either<Error, readonly Quad[]>;
+//# sourceMappingURL=parseSync%20copy.d.ts.map

package/dist/parseSync copy.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%20copy.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/parsers.d.ts

@@ -0,0 +1,8 @@
+import { type ParserOptions as JsonLdParserOptions } from "@rdfjs/parser-jsonld";
+import { type ParserOptions as N3ParserOptions } from "@rdfjs/parser-n3";
+import SinkMap from "@rdfjs/sink-map";
+import type { DataFactory } from "@rdfjs/types";
+export declare function parsers({ dataFactory, ...otherOptions }: {
+    dataFactory: DataFactory;
+} & Omit<JsonLdParserOptions & N3ParserOptions, "factory">): SinkMap<import("events")<[never]>, import("@rdfjs/types").Stream<import("@rdfjs/types").Quad>>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/parsers.js

@@ -0,0 +1,16 @@
+import JsonLdParser from "@rdfjs/parser-jsonld";
+import N3Parser from "@rdfjs/parser-n3";
+import SinkMap from "@rdfjs/sink-map";
+export function parsers({ dataFactory, ...otherOptions }) {
+    const options = { ...otherOptions, factory: dataFactory };
+    const n3Parser = new N3Parser(options);
+    return new SinkMap([
+        ["application/ld+json", new JsonLdParser(options)],
+        ["application/trig", n3Parser],
+        ["application/n-quads", n3Parser],
+        ["application/n-triples", n3Parser],
+        ["text/n3", n3Parser],
+        ["text/turtle", n3Parser],
+    ]);
+}
+//# sourceMappingURL=parsers.js.map

package/dist/testData.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=testData.d.ts.map

package/dist/testData.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=testData.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "dependencies": {
+    "@rdfx/format": "0.0.51",
+    "@rdfx/stream": "0.0.51",
+    "@rdfjs/parser-jsonld": "~2.1.3",
+    "@rdfjs/parser-n3": "~2.1.0",
+    "@rdfjs/sink-map": "~2.0.1",
+    "@rdfjs/types": "~2.0.1",
+    "@types/rdfjs__parser-jsonld": "~2.1.7",
+    "@types/rdfjs__parser-n3": "~2.0.6",
+    "purify-ts": "~2.1.4"
+  },
+  "devDependencies": {},
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/parser",
+  "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/parser/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.51"
+}