ldkit 2.3.0 → 2.5.0

package/script/library/lens/lens.d.ts

@@ -0,0 +1,431 @@
+import type { IRI, RDF } from "../rdf.js";
+import { type Options } from "../options.js";
+import { type Identity, type Schema, type SchemaInterface, type SchemaSearchInterface, type SchemaUpdateInterface } from "../schema/mod.js";
+import type { Entity, Unite } from "./types.js";
+/**
+ * Creates an instance of Lens that lets you query and update RDF data
+ * via data schema using TypeScript native data types.
+ *
+ * In order to create a Lens instance, you need to provide a data schema
+ * that describes the data model which serves to translate data between
+ * Linked Data and TypeScript native types (see {@link Schema} for details).
+ *
+ * You can also pass a set of options for LDkit and a query engine that
+ * specify the data source, preferred language, etc. (see {@link Options} for details).
+ *
+ * @example
+ * ```typescript
+ * import { createLens, type Options } from "ldkit";
+ * import { dbo, rdfs, xsd } from "ldkit/namespaces";
+ *
+ * // Create options for query engine
+ * const options: Options = {
+ *   sources: ["https://dbpedia.org/sparql"], // SPARQL endpoint
+ *   language: "en", // Preferred language
+ * };
+ *
+ * // Create a schema
+ * const PersonSchema = {
+ *   "@type": dbo.Person,
+ *   name: rdfs.label,
+ *   abstract: dbo.abstract,
+ *   birthDate: {
+ *     "@id": dbo.birthDate,
+ *     "@type": xsd.date,
+ *   },
+ * } as const;
+ *
+ * // Create a resource using the data schema and options above
+ * const Persons = createLens(PersonSchema, options);
+ *
+ * // List some persons
+ * const persons = await Persons.find({ take: 10 });
+ * for (const person of persons) {
+ *   console.log(person.name); // string
+ *   console.log(person.birthDate); // Date
+ * }
+ *
+ * // Get a particular person identified by IRI
+ * const ada = await Persons.findByIri("http://dbpedia.org/resource/Ada_Lovelace");
+ * console.log(ada?.name); // string "Ada Lovelace"
+ * console.log(ada?.birthDate); // Date object of 1815-12-10
+ * ```
+ *
+ * @param schema data schema which extends {@link Schema}
+ * @param options optional {@link Options} - contains LDkit and query engine configuration
+ * @returns Lens instance that provides interface to Linked Data based on the schema
+ */
+export declare function createLens<T extends Schema>(schema: T, options?: Options): Lens<T>;
+/**
+ * Lens provides an interface to Linked Data based on the data schema.
+ *
+ * For the best developer experience, use the {@link createLens} function to create the instance.
+ */
+export declare class Lens<T extends Schema> {
+    private readonly schema;
+    private readonly options;
+    private readonly engine;
+    private readonly queryBuilder;
+    constructor(schema: T, options?: Options);
+    private decode;
+    private log;
+    /**
+     * Returns the total number of entities corresponding to the data schema.
+     * Optionally, you can specify search criteria and a maximum number of results to count.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Count all persons
+     * const count = await Persons.count(); // number
+     *
+     * // Count all persons with name that starts with "Ada"
+     * const adaCount = await Persons.count({
+     *   where: {
+     *     name: { $strStarts: "Ada" },
+     *   },
+     * });
+     *
+     * // Count all persons, but limit the result to 100
+     * const limitedCount = await Persons.count({ max: 100 });
+     * ```
+     *
+     * @param options Search criteria and maximum number of results to count
+     * @returns total number of entities corresponding to the data schema
+     */
+    count(options?: {
+        where?: SchemaSearchInterface<T>;
+        max?: number;
+    }): Promise<number>;
+    /**
+     * Find entities with a custom SPARQL query.
+     *
+     * The query must be a CONSTRUCT query, and the root nodes must be of type `ldkit:Resource`.
+     * So that the decoder can decode the results, the query must also return all properties
+     * according to the data schema.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { ldkit, schema } from "ldkit/namespaces";
+     * import { CONSTRUCT } from "ldkit/sparql";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Query to find all persons named "Doe"
+     * const query = CONSTRUCT`?s a <${ldkit.Resource}>; <${schema.name}> ?name`
+     *   .WHERE`?s <${schema.name}> ?name; <${schema.familyName}> "Doe"`.build();
+     *
+     * // Find all persons that match the custom query
+     * const doePersons = await Persons.query(query);
+     * ```
+     *
+     * @param sparqlConstructQuery CONSTRUCT SPARQL query
+     * @returns Found entities
+     */
+    query(sparqlConstructQuery: string): Promise<Unite<SchemaInterface<T>>[]>;
+    /**
+     * Find entities that match the given search criteria.
+     *
+     * The search criteria is a JSON object that may contain properties from the data schema.
+     * In addition you can specify how many results to return and how many to skip
+     * for pagination purposes.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Find 100 persons with name that starts with "Ada"
+     * const persons = await Persons.find({
+     *   where: {
+     *     name: { $strStarts: "Ada" },
+     *   },
+     *   take: 100,
+     * });
+     * ```
+     *
+     * @param options Search criteria and pagination options
+     * @returns entities that match the given search criteria
+     */
+    find(options?: {
+        where?: SchemaSearchInterface<T> | string | RDF.Quad[];
+        take?: number;
+        skip?: number;
+    }): Promise<Unite<SchemaInterface<T>>[]>;
+    /**
+     * Find one entity that matches the given search criteria.
+     *
+     * The search criteria is a JSON object that may contain properties from the data schema.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Find one person with name that starts with "Ada"
+     * const person = await Persons.findOne({
+     *   name: { $strStarts: "Ada" },
+     * });
+     * ```
+     *
+     * @param options Search criteria and pagination options
+     * @returns entities that match the given search criteria
+     */
+    findOne(where?: SchemaSearchInterface<T>): Promise<Unite<SchemaInterface<T>> | null>;
+    /**
+     * Find a single entity that matches the given IRI.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Get a particular person identified by IRI
+     * const ada = await Persons.findByIri("http://dbpedia.org/resource/Ada_Lovelace");
+     * console.log(ada?.name); // string "Ada Lovelace"
+     * ```
+     *
+     * @param iri IRI of the entity to find
+     * @returns Entity if found, null otherwise
+     */
+    findByIri(iri: IRI): Promise<Unite<SchemaInterface<T>> | null>;
+    /**
+     * Find entities that match the given IRIs.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Get specific persons identified by IRIs
+     * const matches = await Persons.findByIris([
+     *   "http://dbpedia.org/resource/Ada_Lovelace",
+     *   "http://dbpedia.org/resource/Alan_Turing"
+     * ]);
+     * console.log(matches[0].name); // string "Ada Lovelace"
+     * console.log(matches[1].name); // string "Alan Turing"
+     * ```
+     *
+     * @param iris IRIs of the entities to find
+     * @returns Array of found entities, empty array if there are no matches
+     */
+    findByIris(iris: IRI[]): Promise<Unite<SchemaInterface<T>>[]>;
+    private updateQuery;
+    /**
+     * Inserts one or more entities to the data store.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Insert a new person
+     * await Persons.insert({
+     *   $id: "http://example.org/Alan_Turing",
+     *   name: "Alan Turing",
+     * });
+     * ```
+     *
+     * @param entities Entities to insert
+     * @returns Nothing
+     */
+    insert(...entities: Entity<SchemaInterface<T>>[]): Promise<void>;
+    /**
+     * Inserts raw RDF quads to the data store.
+     *
+     * This method is useful when you need to insert data that is not covered by the data schema.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     * import { DataFactory } from "ldkit/rdf";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Create a custom quad to insert
+     * const df = new DataFactory();
+     * const quad = df.quad(
+     *   df.namedNode("http://example.org/Alan_Turing"),
+     *   df.namedNode("http://schema.org/name"),
+     *   df.literal("Alan Turing"),
+     * );
+     *
+     * // Insert the quad
+     * await Persons.insertData(quad);
+     * ```
+     *
+     * @param quads Quads to insert to the data store
+     * @returns Nothing
+     */
+    insertData(...quads: RDF.Quad[]): Promise<void>;
+    /**
+     * Updates one or more entities in the data store.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Update Alan Turing's name
+     * await Persons.update({
+     *   $id: "http://example.org/Alan_Turing",
+     *   name: "Not Alan Turing",
+     * });
+     * ```
+     *
+     * @param entities Partial entities to update
+     * @returns Nothing
+     */
+    update(...entities: SchemaUpdateInterface<T>[]): Promise<void>;
+    /**
+     * Deletes one or more entities from the data store.
+     *
+     * This method accepts IRIs of the entities to delete and attemps
+     * to delete all triples from the database that corresponds to
+     * the data schema. Other triples that are not covered by the data
+     * schema will not be deleted.
+     *
+     * If you need to have more control of what triples to delete,
+     * use {@link deleteData} instead.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Delete a person
+     * await Persons.delete("http://example.org/Alan_Turing");
+     * ```
+     *
+     * @param identities Identities or IRIs of the entities to delete
+     * @returns Nothing
+     */
+    delete(...identities: Identity[] | IRI[]): Promise<void>;
+    /**
+     * Deletes raw RDF quads from the data store.
+     *
+     * This method is useful when you need to delete data that is not covered by the data schema.
+     *
+     * @example
+     * ```typescript
+     * import { createLens } from "ldkit";
+     * import { schema } from "ldkit/namespaces";
+     * import { DataFactory } from "ldkit/rdf";
+     *
+     * // Create a schema
+     * const PersonSchema = {
+     *   "@type": schema.Person,
+     *   name: schema.name,
+     * } as const;
+     *
+     * // Create a resource using the data schema and context above
+     * const Persons = createLens(PersonSchema);
+     *
+     * // Create a custom quad to insert
+     * const df = new DataFactory();
+     * const quad = df.quad(
+     *   df.namedNode("http://example.org/Alan_Turing"),
+     *   df.namedNode("http://schema.org/name"),
+     *   df.literal("Alan Turing"),
+     * );
+     *
+     * // Delete the quad
+     * await Persons.deleteData(quad);
+     * ```
+     *
+     * @param quads Quads to delete from the data store
+     * @returns Nothing
+     */
+    deleteData(...quads: RDF.Quad[]): Promise<void>;
+}
+//# sourceMappingURL=lens.d.ts.map

