git-chopstick-core 0.1.1 → 0.1.3

package/src/lib/status-parser.ts

@@ -1,188 +0,0 @@
-import {
-  FileEntry,
-  GitStatusEntry,
-  SubmoduleStatus,
-  UnmergedEntrySummary,
-} from '../models/status'
-import { splitBuffer } from './split-buffer'
-
-type StatusItem = IStatusHeader | IStatusEntry
-
-export interface IStatusHeader {
-  readonly kind: 'header'
-  readonly value: string
-}
-
-export interface IStatusEntry {
-  readonly kind: 'entry'
-  readonly path: string
-  readonly statusCode: string
-  readonly submoduleStatusCode: string
-  readonly oldPath?: string
-  readonly renameOrCopyScore?: number
-}
-
-export function isStatusHeader(
-  statusItem: StatusItem
-): statusItem is IStatusHeader {
-  return statusItem.kind === 'header'
-}
-
-export function isStatusEntry(
-  statusItem: StatusItem
-): statusItem is IStatusEntry {
-  return statusItem.kind === 'entry'
-}
-
-const ChangedEntryType = '1'
-const RenamedOrCopiedEntryType = '2'
-const UnmergedEntryType = 'u'
-const UntrackedEntryType = '?'
-
-const changedEntryRe =
-  /^1 ([MADRCUTX?!.]{2}) (N\.\.\.|S[C.][M.][U.]) (\d+) (\d+) (\d+) ([a-f0-9]+) ([a-f0-9]+) ([\s\S]*?)$/
-
-const renamedOrCopiedEntryRe =
-  /^2 ([MADRCUTX?!.]{2}) (N\.\.\.|S[C.][M.][U.]) (\d+) (\d+) (\d+) ([a-f0-9]+) ([a-f0-9]+) ([RC]\d+) ([\s\S]*?)$/
-
-const unmergedEntryRe =
-  /^u ([DAU]{2}) (N\.\.\.|S[C.][M.][U.]) (\d+) (\d+) (\d+) (\d+) ([a-f0-9]+) ([a-f0-9]+) ([a-f0-9]+) ([\s\S]*?)$/
-
-export function parsePorcelainStatus(
-  output: Buffer
-): ReadonlyArray<StatusItem> {
-  const entries = new Array<StatusItem>()
-  const tokens = splitBuffer(output, '\0')
-
-  for (let i = 0; i < tokens.length; i++) {
-    const field = tokens[i].toString()
-    if (field.startsWith('# ') && field.length > 2) {
-      entries.push({ kind: 'header', value: field.substring(2) })
-      continue
-    }
-
-    const entryKind = field.substring(0, 1)
-
-    if (entryKind === ChangedEntryType) {
-      entries.push(parseChangedEntry(field))
-    } else if (entryKind === RenamedOrCopiedEntryType) {
-      entries.push(parsedRenamedOrCopiedEntry(field, tokens[++i].toString()))
-    } else if (entryKind === UnmergedEntryType) {
-      entries.push(parseUnmergedEntry(field))
-    } else if (entryKind === UntrackedEntryType) {
-      entries.push(parseUntrackedEntry(field))
-    }
-  }
-
-  return entries
-}
-
-function parseChangedEntry(field: string): IStatusEntry {
-  const match = changedEntryRe.exec(field)
-  if (!match) throw new Error(`Failed to parse status line for changed entry`)
-  return {
-    kind: 'entry',
-    statusCode: match[1],
-    submoduleStatusCode: match[2],
-    path: match[8],
-  }
-}
-
-function parsedRenamedOrCopiedEntry(
-  field: string,
-  oldPath: string | undefined
-): IStatusEntry {
-  const match = renamedOrCopiedEntryRe.exec(field)
-  if (!match) throw new Error(`Failed to parse status line for renamed or copied entry`)
-  if (!oldPath) throw new Error('Failed to parse renamed or copied entry, could not parse old path')
-
-  return {
-    kind: 'entry',
-    statusCode: match[1],
-    submoduleStatusCode: match[2],
-    oldPath,
-    renameOrCopyScore: parseInt(match[8].substring(1), 10),
-    path: match[9],
-  }
-}
-
-function parseUnmergedEntry(field: string): IStatusEntry {
-  const match = unmergedEntryRe.exec(field)
-  if (!match) throw new Error(`Failed to parse status line for unmerged entry`)
-  return {
-    kind: 'entry',
-    statusCode: match[1],
-    submoduleStatusCode: match[2],
-    path: match[10],
-  }
-}
-
-function parseUntrackedEntry(field: string): IStatusEntry {
-  const path = field.substring(2)
-  return {
-    kind: 'entry',
-    statusCode: '??',
-    submoduleStatusCode: '????',
-    path,
-  }
-}
-
-function mapSubmoduleStatus(
-  submoduleStatusCode: string
-): SubmoduleStatus | undefined {
-  if (!submoduleStatusCode.startsWith('S')) return undefined
-  return {
-    commitChanged: submoduleStatusCode[1] === 'C',
-    modifiedChanges: submoduleStatusCode[2] === 'M',
-    untrackedChanges: submoduleStatusCode[3] === 'U',
-  }
-}
-
-export function mapStatus(
-  statusCode: string,
-  submoduleStatusCode: string,
-  renameOrCopyScore: number | undefined
-): FileEntry {
-  const submoduleStatus = mapSubmoduleStatus(submoduleStatusCode)
-
-  if (statusCode === '??') return { kind: 'untracked', submoduleStatus }
-
-  const sc = (code: string, idx: 'index' | 'workingTree') => {
-    const map: Record<string, GitStatusEntry> = {
-      'M': GitStatusEntry.Modified,
-      'A': GitStatusEntry.Added,
-      'D': GitStatusEntry.Deleted,
-      'R': GitStatusEntry.Renamed,
-      'C': GitStatusEntry.Copied,
-      '.': GitStatusEntry.Unchanged,
-      'U': GitStatusEntry.UpdatedButUnmerged,
-    }
-    return map[code] ?? GitStatusEntry.Modified
-  }
-
-  const pairs: Record<string, () => FileEntry> = {
-    '.M': () => ({ kind: 'ordinary', type: 'modified', index: GitStatusEntry.Unchanged, workingTree: GitStatusEntry.Modified, submoduleStatus }),
-    'M.': () => ({ kind: 'ordinary', type: 'modified', index: GitStatusEntry.Modified, workingTree: GitStatusEntry.Unchanged, submoduleStatus }),
-    '.A': () => ({ kind: 'ordinary', type: 'added', index: GitStatusEntry.Unchanged, workingTree: GitStatusEntry.Added, submoduleStatus }),
-    'A.': () => ({ kind: 'ordinary', type: 'added', index: GitStatusEntry.Added, workingTree: GitStatusEntry.Unchanged, submoduleStatus }),
-    '.D': () => ({ kind: 'ordinary', type: 'deleted', index: GitStatusEntry.Unchanged, workingTree: GitStatusEntry.Deleted, submoduleStatus }),
-    'D.': () => ({ kind: 'ordinary', type: 'deleted', index: GitStatusEntry.Deleted, workingTree: GitStatusEntry.Unchanged, submoduleStatus }),
-    'R.': () => ({ kind: 'renamed' as const, index: GitStatusEntry.Renamed, workingTree: GitStatusEntry.Unchanged, renameOrCopyScore, submoduleStatus }),
-    '.R': () => ({ kind: 'renamed' as const, index: GitStatusEntry.Unchanged, workingTree: GitStatusEntry.Renamed, renameOrCopyScore, submoduleStatus }),
-    'C.': () => ({ kind: 'copied' as const, index: GitStatusEntry.Copied, workingTree: GitStatusEntry.Unchanged, submoduleStatus }),
-    '.C': () => ({ kind: 'copied' as const, index: GitStatusEntry.Unchanged, workingTree: GitStatusEntry.Copied, submoduleStatus }),
-    'AD': () => ({ kind: 'ordinary', type: 'added', index: GitStatusEntry.Added, workingTree: GitStatusEntry.Deleted, submoduleStatus }),
-    'AM': () => ({ kind: 'ordinary', type: 'added', index: GitStatusEntry.Added, workingTree: GitStatusEntry.Modified, submoduleStatus }),
-    'RM': () => ({ kind: 'renamed' as const, index: GitStatusEntry.Renamed, workingTree: GitStatusEntry.Modified, renameOrCopyScore, submoduleStatus }),
-    'RD': () => ({ kind: 'renamed' as const, index: GitStatusEntry.Renamed, workingTree: GitStatusEntry.Deleted, renameOrCopyScore, submoduleStatus }),
-    'DD': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.BothDeleted, us: GitStatusEntry.Deleted, them: GitStatusEntry.Deleted, submoduleStatus }),
-    'AU': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.AddedByUs, us: GitStatusEntry.Added, them: GitStatusEntry.UpdatedButUnmerged, submoduleStatus }),
-    'UD': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.DeletedByThem, us: GitStatusEntry.UpdatedButUnmerged, them: GitStatusEntry.Deleted, submoduleStatus }),
-    'UA': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.AddedByThem, us: GitStatusEntry.UpdatedButUnmerged, them: GitStatusEntry.Added, submoduleStatus }),
-    'DU': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.DeletedByUs, us: GitStatusEntry.Deleted, them: GitStatusEntry.UpdatedButUnmerged, submoduleStatus }),
-    'AA': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.BothAdded, us: GitStatusEntry.Added, them: GitStatusEntry.Added, submoduleStatus }),
-    'UU': () => ({ kind: 'conflicted' as const, action: UnmergedEntrySummary.BothModified, us: GitStatusEntry.UpdatedButUnmerged, them: GitStatusEntry.UpdatedButUnmerged, submoduleStatus }),
-  }
-
-  return pairs[statusCode]?.() ?? { kind: 'ordinary', type: 'modified', submoduleStatus }
-}

