@apollo-annotation/mst 0.1.17 → 0.1.19

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@apollo-annotation/mst",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "main": "./dist/index.js",
   "scripts": {
     "build": "tsc"
   },
   "dependencies": {
-    "@jbrowse/core": "^2.7.0",
+    "@jbrowse/core": "^2.13.1",
     "mobx": "^6.6.1",
     "mobx-state-tree": "^5.1.7",
+    "react-dom": "^18.2.0",
     "rxjs": "^7.4.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "typescript": "^5.1.6"
+    "typescript": "^5.5.3"
   },
   "publishConfig": {
     "access": "public"

package/src/AnnotationFeatureModel.ts

@@ -0,0 +1,293 @@
+import { intersection2 } from '@jbrowse/core/util'
+import {
+  IAnyModelType,
+  IMSTMap,
+  Instance,
+  SnapshotIn,
+  SnapshotOrInstance,
+  cast,
+  getParentOfType,
+  getSnapshot,
+  types,
+} from 'mobx-state-tree'
+
+import { ApolloAssembly } from '.'
+
+const LateAnnotationFeature = types.late(
+  (): IAnyModelType => AnnotationFeatureModel,
+)
+
+export const AnnotationFeatureModel = types
+  .model('AnnotationFeatureModel', {
+    _id: types.identifier,
+    /** Unique ID of the reference sequence on which this feature is located */
+    refSeq: types.string,
+    /**
+     * Type of feature. Can be any string, but is usually an ontology term,
+     * e.g. "gene" from the
+     * {@link http://sequenceontology.org/browser/current_release/term/SO:0000704 |Sequence Ontology}.
+     */
+    type: types.string,
+    /**
+     * Coordinate of the edge of the feature that is closer to the beginning of
+     * the reference sequence. This can be thought of as the "start" of features
+     * on the positive strand. Uses interbase (0-based half-open) coordinates.
+     */
+    min: types.number,
+    /**
+     * Coordinate of the edge of the feature that is closer to the end of the
+     * reference sequence. This can be thought of as the "end" of features on
+     * the positive strand. Uses interbase (0-based half-open) coordinates.
+     */
+    max: types.number,
+    /**
+     * The strand on which the feature is located. `+1` for the positive (a.k.a.
+     * plus or forward) and `-1` for the negative (a.k.a minus or reverse)
+     * strand.
+     */
+    strand: types.maybe(types.union(types.literal(1), types.literal(-1))),
+    /** Child features of this feature */
+    children: types.maybe(types.map(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.max - self.min
+    },
+    get featureId() {
+      return self.attributes.get('id')
+    },
+    /**
+     * Possibly different from `min` because "The GFF3 format does not enforce a
+     * rule in which features must be wholly contained within the location of
+     * their parents"
+     */
+    get minWithChildren() {
+      let { min } = self
+      const children = self.children as Children
+      if (!children) {
+        return min
+      }
+      for (const [, child] of children) {
+        min = Math.min(min, child.min)
+      }
+      return min
+    },
+    /**
+     * Possibly different from `max` because "The GFF3 format does not enforce a
+     * rule in which features must be wholly contained within the location of
+     * their parents"
+     */
+    get maxWithChildren() {
+      let { max } = self
+      const children = self.children as Children
+      if (!children) {
+        return max
+      }
+      for (const [, child] of children) {
+        max = Math.max(max, child.max)
+      }
+      return max
+    },
+    hasDescendant(featureId: string) {
+      const children = self.children as Children
+      if (!children) {
+        return false
+      }
+      for (const [id, child] of children) {
+        if (id === featureId) {
+          return true
+        }
+        if (child.hasDescendant(featureId)) {
+          return true
+        }
+      }
+      return false
+    },
+    get cdsLocations(): { min: number; max: number; phase: 0 | 1 | 2 }[][] {
+      if (self.type !== 'mRNA') {
+        throw new Error(
+          'Only features of type "mRNA" or equivalent can calculate CDS locations',
+        )
+      }
+      const children = self.children as Children
+      if (!children) {
+        throw new Error('no CDS or exons in mRNA')
+      }
+      const cdsChildren = [...children.values()].filter(
+        (child) => child.type === 'CDS',
+      )
+      if (cdsChildren.length === 0) {
+        throw new Error('no CDS in mRNA')
+      }
+      const cdsLocations: { min: number; max: number; phase: 0 | 1 | 2 }[][] =
+        []
+      for (const cds of cdsChildren) {
+        const { max: cdsMax, min: cdsMin } = cds
+        const locs: { min: number; max: number }[] = []
+        for (const [, child] of children) {
+          if (child.type !== 'exon') {
+            continue
+          }
+          const [start, end] = intersection2(
+            cdsMin,
+            cdsMax,
+            child.min,
+            child.max,
+          )
+          if (start !== undefined && end !== undefined) {
+            locs.push({ min: start, max: end })
+          }
+        }
+        locs.sort(({ min: a }, { min: b }) => a - b)
+        if (self.strand === -1) {
+          locs.reverse()
+        }
+        let nextPhase: 0 | 1 | 2 = 0
+        const phasedLocs = locs.map((loc) => {
+          const phase = nextPhase
+          nextPhase = ((3 - ((loc.max - loc.min - phase + 3) % 3)) % 3) as
+            | 0
+            | 1
+            | 2
+          return { ...loc, phase }
+        })
+        cdsLocations.push(phasedLocs)
+      }
+      return cdsLocations
+    },
+  }))
+  .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
+    },
+    setMin(min: number) {
+      if (min > self.max) {
+        throw new Error(`Min "${min}" is greater than max "${self.max}"`)
+      }
+      if (self.min !== min) {
+        self.min = min
+      }
+    },
+    setMax(max: number) {
+      if (max < self.min) {
+        throw new Error(`Max "${max}" is less than Min "${self.min}"`)
+      }
+      if (self.max !== max) {
+        self.max = max
+      }
+    },
+    setStrand(strand?: 1 | -1 | undefined) {
+      self.strand = strand
+    },
+    addChild(childFeature: AnnotationFeatureSnapshot) {
+      if (self.children && self.children.size > 0) {
+        const existingChildren = getSnapshot<
+          Record<string, AnnotationFeatureSnapshot>
+        >(self.children)
+        self.children.clear()
+        for (const [, child] of Object.entries({
+          ...existingChildren,
+          [childFeature._id]: childFeature,
+        }).sort(([, a], [, b]) => a.min - b.min)) {
+          self.children.put(child)
+        }
+      } else {
+        self.children = cast({})
+        self.children?.put(childFeature)
+      }
+    },
+    deleteChild(childFeatureId: string) {
+      self.children?.delete(childFeatureId)
+    },
+  }))
+  .actions((self) => ({
+    update({
+      children,
+      max,
+      min,
+      refSeq,
+      strand,
+    }: {
+      refSeq: string
+      min: number
+      max: number
+      strand?: 1 | -1
+      children?: SnapshotOrInstance<typeof self.children>
+    }) {
+      self.setRefSeq(refSeq)
+      self.setMin(min)
+      self.setMax(max)
+      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(): AnnotationFeature | undefined {
+      let parent: AnnotationFeature | undefined
+      try {
+        parent = getParentOfType(self, AnnotationFeatureModel)
+      } catch {
+        // pass
+      }
+      return parent
+    },
+    get topLevelFeature(): AnnotationFeature {
+      let feature = self
+      let parent
+      do {
+        try {
+          parent = getParentOfType(feature, AnnotationFeatureModel)
+          feature = parent
+        } catch {
+          parent = undefined
+        }
+      } while (parent)
+      return feature as AnnotationFeature
+    },
+    get assemblyId(): string {
+      return getParentOfType(self, ApolloAssembly)._id
+    },
+  }))
+
+export type Children = IMSTMap<typeof AnnotationFeatureModel> | undefined
+
+// eslint disables because of
+// https://mobx-state-tree.js.org/tips/typescript#using-a-mst-type-at-design-time
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface AnnotationFeatureRaw
+  extends Instance<typeof AnnotationFeatureModel> {}
+// This type isn't exactly right, since "children" is actually an IMSTMap and
+// not a Map, but it's better than typing it as any.
+export interface AnnotationFeature
+  extends Omit<AnnotationFeatureRaw, 'children'> {
+  children?: Map<string, AnnotationFeature>
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface AnnotationFeatureSnapshotRaw
+  extends SnapshotIn<typeof AnnotationFeatureModel> {}
+export interface AnnotationFeatureSnapshot
+  extends AnnotationFeatureSnapshotRaw {
+  /** Child features of this feature */
+  children?: Record<string, AnnotationFeatureSnapshot>
+}

package/src/ApolloAssembly.ts

@@ -2,6 +2,11 @@ import { Instance, SnapshotIn, types } from 'mobx-state-tree'
 
 import { ApolloRefSeq } from './ApolloRefSeq'
 
+export type BackendDriverType =
+  | 'CollaborationServerDriver'
+  | 'InMemoryFileDriver'
+  | 'DesktopFileDriver'
+
 export const ApolloAssembly = types
   .model('ApolloAssembly', {
     _id: types.identifier,
@@ -30,5 +35,10 @@ export const ApolloAssembly = types
     },
   }))
 
