ldkit 2.5.2 → 2.7.0

package/esm/scripts/shacl_to_schema.js

@@ -0,0 +1,505 @@
+import { Parser, Store } from "n3";
+import { NAMESPACES, } from "./schema_to_script.js";
+const BUILTIN_NAMESPACE_IRIS = new Set(NAMESPACES.map((n) => n.$iri));
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const RDFS = "http://www.w3.org/2000/01/rdf-schema#";
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const SH = "http://www.w3.org/ns/shacl#";
+const RDF_TYPE = `${RDF}type`;
+const RDF_FIRST = `${RDF}first`;
+const RDF_REST = `${RDF}rest`;
+const RDF_NIL = `${RDF}nil`;
+const RDF_LANG_STRING = `${RDF}langString`;
+const XSD_STRING = `${XSD}string`;
+const RDFS_CLASS = `${RDFS}Class`;
+const SH_NODE_SHAPE = `${SH}NodeShape`;
+const SH_TARGET_CLASS = `${SH}targetClass`;
+const SH_PROPERTY = `${SH}property`;
+const SH_PATH = `${SH}path`;
+const SH_INVERSE_PATH = `${SH}inversePath`;
+const SH_DATATYPE = `${SH}datatype`;
+const SH_NODE_KIND = `${SH}nodeKind`;
+const SH_IRI = `${SH}IRI`;
+const SH_NODE = `${SH}node`;
+const SH_CLASS = `${SH}class`;
+const SH_MIN_COUNT = `${SH}minCount`;
+const SH_MAX_COUNT = `${SH}maxCount`;
+const SH_UNIQUE_LANG = `${SH}uniqueLang`;
+const SH_AND = `${SH}and`;
+const SH_OR = `${SH}or`;
+const SH_IN = `${SH}in`;
+// Numeric widening order: leftmost = widest.
+const NUMERIC_WIDENING = [
+    `${XSD}decimal`,
+    `${XSD}double`,
+    `${XSD}float`,
+    `${XSD}long`,
+    `${XSD}integer`,
+    `${XSD}int`,
+    `${XSD}short`,
+    `${XSD}byte`,
+    `${XSD}nonNegativeInteger`,
+    `${XSD}positiveInteger`,
+    `${XSD}unsignedLong`,
+    `${XSD}unsignedInt`,
+];
+export function shaclToSchema(turtle, options = {}) {
+    const converter = new ShaclConverter(options);
+    return converter.process(turtle);
+}
+class ShaclConverter {
+    constructor(options = {}) {
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schemas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "shapeIriToName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "usedNames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "prefixMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "prefixAliases", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.prefixAliases = options.prefixAliases ?? {};
+    }
+    process(turtle) {
+        this.parseWithPrefixes(turtle);
+        const shapeIris = this.findNodeShapes();
+        for (const shapeIri of shapeIris) {
+            const name = this.deriveSchemaName(shapeIri);
+            this.shapeIriToName.set(shapeIri, name);
+        }
+        const schemaSourcePrefixes = new Map();
+        for (const shapeIri of shapeIris) {
+            const schema = this.buildSchema(shapeIri);
+            this.schemas.push(schema);
+            const baseIri = schema.type[0] ?? shapeIri;
+            const prefix = this.findNamespacePrefix(baseIri);
+            if (prefix)
+                schemaSourcePrefixes.set(schema.name, prefix);
+        }
+        return {
+            schemas: this.schemas,
+            extraNamespaces: this.deriveExtraNamespaces(),
+            schemaSourcePrefixes,
+        };
+    }
+    parseWithPrefixes(turtle) {
+        const parser = new Parser();
+        let quads;
+        try {
+            quads = parser.parse(turtle);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to parse Turtle input: ${detail}`);
+        }
+        this.store = new Store(quads);
+        const prefixRe = /@prefix\s+([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*<([^>]+)>\s*\./g;
+        for (const match of turtle.matchAll(prefixRe)) {
+            const [, prefix, iri] = match;
+            this.prefixMap[prefix] = iri;
+        }
+    }
+    deriveExtraNamespaces() {
+        const usedIris = new Set();
+        for (const schema of this.schemas) {
+            for (const t of schema.type)
+                usedIris.add(t);
+            for (const prop of Object.values(schema.properties)) {
+                usedIris.add(prop.id);
+                if (prop.type)
+                    usedIris.add(prop.type);
+            }
+        }
+        const result = [];
+        const seenIris = new Set();
+        const usedNames = new Set();
+        for (const [prefix, iri] of Object.entries(this.prefixMap)) {
+            if (BUILTIN_NAMESPACE_IRIS.has(iri))
+                continue;
+            if (seenIris.has(iri))
+                continue;
+            const isUsed = [...usedIris].some((u) => u.startsWith(iri));
+            if (!isUsed)
+                continue;
+            seenIris.add(iri);
+            let safeName = prefix;
+            while (usedNames.has(safeName)) {
+                safeName += "_";
+            }
+            usedNames.add(safeName);
+            result.push({ iri, prefix: safeName });
+        }
+        return result;
+    }
+    findNodeShapes() {
+        const quads = this.store.getQuads(null, RDF_TYPE, SH_NODE_SHAPE, null);
+        const iris = [];
+        for (const q of quads) {
+            if (q.subject.termType === "NamedNode") {
+                iris.push(q.subject.value);
+            }
+        }
+        return iris;
+    }
+    deriveSchemaName(shapeIri) {
+        const targetClass = this.getObjectIri(shapeIri, SH_TARGET_CLASS);
+        const baseIri = targetClass ?? shapeIri;
+        let local = this.getSuffix(baseIri);
+        if (!targetClass && local.endsWith("Shape")) {
+            local = local.substring(0, local.length - "Shape".length);
+        }
+        return this.uniqueName(this.composeSchemaName(baseIri, local));
+    }
+    // Schema names are always namespace-prefixed (when a @prefix declaration
+    // covers the IRI) so that classes sharing a local-part across vocabularies
+    // — e.g. m:Campaign, meta:Campaign, google:Campaign — produce
+    // self-documenting, deterministic names like MCampaignSchema,
+    // MetaCampaignSchema, GoogleCampaignSchema. IRIs without a declared prefix
+    // fall back to the bare local-part (preserves prior behavior for
+    // hand-written SHACL test fixtures that omit @prefix declarations).
+    composeSchemaName(iri, local) {
+        const prefix = this.findNamespacePrefix(iri);
+        const prefixPart = prefix
+            ? (this.prefixAliases[prefix] ??
+                this.capitalize(this.sanitizeIdentifier(prefix)))
+            : "";
+        const localPart = this.capitalize(this.sanitizeIdentifier(local));
+        return `${prefixPart}${localPart}Schema`;
+    }
+    findNamespacePrefix(iri) {
+        let bestPrefix = null;
+        let bestLength = 0;
+        for (const [prefix, ns] of Object.entries(this.prefixMap)) {
+            if (iri.startsWith(ns) && ns.length > bestLength) {
+                bestPrefix = prefix;
+                bestLength = ns.length;
+            }
+        }
+        return bestPrefix;
+    }
+    uniqueName(name) {
+        if (!this.usedNames.has(name)) {
+            this.usedNames.add(name);
+            return name;
+        }
+        for (let i = 1; i < 1000; i++) {
+            const candidate = `${name}${i}`;
+            if (!this.usedNames.has(candidate)) {
+                this.usedNames.add(candidate);
+                return candidate;
+            }
+        }
+        throw new Error(`Could not generate a unique name for ${name}`);
+    }
+    buildSchema(shapeIri) {
+        return {
+            name: this.shapeIriToName.get(shapeIri),
+            type: this.deriveType(shapeIri),
+            properties: this.buildProperties(shapeIri),
+        };
+    }
+    deriveType(shapeIri) {
+        const targetClasses = this.getObjectIris(shapeIri, SH_TARGET_CLASS);
+        if (targetClasses.length > 0) {
+            return targetClasses;
+        }
+        const isRdfsClass = this.store.getQuads(shapeIri, RDF_TYPE, RDFS_CLASS, null).length > 0;
+        return isRdfsClass ? [shapeIri] : [];
+    }
+    buildProperties(shapeIri) {
+        const propertyNodes = this.store.getQuads(shapeIri, SH_PROPERTY, null, null);
+        const properties = {};
+        for (const q of propertyNodes) {
+            if (q.object.termType !== "NamedNode" &&
+                q.object.termType !== "BlankNode") {
+                console.error(`[shacl-to-schema] warning: skipping non-node sh:property value on shape <${shapeIri}> (got ${q.object.termType})`);
+                continue;
+            }
+            const { name, spec } = this.buildProperty(q.object, shapeIri);
+            if (properties[name]) {
+                properties[name] = this.mergePropertySpecs(properties[name], spec);
+            }
+            else {
+                properties[name] = spec;
+            }
+        }
+        return properties;
+    }
+    // SHACL conjoins multiple property shapes on the same path (AND). LDkit's
+    // runtime ignores @type when @schema is set, so schemaRef wins over type.
+    mergePropertySpecs(a, b) {
+        const merged = { id: a.id };
+        if (b.schemaRef !== undefined || a.schemaRef !== undefined) {
+            merged.schemaRef = b.schemaRef ?? a.schemaRef;
+        }
+        else if (b.type !== undefined) {
+            merged.type = b.type;
+        }
+        else if (a.type !== undefined) {
+            merged.type = a.type;
+        }
+        if (a.optional && b.optional)
+            merged.optional = true;
+        if (a.array && b.array)
+            merged.array = true;
+        if (a.multilang || b.multilang)
+            merged.multilang = true;
+        if (a.inverse || b.inverse)
+            merged.inverse = true;
+        return merged;
+    }
+    buildProperty(propertyNode, enclosingShapeIri) {
+        const { iri: pathIri, inverse } = this.resolvePath(propertyNode, enclosingShapeIri);
+        const name = this.getSuffix(pathIri);
+        const spec = { id: pathIri };
+        if (inverse) {
+            spec.inverse = true;
+        }
+        const direct = this.collectConstraints(propertyNode);
+        const orBranches = this.collectOrBranches(propertyNode);
+        let forceOptional = false;
+        const refTarget = direct.refNode ?? direct.refClass;
+        if (direct.uniqueLang || direct.datatype === RDF_LANG_STRING) {
+            spec.multilang = true;
+        }
+        else if (refTarget) {
+            // Default to IRI for sh:node / sh:class references
+            spec.type = "@id";
+        }
+        else if (direct.datatype && direct.datatype !== XSD_STRING) {
+            spec.type = direct.datatype;
+        }
+        else if (direct.nodeKind === SH_IRI) {
+            spec.type = "@id";
+        }
+        else if (direct.inFirstType) {
+            if (direct.inFirstType === "@id") {
+                spec.type = "@id";
+            }
+            else if (direct.inFirstType !== XSD_STRING) {
+                spec.type = direct.inFirstType;
+            }
+        }
+        else if (orBranches.length > 0) {
+            const reduced = this.reduceOrBranches(orBranches);
+            forceOptional = true;
+            if (reduced.kind === "datatype" && reduced.value !== XSD_STRING) {
+                spec.type = reduced.value;
+            }
+            else if (reduced.kind === "iri") {
+                spec.type = "@id";
+            }
+        }
+        const minCount = this.getObjectInteger(propertyNode, SH_MIN_COUNT);
+        const maxCount = this.getObjectInteger(propertyNode, SH_MAX_COUNT);
+        if (forceOptional || minCount === undefined || minCount === 0) {
+            spec.optional = true;
+        }
+        if (maxCount === undefined || maxCount > 1) {
+            spec.array = true;
+        }
+        return { name, spec };
+    }
+    resolvePath(propertyNode, enclosingShapeIri) {
+        const ctx = enclosingShapeIri ? ` on shape <${enclosingShapeIri}>` : "";
+        const pathTerm = this.getObjectTerm(propertyNode, SH_PATH);
+        if (!pathTerm) {
+            throw new Error(`Property shape${ctx} is missing sh:path`);
+        }
+        if (pathTerm.termType === "NamedNode") {
+            return { iri: pathTerm.value, inverse: false };
+        }
+        if (pathTerm.termType === "BlankNode") {
+            const inverseIri = this.getObjectIri(pathTerm, SH_INVERSE_PATH);
+            if (inverseIri) {
+                return { iri: inverseIri, inverse: true };
+            }
+        }
+        throw new Error(`Unsupported sh:path${ctx}: only simple predicate IRIs and sh:inversePath are supported (got ${pathTerm.termType})`);
+    }
+    collectConstraints(node) {
+        const c = {
+            datatype: this.getObjectIri(node, SH_DATATYPE),
+            nodeKind: this.getObjectIri(node, SH_NODE_KIND),
+            refNode: this.getObjectIri(node, SH_NODE),
+            refClass: this.getObjectIri(node, SH_CLASS),
+            uniqueLang: this.getObjectBoolean(node, SH_UNIQUE_LANG),
+        };
+        const inListTerm = this.getObjectTerm(node, SH_IN);
+        if (inListTerm) {
+            const items = this.walkList(inListTerm);
+            const first = items[0];
+            if (first?.termType === "NamedNode") {
+                c.inFirstType = "@id";
+            }
+            else if (first?.termType === "Literal") {
+                const dt = first.datatype?.value ??
+                    XSD_STRING;
+                c.inFirstType = dt;
+            }
+        }
+        const andListTerm = this.getObjectTerm(node, SH_AND);
+        if (andListTerm) {
+            for (const branch of this.walkList(andListTerm)) {
+                const sub = this.collectConstraints(branch);
+                if (sub.datatype !== undefined)
+                    c.datatype = sub.datatype;
+                if (sub.nodeKind !== undefined)
+                    c.nodeKind = sub.nodeKind;
+                if (sub.refNode !== undefined)
+                    c.refNode = sub.refNode;
+                if (sub.refClass !== undefined)
+                    c.refClass = sub.refClass;
+                if (sub.uniqueLang !== undefined)
+                    c.uniqueLang = sub.uniqueLang;
+                if (sub.inFirstType !== undefined)
+                    c.inFirstType = sub.inFirstType;
+            }
+        }
+        return c;
+    }
+    collectOrBranches(node) {
+        const orListTerm = this.getObjectTerm(node, SH_OR);
+        if (!orListTerm)
+            return [];
+        return this.walkList(orListTerm).map((branch) => this.collectConstraints(branch));
+    }
+    reduceOrBranches(branches) {
+        if (branches.length === 0) {
+            return { kind: "untyped" };
+        }
+        const allDatatypes = branches.every((b) => b.datatype && !b.refNode && !b.refClass);
+        const allRefs = branches.every((b) => (b.refNode || b.refClass) && !b.datatype);
+        if (allDatatypes) {
+            const dts = branches.map((b) => b.datatype);
+            const widened = this.pickWidestNumeric(dts);
+            if (widened) {
+                return { kind: "datatype", value: widened };
+            }
+            const unique = new Set(dts);
+            if (unique.size === 1) {
+                return { kind: "datatype", value: dts[0] };
+            }
+            return { kind: "untyped" };
+        }
+        if (allRefs) {
+            return { kind: "iri" };
+        }
+        return { kind: "untyped" };
+    }
+    pickWidestNumeric(types) {
+        const indices = types.map((t) => NUMERIC_WIDENING.indexOf(t));
+        if (indices.every((i) => i >= 0)) {
+            return NUMERIC_WIDENING[Math.min(...indices)];
+        }
+        return undefined;
+    }
+    walkList(listHead) {
+        const items = [];
+        const visited = new Set();
+        let current = listHead;
+        while (current &&
+            !(current.termType === "NamedNode" && current.value === RDF_NIL)) {
+            const key = `${current.termType}:${current.value}`;
+            if (visited.has(key))
+                break;
+            visited.add(key);
+            const first = this.getObjectTerm(current, RDF_FIRST);
+            if (!first)
+                break;
+            items.push(first);
+            const rest = this.getObjectTerm(current, RDF_REST);
+            if (!rest)
+                break;
+            current = rest;
+        }
+        return items;
+    }
+    sanitizeIdentifier(value) {
+        let cleaned = value.replace(/[^A-Za-z0-9_$]/g, "_");
+        if (cleaned.length > 0 && /^[0-9]/.test(cleaned)) {
+            cleaned = `_${cleaned}`;
+        }
+        return cleaned;
+    }
+    getObjectTerm(subject, predicate) {
+        const quads = this.store.getQuads(subject, predicate, null, null);
+        return quads[0]?.object;
+    }
+    getObjectIri(subject, predicate) {
+        const term = this.getObjectTerm(subject, predicate);
+        if (term && term.termType === "NamedNode") {
+            return term.value;
+        }
+        return undefined;
+    }
+    getObjectIris(subject, predicate) {
+        const quads = this.store.getQuads(subject, predicate, null, null);
+        const result = [];
+        for (const q of quads) {
+            if (q.object.termType === "NamedNode") {
+                result.push(q.object.value);
+            }
+        }
+        return result;
+    }
+    getObjectInteger(subject, predicate) {
+        const term = this.getObjectTerm(subject, predicate);
+        if (term && term.termType === "Literal") {
+            const parsed = parseInt(term.value, 10);
+            if (!Number.isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        return undefined;
+    }
+    getObjectBoolean(subject, predicate) {
+        const term = this.getObjectTerm(subject, predicate);
+        if (term && term.termType === "Literal") {
+            if (term.value === "true")
+                return true;
+            if (term.value === "false")
+                return false;
+        }
+        return undefined;
+    }
+    getSuffix(value) {
+        const cutoff = Math.max(value.lastIndexOf("#"), value.lastIndexOf("/"));
+        if (cutoff === -1) {
+            return value;
+        }
+        return value.substring(cutoff + 1);
+    }
+    capitalize(value) {
+        if (value.length === 0)
+            return value;
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldkit",
-  "version": "2.5.2",
+  "version": "2.7.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "keywords": [
     "linked data",
@@ -43,7 +43,7 @@
     "ldkit": "./esm/cli.js"
   },
   "dependencies": {
-    "@comunica/types": "^4",
+    "@comunica/types": "^5",
     "@rdfjs/types": "^2",
     "@shexjs/parser": "1.0.0-alpha.28",
     "@types/n3": "^1",

package/script/cli.js

@@ -4,10 +4,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_process_1 = require("node:process");
 const node_util_1 = require("node:util");
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const commander_1 = require("commander");
 const context_to_schema_js_1 = require("./scripts/context_to_schema.js");
 const shex_to_schema_js_1 = require("./scripts/shex_to_schema.js");
+const shacl_to_schema_js_1 = require("./scripts/shacl_to_schema.js");
 const schema_to_script_js_1 = require("./scripts/schema_to_script.js");
+const schema_to_package_js_1 = require("./scripts/schema_to_package.js");
 const asciiArt = String.raw `
   _     ____  _    _ _   
  | |   |  _ \| | _(_) |_ 
@@ -87,6 +90,56 @@ program.command("shexj-to-schema")
         console.error((0, node_util_1.styleText)("red", `${error.message}`));
     }
 });
