@blotch/dolan 22.2.2 → 22.2.4

package/dist/commands/update.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { readFileSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { createFixture, DEFAULT_CONFIG } from '../test-utils';
+import { createFixture, DEFAULT_CONFIG, shippedTheme, } from '../test-utils';
 import { hashContent } from '../lockfile';
 const spinnerMock = { start: vi.fn(), stop: vi.fn() };
 vi.mock('@clack/prompts', () => ({
@@ -20,14 +20,29 @@ vi.mock('@clack/prompts', () => ({
     cancel: vi.fn(),
     isCancel: vi.fn().mockReturnValue(false),
 }));
+// Vitest's stdin isn't a terminal, which reads as "nobody can answer". Most
+// tests are about the questions, so they run as if in one.
+let interactive = true;
+vi.mock('../utils/interactive.js', () => ({
+    isInteractive: () => interactive,
+}));
 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.
+const installComponentPackages = vi.fn();
+vi.mock('./install-packages.js', () => ({
+    installComponentPackages: (...args) => installComponentPackages(...args),
+}));
 beforeEach(() => {
+    interactive = true;
+    // Each test sees only its own calls. Without this, an assertion could pass
+    // on a message an earlier test logged.
+    vi.clearAllMocks();
     vi.spyOn(process, 'exit').mockImplementation((code) => {
         throw new Error(`process.exit(${code})`);
     });
@@ -91,28 +106,28 @@ describe('updateCommand --selective', () => {
     it('handles mixed decisions across multiple files', async () => {
         const cardOriginal = 'export const Card = { v: 1 };';
         const cardUpstream = 'export const Card = { v: 2 };';
-        const spinnerOriginal = 'export const Spinner = { v: 1 };';
-        const spinnerUpstream = 'export const Spinner = { v: 2 };';
+        const skeletonOriginal = 'export const Skeleton = { v: 1 };';
+        const skeletonUpstream = 'export const Skeleton = { v: 2 };';
         const cardHash = hashContent(cardOriginal);
-        const spinnerHash = hashContent(spinnerOriginal);
+        const skeletonHash = hashContent(skeletonOriginal);
         fixture = createFixture({
             config: DEFAULT_CONFIG,
             lockfile: {
                 version: 1,
                 components: {
                     card: { 'card.ts': { hash: cardHash } },
-                    spinner: { 'spinner.ts': { hash: spinnerHash } },
+                    skeleton: { 'skeleton.ts': { hash: skeletonHash } },
                 },
                 utils: {},
                 theme: {},
             },
             components: {
                 card: { 'card.ts': cardOriginal },
-                spinner: { 'spinner.ts': spinnerOriginal },
+                skeleton: { 'skeleton.ts': skeletonOriginal },
             },
             uiSource: {
                 card: { 'card.ts': cardUpstream },
-                spinner: { 'spinner.ts': spinnerUpstream },
+                skeleton: { 'skeleton.ts': skeletonUpstream },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
@@ -124,11 +139,11 @@ describe('updateCommand --selective', () => {
         await updateCommand({ selective: true });
         // Card should be updated (first select → upstream)
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(cardUpstream);
-        // Spinner should be skipped (second select → keep)
-        expect(readInstalledFile(fixture.dir, 'spinner', 'spinner.ts')).toBe(spinnerOriginal);
+        // Skeleton should be skipped (second select → keep)
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe(skeletonOriginal);
         const lockfile = readLockfile(fixture.dir);
         expect(lockfile.components.card['card.ts'].hash).toBe(hashContent(cardUpstream));
-        expect(lockfile.components.spinner['spinner.ts'].hash).toBe(spinnerHash);
+        expect(lockfile.components.skeleton['skeleton.ts'].hash).toBe(skeletonHash);
     });
     it('does not create new-upstream file when user chooses skip', async () => {
         const upstream = 'export const Card = {};';
@@ -136,7 +151,7 @@ describe('updateCommand --selective', () => {
             config: DEFAULT_CONFIG,
             lockfile: {
                 version: 1,
-                components: {},
+                components: { card: {} },
                 utils: {},
                 theme: {},
             },
@@ -169,7 +184,6 @@ describe('updateCommand --selective', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true, selective: true });
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
@@ -219,7 +233,6 @@ describe('updateCommand --selective', () => {
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
         p.confirm.mockResolvedValue(true);
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({});
         expect(p.confirm).toHaveBeenCalled();
@@ -306,8 +319,6 @@ describe('updateCommand --force', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
-        p.confirm.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         // Local edit discarded, file reset to upstream.
@@ -337,7 +348,6 @@ describe('updateCommand --force', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
@@ -345,14 +355,14 @@ describe('updateCommand --force', () => {
         const lockfile = readLockfile(fixture.dir);
         expect(lockfile.components.card['card.ts'].hash).toBe(hashContent(upstream));
     });
-    it('overwrites a drifted file with no lockfile entry (unknown base → conflict)', async () => {
+    it('overwrites a drifted file with no lockfile hash (unknown base → conflict)', async () => {
         // With no stored hash the base is unknown, so any local difference is
         // treated as a conflict. --force must still overwrite it.
         const userVersion = 'export const Card = { v: 1, local: true };';
         const upstream = 'export const Card = { v: 2 };';
         fixture = createFixture({
             config: DEFAULT_CONFIG,
-            lockfile: { version: 1, components: {}, utils: {}, theme: {} },
+            lockfile: { version: 1, components: { card: {} }, utils: {}, theme: {} },
             components: { card: { 'card.ts': userVersion } },
             uiSource: { card: { 'card.ts': upstream } },
         });
@@ -477,25 +487,25 @@ describe('updateCommand --force', () => {
                 version: 1,
                 components: {
                     card: { 'card.ts': { hash: hashContent('card-base') } },
-                    spinner: { 'spinner.ts': { hash: hashContent('spinner-base') } },
+                    skeleton: { 'skeleton.ts': { hash: hashContent('skeleton-base') } },
                 },
                 utils: {},
                 theme: {},
             },
             components: {
                 card: { 'card.ts': 'card-local' },
-                spinner: { 'spinner.ts': 'spinner-local' },
+                skeleton: { 'skeleton.ts': 'skeleton-local' },
             },
             uiSource: {
                 card: { 'card.ts': 'card-upstream' },
-                spinner: { 'spinner.ts': 'spinner-upstream' },
+                skeleton: { 'skeleton.ts': 'skeleton-upstream' },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe('card-upstream');
-        expect(readInstalledFile(fixture.dir, 'spinner', 'spinner.ts')).toBe('spinner-upstream');
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe('skeleton-upstream');
     });
     it('does not delete untracked local files sitting alongside components', async () => {
         // Force overwrites tracked files but must not touch files the registry
@@ -606,6 +616,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,
@@ -635,8 +665,6 @@ describe('updateCommand --force', () => {
         seedTheme(fixture, 'default.css', 'theme-local'); // theme conflict
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
-        p.confirm.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         expect(p.select).not.toHaveBeenCalled();
@@ -781,8 +809,6 @@ describe('updateCommand — config / no-op paths', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.confirm.mockClear();
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({});
         // Nothing prompts — a lone user-modified file with no force/selective is
@@ -874,7 +900,6 @@ describe('updateCommand — config / no-op paths', () => {
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
         p.confirm.mockResolvedValueOnce(true);
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({});
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(cardUpstream);
@@ -888,15 +913,15 @@ describe('updateCommand — config / no-op paths', () => {
         // The already up-to-date theme file's hash is still recorded.
         expect(lockfile.theme['default.css'].hash).toBe(hashContent(themeContent));
     });
-    it('advances the lockfile for an up-to-date component and theme file with no prior lockfile entries', async () => {
-        // Neither the component nor the theme file has ANY lockfile record at
-        // all (not just a missing hash) — buildLockfile() must create fresh
-        // entries for both from scratch on the "nothing to do" fast path.
+    it('advances the lockfile for an up-to-date component with no file hashes and a theme file with no entry', async () => {
+        // The component is tracked without file hashes, and the theme file has
+        // no lockfile record at all — buildLockfile() must create fresh entries
+        // for both on the "nothing to do" fast path.
         const cardContent = 'export const Card = {};';
         const themeContent = ':root { --primary: rgba(1, 1, 1, 1); }';
         fixture = createFixture({
             config: DEFAULT_CONFIG,
-            lockfile: { version: 1, components: {}, utils: {}, theme: {} },
+            lockfile: { version: 1, components: { card: {} }, utils: {}, theme: {} },
             components: { card: { 'card.ts': cardContent } },
             uiSource: { card: { 'card.ts': cardContent } },
             themeFiles: { 'default.css': themeContent },
@@ -1230,4 +1255,533 @@ describe('updateCommand — selective review of shared theme files', () => {
         expect(lockfile.theme['default.css'].hash).toBe(hashContent(upstream));
     });
 });
+describe('updateCommand dependencies', () => {
+    it("adds a dependency a component's new version needs, and its packages", async () => {
+        // line-chart used to stand alone; upstream it now builds on chart, which
+        // the project doesn't have yet.
+        const lineChart = "import { UiChart } from '../chart/chart';";
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    'line-chart': { 'line-chart.ts': { hash: hashContent('old') } },
+                },
+                utils: {},
+                theme: {},
+            },
+            components: { 'line-chart': { 'line-chart.ts': 'old' } },
+            uiSource: {
+                'line-chart': { 'line-chart.ts': lineChart },
+                chart: { 'chart.ts': 'export const UiChart = {};' },
+            },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(readInstalledFile(fixture.dir, 'chart', 'chart.ts')).toBe('export const UiChart = {};');
+        expect(readInstalledFile(fixture.dir, 'line-chart', 'line-chart.ts')).toBe(lineChart);
+        expect(installComponentPackages).toHaveBeenCalledWith(fixture.dir, [
+            'chart',
+            'line-chart',
+        ]);
+    });
+    it('leaves out a new dependency the user skips in selective mode', async () => {
+        const lineChart = "import { UiChart } from '../chart/chart';";
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    'line-chart': { 'line-chart.ts': { hash: hashContent(lineChart) } },
+                },
+                utils: {},
+                theme: {},
+            },
+            components: { 'line-chart': { 'line-chart.ts': lineChart } },
+            uiSource: {
+                'line-chart': { 'line-chart.ts': lineChart },
+                chart: { 'chart.ts': 'export const UiChart = {};' },
+            },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const p = await import('@clack/prompts');
+        p.select.mockResolvedValueOnce('keep');
+        const { updateCommand } = await import('./update');
+        await updateCommand({ selective: true });
+        expect(existsSync(join(fixture.dir, DEFAULT_CONFIG.aliases.components, 'chart/chart.ts'))).toBe(false);
+        expect(readLockfile(fixture.dir).components['chart']).toEqual({});
+    });
+});
+describe('updateCommand — ejected components', () => {
+    /**
+     * `dolan eject card` deleted card's lockfile entry and kept its files,
+     * which the app has since changed.
+     */
+    const ejectedCard = (lockfileComponents = {}) => createFixture({
+        config: DEFAULT_CONFIG,
+        lockfile: {
+            version: 1,
+            components: lockfileComponents,
+            utils: {},
+            theme: {},
+        },
+        components: {
+            card: { 'card.ts': 'export const Card = { mine: true };' },
+        },
+        uiSource: { card: { 'card.ts': 'export const Card = { v: 2 };' } },
+    });
+    it("doesn't overwrite or track them again, even with --force", async () => {
+        fixture = ejectedCard();
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe('export const Card = { mine: true };');
+        expect(readLockfile(fixture.dir).components).not.toHaveProperty('card');
+    });
+    it("doesn't report them as a conflict", async () => {
+        fixture = ejectedCard();
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        const messages = p.log.message.mock.calls
+            .map((c) => c[0])
+            .join('\n');
+        expect(messages).not.toContain('card');
+        expect(p.select).not.toHaveBeenCalled();
+    });
+    it('leaves an ejected dependency of a tracked component alone', async () => {
+        // select is tracked and depends on bottom-sheet, which was ejected.
+        const select = 'export const Select = {};';
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: { select: { 'select.ts': { hash: hashContent(select) } } },
+                utils: {},
+                theme: {},
+            },
+            components: {
+                select: { 'select.ts': select },
+                'bottom-sheet': {
+                    'bottom-sheet.ts': 'export const BottomSheet = { mine: true };',
+                },
+            },
+            uiSource: {
+                select: { 'select.ts': select },
+                'bottom-sheet': { 'bottom-sheet.ts': 'export const BottomSheet = {};' },
+            },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(readInstalledFile(fixture.dir, 'bottom-sheet', 'bottom-sheet.ts')).toBe('export const BottomSheet = { mine: true };');
+        expect(readLockfile(fixture.dir).components).not.toHaveProperty('bottom-sheet');
+    });
+});
+// CI, agents and scripts: a question there would wait for input that never
+// comes.
+describe('updateCommand without a terminal', () => {
+    const base = 'export const Card = { v: 1 };';
+    const userVersion = 'export const Card = { v: 1, local: true };';
+    const upstream = 'export const Card = { v: 2 };';
+    const themeBase = ':root { --primary: rgba(1, 1, 1, 1); }';
+    const themeMine = ':root { --primary: rgba(9, 9, 9, 1); }';
+    const themeUpstream = ':root { --primary: rgba(2, 2, 2, 1); }';
+    /**
+     * `card` and `default.css` conflict (both sides changed), and `skeleton` is
+     * a plain auto-update.
+     */
+    const setup = () => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    card: { 'card.ts': { hash: hashContent(base) } },
+                    skeleton: { 'skeleton.ts': { hash: hashContent(base) } },
+                },
+                utils: {},
+                theme: { 'default.css': { hash: hashContent(themeBase) } },
+            },
+            components: {
+                card: { 'card.ts': userVersion },
+                skeleton: { 'skeleton.ts': base },
+            },
+            uiSource: {
+                card: { 'card.ts': upstream },
+                skeleton: { 'skeleton.ts': upstream },
+            },
+            themeFiles: { 'default.css': themeUpstream },
+        });
+        writeFileSync(join(fixture.dir, DEFAULT_CONFIG.aliases.theme, 'default.css'), themeMine);
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+    };
+    const readTheme = () => readFileSync(join(fixture.dir, DEFAULT_CONFIG.aliases.theme, 'default.css'), 'utf-8');
+    beforeEach(() => {
+        interactive = false;
+    });
+    it('applies auto-updates without asking', async () => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: { card: { 'card.ts': { hash: hashContent(base) } } },
+                utils: {},
+                theme: {},
+            },
+            components: { card: { 'card.ts': base } },
+            uiSource: { card: { 'card.ts': upstream } },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.confirm).not.toHaveBeenCalled();
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('leaves conflicts as they are for a terminal to ask about, and exits 1', async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await expect(updateCommand({})).rejects.toThrow('process.exit(1)');
+        expect(p.select).not.toHaveBeenCalled();
+        // The count is bold, and CI turns colors on, so match the plain text.
+        const [warning] = p.log.warn.mock.calls[0];
+        // oxlint-disable-next-line no-control-regex -- matching ANSI color codes
+        expect(warning.replace(/\u001b\[\d+m/g, '')).toMatch(/2 conflict\(s\) left.*dolan update --force/);
+        // The auto-update still applies.
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe(upstream);
+        // The conflicts keep both their files and their lockfile base. Keeping
+        // the user's version would advance the base and lose the upstream change.
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(userVersion);
+        expect(readTheme()).toBe(themeMine);
+        const lockfile = readLockfile(fixture.dir);
+        expect(lockfile.components.card['card.ts'].hash).toBe(hashContent(base));
+        expect(lockfile.theme['default.css'].hash).toBe(hashContent(themeBase));
+        // So an update in a terminal still asks about both.
+        interactive = true;
+        vi.clearAllMocks();
+        // A reset drops answers an earlier test queued and never used.
+        p.select
+            .mockReset()
+            .mockResolvedValue('upstream');
+        await updateCommand({});
+        expect(p.select).toHaveBeenCalledTimes(2);
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
+        expect(readTheme()).toBe(themeUpstream);
+    });
+    it("takes upstream's version of conflicts with --force, which wins over --selective", async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true, selective: true });
+        expect(p.log.error).not.toHaveBeenCalled();
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
+        expect(readTheme()).toBe(themeUpstream);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('fails with --selective, which asks about each file', async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await expect(updateCommand({ selective: true })).rejects.toThrow('process.exit(1)');
+        expect(p.log.error).toHaveBeenCalledWith(expect.stringContaining('--selective'));
+        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) });
+    });
+});
 //# sourceMappingURL=update.test.js.map