package/script/library/lens/lens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lens.d.ts","sourceRoot":"","sources":["../../../src/library/lens/lens.ts"],"names":[],"mappings":"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"}

package/script/library/lens/lens.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lens = exports.createLens = void 0;
+exports.Lens = void 0;
+exports.createLens = createLens;
 const options_js_1 = require("../options.js");
 const mod_js_1 = require("../schema/mod.js");
 const decoder_js_1 = require("../decoder.js");
@@ -62,7 +63,6 @@ const query_engine_proxy_js_1 = require("../engine/query_engine_proxy.js");
 function createLens(schema, options) {
     return new Lens(schema, options);
 }
-exports.createLens = createLens;
 /**
  * Lens provides an interface to Linked Data based on the data schema.
  *
@@ -108,6 +108,7 @@ class Lens {
     }
     /**
      * Returns the total number of entities corresponding to the data schema.
+     * Optionally, you can specify search criteria and a maximum number of results to count.
      *
      * @example
      * ```typescript
@@ -125,12 +126,27 @@ class Lens {
      *
      * // Count all persons
      * const count = await Persons.count(); // number
+     *
+     * // Count all persons with name that starts with "Ada"
+     * const adaCount = await Persons.count({
+     *   where: {
+     *     name: { $strStarts: "Ada" },
+     *   },
+     * });
+     *
+     * // Count all persons, but limit the result to 100
+     * const limitedCount = await Persons.count({ max: 100 });
      * ```
      *
+     * @param options Search criteria and maximum number of results to count
      * @returns total number of entities corresponding to the data schema
      */
