diff --git a/frontend/package.json b/frontend/package.json index 2b21d2f..45aca19 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -7,7 +7,7 @@ "dev": "vite", "build": "tsc -b && vite build", "lint": "oxlint", - "test": "vitest run", + "test": "node --test src/mini-algo.test.ts && vitest run src/App.test.tsx", "preview": "vite preview" }, "dependencies": { diff --git a/frontend/src/mini-algo.test.ts b/frontend/src/mini-algo.test.ts new file mode 100644 index 0000000..607d1c0 --- /dev/null +++ b/frontend/src/mini-algo.test.ts @@ -0,0 +1,144 @@ +/// + +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { + fitTest, + STAGING_AREA_CAPACITY, + type Sticker, + type StickerSelection, +} from './mini-algo.ts'; + +const baseSticker: Sticker = { + name: '', + height: 1, + width: 1, + description: '', + tags: [], + id: '', + categorySection: '', + hpglFilePath: '', + svgLocation: '', +}; + +function selection(id: string, height: number, width = 1, quantity = 1): StickerSelection { + return { + id, + sticker: { ...baseSticker, id, height, width }, + quantity, + }; +} + + +// tests moved into their own file using github copilot (and turned into actual tests) +test('accepts a sticker that fits without mutating the staging area', () => { + const existing = selection('existing', 6, 7); + const stagingArea = { stickers: [existing] }; + + assert.deepEqual(fitTest(stagingArea, selection('new', 1, 3)), { + fits: true, + stickersToRemove: [], + }); + assert.deepEqual(stagingArea.stickers, [existing]); +}); + +test('suggests removing existing stickers when the area is full', () => { + const existing = selection('existing', 6, 7); + const stagingArea = { stickers: [existing] }; + + assert.deepEqual(fitTest(stagingArea, selection('new', 2, 2)), { + fits: false, + stickersToRemove: [[existing]], + }); + assert.deepEqual(stagingArea.stickers, [existing]); +}); + +test('rejects a missing sticker', () => { + assert.deepEqual(fitTest({ stickers: [] }, null), { + fits: false, + stickersToRemove: [], + }); + assert.deepEqual(fitTest({ stickers: [] }, undefined), { + fits: false, + stickersToRemove: [], + }); +}); + +test('rejects a sticker quantity that exceeds capacity', () => { + assert.deepEqual(fitTest({ stickers: [] }, selection('too-large', 5, 5, 2)), { + fits: false, + stickersToRemove: [], + }); +}); + +test('suggests combinations of existing stickers when needed', () => { + const first = selection('first', 2, 5); + const second = selection('second', 4, 5); + const stagingArea = { stickers: [first, second] }; + + assert.deepEqual(fitTest(stagingArea, selection('new', 6, 6)), { + fits: false, + stickersToRemove: [[first, second]], + }); +}); + +test('prefers the smallest removal option and preserves staging order', () => { + const small = selection('small', 1, 2); + const large = selection('large', 4, 5); + + assert.deepEqual(fitTest({ stickers: [small, large] }, selection('new', 5, 6)), { + fits: false, + stickersToRemove: [[large]], + }); +}); + +test('returns alternate removal combinations in staging order', () => { + const first = selection('first', 4, 5); + const second = selection('second', 5, 4); + const third = selection('third', 2, 5); + + assert.deepEqual( + fitTest({ stickers: [first, second, third] }, selection('new', 4, 5)), + { + fits: false, + stickersToRemove: [ + [first, second], + [first, third], + [second, third], + ], + }, + ); +}); + +test('only suggests removing up to MAX_STICKERS_PER_REMOVAL (3) stickers', () => { + const stickers = Array.from({ length: 5 }, (_, index) => + selection(`sticker-${index}`, 4, 5), + ); + + const result = fitTest({ stickers }, selection('new', 1, 5)); + + assert.equal(result.fits, false); + assert(result.stickersToRemove.length > 0); + assert(result.stickersToRemove.some((option) => option.length === 3)); + assert(result.stickersToRemove.every((option) => option.length <= 3)); +}); + +test('caps removal suggestions at five options', () => { + const stickers = Array.from({ length: 5 }, (_, index) => + selection(`option-${index}`, 4, 5), + ); + const result = fitTest({ stickers }, selection('new', 1, 5)); + + assert.equal(result.stickersToRemove.length, 5); + assert(result.stickersToRemove.every((option) => option.length <= 3)); +}); + +test('rejects a sticker larger than the staging area capacity', () => { + assert.deepEqual( + fitTest( + { stickers: [selection('existing', 1, 3)] }, + selection('too-large', STAGING_AREA_CAPACITY + 1, 1), + ), + { fits: false, stickersToRemove: [] }, + ); +}); diff --git a/frontend/src/mini-algo.ts b/frontend/src/mini-algo.ts new file mode 100644 index 0000000..fb83bd3 --- /dev/null +++ b/frontend/src/mini-algo.ts @@ -0,0 +1,185 @@ +export const STAGING_AREA_CAPACITY = 45; +const MAX_REMOVAL_OPTIONS = 5; +const MAX_STICKERS_PER_REMOVAL_OPTION = 3; + +export interface Sticker { + name: string; + height: number; + width: number; + description: string; + tags: string[]; + id: string; + categorySection: string; + hpglFilePath: string; + svgLocation: string; +} + +export interface StickerSelection { + id: string; + sticker: Sticker; + quantity: number; +} + +export interface StagingArea { + accountId: string; + stickers: StickerSelection[]; +} + +export interface FitTestResult { + fits: boolean; + stickersToRemove: StickerSelection[][]; +} + +export const sticker: Sticker = { + name: '', + height: 3, + width: 3, + description: '', + tags: [], + id: '', + categorySection: '', + hpglFilePath: '', + svgLocation: '', +}; + +export const sticker_selection: StickerSelection = { + id: '', + sticker, + quantity: 1, +}; + +type RemovalCandidate = { + selection: StickerSelection; + index: number; + area: number; +}; + + +function collectOptions( + removalCandidates: RemovalCandidate[], + stickersToRemove: number, + overflowAmount: number, +): StickerSelection[][] { + // Array for selected stickers to remove and the list of options to remove from the staging area + const options: StickerSelection[][] = []; + const selected: RemovalCandidate[] = []; + + // Recursive function to find a list of options to remove from the stickers in the staging area. + function search(startIndex: number, freedArea: number): void { + // Stop the recursion once we have gathered enough removal options. + if (options.length >= MAX_REMOVAL_OPTIONS) { + return; + } + + // If the current selected combination of stickers is equal to stickersToRemove, + // we examine if removing those stickers frees enough space + // to accommodate the overflowAmount. If so, we push that combination on to + // the list of options, sorted by their original staging area index. + if (selected.length === stickersToRemove) { + if (freedArea >= overflowAmount) { + options.push( + [...selected] + .sort((left, right) => left.index - right.index) + .map(({ selection }) => selection), + ); + } + return; + } + + // Are there enough candidates left to finish this combination? + const remainingCount = stickersToRemove - selected.length; + if (removalCandidates.length - startIndex < remainingCount) { + return; + } + + // Make sure that the amount of area that could be freed by the remaining stickers is enough to accommodate the overflowAmount + let maximumRemainingArea = 0; + for (let index = startIndex; index < startIndex + remainingCount; index++) { + maximumRemainingArea += removalCandidates[index].area; + } + if (freedArea + maximumRemainingArea < overflowAmount) { // if not end + return; + } + + // Recursively call this function with a new starting index. + for ( + let index = startIndex; + index <= removalCandidates.length - remainingCount && + options.length < MAX_REMOVAL_OPTIONS; + index++ + ) { + selected.push(removalCandidates[index]); + search(index + 1, freedArea + removalCandidates[index].area); + selected.pop(); + } + } + + // Start the recursive function to find options of stickers to remove and return results. + search(0, 0); + return options; +} + +/** + * Checks whether a sticker selection can be added to the staging area. + * + * Calculates the total area used by the stickers in the staging area. + * Determines if adding the new sticker selection would exceed the staging area's capacity. + * If the new selection would exceed the capacity, it identifies combinations of existing selections that could be removed to make room. + * Returns a `FitTestResult` object containing whether the new selection fits and the suggested combinations to remove if it doesn't. + * STAGING_AREA_CAPACITY, MAX_REMOVAL_OPTIONS, MAX_STICKERS_PER_REMOVAL_OPTION define limits for the function's behavior. + * + * A result with `fits: false` and non-empty `stickersToRemove` means the new + * selection could fit if one of the suggested combinations were removed. + */ +export function fitTest( + stagingArea: Pick, + stickerToAdd: StickerSelection | null | undefined, +): FitTestResult { + if (!stickerToAdd) { + return { fits: false, stickersToRemove: [] }; + } + + // calculate the area of stickers in the staging area + const existingArea = stagingArea.stickers.reduce((totalArea, currentSticker) => { + return totalArea + currentSticker.sticker.height * currentSticker.sticker.width * currentSticker.quantity; + }, 0); + + // calculate area of sticker(s) to add + const stickerArea = stickerToAdd.sticker.height * stickerToAdd.sticker.width * stickerToAdd.quantity; + + // sticker cannot fit in area capacity? + if (stickerArea > STAGING_AREA_CAPACITY) { + return { fits: false, stickersToRemove: [] }; + } + + const overflowAmount = existingArea + stickerArea - STAGING_AREA_CAPACITY; + + if (overflowAmount > 0) { + // Create a list of stickers, their indexes, and areas in the staging area with their sizes + // sorted from greatest area to least area. + const candidates = stagingArea.stickers + .map((selection, index) => ({ + selection, + index, + area: selection.sticker.height * selection.sticker.width * selection.quantity, + })) + .sort((left, right) => right.area - left.area); + + // For each stickersToRemove up to either the number of canidates or the max stickers per removal option + for ( + let stickersToRemove = 1; + stickersToRemove <= Math.min(candidates.length, MAX_STICKERS_PER_REMOVAL_OPTION); + stickersToRemove++ + ) { + const options = collectOptions(candidates, stickersToRemove, overflowAmount); + if (options.length > 0) { + return { fits: false, stickersToRemove: options }; + } + } + + // No combination of stickers found. + return { fits: false, stickersToRemove: [] }; + } + + return { fits: true, stickersToRemove: [] }; +}