ldkit 1.1.0 → 2.0.0

package/script/library/lens/query_builder.js

@@ -1,31 +1,31 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const mod_js_1 = require("../schema/mod.js");
 const mod_js_2 = require("../sparql/mod.js");
 const rdf_js_1 = require("../rdf.js");
-const ldkit_js_1 = __importDefault(require("../namespaces/ldkit.js"));
-const rdf_js_2 = __importDefault(require("../namespaces/rdf.js"));
+const ldkit_js_1 = require("../../namespaces/ldkit.js");
+const rdf_js_2 = require("../../namespaces/rdf.js");
 const encoder_js_1 = require("../encoder.js");
-const query_helper_js_1 = require("./query_helper.js");
+const update_helper_js_1 = require("./update_helper.js");
+const search_helper_js_1 = require("./search_helper.js");
+var Flags;
+(function (Flags) {
+    Flags[Flags["None"] = 0] = "None";
+    Flags[Flags["ExcludeOptional"] = 1] = "ExcludeOptional";
+    Flags[Flags["UnwrapOptional"] = 2] = "UnwrapOptional";
+    Flags[Flags["IncludeTypes"] = 4] = "IncludeTypes";
+    Flags[Flags["IgnoreInverse"] = 8] = "IgnoreInverse";
+})(Flags || (Flags = {}));
 class QueryBuilder {
-    constructor(schema, context) {
+    constructor(schema, options) {
         Object.defineProperty(this, "schema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "schemaProperties", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "context", {
+        Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -51,87 +51,120 @@ class QueryBuilder {
             }
         });
         this.schema = schema;
-        this.schemaProperties = (0, mod_js_1.getSchemaProperties)(this.schema);
-        this.context = context;
+        this.options = options;
         this.df = new rdf_js_1.DataFactory();
     }
     getResourceSignature() {
-        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf_js_2.default.type), this.df.namedNode(ldkit_js_1.default.Resource));
-    }
-    getTypesSignature() {
-        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf_js_2.default.type), this.df.variable("iri_type"));
+        return this.df.quad(this.df.variable("iri"), this.df.namedNode(rdf_js_2.rdf.type), this.df.namedNode(ldkit_js_1.ldkit.Resource));
     }
     entitiesToQuads(entities) {
-        const quadArrays = entities.map((entity) => (0, encoder_js_1.encode)(entity, this.schema, this.context));
+        const quadArrays = entities.map((entity) => (0, encoder_js_1.encode)(entity, this.schema, this.options));
         return [].concat(...quadArrays);
     }
-    getShape(includeOptional = false, wrapOptional = true, omitRootTypes = false) {
+    getShape(flags, searchSchema) {
+        const includeOptional = (flags & Flags.ExcludeOptional) === 0;
+        const wrapOptional = (flags & Flags.UnwrapOptional) === 0;
+        const omitRootTypes = (flags & Flags.IncludeTypes) === 0;
+        const ignoreInverse = (flags & Flags.IgnoreInverse) === Flags.IgnoreInverse;
         const mainVar = "iri";
         const conditions = [];
-        const populateConditionsRecursive = (s, varPrefix) => {
+        const populateSearchConditions = (property, varName, search) => {
+            if (search === undefined) {
+                return;
+            }
+            const helper = new search_helper_js_1.SearchHelper(property, varName, search);
+            helper.process();
+            conditions.push(helper.sparqlValues);
+        };
+        const populateConditionsRecursive = (s, varPrefix, search) => {
             const rdfType = s["@type"];
             const properties = (0, mod_js_1.getSchemaProperties)(s);
             if (varPrefix !== "iri" || !omitRootTypes) {
                 rdfType.forEach((type) => {
-                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(rdf_js_2.default.type), this.df.namedNode(type)));
+                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(rdf_js_2.rdf.type), this.df.namedNode(type)));
                 });
             }
             Object.keys(properties).forEach((prop, index) => {
                 const property = properties[prop];
                 const isOptional = property["@optional"];
-                if (!includeOptional && isOptional) {
+                const propertySchema = search?.[prop];
+                if (!includeOptional && isOptional && propertySchema === undefined) {
                     return;
                 }
                 if (wrapOptional && isOptional) {
                     conditions.push((0, mod_js_2.sparql) `\nOPTIONAL {`);
                 }
-                conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(property["@id"]), this.df.variable(`${varPrefix}_${index}`)));
-                if (typeof property["@context"] === "object") {
-                    populateConditionsRecursive(property["@context"], `${varPrefix}_${index}`);
+                const isInverse = property["@inverse"];
+                if (ignoreInverse || !isInverse) {
+                    conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(property["@id"]), this.df.variable(`${varPrefix}_${index}`)));
+                    populateSearchConditions(property, `${varPrefix}_${index}`, propertySchema);
+                }
+                else {
+                    conditions.push(this.df.quad(this.df.variable(`${varPrefix}_${index}`), this.df.namedNode(property["@id"]), this.df.variable(varPrefix)));
+                }
+                if (typeof property["@schema"] === "object") {
+                    populateConditionsRecursive(property["@schema"], `${varPrefix}_${index}`, propertySchema);
                 }
                 if (wrapOptional && isOptional) {
                     conditions.push((0, mod_js_2.sparql) `\n}\n`);
                 }
             });
         };