package/src/lib/stores/helpers/find-default-remote.ts

@@ -1,3 +0,0 @@
-export function findDefaultRemote(remotes: any[]): any | null {
-  return remotes.length > 0 ? remotes[0] : null
-}

package/src/lib/trampoline/trampoline-environment.ts

@@ -1,8 +0,0 @@
-export async function withTrampolineEnv<T>(
-  fn: (env: Record<string, string | undefined>) => Promise<T>,
-  _path: string,
-  _isBackgroundTask: boolean,
-  _existingEnv?: Record<string, string | undefined>
-): Promise<T> {
-  return fn({})
-}

package/src/models/branch.ts

@@ -1,78 +0,0 @@
-export enum BranchType {
-  Local = 0,
-  Remote = 1,
-}
-
-export interface IAheadBehind {
-  readonly ahead: number
-  readonly behind: number
-}
-
-export interface ICompareResult extends IAheadBehind {
-  readonly commits: ReadonlyArray<Commit>
-}
-
-export interface ITrackingBranch {
-  readonly ref: string
-  readonly sha: string
-  readonly upstreamRef: string
-  readonly upstreamSha: string
-}
-
-export interface IAuthor {
-  readonly date: Date
-}
-
-export interface IBranchTip {
-  readonly sha: string
-  readonly author: IAuthor
-}
-
-export enum StartPoint {
-  CurrentBranch = 'CurrentBranch',
-  DefaultBranch = 'DefaultBranch',
-  Head = 'Head',
-  UpstreamDefaultBranch = 'UpstreamDefaultBranch',
-}
-
-export class Branch {
-  public constructor(
-    public readonly name: string,
-    public readonly upstream: string | null,
-    public readonly tip: IBranchTip,
-    public readonly type: BranchType,
-    public readonly ref: string,
-    public readonly isGone: boolean
-  ) {}
-
-  public get upstreamRemoteName(): string | null {
-    const upstream = this.upstream
-    if (!upstream) return null
-    const pieces = upstream.match(/(.*?)\/.*/)
-    if (!pieces || pieces.length < 2) return null
-    return pieces[1]
-  }
-
-  public get remoteName(): string | null {
-    if (this.type === BranchType.Local) return null
-    const pieces = this.ref.match(/^refs\/remotes\/(.*?)\/.*/)
-    if (!pieces || pieces.length !== 2) {
-      throw new Error(`Remote branch ref has unexpected format: ${this.ref}`)
-    }
-    return pieces[1]
-  }
-
-  public get upstreamWithoutRemote(): string | null {
-    if (!this.upstream) return null
-    const pieces = this.upstream.match(/^[^/]+\/(.*)/)
-    return pieces ? pieces[1] : null
-  }
-
-  public get nameWithoutRemote(): string {
-    if (this.type === BranchType.Local) return this.name
-    const pieces = this.name.match(/^[^/]+\/(.*)/)
-    return pieces ? pieces[1] : this.name
-  }
-}
-
-import { Commit } from './commit'

