@blotch/dolan 22.2.3 → 22.2.5

package/dist/commands/update.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { readFileSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, rmSync, } from 'node:fs';
 import { join } from 'node:path';
-import { createFixture, DEFAULT_CONFIG } from '../test-utils';
+import { stripVTControlCharacters } from 'node:util';
+import { createFixture, DEFAULT_CONFIG, onTailwind, shippedTheme, } from '../test-utils';
 import { hashContent } from '../lockfile';
 const spinnerMock = { start: vi.fn(), stop: vi.fn() };
 vi.mock('@clack/prompts', () => ({
@@ -30,7 +31,7 @@ let fixture;
 vi.mock('../utils/resolve-paths.js', () => ({
     getUiSourceDir: () => fixture.uiDir,
     getComponentSourceDir: (name) => join(fixture.uiDir, 'components', name),
-    getComponentFiles: (name) => readdirSync(join(fixture.uiDir, 'components', name)).filter((f) => f.endsWith('.ts')),
+    getComponentFiles: (name, { tests }) => readdirSync(join(fixture.uiDir, 'components', name)).filter((f) => f.endsWith('.ts') && (tests || !f.endsWith('.test.ts'))),
     rewriteImports: (content) => content,
 }));
 // The install step runs the project's package manager; record calls instead.
@@ -616,6 +617,26 @@ describe('updateCommand --force', () => {
         const lockfile = readLockfile(fixture.dir);
         expect(lockfile.theme['default.css'].hash).toBe(hashContent(upstream));
     });
+    it("adds the Tailwind plugin's test once the project has the testing library", async () => {
+        const pluginTest = "import { blotchPlugin } from './tailwind-plugin';";
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: { version: 1, components: {}, utils: {}, theme: {} },
+            themeFiles: { 'tailwind-plugin.test.ts': pluginTest },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(existsSync(join(fixture.dir, DEFAULT_CONFIG.aliases.theme, 'tailwind-plugin.test.ts'))).toBe(false);
+        writeFileSync(join(fixture.dir, 'package.json'), JSON.stringify({
+            devDependencies: { '@blotch/angular-lynx-testing-library': '^22.2.3' },
+        }));
+        await updateCommand({ force: true });
+        expect(readTheme(fixture, 'tailwind-plugin.test.ts')).toBe(pluginTest);
+        expect(readLockfile(fixture.dir).theme['tailwind-plugin.test.ts']).toEqual({
+            hash: hashContent(pluginTest),
+        });
+    });
     it('never prompts even when conflicts, user-modifications and new files coexist', async () => {
         fixture = createFixture({
             config: DEFAULT_CONFIG,
@@ -1254,6 +1275,7 @@ describe('updateCommand dependencies', () => {
             uiSource: {
                 'line-chart': { 'line-chart.ts': lineChart },
                 chart: { 'chart.ts': 'export const UiChart = {};' },
+                icon: { 'icon.ts': 'export const UiIcon = {};' },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
@@ -1263,6 +1285,7 @@ describe('updateCommand dependencies', () => {
         expect(readInstalledFile(fixture.dir, 'line-chart', 'line-chart.ts')).toBe(lineChart);
         expect(installComponentPackages).toHaveBeenCalledWith(fixture.dir, [
             'chart',
+            'icon',
             'line-chart',
         ]);
     });
@@ -1282,6 +1305,7 @@ describe('updateCommand dependencies', () => {
             uiSource: {
                 'line-chart': { 'line-chart.ts': lineChart },
                 chart: { 'chart.ts': 'export const UiChart = {};' },
+                icon: { 'icon.ts': 'export const UiIcon = {};' },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
@@ -1351,6 +1375,9 @@ describe('updateCommand — ejected components', () => {
             uiSource: {
                 select: { 'select.ts': select },
                 'bottom-sheet': { 'bottom-sheet.ts': 'export const BottomSheet = {};' },
+                // What bottom-sheet's glass variant draws with.
+                glass: { 'glass.ts': 'export const Glass = {};' },
+                icon: { 'icon.ts': 'export const Icon = {};' },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
@@ -1472,4 +1499,544 @@ describe('updateCommand without a terminal', () => {
         expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe(base);
     });
 });
+// 22.2.2's `init` copied the theme but recorded no hashes for it, so the first
+// `update` after a release that changed the theme called every theme file a
+// conflict, though nobody had touched them.
+describe('updateCommand — theme files an older init copied', () => {
+    const themePath = (file) => join(fixture.dir, DEFAULT_CONFIG.aliases.theme, file);
+    const upstream = {
+        'default.css': ':root { --primary: rgba(2, 2, 2, 1); }',
+        'dark.css': 'page.dark { --primary: rgba(3, 3, 3, 1); }',
+    };
+    /**
+     * Writes `files` where init put the theme, with `"theme": {}` locked.
+     */
+    const setup = (files) => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: { version: 1, components: {}, theme: {} },
+            themeFiles: upstream,
+        });
+        for (const [file, content] of Object.entries(files)) {
+            writeFileSync(themePath(file), content);
+        }
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+    };
+    it('updates an untouched copy as an auto-update, not a conflict', async () => {
+        setup({
+            'default.css': shippedTheme('default.css'),
+            'dark.css': shippedTheme('dark.css'),
+        });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.select).not.toHaveBeenCalled();
+        expect(p.confirm).toHaveBeenCalledWith(expect.objectContaining({ message: 'Apply 2 auto-update(s)?' }));
+        expect(readFileSync(themePath('default.css'), 'utf-8')).toBe(upstream['default.css']);
+        expect(readFileSync(themePath('dark.css'), 'utf-8')).toBe(upstream['dark.css']);
+        expect(readLockfile(fixture.dir).theme).toEqual({
+            'default.css': { hash: hashContent(upstream['default.css']) },
+            'dark.css': { hash: hashContent(upstream['dark.css']) },
+        });
+    });
+    it('applies them without a terminal, rather than leaving conflicts and exiting 1', async () => {
+        interactive = false;
+        setup({ 'default.css': shippedTheme('default.css') });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(readFileSync(themePath('default.css'), 'utf-8')).toBe(upstream['default.css']);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('still asks about a copy that was edited, since its base is unknown', async () => {
+        const edited = `${shippedTheme('default.css')}\npage { --mine: red; }\n`;
+        setup({ 'default.css': edited });
+        const p = await import('@clack/prompts');
+        p.select.mockResolvedValueOnce('keep');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.select).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.stringContaining('how to resolve?'),
+        }));
+        expect(readFileSync(themePath('default.css'), 'utf-8')).toBe(edited);
+    });
+});
+// 22.2.3 stopped copying `*-render.test.ts`, but `update` only looked at the
+// files upstream ships now and kept every old lockfile entry, so the stale
+// spec stayed, importing a helper dolan doesn't copy, and broke `ng test`.
+describe('updateCommand — files upstream no longer ships', () => {
+    const card = 'export const Card = {};';
+    const stale = "import { setInputSignal } from '../../../test-utils/x';";
+    const edited = `${stale}\n// mine\n`;
+    const STALE = 'card-render.test.ts';
+    const stalePath = () => join(fixture.dir, DEFAULT_CONFIG.aliases.components, 'card', STALE);
+    /**
+     * card is up to date, and it has STALE (as add copied it, unless `onDisk`
+     * says otherwise), which upstream no longer ships. `upstreamCard` changes
+     * card.ts upstream too.
+     */
+    const setup = ({ onDisk = stale, upstreamCard = card, } = {}) => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    card: {
+                        'card.ts': { hash: hashContent(card) },
+                        [STALE]: { hash: hashContent(stale) },
+                    },
+                },
+                theme: {},
+            },
+            components: {
+                card: {
+                    'card.ts': card,
+                    ...(onDisk === null ? {} : { [STALE]: onDisk }),
+                },
+            },
+            uiSource: { card: { 'card.ts': upstreamCard } },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+    };
+    const lockedCard = () => readLockfile(fixture.dir).components.card;
+    /**
+     * The log messages, colors stripped.
+     */
+    const messages = async () => {
+        const p = await import('@clack/prompts');
+        const text = p.log.message.mock.calls
+            .map(([m]) => m)
+            .join('\n');
+        // oxlint-disable-next-line no-control-regex -- matching ANSI color codes
+        return text.replace(/\u001b\[\d+m/g, '');
+    };
+    /**
+     * The options of the select prompt's first call.
+     */
+    const selectOptions = async () => {
+        const p = await import('@clack/prompts');
+        const [{ options }] = p.select.mock
+            .calls[0];
+        return options;
+    };
+    beforeEach(async () => {
+        // A reset drops answers an earlier test queued and never used.
+        const p = await import('@clack/prompts');
+        p.select
+            .mockReset()
+            .mockResolvedValue('upstream');
+    });
+    it('deletes one nobody edited, with its lockfile entry, after the usual question', async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.confirm).toHaveBeenCalledWith(expect.objectContaining({ message: 'Apply 1 auto-update(s)?' }));
+        expect(p.select).not.toHaveBeenCalled();
+        expect(await messages()).toContain(`card/${STALE} — upstream no longer ships it → delete`);
+        expect(existsSync(stalePath())).toBe(false);
+        expect(lockedCard()).toEqual({ 'card.ts': { hash: hashContent(card) } });
+        expect(p.log.success).toHaveBeenCalledWith(expect.stringContaining('deleted: upstream no longer ships them'));
+    });
+    it('deletes one nobody edited without a terminal too', async () => {
+        interactive = false;
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.confirm).not.toHaveBeenCalled();
+        expect(existsSync(stalePath())).toBe(false);
+        expect(lockedCard()).not.toHaveProperty(STALE);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('asks before deleting one you edited, and deletes it when told to', async () => {
+        setup({ onDisk: edited });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(await messages()).toContain(`card/${STALE} — upstream no longer ships it, and you modified it`);
+        expect(p.select).toHaveBeenCalledTimes(1);
+        expect(p.select).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.stringContaining('you modified it, and upstream no longer ships it'),
+        }));
+        // A deletion is all or nothing, so there are no hunks to review.
+        expect(await selectOptions()).toEqual([
+            expect.objectContaining({ value: 'diff' }),
+            {
+                value: 'keep',
+                label: 'Keep my version',
+                hint: 'keep it as my own file',
+            },
+            { value: 'upstream', label: 'Delete it', hint: 'discard my changes' },
+        ]);
+        expect(existsSync(stalePath())).toBe(false);
+        expect(lockedCard()).not.toHaveProperty(STALE);
+    });
+    it('shows what deleting it would take away', async () => {
+        setup({ onDisk: edited });
+        const p = await import('@clack/prompts');
+        p.select
+            .mockResolvedValueOnce('diff')
+            .mockResolvedValueOnce('upstream');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(await messages()).toContain(`- // mine`);
+        expect(existsSync(stalePath())).toBe(false);
+    });
+    it('keeps one you edited when told to, as your own file from then on', async () => {
+        setup({ onDisk: edited });
+        const p = await import('@clack/prompts');
+        p.select.mockResolvedValueOnce('keep');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(readFileSync(stalePath(), 'utf-8')).toBe(edited);
+        // Upstream has nothing left to merge into it, so dolan stops tracking it,
+        // and the next update doesn't ask again.
+        expect(lockedCard()).toEqual({ 'card.ts': { hash: hashContent(card) } });
+        expect(p.log.info).toHaveBeenCalledWith(expect.stringContaining('file(s) kept as-is'));
+        vi.clearAllMocks();
+        await updateCommand({});
+        expect(p.select).not.toHaveBeenCalled();
+        expect(readFileSync(stalePath(), 'utf-8')).toBe(edited);
+    });
+    it('leaves one you edited for a terminal to ask about without one, and exits 1', async () => {
+        interactive = false;
+        setup({ onDisk: edited });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await expect(updateCommand({})).rejects.toThrow('process.exit(1)');
+        expect(p.select).not.toHaveBeenCalled();
+        expect(p.log.warn).toHaveBeenCalledWith(expect.stringContaining('conflict(s) left as they are'));
+        expect(readFileSync(stalePath(), 'utf-8')).toBe(edited);
+        expect(lockedCard()[STALE]).toEqual({ hash: hashContent(stale) });
+    });
+    it('deletes one you edited with --force', async () => {
+        interactive = false;
+        setup({ onDisk: edited });
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(existsSync(stalePath())).toBe(false);
+        expect(lockedCard()).not.toHaveProperty(STALE);
+    });
+    describe('with --selective', () => {
+        it('asks about the deletion, and "Skip for now" keeps the file and its entry', async () => {
+            setup();
+            const p = await import('@clack/prompts');
+            p.select.mockResolvedValueOnce('keep');
+            const { updateCommand } = await import('./update');
+            await updateCommand({ selective: true });
+            expect(p.select).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringMatching(/upstream no longer ships it$/),
+            }));
+            expect(await selectOptions()).toEqual([
+                expect.objectContaining({ value: 'diff' }),
+                expect.objectContaining({ value: 'keep', label: 'Skip for now' }),
+                { value: 'upstream', label: 'Delete it', hint: 'remove the file' },
+            ]);
+            expect(readFileSync(stalePath(), 'utf-8')).toBe(stale);
+            expect(lockedCard()[STALE]).toEqual({ hash: hashContent(stale) });
+        });
+        it('deletes it when accepted', async () => {
+            setup();
+            const { updateCommand } = await import('./update');
+            await updateCommand({ selective: true });
+            expect(existsSync(stalePath())).toBe(false);
+            expect(lockedCard()).not.toHaveProperty(STALE);
+        });
+    });
+    describe('already gone from disk', () => {
+        it('drops its entry when nothing else changed', async () => {
+            setup({ onDisk: null });
+            const p = await import('@clack/prompts');
+            const { updateCommand } = await import('./update');
+            await updateCommand({});
+            expect(p.confirm).not.toHaveBeenCalled();
+            expect(await messages()).not.toContain(STALE);
+            expect(p.outro).toHaveBeenCalledWith('Everything is up to date.');
+            expect(lockedCard()).toEqual({ 'card.ts': { hash: hashContent(card) } });
+        });
+        it('drops its entry alongside an update', async () => {
+            const upstreamCard = 'export const Card = { v: 2 };';
+            setup({ onDisk: null, upstreamCard });
+            const { updateCommand } = await import('./update');
+            await updateCommand({});
+            expect(lockedCard()).toEqual({
+                'card.ts': { hash: hashContent(upstreamCard) },
+            });
+        });
+    });
+    it("leaves the tests a project without the testing library doesn't get", async () => {
+        // Copied before dolan checked for the library. Upstream still ships them,
+        // so they aren't deleted: `doctor` says what to do about them instead.
+        const test = "import '@blotch/angular-lynx-testing-library';";
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    card: {
+                        'card.ts': { hash: hashContent(card) },
+                        'card.test.ts': { hash: hashContent(test) },
+                    },
+                },
+                theme: {},
+            },
+            components: { card: { 'card.ts': card, 'card.test.ts': test } },
+            uiSource: { card: { 'card.ts': card, 'card.test.ts': test } },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(readInstalledFile(fixture.dir, 'card', 'card.test.ts')).toBe(test);
+        expect(lockedCard()['card.test.ts']).toEqual({ hash: hashContent(test) });
+    });
+});
+// An app that moved from Tailwind 3 to Tailwind 4 kept the plugin and its
+// test: `update` only looked at the theme files the app takes now, so
+// nothing offered to delete them, though nothing imports the plugin and the
+// app's coverage counted it.
+describe('updateCommand — theme files for the Tailwind version the app left', () => {
+    const theme = {
+        'default.css': ':root { --primary: rgba(1, 1, 1, 1); }',
+        'dark.css': 'page.dark { --primary: rgba(2, 2, 2, 1); }',
+        'tailwind.css': '@theme inline { --color-primary: var(--primary); }',
+        'tailwind-plugin.ts': 'export const blotchPlugin = {};',
+        'tailwind-plugin.test.ts': "import { blotchPlugin } from './tailwind-plugin';",
+    };
+    const PLUGIN = 'tailwind-plugin.ts';
+    const PLUGIN_TEST = 'tailwind-plugin.test.ts';
+    const edited = `${theme[PLUGIN]}\n// mine\n`;
+    const themePath = (file) => join(fixture.dir, DEFAULT_CONFIG.aliases.theme, file);
+    const recorded = (files) => Object.fromEntries(files.map((file) => [file, { hash: hashContent(theme[file]) }]));
+    /**
+     * An app `init` set up on Tailwind 3 with the testing library, now on
+     * `tailwind` (4 unless it says otherwise). Dolan's theme ships every file.
+     * `locked` are the theme files the lockfile records and the folder has as
+     * copied, and `onDisk` overrides what the folder has: a string replaces a
+     * file, and null deletes it.
+     */
+    const setup = ({ tailwind = 4, locked = ['default.css', 'dark.css', PLUGIN, PLUGIN_TEST], onDisk = {}, } = {}) => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: { version: 1, components: {}, theme: recorded(locked) },
+            themeFiles: theme,
+        });
+        onTailwind(fixture.dir, tailwind, { testing: true });
+        for (const file of locked)
+            writeFileSync(themePath(file), theme[file]);
+        for (const [file, content] of Object.entries(onDisk)) {
+            if (content === null)
+                rmSync(themePath(file));
+            else
+                writeFileSync(themePath(file), content);
+        }
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+    };
+    const lockedTheme = () => readLockfile(fixture.dir).theme;
+    /**
+     * What a log function was called with, colors stripped.
+     */
+    const logged = (log) => log.mock.calls
+        .map(([message]) => stripVTControlCharacters(message))
+        .join('\n');
+    beforeEach(async () => {
+        // A reset drops answers an earlier test queued and never used.
+        const p = await import('@clack/prompts');
+        p.select
+            .mockReset()
+            .mockResolvedValue('upstream');
+    });
+    it('deletes the plugin and its test nobody edited, with their lockfile entries, after the usual question', async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.confirm).toHaveBeenCalledWith(expect.objectContaining({ message: 'Apply 3 auto-update(s)?' }));
+        expect(p.select).not.toHaveBeenCalled();
+        expect(logged(p.log.message)).toContain([
+            'Shared files:',
+            '  ✓ theme/default.css — up to date',
+            '  ✓ theme/dark.css — up to date',
+            '  + theme/tailwind.css — new file from upstream',
+            '  − theme/tailwind-plugin.ts — the app uses Tailwind 4 → delete',
+            '  − theme/tailwind-plugin.test.ts — the app uses Tailwind 4 → delete',
+        ].join('\n'));
+        expect(existsSync(themePath(PLUGIN))).toBe(false);
+        expect(existsSync(themePath(PLUGIN_TEST))).toBe(false);
+        expect(readFileSync(themePath('tailwind.css'), 'utf-8')).toBe(theme['tailwind.css']);
+        expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', 'tailwind.css']));
+        expect(logged(p.log.success)).toContain('2 theme file(s) deleted: the app uses Tailwind 4.');
+    });
+    it('deletes them without a terminal too', async () => {
+        interactive = false;
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.confirm).not.toHaveBeenCalled();
+        expect(existsSync(themePath(PLUGIN))).toBe(false);
+        expect(lockedTheme()).not.toHaveProperty(PLUGIN);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('asks before deleting a plugin you edited, and deletes it when told to', async () => {
+        setup({ onDisk: { [PLUGIN]: edited } });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(logged(p.log.message)).toContain('  ⚠ theme/tailwind-plugin.ts — the app uses Tailwind 4, and you modified it');
+        expect(p.select).toHaveBeenCalledTimes(1);
+        const [{ message, options }] = p.select.mock
+            .calls[0];
+        expect(stripVTControlCharacters(message)).toBe('shared/theme/tailwind-plugin.ts — you modified it, and the app uses Tailwind 4');
+        // A deletion is all or nothing, so there are no hunks to review.
+        expect(options.map(({ value }) => value)).toEqual([
+            'diff',
+            'keep',
+            'upstream',
+        ]);
+        expect(existsSync(themePath(PLUGIN))).toBe(false);
+        expect(existsSync(themePath(PLUGIN_TEST))).toBe(false);
+        expect(lockedTheme()).not.toHaveProperty(PLUGIN);
+    });
+    it('keeps a plugin you edited when told to, as your own file from then on', async () => {
+        setup({ onDisk: { [PLUGIN]: edited } });
+        const p = await import('@clack/prompts');
+        p.select.mockResolvedValueOnce('keep');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(readFileSync(themePath(PLUGIN), 'utf-8')).toBe(edited);
+        expect(lockedTheme()).not.toHaveProperty(PLUGIN);
+        expect(logged(p.log.info)).toContain('1 file(s) kept as-is.');
+        vi.clearAllMocks();
+        await updateCommand({});
+        expect(p.select).not.toHaveBeenCalled();
+        expect(readFileSync(themePath(PLUGIN), 'utf-8')).toBe(edited);
+    });
+    it('leaves a plugin you edited for a terminal to ask about without one, and exits 1', async () => {
+        interactive = false;
+        setup({ onDisk: { [PLUGIN]: edited } });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await expect(updateCommand({})).rejects.toThrow('process.exit(1)');
+        expect(p.select).not.toHaveBeenCalled();
+        expect(logged(p.log.warn)).toContain('1 conflict(s) left as they are');
+        expect(readFileSync(themePath(PLUGIN), 'utf-8')).toBe(edited);
+        expect(lockedTheme()[PLUGIN]).toEqual({
+            hash: hashContent(theme[PLUGIN]),
+        });
+        // The test nobody edited goes anyway, as auto-updates do.
+        expect(existsSync(themePath(PLUGIN_TEST))).toBe(false);
+    });
+    it('deletes a plugin you edited with --force', async () => {
+        interactive = false;
+        setup({ onDisk: { [PLUGIN]: edited } });
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(existsSync(themePath(PLUGIN))).toBe(false);
+        expect(lockedTheme()).not.toHaveProperty(PLUGIN);
+    });
+    describe('with --selective', () => {
+        it('asks about each deletion, and "Skip for now" keeps the file and its entry', async () => {
+            setup();
+            const p = await import('@clack/prompts');
+            p.select.mockResolvedValue('keep');
+            const { updateCommand } = await import('./update');
+            await updateCommand({ selective: true });
+            const messages = p.select.mock.calls.map(([{ message }]) => stripVTControlCharacters(message));
+            expect(messages).toEqual([
+                'shared/theme/tailwind.css — new file from upstream',
+                'shared/theme/tailwind-plugin.ts — the app uses Tailwind 4',
+                'shared/theme/tailwind-plugin.test.ts — the app uses Tailwind 4',
+            ]);
+            expect(readFileSync(themePath(PLUGIN), 'utf-8')).toBe(theme[PLUGIN]);
+            expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', PLUGIN, PLUGIN_TEST]));
+            expect(logged(p.log.info)).toContain('3 file(s) skipped');
+        });
+        it('deletes them when accepted', async () => {
+            setup();
+            const { updateCommand } = await import('./update');
+            await updateCommand({ selective: true });
+            expect(existsSync(themePath(PLUGIN))).toBe(false);
+            expect(existsSync(themePath(PLUGIN_TEST))).toBe(false);
+            expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', 'tailwind.css']));
+        });
+    });
+    describe('already deleted by hand', () => {
+        it('drops their entries when nothing else changed', async () => {
+            setup({
+                locked: [
+                    'default.css',
+                    'dark.css',
+                    'tailwind.css',
+                    PLUGIN,
+                    PLUGIN_TEST,
+                ],
+                onDisk: { [PLUGIN]: null, [PLUGIN_TEST]: null },
+            });
+            const p = await import('@clack/prompts');
+            const { updateCommand } = await import('./update');
+            await updateCommand({});
+            expect(p.confirm).not.toHaveBeenCalled();
+            expect(logged(p.log.message)).not.toContain(PLUGIN);
+            expect(p.outro).toHaveBeenCalledWith('Everything is up to date.');
+            expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', 'tailwind.css']));
+        });
+        it('drops their entries alongside an update', async () => {
+            setup({ onDisk: { [PLUGIN]: null, [PLUGIN_TEST]: null } });
+            const p = await import('@clack/prompts');
+            const { updateCommand } = await import('./update');
+            await updateCommand({});
+            expect(p.confirm).toHaveBeenCalledWith(expect.objectContaining({ message: 'Apply 1 auto-update(s)?' }));
+            expect(logged(p.log.success)).not.toContain('deleted');
+            expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', 'tailwind.css']));
+        });
+    });
+    it('deletes tailwind.css after a move back to Tailwind 3, and brings the plugin back', async () => {
+        setup({ tailwind: 3, locked: ['default.css', 'dark.css', 'tailwind.css'] });
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(logged(p.log.message)).toContain('  − theme/tailwind.css — the app uses Tailwind 3 → delete');
+        expect(existsSync(themePath('tailwind.css'))).toBe(false);
+        expect(readFileSync(themePath(PLUGIN), 'utf-8')).toBe(theme[PLUGIN]);
+        expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', PLUGIN, PLUGIN_TEST]));
+        expect(logged(p.log.success)).toContain('1 theme file(s) deleted: the app uses Tailwind 3.');
+    });
+    it("keeps the plugin's test that a project without the testing library doesn't get", async () => {
+        // Upstream still ships it to a Tailwind 3 app, as it does a component's
+        // tests, so it isn't deleted for want of the library.
+        setup({ tailwind: 3 });
+        onTailwind(fixture.dir, 3);
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(readFileSync(themePath(PLUGIN_TEST), 'utf-8')).toBe(theme[PLUGIN_TEST]);
+        expect(lockedTheme()[PLUGIN_TEST]).toEqual({
+            hash: hashContent(theme[PLUGIN_TEST]),
+        });
+    });
+    // Tailwind 3 apps were mostly set up by a release whose `init` recorded no
+    // theme hashes, so their plugin isn't in the lockfile.
+    describe('copied by an older init', () => {
+        it('deletes an untouched copy', async () => {
+            setup({
+                locked: [],
+                onDisk: { [PLUGIN]: shippedTheme('tailwind-plugin.ts') },
+            });
+            const { updateCommand } = await import('./update');
+            await updateCommand({});
+            expect(existsSync(themePath(PLUGIN))).toBe(false);
+            expect(lockedTheme()).toEqual(recorded(['default.css', 'dark.css', 'tailwind.css']));
+        });
+        it('leaves an edited copy alone, since nothing says it was dolan’s', async () => {
+            const mine = `${shippedTheme('tailwind-plugin.ts')}\n// mine\n`;
+            setup({ locked: [], onDisk: { [PLUGIN]: mine } });
+            const p = await import('@clack/prompts');
+            const { updateCommand } = await import('./update');
+            await updateCommand({});
+            expect(p.select).not.toHaveBeenCalled();
+            expect(logged(p.log.message)).not.toContain(PLUGIN);
+            expect(readFileSync(themePath(PLUGIN), 'utf-8')).toBe(mine);
+        });
+    });
+});
 //# sourceMappingURL=update.test.js.map