wiki-graph-core 0.3.1

package/dist/topology/segment-incision.js

@@ -0,0 +1,197 @@
+async function computeNormalizedSegmentIncisions(input) {
+  const segmentWordsCounts = await loadSegmentWordsCounts(input.fragments);
+  return normalizeIncisions(
+    computeSegmentIncisions({
+      chunks: input.chunks,
+      edges: input.edges,
+      segmentWordsCounts
+    })
+  );
+}
+async function loadSegmentWordsCounts(fragments) {
+  const wordsCounts = createNumberRecord();
+  const startSentenceIndexes = await fragments.listFragmentIds();
+  for (const startSentenceIndex of startSentenceIndexes) {
+    const segment = await fragments.getFragment(startSentenceIndex);
+    wordsCounts[String(startSentenceIndex)] = segment.sentences.reduce(
+      (total, sentence) => total + sentence.wordsCount,
+      0
+    );
+  }
+  return wordsCounts;
+}
+function computeSegmentIncisions(input) {
+  const startSentenceIndexes = Object.keys(input.segmentWordsCounts).map(Number).sort(compareNumber);
+  const chunkIdsBySegmentStartIndex = createNumberListRecord();
+  const chunkWeightsById = createNumberRecord();
+  const edgesByChunkId = createReadingEdgeListRecord();
+  for (const chunk of input.chunks) {
+    const startSentenceIndex = findContainingSegmentStartIndex(
+      startSentenceIndexes,
+      chunk.sentenceId[1]
+    );
+    if (startSentenceIndex === void 0) {
+      continue;
+    }
+    const segmentKey = String(startSentenceIndex);
+    chunkWeightsById[String(chunk.id)] = chunk.weight;
+    if (chunkIdsBySegmentStartIndex[segmentKey] === void 0) {
+      chunkIdsBySegmentStartIndex[segmentKey] = [];
+    }
+    chunkIdsBySegmentStartIndex[segmentKey]?.push(chunk.id);
+  }
+  for (const edge of input.edges) {
+    const fromKey = String(edge.fromId);
+    const toKey = String(edge.toId);
+    if (edgesByChunkId[fromKey] === void 0) {
+      edgesByChunkId[fromKey] = [];
+    }
+    if (edgesByChunkId[toKey] === void 0) {
+      edgesByChunkId[toKey] = [];
+    }
+    edgesByChunkId[fromKey]?.push(edge);
+    edgesByChunkId[toKey]?.push(edge);
+  }
+  const chunksById = createChunkRecord();
+  for (const chunk of input.chunks) {
+    chunksById[String(chunk.id)] = chunk;
+  }
+  return startSentenceIndexes.filter(
+    (startSentenceIndex) => chunkIdsBySegmentStartIndex[String(startSentenceIndex)] !== void 0
+  ).map((startSentenceIndex) => {
+    const chunkIds = chunkIdsBySegmentStartIndex[String(startSentenceIndex)] ?? [];
+    let endIncision = 0;
+    let startIncision = 0;
+    for (const chunkId of chunkIds) {
+      const chunkWeight = chunkWeightsById[String(chunkId)] ?? 0;
+      const chunkEdges = edgesByChunkId[String(chunkId)] ?? [];
+      const externalEdges = chunkEdges.map((edge) => ({
+        otherChunkId: edge.fromId === chunkId ? edge.toId : edge.fromId,
+        weight: edge.weight
+      })).map((edge) => {
+        const otherChunk = chunksById[String(edge.otherChunkId)];
+        if (otherChunk === void 0) {
+          return void 0;
+        }
+        return {
+          otherSegmentStartIndex: findContainingSegmentStartIndex(
+            startSentenceIndexes,
+            otherChunk.sentenceId[1]
+          ),
+          weight: edge.weight
+        };
+      }).filter(
+        (edge) => edge !== void 0 && edge.otherSegmentStartIndex !== void 0 && edge.otherSegmentStartIndex !== startSentenceIndex
+      );
+      if (externalEdges.length === 0) {
+        continue;
+      }
+      const totalExternalWeight = externalEdges.reduce(
+        (total, edge) => total + edge.weight,
+        0
+      );
+      if (totalExternalWeight === 0) {
+        continue;
+      }
+      for (const edge of externalEdges) {
+        const halfWeight = chunkWeight / totalExternalWeight * edge.weight;
+        if (edge.otherSegmentStartIndex < startSentenceIndex) {
+          startIncision += halfWeight;
+          continue;
+        }
+        endIncision += halfWeight;
+      }
+    }
+    return {
+      endIncision,
+      startSentenceIndex,
+      startIncision,
+      wordsCount: input.segmentWordsCounts[String(startSentenceIndex)] ?? 0
+    };
+  });
+}
+function findContainingSegmentStartIndex(startSentenceIndexes, sentenceIndex) {
+  let containingSegmentStartIndex;
+  for (const startSentenceIndex of startSentenceIndexes) {
+    if (startSentenceIndex > sentenceIndex) {
+      break;
+    }
+    containingSegmentStartIndex = startSentenceIndex;
+  }
+  return containingSegmentStartIndex;
+}
+function normalizeIncisions(segmentInfos) {
+  const allIncisions = segmentInfos.flatMap((segmentInfo) => [
+    segmentInfo.startIncision,
+    segmentInfo.endIncision
+  ]).filter((incision) => incision > 0).sort(compareNumber);
+  if (allIncisions.length === 0) {
+    return [...segmentInfos];
+  }
+  const thresholdIndex = Math.min(
+    Math.floor(allIncisions.length * 0.98),
+    allIncisions.length - 1
+  );
+  const threshold = allIncisions[thresholdIndex] ?? 0;
+  const normalValues = allIncisions.filter((incision) => incision < threshold);
+  if (normalValues.length === 0) {
+    return segmentInfos.map((segmentInfo) => ({
+      ...segmentInfo,
+      endIncision: segmentInfo.endIncision > 0 ? 10 : 0,
+      startIncision: segmentInfo.startIncision > 0 ? 10 : 0
+    }));
+  }
+  const minValue = Math.min(...normalValues);
+  const maxValue = Math.max(...normalValues);
+  const minLog = minValue > 0 ? Math.log(minValue) : 0;
+  const maxLog = maxValue > 0 ? Math.log(maxValue) : 0;
+  const logRange = maxLog - minLog === 0 ? 1 : maxLog - minLog;
+  return segmentInfos.map((segmentInfo) => ({
+    ...segmentInfo,
+    endIncision: normalizeIncision(segmentInfo.endIncision, {
+      logRange,
+      minLog,
+      threshold
+    }),
+    startIncision: normalizeIncision(segmentInfo.startIncision, {
+      logRange,
+      minLog,
+      threshold
+    })
+  }));
+}
+function normalizeIncision(incision, input) {
+  if (incision === 0) {
+    return 0;
+  }
+  if (incision >= input.threshold) {
+    return 10;
+  }
+  const incisionLog = incision > 0 ? Math.log(incision) : input.minLog;
+  return Math.max(
+    1,
+    Math.min(
+      10,
+      Math.round(1 + (incisionLog - input.minLog) / input.logRange * 9)
+    )
+  );
+}
+function compareNumber(left, right) {
+  return left - right;
+}
+function createChunkRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createReadingEdgeListRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createNumberListRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createNumberRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+export {
+  computeNormalizedSegmentIncisions
+};
+//# sourceMappingURL=segment-incision.js.map

