ldkit 0.6.4 → 0.6.5

package/script/library/sparql/sparql_tag.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sparql = void 0;
+const rdf_js_1 = require("../rdf.js");
+const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
+const stringify_js_1 = require("./stringify.js");
+const sparql = (strings, ...values) => {
+    let counter = 0;
+    let result = "";
+    for (const value of values) {
+        result += strings[counter++];
+        result += valueToString(value);
+    }
+    result += strings[counter];
+    return result;
+};
+exports.sparql = sparql;
+const isIterable = (obj) => {
+    return Symbol.iterator in Object(obj);
+};
+const df = new rdf_js_1.DataFactory();
+const valueToString = (value) => {
+    if (typeof value === "undefined" || value === null) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        const numberDataType = Number.isInteger(value) ? xsd_js_1.default.integer : xsd_js_1.default.decimal;
+        return (0, stringify_js_1.stringify)(df.literal(value.toString(), df.namedNode(numberDataType)));
+    }
+    if (typeof value === "boolean") {
+        return (0, stringify_js_1.stringify)(df.literal(value.toString(), df.namedNode(xsd_js_1.default.boolean)));
+    }
+    if (value instanceof Date) {
+        return (0, stringify_js_1.stringify)(df.literal(value.toISOString(), df.namedNode(xsd_js_1.default.dateTime)));
+    }
+    if (isIterable(value)) {
+        const [first, ...rest] = value;
+        let result = valueToString(first);
+        for (const part of rest) {
+            result += `\n${valueToString(part)}`;
+        }
+        return result;
+    }
+    if (value.termType) {
+        return (0, stringify_js_1.stringify)(value);
+    }
+    throw new Error("Not supported input type detected.");
+};

package/script/library/sparql/sparql_update_builders.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WITH = exports.DELETE = exports.INSERT = void 0;
+const sparql_shared_builders_js_1 = require("./sparql_shared_builders.js");
+const WHERE = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `WHERE {\n${value}\n}\n`, { build: sparql_shared_builders_js_1.build });
+const USING_NAMED = (0, sparql_shared_builders_js_1.createNamedNodeBuilder)((value) => `USING NAMED ${value}\n`, { WHERE });
+const USING = (0, sparql_shared_builders_js_1.createNamedNodeBuilder)((value) => `USING ${value}\n`, { USING_NAMED, WHERE });
+const _INSERT = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `INSERT {\n${value}\n}\n`, { USING, USING_NAMED, WHERE });
+const _INSERT_DATA = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `INSERT DATA {\n${value}\n}\n`, { build: sparql_shared_builders_js_1.build });
+exports.INSERT = Object.assign(_INSERT, {
+    DATA: _INSERT_DATA,
+});
+const _DELETE = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `DELETE {\n${value}\n}\n`, { INSERT: _INSERT, USING, USING_NAMED, WHERE });
+const _DELETE_DATA = (0, sparql_shared_builders_js_1.createTemplateBuilder)((value) => `DELETE DATA {\n${value}\n}\n`, { build: sparql_shared_builders_js_1.build });
+exports.DELETE = Object.assign(_DELETE, {
+    DATA: _DELETE_DATA,
+});
+exports.WITH = (0, sparql_shared_builders_js_1.createNamedNodeBuilder)((value) => `WITH ${value}\n`, { build: sparql_shared_builders_js_1.build, INSERT: _INSERT, DELETE: _DELETE });

