@riebeckite/graph 0.0.0-stage → 0.0.36

package/dist/index.js

@@ -0,0 +1,894 @@
+// src/animation.ts
+function buildRevealSchedule(nodes) {
+  const dated = nodes.filter((node) => node.date !== null).sort(
+    (left, right) => Date.parse(left.date) - Date.parse(right.date) || left.id.localeCompare(right.id)
+  );
+  const undated = nodes.filter((node) => node.date === null).sort((left, right) => left.id.localeCompare(right.id));
+  if (dated.length === 0) {
+    return [...undated].map((node, index) => ({
+      id: node.id,
+      at: (index + 1) / Math.max(undated.length, 1),
+      dated: false
+    }));
+  }
+  const datedShare = undated.length === 0 ? 1 : 0.85;
+  const entries = dated.map((node, index) => ({
+    id: node.id,
+    at: (index + 1) / dated.length * datedShare,
+    dated: true
+  }));
+  undated.forEach((node, index) => {
+    entries.push({
+      id: node.id,
+      at: datedShare + (index + 1) / undated.length * (1 - datedShare),
+      dated: false
+    });
+  });
+  return entries;
+}
+function hasDatedNodes(nodes) {
+  return nodes.some((node) => node.date !== null);
+}
+
+// src/query.ts
+var SUPPORTED_OPERATORS = /* @__PURE__ */ new Set(["file", "path", "tag"]);
+var TOKEN_PATTERN = /"[^"]*"|\S+/g;
+function parseGraphQuery(input) {
+  const terms = [];
+  const unsupportedOperators = /* @__PURE__ */ new Set();
+  for (const rawToken of input.match(TOKEN_PATTERN) ?? []) {
+    let token = rawToken.trim();
+    if (token.length === 0) continue;
+    let negated = false;
+    if (token.startsWith("-") && token.length > 1) {
+      negated = true;
+      token = token.slice(1);
+    }
+    const separator = token.indexOf(":");
+    if (separator > 0) {
+      const operator = token.slice(0, separator).toLocaleLowerCase();
+      if (!/^[a-z]+$/.test(operator)) {
+        terms.push({ field: "text", value: unquote(token), negated });
+        continue;
+      }
+      if (!SUPPORTED_OPERATORS.has(operator)) {
+        unsupportedOperators.add(operator);
+        terms.push({
+          field: "unsupported",
+          value: unquote(token.slice(separator + 1)),
+          negated
+        });
+        continue;
+      }
+      terms.push({
+        field: operator,
+        value: normalizeTagValue(unquote(token.slice(separator + 1))),
+        negated
+      });
+      continue;
+    }
+    terms.push({ field: "text", value: unquote(token), negated });
+  }
+  return { terms, unsupportedOperators: [...unsupportedOperators] };
+}
+function matchesGraphQuery(node, query) {
+  for (const term of query.terms) {
+    const matched = matchesTerm(node, term);
+    if (term.negated ? matched : !matched) return false;
+  }
+  return true;
+}
+function normalizeGraphText(value) {
+  return value.normalize("NFKC").toLocaleLowerCase().replace(
+    /[ァ-ン]/g,
+    (character) => String.fromCharCode(character.charCodeAt(0) - 96)
+  );
+}
+function matchesTerm(node, term) {
+  const value = normalizeGraphText(term.value);
+  if (value.length === 0) return false;
+  switch (term.field) {
+    case "file":
+      return normalizeGraphText(node.title).includes(value);
+    case "path":
+      return normalizeGraphText(node.path).includes(value);
+    case "tag":
+      return node.tags.some((tag) => {
+        const normalized = normalizeGraphText(tag);
+        return normalized === value || normalized.startsWith(`${value}/`);
+      });
+    case "text":
+      return normalizeGraphText(node.title).includes(value) || normalizeGraphText(node.path).includes(value) || node.tags.some((tag) => normalizeGraphText(tag).includes(value));
+    case "unsupported":
+      return false;
+  }
+}
+function normalizeTagValue(value) {
+  return value.replace(/^#+/, "");
+}
+function unquote(value) {
+  if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+// src/document.ts
+function buildGraphDocument(entries, options = {}) {
+  const includeTags = options.includeTags ?? true;
+  const includeAttachments = options.includeAttachments ?? true;
+  const includeUnresolved = options.includeUnresolved ?? true;
+  const entryBySlug = new Map(entries.map((entry) => [entry.slug, entry]));
+  const nodes = /* @__PURE__ */ new Map();
+  const links = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    nodes.set(entry.slug, {
+      id: entry.slug,
+      kind: "note",
+      slug: entry.slug,
+      title: entry.title,
+      permalink: entry.permalink,
+      path: entry.slug,
+      tags: uniqueTags(entry.tags ?? []),
+      date: normalizeDate(entry.date ?? null)
+    });
+  }
+  for (const entry of entries) {
+    for (const tag of uniqueTags(entry.tags ?? [])) {
+      if (!includeTags) break;
+      const id = `tag:${normalizeGraphText(tag)}`;
+      if (!nodes.has(id)) {
+        nodes.set(id, {
+          id,
+          kind: "tag",
+          slug: null,
+          title: `#${tag}`,
+          permalink: null,
+          path: `#${tag}`,
+          tags: [tag],
+          date: null
+        });
+      }
+      addLink(links, entry.slug, id);
+    }
+    const assets = uniqueAssets(entry.assets ?? []);
+    for (const link of entry.links ?? []) {
+      if (link.kind === "note" && link.slug !== null) {
+        if (entryBySlug.has(link.slug) && link.slug !== entry.slug) {
+          addLink(links, entry.slug, link.slug);
+        }
+        continue;
+      }
+      if ((link.kind === "attachment" || link.kind === "image") && includeAttachments) {
+        const asset = findAsset(assets, link.raw);
+        if (!asset) continue;
+        const id = `attachment:${asset.path}`;
+        if (!nodes.has(id)) {
+          nodes.set(id, {
+            id,
+            kind: "attachment",
+            slug: null,
+            title: basename(asset.path),
+            permalink: null,
+            path: asset.path,
+            tags: [],
+            date: null
+          });
+        }
+        addLink(links, entry.slug, id);
+        continue;
+      }
+      if (includeUnresolved && link.raw.trim().length > 0) {
+        const key = normalizeGraphText(link.raw);
+        const id = `unresolved:${key}`;
+        if (!nodes.has(id)) {
+          nodes.set(id, {
+            id,
+            kind: "unresolved",
+            slug: null,
+            title: link.raw,
+            permalink: null,
+            path: link.raw,
+            tags: [],
+            date: null
+          });
+        }
+        addLink(links, entry.slug, id);
+      }
+    }
+  }
+  const nodeList = [...nodes.values()].sort(compareNode);
+  const centerId = options.centerSlug && entryBySlug.has(options.centerSlug) ? options.centerSlug : entries[0]?.slug ?? null;
+  return {
+    nodes: nodeList,
+    links: [...links.values()].sort(
+      (left, right) => left.source.localeCompare(right.source) || left.target.localeCompare(right.target)
+    ),
+    centerId
+  };
+}
+function sliceGraphDocument(document, centerId, depth, maxNodes = 320) {
+  const nodeById = new Map(document.nodes.map((node) => [node.id, node]));
+  if (!nodeById.has(centerId)) {
+    return {
+      document: { nodes: [], links: [], centerId: null },
+      truncated: false
+    };
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of document.nodes) adjacency.set(node.id, []);
+  for (const link of document.links) {
+    adjacency.get(link.source)?.push(link.target);
+    adjacency.get(link.target)?.push(link.source);
+  }
+  for (const neighbors of adjacency.values()) {
+    neighbors.sort((left, right) => left.localeCompare(right));
+  }
+  const selected = /* @__PURE__ */ new Set([centerId]);
+  const limit = Math.max(1, Math.floor(maxNodes));
+  let frontier = [centerId];
+  let truncated = false;
+  for (let level = 0; level < Math.max(0, depth); level += 1) {
+    const next = [];
+    for (const id of frontier) {
+      for (const neighbor of adjacency.get(id) ?? []) {
+        if (selected.has(neighbor)) continue;
+        if (selected.size >= limit) {
+          truncated = true;
+          break;
+        }
+        selected.add(neighbor);
+        next.push(neighbor);
+      }
+      if (truncated) break;
+    }
+    if (truncated || next.length === 0) break;
+    frontier = next;
+  }
+  const nodes = document.nodes.filter((node) => selected.has(node.id)).sort(compareNode);
+  const links = document.links.filter(
+    (link) => selected.has(link.source) && selected.has(link.target)
+  );
+  return {
+    document: { nodes, links, centerId },
+    truncated
+  };
+}
+function addLink(links, source, target) {
+  if (source === target) return;
+  links.set(`${source}\0${target}`, { source, target });
+}
+function compareNode(left, right) {
+  return kindOrder(left.kind) - kindOrder(right.kind) || left.id.localeCompare(right.id);
+}
+function kindOrder(kind) {
+  switch (kind) {
+    case "note":
+      return 0;
+    case "unresolved":
+      return 1;
+    case "attachment":
+      return 2;
+    case "tag":
+      return 3;
+  }
+}
+function uniqueTags(tags) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const raw of tags) {
+    const tag = raw.trim().replace(/^#+/, "");
+    if (tag.length === 0) continue;
+    const key = normalizeGraphText(tag);
+    if (!seen.has(key)) seen.set(key, tag);
+  }
+  return [...seen.values()].sort((left, right) => left.localeCompare(right));
+}
+function uniqueAssets(assets) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    seen.set(asset.path, asset);
+  }
+  return [...seen.values()];
+}
+function findAsset(assets, raw) {
+  const value = raw.replace(/^\.\//, "");
+  return assets.find(
+    (asset) => asset.path === value || asset.sourcePath === value
+  ) ?? assets.find(
+    (asset) => asset.path.endsWith(`/${value}`) || asset.sourcePath?.endsWith(`/${value}`) === true
+  ) ?? null;
+}
+function basename(path) {
+  const segments = path.split("/");
+  return segments[segments.length - 1] ?? path;
+}
+function normalizeDate(value) {
+  if (!value) return null;
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+
+// src/settings.ts
+var GRAPH_SETTINGS_RANGES = {
+  depth: { min: 0, max: 5, step: 1 },
+  textFade: { min: 0, max: 1, step: 0.05 },
+  nodeSize: { min: 0.5, max: 2.5, step: 0.1 },
+  linkThickness: { min: 0.25, max: 3, step: 0.05 },
+  centerForce: { min: 0, max: 1, step: 0.05 },
+  repelForce: { min: 0, max: 2e3, step: 10 },
+  linkForce: { min: 0, max: 1, step: 0.05 },
+  linkDistance: { min: 30, max: 500, step: 5 }
+};
+var DEFAULT_GRAPH_SETTINGS = Object.freeze({
+  search: "",
+  showTags: true,
+  showAttachments: true,
+  existingOnly: false,
+  showOrphans: true,
+  depth: 2,
+  arrows: false,
+  textFade: 0.35,
+  nodeSize: 1,
+  linkThickness: 1,
+  animate: false,
+  centerForce: 0.35,
+  repelForce: 600,
+  linkForce: 0.7,
+  linkDistance: 100,
+  groups: []
+});
+var GROUP_COLORS = [
+  "#e07a5f",
+  "#3d85c6",
+  "#6aa84f",
+  "#c27ba0",
+  "#e6b422",
+  "#7c6ee6"
+];
+var MAX_GROUPS = 24;
+function mergeGraphSettings(base, patch) {
+  return normalizeGraphSettings({ ...base, ...patch });
+}
+function normalizeGraphSettings(value) {
+  const source = value !== null && typeof value === "object" ? value : {};
+  return {
+    search: text(source.search, DEFAULT_GRAPH_SETTINGS.search, 200),
+    showTags: flag(source.showTags, DEFAULT_GRAPH_SETTINGS.showTags),
+    showAttachments: flag(
+      source.showAttachments,
+      DEFAULT_GRAPH_SETTINGS.showAttachments
+    ),
+    existingOnly: flag(
+      source.existingOnly,
+      DEFAULT_GRAPH_SETTINGS.existingOnly
+    ),
+    showOrphans: flag(source.showOrphans, DEFAULT_GRAPH_SETTINGS.showOrphans),
+    depth: integer(source.depth, "depth", DEFAULT_GRAPH_SETTINGS.depth),
+    arrows: flag(source.arrows, DEFAULT_GRAPH_SETTINGS.arrows),
+    textFade: number(
+      source.textFade,
+      "textFade",
+      DEFAULT_GRAPH_SETTINGS.textFade
+    ),
+    nodeSize: number(
+      source.nodeSize,
+      "nodeSize",
+      DEFAULT_GRAPH_SETTINGS.nodeSize
+    ),
+    linkThickness: number(
+      source.linkThickness,
+      "linkThickness",
+      DEFAULT_GRAPH_SETTINGS.linkThickness
+    ),
+    animate: flag(source.animate, DEFAULT_GRAPH_SETTINGS.animate),
+    centerForce: number(
+      source.centerForce,
+      "centerForce",
+      DEFAULT_GRAPH_SETTINGS.centerForce
+    ),
+    repelForce: number(
+      source.repelForce,
+      "repelForce",
+      DEFAULT_GRAPH_SETTINGS.repelForce
+    ),
+    linkForce: number(
+      source.linkForce,
+      "linkForce",
+      DEFAULT_GRAPH_SETTINGS.linkForce
+    ),
+    linkDistance: number(
+      source.linkDistance,
+      "linkDistance",
+      DEFAULT_GRAPH_SETTINGS.linkDistance
+    ),
+    groups: groups(source.groups)
+  };
+}
+function readStoredGraphSettings(storage, key) {
+  try {
+    const raw = storage.getItem(key);
+    if (!raw) return null;
+    return normalizeGraphSettings(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function writeStoredGraphSettings(storage, key, settings) {
+  try {
+    storage.setItem(key, JSON.stringify(settings));
+  } catch {
+    return;
+  }
+}
+function flag(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function number(value, key, fallback) {
+  const range = GRAPH_SETTINGS_RANGES[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return clamp(value, range.min, range.max);
+}
+function integer(value, key, fallback) {
+  return Math.round(number(value, key, fallback));
+}
+function text(value, fallback, maxLength) {
+  return typeof value === "string" ? value.slice(0, maxLength) : fallback;
+}
+function groups(value) {
+  if (!Array.isArray(value)) return [];
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (result.length >= MAX_GROUPS) break;
+    if (item === null || typeof item !== "object") continue;
+    const source = item;
+    if (typeof source.id !== "string" || source.id.length === 0) continue;
+    if (seen.has(source.id)) continue;
+    const query = text(source.query, "", 200);
+    if (query.trim().length === 0) continue;
+    seen.add(source.id);
+    result.push({
+      id: source.id.slice(0, 64),
+      query,
+      color: color(source.color, result.length)
+    });
+  }
+  return result;
+}
+function color(value, index) {
+  if (typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value)) {
+    return value.toLocaleLowerCase();
+  }
+  return GROUP_COLORS[index % GROUP_COLORS.length] ?? "#6aa84f";
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/simulation.ts
+var ALPHA_MIN = 1e-3;
+var ALPHA_DECAY = 0.0228;
+var VELOCITY_DECAY = 0.4;
+var MAX_VELOCITY = 40;
+var GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+function createGraphSimulation(input) {
+  const ids = [...new Set(input.nodeIds)].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const nodes = ids.map((id, index) => {
+    const previous = input.positions?.get(id);
+    if (previous && Number.isFinite(previous.x) && Number.isFinite(previous.y)) {
+      return {
+        id,
+        x: previous.x,
+        y: previous.y,
+        vx: 0,
+        vy: 0,
+        fx: null,
+        fy: null
+      };
+    }
+    if (id === input.centerId) {
+      return { id, x: 0, y: 0, vx: 0, vy: 0, fx: null, fy: null };
+    }
+    const radius = 18 + 13 * Math.sqrt(index);
+    const angle = index * GOLDEN_ANGLE + hash(id) % 360 * (Math.PI / 180);
+    return {
+      id,
+      x: Math.cos(angle) * radius,
+      y: Math.sin(angle) * radius,
+      vx: 0,
+      vy: 0,
+      fx: null,
+      fy: null
+    };
+  });
+  const indexById = new Map(nodes.map((node, index) => [node.id, index]));
+  const links = input.links.map((link) => ({
+    source: indexById.get(link.source),
+    target: indexById.get(link.target)
+  })).filter(
+    (link) => link.source !== void 0 && link.target !== void 0
+  );
+  let options = { ...input.options };
+  let alpha = 1;
+  let alphaTarget = 0;
+  let active = true;
+  function tick() {
+    if (!active && alpha < ALPHA_MIN) return false;
+    alpha += (alphaTarget - alpha) * ALPHA_DECAY;
+    applyCenterForce(nodes, options.centerForce, alpha);
+    applyLinkForce(nodes, links, options, alpha);
+    applyRepelForce(nodes, options.repelForce * alpha * 0.02);
+    for (const node of nodes) {
+      if (node.fx !== null && node.fy !== null) {
+        node.x = node.fx;
+        node.y = node.fy;
+        node.vx = 0;
+        node.vy = 0;
+        continue;
+      }
+      node.vx *= 1 - VELOCITY_DECAY;
+      node.vy *= 1 - VELOCITY_DECAY;
+      node.vx = clampVelocity(node.vx);
+      node.vy = clampVelocity(node.vy);
+      node.x += node.vx;
+      node.y += node.vy;
+    }
+    if (alpha < ALPHA_MIN) {
+      alpha = 0;
+      active = false;
+    }
+    return active;
+  }
+  return {
+    nodes,
+    tick,
+    reheat(value = 0.7) {
+      alpha = Math.max(alpha, value);
+      active = true;
+    },
+    setOptions(next) {
+      options = { ...next };
+      if (alpha < 0.05) {
+        alpha = 0.05;
+        active = true;
+      }
+    },
+    fix(id, x, y) {
+      const index = indexById.get(id);
+      const node = index === void 0 ? void 0 : nodes[index];
+      if (!node) return;
+      node.fx = x;
+      node.fy = y;
+      node.x = x;
+      node.y = y;
+      node.vx = 0;
+      node.vy = 0;
+      alpha = Math.max(alpha, 0.5);
+      active = true;
+    },
+    release(id) {
+      const index = indexById.get(id);
+      const node = index === void 0 ? void 0 : nodes[index];
+      if (!node) return;
+      node.fx = null;
+      node.fy = null;
+      alpha = Math.max(alpha, 0.45);
+      active = true;
+    },
+    stop() {
+      alpha = 0;
+      alphaTarget = 0;
+      active = false;
+    },
+    isActive() {
+      return active;
+    },
+    getAlpha() {
+      return alpha;
+    }
+  };
+}
+function applyCenterForce(nodes, centerForce, alpha) {
+  const strength = centerForce * 0.03 * alpha;
+  if (strength <= 0) return;
+  for (const node of nodes) {
+    node.vx -= node.x * strength;
+    node.vy -= node.y * strength;
+  }
+}
+function applyLinkForce(nodes, links, options, alpha) {
+  const strength = options.linkForce * 0.12 * alpha;
+  if (strength <= 0) return;
+  for (const link of links) {
+    const source = nodes[link.source];
+    const target = nodes[link.target];
+    if (!source || !target) continue;
+    const dx = target.x - source.x;
+    const dy = target.y - source.y;
+    const distance = Math.hypot(dx, dy);
+    if (distance < 1e-3) continue;
+    const force = (distance - options.linkDistance) / distance * strength;
+    source.vx += dx * force;
+    source.vy += dy * force;
+    target.vx -= dx * force;
+    target.vy -= dy * force;
+  }
+}
+function applyRepelForce(nodes, strength) {
+  if (strength <= 0 || nodes.length < 2) return;
+  if (nodes.length <= 250) {
+    applyExactRepulsion(nodes, strength);
+    return;
+  }
+  applyQuadtreeRepulsion(nodes, strength);
+}
+function applyExactRepulsion(nodes, strength) {
+  for (let left = 0; left < nodes.length; left += 1) {
+    const a = nodes[left];
+    if (!a) continue;
+    for (let right = left + 1; right < nodes.length; right += 1) {
+      const b = nodes[right];
+      if (!b) continue;
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const distanceSquared = dx * dx + dy * dy + 1;
+      const force = strength / distanceSquared;
+      a.vx -= dx * force;
+      a.vy -= dy * force;
+      b.vx += dx * force;
+      b.vy += dy * force;
+    }
+  }
+}
+function applyQuadtreeRepulsion(nodes, strength) {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const node of nodes) {
+    minX = Math.min(minX, node.x);
+    minY = Math.min(minY, node.y);
+    maxX = Math.max(maxX, node.x);
+    maxY = Math.max(maxY, node.y);
+  }
+  const size = Math.max(maxX - minX, maxY - minY, 1) + 1;
+  const root = {
+    x: (minX + maxX - size) / 2,
+    y: (minY + maxY - size) / 2,
+    size,
+    mass: 0,
+    centerX: 0,
+    centerY: 0,
+    members: null,
+    children: null
+  };
+  for (let index = 0; index < nodes.length; index += 1) {
+    insertQuad(root, nodes, index, 0);
+  }
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    if (node) applyQuadForce(root, nodes, node, index, strength);
+  }
+}
+function insertQuad(quad, nodes, index, depth) {
+  const node = nodes[index];
+  if (!node) return;
+  quad.centerX = (quad.centerX * quad.mass + node.x) / (quad.mass + 1);
+  quad.centerY = (quad.centerY * quad.mass + node.y) / (quad.mass + 1);
+  quad.mass += 1;
+  if (quad.children) {
+    insertIntoChild(quad, nodes, index, depth + 1);
+    return;
+  }
+  if (!quad.members) {
+    quad.members = [index];
+    return;
+  }
+  if (depth >= 16) {
+    quad.members.push(index);
+    return;
+  }
+  const members = quad.members;
+  quad.members = null;
+  const half = quad.size / 2;
+  quad.children = [
+    createQuad(quad.x, quad.y, half),
+    createQuad(quad.x + half, quad.y, half),
+    createQuad(quad.x, quad.y + half, half),
+    createQuad(quad.x + half, quad.y + half, half)
+  ];
+  for (const member of members) insertIntoChild(quad, nodes, member, depth + 1);
+  insertIntoChild(quad, nodes, index, depth + 1);
+}
+function insertIntoChild(quad, nodes, index, depth) {
+  const children = quad.children;
+  if (!children) return;
+  const node = nodes[index];
+  if (!node) return;
+  const half = quad.size / 2;
+  const right = node.x >= quad.x + half ? 1 : 0;
+  const bottom = node.y >= quad.y + half ? 2 : 0;
+  const child = children[right + bottom];
+  if (child) insertQuad(child, nodes, index, depth);
+}
+function createQuad(x, y, size) {
+  return {
+    x,
+    y,
+    size,
+    mass: 0,
+    centerX: 0,
+    centerY: 0,
+    members: null,
+    children: null
+  };
+}
+function applyQuadForce(quad, nodes, target, targetIndex, strength) {
+  if (quad.mass === 0) return;
+  const dx = quad.centerX - target.x;
+  const dy = quad.centerY - target.y;
+  const distanceSquared = dx * dx + dy * dy + 1;
+  if (!quad.children) {
+    for (const index of quad.members ?? []) {
+      if (index === targetIndex) continue;
+      const other = nodes[index];
+      if (other) applyPairRepulsion(target, other, strength);
+    }
+    return;
+  }
+  if (quad.size * quad.size < 0.81 * distanceSquared) {
+    const force = strength * quad.mass / distanceSquared;
+    target.vx -= dx * force;
+    target.vy -= dy * force;
+    return;
+  }
+  for (const child of quad.children) {
+    applyQuadForce(child, nodes, target, targetIndex, strength);
+  }
+}
+function applyPairRepulsion(a, b, strength) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const distanceSquared = dx * dx + dy * dy + 1;
+  const force = strength / distanceSquared;
+  a.vx -= dx * force;
+  a.vy -= dy * force;
+  b.vx += dx * force;
+  b.vy += dy * force;
+}
+function clampVelocity(value) {
+  return Math.min(Math.max(value, -MAX_VELOCITY), MAX_VELOCITY);
+}
+function hash(value) {
+  let result = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    result ^= value.charCodeAt(index);
+    result = Math.imul(result, 16777619);
+  }
+  return result >>> 0;
+}
+
+// src/view.ts
+function buildVisibleGraph(input) {
+  const { document, settings, mode } = input;
+  const centerId = input.centerId ?? document.centerId;
+  const nodeById = new Map(document.nodes.map((node) => [node.id, node]));
+  const adjacency = buildAdjacency(document);
+  const fullDegree = /* @__PURE__ */ new Map();
+  for (const link of document.links) {
+    fullDegree.set(link.source, (fullDegree.get(link.source) ?? 0) + 1);
+    fullDegree.set(link.target, (fullDegree.get(link.target) ?? 0) + 1);
+  }
+  const search = parseGraphQuery(settings.search);
+  const groups2 = settings.groups.map((group) => ({
+    group,
+    query: parseGraphQuery(group.query)
+  }));
+  const unsupportedOperators = new Set(search.unsupportedOperators);
+  for (const entry of groups2) {
+    for (const operator of entry.query.unsupportedOperators) {
+      unsupportedOperators.add(operator);
+    }
+  }
+  const candidates = mode === "local" ? collectLocalNodeIds(adjacency, centerId, settings.depth) : new Set(document.nodes.map((node) => node.id));
+  const visibleNodes = [];
+  for (const id of candidates) {
+    const node = nodeById.get(id);
+    if (!node) continue;
+    if (node.kind === "tag" && !settings.showTags) continue;
+    if (node.kind === "attachment" && !settings.showAttachments) continue;
+    if (node.kind === "unresolved" && settings.existingOnly) continue;
+    if (node.kind === "note" && !settings.showOrphans && (fullDegree.get(node.id) ?? 0) === 0) {
+      continue;
+    }
+    if (settings.search.trim().length > 0 && !matchesGraphQuery(node, search)) {
+      if (mode !== "local" || id !== centerId) continue;
+    }
+    visibleNodes.push({
+      ...node,
+      degree: 0,
+      radius: 0,
+      color: "",
+      groupId: null
+    });
+  }
+  const visibleIds = new Set(visibleNodes.map((node) => node.id));
+  const links = document.links.filter(
+    (link) => visibleIds.has(link.source) && visibleIds.has(link.target)
+  );
+  const degree = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    degree.set(link.source, (degree.get(link.source) ?? 0) + 1);
+    degree.set(link.target, (degree.get(link.target) ?? 0) + 1);
+  }
+  visibleNodes.sort((left, right) => left.id.localeCompare(right.id));
+  for (const node of visibleNodes) {
+    node.degree = degree.get(node.id) ?? 0;
+    node.radius = 3 + Math.sqrt(node.degree) * 1.7;
+    const group = findGroup(node, groups2);
+    node.groupId = group?.group.id ?? null;
+    node.color = group?.group.color ?? "";
+  }
+  return {
+    nodes: visibleNodes,
+    links,
+    centerId: centerId && visibleIds.has(centerId) ? centerId : null,
+    unsupportedOperators: [...unsupportedOperators]
+  };
+}
+function collectLocalNodeIds(adjacency, centerId, depth) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!centerId) return ids;
+  ids.add(centerId);
+  let frontier = [centerId];
+  for (let level = 0; level < depth; level += 1) {
+    const next = [];
+    for (const id of frontier) {
+      for (const neighbor of adjacency.get(id) ?? []) {
+        if (ids.has(neighbor)) continue;
+        ids.add(neighbor);
+        next.push(neighbor);
+      }
+    }
+    if (next.length === 0) break;
+    frontier = next;
+  }
+  return ids;
+}
+function buildAdjacency(document) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of document.nodes) adjacency.set(node.id, []);
+  for (const link of document.links) {
+    adjacency.get(link.source)?.push(link.target);
+    adjacency.get(link.target)?.push(link.source);
+  }
+  return adjacency;
+}
+function findGroup(node, groups2) {
+  for (const entry of groups2) {
+    if (entry.group.query.trim().length === 0) continue;
+    if (entry.query.unsupportedOperators.length > 0) continue;
+    if (matchesGraphQuery(node, entry.query)) return entry;
+  }
+  return null;
+}
+export {
+  DEFAULT_GRAPH_SETTINGS,
+  GRAPH_SETTINGS_RANGES,
+  buildGraphDocument,
+  buildRevealSchedule,
+  buildVisibleGraph,
+  collectLocalNodeIds,
+  createGraphSimulation,
+  hasDatedNodes,
+  matchesGraphQuery,
+  mergeGraphSettings,
+  normalizeGraphSettings,
+  normalizeGraphText,
+  parseGraphQuery,
+  readStoredGraphSettings,
+  sliceGraphDocument,
+  writeStoredGraphSettings
+};