package/src/models/cherry-pick.ts

@@ -1,12 +0,0 @@
-import { IMultiCommitOperationProgress } from './progress'
-import { CommitOneLine } from './commit'
-
-export interface ICherryPickSnapshot {
-  readonly sha: string
-  readonly parentCount: number
-  readonly progress: IMultiCommitOperationProgress | null
-  readonly commits: ReadonlyArray<CommitOneLine>
-  readonly remainingCommits: ReadonlyArray<CommitOneLine>
-  readonly targetBranchUndoSha: string
-  readonly cherryPickedCount: number
-}

package/src/models/clone-options.ts

@@ -1,6 +0,0 @@
-export interface CloneOptions {
-  readonly url: string
-  readonly path: string
-  readonly branch?: string
-  readonly defaultBranch?: string
-}

package/src/models/commit-identity.ts

@@ -1,35 +0,0 @@
-export class CommitIdentity {
-  public static parseIdentity(identity: string): CommitIdentity {
-    const m = identity.match(/^(.*?) <(.*?)> (\d+) (\+|-)?(\d{2})(\d{2})/)
-    if (!m) {
-      throw new Error(`Couldn't parse identity ${identity}`)
-    }
-
-    const name = m[1]
-    const email = m[2]
-    const date = new Date(parseInt(m[3], 10) * 1000)
-
-    if (isNaN(date.valueOf())) {
-      throw new Error(`Couldn't parse identity ${identity}, invalid date`)
-    }
-
-    const tzSign = m[4] === '-' ? '-' : '+'
-    const tzHH = m[5]
-    const tzmm = m[6]
-    const tzMinutes = parseInt(tzHH, 10) * 60 + parseInt(tzmm, 10)
-    const tzOffset = tzMinutes * (tzSign === '-' ? -1 : 1)
-
-    return new CommitIdentity(name, email, date, tzOffset)
-  }
-
-  public constructor(
-    public readonly name: string,
-    public readonly email: string,
-    public readonly date: Date,
-    public readonly tzOffset: number = new Date().getTimezoneOffset()
-  ) {}
-
-  public toString() {
-    return `${this.name} <${this.email}>`
-  }
-}