+program.command("shacl-to-schema")
+    .description("Convert a SHACL shapes graph from a file or URL to a LDkit schema")
+    .addArgument(new commander_1.Argument("<method>", "type of input").choices([
+    "url",
+    "file",
+    "arg",
+]))
+    .argument("<input>", "input SHACL Turtle - file, URL, or string")
+    .option("--prefix-alias <mapping>", "rename a SHACL prefix in generated schema names (format: prefix=Alias). Repeatable.", (value, previous) => [...previous, value], [])
+    .action(async (method, input, opts) => {
+    try {
+        const resolvedInput = await resolve(method, input);
+        const prefixAliases = parsePrefixAliases(opts.prefixAlias);
+        const { schemas, extraNamespaces } = (0, shacl_to_schema_js_1.shaclToSchema)(resolvedInput, {
+            prefixAliases,
+        });
+        console.log((0, schema_to_script_js_1.schemaToScript)(schemas, extraNamespaces));
+    }
+    catch (error) {
+        console.error((0, node_util_1.styleText)("red", `${error.message}`));
+    }
+});
+program.command("shacl-to-package")
+    .description("Convert a SHACL shapes graph into a directory of per-namespace LDkit schema files (one .ts per prefix plus an index.ts barrel)")
+    .addArgument(new commander_1.Argument("<method>", "type of input").choices([
+    "url",
+    "file",
+    "arg",
+]))
+    .argument("<input>", "input SHACL Turtle - file, URL, or string")
+    .argument("<outDir>", "output directory for the generated package")
+    .option("--prefix-alias <mapping>", "rename a SHACL prefix in generated schema names AND in the per-namespace file name (format: prefix=Alias). Repeatable.", (value, previous) => [...previous, value], [])
+    .action(async (method, input, outDir, opts) => {
+    try {
+        const resolvedInput = await resolve(method, input);
+        const prefixAliases = parsePrefixAliases(opts.prefixAlias);
+        const { schemas, extraNamespaces, schemaSourcePrefixes } = (0, shacl_to_schema_js_1.shaclToSchema)(resolvedInput, { prefixAliases });
+        const { files } = (0, schema_to_package_js_1.schemaToPackage)(schemas, extraNamespaces, {
+            prefixAliases,
+            schemaSourcePrefixes,
+        });
+        (0, node_fs_1.mkdirSync)(outDir, { recursive: true });
+        for (const [base, contents] of files) {
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, `${base}.ts`), contents);
+        }
+    }
+    catch (error) {
+        console.error((0, node_util_1.styleText)("red", `${error.message}`));
+    }
+});
 // Check if no arguments were provided
 if (node_process_1.argv.length <= 2) {
     console.log((0, node_util_1.styleText)("red", asciiArt));
@@ -95,6 +148,21 @@ if (node_process_1.argv.length <= 2) {
 else {
     program.parse(node_process_1.argv);
 }
+function parsePrefixAliases(pairs) {
+    if (!pairs || pairs.length === 0)
+        return {};
+    const result = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf("=");
+        if (eq <= 0 || eq === pair.length - 1) {
+            throw new Error(`Invalid --prefix-alias value "${pair}" (expected format: prefix=Alias)`);
+        }
+        const prefix = pair.substring(0, eq);
+        const alias = pair.substring(eq + 1);
+        result[prefix] = alias;
+    }
+    return result;
+}
 async function resolve(method, input) {
     if (method === "url") {
         try {

package/script/library/options.d.ts

@@ -51,8 +51,10 @@ export declare function resolveOptions(options?: Options): {
     fileBaseIRI?: string;
     log?: import("@comunica/types").Logger;
     datetime?: Date;
+    queryTimestampHighResolution?: DOMHighResTimeStamp;
     httpProxyHandler?: import("@comunica/types").IProxyHandler;
     lenient?: boolean;
+    parseUnsupportedVersions?: boolean;
     httpIncludeCredentials?: boolean;
     httpAuth?: string;
     httpTimeout?: number;
@@ -60,14 +62,27 @@ export declare function resolveOptions(options?: Options): {
     httpRetryCount?: number;
     httpRetryDelayFallback?: number;
     httpRetryDelayLimit?: number;
+    httpRetryStatusCodes?: number[];
+    httpRetryBodyCount?: number;
+    httpRetryBodyDelayFallback?: number;
+    httpRetryBodyAllowUnsafe?: boolean;
+    httpRetryBodyMaxBytes?: number;
+    httpAbortSignal?: AbortSignal;
+    httpCache?: boolean;
     fetch?: typeof fetch;
+    recoverBrokenLinks?: boolean;
     readOnly?: boolean;
+    extensionFunctions?: Record<string, (args: import("@rdfjs/types").Term[]) => Promise<import("@rdfjs/types").Term>>;
+    extensionFunctionsAlwaysPushdown?: boolean;
     extensionFunctionCreator?: (functionNamedNode: import("@rdfjs/types").NamedNode) => ((args: import("@rdfjs/types").Term[]) => Promise<import("@rdfjs/types").Term>) | undefined;
     functionArgumentsCache?: import("@comunica/types").FunctionArgumentsCache;
-    extensionFunctions?: Record<string, (args: import("@rdfjs/types").Term[]) => Promise<import("@rdfjs/types").Term>>;
     explain?: import("@comunica/types").QueryExplainMode;
-    recoverBrokenLinks?: boolean;
+    unionDefaultGraph?: boolean;
+    traverse?: boolean;
+    invalidateCache?: boolean;
+    dataFactory?: import("@comunica/types").ComunicaDataFactory;
     distinctConstruct?: boolean;
+    rdfSerializationPrefixes?: Record<string, string>;
 };
 export declare function resolveQueryContext(options: Options): QueryContext;
 //# sourceMappingURL=options.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/library/options.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EAElB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEvD;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,OAAY;YAxCzC,YAAY;eACV,MAAM;UACV,MAAM;cACF,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CnC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAclE"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/library/options.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EAElB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEvD;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,OAAY;YAxCzC,YAAY;eACV,MAAM;UACV,MAAM;cACF,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CnC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAclE"}

package/script/scripts/schema_to_package.d.ts

@@ -0,0 +1,10 @@
+import { type ExtraNamespace, type SchemaSpec } from "./schema_to_script.js";
+export type SchemaToPackageOptions = {
+    prefixAliases?: Record<string, string>;
+    schemaSourcePrefixes?: Map<string, string>;
+};
+export type SchemaPackage = {
+    files: Map<string, string>;
+};
+export declare function schemaToPackage(schemas: SchemaSpec[], extraNamespaces?: ExtraNamespace[], options?: SchemaToPackageOptions): SchemaPackage;
+//# sourceMappingURL=schema_to_package.d.ts.map

package/script/scripts/schema_to_package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_to_package.d.ts","sourceRoot":"","sources":["../../src/scripts/schema_to_package.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,UAAU,EAEhB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B,CAAC;AAKF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,UAAU,EAAE,EACrB,eAAe,GAAE,cAAc,EAAO,EACtC,OAAO,GAAE,sBAA2B,GACnC,aAAa,CAkDf"}