@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/TermCodec-_03bDXr0.d.mts

@@ -0,0 +1,209 @@
+import { C as Resource, d as NamedNode, i as Direction, l as Literal, s as GroundTerm } from "./Term-B_4ezyXq.mjs";
+import * as Schema from "effect/Schema";
+import * as BigDecimal from "effect/BigDecimal";
+import * as DateTime from "effect/DateTime";
+declare namespace TermCodec_d_exports {
+  export { LocalizedString, TermCodec, bigint, boolean, date, dateTime, decimal, double, float, integer, iri, langString, lexical, literal, localized, make, namedNode, number, resource, string, term, typed, typedOneOf, value };
+}
+/**
+ * A schema decoding a term to a JS value of type `A`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type TermCodec<A> = Schema.Codec<A, GroundTerm>;
+/**
+ * Builds a term codec from a (fallible) decoder and an encoder.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: <A>(target: Schema.Codec<A>, options: {
+  readonly expected: string;
+  readonly decode: (term: GroundTerm) => A | undefined;
+  readonly encode: (value: A) => GroundTerm;
+}) => TermCodec<A>;
+/**
+ * Any RDF term (identity).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const term: TermCodec<GroundTerm>;
+/**
+ * An IRI, decoded to a `NamedNode`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const namedNode: TermCodec<NamedNode>;
+/**
+ * An IRI, decoded to its string.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const iri: TermCodec<string>;
+/**
+ * A blank node or IRI (a resource), decoded to the term.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const resource: TermCodec<Resource>;
+/**
+ * Any literal, decoded to the `Literal` term.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const literal: TermCodec<Literal>;
+/**
+ * A string literal (simple, `xsd:string` or language-tagged), decoded to its
+ * lexical form. Encodes to `xsd:string`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const string: TermCodec<string>;
+/**
+ * The lexical form of any literal, or the string of an IRI.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const lexical: TermCodec<string>;
+/**
+ * A language-tagged string, decoded to `{ value, language, direction? }`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const langString: TermCodec<{
+  readonly value: string;
+  readonly language: string;
+  readonly direction?: Direction | undefined;
+}>;
+/**
+ * Any numeric literal, decoded to a JS number. Encodes to `xsd:double`
+ * (or `xsd:integer` for integral values).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const number: TermCodec<number>;
+/**
+ * An integer literal (`xsd:integer` and derived types), decoded to a JS
+ * number.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const integer: TermCodec<number>;
+/**
+ * An integer literal decoded to a `bigint` (no precision loss).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const bigint: TermCodec<bigint>;
+/**
+ * A decimal (or integer) literal decoded to a `BigDecimal`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const decimal: TermCodec<BigDecimal.BigDecimal>;
+/**
+ * An `xsd:boolean` literal.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const boolean: TermCodec<boolean>;
+/**
+ * An `xsd:dateTime` or `xsd:date` literal decoded to a `Date`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const date: TermCodec<Date>;
+/**
+ * A literal decoded to its natural JS value (see `Xsd.toJs`): strings,
+ * numbers, bigints, booleans and dates.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const value: TermCodec<string | number | bigint | boolean | Date>;
+/**
+ * A literal with a specific datatype, decoded to its lexical form.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const typed: (datatype: string | NamedNode) => TermCodec<string>;
+/**
+ * An `xsd:dateTime` or `xsd:dateTimeStamp` literal decoded to an Effect
+ * `DateTime`: a `DateTime.Zoned` with a fixed offset when the lexical form
+ * has a `±hh:mm` offset, otherwise (`Z`, or no timezone, read as UTC) a
+ * `DateTime.Utc`. Encodes to `xsd:dateTime`, keeping a zoned value's offset.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const dateTime: TermCodec<DateTime.DateTime>;
+/**
+ * An `xsd:double` literal, decoded to a JS number and encoded back to
+ * `xsd:double` (unlike `number`, which accepts any numeric datatype and
+ * encodes integral values as `xsd:integer`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const double: TermCodec<number>;
+/**
+ * An `xsd:float` literal, decoded to a JS number and encoded back to
+ * `xsd:float`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const float: TermCodec<number>;
+/**
+ * The value `localized` decodes to: a string with an optional language tag
+ * and base direction.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface LocalizedString {
+  readonly value: string;
+  readonly language?: string | undefined;
+  readonly direction?: Direction | undefined;
+}
+/**
+ * A string literal with an optional language tag and base direction: a
+ * simple or `xsd:string` literal decodes to `{ value }`, a (directional)
+ * language-tagged string to `{ value, language, direction? }`. Encodes back
+ * to the same kind of literal.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const localized: TermCodec<LocalizedString>;
+/**
+ * A literal whose datatype is any of `datatypes`, decoded to its lexical
+ * form and datatype IRI (so encoding restores the same literal). Use it
+ * where a property's range admits several datatypes, e.g. `xsd:date` or
+ * `xsd:gYear`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const typedOneOf: (datatypes: ReadonlyArray<string | NamedNode>) => TermCodec<{
+  readonly value: string;
+  readonly datatype: string;
+}>;
+export { typed as C, term as S, value as T, make as _, boolean as a, resource as b, decimal as c, integer as d, iri as f, localized as g, literal as h, bigint as i, double as l, lexical as m, TermCodec as n, date as o, langString as p, TermCodec_d_exports as r, dateTime as s, LocalizedString as t, float as u, namedNode as v, typedOneOf as w, string as x, number as y };
+//# sourceMappingURL=TermCodec-_03bDXr0.d.mts.map

package/dist/TermCodec.d.mts

@@ -0,0 +1,2 @@
+import { C as typed, S as term, T as value, _ as make, a as boolean, b as resource, c as decimal, d as integer, f as iri, g as localized, h as literal, i as bigint, l as double, m as lexical, n as TermCodec, o as date, p as langString, s as dateTime, t as LocalizedString, u as float, v as namedNode, w as typedOneOf, x as string, y as number } from "./TermCodec-_03bDXr0.mjs";
+export { LocalizedString, TermCodec, bigint, boolean, date, dateTime, decimal, double, float, integer, iri, langString, lexical, literal, localized, make, namedNode, number, resource, string, term, typed, typedOneOf, value };

package/dist/TermCodec.mjs

@@ -0,0 +1 @@
+export { n as bigint, r as boolean, i as date, a as dateTime, o as decimal, s as double, c as float, l as integer, u as iri, d as langString, f as lexical, p as literal, m as localized, h as make, g as namedNode, _ as number, v as resource, y as string, b as term, x as typed, S as typedOneOf, C as value } from "./TermCodec-CDZiEztW.mjs";

package/dist/TermJson-BOPe0yve.d.mts

@@ -0,0 +1,232 @@
+import * as Schema from "effect/Schema";
+declare namespace TermJson_d_exports {
+  export { BlankNode, BlankNodeSchema, DefaultGraph, DefaultGraphSchema, GroundTerm, GroundTermSchema, Literal, LiteralSchema, NamedNode, NamedNodeSchema, Quad, QuadSchema, Term, TermSchema, Triple, TripleSchema, Variable, VariableSchema };
+}
+/**
+ * The JSON encoding of an IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface NamedNode {
+  readonly type: 'uri';
+  readonly value: string;
+}
+/**
+ * The JSON encoding of a blank node; `value` is its label without `_:`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface BlankNode {
+  readonly type: 'bnode';
+  readonly value: string;
+}
+/**
+ * The JSON encoding of a literal. A literal without `xml:lang` or `datatype`
+ * is an `xsd:string`; `typed-literal` is the SPARQL 1.0 spelling, accepted
+ * on input.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Literal {
+  readonly type: 'literal' | 'typed-literal';
+  readonly value: string;
+  readonly 'xml:lang'?: string | undefined;
+  readonly 'its:dir'?: string | undefined;
+  readonly datatype?: string | undefined;
+}
+/**
+ * The JSON encoding of a triple term. As in SPARQL JSON results, each
+ * position holds any ground JSON term; `Term.TripleSchema`'s JSON codec
+ * rejects a triple whose positions don't fit RDF.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Triple {
+  readonly type: 'triple';
+  readonly value: {
+    readonly subject: GroundTerm;
+    readonly predicate: GroundTerm;
+    readonly object: GroundTerm;
+  };
+}
+/**
+ * The JSON encoding of a SPARQL variable (an extension of the SPARQL results
+ * format); `value` is the name without `?`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Variable {
+  readonly type: 'variable';
+  readonly value: string;
+}
+/**
+ * The JSON encoding of the default graph (an extension of the SPARQL results
+ * format).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface DefaultGraph {
+  readonly type: 'default-graph';
+}
+/**
+ * The JSON encoding of a ground term: exactly the RDF term of SPARQL 1.2
+ * JSON results.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GroundTerm = NamedNode | BlankNode | Literal | Triple;
+/**
+ * The JSON encoding of any term, variables and the default graph included.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Term = GroundTerm | Variable | DefaultGraph;
+/**
+ * The JSON encoding of a quad. `graph` is omitted for the default graph.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Quad {
+  readonly subject: NamedNode | BlankNode | Triple;
+  readonly predicate: NamedNode;
+  readonly object: GroundTerm;
+  readonly graph?: NamedNode | BlankNode;
+}
+/**
+ * Schema of the JSON encoding of an IRI.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const NamedNodeSchema: Schema.Codec<NamedNode>;
+/**
+ * The type `NamedNodeSchema` decodes to (the same as `NamedNode`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type NamedNodeSchema = typeof NamedNodeSchema.Type;
+/**
+ * Schema of the JSON encoding of a blank node.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const BlankNodeSchema: Schema.Codec<BlankNode>;
+/**
+ * The type `BlankNodeSchema` decodes to (the same as `BlankNode`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type BlankNodeSchema = typeof BlankNodeSchema.Type;
+/**
+ * Schema of the JSON encoding of a literal.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const LiteralSchema: Schema.Codec<Literal>;
+/**
+ * The type `LiteralSchema` decodes to (the same as `Literal`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type LiteralSchema = typeof LiteralSchema.Type;
+/**
+ * Schema of the JSON encoding of a triple term.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const TripleSchema: Schema.Codec<Triple>;
+/**
+ * The type `TripleSchema` decodes to (the same as `Triple`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type TripleSchema = typeof TripleSchema.Type;
+/**
+ * Schema of the JSON encoding of a variable.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const VariableSchema: Schema.Codec<Variable>;
+/**
+ * The type `VariableSchema` decodes to (the same as `Variable`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type VariableSchema = typeof VariableSchema.Type;
+/**
+ * Schema of the JSON encoding of the default graph.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const DefaultGraphSchema: Schema.Codec<DefaultGraph>;
+/**
+ * The type `DefaultGraphSchema` decodes to (the same as `DefaultGraph`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type DefaultGraphSchema = typeof DefaultGraphSchema.Type;
+/**
+ * Schema of the JSON encoding of a ground term (the SPARQL 1.2 JSON results
+ * term).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const GroundTermSchema: Schema.Codec<GroundTerm>;
+/**
+ * The type `GroundTermSchema` decodes to (the same as `GroundTerm`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type GroundTermSchema = typeof GroundTermSchema.Type;
+/**
+ * Schema of the JSON encoding of any term.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const TermSchema: Schema.Codec<Term>;
+/**
+ * The type `TermSchema` decodes to (the same as `Term`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type TermSchema = typeof TermSchema.Type;
+/**
+ * Schema of the JSON encoding of a quad.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const QuadSchema: Schema.Codec<Quad>;
+/**
+ * The type `QuadSchema` decodes to (the same as `Quad`).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type QuadSchema = typeof QuadSchema.Type;
+export { TripleSchema as _, GroundTerm as a, LiteralSchema as c, Quad as d, QuadSchema as f, Triple as g, TermSchema as h, DefaultGraphSchema as i, NamedNode as l, TermJson_d_exports as m, BlankNodeSchema as n, GroundTermSchema as o, Term as p, DefaultGraph as r, Literal as s, BlankNode as t, NamedNodeSchema as u, Variable as v, VariableSchema as y };
+//# sourceMappingURL=TermJson-BOPe0yve.d.mts.map

package/dist/TermJson-FAg3lvjl.mjs

@@ -0,0 +1,142 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Schema from "effect/Schema";
+// src/TermJson.ts
+/**
+* The JSON shape of RDF terms and quads: the term encoding of the SPARQL 1.2
+* Query Results JSON Format (`{ "type": "uri", "value": … }`, triple terms
+* and `its:dir` included), extended with variables and the default graph.
+*
+* These are plain JSON schemas. `Term.toJson` / `Term.fromJson` convert
+* between them and terms, and the `Term` and `Dataset` schemas link to them
+* as their `toCodecJson` representation, so `Schema.toCodecJson(Term.TermSchema)`
+* and `Schema.toJsonSchemaDocument(Term.TermSchema)` work.
+*
+* Two members extend the SPARQL results format, which has no need for them:
+*
+* - a variable is `{ "type": "variable", "value": "name" }` (the name without
+*   the leading `?`);
+* - the default graph is `{ "type": "default-graph" }`.
+*
+* @since 0.1.0
+*/
+var TermJson_exports = /* @__PURE__ */ __exportAll({
+	BlankNodeSchema: () => BlankNodeSchema,
+	DefaultGraphSchema: () => DefaultGraphSchema,
+	GroundTermSchema: () => GroundTermSchema,
+	LiteralSchema: () => LiteralSchema,
+	NamedNodeSchema: () => NamedNodeSchema,
+	QuadSchema: () => QuadSchema,
+	TermSchema: () => TermSchema,
+	TripleSchema: () => TripleSchema,
+	VariableSchema: () => VariableSchema
+});
+/**
+* Schema of the JSON encoding of an IRI.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const NamedNodeSchema = Schema.Struct({
+	type: Schema.Literal("uri"),
+	value: Schema.String
+}).annotate({ identifier: "JsonNamedNode" });
+/**
+* Schema of the JSON encoding of a blank node.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const BlankNodeSchema = Schema.Struct({
+	type: Schema.Literal("bnode"),
+	value: Schema.String
+}).annotate({ identifier: "JsonBlankNode" });
+/**
+* Schema of the JSON encoding of a literal.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const LiteralSchema = Schema.Struct({
+	type: Schema.Literals(["literal", "typed-literal"]),
+	value: Schema.String,
+	"xml:lang": Schema.optional(Schema.String),
+	"its:dir": Schema.optional(Schema.String),
+	datatype: Schema.optional(Schema.String)
+}).annotate({ identifier: "JsonLiteral" });
+/**
+* Schema of the JSON encoding of a triple term.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const TripleSchema = Schema.Struct({
+	type: Schema.Literal("triple"),
+	value: Schema.Struct({
+		subject: Schema.suspend(() => GroundTermSchema),
+		predicate: Schema.suspend(() => GroundTermSchema),
+		object: Schema.suspend(() => GroundTermSchema)
+	})
+}).annotate({ identifier: "JsonTriple" });
+/**
+* Schema of the JSON encoding of a variable.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const VariableSchema = Schema.Struct({
+	type: Schema.Literal("variable"),
+	value: Schema.String
+}).annotate({ identifier: "JsonVariable" });
+/**
+* Schema of the JSON encoding of the default graph.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DefaultGraphSchema = Schema.Struct({ type: Schema.Literal("default-graph") }).annotate({ identifier: "JsonDefaultGraph" });
+/**
+* Schema of the JSON encoding of a ground term (the SPARQL 1.2 JSON results
+* term).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const GroundTermSchema = Schema.Union([
+	NamedNodeSchema,
+	BlankNodeSchema,
+	LiteralSchema,
+	TripleSchema
+]).annotate({ identifier: "JsonGroundTerm" });
+/**
+* Schema of the JSON encoding of any term.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const TermSchema = Schema.Union([
+	NamedNodeSchema,
+	BlankNodeSchema,
+	LiteralSchema,
+	TripleSchema,
+	VariableSchema,
+	DefaultGraphSchema
+]).annotate({ identifier: "JsonTerm" });
+/**
+* Schema of the JSON encoding of a quad.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const QuadSchema = Schema.Struct({
+	subject: Schema.Union([
+		NamedNodeSchema,
+		BlankNodeSchema,
+		TripleSchema
+	]),
+	predicate: NamedNodeSchema,
+	object: GroundTermSchema,
+	graph: Schema.optionalKey(Schema.Union([NamedNodeSchema, BlankNodeSchema]))
+}).annotate({ identifier: "JsonQuad" });
+export { NamedNodeSchema as a, TermSchema as c, LiteralSchema as i, TripleSchema as l, DefaultGraphSchema as n, QuadSchema as o, GroundTermSchema as r, TermJson_exports as s, BlankNodeSchema as t, VariableSchema as u };
+
+//# sourceMappingURL=TermJson-FAg3lvjl.mjs.map

package/dist/TermJson-FAg3lvjl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TermJson-FAg3lvjl.mjs","names":[],"sources":["../src/TermJson.ts"],"sourcesContent":["/**\n * The JSON shape of RDF terms and quads: the term encoding of the SPARQL 1.2\n * Query Results JSON Format (`{ \"type\": \"uri\", \"value\": … }`, triple terms\n * and `its:dir` included), extended with variables and the default graph.\n *\n * These are plain JSON schemas. `Term.toJson` / `Term.fromJson` convert\n * between them and terms, and the `Term` and `Dataset` schemas link to them\n * as their `toCodecJson` representation, so `Schema.toCodecJson(Term.TermSchema)`\n * and `Schema.toJsonSchemaDocument(Term.TermSchema)` work.\n *\n * Two members extend the SPARQL results format, which has no need for them:\n *\n * - a variable is `{ \"type\": \"variable\", \"value\": \"name\" }` (the name without\n *   the leading `?`);\n * - the default graph is `{ \"type\": \"default-graph\" }`.\n *\n * @since 0.1.0\n */\nimport * as Schema from 'effect/Schema';\n\n/**\n * The JSON encoding of an IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface NamedNode {\n  readonly type: 'uri';\n  readonly value: string;\n}\n\n/**\n * The JSON encoding of a blank node; `value` is its label without `_:`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BlankNode {\n  readonly type: 'bnode';\n  readonly value: string;\n}\n\n/**\n * The JSON encoding of a literal. A literal without `xml:lang` or `datatype`\n * is an `xsd:string`; `typed-literal` is the SPARQL 1.0 spelling, accepted\n * on input.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Literal {\n  readonly type: 'literal' | 'typed-literal';\n  readonly value: string;\n  readonly 'xml:lang'?: string | undefined;\n  readonly 'its:dir'?: string | undefined;\n  readonly datatype?: string | undefined;\n}\n\n/**\n * The JSON encoding of a triple term. As in SPARQL JSON results, each\n * position holds any ground JSON term; `Term.TripleSchema`'s JSON codec\n * rejects a triple whose positions don't fit RDF.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Triple {\n  readonly type: 'triple';\n  readonly value: {\n    readonly subject: GroundTerm;\n    readonly predicate: GroundTerm;\n    readonly object: GroundTerm;\n  };\n}\n\n/**\n * The JSON encoding of a SPARQL variable (an extension of the SPARQL results\n * format); `value` is the name without `?`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Variable {\n  readonly type: 'variable';\n  readonly value: string;\n}\n\n/**\n * The JSON encoding of the default graph (an extension of the SPARQL results\n * format).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface DefaultGraph {\n  readonly type: 'default-graph';\n}\n\n/**\n * The JSON encoding of a ground term: exactly the RDF term of SPARQL 1.2\n * JSON results.\n *\n * @since 0.1.0\n * @category models\n */\nexport type GroundTerm = NamedNode | BlankNode | Literal | Triple;\n\n/**\n * The JSON encoding of any term, variables and the default graph included.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Term = GroundTerm | Variable | DefaultGraph;\n\n/**\n * The JSON encoding of a quad. `graph` is omitted for the default graph.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Quad {\n  readonly subject: NamedNode | BlankNode | Triple;\n  readonly predicate: NamedNode;\n  readonly object: GroundTerm;\n  readonly graph?: NamedNode | BlankNode;\n}\n\n/**\n * Schema of the JSON encoding of an IRI.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const NamedNodeSchema: Schema.Codec<NamedNode> = Schema.Struct({\n  type: Schema.Literal('uri'),\n  value: Schema.String,\n}).annotate({ identifier: 'JsonNamedNode' });\n\n/**\n * The type `NamedNodeSchema` decodes to (the same as `NamedNode`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type NamedNodeSchema = typeof NamedNodeSchema.Type;\n\n/**\n * Schema of the JSON encoding of a blank node.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const BlankNodeSchema: Schema.Codec<BlankNode> = Schema.Struct({\n  type: Schema.Literal('bnode'),\n  value: Schema.String,\n}).annotate({ identifier: 'JsonBlankNode' });\n\n/**\n * The type `BlankNodeSchema` decodes to (the same as `BlankNode`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type BlankNodeSchema = typeof BlankNodeSchema.Type;\n\n/**\n * Schema of the JSON encoding of a literal.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const LiteralSchema: Schema.Codec<Literal> = Schema.Struct({\n  type: Schema.Literals(['literal', 'typed-literal']),\n  value: Schema.String,\n  'xml:lang': Schema.optional(Schema.String),\n  'its:dir': Schema.optional(Schema.String),\n  datatype: Schema.optional(Schema.String),\n}).annotate({ identifier: 'JsonLiteral' });\n\n/**\n * The type `LiteralSchema` decodes to (the same as `Literal`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type LiteralSchema = typeof LiteralSchema.Type;\n\n/**\n * Schema of the JSON encoding of a triple term.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const TripleSchema: Schema.Codec<Triple> = Schema.Struct({\n  type: Schema.Literal('triple'),\n  value: Schema.Struct({\n    subject: Schema.suspend((): Schema.Codec<GroundTerm> => GroundTermSchema),\n    predicate: Schema.suspend((): Schema.Codec<GroundTerm> => GroundTermSchema),\n    object: Schema.suspend((): Schema.Codec<GroundTerm> => GroundTermSchema),\n  }),\n}).annotate({ identifier: 'JsonTriple' });\n\n/**\n * The type `TripleSchema` decodes to (the same as `Triple`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type TripleSchema = typeof TripleSchema.Type;\n\n/**\n * Schema of the JSON encoding of a variable.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const VariableSchema: Schema.Codec<Variable> = Schema.Struct({\n  type: Schema.Literal('variable'),\n  value: Schema.String,\n}).annotate({ identifier: 'JsonVariable' });\n\n/**\n * The type `VariableSchema` decodes to (the same as `Variable`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type VariableSchema = typeof VariableSchema.Type;\n\n/**\n * Schema of the JSON encoding of the default graph.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const DefaultGraphSchema: Schema.Codec<DefaultGraph> = Schema.Struct({\n  type: Schema.Literal('default-graph'),\n}).annotate({ identifier: 'JsonDefaultGraph' });\n\n/**\n * The type `DefaultGraphSchema` decodes to (the same as `DefaultGraph`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type DefaultGraphSchema = typeof DefaultGraphSchema.Type;\n\n/**\n * Schema of the JSON encoding of a ground term (the SPARQL 1.2 JSON results\n * term).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const GroundTermSchema: Schema.Codec<GroundTerm> = Schema.Union([\n  NamedNodeSchema,\n  BlankNodeSchema,\n  LiteralSchema,\n  TripleSchema,\n]).annotate({ identifier: 'JsonGroundTerm' });\n\n/**\n * The type `GroundTermSchema` decodes to (the same as `GroundTerm`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type GroundTermSchema = typeof GroundTermSchema.Type;\n\n/**\n * Schema of the JSON encoding of any term.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const TermSchema: Schema.Codec<Term> = Schema.Union([\n  NamedNodeSchema,\n  BlankNodeSchema,\n  LiteralSchema,\n  TripleSchema,\n  VariableSchema,\n  DefaultGraphSchema,\n]).annotate({ identifier: 'JsonTerm' });\n\n/**\n * The type `TermSchema` decodes to (the same as `Term`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type TermSchema = typeof TermSchema.Type;\n\n/**\n * Schema of the JSON encoding of a quad.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const QuadSchema: Schema.Codec<Quad> = Schema.Struct({\n  subject: Schema.Union([NamedNodeSchema, BlankNodeSchema, TripleSchema]),\n  predicate: NamedNodeSchema,\n  object: GroundTermSchema,\n  graph: Schema.optionalKey(Schema.Union([NamedNodeSchema, BlankNodeSchema])),\n}).annotate({ identifier: 'JsonQuad' });\n\n/**\n * The type `QuadSchema` decodes to (the same as `Quad`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type QuadSchema = typeof QuadSchema.Type;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsIA,MAAa,kBAA2C,OAAO,OAAO;CACpE,MAAM,OAAO,QAAQ,KAAK;CAC1B,OAAO,OAAO;AAChB,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,gBAAgB,CAAC;;;;;;;AAgB3C,MAAa,kBAA2C,OAAO,OAAO;CACpE,MAAM,OAAO,QAAQ,OAAO;CAC5B,OAAO,OAAO;AAChB,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,gBAAgB,CAAC;;;;;;;AAgB3C,MAAa,gBAAuC,OAAO,OAAO;CAChE,MAAM,OAAO,SAAS,CAAC,WAAW,eAAe,CAAC;CAClD,OAAO,OAAO;CACd,YAAY,OAAO,SAAS,OAAO,MAAM;CACzC,WAAW,OAAO,SAAS,OAAO,MAAM;CACxC,UAAU,OAAO,SAAS,OAAO,MAAM;AACzC,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,cAAc,CAAC;;;;;;;AAgBzC,MAAa,eAAqC,OAAO,OAAO;CAC9D,MAAM,OAAO,QAAQ,QAAQ;CAC7B,OAAO,OAAO,OAAO;EACnB,SAAS,OAAO,cAAwC,gBAAgB;EACxE,WAAW,OAAO,cAAwC,gBAAgB;EAC1E,QAAQ,OAAO,cAAwC,gBAAgB;CACzE,CAAC;AACH,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,aAAa,CAAC;;;;;;;AAgBxC,MAAa,iBAAyC,OAAO,OAAO;CAClE,MAAM,OAAO,QAAQ,UAAU;CAC/B,OAAO,OAAO;AAChB,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,eAAe,CAAC;;;;;;;AAgB1C,MAAa,qBAAiD,OAAO,OAAO,EAC1E,MAAM,OAAO,QAAQ,eAAe,EACtC,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,mBAAmB,CAAC;;;;;;;;AAiB9C,MAAa,mBAA6C,OAAO,MAAM;CACrE;CACA;CACA;CACA;AACF,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,iBAAiB,CAAC;;;;;;;AAgB5C,MAAa,aAAiC,OAAO,MAAM;CACzD;CACA;CACA;CACA;CACA;CACA;AACF,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,WAAW,CAAC;;;;;;;AAgBtC,MAAa,aAAiC,OAAO,OAAO;CAC1D,SAAS,OAAO,MAAM;EAAC;EAAiB;EAAiB;CAAY,CAAC;CACtE,WAAW;CACX,QAAQ;CACR,OAAO,OAAO,YAAY,OAAO,MAAM,CAAC,iBAAiB,eAAe,CAAC,CAAC;AAC5E,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,WAAW,CAAC"}

package/dist/TermJson.d.mts

@@ -0,0 +1,2 @@
+import { _ as TripleSchema, a as GroundTerm, c as LiteralSchema, d as Quad, f as QuadSchema, g as Triple, h as TermSchema, i as DefaultGraphSchema, l as NamedNode, n as BlankNodeSchema, o as GroundTermSchema, p as Term, r as DefaultGraph, s as Literal, t as BlankNode, u as NamedNodeSchema, v as Variable, y as VariableSchema } from "./TermJson-BOPe0yve.mjs";
+export { BlankNode, BlankNodeSchema, DefaultGraph, DefaultGraphSchema, GroundTerm, GroundTermSchema, Literal, LiteralSchema, NamedNode, NamedNodeSchema, Quad, QuadSchema, Term, TermSchema, Triple, TripleSchema, Variable, VariableSchema };

package/dist/TermJson.mjs

@@ -0,0 +1 @@
+export { t as BlankNodeSchema, n as DefaultGraphSchema, r as GroundTermSchema, i as LiteralSchema, a as NamedNodeSchema, o as QuadSchema, c as TermSchema, l as TripleSchema, u as VariableSchema } from "./TermJson-FAg3lvjl.mjs";

package/dist/TermSchema-Bn9CoaYA.mjs

@@ -0,0 +1,30 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { C as value, S as typedOneOf, _ as number, a as dateTime, b as term, c as float, d as langString, f as lexical, g as namedNode, h as make, i as date, l as integer, m as localized, n as bigint, o as decimal, p as literal, r as boolean, s as double, u as iri, v as resource, x as typed, y as string } from "./TermCodec-CDZiEztW.mjs";
+// src/sparql/TermSchema.ts
+var TermSchema_exports = /* @__PURE__ */ __exportAll({
+	bigint: () => bigint,
+	boolean: () => boolean,
+	date: () => date,
+	dateTime: () => dateTime,
+	decimal: () => decimal,
+	double: () => double,
+	float: () => float,
+	integer: () => integer,
+	iri: () => iri,
+	langString: () => langString,
+	lexical: () => lexical,
+	literal: () => literal,
+	localized: () => localized,
+	make: () => make,
+	namedNode: () => namedNode,
+	number: () => number,
+	resource: () => resource,
+	string: () => string,
+	term: () => term,
+	typed: () => typed,
+	typedOneOf: () => typedOneOf,
+	value: () => value
+});
+export { TermSchema_exports as t };
+
+//# sourceMappingURL=TermSchema-Bn9CoaYA.mjs.map