package/src/models/commit.ts

@@ -1,44 +0,0 @@
-export function shortenSHA(sha: string) {
-  return sha.slice(0, 7)
-}
-
-export interface ICommitContext {
-  readonly summary: string
-  readonly description: string | null
-  readonly amend?: boolean
-  readonly trailers?: ReadonlyArray<ITrailer>
-}
-
-export type CommitOneLine = {
-  readonly sha: string
-  readonly summary: string
-}
-
-export interface ITrailer {
-  readonly token: string
-  readonly value: string
-}
-
-export class Commit {
-  public readonly authoredByCommitter: boolean
-  public readonly isMergeCommit: boolean
-
-  public constructor(
-    public readonly sha: string,
-    public readonly shortSha: string,
-    public readonly summary: string,
-    public readonly body: string,
-    public readonly author: CommitIdentity,
-    public readonly committer: CommitIdentity,
-    public readonly parentSHAs: ReadonlyArray<string>,
-    public readonly trailers: ReadonlyArray<ITrailer>,
-    public readonly tags: ReadonlyArray<string>
-  ) {
-    this.authoredByCommitter =
-      this.author.name === this.committer.name &&
-      this.author.email === this.committer.email
-    this.isMergeCommit = parentSHAs.length > 1
-  }
-}
-
-import { CommitIdentity } from './commit-identity'

package/src/models/computed-action.ts

@@ -1,6 +0,0 @@
-export enum ComputedAction {
-  Clean = 'Clean',
-  Conflicts = 'Conflicts',
-  Invalid = 'Invalid',
-  Loading = 'Loading',
-}

package/src/models/diff/diff-data.ts

