@gmod/gbz-base 0.0.1 → 1.1.0

package/src/gbwt/sequence.ts

@@ -0,0 +1,50 @@
+const DECODE = ['', 'A', 'C', 'G', 'T', 'N']
+
+export function encodedSequenceLength(encoded: Uint8Array) {
+  const last = encoded[encoded.length - 1]
+  if (last === undefined) {
+    return 0
+  }
+  let value = last
+  let inLast = 0
+  for (let i = 0; i < 3; i++) {
+    if (value % 6 === 0) {
+      break
+    }
+    value = Math.floor(value / 6)
+    inLast += 1
+  }
+  return 3 * (encoded.length - 1) + inLast
+}
+
+export function decodeSequence(encoded: Uint8Array) {
+  let result = ''
+  for (const byte of encoded) {
+    let value = byte
+    for (let i = 0; i < 3; i++) {
+      const base = DECODE[value % 6]!
+      if (base === '') {
+        return result
+      }
+      value = Math.floor(value / 6)
+      result += base
+    }
+  }
+  return result
+}
+
+const COMPLEMENT: Record<string, string> = {
+  A: 'T',
+  C: 'G',
+  G: 'C',
+  T: 'A',
+  N: 'N',
+}
+
+export function reverseComplement(sequence: string) {
+  let result = ''
+  for (let i = sequence.length - 1; i >= 0; i--) {
+    result += COMPLEMENT[sequence[i]!] ?? 'N'
+  }
+  return result
+}

package/src/graphName.ts

@@ -0,0 +1,94 @@
+export interface GraphName {
+  name: string | undefined
+  subgraph: Map<string, Set<string>>
+  translation: Map<string, Set<string>>
+}
+
+function parseRelationships(field: string | undefined, what: string) {
+  const relationships = new Map<string, Set<string>>()
+  if (field !== undefined) {
+    for (const rel of field.split(';')) {
+      const parts = rel.split(',')
+      const [from, to] = parts
+      if (parts.length !== 2 || !from || !to) {
+        throw new Error(`Invalid ${what} relationship: ${rel}`)
+      }
+      let targets = relationships.get(from)
+      if (!targets) {
+        targets = new Set()
+        relationships.set(from, targets)
+      }
+      targets.add(to)
+    }
+  }
+  return relationships
+}
+
+export function graphNameFromTags(tags: Map<string, string>): GraphName {
+  return {
+    name: tags.get('pggname'),
+    subgraph: parseRelationships(tags.get('subgraph'), 'subgraph'),
+    translation: parseRelationships(tags.get('translation'), 'translation'),
+  }
+}
+
+function merge(into: Map<string, Set<string>>, from: Map<string, Set<string>>) {
+  for (const [key, values] of from) {
+    let targets = into.get(key)
+    if (!targets) {
+      targets = new Set()
+      into.set(key, targets)
+    }
+    for (const value of values) {
+      targets.add(value)
+    }
+  }
+}
+
+export function subgraphName(name: string, parent: GraphName): GraphName {
+  const result: GraphName = {
+    name,
+    subgraph: new Map(),
+    translation: new Map(),
+  }
+  if (parent.name !== undefined) {
+    result.subgraph.set(name, new Set([parent.name]))
+    merge(result.subgraph, parent.subgraph)
+    merge(result.translation, parent.translation)
+  }
+  return result
+}
+
+function sortedEntries(relationships: Map<string, Set<string>>) {
+  return [...relationships.entries()]
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .flatMap(([from, tos]) => [...tos].sort().map(to => [from, to] as const))
+}
+
+export function gfaHeaderLines(graphName: GraphName) {
+  const lines: string[] = []
+  if (graphName.name !== undefined) {
+    lines.push(`H\tNM:Z:${graphName.name}`)
+  }
+  for (const [subgraph, supergraph] of sortedEntries(graphName.subgraph)) {
+    lines.push(`H\tSG:Z:${subgraph},${supergraph}`)
+  }
+  for (const [from, to] of sortedEntries(graphName.translation)) {
+    lines.push(`H\tTL:Z:${from},${to}`)
+  }
+  return lines
+}
+
+export async function sha256Hex(chunks: Uint8Array[]) {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
+  const bytes = new Uint8Array(total)
+  let offset = 0
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset)
+    offset += chunk.length
+  }
+  const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes)
+  return [...new Uint8Array(digest)]
+    .map(byte => byte.toString(16).padStart(2, '0'))
+    .join('')
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+export {
+  GBZBase,
+  GENERIC_SAMPLE,
+  GbzRecord,
+  SCHEMA_VERSION,
+  SchemaVersionError,
+  formatPathName,
+} from './db.ts'
+export type { GbzPath, HaplotypeSample, OpenOptions, PathName } from './db.ts'
+export type { ByteSource } from './filehandle.ts'
+export type { Pos } from './gbwt/record.ts'
+export { Subgraph } from './subgraph.ts'
+export type {
+  HaplotypeAlignment,
+  HaplotypeOutput,
+  PathIdentity,
+  PathPosition,
+  ReferencePath,
+  SnarlOutput,
+  SubgraphJson,
+  SubgraphPath,
+  ToJsonOptions,
+} from './subgraph.ts'
+export {
+  subgraphAroundNodes,
+  subgraphAtOffset,
+  subgraphBetween,
+  subgraphInInterval,
+} from './query.ts'
+export type { PathQuery, QueryOptions } from './query.ts'
+export { SqliteDatabase } from './sqlite/database.ts'
+export type { GraphName } from './graphName.ts'
+export { weightedLcs } from './lcs.ts'
+export * as nodes from './gbwt/node.ts'

package/src/lcs.ts

@@ -0,0 +1,282 @@
+interface Point {
+  weight: number
+  a: number
+  b: number
+  matches: number
+}
+
+function prefixSums(sequence: number[], weight: (x: number) => number) {
+  const sums = [0]
+  for (let i = 0; i < sequence.length; i++) {
+    sums.push(sums[i]! + weight(sequence[i]!))
+  }
+  return sums
+}
+
+class MinHeap {
+  private items: number[] = []
+
+  push(value: number) {
+    const items = this.items
+    items.push(value)
+    let i = items.length - 1
+    while (i > 0) {
+      const parent = (i - 1) >> 1
+      if (items[parent]! <= value) {
+        break
+      }
+      items[i] = items[parent]!
+      i = parent
+    }
+    items[i] = value
+  }
+
+  peek() {
+    return this.items[0]
+  }
+
+  pop() {
+    const items = this.items
+    const top = items[0]
+    const last = items.pop()
+    if (items.length > 0 && last !== undefined) {
+      let i = 0
+      for (;;) {
+        const left = 2 * i + 1
+        const right = left + 1
+        let smallest = i
+        let value = last
+        if (left < items.length && items[left]! < value) {
+          smallest = left
+          value = items[left]!
+        }
+        if (right < items.length && items[right]! < value) {
+          smallest = right
+        }
+        if (smallest === i) {
+          break
+        }
+        items[i] = items[smallest]!
+        i = smallest
+      }
+      items[i] = last
+    }
+    return top
+  }
+}
+
+class Matrix {
+  readonly aSums: number[]
+  readonly bSums: number[]
+  readonly a: number[]
+  readonly b: number[]
+  readonly points = new Map<number, Map<number, Point>>()
+  private pendingEdits = new MinHeap()
+
+  constructor(a: number[], b: number[], weight: (x: number) => number) {
+    this.a = a
+    this.b = b
+    this.aSums = prefixSums(a, weight)
+    this.bSums = prefixSums(b, weight)
+    this.set(0, 0, { weight: 0, a: 0, b: 0, matches: 0 })
+  }
+
+  private set(edits: number, diagonal: number, point: Point) {
+    let row = this.points.get(edits)
+    if (!row) {
+      row = new Map()
+      this.points.set(edits, row)
+      this.pendingEdits.push(edits)
+    }
+    row.set(diagonal, point)
+  }
+
+  get(edits: number, diagonal: number) {
+    return this.points.get(edits)?.get(diagonal)
+  }
+
+  private tryInsert(edits: number, diagonal: number, point: Point) {
+    const existing = this.get(edits, diagonal)
+    if (!existing || point.weight > existing.weight) {
+      this.set(edits, diagonal, point)
+    }
+  }
+
+  aWeight(offset: number) {
+    return this.aSums[offset + 1]! - this.aSums[offset]!
+  }
+
+  bWeight(offset: number) {
+    return this.bSums[offset + 1]! - this.bSums[offset]!
+  }
+
+  extend(edits: number): Point | undefined {
+    const row = this.points.get(edits)
+    if (!row) {
+      return undefined
+    }
+    const diagonals = [...row.keys()].sort((x, y) => x - y)
+    for (const diagonal of diagonals) {
+      const found = row.get(diagonal)
+      if (!found) {
+        continue
+      }
+      const point = { ...found }
+      while (
+        point.a < this.a.length &&
+        point.b < this.b.length &&
+        this.a[point.a] === this.b[point.b]
+      ) {
+        point.weight += 2 * this.aWeight(point.a)
+        point.a += 1
+        point.b += 1
+        point.matches += 1
+      }
+      if (point.matches > 0) {
+        row.set(diagonal, point)
+      }
+      if (point.a === this.a.length && point.b === this.b.length) {
+        return point
+      }
+      if (point.a < this.a.length) {
+        const w = this.aWeight(point.a)
+        this.tryInsert(edits + w, diagonal + w, {
+          weight: point.weight,
+          a: point.a + 1,
+          b: point.b,
+          matches: 0,
+        })
+      }
+      if (point.b < this.b.length) {
+        const w = this.bWeight(point.b)
+        this.tryInsert(edits + w, diagonal - w, {
+          weight: point.weight,
+          a: point.a,
+          b: point.b + 1,
+          matches: 0,
+        })
+      }
+    }
+    return undefined
+  }
+
+  nextEdits(edits: number) {
+    while (
+      this.pendingEdits.peek() !== undefined &&
+      this.pendingEdits.peek()! <= edits
+    ) {
+      this.pendingEdits.pop()
+    }
+    return this.pendingEdits.peek()
+  }
+
+  predecessor(
+    a: number,
+    b: number,
+    edits: number,
+  ): [Point, number] | undefined {
+    const diagonal = this.aSums[a]! - this.bSums[b]!
+    const prev =
+      a > 0 && this.aWeight(a - 1) <= edits
+        ? this.get(edits - this.aWeight(a - 1), diagonal - this.aWeight(a - 1))
+        : undefined
+    const next =
+      b > 0 && this.bWeight(b - 1) <= edits
+        ? this.get(edits - this.bWeight(b - 1), diagonal + this.bWeight(b - 1))
+        : undefined
+    if (prev && next) {
+      return prev.weight > next.weight
+        ? [prev, edits - this.aWeight(a - 1)]
+        : [next, edits - this.bWeight(b - 1)]
+    }
+    if (prev) {
+      return [prev, edits - this.aWeight(a - 1)]
+    }
+    if (next) {
+      return [next, edits - this.bWeight(b - 1)]
+    }
+    return undefined
+  }
+}
+
+export function weightedLcs(
+  a: number[],
+  b: number[],
+  weight: (x: number) => number,
+): [pairs: [number, number][], weight: number] {
+  let prefix = 0
+  while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) {
+    prefix += 1
+  }
+  let suffix = 0
+  while (
+    suffix < a.length - prefix &&
+    suffix < b.length - prefix &&
+    a[a.length - 1 - suffix] === b[b.length - 1 - suffix]
+  ) {
+    suffix += 1
+  }
+  const pairs: [number, number][] = []
+  let total = 0
+  for (let i = 0; i < prefix; i++) {
+    pairs.push([i, i])
+    total += weight(a[i]!)
+  }
+  const [middle, middleWeight] = weightedLcsCore(
+    a.slice(prefix, a.length - suffix),
+    b.slice(prefix, b.length - suffix),
+    weight,
+  )
+  for (const [i, j] of middle) {
+    pairs.push([i + prefix, j + prefix])
+  }
+  total += middleWeight
+  for (let i = suffix; i > 0; i--) {
+    pairs.push([a.length - i, b.length - i])
+    total += weight(a[a.length - i]!)
+  }
+  return [pairs, total]
+}
+
+function weightedLcsCore(
+  a: number[],
+  b: number[],
+  weight: (x: number) => number,
+): [pairs: [number, number][], weight: number] {
+  if (a.length === 0 || b.length === 0) {
+    return [[], 0]
+  }
+  const matrix = new Matrix(a, b, weight)
+  let edits = 0
+  let point: Point = { weight: 0, a: 0, b: 0, matches: 0 }
+  for (;;) {
+    const end = matrix.extend(edits)
+    if (end) {
+      point = end
+      break
+    }
+    const next = matrix.nextEdits(edits)
+    if (next === undefined) {
+      break
+    }
+    edits = next
+  }
+  const result: [number, number][] = []
+  const finalWeight = point.weight / 2
+  point = { ...point }
+  for (;;) {
+    for (let i = 0; i < point.matches; i++) {
+      point.a -= 1
+      point.b -= 1
+      result.push([point.a, point.b])
+    }
+    const pred = matrix.predecessor(point.a, point.b, edits)
+    if (!pred) {
+      break
+    }
+    point = { ...pred[0] }
+    edits = pred[1]
+  }
+  result.reverse()
+  return [result, finalWeight]
+}

package/src/query.ts

@@ -0,0 +1,106 @@
+import { GENERIC_SAMPLE } from './db.ts'
+import { Subgraph } from './subgraph.ts'
+
+import type { GBZBase, PathName } from './db.ts'
+import type { HaplotypeOutput, SnarlOutput } from './subgraph.ts'
+
+export interface QueryOptions {
+  context?: number
+  haplotypes?: HaplotypeOutput
+  snarls?: SnarlOutput
+  limit?: number
+}
+
+export interface PathQuery {
+  sample?: string
+  contig: string
+  haplotype?: number
+}
+
+function pathName(query: PathQuery, fragment: number): PathName {
+  return {
+    sample: query.sample ?? GENERIC_SAMPLE,
+    contig: query.contig,
+    haplotype: query.haplotype ?? 0,
+    fragment,
+  }
+}
+
+export async function subgraphAtOffset(
+  db: GBZBase,
+  query: PathQuery,
+  offset: number,
+  opts: QueryOptions = {},
+) {
+  const subgraph = new Subgraph(db)
+  subgraph.limit = opts.limit
+  const reference = await subgraph.pathPosition(pathName(query, offset))
+  await subgraph.aroundPosition(
+    reference.position.handle,
+    reference.position.nodeOffset,
+    opts.context ?? 100,
+  )
+  await subgraph.extractSnarls(opts.snarls ?? 'none')
+  subgraph.extractPaths(reference, opts.haplotypes ?? 'all')
+  return subgraph
+}
+
+export async function subgraphInInterval(
+  db: GBZBase,
+  query: PathQuery,
+  start: number,
+  end: number,
+  opts: QueryOptions = {},
+) {
+  const subgraph = new Subgraph(db)
+  subgraph.limit = opts.limit
+  const reference = await subgraph.pathPosition(pathName(query, start))
+  await subgraph.aroundInterval(
+    reference.position,
+    end - start,
+    opts.context ?? 100,
+  )
+  await subgraph.extractSnarls(opts.snarls ?? 'none')
+  subgraph.extractPaths(reference, opts.haplotypes ?? 'all')
+  return subgraph
+}
+
+export async function subgraphAroundNodes(
+  db: GBZBase,
+  nodes: number[],
+  opts: QueryOptions = {},
+) {
+  const haplotypes = opts.haplotypes ?? 'all'
+  const snarls = opts.snarls ?? 'none'
+  if (haplotypes === 'reference-only') {
+    throw new Error('Cannot output a reference path in a node-based query')
+  }
+  if (snarls === 'overlapping' && nodes.length > 1) {
+    throw new Error(
+      'Overlapping snarls cannot be extracted for a node-based query with multiple nodes',
+    )
+  }
+  const subgraph = new Subgraph(db)
+  subgraph.limit = opts.limit
+  await subgraph.aroundNodes(nodes, opts.context ?? 100)
+  await subgraph.extractSnarls(snarls)
+  subgraph.extractPaths(undefined, haplotypes)
+  return subgraph
+}
+
+export async function subgraphBetween(
+  db: GBZBase,
+  start: number,
+  end: number,
+  opts: Pick<QueryOptions, 'haplotypes' | 'limit'> = {},
+) {
+  const haplotypes = opts.haplotypes ?? 'all'
+  if (haplotypes === 'reference-only') {
+    throw new Error('Cannot output a reference path in a node-based query')
+  }
+  const subgraph = new Subgraph(db)
+  subgraph.limit = opts.limit
+  await subgraph.betweenNodes(start, end)
+  subgraph.extractPaths(undefined, haplotypes)
+  return subgraph
+}