@apollo-annotation/mst 0.1.11

package/README.md

@@ -0,0 +1 @@
+# apollo-mst

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@apollo-annotation/mst",
+  "version": "0.1.11",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@jbrowse/core": "^2.7.0",
+    "mobx": "^6.6.1",
+    "mobx-state-tree": "^5.1.7",
+    "rxjs": "^7.4.0",
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.1.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/AnnotationFeature.ts

@@ -0,0 +1,243 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import {
+  IAnyModelType,
+  Instance,
+  SnapshotIn,
+  SnapshotOrInstance,
+  cast,
+  getParentOfType,
+  getSnapshot,
+  types,
+} from 'mobx-state-tree'
+
+import { ApolloAssembly } from '.'
+
+export const LateAnnotationFeature = types.late(
+  (): IAnyModelType => AnnotationFeature,
+)
+
+const Phase = types.maybe(
+  types.union(types.literal(0), types.literal(1), types.literal(2)),
+)
+export const AnnotationFeature = types
+  .model('AnnotationFeature', {
+    _id: types.identifier,
+    gffId: types.maybe(types.string), // ID from attributes if exists, otherwise gffId = _id
+    /** Reference sequence name */
+    refSeq: types.string,
+    /** Feature type */
+    type: types.string,
+    /** Feature location start coordinate */
+    start: types.number,
+    /** Feature location end coordinate */
+    end: types.number,
+    /**
+     * If the feature exists in multiple places, e.g. a CDS in a canonical SO
+     * gene, this gives the coordinates of the individual starts and ends. The
+     * start of the first location and the end of the last location should match
+     * the feature's start and end.
+     */
+    discontinuousLocations: types.maybe(
+      types.array(
+        types.model({ start: types.number, end: types.number, phase: Phase }),
+      ),
+    ),
+    /** The strand on which the feature is located */
+    strand: types.maybe(types.union(types.literal(1), types.literal(-1))),
+    /** The feature's score */
+    score: types.maybe(types.number),
+    /**
+     * The feature's phase, which is required for certain features, e.g. CDS in a
+     * canonical SO gene
+     */
+    phase: Phase,
+    /** Child features of this feature */
+    children: types.maybe(types.map(types.maybe(LateAnnotationFeature))),
+    /**
+     * Additional attributes of the feature. This could include name, source,
+     * note, dbxref, etc.
+     */
+    attributes: types.map(types.array(types.string)),
+  })
+  .views((self) => ({
+    get length() {
+      return self.end - self.start
+    },
+    get featureId() {
+      return self.attributes.get('id')
+    },
+    /**
+     * Possibly different from `start` because "The GFF3 format does not enforce
+     * a rule in which features must be wholly contained within the location of
+     * their parents"
+     */
+    get min() {
+      let min = self.start
+      for (const [, child] of self.children ?? []) {
+        min = Math.min(min, child.min)
+      }
+      return min
+    },
+    /**
+     * Possibly different from `end` because "The GFF3 format does not enforce a
+     * rule in which features must be wholly contained within the location of
+     * their parents"
+     */
+    get max() {
+      let max = self.end
+      for (const [, child] of self.children ?? []) {
+        max = Math.max(max, child.max)
+      }
+      return max
+    },
+    hasDescendant(featureId: string) {
+      const { children } = self
+      if (!children) {
+        return false
+      }
+      for (const [id, child] of children) {
+        if (id === featureId) {
+          return true
+        }
+        if (child.hasDescendant(featureId)) {
+          return true
+        }
+      }
+      return false
+    },
+  }))
+  .actions((self) => ({
+    setAttributes(attributes: Map<string, string[]>) {
+      self.attributes.clear()
+      for (const [key, value] of attributes.entries()) {
+        self.attributes.set(key, value)
+      }
+    },
+    setAttribute(key: string, value: string[]) {
+      self.attributes.merge({ [key]: value })
+    },
+    setType(type: string) {
+      self.type = type
+    },
+    setRefSeq(refSeq: string) {
+      self.refSeq = refSeq
+    },
+    setStart(start: number) {
+      if (start > self.end) {
+        throw new Error(`Start "${start}" is greater than end "${self.end}"`)
+      }
+      if (self.start !== start) {
+        self.start = start
+      }
+    },
+    setCDSDiscontinuousLocationStart(start: number, index: number) {
+      const dl = self.discontinuousLocations
+      if (dl && dl.length > 0 && dl[index].start !== start) {
+        dl[index].start = start
+        if (index === 0) {
+          self.start = start
+        }
+      }
+    },
+    setEnd(end: number) {
+      if (end < self.start) {
+        throw new Error(`End "${end}" is less than start "${self.start}"`)
+      }
+      if (self.end !== end) {
+        self.end = end
+      }
+    },
+    setCDSDiscontinuousLocationEnd(end: number, index: number) {
+      const dl = self.discontinuousLocations
+      if (dl && dl.length > 0 && dl[index].end !== end) {
+        dl[index].end = end
+        if (index === dl.length - 1) {
+          self.end = end
+        }
+      }
+    },
+    setStrand(strand?: 1 | -1) {
+      self.strand = strand
+    },
+    addChild(childFeature: AnnotationFeatureSnapshot) {
+      if (self.children && self.children.size > 0) {
+        const existingChildren = getSnapshot(self.children) ?? {}
+        self.children.clear()
+        for (const [, child] of Object.entries({
+          ...existingChildren,
+          [childFeature._id]: childFeature,
+        }).sort(([, a], [, b]) => a.start - b.start)) {
+          self.children.put(child)
+        }
+      } else {
+        self.children = cast({})
+        self.children?.put(childFeature)
+      }
+    },
+    deleteChild(childFeatureId: string) {
+      self.children?.delete(childFeatureId)
+    },
+  }))
+  .actions((self) => ({
+    update({
+      children,
+      end,
+      refSeq,
+      start,
+      strand,
+    }: {
+      refSeq: string
+      start: number
+      end: number
+      strand?: 1 | -1
+      children?: SnapshotOrInstance<typeof LateAnnotationFeature>
+    }) {
+      self.setRefSeq(refSeq)
+      self.setStart(start)
+      self.setEnd(end)
+      self.setStrand(strand)
+      if (children) {
+        self.children = cast(children)
+      }
+    },
+  }))
+  // This views block has to be last to avoid:
+  // "'parent' is referenced directly or indirectly in its own type annotation."
+  .views((self) => ({
+    get parent() {
+      let parent: AnnotationFeatureI | undefined
+      try {
+        parent = getParentOfType(self, AnnotationFeature)
+      } catch {
+        // pass
+      }
+      return parent
+    },
+    get topLevelFeature(): AnnotationFeatureI {
+      let feature = self
+      let parent
+      do {
+        try {
+          parent = getParentOfType(feature, AnnotationFeature)
+          feature = parent
+        } catch {
+          parent = undefined
+        }
+      } while (parent)
+      return feature as AnnotationFeatureI
+    },
+    get assemblyId(): string {
+      return getParentOfType(self, ApolloAssembly)._id
+    },
+  }))
+
+export type AnnotationFeatureI = Instance<typeof AnnotationFeature>
+type AnnotationFeatureSnapshotRaw = SnapshotIn<typeof AnnotationFeature>
+export interface AnnotationFeatureSnapshot
+  extends AnnotationFeatureSnapshotRaw {
+  /** Child features of this feature */
+  children?: Record<string, AnnotationFeatureSnapshot>
+}

