n3writer-wrapper 1.0.0

package/dist/index.cjs

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  expandLiterals: () => expandLiterals,
+  reindent: () => reindent,
+  topoWrite: () => topoWrite
+});
+module.exports = __toCommonJS(index_exports);
+function topoWrite(writer, quads) {
+  const termKey = (t) => t.termType === "Literal" ? `L\0${t.value}\0${t.datatype?.value ?? ""}\0${t.language ?? ""}` : `${t.termType[0]}\0${t.value}`;
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [...quads].filter((q) => {
+    const k = `${termKey(q.graph)}\0${termKey(q.subject)}\0${q.predicate.value}\0${termKey(q.object)}`;
+    return seen.size !== seen.add(k).size;
+  });
+  const bySub = /* @__PURE__ */ new Map();
+  const oCount = /* @__PURE__ */ new Map();
+  for (const q of deduped) {
+    const k = `${q.graph.value}\0${q.subject.termType}\0${q.subject.value}`;
+    if (!bySub.has(k)) bySub.set(k, { term: q.subject, graph: q.graph, pos: [] });
+    bySub.get(k).pos.push(q);
+    if (q.object.termType === "BlankNode") {
+      const ok = `${q.graph.value}\0${q.object.value}`;
+      oCount.set(ok, (oCount.get(ok) ?? 0) + 1);
+    }
+  }
+  const inlineable = (bn, graph) => oCount.get(`${graph.value}\0${bn.value}`) === 1 && bySub.has(`${graph.value}\0BlankNode\0${bn.value}`);
+  function buildBlank(bn, graph) {
+    const entry = bySub.get(`${graph.value}\0BlankNode\0${bn.value}`);
+    if (!entry) return writer.blank();
+    return writer.blank(
+      entry.pos.map((q) => ({
+        predicate: q.predicate,
+        object: q.object.termType === "BlankNode" && inlineable(q.object, graph) ? buildBlank(q.object, graph) : q.object
+      }))
+    );
+  }
+  for (const { term, graph, pos } of bySub.values()) {
+    if (term.termType === "BlankNode" && inlineable(term, graph)) continue;
+    for (const q of pos) {
+      writer.addQuad(
+        q.subject,
+        q.predicate,
+        q.object.termType === "BlankNode" && inlineable(q.object, graph) ? buildBlank(q.object, graph) : q.object,
+        q.graph
+      );
+    }
+  }
+}
+function reindent(turtle, step = "  ") {
+  let depth = 0;
+  return turtle.split("\n").map((line) => {
+    const t = line.trimStart();
+    if (!t) return "";
+    let leading = 0;
+    while (leading < t.length && t[leading] === "]") {
+      depth = Math.max(0, depth - 1);
+      leading++;
+    }
+    let out;
+    if (depth > 0) {
+      out = step.repeat(depth + 1) + t;
+    } else if (leading > 0 || line !== t) {
+      out = step + t;
+    } else {
+      out = line.trimEnd();
+    }
+    if (t.trimEnd().endsWith("[")) {
+      let opens = 0, closes = 0, inStr = false, i = 0;
+      while (i < t.length) {
+        const c = t[i];
+        if (c === "\\" && inStr) {
+          i += 2;
+          continue;
+        }
+        if (c === '"') inStr = !inStr;
+        else if (!inStr) {
+          if (c === "[") opens++;
+          else if (c === "]") closes++;
+        }
+        i++;
+      }
+      const netOpen = opens - closes + leading;
+      if (netOpen > 0) depth += netOpen;
+    }
+    return out;
+  }).join("\n");
+}
+function expandLiterals(turtle) {
+  return turtle.replace(/"((?:[^"\\]|\\.)*)"/g, (match, content) => {
+    if (!content.includes("\\n")) return match;
+    const expanded = content.replace(/\\n/g, "\n");
+    if (expanded.includes('"""')) return match;
+    return `"""${expanded}"""`;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandLiterals,
+  reindent,
+  topoWrite
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * n3writer-wrapper\n *\n * Helpers that improve the readability of Turtle/TriG output from n3.Writer:\n *\n *   topoWrite(writer, quads)  — feed quads to an N3 Writer using nested [ ]\n *                               notation for blank nodes that appear as an\n *                               object exactly once (tree-edge inlining).\n *\n *   reindent(turtle, step?)   — post-process a Turtle/TriG string so that\n *                               predicate-continuation lines use `step`\n *                               (default 2 spaces) instead of n3.Writer's\n *                               hard-coded 4, and blank-node content at depth\n *                               d uses step × (d+1).\n *\n *   expandLiterals(turtle)    — convert STRING_LITERAL2 values containing \\n\n *                               into STRING_LITERAL_LONG2 (\"\"\"…\"\"\") with a\n *                               real embedded newline.\n */\n\n/** Minimal structural interface for terms (compatible with n3, rdfjs, graphy). */\nexport interface RdfTerm {\n  termType: string;\n  value: string;\n  datatype?: { value: string };\n  language?: string;\n}\n\n/** Minimal structural interface for quads. */\nexport interface RdfQuad {\n  subject: RdfTerm;\n  predicate: RdfTerm;\n  object: RdfTerm;\n  graph: RdfTerm;\n}\n\n/**\n * Minimal structural interface for the n3.Writer methods that topoWrite uses.\n * Any object that provides blank() and addQuad() with these signatures works.\n */\nexport interface TurtleWriter {\n  blank(predicates?: Array<{ predicate: RdfTerm; object: unknown }>): unknown;\n  addQuad(subject: RdfTerm, predicate: RdfTerm, object: unknown, graph?: RdfTerm): void;\n}\n\n/**\n * Write quads to an N3 Writer using nested [ ] notation for blank nodes that\n * appear as an object exactly once (sole child in a tree edge).  Blank nodes\n * used more than once as objects, or that have no subject triples, fall back\n * to the normal _:label reference.  CONSTRUCT-style duplicate quads are\n * deduplicated before processing.\n */\nexport function topoWrite(writer: TurtleWriter, quads: Iterable<RdfQuad>): void {\n  const termKey = (t: RdfTerm): string =>\n    t.termType === 'Literal'\n      ? `L\\0${t.value}\\0${t.datatype?.value ?? ''}\\0${t.language ?? ''}`\n      : `${t.termType[0]}\\0${t.value}`;\n\n  const seen = new Set<string>();\n  const deduped = [...quads].filter(q => {\n    const k = `${termKey(q.graph)}\\0${termKey(q.subject)}\\0${q.predicate.value}\\0${termKey(q.object)}`;\n    return seen.size !== seen.add(k).size;\n  });\n\n  // Index quads by (graph, subject); count blank-node object occurrences per graph.\n  const bySub = new Map<string, { term: RdfTerm; graph: RdfTerm; pos: RdfQuad[] }>();\n  const oCount = new Map<string, number>();\n\n  for (const q of deduped) {\n    const k = `${q.graph.value}\\0${q.subject.termType}\\0${q.subject.value}`;\n    if (!bySub.has(k)) bySub.set(k, { term: q.subject, graph: q.graph, pos: [] });\n    bySub.get(k)!.pos.push(q);\n    if (q.object.termType === 'BlankNode') {\n      const ok = `${q.graph.value}\\0${q.object.value}`;\n      oCount.set(ok, (oCount.get(ok) ?? 0) + 1);\n    }\n  }\n\n  const inlineable = (bn: RdfTerm, graph: RdfTerm): boolean =>\n    oCount.get(`${graph.value}\\0${bn.value}`) === 1 &&\n    bySub.has(`${graph.value}\\0BlankNode\\0${bn.value}`);\n\n  function buildBlank(bn: RdfTerm, graph: RdfTerm): unknown {\n    const entry = bySub.get(`${graph.value}\\0BlankNode\\0${bn.value}`);\n    if (!entry) return writer.blank();\n    return writer.blank(\n      entry.pos.map(q => ({\n        predicate: q.predicate,\n        object:\n          q.object.termType === 'BlankNode' && inlineable(q.object, graph)\n            ? buildBlank(q.object, graph)\n            : q.object,\n      })),\n    );\n  }\n\n  for (const { term, graph, pos } of bySub.values()) {\n    if (term.termType === 'BlankNode' && inlineable(term, graph)) continue;\n    for (const q of pos) {\n      writer.addQuad(\n        q.subject,\n        q.predicate,\n        q.object.termType === 'BlankNode' && inlineable(q.object, graph)\n          ? buildBlank(q.object, graph)\n          : q.object,\n        q.graph,\n      );\n    }\n  }\n}\n\n/**\n * Post-process an N3.js Writer Turtle/TriG string with uniform indentation.\n *\n * n3.Writer uses 4 spaces for predicate-continuation lines and 2 spaces inside\n * blank-node [ ] blocks.  reindent normalises this so that each additional level\n * of [ ] nesting adds exactly one `step` (default: 2 spaces).\n */\nexport function reindent(turtle: string, step = '  '): string {\n  let depth = 0;\n  return turtle\n    .split('\\n')\n    .map(line => {\n      const t = line.trimStart();\n      if (!t) return '';\n\n      // Leading ] chars close blocks: reduce depth before outputting this line.\n      let leading = 0;\n      while (leading < t.length && t[leading] === ']') {\n        depth = Math.max(0, depth - 1);\n        leading++;\n      }\n\n      let out: string;\n      if (depth > 0) {\n        out = step.repeat(depth + 1) + t;\n      } else if (leading > 0 || line !== t) {\n        out = step + t;\n      } else {\n        out = line.trimEnd();\n      }\n\n      // Count net unbalanced [ brackets outside string literals to track depth.\n      if (t.trimEnd().endsWith('[')) {\n        let opens = 0,\n          closes = 0,\n          inStr = false,\n          i = 0;\n        while (i < t.length) {\n          const c = t[i];\n          if (c === '\\\\' && inStr) {\n            i += 2;\n            continue;\n          }\n          if (c === '\"') inStr = !inStr;\n          else if (!inStr) {\n            if (c === '[') opens++;\n            else if (c === ']') closes++;\n          }\n          i++;\n        }\n        const netOpen = opens - closes + leading;\n        if (netOpen > 0) depth += netOpen;\n      }\n\n      return out;\n    })\n    .join('\\n');\n}\n\n/**\n * Replace STRING_LITERAL2 values that contain the \\n escape sequence with\n * STRING_LITERAL_LONG2 (triple-quoted) with a real embedded newline.\n *\n * Falls back to the original form if the expanded content contains \"\"\" (which\n * cannot appear unescaped inside a long literal).\n */\nexport function expandLiterals(turtle: string): string {\n  return turtle.replace(/\"((?:[^\"\\\\]|\\\\.)*)\"/g, (match, content: string) => {\n    if (!content.includes('\\\\n')) return match;\n    const expanded = content.replace(/\\\\n/g, '\\n');\n    if (expanded.includes('\"\"\"')) return match;\n    return `\"\"\"${expanded}\"\"\"`;\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,72 @@
+/**
+ * n3writer-wrapper
+ *
+ * Helpers that improve the readability of Turtle/TriG output from n3.Writer:
+ *
+ *   topoWrite(writer, quads)  — feed quads to an N3 Writer using nested [ ]
+ *                               notation for blank nodes that appear as an
+ *                               object exactly once (tree-edge inlining).
+ *
+ *   reindent(turtle, step?)   — post-process a Turtle/TriG string so that
+ *                               predicate-continuation lines use `step`
+ *                               (default 2 spaces) instead of n3.Writer's
+ *                               hard-coded 4, and blank-node content at depth
+ *                               d uses step × (d+1).
+ *
+ *   expandLiterals(turtle)    — convert STRING_LITERAL2 values containing \n
+ *                               into STRING_LITERAL_LONG2 ("""…""") with a
+ *                               real embedded newline.
+ */
+/** Minimal structural interface for terms (compatible with n3, rdfjs, graphy). */
+interface RdfTerm {
+    termType: string;
+    value: string;
+    datatype?: {
+        value: string;
+    };
+    language?: string;
+}
+/** Minimal structural interface for quads. */
+interface RdfQuad {
+    subject: RdfTerm;
+    predicate: RdfTerm;
+    object: RdfTerm;
+    graph: RdfTerm;
+}
+/**
+ * Minimal structural interface for the n3.Writer methods that topoWrite uses.
+ * Any object that provides blank() and addQuad() with these signatures works.
+ */
+interface TurtleWriter {
+    blank(predicates?: Array<{
+        predicate: RdfTerm;
+        object: unknown;
+    }>): unknown;
+    addQuad(subject: RdfTerm, predicate: RdfTerm, object: unknown, graph?: RdfTerm): void;
+}
+/**
+ * Write quads to an N3 Writer using nested [ ] notation for blank nodes that
+ * appear as an object exactly once (sole child in a tree edge).  Blank nodes
+ * used more than once as objects, or that have no subject triples, fall back
+ * to the normal _:label reference.  CONSTRUCT-style duplicate quads are
+ * deduplicated before processing.
+ */
+declare function topoWrite(writer: TurtleWriter, quads: Iterable<RdfQuad>): void;
+/**
+ * Post-process an N3.js Writer Turtle/TriG string with uniform indentation.
+ *
+ * n3.Writer uses 4 spaces for predicate-continuation lines and 2 spaces inside
+ * blank-node [ ] blocks.  reindent normalises this so that each additional level
+ * of [ ] nesting adds exactly one `step` (default: 2 spaces).
+ */
+declare function reindent(turtle: string, step?: string): string;
+/**
+ * Replace STRING_LITERAL2 values that contain the \n escape sequence with
+ * STRING_LITERAL_LONG2 (triple-quoted) with a real embedded newline.
+ *
+ * Falls back to the original form if the expanded content contains """ (which
+ * cannot appear unescaped inside a long literal).
+ */
+declare function expandLiterals(turtle: string): string;
+
+export { type RdfQuad, type RdfTerm, type TurtleWriter, expandLiterals, reindent, topoWrite };

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * n3writer-wrapper
+ *
+ * Helpers that improve the readability of Turtle/TriG output from n3.Writer:
+ *
+ *   topoWrite(writer, quads)  — feed quads to an N3 Writer using nested [ ]
+ *                               notation for blank nodes that appear as an
+ *                               object exactly once (tree-edge inlining).
+ *
+ *   reindent(turtle, step?)   — post-process a Turtle/TriG string so that
+ *                               predicate-continuation lines use `step`
+ *                               (default 2 spaces) instead of n3.Writer's
+ *                               hard-coded 4, and blank-node content at depth
+ *                               d uses step × (d+1).
+ *
+ *   expandLiterals(turtle)    — convert STRING_LITERAL2 values containing \n
+ *                               into STRING_LITERAL_LONG2 ("""…""") with a
+ *                               real embedded newline.
+ */
+/** Minimal structural interface for terms (compatible with n3, rdfjs, graphy). */
+interface RdfTerm {
+    termType: string;
+    value: string;
+    datatype?: {
+        value: string;
+    };
+    language?: string;
+}
+/** Minimal structural interface for quads. */
+interface RdfQuad {
+    subject: RdfTerm;
+    predicate: RdfTerm;
+    object: RdfTerm;
+    graph: RdfTerm;
+}
+/**
+ * Minimal structural interface for the n3.Writer methods that topoWrite uses.
+ * Any object that provides blank() and addQuad() with these signatures works.
+ */
+interface TurtleWriter {
+    blank(predicates?: Array<{
+        predicate: RdfTerm;
+        object: unknown;
+    }>): unknown;
+    addQuad(subject: RdfTerm, predicate: RdfTerm, object: unknown, graph?: RdfTerm): void;
+}
+/**
+ * Write quads to an N3 Writer using nested [ ] notation for blank nodes that
+ * appear as an object exactly once (sole child in a tree edge).  Blank nodes
+ * used more than once as objects, or that have no subject triples, fall back
+ * to the normal _:label reference.  CONSTRUCT-style duplicate quads are
+ * deduplicated before processing.
+ */
+declare function topoWrite(writer: TurtleWriter, quads: Iterable<RdfQuad>): void;
+/**
+ * Post-process an N3.js Writer Turtle/TriG string with uniform indentation.
+ *
+ * n3.Writer uses 4 spaces for predicate-continuation lines and 2 spaces inside
+ * blank-node [ ] blocks.  reindent normalises this so that each additional level
+ * of [ ] nesting adds exactly one `step` (default: 2 spaces).
+ */
+declare function reindent(turtle: string, step?: string): string;
+/**
+ * Replace STRING_LITERAL2 values that contain the \n escape sequence with
+ * STRING_LITERAL_LONG2 (triple-quoted) with a real embedded newline.
+ *
+ * Falls back to the original form if the expanded content contains """ (which
+ * cannot appear unescaped inside a long literal).
+ */
+declare function expandLiterals(turtle: string): string;
+
+export { type RdfQuad, type RdfTerm, type TurtleWriter, expandLiterals, reindent, topoWrite };

package/dist/index.js

@@ -0,0 +1,95 @@
+// src/index.ts
+function topoWrite(writer, quads) {
+  const termKey = (t) => t.termType === "Literal" ? `L\0${t.value}\0${t.datatype?.value ?? ""}\0${t.language ?? ""}` : `${t.termType[0]}\0${t.value}`;
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [...quads].filter((q) => {
+    const k = `${termKey(q.graph)}\0${termKey(q.subject)}\0${q.predicate.value}\0${termKey(q.object)}`;
+    return seen.size !== seen.add(k).size;
+  });
+  const bySub = /* @__PURE__ */ new Map();
+  const oCount = /* @__PURE__ */ new Map();
+  for (const q of deduped) {
+    const k = `${q.graph.value}\0${q.subject.termType}\0${q.subject.value}`;
+    if (!bySub.has(k)) bySub.set(k, { term: q.subject, graph: q.graph, pos: [] });
+    bySub.get(k).pos.push(q);
+    if (q.object.termType === "BlankNode") {
+      const ok = `${q.graph.value}\0${q.object.value}`;
+      oCount.set(ok, (oCount.get(ok) ?? 0) + 1);
+    }
+  }
+  const inlineable = (bn, graph) => oCount.get(`${graph.value}\0${bn.value}`) === 1 && bySub.has(`${graph.value}\0BlankNode\0${bn.value}`);
+  function buildBlank(bn, graph) {
+    const entry = bySub.get(`${graph.value}\0BlankNode\0${bn.value}`);
+    if (!entry) return writer.blank();
+    return writer.blank(
+      entry.pos.map((q) => ({
+        predicate: q.predicate,
+        object: q.object.termType === "BlankNode" && inlineable(q.object, graph) ? buildBlank(q.object, graph) : q.object
+      }))
+    );
+  }
+  for (const { term, graph, pos } of bySub.values()) {
+    if (term.termType === "BlankNode" && inlineable(term, graph)) continue;
+    for (const q of pos) {
+      writer.addQuad(
+        q.subject,
+        q.predicate,
+        q.object.termType === "BlankNode" && inlineable(q.object, graph) ? buildBlank(q.object, graph) : q.object,
+        q.graph
+      );
+    }
+  }
+}
+function reindent(turtle, step = "  ") {
+  let depth = 0;
+  return turtle.split("\n").map((line) => {
+    const t = line.trimStart();
+    if (!t) return "";
+    let leading = 0;
+    while (leading < t.length && t[leading] === "]") {
+      depth = Math.max(0, depth - 1);
+      leading++;
+    }
+    let out;
+    if (depth > 0) {
+      out = step.repeat(depth + 1) + t;
+    } else if (leading > 0 || line !== t) {
+      out = step + t;
+    } else {
+      out = line.trimEnd();
+    }
+    if (t.trimEnd().endsWith("[")) {
+      let opens = 0, closes = 0, inStr = false, i = 0;
+      while (i < t.length) {
+        const c = t[i];
+        if (c === "\\" && inStr) {
+          i += 2;
+          continue;
+        }
+        if (c === '"') inStr = !inStr;
+        else if (!inStr) {
+          if (c === "[") opens++;
+          else if (c === "]") closes++;
+        }
+        i++;
+      }
+      const netOpen = opens - closes + leading;
+      if (netOpen > 0) depth += netOpen;
+    }
+    return out;
+  }).join("\n");
+}
+function expandLiterals(turtle) {
+  return turtle.replace(/"((?:[^"\\]|\\.)*)"/g, (match, content) => {
+    if (!content.includes("\\n")) return match;
+    const expanded = content.replace(/\\n/g, "\n");
+    if (expanded.includes('"""')) return match;
+    return `"""${expanded}"""`;
+  });
+}
+export {
+  expandLiterals,
+  reindent,
+  topoWrite
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * n3writer-wrapper\n *\n * Helpers that improve the readability of Turtle/TriG output from n3.Writer:\n *\n *   topoWrite(writer, quads)  — feed quads to an N3 Writer using nested [ ]\n *                               notation for blank nodes that appear as an\n *                               object exactly once (tree-edge inlining).\n *\n *   reindent(turtle, step?)   — post-process a Turtle/TriG string so that\n *                               predicate-continuation lines use `step`\n *                               (default 2 spaces) instead of n3.Writer's\n *                               hard-coded 4, and blank-node content at depth\n *                               d uses step × (d+1).\n *\n *   expandLiterals(turtle)    — convert STRING_LITERAL2 values containing \\n\n *                               into STRING_LITERAL_LONG2 (\"\"\"…\"\"\") with a\n *                               real embedded newline.\n */\n\n/** Minimal structural interface for terms (compatible with n3, rdfjs, graphy). */\nexport interface RdfTerm {\n  termType: string;\n  value: string;\n  datatype?: { value: string };\n  language?: string;\n}\n\n/** Minimal structural interface for quads. */\nexport interface RdfQuad {\n  subject: RdfTerm;\n  predicate: RdfTerm;\n  object: RdfTerm;\n  graph: RdfTerm;\n}\n\n/**\n * Minimal structural interface for the n3.Writer methods that topoWrite uses.\n * Any object that provides blank() and addQuad() with these signatures works.\n */\nexport interface TurtleWriter {\n  blank(predicates?: Array<{ predicate: RdfTerm; object: unknown }>): unknown;\n  addQuad(subject: RdfTerm, predicate: RdfTerm, object: unknown, graph?: RdfTerm): void;\n}\n\n/**\n * Write quads to an N3 Writer using nested [ ] notation for blank nodes that\n * appear as an object exactly once (sole child in a tree edge).  Blank nodes\n * used more than once as objects, or that have no subject triples, fall back\n * to the normal _:label reference.  CONSTRUCT-style duplicate quads are\n * deduplicated before processing.\n */\nexport function topoWrite(writer: TurtleWriter, quads: Iterable<RdfQuad>): void {\n  const termKey = (t: RdfTerm): string =>\n    t.termType === 'Literal'\n      ? `L\\0${t.value}\\0${t.datatype?.value ?? ''}\\0${t.language ?? ''}`\n      : `${t.termType[0]}\\0${t.value}`;\n\n  const seen = new Set<string>();\n  const deduped = [...quads].filter(q => {\n    const k = `${termKey(q.graph)}\\0${termKey(q.subject)}\\0${q.predicate.value}\\0${termKey(q.object)}`;\n    return seen.size !== seen.add(k).size;\n  });\n\n  // Index quads by (graph, subject); count blank-node object occurrences per graph.\n  const bySub = new Map<string, { term: RdfTerm; graph: RdfTerm; pos: RdfQuad[] }>();\n  const oCount = new Map<string, number>();\n\n  for (const q of deduped) {\n    const k = `${q.graph.value}\\0${q.subject.termType}\\0${q.subject.value}`;\n    if (!bySub.has(k)) bySub.set(k, { term: q.subject, graph: q.graph, pos: [] });\n    bySub.get(k)!.pos.push(q);\n    if (q.object.termType === 'BlankNode') {\n      const ok = `${q.graph.value}\\0${q.object.value}`;\n      oCount.set(ok, (oCount.get(ok) ?? 0) + 1);\n    }\n  }\n\n  const inlineable = (bn: RdfTerm, graph: RdfTerm): boolean =>\n    oCount.get(`${graph.value}\\0${bn.value}`) === 1 &&\n    bySub.has(`${graph.value}\\0BlankNode\\0${bn.value}`);\n\n  function buildBlank(bn: RdfTerm, graph: RdfTerm): unknown {\n    const entry = bySub.get(`${graph.value}\\0BlankNode\\0${bn.value}`);\n    if (!entry) return writer.blank();\n    return writer.blank(\n      entry.pos.map(q => ({\n        predicate: q.predicate,\n        object:\n          q.object.termType === 'BlankNode' && inlineable(q.object, graph)\n            ? buildBlank(q.object, graph)\n            : q.object,\n      })),\n    );\n  }\n\n  for (const { term, graph, pos } of bySub.values()) {\n    if (term.termType === 'BlankNode' && inlineable(term, graph)) continue;\n    for (const q of pos) {\n      writer.addQuad(\n        q.subject,\n        q.predicate,\n        q.object.termType === 'BlankNode' && inlineable(q.object, graph)\n          ? buildBlank(q.object, graph)\n          : q.object,\n        q.graph,\n      );\n    }\n  }\n}\n\n/**\n * Post-process an N3.js Writer Turtle/TriG string with uniform indentation.\n *\n * n3.Writer uses 4 spaces for predicate-continuation lines and 2 spaces inside\n * blank-node [ ] blocks.  reindent normalises this so that each additional level\n * of [ ] nesting adds exactly one `step` (default: 2 spaces).\n */\nexport function reindent(turtle: string, step = '  '): string {\n  let depth = 0;\n  return turtle\n    .split('\\n')\n    .map(line => {\n      const t = line.trimStart();\n      if (!t) return '';\n\n      // Leading ] chars close blocks: reduce depth before outputting this line.\n      let leading = 0;\n      while (leading < t.length && t[leading] === ']') {\n        depth = Math.max(0, depth - 1);\n        leading++;\n      }\n\n      let out: string;\n      if (depth > 0) {\n        out = step.repeat(depth + 1) + t;\n      } else if (leading > 0 || line !== t) {\n        out = step + t;\n      } else {\n        out = line.trimEnd();\n      }\n\n      // Count net unbalanced [ brackets outside string literals to track depth.\n      if (t.trimEnd().endsWith('[')) {\n        let opens = 0,\n          closes = 0,\n          inStr = false,\n          i = 0;\n        while (i < t.length) {\n          const c = t[i];\n          if (c === '\\\\' && inStr) {\n            i += 2;\n            continue;\n          }\n          if (c === '\"') inStr = !inStr;\n          else if (!inStr) {\n            if (c === '[') opens++;\n            else if (c === ']') closes++;\n          }\n          i++;\n        }\n        const netOpen = opens - closes + leading;\n        if (netOpen > 0) depth += netOpen;\n      }\n\n      return out;\n    })\n    .join('\\n');\n}\n\n/**\n * Replace STRING_LITERAL2 values that contain the \\n escape sequence with\n * STRING_LITERAL_LONG2 (triple-quoted) with a real embedded newline.\n *\n * Falls back to the original form if the expanded content contains \"\"\" (which\n * cannot appear unescaped inside a long literal).\n */\nexport function expandLiterals(turtle: string): string {\n  return turtle.replace(/\"((?:[^\"\\\\]|\\\\.)*)\"/g, (match, content: string) => {\n    if (!content.includes('\\\\n')) return match;\n    const expanded = content.replace(/\\\\n/g, '\\n');\n    if (expanded.includes('\"\"\"')) return match;\n    return `\"\"\"${expanded}\"\"\"`;\n  });\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "n3writer-wrapper",
+  "version": "1.0.0",
+  "description": "Helpers for n3.Writer: topological blank-node inlining, uniform reindent, and multiline literal expansion",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "rdf",
+    "turtle",
+    "n3",
+    "blank-node",
+    "pretty-print"
+  ],
+  "author": "Eric Prud'hommeaux",
+  "license": "MIT",
+  "peerDependencies": {
+    "n3": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "n3": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "n3": "^1.26.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  }
+}