@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Model-DaMmxurZ.d.mts

@@ -0,0 +1,293 @@
+import { d as NamedNode, j as Variable, l as Literal, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+import { t as PrefixMap } from "./PrefixMap-BMlXrWNd.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";
+declare namespace Model_d_exports {
+  export { Collection, CollectionSchema, Document, Formula, FormulaSchema, N3Term, N3TermSchema, Statement, StatementSchema, TypeId, addStatements, blankNodes, collection, document, emptyFormula, formula, hasStatement, isCollection, isFormula, isGround, isN3Term, isStatement, mapTerms, statement, substitute, variables };
+}
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+declare const TypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+type TypeId = typeof TypeId;
+declare abstract class N3Base implements Equal.Equal, Pipeable {
+  #private;
+  readonly [TypeId]: TypeId;
+  abstract readonly _tag: string;
+  /** A canonical, N3-like serialisation used for equality and hashing. */
+  get key(): string;
+  protected abstract computeKey(): string;
+  /**
+   * Statements, collections and formulas override this to combine their
+   * parts' hashes, so that a formula deduplicating its statements builds no
+   * key; whatever the override, equal keys give equal hashes.
+   */
+  protected computeHash(): number;
+  /** RDF/JS-style alias of `_tag`. */
+  get termType(): this['_tag'];
+  equals(that: unknown): boolean;
+  [Equal.symbol](that: Equal.Equal): boolean;
+  [Hash.symbol](): number;
+  pipe(): unknown;
+  toString(): string;
+  toJSON(): unknown;
+  [NodeInspectSymbol](): string;
+}
+/**
+ * An N3 list (collection): an ordered, first-class sequence of terms,
+ * written `( a b c )`. The empty collection corresponds to `rdf:nil`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Collection extends N3Base {
+  readonly _tag: "Collection";
+  readonly items: ReadonlyArray<N3Term>;
+  constructor(items: ReadonlyArray<N3Term>);
+  protected computeHash(): number;
+  protected computeKey(): string;
+}
+/**
+ * An N3 statement: a triple whose subject, predicate and object may be any
+ * `N3Term`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Statement<out S extends N3Term = N3Term, out P extends N3Term = N3Term, out O extends N3Term = N3Term> extends N3Base {
+  readonly _tag: "Statement";
+  readonly subject: S;
+  readonly predicate: P;
+  readonly object: O;
+  constructor(subject: S, predicate: P, object: O);
+  protected computeHash(): number;
+  protected computeKey(): string;
+}
+/**
+ * An N3 formula (graph term): an unordered set of statements, written
+ * `{ ... }`. Duplicate statements are removed (when the statements are first
+ * read), and equality is set equality of the statements (blank node labels are compared
+ * literally; use `Isomorphism.isomorphic` for a blank-node-aware comparison).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class Formula extends N3Base {
+  #private;
+  readonly _tag: "Formula";
+  constructor(statements: Iterable<Statement>);
+  /**
+   * The statements, without duplicates, in the order first given. They are
+   * deduplicated the first time they are read, not when the formula is
+   * made, so a formula that is never read (a parse whose result is only
+   * checked for errors, a formula a rule discards) costs nothing to dedupe.
+   */
+  get statements(): ReadonlyArray<Statement>;
+  /** The sum of the statements' hashes: the same for the same set, whatever the order. */
+  protected computeHash(): number;
+  /** The number of statements in the formula. */
+  get size(): number;
+  protected computeKey(): string;
+  [Symbol.iterator](): Iterator<Statement>;
+}
+/**
+ * Any term that may appear in an N3 statement.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type N3Term = NamedNode | BlankNode | Literal | Variable | Collection | Formula;
+/**
+ * A parsed N3 document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Document {
+  /** The top-level formula: every statement asserted by the document. */
+  readonly formula: Formula;
+  /** The prefixes declared by the document (in declaration order). */
+  readonly prefixes: PrefixMap;
+  /** The final in-scope base IRI of the document, if any. */
+  readonly baseIri: string | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const statement: <S extends N3Term, P extends N3Term, O extends N3Term>(subject: S, predicate: P, object: O) => Statement<S, P, O>;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const formula: (statements?: Iterable<Statement>) => Formula;
+/**
+ * The empty formula `{}`.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const emptyFormula: Formula;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const collection: (items?: Iterable<N3Term>) => Collection;
+/**
+ * Creates a document from a formula.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const document: (formula: Formula, options?: {
+  readonly prefixes?: PrefixMap;
+  readonly baseIri?: string | undefined;
+}) => Document;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isFormula: (u: unknown) => u is Formula;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isCollection: (u: unknown) => u is Collection;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isStatement: (u: unknown) => u is Statement;
+/**
+ * Whether a value is an `N3Term` (a core IRI, blank node, literal or
+ * variable, or an N3 collection or formula).
+ *
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isN3Term: (u: unknown) => u is N3Term;
+/**
+ * Whether a term, statement or formula is free of variables (recursively).
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const isGround: (self: N3Term | Statement) => boolean;
+/**
+ * All distinct variables occurring in a term, statement or formula
+ * (including inside nested formulas and collections), in order of first
+ * occurrence.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const variables: (self: N3Term | Statement) => ReadonlyArray<Variable>;
+/**
+ * All distinct blank nodes occurring in a term, statement or formula
+ * (including inside nested formulas and collections).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const blankNodes: (self: N3Term | Statement) => ReadonlyArray<BlankNode>;
+/**
+ * Applies `f` to every atomic term (IRI, blank node, literal, variable),
+ * recursing into collections, statements and nested formulas.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+declare function mapTerms<T extends N3Term | Statement>(self: T, f: (term: NamedNode | BlankNode | Literal | Variable) => N3Term): T extends Statement ? Statement : T extends Formula ? Formula : N3Term;
+/**
+ * Replaces variables by the terms bound to them (by variable name); unbound
+ * variables are kept.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+declare function substitute<T extends N3Term | Statement>(self: T, bindings: ReadonlyMap<string, N3Term>): T extends Statement ? Statement : T extends Formula ? Formula : N3Term;
+/**
+ * Adds statements to a formula.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+declare const addStatements: (self: Formula, statements: Iterable<Statement>) => Formula;
+/**
+ * Whether a formula contains a statement.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const hasStatement: (self: Formula, statement: Statement) => boolean;
+/**
+ * Schema of a formula; its JSON codec is
+ * `{ "type": "formula", "statements": [{ subject, predicate, object }, …] }`
+ * over JSON N3 terms.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const FormulaSchema: Schema.declare<Formula>;
+/**
+ * The value a `FormulaSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type FormulaSchema = typeof FormulaSchema.Type;
+/**
+ * Schema of a collection; its JSON codec is
+ * `{ "type": "collection", "items": [ … ] }` over JSON N3 terms.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const CollectionSchema: Schema.declare<Collection>;
+/**
+ * The value a `CollectionSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type CollectionSchema = typeof CollectionSchema.Type;
+/**
+ * Schema of a statement; its JSON codec is `{ subject, predicate, object }`
+ * over JSON N3 terms.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const StatementSchema: Schema.declare<Statement>;
+/**
+ * The value a `StatementSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type StatementSchema = typeof StatementSchema.Type;
+/**
+ * Schema of any N3 term; its JSON codec is core's `TermJson` term (IRIs,
+ * blank nodes, literals, variables) or a JSON collection or formula.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const N3TermSchema: Schema.declare<N3Term>;
+/**
+ * The value a `N3TermSchema` decodes to.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type N3TermSchema = typeof N3TermSchema.Type;
+export { isStatement as C, variables as D, substitute as E, isN3Term as S, statement as T, formula as _, FormulaSchema as a, isFormula as b, N3TermSchema as c, TypeId as d, addStatements as f, emptyFormula as g, document as h, Formula as i, Statement as l, collection as m, CollectionSchema as n, Model_d_exports as o, blankNodes as p, Document as r, N3Term as s, Collection as t, StatementSchema as u, hasStatement as v, mapTerms as w, isGround as x, isCollection as y };
+//# sourceMappingURL=Model-DaMmxurZ.d.mts.map