package/dist/topology/segment-incision.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/topology/segment-incision.ts"],"sourcesContent":["import type {\n  ChunkRecord,\n  ReadingEdgeRecord,\n  ReadonlySerialFragments,\n} from \"../document/index.js\";\n\nexport interface SegmentInfo {\n  readonly startSentenceIndex: number;\n  readonly wordsCount: number;\n  readonly startIncision: number;\n  readonly endIncision: number;\n}\n\nexport async function computeNormalizedSegmentIncisions(input: {\n  chunks: readonly ChunkRecord[];\n  edges: readonly ReadingEdgeRecord[];\n  fragments: ReadonlySerialFragments;\n}): Promise<SegmentInfo[]> {\n  const segmentWordsCounts = await loadSegmentWordsCounts(input.fragments);\n\n  return normalizeIncisions(\n    computeSegmentIncisions({\n      chunks: input.chunks,\n      edges: input.edges,\n      segmentWordsCounts,\n    }),\n  );\n}\n\nasync function loadSegmentWordsCounts(\n  fragments: ReadonlySerialFragments,\n): Promise<Readonly<Record<string, number>>> {\n  const wordsCounts = createNumberRecord();\n  const startSentenceIndexes = await fragments.listFragmentIds();\n\n  for (const startSentenceIndex of startSentenceIndexes) {\n    const segment = await fragments.getFragment(startSentenceIndex);\n\n    wordsCounts[String(startSentenceIndex)] = segment.sentences.reduce(\n      (total, sentence) => total + sentence.wordsCount,\n      0,\n    );\n  }\n\n  return wordsCounts;\n}\n\nfunction computeSegmentIncisions(input: {\n  chunks: readonly ChunkRecord[];\n  edges: readonly ReadingEdgeRecord[];\n  segmentWordsCounts: Readonly<Record<string, number>>;\n}): SegmentInfo[] {\n  const startSentenceIndexes = Object.keys(input.segmentWordsCounts)\n    .map(Number)\n    .sort(compareNumber);\n  const chunkIdsBySegmentStartIndex = createNumberListRecord();\n  const chunkWeightsById = createNumberRecord();\n  const edgesByChunkId = createReadingEdgeListRecord();\n\n  for (const chunk of input.chunks) {\n    const startSentenceIndex = findContainingSegmentStartIndex(\n      startSentenceIndexes,\n      chunk.sentenceId[1],\n    );\n\n    if (startSentenceIndex === undefined) {\n      continue;\n    }\n\n    const segmentKey = String(startSentenceIndex);\n\n    chunkWeightsById[String(chunk.id)] = chunk.weight;\n    if (chunkIdsBySegmentStartIndex[segmentKey] === undefined) {\n      chunkIdsBySegmentStartIndex[segmentKey] = [];\n    }\n    chunkIdsBySegmentStartIndex[segmentKey]?.push(chunk.id);\n  }\n\n  for (const edge of input.edges) {\n    const fromKey = String(edge.fromId);\n    const toKey = String(edge.toId);\n\n    if (edgesByChunkId[fromKey] === undefined) {\n      edgesByChunkId[fromKey] = [];\n    }\n    if (edgesByChunkId[toKey] === undefined) {\n      edgesByChunkId[toKey] = [];\n    }\n\n    edgesByChunkId[fromKey]?.push(edge);\n    edgesByChunkId[toKey]?.push(edge);\n  }\n\n  const chunksById = createChunkRecord();\n\n  for (const chunk of input.chunks) {\n    chunksById[String(chunk.id)] = chunk;\n  }\n\n  return startSentenceIndexes\n    .filter(\n      (startSentenceIndex) =>\n        chunkIdsBySegmentStartIndex[String(startSentenceIndex)] !== undefined,\n    )\n    .map((startSentenceIndex) => {\n      const chunkIds =\n        chunkIdsBySegmentStartIndex[String(startSentenceIndex)] ?? [];\n      let endIncision = 0;\n      let startIncision = 0;\n\n      for (const chunkId of chunkIds) {\n        const chunkWeight = chunkWeightsById[String(chunkId)] ?? 0;\n        const chunkEdges = edgesByChunkId[String(chunkId)] ?? [];\n        const externalEdges = chunkEdges\n          .map((edge) => ({\n            otherChunkId: edge.fromId === chunkId ? edge.toId : edge.fromId,\n            weight: edge.weight,\n          }))\n          .map((edge) => {\n            const otherChunk = chunksById[String(edge.otherChunkId)];\n\n            if (otherChunk === undefined) {\n              return undefined;\n            }\n\n            return {\n              otherSegmentStartIndex: findContainingSegmentStartIndex(\n                startSentenceIndexes,\n                otherChunk.sentenceId[1],\n              ),\n              weight: edge.weight,\n            };\n          })\n          .filter(\n            (\n              edge,\n            ): edge is {\n              otherSegmentStartIndex: number;\n              weight: number;\n            } =>\n              edge !== undefined &&\n              edge.otherSegmentStartIndex !== undefined &&\n              edge.otherSegmentStartIndex !== startSentenceIndex,\n          );\n\n        if (externalEdges.length === 0) {\n          continue;\n        }\n\n        const totalExternalWeight = externalEdges.reduce(\n          (total, edge) => total + edge.weight,\n          0,\n        );\n\n        if (totalExternalWeight === 0) {\n          continue;\n        }\n\n        for (const edge of externalEdges) {\n          const halfWeight = (chunkWeight / totalExternalWeight) * edge.weight;\n\n          if (edge.otherSegmentStartIndex < startSentenceIndex) {\n            startIncision += halfWeight;\n            continue;\n          }\n\n          endIncision += halfWeight;\n        }\n      }\n\n      return {\n        endIncision,\n        startSentenceIndex,\n        startIncision,\n        wordsCount: input.segmentWordsCounts[String(startSentenceIndex)] ?? 0,\n      };\n    });\n}\n\nfunction findContainingSegmentStartIndex(\n  startSentenceIndexes: readonly number[],\n  sentenceIndex: number,\n): number | undefined {\n  let containingSegmentStartIndex: number | undefined;\n\n  for (const startSentenceIndex of startSentenceIndexes) {\n    if (startSentenceIndex > sentenceIndex) {\n      break;\n    }\n\n    containingSegmentStartIndex = startSentenceIndex;\n  }\n\n  return containingSegmentStartIndex;\n}\n\nfunction normalizeIncisions(\n  segmentInfos: readonly SegmentInfo[],\n): SegmentInfo[] {\n  const allIncisions = segmentInfos\n    .flatMap((segmentInfo) => [\n      segmentInfo.startIncision,\n      segmentInfo.endIncision,\n    ])\n    .filter((incision) => incision > 0)\n    .sort(compareNumber);\n\n  if (allIncisions.length === 0) {\n    return [...segmentInfos];\n  }\n\n  const thresholdIndex = Math.min(\n    Math.floor(allIncisions.length * 0.98),\n    allIncisions.length - 1,\n  );\n  const threshold = allIncisions[thresholdIndex] ?? 0;\n  const normalValues = allIncisions.filter((incision) => incision < threshold);\n\n  if (normalValues.length === 0) {\n    return segmentInfos.map((segmentInfo) => ({\n      ...segmentInfo,\n      endIncision: segmentInfo.endIncision > 0 ? 10 : 0,\n      startIncision: segmentInfo.startIncision > 0 ? 10 : 0,\n    }));\n  }\n\n  const minValue = Math.min(...normalValues);\n  const maxValue = Math.max(...normalValues);\n  const minLog = minValue > 0 ? Math.log(minValue) : 0;\n  const maxLog = maxValue > 0 ? Math.log(maxValue) : 0;\n  const logRange = maxLog - minLog === 0 ? 1 : maxLog - minLog;\n\n  return segmentInfos.map((segmentInfo) => ({\n    ...segmentInfo,\n    endIncision: normalizeIncision(segmentInfo.endIncision, {\n      logRange,\n      minLog,\n      threshold,\n    }),\n    startIncision: normalizeIncision(segmentInfo.startIncision, {\n      logRange,\n      minLog,\n      threshold,\n    }),\n  }));\n}\n\nfunction normalizeIncision(\n  incision: number,\n  input: {\n    logRange: number;\n    minLog: number;\n    threshold: number;\n  },\n): number {\n  if (incision === 0) {\n    return 0;\n  }\n\n  if (incision >= input.threshold) {\n    return 10;\n  }\n\n  const incisionLog = incision > 0 ? Math.log(incision) : input.minLog;\n\n  return Math.max(\n    1,\n    Math.min(\n      10,\n      Math.round(1 + ((incisionLog - input.minLog) / input.logRange) * 9),\n    ),\n  );\n}\n\nfunction compareNumber(left: number, right: number): number {\n  return left - right;\n}\n\nfunction createChunkRecord(): Record<string, ChunkRecord | undefined> {\n  return Object.create(null) as Record<string, ChunkRecord | undefined>;\n}\n\nfunction createReadingEdgeListRecord(): Record<\n  string,\n  ReadingEdgeRecord[] | undefined\n> {\n  return Object.create(null) as Record<string, ReadingEdgeRecord[] | undefined>;\n}\n\nfunction createNumberListRecord(): Record<string, number[] | undefined> {\n  return Object.create(null) as Record<string, number[] | undefined>;\n}\n\nfunction createNumberRecord(): Record<string, number> {\n  return Object.create(null) as Record<string, number>;\n}\n"],"mappings":"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","names":[]}

package/dist/topology/snake-detector.d.ts

@@ -0,0 +1,13 @@
+import { ChunkRecord, ReadingEdgeRecord } from '../document/types.js';
+
+declare function splitConnectedComponents(input: {
+    chunkIds: readonly number[];
+    edges: readonly ReadingEdgeRecord[];
+}): number[][];
+declare function detectSnakesInComponent(input: {
+    chunks: readonly ChunkRecord[];
+    edges: readonly ReadingEdgeRecord[];
+    snakeWordsCount?: number;
+}): number[][];
+
+export { detectSnakesInComponent, splitConnectedComponents };