Skip to content

Edge-Drop is a clipboard shelf on the edge of your screen. Hover to open it. Drag files and images into any app, click to copy text and links. Free and open-source for Windows.

feat(store): enable cross-type stacking of web & captured images with files

Deepender25a86d99a37ff2
diff --git a/electron/store/ItemStore.ts b/electron/store/ItemStore.ts
index 847f0a6..0b4c3a5 100644
--- a/electron/store/ItemStore.ts
+++ b/electron/store/ItemStore.ts
@@ -336,65 +336,59 @@ export class ItemStore {
const src = this.items[srcIdx]
const tgt = this.items[tgtIdx]
- // Determine how to merge based on kinds
- // 1. Image(s) + Image(s) -> Image Collection / Image File Stack (any screenshot or image file)
- // 2. Files + Files -> Files (any non-image files stack together)
+ // Text and links cannot be merged into stacks
+ if (src.data.kind === 'text' || tgt.data.kind === 'text') {
+ return { ok: false, reason: 'incompatible', message: 'Text and links cannot be grouped together' }
+ }
let newData: ItemData | null = null
- const isImageItem = (item: ClipboardItem): boolean => {
- if (item.data.kind === 'image' || item.data.kind === 'image-collection') return true
- if (item.data.kind === 'files' && item.data.paths.length > 0) {
- return item.data.paths.every((p) => isImageExt(p))
- }
- return false
- }
-
- const getImagePaths = (item: ClipboardItem): string[] => {
+ const getItemPaths = (item: ClipboardItem): string[] => {
if (item.data.kind === 'files') return item.data.paths
if (item.data.kind === 'image') return [this.imagePath(item.data.imageId, item.data.ext)]
if (item.data.kind === 'image-collection') return item.data.images.map((img) => this.imagePath(img.imageId, img.ext))
return []
}
- const srcIsImage = isImageItem(src)
- const tgtIsImage = isImageItem(tgt)
-
- if (srcIsImage && tgtIsImage) {
- if (src.data.kind !== 'files' && tgt.data.kind !== 'files') {
- const srcData = src.data
- const tgtData = tgt.data
- const srcImages = srcData.kind === 'image-collection' ? srcData.images : srcData.kind === 'image' ? [{ imageId: srcData.imageId, width: srcData.width, height: srcData.height, bytes: srcData.bytes, ext: srcData.ext, source: srcData.source, fileName: srcData.fileName }] : []
- const tgtImages = tgtData.kind === 'image-collection' ? tgtData.images : tgtData.kind === 'image' ? [{ imageId: tgtData.imageId, width: tgtData.width, height: tgtData.height, bytes: tgtData.bytes, ext: tgtData.ext, source: tgtData.source, fileName: tgtData.fileName }] : []
- const seen = new Set(tgtImages.map((i) => i.imageId))
- const combined = [...tgtImages, ...srcImages.filter((i) => !seen.has(i.imageId))]
-
- if (combined.length > MAX_STACK) return { ok: false, reason: 'full', message: 'An image collection can hold a maximum of 10 items' }
- newData = { kind: 'image-collection', images: combined }
- } else {
- const srcPaths = getImagePaths(src)
- const tgtPaths = getImagePaths(tgt)
- const seen = new Set(tgtPaths)
- const combined = [...tgtPaths, ...srcPaths.filter((p) => !seen.has(p))]
-
- if (combined.length > MAX_STACK) return { ok: false, reason: 'full', message: 'An image collection can hold a maximum of 10 items' }
- newData = { kind: 'files', paths: combined }
- }
- } else if (src.data.kind === 'files' && tgt.data.kind === 'files') {
- const seen = new Set(tgt.data.paths)
- const combined = [...tgt.data.paths, ...src.data.paths.filter((p) => !seen.has(p))]
+ const isPureImage = (item: ClipboardItem): boolean => {
+ return item.data.kind === 'image' || item.data.kind === 'image-collection'
+ }
+
+ if (isPureImage(src) && isPureImage(tgt)) {
+ // Pure Image(s) + Pure Image(s) -> Image Collection
+ const srcData = src.data
+ const tgtData = tgt.data
+ const srcImages = srcData.kind === 'image-collection'
+ ? srcData.images
+ : srcData.kind === 'image'
+ ? [{ imageId: srcData.imageId, width: srcData.width, height: srcData.height, bytes: srcData.bytes, ext: srcData.ext, source: srcData.source, fileName: srcData.fileName }]
+ : []
+ const tgtImages = tgtData.kind === 'image-collection'
+ ? tgtData.images
+ : tgtData.kind === 'image'
+ ? [{ imageId: tgtData.imageId, width: tgtData.width, height: tgtData.height, bytes: tgtData.bytes, ext: tgtData.ext, source: tgtData.source, fileName: tgtData.fileName }]
+ : []
+ const seen = new Set(tgtImages.map((i) => i.imageId))
+ const combined = [...tgtImages, ...srcImages.filter((i) => !seen.has(i.imageId))]
+
+ if (combined.length > MAX_STACK) return { ok: false, reason: 'full', message: 'An image collection can hold a maximum of 10 items' }
+ newData = { kind: 'image-collection', images: combined }
+ } else if (
+ (src.data.kind === 'files' || src.data.kind === 'image' || src.data.kind === 'image-collection') &&
+ (tgt.data.kind === 'files' || tgt.data.kind === 'image' || tgt.data.kind === 'image-collection')
+ ) {
+ // Mixed combinations: Files + Files, Image(s) + Files, Files + Image(s)
+ const srcPaths = getItemPaths(src)
+ const tgtPaths = getItemPaths(tgt)
+ const seen = new Set(tgtPaths)
+ const combined = [...tgtPaths, ...srcPaths.filter((p) => !seen.has(p))]
if (combined.length > MAX_STACK) return { ok: false, reason: 'full', message: 'A folder bundle can hold a maximum of 10 files' }
newData = { kind: 'files', paths: combined }
}
if (!newData) {
- if (srcIsImage || tgtIsImage) {
- return { ok: false, reason: 'incompatible', message: 'Images can only be grouped with other images' }
- } else if (src.data.kind === 'files' || tgt.data.kind === 'files') {
- return { ok: false, reason: 'incompatible', message: 'Files can only be grouped with other files' }
- }
- return { ok: false, reason: 'incompatible', message: 'Text and links cannot be grouped together' }
+ return { ok: false, reason: 'incompatible', message: 'Cannot combine these items' }
}
// Update target item
@@ -512,8 +506,18 @@ export class ItemStore {
} catch {}
}
let bytes = 0
- try { bytes = statSync(p).size } catch {}
- newData = { kind: 'image', imageId, width: 0, height: 0, bytes, ext }
+ let width = 0
+ let height = 0
+ try {
+ bytes = statSync(p).size
+ const img = nativeImage.createFromPath(p)
+ if (!img.isEmpty()) {
+ const sz = img.getSize()
+ width = sz.width
+ height = sz.height
+ }
+ } catch {}
+ newData = { kind: 'image', imageId, width, height, bytes, ext }
}
}
diff --git a/src/hooks/useFilteredItems.ts b/src/hooks/useFilteredItems.ts
index c93385a..ad1d084 100644
--- a/src/hooks/useFilteredItems.ts
+++ b/src/hooks/useFilteredItems.ts
@@ -44,9 +44,11 @@ function matchesType(it: ClipboardItemDto, filter: TypeFilter): boolean {
case 'links':
return it.data.kind === 'text' && !!it.data.isUrl
case 'images':
- return isImageItem(it)
+ if (it.data.kind === 'image' || it.data.kind === 'image-collection') return true
+ if (it.data.kind === 'files') return it.data.paths.some((p) => isImagePath(p))
+ return false
case 'files':
- return it.data.kind === 'files' && !isImageItem(it)
+ return it.data.kind === 'files'
}
}
diff --git a/tests/imageFileStacking.test.ts b/tests/imageFileStacking.test.ts
new file mode 100644
index 0000000..b24ea41
--- /dev/null
+++ b/tests/imageFileStacking.test.ts
@@ -0,0 +1,214 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+const fsRoots = vi.hoisted(() => ({
+ home: '',
+ userData: ''
+}))
+
+vi.mock('electron', () => ({
+ app: {
+ isPackaged: false,
+ getAppPath: () => join(fsRoots.userData, 'app'),
+ getPath: (name: string) => (name === 'userData' ? fsRoots.userData : join(fsRoots.userData, name))
+ },
+ nativeImage: {
+ createFromPath: () => ({
+ isEmpty: () => false,
+ getSize: () => ({ width: 800, height: 600 }),
+ resize: () => ({ toDataURL: () => 'data:image/png;base64,mock' }),
+ toDataURL: () => 'data:image/png;base64,mock'
+ })
+ },
+ safeStorage: {
+ isEncryptionAvailable: () => false
+ }
+}))
+
+vi.mock('node:os', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('node:os')>()
+ return {
+ ...actual,
+ homedir: () => fsRoots.home
+ }
+})
+
+import { ItemStore } from '../electron/store/ItemStore'
+import type { ItemData } from '../shared/types'
+
+describe('Image and File Stacking & Merging', () => {
+ beforeEach(() => {
+ fsRoots.userData = join(tmpdir(), `ed-imgfile-ud-${Date.now()}-${Math.random().toString(16).slice(2)}`)
+ fsRoots.home = join(tmpdir(), `ed-imgfile-home-${Date.now()}-${Math.random().toString(16).slice(2)}`)
+ mkdirSync(join(fsRoots.userData, 'images'), { recursive: true })
+ mkdirSync(fsRoots.home, { recursive: true })
+ })
+
+ afterEach(() => {
+ try { rmSync(fsRoots.userData, { recursive: true, force: true }) } catch { /* ignore */ }
+ try { rmSync(fsRoots.home, { recursive: true, force: true }) } catch { /* ignore */ }
+ })
+
+ it('merges a web/screenshot image card into a non-image file card', () => {
+ const store = new ItemStore()
+ const imgPath = join(fsRoots.userData, 'images', 'img-web-1.png')
+ writeFileSync(imgPath, 'fake-png')
+
+ const fileDocPath = join(fsRoots.home, 'document.pdf')
+ writeFileSync(fileDocPath, 'fake-pdf')
+
+ // 1. Add image item (e.g. from web / screenshot)
+ const imgData: ItemData = {
+ kind: 'image',
+ imageId: 'img-web-1',
+ width: 800,
+ height: 600,
+ bytes: 1024,
+ ext: 'png',
+ source: 'image',
+ fileName: 'web-photo.png'
+ }
+ store.add(imgData, 10)
+
+ // 2. Add files item (e.g. from Explorer)
+ const fileData: ItemData = {
+ kind: 'files',
+ paths: [fileDocPath]
+ }
+ store.add(fileData, 10)
+
+ const items = store.list()
+ expect(items).toHaveLength(2)
+ const fileItemId = items.find((i) => i.data.kind === 'files')!.id
+ const imageItemId = items.find((i) => i.data.kind === 'image')!.id
+
+ // 3. Merge image into file stack
+ const res = store.merge(imageItemId, fileItemId)
+ expect(res.ok).toBe(true)
+
+ const updated = store.list()
+ expect(updated).toHaveLength(1)
+ expect(updated[0].id).toBe(fileItemId)
+ expect(updated[0].data.kind).toBe('files')
+ if (updated[0].data.kind === 'files') {
+ expect(updated[0].data.paths).toHaveLength(2)
+ expect(updated[0].data.paths).toContain(fileDocPath)
+ expect(updated[0].data.paths).toContain(imgPath)
+ }
+ })
+
+ it('merges a file card into an image card, transforming into a files bundle', () => {
+ const store = new ItemStore()
+ const imgPath = join(fsRoots.userData, 'images', 'img-web-2.png')
+ writeFileSync(imgPath, 'fake-png')
+
+ const fileZipPath = join(fsRoots.home, 'archive.zip')
+ writeFileSync(fileZipPath, 'fake-zip')
+
+ const imgData: ItemData = {
+ kind: 'image',
+ imageId: 'img-web-2',
+ width: 400,
+ height: 300,
+ bytes: 512,
+ ext: 'png',
+ source: 'screenshot'
+ }
+ store.add(imgData, 10)
+
+ const fileData: ItemData = {
+ kind: 'files',
+ paths: [fileZipPath]
+ }
+ store.add(fileData, 10)
+
+ const items = store.list()
+ const fileItemId = items.find((i) => i.data.kind === 'files')!.id
+ const imageItemId = items.find((i) => i.data.kind === 'image')!.id
+
+ // Drop file item onto image item
+ const res = store.merge(fileItemId, imageItemId)
+ expect(res.ok).toBe(true)
+
+ const updated = store.list()
+ expect(updated).toHaveLength(1)
+ expect(updated[0].id).toBe(imageItemId)
+ expect(updated[0].data.kind).toBe('files')
+ if (updated[0].data.kind === 'files') {
+ expect(updated[0].data.paths).toHaveLength(2)
+ expect(updated[0].data.paths).toContain(fileZipPath)
+ expect(updated[0].data.paths).toContain(imgPath)
+ }
+ })
+
+ it('merges two pure image cards into an image-collection', () => {
+ const store = new ItemStore()
+ const img1: ItemData = {
+ kind: 'image',
+ imageId: 'img-1',
+ width: 100,
+ height: 100,
+ bytes: 200,
+ ext: 'png'
+ }
+ const img2: ItemData = {
+ kind: 'image',
+ imageId: 'img-2',
+ width: 200,
+ height: 200,
+ bytes: 400,
+ ext: 'png'
+ }
+ store.add(img1, 10)
+ store.add(img2, 10)
+
+ const items = store.list()
+ const res = store.merge(items[1].id, items[0].id)
+ expect(res.ok).toBe(true)
+
+ const updated = store.list()
+ expect(updated).toHaveLength(1)
+ expect(updated[0].data.kind).toBe('image-collection')
+ if (updated[0].data.kind === 'image-collection') {
+ expect(updated[0].data.images).toHaveLength(2)
+ }
+ })
+
+ it('splits an image out of a mixed files bundle back into an image card', () => {
+ const store = new ItemStore()
+ const imgPath = join(fsRoots.userData, 'images', 'img-web-3.png')
+ writeFileSync(imgPath, 'fake-png')
+ const docPath = join(fsRoots.home, 'notes.txt')
+ writeFileSync(docPath, 'hello world')
+
+ const fileData: ItemData = {
+ kind: 'files',
+ paths: [docPath, imgPath]
+ }
+ store.add(fileData, 10)
+
+ const items = store.list()
+ expect(items).toHaveLength(1)
+ const bundleId = items[0].id
+
+ // Split the image out
+ const splitOk = store.split({ id: bundleId, paths: [imgPath], splitPlacement: 'after' })
+ expect(splitOk).toBe(true)
+
+ const updated = store.list()
+ expect(updated).toHaveLength(2)
+
+ // Original bundle now only has the text file
+ const remainingBundle = updated.find((i) => i.id === bundleId)!
+ expect(remainingBundle.data.kind).toBe('files')
+ if (remainingBundle.data.kind === 'files') {
+ expect(remainingBundle.data.paths).toEqual([docPath])
+ }
+
+ // New item is extracted as a standalone image card
+ const extracted = updated.find((i) => i.id !== bundleId)!
+ expect(extracted.data.kind).toBe('image')
+ })
+})