-        populateConditionsRecursive(this.schema, mainVar);
+        populateConditionsRecursive(this.schema, mainVar, searchSchema);
         return conditions;
     }
     countQuery() {
-        const quads = this.getShape();
+        const quads = this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes);
         return (0, mod_js_2.SELECT) `(count(?iri) as ?count)`.WHERE `${quads}`.build();
     }
-    getQuery(where, limit = 1000) {
-        const selectSubQuery = (0, mod_js_2.SELECT) `
+    getQuery(where, limit, offset) {
+        const selectSubQuery = mod_js_2.SELECT.DISTINCT `
       ${this.df.variable("iri")}
     `.WHERE `
-      ${this.getShape(false, true)}
+      ${this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes)} 
       ${where}
-    `.LIMIT(limit).build();
+    `.LIMIT(limit).OFFSET(offset).build();
+        const query = (0, mod_js_2.CONSTRUCT) `
+      ${this.getResourceSignature()}
+      ${this.getShape(Flags.UnwrapOptional | Flags.IgnoreInverse)}
+    `.WHERE `
+      {
+        ${selectSubQuery}
+      }
+      ${this.getShape(Flags.None)}
+    `.build();
+        return query;
+    }
+    getSearchQuery(where, limit, offset) {
+        if (where.$id) {
+            const ids = Array.isArray(where.$id) ? where.$id : [where.$id];
+            return this.getByIrisQuery(ids, where);
+        }
+        const selectSubQuery = mod_js_2.SELECT.DISTINCT `
+      ${this.df.variable("iri")}
+    `.WHERE `
+      ${this.getShape(Flags.ExcludeOptional | Flags.IncludeTypes, where)} 
+    `.LIMIT(limit).OFFSET(offset).build();
         const query = (0, mod_js_2.CONSTRUCT) `
       ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
+      ${this.getShape(Flags.UnwrapOptional | Flags.IgnoreInverse)}
     `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
       {
         ${selectSubQuery}
       }
+      ${this.getShape(Flags.None, where)}
     `.build();
         return query;
     }
-    getByIrisQuery(iris) {
+    getByIrisQuery(iris, where) {
         const query = (0, mod_js_2.CONSTRUCT) `
       ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
+      ${this.getShape(Flags.UnwrapOptional | Flags.IgnoreInverse)}
     `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
       VALUES ?iri {
         ${iris.map(this.df.namedNode)}
       }
+      ${this.getShape(Flags.IncludeTypes, where)}
     `.build();
         return query;
     }
@@ -146,17 +179,12 @@ class QueryBuilder {
         return mod_js_2.DELETE.DATA `${quads}`.build();
     }
     updateQuery(entities) {
-        const deleteQuads = [];
-        const insertQuads = [];
-        const whereQuads = [];
-        entities.forEach((entity, index) => {
-            const helper = new query_helper_js_1.QueryHelper(entity, this.schema, this.context, 1000 * index);
-            deleteQuads.push(...helper.getDeleteQuads());
-            insertQuads.push(...helper.getInsertQuads());
-            whereQuads.push(...helper.getWhereQuads());
-        });
-        return (0, mod_js_2.DELETE) `${deleteQuads}`.INSERT `${insertQuads}`
-            .WHERE `${deleteQuads}`.build();
+        const helper = new update_helper_js_1.UpdateHelper(this.schema, this.options);
+        for (const entity of entities) {
+            helper.process(entity);
+        }
+        return (0, mod_js_2.DELETE) `${helper.deleteQuads}`.INSERT `${helper.insertQuads}`
+            .WHERE `${helper.whereQuads}`.build();
     }
 }
 exports.QueryBuilder = QueryBuilder;