package/src/ApolloAssembly.ts

@@ -0,0 +1,34 @@
+import { Instance, SnapshotIn, types } from 'mobx-state-tree'
+
+import { ApolloRefSeq } from './ApolloRefSeq'
+
+export const ApolloAssembly = types
+  .model('ApolloAssembly', {
+    _id: types.identifier,
+    refSeqs: types.map(ApolloRefSeq),
+    comments: types.array(types.string),
+    backendDriverType: types.optional(
+      types.enumeration('backendDriverType', [
+        'CollaborationServerDriver',
+        'InMemoryFileDriver',
+        'DesktopFileDriver',
+      ]),
+      'CollaborationServerDriver',
+    ),
+  })
+  .views((self) => ({
+    getByRefName(refName: string) {
+      return [...self.refSeqs.values()].find((val) => val.name === refName)
+    },
+  }))
+  .actions((self) => ({
+    addRefSeq(id: string, name: string, description?: string) {
+      return self.refSeqs.put({ _id: id, name, description })
+    },
+    addComment(comment: string) {
+      return self.comments.push(comment)
+    },
+  }))
+
+export type ApolloAssemblyI = Instance<typeof ApolloAssembly>
+export type ApolloAssemblySnapshot = SnapshotIn<typeof ApolloAssembly>

package/src/ApolloRefSeq.ts