@@ -1,78 +0,0 @@
-import { DiffHunk } from './raw-diff'
-import { Image } from './image'
-import { SubmoduleStatus } from '../status'
-
-export enum DiffType {
-  Text,
-  Image,
-  Binary,
-  Submodule,
-  LargeText,
-  Unrenderable,
-}
-
-type LineEnding = 'CR' | 'LF' | 'CRLF'
-
-export type LineEndingsChange = {
-  from: LineEnding
-  to: LineEnding
-}
-
-export function parseLineEndingText(text: string): LineEnding | null {
-  const input = text.trim()
-  switch (input) {
-    case 'CR': return 'CR'
-    case 'LF': return 'LF'
-    case 'CRLF': return 'CRLF'
-    default: return null
-  }
-}
-
-interface ITextDiffData {
-  readonly text: string
-  readonly hunks: ReadonlyArray<DiffHunk>
-  readonly lineEndingsChange?: LineEndingsChange
-  readonly maxLineNumber: number
-  readonly hasHiddenBidiChars: boolean
-}
-
-export interface ITextDiff extends ITextDiffData {
-  readonly kind: DiffType.Text
-}
-
-export interface IImageDiff {
-  readonly kind: DiffType.Image
-  readonly previous?: Image
-  readonly current?: Image
-  readonly textDiff?: ITextDiffData
-}
-
-export interface IBinaryDiff {
-  readonly kind: DiffType.Binary
-}
-
-export interface ISubmoduleDiff {
-  readonly kind: DiffType.Submodule
-  readonly fullPath: string
-  readonly path: string
-  readonly url: string | null
-  readonly status: SubmoduleStatus
-  readonly oldSHA: string | null
-  readonly newSHA: string | null
-}
-
-export interface ILargeTextDiff extends ITextDiffData {
-  readonly kind: DiffType.LargeText
-}
-
-export interface IUnrenderableDiff {
-  readonly kind: DiffType.Unrenderable
-}
-
-export type IDiff =
-  | ITextDiff
-  | IImageDiff
-  | IBinaryDiff
-  | ISubmoduleDiff
-  | ILargeTextDiff
-  | IUnrenderableDiff

package/src/models/diff/diff-line.ts

@@ -1,36 +0,0 @@
-export enum DiffLineType {
-  Context,
-  Add,
-  Delete,
-  Hunk,
-}
-
-export class DiffLine {
-  public constructor(
-    public readonly text: string,
-    public readonly type: DiffLineType,
-    public readonly originalLineNumber: number | null,
-    public readonly oldLineNumber: number | null,
-    public readonly newLineNumber: number | null,
-    public readonly noTrailingNewLine: boolean = false
-  ) {}
-
-  public withNoTrailingNewLine(noTrailingNewLine: boolean): DiffLine {
-    return new DiffLine(
-      this.text,
-      this.type,
-      this.originalLineNumber,
-      this.oldLineNumber,
-      this.newLineNumber,
-      noTrailingNewLine
-    )
-  }
-
-  public isIncludeableLine() {
-    return this.type === DiffLineType.Add || this.type === DiffLineType.Delete
-  }
-
-  public get content(): string {
-    return this.text.substring(1)
-  }
-}

package/src/models/diff/diff-selection.ts