package/script/library/lens/search_helper.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchHelper = void 0;
+const rdf_js_1 = require("../rdf.js");
+const mod_js_1 = require("../sparql/mod.js");
+const encoder_js_1 = require("../encoder.js");
+const xsd_js_1 = require("../../namespaces/xsd.js");
+class SearchHelper {
+    constructor(property, varName, searchSchema) {
+        Object.defineProperty(this, "property", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "propertyType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "varName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "searchSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "df", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new rdf_js_1.DataFactory({
+                blankNodePrefix: "b",
+            })
+        });
+        Object.defineProperty(this, "sparqlValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.property = property;
+        this.propertyType = property["@type"] ? property["@type"] : xsd_js_1.xsd.string;
+        this.varName = varName;
+        this.searchSchema = this.isPlainObject(searchSchema)
+            ? searchSchema
+            : { $equals: searchSchema };
+    }
+    process() {
+        this.processOperators();
+        this.processStringFunctions();
+        this.processRegex();
+        this.processLangMatches();
+        this.processArrayFunctions();
+        this.processFilter();
+    }
+    processOperators() {
+        const map = {
+            $equals: "=",
+            $not: "!=",
+            $gt: ">",
+            $gte: ">=",
+            $lt: "<",
+            $lte: "<=",
+        };
+        for (const [key, operator] of Object.entries(map)) {
+            const value = this.searchSchema[key];
+            if (value === undefined) {
+                continue;
+            }
+            this.addFilter((0, mod_js_1.sparql) `${this.df.variable(this.varName)} ${operator} ${this.encode(value)}`);
+        }
+    }
+    processStringFunctions() {
+        const map = {
+            $contains: "CONTAINS",
+            $strStarts: "STRSTARTS",
+            $strEnds: "STRENDS",
+        };
+        for (const [key, func] of Object.entries(map)) {
+            const value = this.searchSchema[key];
+            if (value === undefined) {
+                continue;
+            }
+            this.addFilter((0, mod_js_1.sparql) `${func}(${this.df.variable(this.varName)}, ${this.encode(value)})`);
+        }
+    }
+    processRegex() {
+        const value = this.searchSchema.$regex;
+        if (value === undefined) {
+            return;
+        }
+        this.addFilter((0, mod_js_1.sparql) `REGEX(${this.df.variable(this.varName)}, "${value}")`);
+    }
+    processLangMatches() {
+        const value = this.searchSchema.$langMatches;
+        if (value === undefined) {
+            return;
+        }
+        this.addFilter((0, mod_js_1.sparql) `LANGMATCHES(LANG(${this.df.variable(this.varName)}), "${value}")`);
+    }
+    processArrayFunctions() {
+        const map = {
+            $in: "IN",
+            $notIn: "NOT IN",
+        };
+        for (const [key, func] of Object.entries(map)) {
+            const value = this.searchSchema[key];
+            if (value === undefined) {
+                continue;
+            }
+            const values = value.map((v) => (0, mod_js_1.sparql) `${this.encode(v)}`);
+            this.addFilter((0, mod_js_1.sparql) `${this.df.variable(this.varName)} ${func} (${values.join(", ")})`);
+        }
+    }
+    processFilter() {
+        const value = this.searchSchema.$filter;
+        if (value === undefined) {
+            return;
+        }
+        const stringified = (0, mod_js_1.sparql) `${value}`;
+        this.addFilter(stringified.replace("?value", `?${this.varName}`));
+    }
+    addFilter(filter) {
+        this.sparqlValues.push((0, mod_js_1.sparql) `FILTER (${filter}) .`);
+    }
+    encode(value) {
+        return (0, encoder_js_1.encodeValue)(value, this.propertyType, this.df);
+    }
+    isPlainObject(value) {
+        if (typeof value !== "object" || value === null) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return (prototype === null || prototype === Object.prototype ||
+            Object.getPrototypeOf(prototype) === null) &&
+            !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+    }
+}
+exports.SearchHelper = SearchHelper;