package/script/library/sparql/stringify.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.literal = exports.variable = exports.namedNode = exports.blankNode = void 0;
+const rdf_js_1 = require("../rdf.js");
+const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
+const escape_js_1 = require("./escape.js");
+const blankNode = (term) => {
+    return `_:${term.value}`;
+};
+exports.blankNode = blankNode;
+const namedNode = (term) => {
+    return `<${term.value}>`;
+};
+exports.namedNode = namedNode;
+const variable = (term) => {
+    return `?${term.value}`;
+};
+exports.variable = variable;
+const literal = (term) => {
+    const datatype = term.datatype.value;
+    if (datatype === xsd_js_1.default.integer || datatype === xsd_js_1.default.boolean ||
+        datatype === xsd_js_1.default.decimal) {
+        return term.value;
+    }
+    const value = `"${(0, escape_js_1.escape)(term.value)}"`;
+    if (term.language) {
+        return `${value}@${term.language}`;
+    }
+    if (datatype !== xsd_js_1.default.string) {
+        return `${value}^^${(0, exports.namedNode)(term.datatype)}`;
+    }
+    return value;
+};
+exports.literal = literal;
+const quad = (term) => {
+    const triple = `${(0, exports.stringify)(term.subject)} ${(0, exports.stringify)(term.predicate)} ${(0, exports.stringify)(term.object)} .`;
+    if (term.graph.equals(rdf_js_1.DefaultGraph.INSTANCE)) {
+        return triple;
+    }
+    return `GRAPH ${(0, exports.stringify)(term.graph)} { ${triple} }`;
+};
+const stringify = (term) => {
+    switch (term.termType) {
+        case "BlankNode":
+            return (0, exports.blankNode)(term);
+        case "NamedNode":
+            return (0, exports.namedNode)(term);
+        case "Variable":
+            return (0, exports.variable)(term);
+        case "Literal":
+            return (0, exports.literal)(term);
+        case "Quad":
+            return quad(term);
+        default:
+            throw new Error("Unknown RDF type found.");
+    }
+};
+exports.stringify = stringify;

package/script/sparql.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./library/sparql.js"), exports);
+__exportStar(require("./library/sparql/mod.js"), exports);

package/types/library/rdf.d.ts

@@ -1,8 +1,8 @@
 import type * as RDF from "rdf-js";
 export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
-import { DataFactory } from "rdf-data-factory";
-export { DataFactory };
+import { DataFactory, DefaultGraph } from "rdf-data-factory";
+export { DataFactory, DefaultGraph };
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
 export declare type LDkitContext = {
     graph?: string;

package/types/library/resource/types.d.ts

@@ -1,5 +1,5 @@
 import type { SchemaInterfaceIdentity } from "../schema/mod.js";
-export declare type Entity<T extends any = Record<string, any>> = DeepPartial<T> & SchemaInterfaceIdentity;
-export declare type DeepPartial<T> = T extends Function ? T : T extends object ? {
+export declare type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & SchemaInterfaceIdentity;
+export declare type DeepPartial<T> = T extends Record<string, unknown> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;

package/types/library/schema/interface.d.ts

@@ -1,5 +1,5 @@
 import type { SupportedDataTypes } from "./data_types.js";
-import type { SchemaPrototype, PropertyPrototype } from "./schema.js";
+import type { PropertyPrototype, SchemaPrototype } from "./schema.js";
 declare type IsOptional<Property extends PropertyPrototype> = Property extends {
     "@optional": true;
 } ? true : false;
@@ -13,7 +13,7 @@ declare type ValidPropertyDefinition = PropertyPrototype | string;
 declare type ConvertPropertyType<T extends PropertyPrototype> = T extends {
     "@context": SchemaPrototype;
 } ? SchemaInterface<T["@context"]> : T extends {
-    "@type": any;
+    "@type": unknown;
 } ? T["@type"] extends keyof SupportedDataTypes ? SupportedDataTypes[T["@type"]] : never : string;
 declare type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
 declare type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;

package/types/library/schema/mod.d.ts

@@ -1,3 +1,3 @@
 export type { SchemaInterface, SchemaInterfaceIdentity, SchemaInterfaceType, } from "./interface.js";
-export type { Schema, SchemaPrototype, Property, PropertyPrototype, } from "./schema.js";
+export type { Property, PropertyPrototype, Schema, SchemaPrototype, } from "./schema.js";
 export { expandSchema, getSchemaProperties } from "./utils.js";

package/types/library/sparql/escape.d.ts

@@ -0,0 +1 @@
+export declare const escape: (value: string) => string;

package/types/library/sparql/mod.d.ts

@@ -0,0 +1,3 @@
+export { sparql, type SparqlValue } from "./sparql_tag.js";
+export { ASK, CONSTRUCT, DESCRIBE, SELECT } from "./sparql_query_builders.js";
+export { DELETE, INSERT, WITH } from "./sparql_update_builders.js";