-    async count(max) {
-        const q = this.queryBuilder.countQuery(max);
+    async count(options = {}) {
+        const { where, max } = {
+            where: {},
+            ...options,
+        };
+        const q = this.queryBuilder.countQuery(where, max);
         this.log(q);
         const bindings = await this.engine.queryBindings(q);
         return parseInt(bindings[0].get("count").value);

package/script/library/lens/mod.d.ts

@@ -0,0 +1,2 @@
+export * from "./lens.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/library/lens/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/library/lens/mod.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/script/library/lens/query_builder.d.ts

@@ -0,0 +1,23 @@
+import { type Options } from "../options.js";
+import { type ExpandedSchema, type SearchSchema } from "../schema/mod.js";
+import { type IRI, type RDF } from "../rdf.js";
+import { type Entity } from "./types.js";
+export declare class QueryBuilder {
+    private readonly schema;
+    private readonly options;
+    private readonly df;
+    constructor(schema: ExpandedSchema, options: Options);
+    private getResourceSignature;
+    private entitiesToQuads;
+    private getShape;
+    countQuery(where: SearchSchema, max?: number): string;
+    getQuery(where: string | RDF.Quad[] | undefined, limit: number, offset: number): string;
+    getSearchQuery(where: SearchSchema, limit: number, offset: number): string;
+    getByIrisQuery(iris: IRI[], where?: SearchSchema): string;
+    insertQuery(entities: Entity[]): string;
+    insertDataQuery(quads: RDF.Quad[]): string;
+    deleteQuery: (iris: IRI[]) => string;
+    deleteDataQuery(quads: RDF.Quad[]): string;
+    updateQuery(entities: Entity[]): string;
+}
+//# sourceMappingURL=query_builder.d.ts.map

package/script/library/lens/query_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query_builder.d.ts","sourceRoot":"","sources":["../../../src/library/lens/query_builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAAe,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAM5D,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAYzC,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAkB;gBAEzB,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO;IAMpD,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,QAAQ;IA4FhB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,MAAM;IAW5C,QAAQ,CACN,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,GAAG,SAAS,EACtC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM;IAsBhB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAyBjE,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,KAAK,CAAC,EAAE,YAAY;IAchD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE;IAK9B,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE;IAIjC,WAAW,SAAU,GAAG,EAAE,YAOxB;IAEF,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE;IAIjC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE;CAU/B"}

package/script/library/lens/query_builder.js

@@ -113,8 +113,8 @@ class QueryBuilder {
         populateConditionsRecursive(this.schema, mainVar, searchSchema);
         return conditions;
     }
-    countQuery(max) {
-        const quads = this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes);
+    countQuery(where, max) {
+        const quads = this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes, where);
         const innerQuery = max === undefined
             ? quads
             : (0, mod_js_2.SELECT) `?iri`.WHERE `${quads}`.LIMIT(max);

package/script/library/lens/search_helper.d.ts

@@ -0,0 +1,22 @@
+import { type SparqlValue } from "../sparql/mod.js";
+import { type ExpandedProperty, type SearchSchema } from "../schema/mod.js";
+export declare class SearchHelper {
+    private readonly property;
+    private readonly propertyType;
+    private readonly varName;
+    private readonly searchSchema;
+    private df;
+    readonly sparqlValues: SparqlValue[];
+    constructor(property: ExpandedProperty, varName: string, searchSchema: SearchSchema);
+    process(): void;
+    private processOperators;
+    private processStringFunctions;
+    private processRegex;
+    private processLangMatches;
+    private processArrayFunctions;
+    private processFilter;
+    private addFilter;
+    private encode;
+    private isPlainObject;
+}
+//# sourceMappingURL=search_helper.d.ts.map

package/script/library/lens/search_helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search_helper.d.ts","sourceRoot":"","sources":["../../../src/library/lens/search_helper.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAI5E,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAE5C,OAAO,CAAC,EAAE,CAEP;IAEH,SAAgB,YAAY,EAAE,WAAW,EAAE,CAAM;gBAG/C,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,YAAY;IAUrB,OAAO;IASd,OAAO,CAAC,gBAAgB;IAsBxB,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,qBAAqB;IAmB7B,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,aAAa;CAUtB"}

package/script/library/lens/types.d.ts

@@ -0,0 +1,9 @@
+import type { Identity } from "../schema/mod.js";
+export type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & Identity;
+export type DeepPartial<T> = T extends Record<string, unknown> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type Unite<T> = T extends Record<string, unknown> ? {
+    [Key in keyof T]: T[Key];
+} : T;
+//# sourceMappingURL=types.d.ts.map

package/script/library/lens/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/library/lens/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAC1D,WAAW,CAAC,CAAC,CAAC,GACd,QAAQ,CAAC;AAEb,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC1D;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACtC,CAAC,CAAC;AAEN,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACpD;KAAG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;CAAE,GAC5B,CAAC,CAAC"}

package/script/library/lens/update_helper.d.ts

@@ -0,0 +1,24 @@
+import type { Options } from "../options.js";
+import type { RDF } from "../rdf.js";
+import { type SparqlValue } from "../sparql/mod.js";
+import { type ExpandedSchema } from "../schema/mod.js";
+import type { Entity } from "./types.js";
+export declare class UpdateHelper {
+    private readonly schema;
+    private readonly properties;
+    private readonly options;
+    private variableCounter;
+    readonly deleteQuads: RDF.Quad[];
+    readonly insertQuads: RDF.Quad[];
+    readonly whereQuads: SparqlValue[];
+    constructor(schema: ExpandedSchema, options: Options, variableInitCounter?: number);
+    process(entity: Entity): void;
+    private processProperty;
+    private processSingleProperty;
+    private processArrayProperty;
+    private processArraySet;
+    private processArrayAddRemove;
+    private parseArrayUpdateConfig;
+    private encode;
+}
+//# sourceMappingURL=update_helper.d.ts.map

package/script/library/lens/update_helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update_helper.d.ts","sourceRoot":"","sources":["../../../src/library/lens/update_helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmC;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC,OAAO,CAAC,eAAe,CAAK;IAE5B,SAAgB,WAAW,EAAE,GAAG,CAAC,IAAI,EAAE,CAAM;IAC7C,SAAgB,WAAW,EAAE,GAAG,CAAC,IAAI,EAAE,CAAM;IAC7C,SAAgB,UAAU,EAAE,WAAW,EAAE,CAAM;gBAG7C,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,OAAO,EAChB,mBAAmB,SAAI;IAQlB,OAAO,CAAC,MAAM,EAAE,MAAM;IAM7B,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,qBAAqB;IAgC7B,OAAO,CAAC,oBAAoB;IAkB5B,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,sBAAsB;IA8B9B,OAAO,CAAC,MAAM;CASf"}

package/script/library/namespace.d.ts

@@ -0,0 +1,42 @@
+/** Original type of namespace specification */
+export type Namespace = {
+    iri: string;
+    prefix: string;
+    terms: readonly string[];
+};
+/** Resulting type of namespace providing access to all terms, prefix and IRI */
+export type NamespaceInterface<NamespaceSpec extends Namespace> = {
+    [Term in NamespaceSpec["terms"][number]]: `${NamespaceSpec["prefix"]}${Term}`;
+} & {
+    $prefix: NamespaceSpec["prefix"];
+    $iri: NamespaceSpec["iri"];
+};
+/**
+ * Creates a strongly typed container for Linked Data vocabulary to provide
+ * type safe access to all vocabulary terms as well as IDE autocompletion.
+ *
+ * @example
+ * ```typescript
+ * import { createNamespace } from "ldkit";
+ *
+ * const onto = createNamespace(
+ *   {
+ *     iri: "http://www.example.com/ontology#",
+ *     prefix: "onto:",
+ *     terms: [
+ *       "object",
+ *       "predicate",
+ *       "subject",
+ *     ],
+ *   } as const,
+ * );
+ *
+ * console.log(onto.subject); // prints http://www.example.com/ontology#subject
+ * console.log(onto.unknown); // TypeScript error! This term does not exist
+ * ```
+ *
+ * @param namespaceSpec Specification of the namespace
+ * @returns
+ */
+export declare function createNamespace<N extends Namespace>(namespaceSpec: N): NamespaceInterface<N>;
+//# sourceMappingURL=namespace.d.ts.map

package/script/library/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/library/namespace.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,MAAM,MAAM,SAAS,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,kBAAkB,CAAC,aAAa,SAAS,SAAS,IAC1D;KACC,IAAI,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,GACrC,GAAG,aAAa,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE;CACtC,GACC;IACA,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACjC,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;CAC5B,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,SAAS,EACjD,aAAa,EAAE,CAAC,GACf,kBAAkB,CAAC,CAAC,CAAC,CAWvB"}

package/script/library/namespace.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamespace = void 0;
+exports.createNamespace = createNamespace;
 /**
  * Creates a strongly typed container for Linked Data vocabulary to provide
  * type safe access to all vocabulary terms as well as IDE autocompletion.
@@ -37,4 +37,3 @@ function createNamespace(namespaceSpec) {
         $iri: namespaceSpec["iri"],
     });
 }
-exports.createNamespace = createNamespace;