@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/TriG-xDjdDatp.d.mts

@@ -0,0 +1,86 @@
+import { _ as Quad } from "./Term-B_4ezyXq.mjs";
+import { c as Parser, i as Format, l as RdfParseError, m as Serializer, o as ParseOptions, r as Codec, s as ParseResult, u as RdfSerializeError } from "./Serialization-Df8iVauT.mjs";
+import { n as QuadsResult$1, t as SerializeOptions$1 } from "./serialize-DsoXdM6n.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+declare namespace TriG_d_exports {
+  export { QuadsResult, SerializeOptions, codec, format, parse, parseQuads, parseStream, parser, serialize, serializeStream, serializer };
+}
+/**
+ * The result of `parseQuads`: statements in document order with the
+ * document's prefixes and final base IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type QuadsResult = QuadsResult$1;
+/**
+ * Options for the TriG serializer.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type SerializeOptions = SerializeOptions$1;
+/**
+ * @since 0.1.0
+ * @category formats
+ */
+declare const format: Format;
+/**
+ * Parses a TriG document, returning the dataset together with the declared
+ * prefixes and the final base IRI.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (input: string, options?: ParseOptions) => Effect.Effect<ParseResult, RdfParseError>;
+/**
+ * Parses a TriG document into statements in document order.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseQuads: (input: string, options?: ParseOptions) => Effect.Effect<QuadsResult, RdfParseError>;
+/**
+ * Parses a stream of text chunks incrementally. Statements are emitted as
+ * soon as they are complete (statements inside graph blocks individually);
+ * chunk boundaries may fall anywhere.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseStream: <E, R>(input: Stream.Stream<string, E, R>, options?: ParseOptions) => Stream.Stream<Quad, RdfParseError | E, R>;
+/**
+ * Serialises quads as pretty TriG. Fails for triple terms in the subject
+ * position (not expressible in TriG 1.2).
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serialize: (quads: Iterable<Quad>, options?: SerializeOptions) => Effect.Effect<string, RdfSerializeError>;
+/**
+ * Serialises a stream of quads incrementally in constant memory. Only
+ * consecutive statements are grouped (a graph block is opened whenever the
+ * graph changes), and blank nodes keep their labels.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializeStream: <E, R>(quads: Stream.Stream<Quad, E, R>, options?: SerializeOptions) => Stream.Stream<string, RdfSerializeError | E, R>;
+/**
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parser: Parser;
+/**
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializer: Serializer<SerializeOptions>;
+/**
+ * @since 0.1.0
+ * @category codecs
+ */
+declare const codec: Codec<ParseOptions, SerializeOptions>;
+export { format as a, parseStream as c, serializeStream as d, serializer as f, codec as i, parser as l, SerializeOptions as n, parse as o, TriG_d_exports as r, parseQuads as s, QuadsResult as t, serialize as u };
+//# sourceMappingURL=TriG-xDjdDatp.d.mts.map

package/dist/Turtle-Bv1_bisW.d.mts

@@ -0,0 +1,85 @@
+import { _ as Quad } from "./Term-B_4ezyXq.mjs";
+import { c as Parser, i as Format, l as RdfParseError, m as Serializer, o as ParseOptions, r as Codec, s as ParseResult, u as RdfSerializeError } from "./Serialization-Df8iVauT.mjs";
+import { n as QuadsResult$1, t as SerializeOptions$1 } from "./serialize-DsoXdM6n.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+declare namespace Turtle_d_exports {
+  export { QuadsResult, SerializeOptions, codec, format, parse, parseQuads, parseStream, parser, serialize, serializeStream, serializer };
+}
+/**
+ * The result of `parseQuads`: statements in document order with the
+ * document's prefixes and final base IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type QuadsResult = QuadsResult$1;
+/**
+ * Options for the Turtle serializer.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type SerializeOptions = SerializeOptions$1;
+/**
+ * @since 0.1.0
+ * @category formats
+ */
+declare const format: Format;
+/**
+ * Parses a Turtle document, returning the dataset together with the
+ * declared prefixes and the final base IRI. Triples are placed in
+ * `options.graph` (the default graph when omitted).
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (input: string, options?: ParseOptions) => Effect.Effect<ParseResult, RdfParseError>;
+/**
+ * Parses a Turtle document into statements in document order.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseQuads: (input: string, options?: ParseOptions) => Effect.Effect<QuadsResult, RdfParseError>;
+/**
+ * Parses a stream of text chunks incrementally. Statements are emitted as
+ * soon as they are complete; chunk boundaries may fall anywhere.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseStream: <E, R>(input: Stream.Stream<string, E, R>, options?: ParseOptions) => Stream.Stream<Quad, RdfParseError | E, R>;
+/**
+ * Serialises triples as pretty Turtle. Fails for quads in named graphs and
+ * for triple terms in the subject position (not expressible in Turtle 1.2).
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serialize: (quads: Iterable<Quad>, options?: SerializeOptions) => Effect.Effect<string, RdfSerializeError>;
+/**
+ * Serialises a stream of triples incrementally in constant memory. Only
+ * consecutive statements are grouped, and blank nodes keep their labels.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializeStream: <E, R>(quads: Stream.Stream<Quad, E, R>, options?: SerializeOptions) => Stream.Stream<string, RdfSerializeError | E, R>;
+/**
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parser: Parser;
+/**
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializer: Serializer<SerializeOptions>;
+/**
+ * @since 0.1.0
+ * @category codecs
+ */
+declare const codec: Codec<ParseOptions, SerializeOptions>;
+export { format as a, parseStream as c, serializeStream as d, serializer as f, codec as i, parser as l, SerializeOptions as n, parse as o, Turtle_d_exports as r, parseQuads as s, QuadsResult as t, serialize as u };
+//# sourceMappingURL=Turtle-Bv1_bisW.d.mts.map