-export type ApolloAssemblyI = Instance<typeof ApolloAssembly>
-export type ApolloAssemblySnapshot = SnapshotIn<typeof ApolloAssembly>
+// eslint disables because of
+// https://mobx-state-tree.js.org/tips/typescript#using-a-mst-type-at-design-time
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ApolloAssemblyI extends Instance<typeof ApolloAssembly> {}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ApolloAssemblySnapshot
+  extends SnapshotIn<typeof ApolloAssembly> {}

package/src/ApolloRefSeq.ts

@@ -7,9 +7,9 @@ import {
 } from 'mobx-state-tree'
 
 import {
-  AnnotationFeature,
+  AnnotationFeatureModel,
   AnnotationFeatureSnapshot,
-} from './AnnotationFeature'
+} from './AnnotationFeatureModel'
 
 export const Sequence = types.model({
   start: types.number,
@@ -28,7 +28,7 @@ export const ApolloRefSeq = types
     _id: types.identifier,
     name: types.string,
     description: '',
-    features: types.map(AnnotationFeature),
+    features: types.map(AnnotationFeatureModel),
     sequence: types.array(Sequence),
   })
   .actions((self) => ({
@@ -112,5 +112,9 @@ export const ApolloRefSeq = types
     },
   }))
 
-export type ApolloRefSeqI = Instance<typeof ApolloRefSeq>
-export type ApolloRefSeqSnapshot = SnapshotIn<typeof ApolloRefSeq>
+// eslint disables because of
+// https://mobx-state-tree.js.org/tips/typescript#using-a-mst-type-at-design-time
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ApolloRefSeqI extends Instance<typeof ApolloRefSeq> {}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ApolloRefSeqSnapshot extends SnapshotIn<typeof ApolloRefSeq> {}

package/src/CheckResult.ts

@@ -1,11 +1,11 @@
 import { Instance, SnapshotIn, types } from 'mobx-state-tree'
 
-import { AnnotationFeature } from './AnnotationFeature'
+import { AnnotationFeatureModel } from './AnnotationFeatureModel'
 
 export const CheckResult = types.model('CheckResult', {
   _id: types.identifier,
   name: types.string,
-  ids: types.array(types.safeReference(AnnotationFeature)),
+  ids: types.array(types.safeReference(AnnotationFeatureModel)),
   refSeq: types.string,
   start: types.number,
   end: types.number,
@@ -13,5 +13,9 @@ export const CheckResult = types.model('CheckResult', {
   message: types.string,
 })
 
-export type CheckResultI = Instance<typeof CheckResult>
-export type CheckResultSnapshot = SnapshotIn<typeof CheckResult>
+// eslint disables because of
+// https://mobx-state-tree.js.org/tips/typescript#using-a-mst-type-at-design-time
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface CheckResultI extends Instance<typeof CheckResult> {}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface CheckResultSnapshot extends SnapshotIn<typeof CheckResult> {}

package/src/index.ts

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

package/src/AnnotationFeature.ts

@@ -1,243 +0,0 @@
-/* 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>
-}