package/script/library/lens/update_helper.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateHelper = void 0;
+const mod_js_1 = require("../sparql/mod.js");
+const mod_js_2 = require("../schema/mod.js");
+const encoder_js_1 = require("../encoder.js");
+class UpdateHelper {
+    constructor(schema, options, variableInitCounter = 0) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "properties", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variableCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "deleteQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "insertQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "whereQuads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.schema = schema;
+        this.properties = (0, mod_js_2.getSchemaProperties)(schema);
+        this.options = options;
+        this.variableCounter = variableInitCounter;
+    }
+    process(entity) {
+        for (const name in this.properties) {
+            this.processProperty(entity, name, this.properties[name]);
+        }
+    }
+    processProperty(entity, propertyName, property) {
+        this.variableCounter++;
+        const value = entity[propertyName];
+        if (value === undefined) {
+            return;
+        }
+        if (property["@array"]) {
+            this.processArrayProperty(entity, propertyName, value);
+        }
+        else {
+            this.processSingleProperty(entity, propertyName, value, property);
+        }
+    }
+    processSingleProperty(entity, propertyName, propertyValue, property) {
+        const deletePattern = {
+            $id: entity.$id,
+            [propertyName]: null,
+        };
+        const quadsToDelete = this.encode(deletePattern);
+        this.deleteQuads.push(...quadsToDelete);
+        if (property["@optional"]) {
+            this.whereQuads.push((0, mod_js_1.OPTIONAL) `${quadsToDelete}`);
+        }
+        else {
+            this.whereQuads.push(...quadsToDelete);
+        }
+        if (property["@optional"] && propertyValue === null) {
+            // The intention was to delete a value of an optional property, nothing to insert
+            return;
+        }
+        const insertPattern = {
+            $id: entity.$id,
+            [propertyName]: propertyValue,
+        };
+        const quadsToInsert = this.encode(insertPattern);
+        this.insertQuads.push(...quadsToInsert);
+    }
+    processArrayProperty(entity, propertyName, propertyValue) {
+        const config = this.parseArrayUpdateConfig(propertyValue);
+        if (config.$set) {
+            this.processArraySet(entity, propertyName, config.$set);
+        }
+        else {
+            this.processArrayAddRemove(entity, propertyName, config.$add, config.$remove);
+        }
+    }
+    processArraySet(entity, propertyName, propertyValue) {
+        const deletePattern = {
+            $id: entity.$id,
+            [propertyName]: null,
+        };
+        const quadsToDelete = this.encode(deletePattern);
+        this.deleteQuads.push(...quadsToDelete);
+        this.whereQuads.push(...quadsToDelete);
+        const insertPattern = {
+            $id: entity.$id,
+            [propertyName]: propertyValue,
+        };
+        const quadsToInsert = this.encode(insertPattern);
+        this.insertQuads.push(...quadsToInsert);
+    }
+    processArrayAddRemove(entity, propertyName, $add, $remove) {
+        if ($remove) {
+            const deletePattern = {
+                $id: entity.$id,
+                [propertyName]: $remove,
+            };
+            const quadsToDelete = this.encode(deletePattern);
+            this.deleteQuads.push(...quadsToDelete);
+        }
+        if ($add) {
+            const insertPattern = {
+                $id: entity.$id,
+                [propertyName]: $add,
+            };
+            const quadsToInsert = this.encode(insertPattern);
+            this.insertQuads.push(...quadsToInsert);
+        }
+    }
+    parseArrayUpdateConfig(config) {
+        if (Array.isArray(config)) {
+            return { $set: config, $add: undefined, $remove: undefined };
+        }
+        if (config == null || typeof config !== "object") {
+            throw new Error("Invalid array update query, expected an array, or an object with $add, $set, or $remove properties");
+        }
+        const { $add, $set, $remove } = config;
+        switch (true) {
+            case Array.isArray($set) && $add === undefined && $remove === undefined:
+            case $set === undefined && Array.isArray($add) && $remove === undefined:
+            case $set === undefined && $add === undefined && Array.isArray($remove):
+            case $set === undefined && Array.isArray($add) && Array.isArray($remove):
+                return { $add, $set, $remove };
+        }
+        throw new Error("Invalid array update query, expected an array, or an object with $add, $set, or $remove properties");
+    }
+    encode(entity) {
+        return (0, encoder_js_1.encode)(entity, this.schema, this.options, false, this.variableCounter);
+    }
+}
+exports.UpdateHelper = UpdateHelper;

package/script/library/namespace.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNamespace = void 0;
+/**
+ * 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
+ */
+function createNamespace(namespaceSpec) {
+    return Object.assign(namespaceSpec.terms.reduce((acc, term) => {
+        acc[term] = `${namespaceSpec.iri}${term}`;
+        return acc;
+    }, {}), {
+        $prefix: namespaceSpec["prefix"],
+        $iri: namespaceSpec["iri"],
+    });
+}
+exports.createNamespace = createNamespace;

