@apollo-annotation/shared 0.3.5 → 0.3.7

package/src/Changes/UndoMergeExonsChange.ts

@@ -0,0 +1,149 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  type ChangeOptions,
+  type ClientDataStore,
+  FeatureChange,
+  type LocalGFF3DataStore,
+  type SerializedFeatureChange,
+  type ServerDataStore,
+} from '@apollo-annotation/common'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { MergeExonsChange } from './MergeExonsChange'
+
+interface SerializedUndoMergeExonsChangeBase extends SerializedFeatureChange {
+  typeName: 'UndoMergeExonsChange'
+}
+
+export interface UndoMergeExonsChangeDetails {
+  exonsToRestore: AnnotationFeatureSnapshot[]
+  parentFeatureId: string
+}
+
+interface SerializedUndoMergeExonsChangeSingle
+  extends SerializedUndoMergeExonsChangeBase,
+    UndoMergeExonsChangeDetails {}
+
+interface SerializedUndoMergeExonsChangeMultiple
+  extends SerializedUndoMergeExonsChangeBase {
+  changes: UndoMergeExonsChangeDetails[]
+}
+
+export type SerializedUndoMergeExonsChange =
+  | SerializedUndoMergeExonsChangeSingle
+  | SerializedUndoMergeExonsChangeMultiple
+export class UndoMergeExonsChange extends FeatureChange {
+  typeName = 'UndoMergeExonsChange' as const
+  changes: UndoMergeExonsChangeDetails[]
+
+  constructor(json: SerializedUndoMergeExonsChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedUndoMergeExonsChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ exonsToRestore, parentFeatureId }] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        exonsToRestore,
+        parentFeatureId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes } = this
+    for (const change of changes) {
+      const { exonsToRestore, parentFeatureId } = change
+      if (exonsToRestore.length !== 2) {
+        throw new Error(
+          `Expected exactly two exons to restore. Got :${exonsToRestore.length}`,
+        )
+      }
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: parentFeatureId })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        throw new Error(`Could not find feature with ID "${parentFeatureId}"`)
+      }
+      const parentFeature = this.getFeatureFromId(
+        topLevelFeature,
+        parentFeatureId,
+      )
+      if (!parentFeature) {
+        throw new Error(
+          `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id.toString()}"`,
+        )
+      }
+      if (!parentFeature.children) {
+        parentFeature.children = new Map()
+      }
+      for (const exon of exonsToRestore) {
+        this.addChild(parentFeature, exon)
+        const childIds = this.getChildFeatureIds(exon)
+        topLevelFeature.allIds.push(exon._id, ...childIds)
+      }
+      await topLevelFeature.save()
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { changes } = this
+    for (const change of changes) {
+      const { exonsToRestore, parentFeatureId } = change
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      for (const exon of exonsToRestore) {
+        parentFeature.addChild(exon)
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((undoMergeExonsChange) => ({
+        firstExon: undoMergeExonsChange.exonsToRestore[0],
+        secondExon: undoMergeExonsChange.exonsToRestore[1],
+        parentFeatureId: undoMergeExonsChange.parentFeatureId,
+      }))
+
+    return new MergeExonsChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'MergeExonsChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}

package/src/Changes/UndoMergeTranscriptsChange.ts

@@ -0,0 +1,153 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  type ChangeOptions,
+  type ClientDataStore,
+  FeatureChange,
+  type LocalGFF3DataStore,
+  type SerializedFeatureChange,
+  type ServerDataStore,
+} from '@apollo-annotation/common'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { MergeTranscriptsChange } from './MergeTranscriptsChange'
+
+interface SerializedUndoMergeTranscriptsChangeBase
+  extends SerializedFeatureChange {
+  typeName: 'UndoMergeTranscriptsChange'
+}
+
+export interface UndoMergeTranscriptsChangeDetails {
+  transcriptsToRestore: AnnotationFeatureSnapshot[]
+  parentFeatureId: string
+}
+
+interface SerializedUndoMergeTranscriptsChangeSingle
+  extends SerializedUndoMergeTranscriptsChangeBase,
+    UndoMergeTranscriptsChangeDetails {}
+
+interface SerializedUndoMergeTranscriptsChangeMultiple
+  extends SerializedUndoMergeTranscriptsChangeBase {
+  changes: UndoMergeTranscriptsChangeDetails[]
+}
+
+export type SerializedUndoMergeTranscriptsChange =
+  | SerializedUndoMergeTranscriptsChangeSingle
+  | SerializedUndoMergeTranscriptsChangeMultiple
+export class UndoMergeTranscriptsChange extends FeatureChange {
+  typeName = 'UndoMergeTranscriptsChange' as const
+  changes: UndoMergeTranscriptsChangeDetails[]
+
+  constructor(
+    json: SerializedUndoMergeTranscriptsChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedUndoMergeTranscriptsChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ transcriptsToRestore, parentFeatureId }] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        transcriptsToRestore,
+        parentFeatureId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes } = this
+    for (const change of changes) {
+      const { transcriptsToRestore, parentFeatureId } = change
+      if (transcriptsToRestore.length !== 2) {
+        throw new Error(
+          `Expected exactly two transcripts to restore. Got :${transcriptsToRestore.length}`,
+        )
+      }
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: parentFeatureId })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        throw new Error(`Could not find feature with ID "${parentFeatureId}"`)
+      }
+      const parentFeature = this.getFeatureFromId(
+        topLevelFeature,
+        parentFeatureId,
+      )
+      if (!parentFeature) {
+        throw new Error(
+          `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id.toString()}"`,
+        )
+      }
+      if (!parentFeature.children) {
+        parentFeature.children = new Map()
+      }
+      for (const transcript of transcriptsToRestore) {
+        this.addChild(parentFeature, transcript)
+        const childIds = this.getChildFeatureIds(transcript)
+        topLevelFeature.allIds.push(transcript._id, ...childIds)
+      }
+      await topLevelFeature.save()
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { changes } = this
+    for (const change of changes) {
+      const { transcriptsToRestore, parentFeatureId } = change
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      for (const transcript of transcriptsToRestore) {
+        parentFeature.addChild(transcript)
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((undoMergeTranscriptsChange) => ({
+        firstTranscript: undoMergeTranscriptsChange.transcriptsToRestore[0],
+        secondTranscript: undoMergeTranscriptsChange.transcriptsToRestore[1],
+        parentFeatureId: undoMergeTranscriptsChange.parentFeatureId,
+      }))
+
+    return new MergeTranscriptsChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'MergeTranscriptsChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}

package/src/Changes/UndoSplitExonChange.ts

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  type ChangeOptions,
+  type ClientDataStore,
+  FeatureChange,
+  type LocalGFF3DataStore,
+  type SerializedFeatureChange,
+  type ServerDataStore,
+} from '@apollo-annotation/common'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { findAndDeleteChildFeature } from './DeleteFeatureChange'
+import { SplitExonChange } from './SplitExonChange'
+
+interface SerializedUndoSplitExonChangeBase extends SerializedFeatureChange {
+  typeName: 'UndoSplitExonChange'
+}
+
+export interface UndoSplitExonChangeDetails {
+  exonToRestore: AnnotationFeatureSnapshot
+  parentFeatureId: string
+  idsToDelete: string[]
+  upstreamCut: number
+  downstreamCut: number
+  leftExonId: string
+  rightExonId: string
+}
+
+interface SerializedUndoSplitExonChangeSingle
+  extends SerializedUndoSplitExonChangeBase,
+    UndoSplitExonChangeDetails {}
+
+interface SerializedUndoSplitExonChangeMultiple
+  extends SerializedUndoSplitExonChangeBase {
+  changes: UndoSplitExonChangeDetails[]
+}
+
+export type SerializedUndoSplitExonChange =
+  | SerializedUndoSplitExonChangeSingle
+  | SerializedUndoSplitExonChangeMultiple
+export class UndoSplitExonChange extends FeatureChange {
+  typeName = 'UndoSplitExonChange' as const
+  changes: UndoSplitExonChangeDetails[]
+
+  constructor(json: SerializedUndoSplitExonChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedUndoSplitExonChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [
+        {
+          exonToRestore,
+          parentFeatureId,
+          idsToDelete,
+          upstreamCut,
+          downstreamCut,
+          leftExonId,
+          rightExonId,
+        },
+      ] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        exonToRestore,
+        parentFeatureId,
+        idsToDelete,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes } = this
+    for (const change of changes) {
+      const { exonToRestore, parentFeatureId, idsToDelete } = change
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: parentFeatureId })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        throw new Error(`Could not find feature with ID "${parentFeatureId}"`)
+      }
+      const parentFeature = this.getFeatureFromId(
+        topLevelFeature,
+        parentFeatureId,
+      )
+      if (!parentFeature) {
+        throw new Error(
+          `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id.toString()}"`,
+        )
+      }
+      if (!parentFeature.children) {
+        parentFeature.children = new Map()
+      }
+
+      this.addChild(parentFeature, exonToRestore)
+      const childIds = this.getChildFeatureIds(exonToRestore)
+      topLevelFeature.allIds.push(exonToRestore._id, ...childIds)
+      topLevelFeature.allIds = topLevelFeature.allIds.filter(
+        (id) => !idsToDelete.includes(id),
+      )
+      idsToDelete.map((id) =>
+        findAndDeleteChildFeature(topLevelFeature, id, this),
+      )
+      await topLevelFeature.save()
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { changes } = this
+    for (const change of changes) {
+      const { exonToRestore, parentFeatureId, idsToDelete } = change
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      parentFeature.addChild(exonToRestore)
+      idsToDelete.map((id) => {
+        parentFeature.deleteChild(id)
+      })
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((undoSplitExonChange) => ({
+        parentFeatureId: undoSplitExonChange.parentFeatureId,
+        exonToBeSplit: undoSplitExonChange.exonToRestore,
+        upstreamCut: undoSplitExonChange.upstreamCut,
+        downstreamCut: undoSplitExonChange.downstreamCut,
+        leftExonId: undoSplitExonChange.leftExonId,
+        rightExonId: undoSplitExonChange.rightExonId,
+      }))
+
+    return new SplitExonChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'SplitExonChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}

package/src/Changes/UserChange.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/require-await */
 import {
   Change,
-  ChangeOptions,
-  ClientDataStore,
-  LocalGFF3DataStore,
-  SerializedChange,
-  ServerDataStore,
+  type ChangeOptions,
+  type ClientDataStore,
+  type LocalGFF3DataStore,
+  type SerializedChange,
+  type ServerDataStore,
 } from '@apollo-annotation/common'
 
 export interface SerializedUserChangeBase extends SerializedChange {

package/src/Changes/index.ts

@@ -1,3 +1,4 @@
+import { AddAssemblyAliasesChange } from './AddAssemblyAliasesChange'
 import { AddAssemblyAndFeaturesFromFileChange } from './AddAssemblyAndFeaturesFromFileChange'
 import { AddAssemblyFromExternalChange } from './AddAssemblyFromExternalChange'
 import { AddAssemblyFromFileChange } from './AddAssemblyFromFileChange'
@@ -11,8 +12,14 @@ import { FeatureAttributeChange } from './FeatureAttributeChange'
 import { ImportJBrowseConfigChange } from './ImportJBrowseConfigChange'
 import { LocationEndChange } from './LocationEndChange'
 import { LocationStartChange } from './LocationStartChange'
+import { MergeExonsChange } from './MergeExonsChange'
+import { MergeTranscriptsChange } from './MergeTranscriptsChange'
+import { SplitExonChange } from './SplitExonChange'
 import { StrandChange } from './StrandChange'
 import { TypeChange } from './TypeChange'
+import { UndoMergeExonsChange } from './UndoMergeExonsChange'
+import { UndoMergeTranscriptsChange } from './UndoMergeTranscriptsChange'
+import { UndoSplitExonChange } from './UndoSplitExonChange'
 import { UserChange } from './UserChange'
 
 export const changes = {
@@ -28,10 +35,17 @@ export const changes = {
   ImportJBrowseConfigChange,
   LocationEndChange,
   LocationStartChange,
+  MergeExonsChange,
+  SplitExonChange,
+  MergeTranscriptsChange,
+  UndoMergeExonsChange,
+  UndoSplitExonChange,
+  UndoMergeTranscriptsChange,
   StrandChange,
   TypeChange,
   UserChange,
   AddRefSeqAliasesChange,
+  AddAssemblyAliasesChange,
 }
 
 export * from './AddAssemblyAndFeaturesFromFileChange'
@@ -46,7 +60,14 @@ export * from './FeatureAttributeChange'
 export * from './ImportJBrowseConfigChange'
 export * from './LocationEndChange'
 export * from './LocationStartChange'
+export * from './MergeExonsChange'
+export * from './SplitExonChange'
+export * from './MergeTranscriptsChange'
+export * from './UndoMergeExonsChange'
+export * from './UndoSplitExonChange'
+export * from './UndoMergeTranscriptsChange'
 export * from './StrandChange'
 export * from './TypeChange'
 export * from './UserChange'
 export * from './AddRefSeqAliasesChange'
+export * from './AddAssemblyAliasesChange'

package/src/Checks/CDSCheck.ts

@@ -1,7 +1,7 @@
 import { Check } from '@apollo-annotation/common'
 import {
-  AnnotationFeatureSnapshot,
-  CheckResultSnapshot,
+  type AnnotationFeatureSnapshot,
+  type CheckResultSnapshot,
 } from '@apollo-annotation/mst'
 import { intersection2 } from '@jbrowse/core/util'
 import ObjectID from 'bson-objectid'

package/src/GFF3/annotationFeatureToGFF3.test.ts

@@ -1,10 +1,12 @@
 /* eslint-disable prefer-destructuring */
 /* eslint-disable @typescript-eslint/no-floating-promises */
 import { describe, it } from 'node:test'
+
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
 import { assert } from 'chai'
-import { readAnnotationFeatureSnapshot } from './gff3ToAnnotationFeature.test'
+
 import { annotationFeatureToGFF3 } from './annotationFeatureToGFF3'
-import { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+import { readAnnotationFeatureSnapshot } from './gff3ToAnnotationFeature.test'
 
 describe('annotationFeatureToGFF3', () => {
   it('Test mandatory columns', () => {

package/src/GFF3/annotationFeatureToGFF3.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 
 import {
-  AnnotationFeatureSnapshot,
-  TranscriptPartLocation,
-  TranscriptPartNonCoding,
+  type AnnotationFeatureSnapshot,
+  type TranscriptPartLocation,
+  type TranscriptPartNonCoding,
 } from '@apollo-annotation/mst'
-import { GFF3Feature } from '@gmod/gff'
+import { type GFF3Feature } from '@gmod/gff'
 import { intersection2 } from '@jbrowse/core/util'
 
 export function annotationFeatureToGFF3(
@@ -252,7 +252,13 @@ function getTranscriptParts(
 function getCdsLocations(
   feature: AnnotationFeatureSnapshot,
 ): TranscriptPartCoding[][] {
-  const transcriptParts = getTranscriptParts(feature)
+  let transcriptParts: TranscriptParts[] = []
+  try {
+    transcriptParts = getTranscriptParts(feature)
+  } catch {
+    return []
+  }
+
   return transcriptParts.map((transcript) =>
     transcript.filter((transcriptPart) => transcriptPart.type === 'CDS'),
   )

package/src/GFF3/gff3ToAnnotationFeature.test.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-floating-promises */
-import { describe, it } from 'node:test'
 import { readFileSync } from 'node:fs'
+import { describe, it } from 'node:test'
 
-import gff, { GFF3Feature } from '@gmod/gff'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+import gff, { type GFF3Feature } from '@gmod/gff'
 import { assert, use } from 'chai'
 import chaiExclude from 'chai-exclude'
 
 import { gff3ToAnnotationFeature } from './gff3ToAnnotationFeature'
-import { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
 
 use(chaiExclude)
 

package/src/GFF3/gff3ToAnnotationFeature.ts

@@ -1,5 +1,5 @@
-import { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
-import { GFF3Feature, GFF3FeatureLineWithRefs } from '@gmod/gff'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+import { type GFF3Feature, type GFF3FeatureLineWithRefs } from '@gmod/gff'
 import { doesIntersect2 } from '@jbrowse/core/util'
 import ObjectID from 'bson-objectid'
 

package/src/GFF3/gffReservedKeys.ts

@@ -59,3 +59,28 @@ export const internalToGFF: Record<GFFInternalAttribute, GFFReservedAttribute> =
     gff_ontology_term: 'Ontology_term',
     gff_is_circular: 'Is_circular',
   }
+
+export function isGFFInternalAttribute(
+  attribute: string,
+): attribute is GFFInternalAttribute {
+  return attribute in internalToGFF
+}
+
+export type GFFColumn = 'score' | 'source'
+export type GFFColumnInternal = 'gff_score' | 'gff_source'
+export const gffColumnToInternal: Record<GFFColumn, GFFColumnInternal> = {
+  score: 'gff_score',
+  source: 'gff_source',
+}
+export function isGFFColumn(attribute: string): attribute is GFFColumn {
+  return attribute in gffColumnToInternal
+}
+export const gffInternalToColumn: Record<GFFColumnInternal, GFFColumn> = {
+  gff_score: 'score',
+  gff_source: 'source',
+}
+export function isGFFColumnInternal(
+  column: string,
+): column is GFFColumnInternal {
+  return column in gffInternalToColumn
+}

package/src/Messages.ts

@@ -1,5 +1,5 @@
-import { SerializedChange } from '@apollo-annotation/common'
-import { CheckResultSnapshot } from '@apollo-annotation/mst'
+import { type SerializedChange } from '@apollo-annotation/common'
+import { type CheckResultSnapshot } from '@apollo-annotation/mst'
 
 interface BaseMessage {
   channel: string

package/src/Operations/GetAssembliesOperation.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/require-await */
 import {
-  LocalGFF3DataStore,
+  type LocalGFF3DataStore,
   Operation,
-  SerializedOperation,
-  ServerDataStore,
+  type SerializedOperation,
+  type ServerDataStore,
 } from '@apollo-annotation/common'
 
 interface SerializedGetAssembliesOperation extends SerializedOperation {