package/dist/TermSchema-Bn9CoaYA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TermSchema-Bn9CoaYA.mjs","names":[],"sources":["../src/sparql/TermSchema.ts"],"sourcesContent":["/**\n * Effect `Schema`s that decode RDF terms (as found in SPARQL solutions) to\n * JavaScript values and encode them back, for typed decoding of query\n * results with `QueryBuilder.decode`:\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: TermSchema.string,\n *   age: Schema.optional(TermSchema.integer),\n *   homepage: Schema.optional(TermSchema.iri),\n * })\n * // QueryBuilder.decode(query, Person) : Stream<{ name: string; age?: number; … }>\n * ```\n *\n * A re-export of core's `@thomasfosterau/effect-rdf/TermCodec`, which holds\n * the codecs and their documentation; nothing here depends on SPARQL.\n *\n * @since 0.1.0\n */\nexport * from '../TermCodec.ts';\n"],"mappings":""}

package/dist/TermSchema-DBO6MroX.d.mts

@@ -0,0 +1,6 @@
+import { C as typed, S as term, T as value, _ as make, a as boolean, b as resource, c as decimal, d as integer, f as iri, g as localized, h as literal, i as bigint, l as double, m as lexical, n as TermCodec, o as date, p as langString, s as dateTime, t as LocalizedString, u as float, v as namedNode, w as typedOneOf, x as string, y as number } from "./TermCodec-_03bDXr0.mjs";
+declare namespace TermSchema_d_exports {
+  export { LocalizedString, TermCodec, bigint, boolean, date, dateTime, decimal, double, float, integer, iri, langString, lexical, literal, localized, make, namedNode, number, resource, string, term, typed, typedOneOf, value };
+}
+export { TermSchema_d_exports as t };
+//# sourceMappingURL=TermSchema-DBO6MroX.d.mts.map