@@ -1,165 +0,0 @@
-export enum DiffSelectionType {
-  All = 'All',
-  Partial = 'Partial',
-  None = 'None',
-}
-
-function typeMatchesSelection(
-  selectionType: DiffSelectionType,
-  selected: boolean
-): boolean {
-  switch (selectionType) {
-    case DiffSelectionType.All:
-      return selected
-    case DiffSelectionType.None:
-      return !selected
-    case DiffSelectionType.Partial:
-      return false
-  }
-}
-
-export class DiffSelection {
-  public static fromInitialSelection(
-    initialSelection: DiffSelectionType.All | DiffSelectionType.None
-  ): DiffSelection {
-    return new DiffSelection(initialSelection, null, null)
-  }
-
-  private constructor(
-    private readonly defaultSelectionType: DiffSelectionType.All | DiffSelectionType.None,
-    private readonly divergingLines: Set<number> | null = null,
-    private readonly selectableLines: Set<number> | null = null
-  ) {}
-
-  public getSelectionType(): DiffSelectionType {
-    const divergingLines = this.divergingLines
-    const selectableLines = this.selectableLines
-
-    if (!divergingLines || divergingLines.size === 0) {
-      return this.defaultSelectionType
-    }
-
-    if (selectableLines && selectableLines.size === divergingLines.size) {
-      const allSelectableLinesAreDivergent = [...selectableLines].every(i =>
-        divergingLines.has(i)
-      )
-      if (allSelectableLinesAreDivergent) {
-        return this.defaultSelectionType === DiffSelectionType.All
-          ? DiffSelectionType.None
-          : DiffSelectionType.All
-      }
-    }
-
-    return DiffSelectionType.Partial
-  }
-
-  public isSelected(lineIndex: number): boolean {
-    const lineIsDivergent =
-      !!this.divergingLines && this.divergingLines.has(lineIndex)
-
-    if (this.defaultSelectionType === DiffSelectionType.All) {
-      return !lineIsDivergent
-    }
-    return lineIsDivergent
-  }
-
-  public isRangeSelected(from: number, length: number): DiffSelectionType {
-    if (length <= 0) return DiffSelectionType.None
-
-    const computedSelectionType = this.getSelectionType()
-    if (computedSelectionType !== DiffSelectionType.Partial) {
-      return computedSelectionType
-    }
-
-    if (length === 1) {
-      return this.isSelected(from) ? DiffSelectionType.All : DiffSelectionType.None
-    }
-
-    const to = from + length
-    let foundSelected = false
-    let foundDeselected = false
-    for (let i = from; i < to; i++) {
-      if (this.isSelected(i)) foundSelected = true
-      if (!this.isSelected(i)) foundDeselected = true
-      if (foundSelected && foundDeselected) return DiffSelectionType.Partial
-    }
-
-    return foundSelected ? DiffSelectionType.All : DiffSelectionType.None
-  }
-
-  public isSelectable(lineIndex: number): boolean {
-    return this.selectableLines ? this.selectableLines.has(lineIndex) : true
-  }
-
-  public withLineSelection(lineIndex: number, selected: boolean): DiffSelection {
-    return this.withRangeSelection(lineIndex, 1, selected)
-  }
-
-  public withRangeSelection(from: number, length: number, selected: boolean): DiffSelection {
-    const computedSelectionType = this.getSelectionType()
-    const to = from + length
-
-    if (typeMatchesSelection(computedSelectionType, selected)) {
-      return this
-    }
-
-    if (computedSelectionType === DiffSelectionType.Partial) {
-      const newDivergingLines = new Set<number>(this.divergingLines!)
-
-      if (typeMatchesSelection(this.defaultSelectionType, selected)) {
-        for (let i = from; i < to; i++) {
-          newDivergingLines.delete(i)
-        }
-      } else {
-        for (let i = from; i < to; i++) {
-          if (this.isSelectable(i)) {
-            newDivergingLines.add(i)
-          }
-        }
-      }
-
-      return new DiffSelection(
-        this.defaultSelectionType,
-        newDivergingLines.size === 0 ? null : newDivergingLines,
-        this.selectableLines
-      )
-    }
-
-    const newDivergingLines = new Set<number>()
-    for (let i = from; i < to; i++) {
-      if (this.isSelectable(i)) {
-        newDivergingLines.add(i)
-      }
-    }
-
-    return new DiffSelection(
-      computedSelectionType,
-      newDivergingLines,
-      this.selectableLines
-    )
-  }
-
-  public withToggleLineSelection(lineIndex: number): DiffSelection {
-    return this.withLineSelection(lineIndex, !this.isSelected(lineIndex))
-  }
-
-  public withSelectAll(): DiffSelection {
-    return new DiffSelection(DiffSelectionType.All, null, this.selectableLines)
-  }
-
-  public withSelectNone(): DiffSelection {
-    return new DiffSelection(DiffSelectionType.None, null, this.selectableLines)
-  }
-
-  public withSelectableLines(selectableLines: Set<number>) {
-    const divergingLines = this.divergingLines
-      ? new Set([...this.divergingLines].filter(x => selectableLines.has(x)))
-      : null
-
-    return new DiffSelection(
-      this.defaultSelectionType,
-      divergingLines,
-      selectableLines
-    )
-  }
-}

package/src/models/diff/image-diff.ts

@@ -1,6 +0,0 @@
-export enum ImageDiffType {
-  TwoUp,
-  Swipe,
-  OnionSkin,
-  Difference,
-}

package/src/models/diff/image.ts

@@ -1,8 +0,0 @@
-export class Image {
-  public constructor(
-    public readonly rawContents: ArrayBufferLike,
-    public readonly contents: string,
-    public readonly mediaType: string,
-    public readonly bytes: number
-  ) {}
-}

package/src/models/diff/index.ts

@@ -1,6 +0,0 @@
-export * from './diff-data'
-export * from './diff-line'
-export * from './diff-selection'
-export * from './image'
-export * from './raw-diff'
-export * from './image-diff'