@@ -0,0 +1,116 @@
+import { isContainedWithin } from '@jbrowse/core/util'
+import {
+  Instance,
+  SnapshotIn,
+  SnapshotOrInstance,
+  types,
+} from 'mobx-state-tree'
+
+import {
+  AnnotationFeature,
+  AnnotationFeatureSnapshot,
+} from './AnnotationFeature'
+
+export const Sequence = types.model({
+  start: types.number,
+  stop: types.number,
+  sequence: types.string,
+})
+
+interface SequenceSnapshot {
+  start: number
+  stop: number
+  sequence: string
+}
+
+export const ApolloRefSeq = types
+  .model('ApolloRefSeq', {
+    _id: types.identifier,
+    name: types.string,
+    description: '',
+    features: types.map(AnnotationFeature),
+    sequence: types.array(Sequence),
+  })
+  .actions((self) => ({
+    addFeature(feature: AnnotationFeatureSnapshot) {
+      self.features.put(feature)
+    },
+    deleteFeature(featureId: string) {
+      return self.features.delete(featureId)
+    },
+    setDescription(description: string) {
+      self.description = description
+    },
+    addSequence(seq: SnapshotOrInstance<typeof Sequence>) {
+      if (seq.sequence.length !== seq.stop - seq.start) {
+        throw new Error('sequence does not match declared length')
+      }
+      if (self.sequence.length === 0) {
+        self.sequence.push(seq)
+        return
+      }
+      const newSequences: SequenceSnapshot[] = self.sequence.map((s) => ({
+        start: s.start,
+        stop: s.stop,
+        sequence: s.sequence,
+      }))
+      newSequences.push({
+        start: seq.start,
+        stop: seq.stop,
+        sequence: seq.sequence,
+      })
+      newSequences.sort((s1, s2) => s1.start - s2.start)
+      // eslint-disable-next-line unicorn/no-array-reduce
+      const consolidatedSequences = newSequences.reduce<SequenceSnapshot[]>(
+        (result, current) => {
+          const lastRange = result.at(-1)
+          if (lastRange === undefined) {
+            return [current]
+          }
+          if (lastRange.stop >= current.start) {
+            if (current.stop > lastRange.stop) {
+              lastRange.stop = current.stop
+              lastRange.sequence += current.sequence.slice(
+                current.stop - lastRange.stop,
+              )
+            }
+          } else {
+            result.push(current)
+          }
+          return result
+        },
+        [],
+      )
+      if (
+        self.sequence.length === consolidatedSequences.length &&
+        self.sequence.every(
+          (s, idx) =>
+            s.start === consolidatedSequences[idx].start &&
+            s.stop === consolidatedSequences[idx].stop,
+        )
+      ) {
+        // sequences was unchanged
+        return
+      }
+      self.sequence.clear()
+      self.sequence.push(...consolidatedSequences)
+    },
+  }))
+  .views((self) => ({
+    getSequence(start: number, stop: number): string {
+      for (const {
+        sequence,
+        start: seqStart,
+        stop: seqStop,
+      } of self.sequence) {
+        // adjacent to existing sequence - modify
+        if (isContainedWithin(start, stop, seqStart, seqStop)) {
+          return sequence.slice(start - seqStart, stop - seqStart)
+        }
+      }
+      return ''
+    },
+  }))
+
+export type ApolloRefSeqI = Instance<typeof ApolloRefSeq>
+export type ApolloRefSeqSnapshot = SnapshotIn<typeof ApolloRefSeq>

package/src/CheckResult.ts

@@ -0,0 +1,17 @@
+import { Instance, SnapshotIn, types } from 'mobx-state-tree'
+
+import { AnnotationFeature } from './AnnotationFeature'
+
+export const CheckResult = types.model('CheckResult', {
+  _id: types.identifier,
+  name: types.string,
+  ids: types.array(types.safeReference(AnnotationFeature)),
+  refSeq: types.string,
+  start: types.number,
+  end: types.number,
+  ignored: false,
+  message: types.string,
+})
+
+export type CheckResultI = Instance<typeof CheckResult>
+export type CheckResultSnapshot = SnapshotIn<typeof CheckResult>

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './AnnotationFeature'
+export * from './ApolloAssembly'
+export * from './ApolloRefSeq'
+export * from './CheckResult'

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "incremental": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "CommonJS",
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strictPropertyInitialization": false,
+  },
+  "include": ["./src"],
+}