@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Term-B_4ezyXq.d.mts

@@ -0,0 +1,619 @@
+import { a as GroundTerm$1, d as Quad$1, p as Term$1 } from "./TermJson-BOPe0yve.mjs";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { NodeInspectSymbol } from "effect/Inspectable";
+import { Pipeable } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as equivalence from "effect/Equivalence";
+import * as order from "effect/Order";
+declare namespace Term_d_exports {
+  export { BlankNode, BlankNodeSchema, DefaultGraph, Direction, Equivalence, Graph, GroundTerm, GroundTermSchema, Literal, LiteralSchema, NamedNode, NamedNodeSchema, Object$1 as Object, Order, PatternTerm, Predicate, Quad, QuadEquivalence, QuadOrder, QuadSchema, RDF_DIR_LANG_STRING, RDF_LANG_STRING, Resource, Subject, Term, TermSchema, Triple, TripleSchema, TypeId, Variable, VariableSchema, XSD_STRING, blankNode, compare, compareQuads, defaultGraph, escapeIri, escapeString, fromJson, hasBlankNodes, isBlankNode, isDefaultGraph, isGraph, isGround, isGroundTerm, isLanguageTagged, isLiteral, isNamedNode, isObject, isQuad, isResource, isSubject, isTerm, isTriple, isVariable, isWellFormed, literal, mapTerms, namedNode, quad, quadFromJson, quadToJson, toJson, toQuad, triple, variable };
+}
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+declare const TypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+type TypeId = typeof TypeId;
+/**
+ * The base direction of a directional language-tagged string.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Direction = 'ltr' | 'rtl';
+declare abstract class TermBase implements Equal.Equal, Pipeable {
+  #private;
+  readonly [TypeId]: TypeId;
+  abstract readonly _tag: string;
+  /** The canonical N-Triples serialisation of this term. */
+  get key(): string;
+  protected abstract computeKey(): string;
+  /** RDF/JS compatible alias of `_tag`. */
+  get termType(): this['_tag'];
+  /** RDF/JS compatible equality. */
+  equals(that: unknown): boolean;
+  [Equal.symbol](that: Equal.Equal): boolean;
+  [Hash.symbol](): number;
+  /**
+   * The hash, consistent with `key` (terms with equal keys have equal
+   * hashes). IRIs, blank nodes, variables and literals hash their parts, so
+   * that hashing one builds no key.
+   */
+  protected computeHash(): number;
+  pipe(): unknown;
+  toString(): string;
+  toJSON(): {
+    _tag: string;
+    value: string;
+  };
+  [NodeInspectSymbol](): string;
+}
+/**
+ * An IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class NamedNode<out Iri extends string = string> extends TermBase {
+  readonly _tag: "NamedNode";
+  readonly value: Iri;
+  constructor(value: Iri);
+  protected computeKey(): string;
+  protected computeHash(): number;
+}
+/**
+ * A blank node. Labels are scoped to the dataset or document that contains
+ * them.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class BlankNode extends TermBase {
+  readonly _tag: "BlankNode";
+  readonly value: string;
+  constructor(value: string);
+  protected computeKey(): string;
+  protected computeHash(): number;
+}
+/**
+ * A literal. Language-tagged strings have datatype `rdf:langString`, and
+ * directional language-tagged strings (RDF 1.2) have datatype
+ * `rdf:dirLangString`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Literal extends TermBase {
+  readonly _tag: "Literal";
+  readonly value: string;
+  readonly datatype: NamedNode;
+  readonly language: string;
+  readonly direction: Direction | undefined;
+  constructor(value: string, datatype: NamedNode, language?: string, direction?: Direction);
+  protected computeKey(): string;
+  protected computeHash(): number;
+}
+/**
+ * A SPARQL query variable. Variables never appear in RDF data; they are used
+ * in quad patterns.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Variable<out Name extends string = string> extends TermBase {
+  readonly _tag: "Variable";
+  readonly value: Name;
+  constructor(value: Name);
+  protected computeKey(): string;
+  protected computeHash(): number;
+}
+/**
+ * The default graph of a dataset.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class DefaultGraph extends TermBase {
+  readonly _tag: "DefaultGraph";
+  readonly value: "";
+  protected computeKey(): string;
+}
+/**
+ * An RDF triple. Triples are also terms (RDF 1.2 "triple terms", RDF-star
+ * "quoted triples") and may appear in the subject or object position of
+ * other triples.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Triple<out S extends Subject = Subject, out P extends Predicate = Predicate, out O extends Object$1 = Object$1> extends TermBase {
+  readonly _tag: "Triple";
+  readonly subject: S;
+  readonly predicate: P;
+  readonly object: O;
+  constructor(subject: S, predicate: P, object: O);
+  protected computeKey(): string;
+  /** Always the default graph: a triple term carries no graph name. */
+  get graph(): DefaultGraph;
+}
+/**
+ * An RDF quad: a triple together with the graph that contains it.
+ *
+ * `Quad` is a statement, not a term; use `Triple` for triple terms.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Quad<out S extends Subject = Subject, out P extends Predicate = Predicate, out O extends Object$1 = Object$1, out G extends Graph = Graph> implements Equal.Equal, Pipeable {
+  #private;
+  readonly _tag: "Quad";
+  readonly subject: S;
+  readonly predicate: P;
+  readonly object: O;
+  readonly graph: G;
+  constructor(subject: S, predicate: P, object: O, graph: G);
+  /** The canonical N-Quads statement (without the trailing ` .`). */
+  get key(): string;
+  /** The triple of this quad, without its graph. */
+  get triple(): Triple<S, P, O>;
+  equals(that: unknown): boolean;
+  [Equal.symbol](that: Equal.Equal): boolean;
+  [Hash.symbol](): number;
+  pipe(): unknown;
+  toString(): string;
+  toJSON(): {
+    _tag: "Quad";
+    value: string;
+  };
+  [NodeInspectSymbol](): string;
+}
+/**
+ * Any RDF term.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | Triple;
+/**
+ * Terms allowed in the subject position of RDF data.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Subject = NamedNode | BlankNode | Triple;
+/**
+ * Terms allowed in the predicate position of RDF data.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Predicate = NamedNode;
+/**
+ * Terms allowed in the object position of RDF data.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Object$1 = NamedNode | BlankNode | Literal | Triple;
+/**
+ * Terms allowed as graph names.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Graph = NamedNode | BlankNode | DefaultGraph;
+/**
+ * Ground terms: terms that may appear in RDF data (everything except
+ * variables and the default graph marker).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GroundTerm = NamedNode | BlankNode | Literal | Triple;
+/**
+ * IRIs and blank nodes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Resource = NamedNode | BlankNode;
+/**
+ * A term or variable in a quad pattern.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type PatternTerm<T extends Term> = T | Variable;
+/**
+ * The singleton default graph.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const defaultGraph: DefaultGraph;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const namedNode: <const Iri extends string>(iri: Iri) => NamedNode<Iri>;
+/**
+ * Creates a blank node. When no label is given a fresh, process-unique label
+ * is generated.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const blankNode: (label?: string) => BlankNode;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const variable: <const Name extends string>(name: Name) => Variable<Name>;
+/** @internal */
+declare const XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+/** @internal */
+declare const RDF_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
+/** @internal */
+declare const RDF_DIR_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString";
+/**
+ * Creates a literal.
+ *
+ * - `literal("x")` is an `xsd:string`
+ * - `literal("x", "en")` is a language-tagged string
+ * - `literal("x", { language: "ar", direction: "rtl" })` is a directional
+ *   language-tagged string
+ * - `literal("1", xsd.integer)` is a typed literal
+ *
+ * Language tags are normalised to lower case.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const literal: (value: string, languageOrDatatype?: string | NamedNode | {
+  readonly language: string;
+  readonly direction?: Direction | undefined;
+}) => Literal;
+/**
+ * Creates a triple (and triple term).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const triple: <S extends Subject, P extends Predicate, O extends Object$1>(subject: S, predicate: P, object: O) => Triple<S, P, O>;
+/**
+ * Creates a quad. The graph defaults to the default graph.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare function quad<S extends Subject, P extends Predicate, O extends Object$1>(subject: S, predicate: P, object: O): Quad<S, P, O, DefaultGraph>;
+declare function quad<S extends Subject, P extends Predicate, O extends Object$1, G extends Graph>(subject: S, predicate: P, object: O, graph: G): Quad<S, P, O, G>;
+/**
+ * Converts a triple to a quad in the given graph (default graph when omitted).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const toQuad: <S extends Subject, P extends Predicate, O extends Object$1, G extends Graph = DefaultGraph>(self: Triple<S, P, O>, graph?: G) => Quad<S, P, O, G>;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isTerm: (u: unknown) => u is Term;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isNamedNode: (u: unknown) => u is NamedNode;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isBlankNode: (u: unknown) => u is BlankNode;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isLiteral: (u: unknown) => u is Literal;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isVariable: (u: unknown) => u is Variable;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isDefaultGraph: (u: unknown) => u is DefaultGraph;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isTriple: (u: unknown) => u is Triple;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isQuad: (u: unknown) => u is Quad;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isResource: (u: unknown) => u is Resource;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isSubject: (u: unknown) => u is Subject;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isObject: (u: unknown) => u is Object$1;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isGraph: (u: unknown) => u is Graph;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isGroundTerm: (u: unknown) => u is GroundTerm;
+/**
+ * Whether a literal is a (possibly directional) language-tagged string.
+ *
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isLanguageTagged: (self: Literal) => boolean;
+/**
+ * Whether a triple or quad mentions a blank node anywhere, including inside
+ * nested triple terms.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const hasBlankNodes: (self: Term | Quad) => boolean;
+/**
+ * Whether a term or quad is free of variables.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const isGround: (self: Term | Quad) => boolean;
+/**
+ * Applies `f` to every term in a quad or triple term (recursively through
+ * nested triple terms). `f` maps each term to one of the same kind; a
+ * result that cannot stand in its position (a literal for a subject, say)
+ * leaves the original term there.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+declare function mapTerms<T extends Quad | Triple>(self: T, f: (term: NamedNode | BlankNode | Literal | DefaultGraph) => Term): T;
+/**
+ * A total ordering of terms suitable for deterministic serialisation:
+ * default graph < blank nodes < IRIs < literals < triple terms < variables,
+ * then by canonical key.
+ *
+ * @since 0.1.0
+ * @category ordering
+ */
+declare const compare: (a: Term, b: Term) => -1 | 0 | 1;
+/**
+ * Orders quads by graph, subject, predicate, object.
+ *
+ * @since 0.1.0
+ * @category ordering
+ */
+declare const compareQuads: (a: Quad, b: Quad) => -1 | 0 | 1;
+/**
+ * The `compare` ordering of terms as an Effect `Order`, for `Array.sort`,
+ * `Order.mapInput` and the other `Order` combinators.
+ *
+ * @since 0.1.0
+ * @category ordering
+ */
+declare const Order: order.Order<Term>;
+/**
+ * The `compareQuads` ordering (graph, subject, predicate, object) as an
+ * Effect `Order`.
+ *
+ * @since 0.1.0
+ * @category ordering
+ */
+declare const QuadOrder: order.Order<Quad>;
+/**
+ * Term equality as an Effect `Equivalence`: the same as `Equal.equals`
+ * (equal canonical keys).
+ *
+ * @since 0.1.0
+ * @category equivalence
+ */
+declare const Equivalence: equivalence.Equivalence<Term>;
+/**
+ * Quad equality as an Effect `Equivalence`: the same as `Equal.equals`.
+ *
+ * @since 0.1.0
+ * @category equivalence
+ */
+declare const QuadEquivalence: equivalence.Equivalence<Quad>;
+/**
+ * Escapes a string for use inside a double-quoted N-Triples / Turtle string
+ * literal, using the canonical N-Triples escapes.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const escapeString: (value: string) => string;
+/**
+ * Escapes characters that are not allowed inside `<...>` IRI references.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const escapeIri: (value: string) => string;
+/**
+ * Encodes a term as JSON: the SPARQL 1.2 JSON results term for a ground term,
+ * plus the `variable` and `default-graph` extensions (see `TermJson`).
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare function toJson(self: GroundTerm): GroundTerm$1;
+declare function toJson(self: Term): Term$1;
+/**
+ * Decodes a JSON term (see `TermJson`). Like a SPARQL JSON results reader,
+ * it trusts the positions of a triple term; use `isWellFormed`, or decode
+ * through `Schema.toCodecJson(TermSchema)`, to check them.
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare function fromJson(json: GroundTerm$1): GroundTerm;
+declare function fromJson(json: Term$1): Term;
+/**
+ * Encodes a quad as JSON; `graph` is omitted for the default graph.
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare const quadToJson: (self: Quad) => Quad$1;
+/**
+ * Decodes a JSON quad; a missing `graph` is the default graph. Triple terms
+ * are trusted as in `fromJson`.
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare const quadFromJson: (json: Quad$1) => Quad;
+/**
+ * Whether every triple term inside a term or quad, at any depth, has a
+ * subject (IRI, blank node or triple term), an IRI predicate and an object
+ * (anything but a variable or the default graph) — always true for terms
+ * built with `triple` and `quad`.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const isWellFormed: (self: Term | Quad) => boolean;
+/**
+ * Schema of an IRI term; its JSON codec is `TermJson.NamedNode`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const NamedNodeSchema: Schema.declare<NamedNode>;
+/**
+ * The type `NamedNodeSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type NamedNodeSchema = typeof NamedNodeSchema.Type;
+/**
+ * Schema of a blank node; its JSON codec is `TermJson.BlankNode`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const BlankNodeSchema: Schema.declare<BlankNode>;
+/**
+ * The type `BlankNodeSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type BlankNodeSchema = typeof BlankNodeSchema.Type;
+/**
+ * Schema of a literal; its JSON codec is `TermJson.Literal`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const LiteralSchema: Schema.declare<Literal>;
+/**
+ * The type `LiteralSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type LiteralSchema = typeof LiteralSchema.Type;
+/**
+ * Schema of a variable; its JSON codec is `TermJson.Variable`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const VariableSchema: Schema.declare<Variable>;
+/**
+ * The type `VariableSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type VariableSchema = typeof VariableSchema.Type;
+/**
+ * Schema of a triple term; its JSON codec is `TermJson.Triple`, and decoding rejects positions that don't fit RDF.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const TripleSchema: Schema.declare<Triple>;
+/**
+ * The type `TripleSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type TripleSchema = typeof TripleSchema.Type;
+/**
+ * Schema of a quad; its JSON codec is `TermJson.Quad`, with `graph` omitted for the default graph.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const QuadSchema: Schema.declare<Quad>;
+/**
+ * The type `QuadSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type QuadSchema = typeof QuadSchema.Type;
+/**
+ * Schema of any term; its JSON codec is `TermJson.Term`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const TermSchema: Schema.declare<Term>;
+/**
+ * The type `TermSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type TermSchema = typeof TermSchema.Type;
+/**
+ * Schema of a ground term (no variables or default graph); its JSON codec is `TermJson.GroundTerm`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const GroundTermSchema: Schema.declare<GroundTerm>;
+/**
+ * The type `GroundTermSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type GroundTermSchema = typeof GroundTermSchema.Type;
+export { isSubject as $, TypeId as A, fromJson as B, Resource as C, Term_d_exports as D, TermSchema as E, compare as F, isGround as G, isBlankNode as H, compareQuads as I, isLiteral as J, isGroundTerm as K, defaultGraph as L, VariableSchema as M, XSD_STRING as N, Triple as O, blankNode as P, isResource as Q, escapeIri as R, RDF_LANG_STRING as S, Term as T, isDefaultGraph as U, hasBlankNodes as V, isGraph as W, isObject as X, isNamedNode as Y, isQuad as Z, Quad as _, Equivalence as a, mapTerms as at, QuadSchema as b, GroundTermSchema as c, quadFromJson as ct, NamedNode as d, toQuad as dt, isTerm as et, NamedNodeSchema as f, triple as ft, Predicate as g, PatternTerm as h, Direction as i, literal as it, Variable as j, TripleSchema as k, Literal as l, quadToJson as lt, Order as m, BlankNodeSchema as n, isVariable as nt, Graph as o, namedNode as ot, Object$1 as p, variable as pt, isLanguageTagged as q, DefaultGraph as r, isWellFormed as rt, GroundTerm as s, quad as st, BlankNode as t, isTriple as tt, LiteralSchema as u, toJson as ut, QuadEquivalence as v, Subject as w, RDF_DIR_LANG_STRING as x, QuadOrder as y, escapeString as z };
+//# sourceMappingURL=Term-B_4ezyXq.d.mts.map