package/dist/Turtle-CZVUOtwl.mjs

@@ -0,0 +1,133 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { c as makeCodec, d as makeSerializer, l as makeFormat, u as makeParser } from "./Serialization-DP9H5bYQ.mjs";
+import { a as parseStream$1, i as parseQuads$1, n as serializeStream$1, r as parse$1, t as serialize$1 } from "./serialize-96KBvKaf.mjs";
+import * as Option from "effect/Option";
+// src/turtle/Turtle.ts
+/**
+* RDF 1.2 Turtle: the terse RDF triple language.
+*
+* The parser supports the full RDF 1.2 grammar (triple terms `<<( s p o )>>`,
+* reified triples `<< s p o ~ r >>`, annotations `{| ... |}`, `VERSION`,
+* directional language tags) as well as RDF 1.1 documents, and reports the
+* declared prefixes and final base IRI. `parseStream` parses incrementally,
+* emitting statements as soon as they are complete.
+*
+* The serializer produces idiomatic output: prefixed names, `@base`
+* relativisation, subject grouping with `;` and `,`, `a` for `rdf:type`,
+* inline `[ ... ]` blank nodes, `( ... )` collections, numeric and boolean
+* shorthand, annotation syntax for reified asserted triples, and a
+* deterministic statement order.
+*
+* @example
+* ```ts
+* import { Effect } from 'effect'
+* import { PrefixMap } from '@thomasfosterau/effect-rdf'
+* import { Turtle } from '@thomasfosterau/effect-rdf/turtle'
+*
+* const program = Effect.gen(function* () {
+*   const { dataset, prefixes } = yield* Turtle.parse(`
+*     PREFIX ex: <http://example.org/>
+*     ex:alice a ex:Person ; ex:knows [ ex:name "Bob" ] .
+*   `)
+*   return yield* Turtle.serialize(dataset, { prefixes })
+* })
+* ```
+*
+* @since 0.1.0
+*/
+var Turtle_exports = /* @__PURE__ */ __exportAll({
+	codec: () => codec,
+	format: () => format,
+	parse: () => parse,
+	parseQuads: () => parseQuads,
+	parseStream: () => parseStream,
+	parser: () => parser,
+	serialize: () => serialize,
+	serializeStream: () => serializeStream,
+	serializer: () => serializer
+});
+/**
+* @since 0.1.0
+* @category formats
+*/
+const format = makeFormat({
+	name: "Turtle",
+	mediaType: "text/turtle",
+	mediaTypes: ["text/turtle", "application/x-turtle"],
+	extensions: ["ttl"],
+	datasets: false
+});
+const syntax = {
+	name: "Turtle",
+	trig: false,
+	trace: Option.some({
+		module: "Turtle",
+		format
+	})
+};
+/**
+* Parses a Turtle document, returning the dataset together with the
+* declared prefixes and the final base IRI. Triples are placed in
+* `options.graph` (the default graph when omitted).
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options) => parse$1(syntax, input, options);
+/**
+* Parses a Turtle document into statements in document order.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseQuads = (input, options) => parseQuads$1(syntax, input, options);
+/**
+* Parses a stream of text chunks incrementally. Statements are emitted as
+* soon as they are complete; chunk boundaries may fall anywhere.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseStream = parseStream$1(syntax);
+/**
+* Serialises triples as pretty Turtle. Fails for quads in named graphs and
+* for triple terms in the subject position (not expressible in Turtle 1.2).
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serialize = (quads, options) => serialize$1(syntax, quads, options);
+/**
+* Serialises a stream of triples incrementally in constant memory. Only
+* consecutive statements are grouped, and blank nodes keep their labels.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializeStream = serializeStream$1(syntax);
+/**
+* @since 0.1.0
+* @category parsing
+*/
+const parser = makeParser({
+	format,
+	parse,
+	parseStream
+});
+/**
+* @since 0.1.0
+* @category serializing
+*/
+const serializer = makeSerializer({
+	format,
+	serialize,
+	serializeStream
+});
+/**
+* @since 0.1.0
+* @category codecs
+*/
+const codec = makeCodec(parser, serializer);
+export { parseQuads as a, serialize as c, parse as i, serializeStream as l, codec as n, parseStream as o, format as r, parser as s, Turtle_exports as t, serializer as u };
+
+//# sourceMappingURL=Turtle-CZVUOtwl.mjs.map