package/script/library/options.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveQueryContext = exports.resolveOptions = exports.setGlobalOptions = void 0;
+const mod_js_1 = require("./engine/mod.js");
+const defaultOptions = {
+    engine: new mod_js_1.QueryEngine(),
+    take: 1000,
+    logQuery: () => { },
+};
+let globalOptions = {};
+/**
+ * Sets global configuration {@link Options} for LDkit that will be used
+ * by default in all queries, unless overridden in {@link Lens}.
+ *
+ * LDkit-specific options are:
+ * - `engine` - a query engine to use for querying data sources
+ * - `language` - a preferred language for literals
+ * - `take` - a default number of results to take (limit of SELECT queries)
+ * - `logQuery` - a function that will be called for each SPARQL query
+ *
+ * Default values for these options are:
+ * ```typescript
+ * const defaultOptions = {
+ *   engine: new QueryEngine(),
+ *   take: 1000,
+ *   logQuery: () => {},
+ * };
+ * ```
+ * The default configuration uses built-in {@link QueryEngine}. Language is not set by default.
+ *
+ * @param options LDkit options and query engine context
+ */
+function setGlobalOptions(options) {
+    globalOptions = options;
+}
+exports.setGlobalOptions = setGlobalOptions;
+function resolveOptions(options = {}) {
+    return {
+        ...defaultOptions,
+        ...globalOptions,
+        ...options,
+    };
+}
+exports.resolveOptions = resolveOptions;
+function resolveQueryContext(options) {
+    const { engine: _engine, language: _language, take: _take, ...context } = options;
+    if (context.source !== undefined && context.sources === undefined) {
+        context.sources = [context.source];
+        delete context.source;
+    }
+    if (context.sources === undefined) {
+        throw new Error("No data source defined in Options");
+    }
+    return context;
+}
+exports.resolveQueryContext = resolveQueryContext;

package/script/library/schema/data_types.js

@@ -1,43 +1,5 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
-const rdf_js_1 = __importDefault(require("../namespaces/rdf.js"));
-const SupportedDataTypesPrototype = {
-    [xsd_js_1.default.dateTime]: new Date(),
-    [xsd_js_1.default.date]: new Date(),
-    [xsd_js_1.default.gDay]: new Date(),
-    [xsd_js_1.default.gMonthDay]: new Date(),
-    [xsd_js_1.default.gYear]: new Date(),
-    [xsd_js_1.default.gYearMonth]: new Date(),
-    [xsd_js_1.default.boolean]: true,
-    [xsd_js_1.default.double]: 0.0,
-    [xsd_js_1.default.decimal]: 0.0,
-    [xsd_js_1.default.float]: 0.0,
-    [xsd_js_1.default.integer]: 0,
-    [xsd_js_1.default.long]: 0,
-    [xsd_js_1.default.int]: 0,
-    [xsd_js_1.default.byte]: 0,
-    [xsd_js_1.default.short]: 0,
-    [xsd_js_1.default.negativeInteger]: 0,
-    [xsd_js_1.default.nonNegativeInteger]: 0,
-    [xsd_js_1.default.nonPositiveInteger]: 0,
-    [xsd_js_1.default.positiveInteger]: 0,
-    [xsd_js_1.default.unsignedByte]: 0,
-    [xsd_js_1.default.unsignedInt]: 0,
-    [xsd_js_1.default.unsignedLong]: 0,
-    [xsd_js_1.default.unsignedShort]: 0,
-    [xsd_js_1.default.string]: "",
-    [xsd_js_1.default.normalizedString]: "",
-    [xsd_js_1.default.anyURI]: "",
-    [xsd_js_1.default.base64Binary]: "",
-    [xsd_js_1.default.language]: "",
-    [xsd_js_1.default.Name]: "",
-    [xsd_js_1.default.NCName]: "",
-    [xsd_js_1.default.NMTOKEN]: "",
-    [xsd_js_1.default.token]: "",
-    [xsd_js_1.default.hexBinary]: "",
-    [rdf_js_1.default.langString]: "",
-};
+const xsd_js_1 = require("../../namespaces/xsd.js");
+const rdf_js_1 = require("../../namespaces/rdf.js");
+const ldkit_js_1 = require("../../namespaces/ldkit.js");

package/script/library/schema/search.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });