@gmod/bed 2.0.7 → 2.0.8

package/src/defaultTypes.js

@@ -0,0 +1,8 @@
+import { parse } from './autoSql'
+import * as types from './as/autoSqlSchemas'
+
+export default Object.fromEntries(
+  Object.entries(types).map(([key, val]) => {
+    return [key, parse(val.trim())]
+  }),
+)

package/src/index.js

@@ -0,0 +1,3 @@
+import BED from './parser'
+
+export default BED

package/src/parser.js

@@ -0,0 +1,104 @@
+import parser from './autoSql'
+import types from './defaultTypes'
+import { detectTypes } from './util'
+
+const strandMap = { '.': 0, '-': -1, '+': 1 }
+
+// heuristic that a BED file is BED12 like...the number in col 10 is blockCount-like
+function isBed12Like(fields) {
+  return (
+    fields.length >= 12 &&
+    !Number.isNaN(parseInt(fields[9], 10)) &&
+    fields[10]?.split(',').filter(f => !!f).length === parseInt(fields[9], 10)
+  )
+}
+
+export default class BED {
+  constructor(args = {}) {
+    if (args.autoSql) {
+      this.autoSql = detectTypes(parser.parse(args.autoSql))
+    } else if (args.type) {
+      if (!types[args.type]) {
+        throw new Error('Type not found')
+      }
+      this.autoSql = detectTypes(types[args.type])
+    } else {
+      this.autoSql = detectTypes(types.defaultBedSchema)
+      this.attemptDefaultBed = true
+    }
+  }
+
+  /*
+   * parses a line of text as a BED line with the loaded autoSql schema
+   *
+   * @param line - a BED line as tab delimited text or array
+   * @param opts - supply opts.uniqueId
+   * @return a object representing a feature
+   */
+  parseLine(line, opts = {}) {
+    const { autoSql } = this
+    const { uniqueId } = opts
+    let fields = line
+    if (!Array.isArray(line)) {
+      if (line.startsWith('track') || line.startsWith('browser')) {
+        throw new Error(
+          `track and browser line parsing is not supported, please filter:\n${line}`,
+        )
+      }
+      fields = line.split('\t')
+    }
+
+    let feature = {}
+    if (
+      !this.attemptDefaultBed ||
+      (this.attemptDefaultBed && isBed12Like(fields))
+    ) {
+      for (let i = 0; i < autoSql.fields.length; i++) {
+        const autoField = autoSql.fields[i]
+        let columnVal = fields[i]
+        const { isNumeric, isArray, arrayIsNumeric, name } = autoField
+        if (columnVal === null || columnVal === undefined) {
+          break
+        }
+        if (columnVal !== '.') {
+          if (isNumeric) {
+            const num = Number(columnVal)
+            columnVal = Number.isNaN(num) ? columnVal : num
+          } else if (isArray) {
+            columnVal = columnVal.split(',')
+            if (columnVal[columnVal.length - 1] === '') {
+              columnVal.pop()
+            }
+            if (arrayIsNumeric) {
+              columnVal = columnVal.map(str => Number(str))
+            }
+          }
+
+          feature[name] = columnVal
+        }
+      }
+    } else {
+      const fieldNames = ['chrom', 'chromStart', 'chromEnd', 'name']
+      feature = Object.fromEntries(
+        fields.map((f, i) => [fieldNames[i] || 'field' + i, f]),
+      )
+      feature.chromStart = +feature.chromStart
+      feature.chromEnd = +feature.chromEnd
+      if (!Number.isNaN(Number.parseFloat(feature.field4))) {
+        feature.score = +feature.field4
+        delete feature.field4
+      }
+      if (feature.field5 === '+' || feature.field5 === '-') {
+        feature.strand = feature.field5
+        delete feature.field5
+      }
+    }
+    if (uniqueId) {
+      feature.uniqueId = uniqueId
+    }
+    feature.strand = strandMap[feature.strand] || 0
+
+    feature.chrom = decodeURIComponent(feature.chrom)
+    return feature
+  }
+}

package/src/util.js

@@ -0,0 +1,26 @@
+/*
+ * adds some type annotations to the autoSql schema
+ * for numeric fields ['uint', 'int', 'float', 'long'] "isNumeric" is added
+ * for array types "isArray" is added
+ * for numeric array types "isArray" and "arrayIsNumeric" is set
+ *
+ * @param autoSql - an autoSql schema from the peg parser
+ * @return autoSql with type annotations added
+ */
+export function detectTypes(autoSql) {
+  const numericTypes = ['uint', 'int', 'float', 'long']
+  const fields = autoSql.fields.map(autoField => {
+    const type = {}
+    if (!autoField.size && numericTypes.includes(autoField.type)) {
+      type.isNumeric = true
+    }
+    if (autoField.size && autoField.type !== 'char') {
+      type.isArray = true
+    }
+    if (autoField.size && numericTypes.includes(autoField.type)) {
+      type.arrayIsNumeric = true
+    }
+    return { ...autoField, ...type }
+  })
+  return { ...autoSql, fields }
+}