package/dist/Turtle-CZVUOtwl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turtle-CZVUOtwl.mjs","names":["Serialization.makeFormat","internal.parse","internal.parseQuads","internal.parseStream","internalSerialize.serialize","internalSerialize.serializeStream","Serialization.makeParser","Serialization.makeSerializer","Serialization.makeCodec"],"sources":["../src/turtle/Turtle.ts"],"sourcesContent":["/**\n * RDF 1.2 Turtle: the terse RDF triple language.\n *\n * The parser supports the full RDF 1.2 grammar (triple terms `<<( s p o )>>`,\n * reified triples `<< s p o ~ r >>`, annotations `{| ... |}`, `VERSION`,\n * directional language tags) as well as RDF 1.1 documents, and reports the\n * declared prefixes and final base IRI. `parseStream` parses incrementally,\n * emitting statements as soon as they are complete.\n *\n * The serializer produces idiomatic output: prefixed names, `@base`\n * relativisation, subject grouping with `;` and `,`, `a` for `rdf:type`,\n * inline `[ ... ]` blank nodes, `( ... )` collections, numeric and boolean\n * shorthand, annotation syntax for reified asserted triples, and a\n * deterministic statement order.\n *\n * @example\n * ```ts\n * import { Effect } from 'effect'\n * import { PrefixMap } from '@thomasfosterau/effect-rdf'\n * import { Turtle } from '@thomasfosterau/effect-rdf/turtle'\n *\n * const program = Effect.gen(function* () {\n *   const { dataset, prefixes } = yield* Turtle.parse(`\n *     PREFIX ex: <http://example.org/>\n *     ex:alice a ex:Person ; ex:knows [ ex:name \"Bob\" ] .\n *   `)\n *   return yield* Turtle.serialize(dataset, { prefixes })\n * })\n * ```\n *\n * @since 0.1.0\n */\nimport * as Serialization from '../Serialization.ts';\nimport type * as Term from '../Term.ts';\nimport type * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport type * as Stream from 'effect/Stream';\nimport * as internal from './internal/parse.ts';\nimport * as internalSerialize from './internal/serialize.ts';\n\n/**\n * The result of `parseQuads`: statements in document order with the\n * document's prefixes and final base IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport type QuadsResult = internal.QuadsResult;\n\n/**\n * Options for the Turtle serializer.\n *\n * @since 0.1.0\n * @category models\n */\nexport type SerializeOptions = internalSerialize.SerializeOptions;\n\n/**\n * @since 0.1.0\n * @category formats\n */\nexport const format: Serialization.Format = Serialization.makeFormat({\n  name: 'Turtle',\n  mediaType: 'text/turtle',\n  mediaTypes: ['text/turtle', 'application/x-turtle'],\n  extensions: ['ttl'],\n  datasets: false,\n});\n\n// The span names are `Turtle.parse`, `Turtle.serialize`, …\nconst syntax: internal.Syntax = {\n  name: 'Turtle',\n  trig: false,\n  trace: Option.some({ module: 'Turtle', format }),\n};\n\n/**\n * Parses a Turtle document, returning the dataset together with the\n * declared prefixes and the final base IRI. Triples are placed in\n * `options.graph` (the default graph when omitted).\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parse = (\n  input: string,\n  options?: Serialization.ParseOptions,\n): Effect.Effect<Serialization.ParseResult, Serialization.RdfParseError> =>\n  internal.parse(syntax, input, options);\n\n/**\n * Parses a Turtle document into statements in document order.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parseQuads = (\n  input: string,\n  options?: Serialization.ParseOptions,\n): Effect.Effect<QuadsResult, Serialization.RdfParseError> =>\n  internal.parseQuads(syntax, input, options);\n\n/**\n * Parses a stream of text chunks incrementally. Statements are emitted as\n * soon as they are complete; chunk boundaries may fall anywhere.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parseStream: <E, R>(\n  input: Stream.Stream<string, E, R>,\n  options?: Serialization.ParseOptions,\n) => Stream.Stream<Term.Quad, Serialization.RdfParseError | E, R> = internal.parseStream(syntax);\n\n/**\n * Serialises triples as pretty Turtle. Fails for quads in named graphs and\n * for triple terms in the subject position (not expressible in Turtle 1.2).\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const serialize = (\n  quads: Iterable<Term.Quad>,\n  options?: SerializeOptions,\n): Effect.Effect<string, Serialization.RdfSerializeError> =>\n  internalSerialize.serialize(syntax, quads, options);\n\n/**\n * Serialises a stream of triples incrementally in constant memory. Only\n * consecutive statements are grouped, and blank nodes keep their labels.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const serializeStream: <E, R>(\n  quads: Stream.Stream<Term.Quad, E, R>,\n  options?: SerializeOptions,\n) => Stream.Stream<string, Serialization.RdfSerializeError | E, R> =\n  internalSerialize.serializeStream(syntax);\n\n/**\n * @since 0.1.0\n * @category parsing\n */\nexport const parser: Serialization.Parser = Serialization.makeParser({\n  format,\n  parse,\n  parseStream,\n});\n\n/**\n * @since 0.1.0\n * @category serializing\n */\nexport const serializer: Serialization.Serializer<SerializeOptions> = Serialization.makeSerializer({\n  format,\n  serialize,\n  serializeStream,\n});\n\n/**\n * @since 0.1.0\n * @category codecs\n */\nexport const codec: Serialization.Codec<Serialization.ParseOptions, SerializeOptions> =\n  Serialization.makeCodec(parser, serializer);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAa,SAA+BA,WAAyB;CACnE,MAAM;CACN,WAAW;CACX,YAAY,CAAC,eAAe,sBAAsB;CAClD,YAAY,CAAC,KAAK;CAClB,UAAU;AACZ,CAAC;AAGD,MAAM,SAA0B;CAC9B,MAAM;CACN,MAAM;CACN,OAAO,OAAO,KAAK;EAAE,QAAQ;EAAU;CAAO,CAAC;AACjD;;;;;;;;;AAUA,MAAa,SACX,OACA,YAEAC,QAAe,QAAQ,OAAO,OAAO;;;;;;;AAQvC,MAAa,cACX,OACA,YAEAC,aAAoB,QAAQ,OAAO,OAAO;;;;;;;;AAS5C,MAAa,cAGuDC,cAAqB,MAAM;;;;;;;;AAS/F,MAAa,aACX,OACA,YAEAC,YAA4B,QAAQ,OAAO,OAAO;;;;;;;;AASpD,MAAa,kBAIXC,kBAAkC,MAAM;;;;;AAM1C,MAAa,SAA+BC,WAAyB;CACnE;CACA;CACA;AACF,CAAC;;;;;AAMD,MAAa,aAAyDC,eAA6B;CACjG;CACA;CACA;AACF,CAAC;;;;;AAMD,MAAa,QACXC,UAAwB,QAAQ,UAAU"}

package/dist/ValidationReport-DBdJshW5.mjs

