@apollo-annotation/shared 0.3.12 → 1.0.0

package/src/Changes/FromFileBaseChange.ts

@@ -1,231 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import {
-  AssemblySpecificChange,
-  type ServerDataStore,
-} from '@apollo-annotation/common'
-import type { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
-import type { FileDocument, RefSeqDocument } from '@apollo-annotation/schemas'
-import type { GFF3Feature } from '@gmod/gff'
-
-import { gff3ToAnnotationFeature } from '../GFF3/index.js'
-
-export abstract class FromFileBaseChange extends AssemblySpecificChange {
-  async addRefSeqIntoDb(
-    fileDoc: FileDocument,
-    assembly: string,
-    backend: ServerDataStore,
-  ) {
-    const { logger } = this
-    const { filesService, refSeqChunkModel, refSeqModel, user } = backend
-    const { CHUNK_SIZE } = process.env
-    const customChunkSize = CHUNK_SIZE && Number(CHUNK_SIZE)
-    let chunkIndex = 0
-    let refSeqLen = 0
-    let refSeqDoc: RefSeqDocument | undefined
-    let fastaInfoStarted = fileDoc.type !== 'text/x-gff3'
-
-    // Read data from compressed file and parse the content
-    const sequenceStream = filesService.getFileStream(fileDoc)
-    let sequenceBuffer = ''
-    let incompleteLine = ''
-    let lastLineIsIncomplete = true
-    let parsingStarted = false
-    logger.debug?.('starting sequence stream')
-    let lineCount = 0
-    const decoder = new TextDecoder()
-    for await (const data of sequenceStream) {
-      const chunk = decoder.decode(data)
-      lastLineIsIncomplete = !chunk.endsWith('\n')
-      // chunk is small enough that you can split the whole thing into lines without having to make it into smaller chunks first.
-      const lines = chunk.split(/\r?\n/)
-      if (incompleteLine) {
-        lines[0] = `${incompleteLine}${lines[0]}`
-        incompleteLine = ''
-      }
-      if (lastLineIsIncomplete) {
-        incompleteLine = lines.pop() ?? ''
-      }
-      for (const line of lines) {
-        lineCount++
-        if (lineCount % 1_000_000 === 0) {
-          logger.debug?.(`Processed ${lineCount} lines`)
-        }
-        // In case of GFF3 file we start to read sequence after '##FASTA' is found
-        if (!fastaInfoStarted) {
-          if (line.trim() === '##FASTA') {
-            fastaInfoStarted = true
-          }
-          continue
-        }
-        const refSeqInfoLine = /^>\s*(\S+)\s*(.*)/.exec(line)
-        // Add new ref sequence info if we are reference seq info line
-        if (refSeqInfoLine) {
-          parsingStarted = true
-          logger.debug?.(
-            `Reference sequence information line "${refSeqInfoLine[0]}"`,
-          )
-
-          // If there is sequence from previous reference sequence then we need to add it to previous ref seq
-          if (sequenceBuffer !== '') {
-            if (!refSeqDoc) {
-              throw new Error('No refSeq document found')
-            }
-            refSeqLen += sequenceBuffer.length
-            // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
-            await refSeqChunkModel.create([
-              {
-                refSeq: refSeqDoc._id,
-                n: chunkIndex,
-                sequence: sequenceBuffer,
-                user,
-                status: -1,
-              },
-            ])
-            sequenceBuffer = ''
-          }
-          await refSeqDoc?.updateOne({ length: refSeqLen })
-          // await refSeqDoc?.updateOne({ length: refSeqLen }, { session })
-          refSeqLen = 0
-          chunkIndex = 0
-
-          const name = refSeqInfoLine[1].trim()
-          const description = refSeqInfoLine[2] ? refSeqInfoLine[2].trim() : ''
-
-          // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
-          const [newRefSeqDoc] = await refSeqModel.create([
-            {
-              name,
-              description,
-              assembly,
-              length: 0,
-              ...(customChunkSize ? { chunkSize: customChunkSize } : null),
-              user,
-              status: -1,
-            },
-          ])
-          logger.debug?.(
-            `Added new refSeq "${name}", desc "${description}", docId "${newRefSeqDoc._id}"`,
-          )
-          refSeqDoc = newRefSeqDoc
-        } else if (/\S/.test(line)) {
-          if (!refSeqDoc) {
-            throw new Error('No refSeq document found')
-          }
-          const { _id, chunkSize } = refSeqDoc
-          sequenceBuffer += line.replaceAll(/\s/g, '')
-          // If sequence block > chunk size then save chunk into Mongo
-          while (sequenceBuffer.length >= chunkSize) {
-            const sequence = sequenceBuffer.slice(0, chunkSize)
-            refSeqLen += sequence.length
-            // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
-            await refSeqChunkModel.create([
-              { refSeq: _id, n: chunkIndex, sequence, user, status: -1 },
-            ])
-            chunkIndex++
-            // Set remaining sequence
-            sequenceBuffer = sequenceBuffer.slice(chunkSize)
-          }
-        }
-      }
-    }
-    if (!parsingStarted) {
-      throw new Error('No reference sequences found in file')
-    }
-
-    if (sequenceBuffer || lastLineIsIncomplete) {
-      if (!refSeqDoc) {
-        throw new Error('No refSeq document found')
-      }
-      // If the file did not end with line break so the last line is incomplete
-      if (lastLineIsIncomplete) {
-        sequenceBuffer += incompleteLine
-      }
-      refSeqLen += sequenceBuffer.length
-      logger.verbose?.(
-        `*** Add the very last chunk to ref seq ("${refSeqDoc._id}", index ${chunkIndex} and total length for ref seq is ${refSeqLen}): "${sequenceBuffer}"`,
-      )
-      logger.debug?.(
-        `Creating refSeq chunk number ${chunkIndex} of "${refSeqDoc._id}"`,
-      )
-      // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
-      await refSeqChunkModel.create([
-        {
-          refSeq: refSeqDoc._id,
-          n: chunkIndex,
-          sequence: sequenceBuffer,
-          user,
-          status: -1,
-        },
-      ])
-      await refSeqDoc.updateOne({ length: refSeqLen })
-    }
-  }
-
-  private refSeqCache = new Map<string, RefSeqDocument>()
-
-  async removeExistingFeatures(backend: ServerDataStore) {
-    const { featureModel, refSeqModel } = backend
-    const { assembly, logger } = this
-    logger.debug?.(`Removing existing features for assembly = ${assembly}`)
-
-    const refSeqs: RefSeqDocument[] = await refSeqModel
-      .find({ assembly })
-      .exec()
-
-    for (const refSeq of refSeqs) {
-      await featureModel.deleteMany({ refSeq: refSeq._id })
-    }
-  }
-
-  async addFeatureIntoDb(gff3Feature: GFF3Feature, backend: ServerDataStore) {
-    const { INDEXED_IDS } = process.env
-    let idsToIndex: string[] | undefined
-    if (INDEXED_IDS) {
-      idsToIndex = INDEXED_IDS.split(',')
-    }
-    const { assembly, refSeqCache } = this
-    const { featureModel, refSeqModel, user } = backend
-
-    const [{ seq_id: refName }] = gff3Feature
-    if (!refName) {
-      throw new Error(
-        `Valid seq_id not found in feature ${JSON.stringify(gff3Feature)}`,
-      )
-    }
-    let refSeqDoc = refSeqCache.get(refName)
-    if (!refSeqDoc) {
-      refSeqDoc =
-        (await refSeqModel.findOne({ assembly, name: refName }).exec()) ??
-        undefined
-      if (refSeqDoc) {
-        refSeqCache.set(refName, refSeqDoc)
-      }
-    }
-    if (!refSeqDoc) {
-      throw new Error(
-        `RefSeq was not found by assembly "${assembly}" and seq_id "${refName}" not found`,
-      )
-    }
-    const newFeature = gff3ToAnnotationFeature(gff3Feature, refSeqDoc._id)
-    const allIds = this.getAllIds(newFeature)
-    const indexedIds = this.getIndexedIds(newFeature, idsToIndex)
-
-    // Add into Mongo
-    // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
-    await featureModel.create([
-      { allIds, indexedIds, ...newFeature, user, status: -1 },
-    ])
-  }
-
-  getAllIds(feature: AnnotationFeatureSnapshot): string[] {
-    const allIds = [feature._id]
-    if (feature.children) {
-      for (const child of Object.values(feature.children)) {
-        const childIds = this.getAllIds(child)
-        allIds.push(...childIds)
-      }
-    }
-    return allIds
-  }
-}

package/src/Changes/UndoMergeExonsChange.ts

@@ -1,149 +0,0 @@
-/* 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.js'
-
-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

@@ -1,153 +0,0 @@
-/* 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.js'
-
-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

@@ -1,174 +0,0 @@
-/* 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.js'
-import { SplitExonChange } from './SplitExonChange.js'
-
-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 },
-    )
-  }
-}