@graphty/graph-io 0.3.48 → 0.3.49

package/dist/sources-sparql.js

@@ -0,0 +1,405 @@
+import { b as throwIfAborted } from "./chunks/input-CAxt_aV-.js";
+import { d as defineSource, S as SPARQL_SOURCE_ID, f as failOn } from "./chunks/credentials-DXHx7nwR.js";
+import { sha256Hex } from "./chunks/sigv4-EokFic1V.js";
+import { S as SPARQL_DESCRIPTOR } from "./chunks/descriptor-B28U25x4.js";
+const TERM = /\s*(?:<([^<>]*)>|_:([\w.-]*[\w-])|"((?:[^"\\]|\\.)*)"(?:@([A-Za-z][\w-]*)|\^\^<([^<>]*)>)?)/y;
+const END = /\s*\.\s*(?:#.*)?$/y;
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const NUMERIC = new Set(
+  [
+    "integer",
+    "decimal",
+    "double",
+    "float",
+    "int",
+    "long",
+    "short",
+    "byte",
+    "nonNegativeInteger",
+    "nonPositiveInteger",
+    "positiveInteger",
+    "negativeInteger",
+    "unsignedInt",
+    "unsignedLong",
+    "unsignedShort",
+    "unsignedByte"
+  ].map((t) => XSD + t)
+);
+function unescape(text) {
+  if (!text.includes("\\")) {
+    return text;
+  }
+  const simple = { t: "	", b: "\b", n: "\n", r: "\r", f: "\f" };
+  return text.replaceAll(
+    /\\(?:u([\da-fA-F]{4})|U([\da-fA-F]{8})|(.))/g,
+    (_m, u4, u8, c) => {
+      const hex = u4 ?? u8;
+      if (hex !== void 0) {
+        return String.fromCodePoint(Number.parseInt(hex, 16));
+      }
+      return simple[c ?? ""] ?? c ?? "";
+    }
+  );
+}
+function readTerm(line, at) {
+  TERM.lastIndex = at;
+  const m = TERM.exec(line);
+  if (m === null) {
+    return null;
+  }
+  const [, iri, bnode, lexical, lang, datatype] = m;
+  let term;
+  if (iri !== void 0) {
+    term = { kind: "iri", value: unescape(iri) };
+  } else if (bnode === void 0) {
+    term = {
+      kind: "literal",
+      value: unescape(lexical ?? ""),
+      lang: lang?.toLowerCase() ?? "",
+      datatype: datatype ?? ""
+    };
+  } else {
+    term = { kind: "bnode", value: `_:${bnode}` };
+  }
+  return { term, end: TERM.lastIndex };
+}
+function parseNTriples(text) {
+  const triples = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    const s = readTerm(line, 0);
+    const p = s === null ? null : readTerm(line, s.end);
+    const o = p === null ? null : readTerm(line, p.end);
+    END.lastIndex = o?.end ?? 0;
+    if (s === null || p === null || o === null || s.term.kind === "literal" || p.term.kind !== "iri" || !END.test(line)) {
+      return { triples, badLine: i + 1 };
+    }
+    triples.push({ s: s.term, p: p.term.value, o: o.term });
+  }
+  return { triples, badLine: null };
+}
+function localName(iri) {
+  const cut = Math.max(iri.lastIndexOf("#"), iri.lastIndexOf("/"), iri.lastIndexOf(":"));
+  const name = iri.slice(cut + 1);
+  return name === "" ? iri : name;
+}
+function literalValue(term) {
+  if (NUMERIC.has(term.datatype)) {
+    const n = Number(term.value);
+    return Number.isFinite(n) ? n : term.value;
+  }
+  if (term.datatype === `${XSD}boolean`) {
+    return term.value === "true" || term.value === "1";
+  }
+  return term.value;
+}
+function languageMatches(lang, want) {
+  return want === "" || lang === "" || lang === want || lang.startsWith(`${want}-`);
+}
+function graphTriples(triples, language, into) {
+  const out = into ?? { nodes: /* @__PURE__ */ new Map(), edges: [] };
+  for (const { s, p, o } of triples) {
+    let attrs = out.nodes.get(s.value);
+    if (attrs === void 0) {
+      attrs = {};
+      out.nodes.set(s.value, attrs);
+    }
+    if (o.kind === "literal") {
+      const key = localName(p);
+      if (languageMatches(o.lang, language) && !(key in attrs)) {
+        attrs[key] = literalValue(o);
+      }
+    } else {
+      out.edges.push({ source: s.value, target: o.value, type: localName(p), predicate: p });
+    }
+  }
+  return out;
+}
+function canonicalTriple(t) {
+  const o = t.o.kind === "literal" ? JSON.stringify([t.o.value, t.o.lang, t.o.datatype]) : t.o.value;
+  return `${t.s.value} ${t.p} ${o}`;
+}
+const NOT_IRI = /[\s<>"{}|^`\\]/;
+const LANGUAGE = /^[a-z]{1,8}(-[a-z\d]{1,8})*$/i;
+function bare(query) {
+  return query.replaceAll(/<[^<>\s]*>/g, "<>").replaceAll(/"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/g, '""').replaceAll(/#[^\n]*/g, "");
+}
+function readQuery(query) {
+  const text = bare(query);
+  const form = /\b(CONSTRUCT|DESCRIBE|SELECT|ASK)\b/i.exec(text)?.[1]?.toLowerCase() ?? null;
+  const tail = text.slice(text.lastIndexOf("}") + 1);
+  let templateVars = [];
+  if (form === "construct") {
+    const template = /\bCONSTRUCT\s*\{([^}]*)\}/i.exec(text)?.[1] ?? "";
+    templateVars = [...new Set(template.match(/[?$]\w+/g) ?? [])].map((v) => `?${v.slice(1)}`);
+  }
+  return {
+    form,
+    ownLimit: /\b(LIMIT|OFFSET)\b/i.test(tail),
+    ordered: /\bORDER\s+BY\b/i.test(tail),
+    templateVars
+  };
+}
+function pagedQuery(query, shape, limit, offset) {
+  const order = shape.ordered || shape.templateVars.length === 0 ? "" : `
+ORDER BY ${shape.templateVars.join(" ")}`;
+  const skip = offset > 0 ? ` OFFSET ${String(offset)}` : "";
+  return `${query.trimEnd()}${order}
+LIMIT ${String(limit)}${skip}`;
+}
+function iriTerm(id) {
+  const text = String(id);
+  return /^[a-z][\w+.-]*:/i.test(text) && !NOT_IRI.test(text) ? `<${text}>` : null;
+}
+function filters(filter) {
+  const { language, predicates } = filter;
+  const lang = language === "" ? "" : ` FILTER(!isLiteral(?o) || lang(?o) = "" || langMatches(lang(?o), "${language}"))`;
+  const along = predicates.map((p) => `STRSTARTS(STR(?p), "${p}")`).join(" || ");
+  return predicates.length === 0 ? lang : `${lang} FILTER(isLiteral(?o) || ${along})`;
+}
+function validLanguage(language) {
+  return LANGUAGE.test(language);
+}
+function allQuery(filter, limit, offset) {
+  return pagedQuery(
+    `CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o .${filters(filter)} }`,
+    { ordered: false, templateVars: ["?s", "?p", "?o"] },
+    limit,
+    offset
+  );
+}
+function aroundQuery(iris, direction, filter, limit, offset) {
+  const values = iris.join(" ");
+  const out = `{ VALUES ?s { ${values} } ?s ?p ?o .${filters(filter)} }`;
+  const inward = `{ VALUES ?o { ${values} } ?s ?p ?o .${filters({ ...filter, language: "" })} }`;
+  let where = `${out} UNION ${inward}`;
+  if (direction !== "both") {
+    where = direction === "out" ? out : inward;
+  }
+  return pagedQuery(
+    `CONSTRUCT { ?s ?p ?o } WHERE { ${where} }`,
+    { ordered: false, templateVars: ["?s", "?p", "?o"] },
+    limit,
+    offset
+  );
+}
+const DEFAULT_PAGE_SIZE = 1e3;
+const DEFAULT_EXPAND_LIMIT = 500;
+const MAX_DEPTH = 10;
+const ACCEPT_TRIPLES = "application/n-triples, text/plain;q=0.9";
+async function send(ctx, query) {
+  throwIfAborted(ctx.signal);
+  const response = await ctx.fetch(ctx.endpoint ?? "", {
+    method: "POST",
+    idempotent: true,
+    headers: { Accept: ACCEPT_TRIPLES, "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ query }).toString(),
+    allowStatus: [400]
+  });
+  if (response.status === 400) {
+    const text = (await response.text()).trim().slice(0, 500);
+    failOn(ctx.report, "E_SOURCE_QUERY", "the endpoint refused the query", {
+      serverCode: null,
+      line: null,
+      column: null,
+      serverMessage: text === "" ? null : text
+    });
+  }
+  const contentType = response.headers.get("content-type");
+  const notTriples = () => failOn(ctx.report, "E_SOURCE_RESPONSE", "the endpoint did not answer N-Triples", {
+    expected: "n-triples",
+    contentType
+  });
+  if (contentType !== null && /html|json|xml/i.test(contentType)) {
+    notTriples();
+  }
+  const { triples, badLine } = parseNTriples(await response.text());
+  if (badLine !== null) {
+    notTriples();
+  }
+  return triples;
+}
+function integer(value, name, max, ctx) {
+  if (!Number.isInteger(value) || value < 1 || value > max) {
+    failOn(ctx.report, "E_SOURCE_PARAM", `${name} is an integer from 1 to ${String(max)}`, {
+      name,
+      reason: "range"
+    });
+  }
+  return value;
+}
+function languageOf(params, ctx) {
+  const language = params.language ?? "";
+  if (language !== "" && !validLanguage(language)) {
+    failOn(ctx.report, "E_SOURCE_PARAM", "language is a language tag", { name: "language", reason: "type" });
+  }
+  return language.toLowerCase();
+}
+function predicatesOf(params, ctx) {
+  const list = params.predicates ?? [];
+  const prefixes = typeof list === "string" ? [list] : list;
+  for (const p of prefixes) {
+    if (typeof p !== "string" || iriTerm(p) === null) {
+      failOn(ctx.report, "E_SOURCE_PARAM", "predicates are IRI prefixes", { name: "predicates", reason: "iri" });
+    }
+  }
+  return prefixes;
+}
+function irisOf(ids, name, ctx) {
+  if (ids === void 0 || ids.length === 0) {
+    failOn(ctx.report, "E_SOURCE_PARAM", `${name} needs at least one IRI`, { name, reason: "required" });
+  }
+  return ids.map(
+    (id) => iriTerm(id) ?? failOn(ctx.report, "E_SOURCE_PARAM", `${name}: not an IRI`, { name, reason: "iri" })
+  );
+}
+function planOf(params, ctx) {
+  const size = integer(params.pageSize ?? DEFAULT_PAGE_SIZE, "pageSize", 1e4, ctx);
+  const filter = { language: languageOf(params, ctx), predicates: predicatesOf(params, ctx) };
+  const query = params.query?.trim() ?? "";
+  const mode = params.mode ?? (query === "" ? "all" : "query");
+  if (mode === "neighborhood") {
+    const iris = irisOf(params.ids, "ids", ctx);
+    return { at: (offset) => aroundQuery(iris, "both", filter, size, offset), paged: true };
+  }
+  if (mode === "all") {
+    return { at: (offset) => allQuery(filter, size, offset), paged: true };
+  }
+  if (query === "") {
+    failOn(ctx.report, "E_SOURCE_PARAM", "mode query needs a query", { name: "query", reason: "required" });
+  }
+  const shape = readQuery(query);
+  if (shape.form !== "construct" && shape.form !== "describe") {
+    failOn(ctx.report, "E_SOURCE_PARAM", "the query must be CONSTRUCT or DESCRIBE", {
+      name: "query",
+      reason: "form"
+    });
+  }
+  if (shape.ownLimit) {
+    return { at: () => query, paged: false };
+  }
+  return { at: (offset) => pagedQuery(query, shape, size, offset), paged: true };
+}
+function write(graphed, sink, ctx) {
+  const { report } = ctx;
+  if (sink.edgeCount === 0) {
+    sink.setDirected(true);
+  }
+  for (const [id, attrs] of graphed.nodes) {
+    try {
+      sink.addNodeRecord(id, attrs);
+      report.counts.nodes++;
+    } catch (err) {
+      report.recordError(err, { element: id });
+      report.counts.skippedNodes++;
+    }
+  }
+  for (const { source, target, ...attrs } of graphed.edges) {
+    try {
+      sink.addEdgeRecord(source, target, attrs, null);
+      report.counts.edges++;
+    } catch (err) {
+      report.recordError(err, { element: `${source} -> ${target}` });
+      report.counts.skippedEdges++;
+    }
+  }
+}
+function hashOf(triples) {
+  return sha256Hex(triples.map(canonicalTriple).sort().join("\n"));
+}
+async function load(params, sink, ctx) {
+  const plan = planOf(params, ctx);
+  const size = params.pageSize ?? DEFAULT_PAGE_SIZE;
+  const start = Number(ctx.cursor?.offset ?? 0);
+  const language = languageOf(params, ctx);
+  let offset = start;
+  let next = null;
+  let contentHash;
+  for (; ; ) {
+    const triples = await send(ctx, plan.at(offset));
+    if (offset === 0) {
+      contentHash = await hashOf(triples);
+    }
+    write(graphTriples(triples, language), sink, ctx);
+    const { counts } = ctx.report;
+    ctx.progress(counts.nodes + counts.edges, void 0, "items");
+    if (!plan.paged || triples.length === 0) {
+      next = null;
+      break;
+    }
+    offset += size;
+    next = { offset };
+    if (ctx.limits.reached()) {
+      break;
+    }
+  }
+  return ctx.finish({ next, ...contentHash === void 0 ? {} : { validators: { contentHash } } });
+}
+async function expand(request, sink, ctx) {
+  const direction = request.direction ?? "both";
+  if (!["out", "in", "both"].includes(direction)) {
+    failOn(ctx.report, "E_SOURCE_PARAM", "direction must be out, in or both", {
+      name: "direction",
+      reason: "enum"
+    });
+  }
+  const depth = integer(request.depth ?? 1, "depth", MAX_DEPTH, ctx);
+  const limit = integer(request.limit ?? DEFAULT_EXPAND_LIMIT, "limit", Number.MAX_SAFE_INTEGER, ctx);
+  const language = languageOf(request.params, ctx);
+  const filter = { language, predicates: predicatesOf(request.params, ctx) };
+  const types = request.relationshipTypes === void 0 ? null : new Set(request.relationshipTypes);
+  const offset = depth === 1 ? Number(ctx.cursor?.offset ?? 0) : 0;
+  const seen = new Set(request.ids.map(String));
+  let frontier = irisOf(request.ids, "ids", ctx);
+  let next = null;
+  const graphed = { nodes: /* @__PURE__ */ new Map(), edges: [] };
+  for (let hop = 0; hop < depth && frontier.length > 0; hop++) {
+    const triples = await send(ctx, aroundQuery(frontier, direction, filter, limit, offset));
+    const before = graphed.edges.length;
+    graphTriples(triples, language, graphed);
+    if (types !== null) {
+      const kept = graphed.edges.slice(before).filter((e) => types.has(e.type) || types.has(e.predicate));
+      graphed.edges.splice(before, Infinity, ...kept);
+    }
+    if (depth === 1 && triples.length > 0) {
+      next = { offset: offset + limit };
+    }
+    const reached = graphed.edges.slice(before).flatMap((e) => [e.source, e.target]);
+    frontier = [...new Set(reached)].filter((id) => !seen.has(id)).flatMap((id) => {
+      seen.add(id);
+      const term = iriTerm(id);
+      return term === null ? [] : [term];
+    });
+  }
+  write(graphed, sink, ctx);
+  return ctx.finish({ next });
+}
+const sparqlSource = defineSource({
+  id: SPARQL_SOURCE_ID,
+  descriptor: SPARQL_DESCRIPTOR,
+  import: load,
+  expand,
+  probe: async (params, ctx) => {
+    await send(ctx, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o } LIMIT 1");
+    languageOf(params, ctx);
+    return { ok: true };
+  },
+  validate: async (params, seen, ctx) => {
+    const contentHash = await hashOf(await send(ctx, planOf(params, ctx).at(0)));
+    let status = "unverifiable";
+    if (seen.contentHash !== void 0) {
+      status = seen.contentHash === contentHash ? "current" : "changed";
+    }
+    return { status, via: "hash", validators: { contentHash } };
+  }
+});
+export {
+  SPARQL_DESCRIPTOR,
+  sparqlSource
+};
+//# sourceMappingURL=sources-sparql.js.map

package/dist/sources-sparql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources-sparql.js","sources":["../src/sources/sparql/ntriples.ts","../src/sources/sparql/query.ts","../src/sources/sparql/index.ts"],"sourcesContent":["/**\n * Reading the N-Triples a CONSTRUCT or DESCRIBE answers, and turning triples into nodes and edges:\n * an IRI or blank-node object is an edge from the subject, a literal is an attribute of the\n * subject named by the predicate's local name.\n */\n\n/** One RDF term. */\nexport type Term =\n    | { readonly kind: \"iri\"; readonly value: string }\n    | { readonly kind: \"bnode\"; readonly value: string }\n    | { readonly kind: \"literal\"; readonly value: string; readonly lang: string; readonly datatype: string };\n\n/** One triple. */\nexport interface Triple {\n    /** The subject: an IRI or a blank node. */\n    readonly s: Term;\n    /** The predicate IRI. */\n    readonly p: string;\n    /** The object. */\n    readonly o: Term;\n}\n\n/** One term at the sticky position: an IRI, a blank node, or a literal with its tag or type. */\nconst TERM = /\\s*(?:<([^<>]*)>|_:([\\w.-]*[\\w-])|\"((?:[^\"\\\\]|\\\\.)*)\"(?:@([A-Za-z][\\w-]*)|\\^\\^<([^<>]*)>)?)/y;\n\n/** The end of a statement: a dot, then an optional comment. */\nconst END = /\\s*\\.\\s*(?:#.*)?$/y;\n\n/** The XSD namespace. */\nconst XSD = \"http://www.w3.org/2001/XMLSchema#\";\n\n/** The XSD numeric types, read as numbers. */\nconst NUMERIC: ReadonlySet<string> = new Set(\n    [\n        \"integer\",\n        \"decimal\",\n        \"double\",\n        \"float\",\n        \"int\",\n        \"long\",\n        \"short\",\n        \"byte\",\n        \"nonNegativeInteger\",\n        \"nonPositiveInteger\",\n        \"positiveInteger\",\n        \"negativeInteger\",\n        \"unsignedInt\",\n        \"unsignedLong\",\n        \"unsignedShort\",\n        \"unsignedByte\",\n    ].map((t) => XSD + t),\n);\n\n/**\n * Undo N-Triples escapes.\n * @param text - escaped text\n * @returns the text\n */\nfunction unescape(text: string): string {\n    if (!text.includes(\"\\\\\")) {\n        return text;\n    }\n    const simple: Readonly<Record<string, string>> = { t: \"\\t\", b: \"\\b\", n: \"\\n\", r: \"\\r\", f: \"\\f\" };\n    return text.replaceAll(\n        /\\\\(?:u([\\da-fA-F]{4})|U([\\da-fA-F]{8})|(.))/g,\n        (_m, u4?: string, u8?: string, c?: string) => {\n            const hex = u4 ?? u8;\n            if (hex !== undefined) {\n                return String.fromCodePoint(Number.parseInt(hex, 16));\n            }\n            return simple[c ?? \"\"] ?? c ?? \"\";\n        },\n    );\n}\n\n/**\n * Read one term at `at`.\n * @param line - the line\n * @param at - where to start\n * @returns the term and where it ended, or null when there is none\n */\nfunction readTerm(line: string, at: number): { term: Term; end: number } | null {\n    TERM.lastIndex = at;\n    const m = TERM.exec(line);\n    if (m === null) {\n        return null;\n    }\n    const [, iri, bnode, lexical, lang, datatype] = m;\n    let term: Term;\n    if (iri !== undefined) {\n        term = { kind: \"iri\", value: unescape(iri) };\n    } else if (bnode === undefined) {\n        term = {\n            kind: \"literal\",\n            value: unescape(lexical ?? \"\"),\n            lang: lang?.toLowerCase() ?? \"\",\n            datatype: datatype ?? \"\",\n        };\n    } else {\n        term = { kind: \"bnode\", value: `_:${bnode}` };\n    }\n    return { term, end: TERM.lastIndex };\n}\n\n/**\n * Parse N-Triples.\n * @param text - the document\n * @returns the triples, or the 1-based number of the first line that is not a triple\n */\nexport function parseNTriples(text: string): { triples: Triple[]; badLine: number | null } {\n    const triples: Triple[] = [];\n    const lines = text.split(/\\r?\\n/);\n    for (let i = 0; i < lines.length; i++) {\n        const line = lines[i];\n        const trimmed = line.trim();\n        if (trimmed === \"\" || trimmed.startsWith(\"#\")) {\n            continue;\n        }\n        const s = readTerm(line, 0);\n        const p = s === null ? null : readTerm(line, s.end);\n        const o = p === null ? null : readTerm(line, p.end);\n        END.lastIndex = o?.end ?? 0;\n        if (\n            s === null ||\n            p === null ||\n            o === null ||\n            s.term.kind === \"literal\" ||\n            p.term.kind !== \"iri\" ||\n            !END.test(line)\n        ) {\n            return { triples, badLine: i + 1 };\n        }\n        triples.push({ s: s.term, p: p.term.value, o: o.term });\n    }\n    return { triples, badLine: null };\n}\n\n/**\n * The local name of an IRI: what follows its last `#`, else its last `/`, else its last `:`.\n * @param iri - the IRI\n * @returns the local name, or the whole IRI when nothing follows\n */\nexport function localName(iri: string): string {\n    const cut = Math.max(iri.lastIndexOf(\"#\"), iri.lastIndexOf(\"/\"), iri.lastIndexOf(\":\"));\n    const name = iri.slice(cut + 1);\n    return name === \"\" ? iri : name;\n}\n\n/**\n * A literal's value: numbers and booleans as such, everything else as its text.\n * @param term - the literal\n * @returns the value\n */\nfunction literalValue(term: Extract<Term, { kind: \"literal\" }>): string | number | boolean {\n    if (NUMERIC.has(term.datatype)) {\n        const n = Number(term.value);\n        return Number.isFinite(n) ? n : term.value;\n    }\n    if (term.datatype === `${XSD}boolean`) {\n        return term.value === \"true\" || term.value === \"1\";\n    }\n    return term.value;\n}\n\n/**\n * Whether a literal's language tag passes a language filter (SPARQL's langMatches, plus untagged).\n * @param lang - the literal's tag, lowercase\n * @param want - the filter, lowercase, or \"\" for none\n * @returns whether to keep it\n */\nfunction languageMatches(lang: string, want: string): boolean {\n    return want === \"\" || lang === \"\" || lang === want || lang.startsWith(`${want}-`);\n}\n\n/** The nodes and edges of some triples. */\nexport interface Graphed {\n    /** Each subject's literal attributes, by subject id; a predicate's first value wins. */\n    readonly nodes: Map<string, Record<string, string | number | boolean>>;\n    /** One edge per IRI or blank-node object. */\n    readonly edges: { source: string; target: string; type: string; predicate: string }[];\n}\n\n/**\n * Turn triples into nodes and edges.\n * @param triples - the triples\n * @param language - the language filter, lowercase, or \"\"\n * @param into - nodes and edges to add to\n * @returns the nodes and edges\n */\nexport function graphTriples(triples: readonly Triple[], language: string, into?: Graphed): Graphed {\n    const out: Graphed = into ?? { nodes: new Map(), edges: [] };\n    for (const { s, p, o } of triples) {\n        let attrs = out.nodes.get(s.value);\n        if (attrs === undefined) {\n            attrs = {};\n            out.nodes.set(s.value, attrs);\n        }\n        if (o.kind === \"literal\") {\n            const key = localName(p);\n            // ponytail: one value per predicate (the first); a list column if multi-valued literals matter\n            if (languageMatches(o.lang, language) && !(key in attrs)) {\n                attrs[key] = literalValue(o);\n            }\n        } else {\n            out.edges.push({ source: s.value, target: o.value, type: localName(p), predicate: p });\n        }\n    }\n    return out;\n}\n\n/**\n * One canonical line per triple, for the content hash.\n * @param t - the triple\n * @returns the line\n */\nexport function canonicalTriple(t: Triple): string {\n    const o = t.o.kind === \"literal\" ? JSON.stringify([t.o.value, t.o.lang, t.o.datatype]) : t.o.value;\n    return `${t.s.value} ${t.p} ${o}`;\n}\n","/**\n * The SPARQL the source sends: the caller's CONSTRUCT or DESCRIBE with the paging the source\n * adds (`ORDER BY` the template's variables, `LIMIT` and `OFFSET`), and the generated queries of\n * \"all\", \"neighborhood\" and expand (`VALUES ?s { ... }`).\n */\n\n/** Characters an IRIREF may not hold. */\nconst NOT_IRI = /[\\s<>\"{}|^`\\\\]/;\n\n/** A language tag a filter may name. */\nconst LANGUAGE = /^[a-z]{1,8}(-[a-z\\d]{1,8})*$/i;\n\n/** The query forms, as the first keyword after the prologue. */\ntype QueryForm = \"construct\" | \"describe\" | \"select\" | \"ask\" | null;\n\n/** What paging the caller's query takes. */\ninterface UserQuery {\n    /** Its form. */\n    readonly form: QueryForm;\n    /** Whether it sets its own LIMIT or OFFSET, so the source sends it as written. */\n    readonly ownLimit: boolean;\n    /** Whether it orders its solutions itself. */\n    readonly ordered: boolean;\n    /** The variables of a CONSTRUCT template, in order, for ORDER BY. */\n    readonly templateVars: readonly string[];\n}\n\n/**\n * The query with IRIs, strings and comments blanked out, so keywords and braces can be found.\n * @param query - the query\n * @returns the bare text\n */\nfunction bare(query: string): string {\n    return query\n        .replaceAll(/<[^<>\\s]*>/g, \"<>\")\n        .replaceAll(/\"\"\"[\\s\\S]*?\"\"\"|'''[\\s\\S]*?'''|\"(?:[^\"\\\\\\n]|\\\\.)*\"|'(?:[^'\\\\\\n]|\\\\.)*'/g, '\"\"')\n        .replaceAll(/#[^\\n]*/g, \"\");\n}\n\n/**\n * Read what paging a caller's query takes.\n * @param query - the query\n * @returns its form, its own modifiers and its template variables\n */\nexport function readQuery(query: string): UserQuery {\n    const text = bare(query);\n    const form = /\\b(CONSTRUCT|DESCRIBE|SELECT|ASK)\\b/i.exec(text)?.[1]?.toLowerCase() ?? null;\n    // the solution modifiers follow the last closing brace (a trailing VALUES block is not handled)\n    const tail = text.slice(text.lastIndexOf(\"}\") + 1);\n    let templateVars: string[] = [];\n    if (form === \"construct\") {\n        const template = /\\bCONSTRUCT\\s*\\{([^}]*)\\}/i.exec(text)?.[1] ?? \"\";\n        templateVars = [...new Set(template.match(/[?$]\\w+/g) ?? [])].map((v) => `?${v.slice(1)}`);\n    }\n    return {\n        form: form as QueryForm,\n        ownLimit: /\\b(LIMIT|OFFSET)\\b/i.test(tail),\n        ordered: /\\bORDER\\s+BY\\b/i.test(tail),\n        templateVars,\n    };\n}\n\n/**\n * The caller's query with one page's modifiers added.\n * @param query - the query\n * @param shape - what readQuery found\n * @param limit - solutions per page\n * @param offset - solutions to skip\n * @returns the query to send\n */\nexport function pagedQuery(query: string, shape: UserQuery, limit: number, offset: number): string {\n    const order = shape.ordered || shape.templateVars.length === 0 ? \"\" : `\\nORDER BY ${shape.templateVars.join(\" \")}`;\n    const skip = offset > 0 ? ` OFFSET ${String(offset)}` : \"\";\n    return `${query.trimEnd()}${order}\\nLIMIT ${String(limit)}${skip}`;\n}\n\n/**\n * An IRI as a SPARQL term, or null when it cannot be one.\n * @param id - the id\n * @returns `<iri>`, or null\n */\nexport function iriTerm(id: unknown): string | null {\n    const text = String(id);\n    return /^[a-z][\\w+.-]*:/i.test(text) && !NOT_IRI.test(text) ? `<${text}>` : null;\n}\n\n/** What generated queries keep: literals in a language, edges along some predicates. */\ninterface TripleFilter {\n    /** Keep literals tagged with this language or untagged; \"\" keeps every literal. */\n    readonly language: string;\n    /** Keep edges whose predicate starts with one of these IRIs; empty keeps every edge. */\n    readonly predicates: readonly string[];\n}\n\n/**\n * The FILTERs of generated queries, or \"\" for none. Both values are checked by the caller.\n * @param filter - the language and the predicate prefixes\n * @returns the FILTER clauses\n */\nfunction filters(filter: TripleFilter): string {\n    const { language, predicates } = filter;\n    const lang =\n        language === \"\" ? \"\" : ` FILTER(!isLiteral(?o) || lang(?o) = \"\" || langMatches(lang(?o), \"${language}\"))`;\n    const along = predicates.map((p) => `STRSTARTS(STR(?p), \"${p}\")`).join(\" || \");\n    return predicates.length === 0 ? lang : `${lang} FILTER(isLiteral(?o) || ${along})`;\n}\n\n/**\n * Whether a language tag may go into a FILTER.\n * @param language - the tag\n * @returns whether it is well formed\n */\nexport function validLanguage(language: string): boolean {\n    return LANGUAGE.test(language);\n}\n\n/**\n * Mode \"all\": every triple, ordered so pages are stable.\n * @param filter - what to keep\n * @param limit - solutions per page\n * @param offset - solutions to skip\n * @returns the query\n */\nexport function allQuery(filter: TripleFilter, limit: number, offset: number): string {\n    return pagedQuery(\n        `CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o .${filters(filter)} }`,\n        { form: \"construct\", ownLimit: false, ordered: false, templateVars: [\"?s\", \"?p\", \"?o\"] },\n        limit,\n        offset,\n    );\n}\n\n/**\n * The triples around some IRIs: out (`VALUES ?s`), in (`VALUES ?o`) or both.\n * @param iris - the IRIs as terms\n * @param direction - which triples\n * @param filter - what to keep\n * @param limit - solutions per page\n * @param offset - solutions to skip\n * @returns the query\n */\nexport function aroundQuery(\n    iris: readonly string[],\n    direction: \"out\" | \"in\" | \"both\",\n    filter: TripleFilter,\n    limit: number,\n    offset: number,\n): string {\n    const values = iris.join(\" \");\n    const out = `{ VALUES ?s { ${values} } ?s ?p ?o .${filters(filter)} }`;\n    const inward = `{ VALUES ?o { ${values} } ?s ?p ?o .${filters({ ...filter, language: \"\" })} }`;\n    let where = `${out} UNION ${inward}`;\n    if (direction !== \"both\") {\n        where = direction === \"out\" ? out : inward;\n    }\n    return pagedQuery(\n        `CONSTRUCT { ?s ?p ?o } WHERE { ${where} }`,\n        { form: \"construct\", ownLimit: false, ordered: false, templateVars: [\"?s\", \"?p\", \"?o\"] },\n        limit,\n        offset,\n    );\n}\n","/**\n * `@graphty/graph-io/sources/sparql`: the SPARQL source. It sends CONSTRUCT (or DESCRIBE) queries\n * over the SPARQL 1.1 protocol (a form POST, N-Triples back) and reads the triples as a graph: an\n * IRI or blank-node object is an edge from the subject (`type` is the predicate's local name,\n * `predicate` the full IRI), a literal is an attribute of the subject named by the predicate's\n * local name. Node ids are the IRIs.\n *\n * - Paging: the source adds `ORDER BY` (the template's variables) and `LIMIT` / `OFFSET` to the\n *   caller's query, unless it sets its own; a load stops between pages at a cap and hands back\n *   `{ offset }` as its cursor. A page is `pageSize` solutions, so its triple count varies; the\n *   first empty page ends the load.\n * - Expand: the triples of the seeds, `VALUES ?s { ... }` out and `VALUES ?o { ... }` in.\n * - Validate: SHA-256 of the first page's triples.\n *\n * Experimental.\n * @module @graphty/graph-io/sources/sparql\n */\n\nimport { type GraphSink } from \"@graphty/graph-format\";\n\nimport { throwIfAborted } from \"../../common/input.js\";\nimport { type ImportReport } from \"../../types.js\";\nimport { defineSource } from \"../define.js\";\nimport { failOn } from \"../fail.js\";\nimport { SPARQL_SOURCE_ID } from \"../ids.js\";\nimport { sha256Hex } from \"../sigv4.js\";\nimport {\n    type ExpandRequest,\n    type GraphSource,\n    type SourceContext,\n    type SourceCursor,\n    type SourceFreshness,\n    type SourceProbe,\n} from \"../types.js\";\nimport { SPARQL_DESCRIPTOR } from \"./descriptor.js\";\nimport { canonicalTriple, type Graphed, graphTriples, parseNTriples, type Triple } from \"./ntriples.js\";\nimport { type SparqlParams } from \"./params.js\";\nimport { allQuery, aroundQuery, iriTerm, pagedQuery, readQuery, validLanguage } from \"./query.js\";\n\nexport { SPARQL_DESCRIPTOR } from \"./descriptor.js\";\nexport { type SparqlParams } from \"./params.js\";\n\n/** Solutions per page when the params name none. */\nconst DEFAULT_PAGE_SIZE = 1000;\n\n/** Triples per hop of an expansion when the request names no limit. */\nconst DEFAULT_EXPAND_LIMIT = 500;\n\n/** The deepest expansion, as for every built-in source. */\nconst MAX_DEPTH = 10;\n\n/** What CONSTRUCT and DESCRIBE are asked to answer. */\nconst ACCEPT_TRIPLES = \"application/n-triples, text/plain;q=0.9\";\n\n/** One page's query, by offset; `paged` false when the query is sent once, as written. */\ninterface Plan {\n    /** The query of the page at an offset. */\n    readonly at: (offset: number) => string;\n    /** Whether the source pages it. */\n    readonly paged: boolean;\n}\n\n/**\n * Send a query and read the answer as N-Triples.\n * @param ctx - the context\n * @param query - the query\n * @returns the triples\n */\nasync function send(ctx: SourceContext, query: string): Promise<Triple[]> {\n    throwIfAborted(ctx.signal);\n    const response = await ctx.fetch(ctx.endpoint ?? \"\", {\n        method: \"POST\",\n        idempotent: true,\n        headers: { Accept: ACCEPT_TRIPLES, \"Content-Type\": \"application/x-www-form-urlencoded\" },\n        body: new URLSearchParams({ query }).toString(),\n        allowStatus: [400],\n    });\n    if (response.status === 400) {\n        const text = (await response.text()).trim().slice(0, 500);\n        failOn(ctx.report, \"E_SOURCE_QUERY\", \"the endpoint refused the query\", {\n            serverCode: null,\n            line: null,\n            column: null,\n            serverMessage: text === \"\" ? null : text,\n        });\n    }\n    const contentType = response.headers.get(\"content-type\");\n    const notTriples = (): never =>\n        failOn(ctx.report, \"E_SOURCE_RESPONSE\", \"the endpoint did not answer N-Triples\", {\n            expected: \"n-triples\",\n            contentType,\n        });\n    if (contentType !== null && /html|json|xml/i.test(contentType)) {\n        notTriples();\n    }\n    const { triples, badLine } = parseNTriples(await response.text());\n    if (badLine !== null) {\n        notTriples();\n    }\n    return triples;\n}\n\n/**\n * A whole-number param, checked.\n * @param value - the value\n * @param name - the param\n * @param max - the largest allowed\n * @param ctx - the context\n * @returns the number\n */\nfunction integer(value: number, name: string, max: number, ctx: SourceContext): number {\n    if (!Number.isInteger(value) || value < 1 || value > max) {\n        failOn(ctx.report, \"E_SOURCE_PARAM\", `${name} is an integer from 1 to ${String(max)}`, {\n            name,\n            reason: \"range\",\n        });\n    }\n    return value;\n}\n\n/**\n * The language filter, lowercase and checked, or \"\" for none.\n * @param params - the params\n * @param ctx - the context\n * @returns the tag\n */\nfunction languageOf(params: SparqlParams, ctx: SourceContext): string {\n    const language = params.language ?? \"\";\n    if (language !== \"\" && !validLanguage(language)) {\n        failOn(ctx.report, \"E_SOURCE_PARAM\", \"language is a language tag\", { name: \"language\", reason: \"type\" });\n    }\n    return language.toLowerCase();\n}\n\n/**\n * The predicate prefixes generated queries follow, checked.\n * @param params - the params\n * @param ctx - the context\n * @returns the prefixes; empty means every predicate\n */\nfunction predicatesOf(params: SparqlParams, ctx: SourceContext): readonly string[] {\n    const list = params.predicates ?? [];\n    const prefixes = typeof list === \"string\" ? [list] : list;\n    for (const p of prefixes) {\n        if (typeof p !== \"string\" || iriTerm(p) === null) {\n            failOn(ctx.report, \"E_SOURCE_PARAM\", \"predicates are IRI prefixes\", { name: \"predicates\", reason: \"iri\" });\n        }\n    }\n    return prefixes;\n}\n\n/**\n * Seed ids as IRI terms; a blank node or anything else that is not an IRI is refused.\n * @param ids - the ids\n * @param name - the param, for the error\n * @param ctx - the context\n * @returns the terms\n */\nfunction irisOf(ids: readonly unknown[] | undefined, name: string, ctx: SourceContext): string[] {\n    if (ids === undefined || ids.length === 0) {\n        failOn(ctx.report, \"E_SOURCE_PARAM\", `${name} needs at least one IRI`, { name, reason: \"required\" });\n    }\n    return ids.map(\n        (id) => iriTerm(id) ?? failOn(ctx.report, \"E_SOURCE_PARAM\", `${name}: not an IRI`, { name, reason: \"iri\" }),\n    );\n}\n\n/**\n * What a load sends, from its mode.\n * @param params - the params\n * @param ctx - the context\n * @returns the plan\n */\nfunction planOf(params: SparqlParams, ctx: SourceContext): Plan {\n    const size = integer(params.pageSize ?? DEFAULT_PAGE_SIZE, \"pageSize\", 10_000, ctx);\n    const filter = { language: languageOf(params, ctx), predicates: predicatesOf(params, ctx) };\n    const query = params.query?.trim() ?? \"\";\n    const mode = params.mode ?? (query === \"\" ? \"all\" : \"query\");\n    if (mode === \"neighborhood\") {\n        const iris = irisOf(params.ids, \"ids\", ctx);\n        return { at: (offset) => aroundQuery(iris, \"both\", filter, size, offset), paged: true };\n    }\n    if (mode === \"all\") {\n        return { at: (offset) => allQuery(filter, size, offset), paged: true };\n    }\n    if (query === \"\") {\n        failOn(ctx.report, \"E_SOURCE_PARAM\", \"mode query needs a query\", { name: \"query\", reason: \"required\" });\n    }\n    const shape = readQuery(query);\n    if (shape.form !== \"construct\" && shape.form !== \"describe\") {\n        failOn(ctx.report, \"E_SOURCE_PARAM\", \"the query must be CONSTRUCT or DESCRIBE\", {\n            name: \"query\",\n            reason: \"form\",\n        });\n    }\n    if (shape.ownLimit) {\n        return { at: () => query, paged: false };\n    }\n    return { at: (offset) => pagedQuery(query, shape, size, offset), paged: true };\n}\n\n/**\n * Write nodes and edges into the sink, counting them on the report.\n * @param graphed - the nodes and edges\n * @param sink - where to write\n * @param ctx - the context\n */\nfunction write(graphed: Graphed, sink: GraphSink, ctx: SourceContext): void {\n    const { report } = ctx;\n    if (sink.edgeCount === 0) {\n        sink.setDirected(true);\n    }\n    for (const [id, attrs] of graphed.nodes) {\n        try {\n            sink.addNodeRecord(id, attrs);\n            report.counts.nodes++;\n        } catch (err) {\n            report.recordError(err, { element: id });\n            report.counts.skippedNodes++;\n        }\n    }\n    for (const { source, target, ...attrs } of graphed.edges) {\n        try {\n            sink.addEdgeRecord(source, target, attrs, null);\n            report.counts.edges++;\n        } catch (err) {\n            report.recordError(err, { element: `${source} -> ${target}` });\n            report.counts.skippedEdges++;\n        }\n    }\n}\n\n/**\n * The content hash of some triples, in any order.\n * @param triples - the triples\n * @returns the SHA-256, hex\n */\nfunction hashOf(triples: readonly Triple[]): Promise<string> {\n    return sha256Hex(triples.map(canonicalTriple).sort().join(\"\\n\")); // NOSONAR(S2871): code-unit order is the point: a locale-free, stable order for the hash\n}\n\n/**\n * Load pages into the sink from the cursor's offset until an empty page or a cap.\n * @param params - the params\n * @param sink - where to write\n * @param ctx - the context\n * @returns the report\n */\nasync function load(params: SparqlParams, sink: GraphSink, ctx: SourceContext): Promise<ImportReport> {\n    const plan = planOf(params, ctx);\n    const size = params.pageSize ?? DEFAULT_PAGE_SIZE;\n    const start = Number(ctx.cursor?.offset ?? 0);\n    const language = languageOf(params, ctx);\n    let offset = start;\n    let next: SourceCursor | null = null;\n    let contentHash: string | undefined;\n    for (;;) {\n        const triples = await send(ctx, plan.at(offset));\n        if (offset === 0) {\n            contentHash = await hashOf(triples);\n        }\n        write(graphTriples(triples, language), sink, ctx);\n        const { counts } = ctx.report;\n        ctx.progress(counts.nodes + counts.edges, undefined, \"items\");\n        if (!plan.paged || triples.length === 0) {\n            next = null;\n            break;\n        }\n        offset += size;\n        next = { offset };\n        if (ctx.limits.reached()) {\n            break;\n        }\n    }\n    return ctx.finish({ next, ...(contentHash === undefined ? {} : { validators: { contentHash } }) });\n}\n\n/**\n * Fetch the triples around some IRIs into the sink, hop by hop.\n * @param request - the seeds, direction, depth, limit and predicate filter\n * @param sink - where to write\n * @param ctx - the context\n * @returns the report\n */\nasync function expand(\n    request: ExpandRequest<SparqlParams>,\n    sink: GraphSink,\n    ctx: SourceContext,\n): Promise<ImportReport> {\n    const direction = request.direction ?? \"both\";\n    if (![\"out\", \"in\", \"both\"].includes(direction)) {\n        failOn(ctx.report, \"E_SOURCE_PARAM\", \"direction must be out, in or both\", {\n            name: \"direction\",\n            reason: \"enum\",\n        });\n    }\n    const depth = integer(request.depth ?? 1, \"depth\", MAX_DEPTH, ctx);\n    const limit = integer(request.limit ?? DEFAULT_EXPAND_LIMIT, \"limit\", Number.MAX_SAFE_INTEGER, ctx);\n    const language = languageOf(request.params, ctx);\n    const filter = { language, predicates: predicatesOf(request.params, ctx) };\n    const types = request.relationshipTypes === undefined ? null : new Set(request.relationshipTypes);\n    // a capped one-hop expansion resumes at its offset; deeper ones are read whole per hop\n    const offset = depth === 1 ? Number(ctx.cursor?.offset ?? 0) : 0;\n    const seen = new Set<string>(request.ids.map(String));\n    let frontier = irisOf(request.ids, \"ids\", ctx);\n    let next: SourceCursor | null = null;\n    const graphed: Graphed = { nodes: new Map(), edges: [] };\n    for (let hop = 0; hop < depth && frontier.length > 0; hop++) {\n        const triples = await send(ctx, aroundQuery(frontier, direction, filter, limit, offset));\n        const before = graphed.edges.length;\n        graphTriples(triples, language, graphed);\n        if (types !== null) {\n            const kept = graphed.edges.slice(before).filter((e) => types.has(e.type) || types.has(e.predicate));\n            graphed.edges.splice(before, Infinity, ...kept);\n        }\n        if (depth === 1 && triples.length > 0) {\n            next = { offset: offset + limit };\n        }\n        const reached = graphed.edges.slice(before).flatMap((e) => [e.source, e.target]);\n        frontier = [...new Set(reached)]\n            .filter((id) => !seen.has(id))\n            .flatMap((id) => {\n                seen.add(id);\n                const term = iriTerm(id);\n                return term === null ? [] : [term];\n            });\n    }\n    write(graphed, sink, ctx);\n    return ctx.finish({ next });\n}\n\n/**\n * The SPARQL source: CONSTRUCT or DESCRIBE queries against any SPARQL 1.1 endpoint, paged by\n * `LIMIT` and `OFFSET`, expanded by `VALUES`, validated by a hash of the first page. Experimental.\n * @category Network sources\n */\nexport const sparqlSource: GraphSource<SparqlParams> = defineSource<SparqlParams>({\n    id: SPARQL_SOURCE_ID,\n    descriptor: SPARQL_DESCRIPTOR,\n    import: load,\n    expand,\n    probe: async (params, ctx): Promise<SourceProbe> => {\n        // the endpoint answers a one-solution query: it is up, it reads SPARQL, the credential works\n        await send(ctx, \"CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o } LIMIT 1\");\n        languageOf(params, ctx);\n        return { ok: true };\n    },\n    validate: async (params, seen, ctx): Promise<SourceFreshness> => {\n        const contentHash = await hashOf(await send(ctx, planOf(params, ctx).at(0)));\n        let status: SourceFreshness[\"status\"] = \"unverifiable\";\n        if (seen.contentHash !== undefined) {\n            status = seen.contentHash === contentHash ? \"current\" : \"changed\";\n        }\n        return { status, via: \"hash\", validators: { contentHash } };\n    },\n});\n"],"names":[],"mappings":"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"}

package/dist/src/formats/cx/importer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"importer.d.ts","sourceRoot":"","sources":["../../../../src/formats/cx/importer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AA6FH,OAAO,EACH,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAIrB,MAAM,gBAAgB,CAAC;AAUxB;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,kBAAkB,EAAE,mBAAmB;IAC5E;;;;OAIG;IACH,GAAG,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;IAGjB,4CAA4C;;IAE5C,oDAAoD;;IAEpD,sDAAsD;;IAEtD;;;OAGG;;IAEH,0DAA0D;;IAE1D,0DAA0D;;IAE1D,8GAA8G;;IAE9G,4EAA4E;;IAE5E,gGAAgG;;IAEhG,wEAAwE;;IAExE,iHAAiH;;IAEjH,kGAAkG;;IAElG,gHAAgH;;IAEhH;;;OAGG;;IAEH,+EAA+E;;IAE/E,6DAA6D;;IAE7D,uEAAuE;;IAEvE;;;OAGG;;IAEH,iEAAiE;;IAEjE,gGAAgG;;IAEhG,qGAAqG;;IAErG,qCAAqC;;IAErC,mEAAmE;;IAEnE,4GAA4G;;IAE5G,iEAAiE;;IAEjE,8BAA8B;;IAE9B,kEAAkE;;IAElE,6DAA6D;;IAE7D,oCAAoC;;IAEpC;;;OAGG;;IAEH,2FAA2F;;IAE3F,sFAAsF;;IAEtF,+FAA+F;;IAE/F,yFAAyF;;IAEzF,qCAAqC;;IAErC,+EAA+E;;IAE/E,gHAAgH;;IAEhH,iDAAiD;;IAEjD;;;OAGG;;IAEH,2EAA2E;;IAE3E,iEAAiE;;IAEjE,kDAAkD;;IAElD;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH,0FAA0F;;IAE1F,kGAAkG;;IAElG;;;OAGG;;IAEH,wEAAwE;;;;;;;;EAE1E,CAAC;AAm/FH;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,aAAa,CAAC,eAAe,CAqGpD,CAAC"}
+{"version":3,"file":"importer.d.ts","sourceRoot":"","sources":["../../../../src/formats/cx/importer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AA6FH,OAAO,EACH,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAIrB,MAAM,gBAAgB,CAAC;AAUxB;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,kBAAkB,EAAE,mBAAmB;IAC5E;;;;OAIG;IACH,GAAG,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;IAGjB,4CAA4C;;IAE5C,oDAAoD;;IAEpD,sDAAsD;;IAEtD;;;OAGG;;IAEH,0DAA0D;;IAE1D,0DAA0D;;IAE1D,8GAA8G;;IAE9G,4EAA4E;;IAE5E,gGAAgG;;IAEhG,wEAAwE;;IAExE,iHAAiH;;IAEjH,kGAAkG;;IAElG,gHAAgH;;IAEhH;;;OAGG;;IAEH,+EAA+E;;IAE/E,6DAA6D;;IAE7D,uEAAuE;;IAEvE;;;OAGG;;IAEH,iEAAiE;;IAEjE,gGAAgG;;IAEhG,qGAAqG;;IAErG,qCAAqC;;IAErC,mEAAmE;;IAEnE,4GAA4G;;IAE5G,iEAAiE;;IAEjE,8BAA8B;;IAE9B,kEAAkE;;IAElE,6DAA6D;;IAE7D,oCAAoC;;IAEpC;;;OAGG;;IAEH,2FAA2F;;IAE3F,sFAAsF;;IAEtF,+FAA+F;;IAE/F,yFAAyF;;IAEzF,qCAAqC;;IAErC,+EAA+E;;IAE/E,gHAAgH;;IAEhH,iDAAiD;;IAEjD;;;OAGG;;IAEH,2EAA2E;;IAE3E,iEAAiE;;IAEjE,kDAAkD;;IAElD;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH,0FAA0F;;IAE1F,kGAAkG;;IAElG;;;OAGG;;IAEH,wEAAwE;;;;;;;;EAE1E,CAAC;AAw/FH;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,aAAa,CAAC,eAAe,CAqGpD,CAAC"}

package/dist/src/formats/cx/importer.js

@@ -2278,7 +2278,11 @@ class CxReader {
             }
             return true;
         });
-        const source = others.size > 0 ? { entries: kept, otherViews: others.size } : { entries: kept };
+        const { weightFrom } = this.options;
+        const collection = aspect(this.doc, "cySubNetworks").length > 0;
+        const source = others.size > 0
+            ? { entries: kept, otherViews: others.size, weightFrom, collection }
+            : { entries: kept, weightFrom, collection };
         this.report.keepForStyles(source);
     }
     /**