@@ -0,0 +1,285 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, L as isGroundTerm, O as defaultGraph, Q as quad, T as blankNode, U as isResource, Y as literal, a as GroundTermSchema, l as NamedNodeSchema, n as BlankNodeSchema, s as LiteralSchema, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf, L as subjectsOf, m as fromIterable } from "./Dataset-BlmlcI7J.mjs";
+import { t as Vocab_exports } from "./Vocab-DceKywpq.mjs";
+import { r as sh } from "./Vocabulary-CnQl-_Z4.mjs";
+import { d as toRdf$1, f as toSparql, o as fromRdf } from "./Path-B20Yp8KE.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Result from "effect/Result";
+// src/shacl/ValidationReport.ts
+/**
+* Validation reports (§3.6): a typed model of the outcome of SHACL
+* validation, convertible to and from the standard RDF validation report
+* vocabulary.
+*
+* @since 0.1.0
+*/
+var ValidationReport_exports = /* @__PURE__ */ __exportAll({
+	ReportSyntaxError: () => ReportSyntaxError,
+	ValidationReportSchema: () => ValidationReportSchema,
+	format: () => format,
+	formatResult: () => formatResult,
+	fromDataset: () => fromDataset,
+	hasNoViolations: () => hasNoViolations,
+	isValidationReport: () => isValidationReport,
+	make: () => make,
+	makeResult: () => makeResult,
+	toDataset: () => toDataset,
+	toRdf: () => toRdf,
+	violations: () => violations,
+	withSeverity: () => withSeverity
+});
+const { rdf, xsd } = Vocab_exports;
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const makeResult = (fields) => ({
+	_tag: "ValidationResult",
+	focusNode: fields.focusNode,
+	resultPath: fields.resultPath ?? Option.none(),
+	value: fields.value ?? Option.none(),
+	sourceShape: fields.sourceShape,
+	sourceConstraintComponent: fields.sourceConstraintComponent,
+	sourceConstraint: fields.sourceConstraint ?? Option.none(),
+	severity: fields.severity ?? sh.Violation,
+	messages: fields.messages ?? [],
+	details: fields.details ?? []
+});
+/**
+* Builds a report from results; `conforms` is true iff there are none.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (results) => ({
+	_tag: "ValidationReport",
+	conforms: Arr.isReadonlyArrayEmpty(results),
+	results
+});
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isValidationReport = (u) => Predicate.isTagged(u, "ValidationReport");
+const PathStruct = Schema.Union([
+	Schema.Struct({
+		_tag: Schema.tag("PredicatePath"),
+		predicate: NamedNodeSchema
+	}),
+	Schema.Struct({
+		_tag: Schema.tag("SequencePath"),
+		paths: Schema.Array(Schema.suspend(() => PathStruct))
+	}),
+	Schema.Struct({
+		_tag: Schema.tag("AlternativePath"),
+		paths: Schema.Array(Schema.suspend(() => PathStruct))
+	}),
+	...[
+		"InversePath",
+		"ZeroOrMorePath",
+		"OneOrMorePath",
+		"ZeroOrOnePath"
+	].map((tag) => Schema.Struct({
+		_tag: Schema.tag(tag),
+		path: Schema.suspend(() => PathStruct)
+	}))
+]).annotate({ identifier: "Path" });
+const ResourceSchema = Schema.Union([NamedNodeSchema, BlankNodeSchema]);
+const ValidationResultStruct = Schema.Struct({
+	_tag: Schema.tag("ValidationResult"),
+	focusNode: GroundTermSchema,
+	resultPath: Schema.Option(PathStruct),
+	value: Schema.Option(GroundTermSchema),
+	sourceShape: ResourceSchema,
+	sourceConstraintComponent: ResourceSchema,
+	sourceConstraint: Schema.Option(ResourceSchema),
+	severity: NamedNodeSchema,
+	messages: Schema.Array(LiteralSchema),
+	details: Schema.Array(Schema.suspend(() => ValidationResultStruct))
+}).annotate({ identifier: "ValidationResult" });
+const ValidationReportJson = Schema.Struct({ results: Schema.Array(ValidationResultStruct) });
+/**
+* Schema of a validation report; its JSON codec is `{ results }`, mirroring
+* the result model with terms as `TermJson` terms and `Option`s in Effect's
+* JSON form (`conforms` is recomputed from the results on decode).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const ValidationReportSchema = Schema.declare(isValidationReport, {
+	identifier: "ValidationReport",
+	toCodecJson: () => Schema.link()(ValidationReportJson, SchemaTransformation.transform({
+		decode: ({ results }) => make(results),
+		encode: ({ results }) => ({ results })
+	}))
+});
+/**
+* The results with a given severity.
+*
+* @since 0.1.0
+* @category queries
+*/
+const withSeverity = (self, severity) => self.results.filter((r) => r.severity.value === severity.value);
+/**
+* The `sh:Violation` results.
+*
+* @since 0.1.0
+* @category queries
+*/
+const violations = (self) => withSeverity(self, sh.Violation);
+/**
+* Whether the report has no results of severity `sh:Violation` (it may still
+* contain warnings and informational results).
+*
+* @since 0.1.0
+* @category queries
+*/
+const hasNoViolations = (self) => Arr.isReadonlyArrayEmpty(violations(self));
+/**
+* A human-readable, multi-line summary of a report.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const format = (self) => {
+	if (self.conforms) return "Conforms";
+	const lines = [`Does not conform (${self.results.length} result(s))`];
+	const go = (indent) => (r) => {
+		lines.push(`${indent}- ${formatResult(r)}`);
+		Arr.forEach(r.details, go(`${indent}  `));
+	};
+	Arr.forEach(self.results, go(""));
+	return lines.join("\n");
+};
+/**
+* Formats one validation result on one line (without its details):
+* severity, constraint component, focus node, path, value, shape and the
+* first message.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatResult = (r) => {
+	const parts = [`[${sh.localName(r.severity) ?? r.severity.key}] ${isNamedNode(r.sourceConstraintComponent) ? sh.localName(r.sourceConstraintComponent) ?? r.sourceConstraintComponent.key : r.sourceConstraintComponent.key} on ${r.focusNode.key}`];
+	if (Option.isSome(r.resultPath)) parts.push(`path ${toSparql(r.resultPath.value)}`);
+	if (Option.isSome(r.value)) parts.push(`value ${r.value.value.key}`);
+	parts.push(`(shape ${r.sourceShape.key})`);
+	const message = r.messages[0];
+	return parts.join(" ") + (message === void 0 ? "" : `: ${message.value}`);
+};
+/**
+* Converts a report to the standard RDF validation report graph, using fresh
+* blank nodes for the report, its results and any non-IRI result paths.
+* Returns the report node together with the dataset.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toRdf = (self, options = {}) => {
+	const graph = options.graph ?? defaultGraph;
+	const includeDetails = options.details !== false;
+	const includeMessages = options.messages !== false;
+	const quads = [];
+	const add = (s, p, o) => quads.push(quad(s, p, o, graph));
+	const writeResult = (r) => {
+		const node = blankNode();
+		add(node, rdf.type, sh.ValidationResult);
+		add(node, sh.focusNode, r.focusNode);
+		if (Option.isSome(r.resultPath)) {
+			const encoded = toRdf$1(r.resultPath.value, graph);
+			quads.push(...encoded.quads);
+			add(node, sh.resultPath, encoded.node);
+		}
+		if (Option.isSome(r.value)) add(node, sh.value, r.value.value);
+		add(node, sh.sourceShape, r.sourceShape);
+		add(node, sh.sourceConstraintComponent, r.sourceConstraintComponent);
+		if (Option.isSome(r.sourceConstraint)) add(node, sh.sourceConstraint, r.sourceConstraint.value);
+		add(node, sh.resultSeverity, r.severity);
+		if (includeMessages) Arr.forEach(r.messages, (m) => add(node, sh.resultMessage, m));
+		if (includeDetails) Arr.forEach(r.details, (d) => add(node, sh.detail, writeResult(d)));
+		return node;
+	};
+	const report = blankNode();
+	add(report, rdf.type, sh.ValidationReport);
+	add(report, sh.conforms, literal(String(self.conforms), xsd.boolean));
+	Arr.forEach(self.results, (r) => add(report, sh.result, writeResult(r)));
+	return {
+		node: report,
+		dataset: fromIterable(quads)
+	};
+};
+/**
+* Converts a report to the standard RDF validation report graph.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toDataset = (self, options = {}) => toRdf(self, options).dataset;
+/**
+* Why an RDF validation report could not be read.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ReportSyntaxError = class extends Schema.TaggedError()("ReportSyntaxError", { message: Schema.String }) {};
+/**
+* Reads a validation report from RDF. The report node defaults to the (only)
+* instance of `sh:ValidationReport` in the dataset.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromDataset = (dataset, reportNode) => {
+	const err = (message) => Result.fail(new ReportSyntaxError({ message }));
+	const node = Option.match(Option.fromUndefinedOr(reportNode), {
+		onSome: (n) => Result.succeed(n),
+		onNone: () => {
+			const reports = subjectsOf(dataset, rdf.type, sh.ValidationReport);
+			return Result.fromOption(Option.filter(Arr.head(reports), () => reports.length === 1), () => `expected exactly one sh:ValidationReport, found ${reports.length}`).pipe(Result.flatMap((n) => isResource(n) ? Result.succeed(n) : Result.fail("invalid report node")));
+		}
+	});
+	if (Result.isFailure(node)) return err(node.failure);
+	const one = (s, p) => Arr.head(objectsOf(dataset, s, p));
+	const conformsNode = Option.filter(one(node.success, sh.conforms), isLiteral);
+	if (Option.isNone(conformsNode)) return err("the report has no sh:conforms literal");
+	const readResults = (nodes, depth) => Result.all(Arr.map(nodes, (r) => readResult(r, depth)));
+	const readResult = (r, depth) => {
+		if (isLiteral(r) || depth > 64) return Result.fail(`invalid result node ${r.key}`);
+		const required = (p, refinement, message) => Result.fromOption(Option.filter(one(r, p), refinement), () => `result ${r.key} ${message}`);
+		const pathNode = one(r, sh.resultPath);
+		return Result.gen(function* () {
+			const focusNode = yield* required(sh.focusNode, isGroundTerm, "has no sh:focusNode");
+			const sourceShape = yield* required(sh.sourceShape, isResource, "has no valid sh:sourceShape");
+			const component = yield* required(sh.sourceConstraintComponent, isResource, "has no valid sh:sourceConstraintComponent");
+			const severity = yield* required(sh.resultSeverity, isNamedNode, "has no valid sh:resultSeverity");
+			const resultPath = Option.isNone(pathNode) ? Option.none() : Option.some(yield* Result.mapError(fromRdf(dataset, pathNode.value), () => `result ${r.key} has an invalid sh:resultPath`));
+			const details = yield* readResults(objectsOf(dataset, r, sh.detail), depth + 1);
+			return makeResult({
+				focusNode,
+				sourceShape,
+				sourceConstraintComponent: component,
+				severity,
+				resultPath,
+				value: one(r, sh.value),
+				sourceConstraint: Option.filter(one(r, sh.sourceConstraint), isResource),
+				messages: objectsOf(dataset, r, sh.resultMessage).filter(isLiteral),
+				details
+			});
+		});
+	};
+	const results = readResults(objectsOf(dataset, node.success, sh.result), 0);
+	if (Result.isFailure(results)) return err(results.failure);
+	return Result.succeed({
+		_tag: "ValidationReport",
+		conforms: conformsNode.value.value === "true" || conformsNode.value.value === "1",
+		results: results.success
+	});
+};
+export { formatResult as a, isValidationReport as c, toDataset as d, toRdf as f, format as i, make as l, withSeverity as m, ValidationReportSchema as n, fromDataset as o, violations as p, ValidationReport_exports as r, hasNoViolations as s, ReportSyntaxError as t, makeResult as u };
+
+//# sourceMappingURL=ValidationReport-DBdJshW5.mjs.map

package/dist/ValidationReport-DBdJshW5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationReport-DBdJshW5.mjs","names":["Vocab","Term.NamedNodeSchema","Term.BlankNodeSchema","Term.GroundTermSchema","Term.LiteralSchema","Term.isNamedNode","Path.toSparql","Term.defaultGraph","Term.quad","Term.blankNode","Path.toRdf","Term.literal","Dataset.fromIterable","Dataset.subjectsOf","Term.isResource","Dataset.objectsOf","Term.isLiteral","Term.isGroundTerm","Path.fromRdf"],"sources":["../src/shacl/ValidationReport.ts"],"sourcesContent":["/**\n * Validation reports (§3.6): a typed model of the outcome of SHACL\n * validation, convertible to and from the standard RDF validation report\n * vocabulary.\n *\n * @since 0.1.0\n */\nimport { Dataset, Term, Vocab } from '../index.ts';\nimport * as Arr from 'effect/Array';\nimport * as Option from 'effect/Option';\nimport * as Result from 'effect/Result';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as Path from './Path.ts';\nimport { sh } from './Vocabulary.ts';\nimport * as Predicate from 'effect/Predicate';\n\nconst { rdf, xsd } = Vocab;\n\n/**\n * A single validation result (`sh:ValidationResult`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ValidationResult {\n  readonly _tag: 'ValidationResult';\n  /** `sh:focusNode`: the focus node that was validated. */\n  readonly focusNode: Term.GroundTerm;\n  /** `sh:resultPath`: the path of the property shape, when relevant. */\n  readonly resultPath: Option.Option<Path.Path>;\n  /** `sh:value`: the value node that caused the result, when relevant. */\n  readonly value: Option.Option<Term.GroundTerm>;\n  /** `sh:sourceShape`: the shape the constraint belongs to. */\n  readonly sourceShape: Term.NamedNode | Term.BlankNode;\n  /** `sh:sourceConstraintComponent`. */\n  readonly sourceConstraintComponent: Term.NamedNode | Term.BlankNode;\n  /** `sh:sourceConstraint` (for SPARQL-based constraints). */\n  readonly sourceConstraint: Option.Option<Term.NamedNode | Term.BlankNode>;\n  /** `sh:resultSeverity`. */\n  readonly severity: Term.NamedNode;\n  /** `sh:resultMessage` values. */\n  readonly messages: ReadonlyArray<Term.Literal>;\n  /** `sh:detail`: nested results explaining this result. */\n  readonly details: ReadonlyArray<ValidationResult>;\n}\n\n/**\n * A validation report (`sh:ValidationReport`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ValidationReport {\n  readonly _tag: 'ValidationReport';\n  /** `sh:conforms`: true when there are no validation results. */\n  readonly conforms: boolean;\n  /** `sh:result` values. */\n  readonly results: ReadonlyArray<ValidationResult>;\n}\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const makeResult = (fields: {\n  readonly focusNode: Term.GroundTerm;\n  readonly sourceShape: Term.NamedNode | Term.BlankNode;\n  readonly sourceConstraintComponent: Term.NamedNode | Term.BlankNode;\n  readonly severity?: Term.NamedNode | undefined;\n  readonly resultPath?: Option.Option<Path.Path> | undefined;\n  readonly value?: Option.Option<Term.GroundTerm> | undefined;\n  readonly sourceConstraint?: Option.Option<Term.NamedNode | Term.BlankNode> | undefined;\n  readonly messages?: ReadonlyArray<Term.Literal> | undefined;\n  readonly details?: ReadonlyArray<ValidationResult> | undefined;\n}): ValidationResult => ({\n  _tag: 'ValidationResult',\n  focusNode: fields.focusNode,\n  resultPath: fields.resultPath ?? Option.none(),\n  value: fields.value ?? Option.none(),\n  sourceShape: fields.sourceShape,\n  sourceConstraintComponent: fields.sourceConstraintComponent,\n  sourceConstraint: fields.sourceConstraint ?? Option.none(),\n  severity: fields.severity ?? sh.Violation,\n  messages: fields.messages ?? [],\n  details: fields.details ?? [],\n});\n\n/**\n * Builds a report from results; `conforms` is true iff there are none.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (results: ReadonlyArray<ValidationResult>): ValidationReport => ({\n  _tag: 'ValidationReport',\n  conforms: Arr.isReadonlyArrayEmpty(results),\n  results,\n});\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isValidationReport = (u: unknown): u is ValidationReport =>\n  Predicate.isTagged(u, 'ValidationReport');\n\n// The structural shape of the report model, which `ValidationReportSchema` links to as its JSON\n// codec: `Schema.toCodecJson` derives the terms' JSON through their own declarations.\nconst PathStruct: Schema.Codec<Path.Path> = Schema.Union([\n  Schema.Struct({ _tag: Schema.tag('PredicatePath'), predicate: Term.NamedNodeSchema }),\n  Schema.Struct({\n    _tag: Schema.tag('SequencePath'),\n    paths: Schema.Array(Schema.suspend((): Schema.Codec<Path.Path> => PathStruct)),\n  }),\n  Schema.Struct({\n    _tag: Schema.tag('AlternativePath'),\n    paths: Schema.Array(Schema.suspend((): Schema.Codec<Path.Path> => PathStruct)),\n  }),\n  ...(['InversePath', 'ZeroOrMorePath', 'OneOrMorePath', 'ZeroOrOnePath'] as const).map((tag) =>\n    Schema.Struct({\n      _tag: Schema.tag(tag),\n      path: Schema.suspend((): Schema.Codec<Path.Path> => PathStruct),\n    }),\n  ),\n]).annotate({ identifier: 'Path' });\n\nconst ResourceSchema = Schema.Union([Term.NamedNodeSchema, Term.BlankNodeSchema]);\n\nconst ValidationResultStruct: Schema.Codec<ValidationResult> = Schema.Struct({\n  _tag: Schema.tag('ValidationResult'),\n  focusNode: Term.GroundTermSchema,\n  resultPath: Schema.Option(PathStruct),\n  value: Schema.Option(Term.GroundTermSchema),\n  sourceShape: ResourceSchema,\n  sourceConstraintComponent: ResourceSchema,\n  sourceConstraint: Schema.Option(ResourceSchema),\n  severity: Term.NamedNodeSchema,\n  messages: Schema.Array(Term.LiteralSchema),\n  details: Schema.Array(\n    Schema.suspend((): Schema.Codec<ValidationResult> => ValidationResultStruct),\n  ),\n}).annotate({ identifier: 'ValidationResult' });\n\n// `conforms` is derived from the results (`make`), so the JSON carries only the results.\nconst ValidationReportJson = Schema.Struct({ results: Schema.Array(ValidationResultStruct) });\n\n/**\n * Schema of a validation report; its JSON codec is `{ results }`, mirroring\n * the result model with terms as `TermJson` terms and `Option`s in Effect's\n * JSON form (`conforms` is recomputed from the results on decode).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const ValidationReportSchema: Schema.declare<ValidationReport> = Schema.declare(\n  isValidationReport,\n  {\n    identifier: 'ValidationReport',\n    toCodecJson: () =>\n      Schema.link<ValidationReport>()(\n        ValidationReportJson,\n        SchemaTransformation.transform({\n          decode: ({ results }) => make(results),\n          encode: ({ results }) => ({ results }),\n        }),\n      ),\n  },\n);\n\n/**\n * The type `ValidationReportSchema` decodes to: a `ValidationReport`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type ValidationReportSchema = typeof ValidationReportSchema.Type;\n\n// -----------------------------------------------------------------------------\n// Queries\n// -----------------------------------------------------------------------------\n\n/**\n * The results with a given severity.\n *\n * @since 0.1.0\n * @category queries\n */\nexport const withSeverity = (\n  self: ValidationReport,\n  severity: Term.NamedNode,\n): ReadonlyArray<ValidationResult> =>\n  self.results.filter((r) => r.severity.value === severity.value);\n\n/**\n * The `sh:Violation` results.\n *\n * @since 0.1.0\n * @category queries\n */\nexport const violations = (self: ValidationReport): ReadonlyArray<ValidationResult> =>\n  withSeverity(self, sh.Violation);\n\n/**\n * Whether the report has no results of severity `sh:Violation` (it may still\n * contain warnings and informational results).\n *\n * @since 0.1.0\n * @category queries\n */\nexport const hasNoViolations = (self: ValidationReport): boolean =>\n  Arr.isReadonlyArrayEmpty(violations(self));\n\n/**\n * A human-readable, multi-line summary of a report.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const format = (self: ValidationReport): string => {\n  if (self.conforms) return 'Conforms';\n  const lines = [`Does not conform (${self.results.length} result(s))`];\n  const go = (indent: string) => (r: ValidationResult) => {\n    lines.push(`${indent}- ${formatResult(r)}`);\n    Arr.forEach(r.details, go(`${indent}  `));\n  };\n  Arr.forEach(self.results, go(''));\n  return lines.join('\\n');\n};\n\n/**\n * Formats one validation result on one line (without its details):\n * severity, constraint component, focus node, path, value, shape and the\n * first message.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const formatResult = (r: ValidationResult): string => {\n  const severity = sh.localName(r.severity) ?? r.severity.key;\n  const component = Term.isNamedNode(r.sourceConstraintComponent)\n    ? (sh.localName(r.sourceConstraintComponent) ?? r.sourceConstraintComponent.key)\n    : r.sourceConstraintComponent.key;\n  const parts = [`[${severity}] ${component} on ${r.focusNode.key}`];\n  if (Option.isSome(r.resultPath)) parts.push(`path ${Path.toSparql(r.resultPath.value)}`);\n  if (Option.isSome(r.value)) parts.push(`value ${r.value.value.key}`);\n  parts.push(`(shape ${r.sourceShape.key})`);\n  const message = r.messages[0];\n  return parts.join(' ') + (message === undefined ? '' : `: ${message.value}`);\n};\n\n// -----------------------------------------------------------------------------\n// RDF conversion\n// -----------------------------------------------------------------------------\n\n/**\n * Options for `toDataset`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ToDatasetOptions {\n  /** The graph to write the report into (default graph by default). */\n  readonly graph?: Term.Graph | undefined;\n  /** Include `sh:detail` results (default `true`). */\n  readonly details?: boolean | undefined;\n  /** Include `sh:resultMessage` values (default `true`). */\n  readonly messages?: boolean | undefined;\n}\n\n/**\n * A validation report encoded as RDF: the report's node and the graph\n * describing it.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport interface ReportRdf {\n  readonly node: Term.BlankNode;\n  readonly dataset: Dataset.Dataset;\n}\n\n/**\n * Converts a report to the standard RDF validation report graph, using fresh\n * blank nodes for the report, its results and any non-IRI result paths.\n * Returns the report node together with the dataset.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toRdf = (self: ValidationReport, options: ToDatasetOptions = {}): ReportRdf => {\n  const graph = options.graph ?? Term.defaultGraph;\n  const includeDetails = options.details !== false;\n  const includeMessages = options.messages !== false;\n  const quads: Array<Term.Quad> = [];\n  const add = (s: Term.Subject, p: Term.NamedNode, o: Term.Object) =>\n    quads.push(Term.quad(s, p, o, graph));\n  const writeResult = (r: ValidationResult): Term.BlankNode => {\n    const node = Term.blankNode();\n    add(node, rdf.type, sh.ValidationResult);\n    add(node, sh.focusNode, r.focusNode);\n    if (Option.isSome(r.resultPath)) {\n      const encoded = Path.toRdf(r.resultPath.value, graph);\n      quads.push(...encoded.quads);\n      add(node, sh.resultPath, encoded.node);\n    }\n    if (Option.isSome(r.value)) add(node, sh.value, r.value.value);\n    add(node, sh.sourceShape, r.sourceShape);\n    add(node, sh.sourceConstraintComponent, r.sourceConstraintComponent);\n    if (Option.isSome(r.sourceConstraint)) add(node, sh.sourceConstraint, r.sourceConstraint.value);\n    add(node, sh.resultSeverity, r.severity);\n    if (includeMessages) Arr.forEach(r.messages, (m) => add(node, sh.resultMessage, m));\n    if (includeDetails) Arr.forEach(r.details, (d) => add(node, sh.detail, writeResult(d)));\n    return node;\n  };\n  const report = Term.blankNode();\n  add(report, rdf.type, sh.ValidationReport);\n  add(report, sh.conforms, Term.literal(String(self.conforms), xsd.boolean));\n  Arr.forEach(self.results, (r) => add(report, sh.result, writeResult(r)));\n  return { node: report, dataset: Dataset.fromIterable(quads) };\n};\n\n/**\n * Converts a report to the standard RDF validation report graph.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toDataset = (\n  self: ValidationReport,\n  options: ToDatasetOptions = {},\n): Dataset.Dataset => toRdf(self, options).dataset;\n\n/**\n * Why an RDF validation report could not be read.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class ReportSyntaxError extends Schema.TaggedError<ReportSyntaxError>()(\n  'ReportSyntaxError',\n  { message: Schema.String },\n) {}\n\n/**\n * Reads a validation report from RDF. The report node defaults to the (only)\n * instance of `sh:ValidationReport` in the dataset.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const fromDataset = (\n  dataset: Dataset.Dataset,\n  reportNode?: Term.NamedNode | Term.BlankNode,\n): Result.Result<ValidationReport, ReportSyntaxError> => {\n  const err = (message: string) => Result.fail(new ReportSyntaxError({ message }));\n  const node = Option.match(Option.fromUndefinedOr(reportNode), {\n    onSome: (n): Result.Result<Term.Resource, string> => Result.succeed(n),\n    onNone: () => {\n      const reports = Dataset.subjectsOf(dataset, rdf.type, sh.ValidationReport);\n      return Result.fromOption(\n        Option.filter(Arr.head(reports), () => reports.length === 1),\n        () => `expected exactly one sh:ValidationReport, found ${reports.length}`,\n      ).pipe(\n        Result.flatMap((n) =>\n          Term.isResource(n) ? Result.succeed(n) : Result.fail('invalid report node'),\n        ),\n      );\n    },\n  });\n  if (Result.isFailure(node)) return err(node.failure);\n  const one = (s: Term.Subject, p: Term.NamedNode) => Arr.head(Dataset.objectsOf(dataset, s, p));\n  const conformsNode = Option.filter(one(node.success, sh.conforms), Term.isLiteral);\n  if (Option.isNone(conformsNode)) return err('the report has no sh:conforms literal');\n  const readResults = (\n    nodes: ReadonlyArray<Term.GroundTerm>,\n    depth: number,\n  ): Result.Result<ReadonlyArray<ValidationResult>, string> =>\n    Result.all(Arr.map(nodes, (r) => readResult(r, depth)));\n  const readResult = (\n    r: Term.GroundTerm,\n    depth: number,\n  ): Result.Result<ValidationResult, string> => {\n    if (Term.isLiteral(r) || depth > 64) return Result.fail(`invalid result node ${r.key}`);\n    const required = <A extends Term.GroundTerm>(\n      p: Term.NamedNode,\n      refinement: (t: Term.GroundTerm) => t is A,\n      message: string,\n    ): Result.Result<A, string> =>\n      Result.fromOption(Option.filter(one(r, p), refinement), () => `result ${r.key} ${message}`);\n    const pathNode = one(r, sh.resultPath);\n    return Result.gen(function* () {\n      const focusNode = yield* required(sh.focusNode, Term.isGroundTerm, 'has no sh:focusNode');\n      const sourceShape = yield* required(\n        sh.sourceShape,\n        Term.isResource,\n        'has no valid sh:sourceShape',\n      );\n      const component = yield* required(\n        sh.sourceConstraintComponent,\n        Term.isResource,\n        'has no valid sh:sourceConstraintComponent',\n      );\n      const severity = yield* required(\n        sh.resultSeverity,\n        Term.isNamedNode,\n        'has no valid sh:resultSeverity',\n      );\n      const resultPath = Option.isNone(pathNode)\n        ? Option.none<Path.Path>()\n        : Option.some(\n            yield* Result.mapError(\n              Path.fromRdf(dataset, pathNode.value),\n              () => `result ${r.key} has an invalid sh:resultPath`,\n            ),\n          );\n      const details = yield* readResults(Dataset.objectsOf(dataset, r, sh.detail), depth + 1);\n      return makeResult({\n        focusNode,\n        sourceShape,\n        sourceConstraintComponent: component,\n        severity,\n        resultPath,\n        value: one(r, sh.value),\n        sourceConstraint: Option.filter(one(r, sh.sourceConstraint), Term.isResource),\n        messages: Dataset.objectsOf(dataset, r, sh.resultMessage).filter(Term.isLiteral),\n        details,\n      });\n    });\n  };\n  const results = readResults(Dataset.objectsOf(dataset, node.success, sh.result), 0);\n  if (Result.isFailure(results)) return err(results.failure);\n  return Result.succeed({\n    _tag: 'ValidationReport',\n    conforms: conformsNode.value.value === 'true' || conformsNode.value.value === '1',\n    results: results.success,\n  });\n};\n"],"mappings":"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"}