dotenv-diff 2.7.8 → 2.7.10

package/dist/test/unit/core/scan/determineComparisonFile.test.js

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { determineComparisonFile } from '../../../../src/core/scan/determineComparisonFile.js';
+import { normalizePath } from '../../../../src/core/helpers/normalizePath.js';
+import fs from 'fs';
+import path from 'path';
+vi.mock('fs');
+describe('determineComparisonFile', () => {
+    const mockExistsSync = vi.mocked(fs.existsSync);
+    const baseOpts = {
+        cwd: '/project',
+        include: [],
+        exclude: [],
+        ignore: [],
+        ignoreRegex: [],
+        secrets: false,
+        json: false,
+    };
+    beforeEach(() => {
+        mockExistsSync.mockClear();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns examplePath when it exists', async () => {
+        const expectedPath = normalizePath(path.resolve('/project/.env.example'));
+        mockExistsSync.mockReturnValue(true);
+        const opts = {
+            ...baseOpts,
+            examplePath: '.env.example',
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: expectedPath,
+                name: '.env.example',
+            },
+        });
+        expect(mockExistsSync).toHaveBeenCalled();
+    });
+    it('returns envPath when it exists and no examplePath provided', async () => {
+        const expectedPath = normalizePath(path.resolve('/project/.env.local'));
+        mockExistsSync.mockReturnValue(true);
+        const opts = {
+            ...baseOpts,
+            envPath: '.env.local',
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: expectedPath,
+                name: '.env.local',
+            },
+        });
+        expect(mockExistsSync).toHaveBeenCalled();
+    });
+    it('prioritizes examplePath over envPath when both exist', async () => {
+        const expectedPath = normalizePath(path.resolve('/project/.env.example'));
+        mockExistsSync.mockReturnValue(true);
+        const opts = {
+            ...baseOpts,
+            examplePath: '.env.example',
+            envPath: '.env',
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: expectedPath,
+                name: '.env.example',
+            },
+        });
+        expect(mockExistsSync).toHaveBeenCalled();
+    });
+    it('falls back to envPath when examplePath does not exist', async () => {
+        const expectedPath = path.resolve('/project/.env');
+        mockExistsSync.mockImplementation((p) => p === expectedPath);
+        const opts = {
+            ...baseOpts,
+            examplePath: '.env.example',
+            envPath: '.env',
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: normalizePath(expectedPath),
+                name: '.env',
+            },
+        });
+    });
+    it('falls back to auto-discovery when envPath does not exist', async () => {
+        const expectedPath = path.resolve('/project/.env');
+        mockExistsSync.mockImplementation((p) => p === expectedPath);
+        const opts = {
+            ...baseOpts,
+            envPath: '.env.missing',
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: normalizePath(expectedPath),
+                name: '.env',
+            },
+        });
+    });
+    it('auto-discovers first available candidate when no paths provided', async () => {
+        const expectedPath = path.resolve('/project/.env.local');
+        mockExistsSync.mockImplementation((p) => p === expectedPath);
+        const result = await determineComparisonFile(baseOpts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: normalizePath(expectedPath),
+                name: '.env.local',
+            },
+        });
+    });
+    it('returns type none when no files exist', async () => {
+        mockExistsSync.mockReturnValue(false);
+        const result = await determineComparisonFile(baseOpts);
+        expect(result).toEqual({ type: 'none' });
+    });
+    it('resolves relative paths correctly', async () => {
+        const expectedPath = normalizePath(path.resolve('/home/user/project/config/.env.example'));
+        mockExistsSync.mockReturnValue(true);
+        const opts = {
+            ...baseOpts,
+            cwd: '/home/user/project',
+            examplePath: 'config/.env.example',
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: expectedPath,
+                name: '.env.example',
+            },
+        });
+    });
+    it('handles absolute paths correctly', async () => {
+        const absolutePath = '/absolute/path/.env.example';
+        const expectedPath = normalizePath(absolutePath);
+        mockExistsSync.mockReturnValue(true);
+        const opts = {
+            ...baseOpts,
+            examplePath: absolutePath,
+        };
+        const result = await determineComparisonFile(opts);
+        expect(result).toEqual({
+            type: 'found',
+            file: {
+                path: expectedPath,
+                name: '.env.example',
+            },
+        });
+        expect(mockExistsSync).toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=determineComparisonFile.test.js.map

package/dist/test/unit/core/scan/determineComparisonFile.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineComparisonFile.test.js","sourceRoot":"","sources":["../../../../../test/unit/core/scan/determineComparisonFile.test.ts"],"names":[],"mappings":"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"}

package/dist/test/unit/core/scan/patterns.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=patterns.test.d.ts.map

package/dist/test/unit/core/scan/patterns.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/core/scan/patterns.test.ts"],"names":[],"mappings":""}

package/dist/test/unit/core/scan/patterns.test.js

@@ -0,0 +1,483 @@
+import { describe, it, expect } from 'vitest';
+import { scanFile } from '../../../../src/core/scan/scanFile';
+import { DEFAULT_INCLUDE_EXTENSIONS, DEFAULT_EXCLUDE_PATTERNS, ENV_PATTERNS, buildSveltekitAliasPatterns, } from '../../../../src/core/scan/patterns';
+describe('scanFile - Pattern Detection', () => {
+    const baseOpts = {
+        cwd: '/test/project',
+        include: [],
+        exclude: [],
+        ignore: [],
+        ignoreRegex: [],
+        files: [],
+        secrets: false,
+        ignoreUrls: [],
+        json: false,
+    };
+    describe('Node.js Dot and Bracket Notation', () => {
+        it('detects standard dot notation: process.env.MY_KEY', () => {
+            const code = 'const val = process.env.MY_KEY;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+        it('detects bracket notation with double quotes: process.env["MY_KEY"]', () => {
+            const code = 'const val = process.env["MY_KEY"];';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+        it("detects bracket notation with single quotes: process.env['MY_KEY']", () => {
+            const code = "const val = process.env['MY_KEY'];";
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+    });
+    describe('Node.js Destructuring', () => {
+        it('detects simple destructuring: const { MY_KEY } = process.env', () => {
+            const code = 'const { MY_KEY } = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+        it('detects aliased destructuring: const { MY_KEY: alias } = process.env', () => {
+            const code = 'const { MY_KEY: alias } = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+        it('detects destructuring with default values: const { MY_KEY = "val" } = process.env', () => {
+            const code = 'const { MY_KEY = "default" } = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+        it('detects multiple mixed destructuring', () => {
+            const code = 'const { MY_KEY, OTHER_KEY: alias, THIRD_KEY = "fallback" } = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(3);
+            const variables = result.map((u) => u.variable).sort();
+            expect(variables).toEqual(['MY_KEY', 'OTHER_KEY', 'THIRD_KEY']);
+        });
+        it('detects multiline destructuring', () => {
+            const code = `
+        const { 
+          MY_KEY, 
+          OTHER_KEY 
+        } = process.env;
+      `;
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(2);
+            const variables = result.map((u) => u.variable).sort();
+            expect(variables).toEqual(['MY_KEY', 'OTHER_KEY']);
+        });
+        it('handles empty destructuring gracefully', () => {
+            const code = 'const {} = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('handles complex whitespace and empty parts in destructuring', () => {
+            const code = 'const { KEY_1, , KEY_2 } = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(2);
+            expect(result.map((r) => r.variable).sort()).toEqual(['KEY_1', 'KEY_2']);
+        });
+    });
+    describe('import.meta.env Dot and Bracket Notation', () => {
+        it('detects standard dot notation: import.meta.env.MY_KEY', () => {
+            const code = 'const val = import.meta.env.MY_KEY;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'import.meta.env',
+            });
+        });
+        it('detects bracket notation with double quotes: import.meta.env["MY_KEY"]', () => {
+            const code = 'const val = import.meta.env["MY_KEY"];';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'import.meta.env',
+            });
+        });
+        it("detects bracket notation with single quotes: import.meta.env['MY_KEY']", () => {
+            const code = "const val = import.meta.env['MY_KEY'];";
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'import.meta.env',
+            });
+        });
+    });
+    describe('Default include extensions', () => {
+        it('includes .mts in default scan extensions', () => {
+            expect(DEFAULT_INCLUDE_EXTENSIONS).toContain('.mts');
+        });
+        it('includes .cts in default scan extensions', () => {
+            expect(DEFAULT_INCLUDE_EXTENSIONS).toContain('.cts');
+        });
+        it('includes all expected extensions', () => {
+            expect(DEFAULT_INCLUDE_EXTENSIONS).toEqual(expect.arrayContaining([
+                '.js',
+                '.ts',
+                '.jsx',
+                '.tsx',
+                '.vue',
+                '.svelte',
+                '.mjs',
+                '.mts',
+                '.cjs',
+                '.cts',
+            ]));
+        });
+        it('will detect patterns in .mts files', () => {
+            const code = 'const val = process.env.MY_KEY;';
+            const result = scanFile('test.mts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'MY_KEY',
+                pattern: 'process.env',
+            });
+        });
+        it('will detect patterns in .vue files', () => {
+            const code = 'const val = import.meta.env.VITE_KEY;';
+            const result = scanFile('component.vue', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({ variable: 'VITE_KEY' });
+        });
+        it('will detect patterns in .svelte files', () => {
+            const code = "import { MY_VAR } from '$env/static/private';";
+            const result = scanFile('page.svelte', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({ variable: 'MY_VAR' });
+        });
+    });
+    describe('Default exclude patterns', () => {
+        it('excludes node_modules', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('node_modules');
+        });
+        it('excludes dist', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('dist');
+        });
+        it('excludes build', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('build');
+        });
+        it('excludes test files by extension', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('.test.');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('.spec.');
+        });
+        it('excludes __tests__ and __mocks__ directories', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('__tests__');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('__mocks__');
+        });
+        it('excludes framework build dirs', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('.next');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('.nuxt');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('.sveltekit');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('.svelte-kit');
+        });
+        it('excludes common fixture/sample paths', () => {
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('fixtures');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('examples');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('samples');
+            expect(DEFAULT_EXCLUDE_PATTERNS).toContain('sandbox');
+        });
+    });
+    describe('ENV_PATTERNS export', () => {
+        it('exports an array', () => {
+            expect(Array.isArray(ENV_PATTERNS)).toBe(true);
+        });
+        it('contains patterns for all three pattern names', () => {
+            const names = ENV_PATTERNS.map((p) => p.name);
+            expect(names).toContain('process.env');
+            expect(names).toContain('import.meta.env');
+            expect(names).toContain('sveltekit');
+        });
+        it('every pattern has a regex', () => {
+            for (const p of ENV_PATTERNS) {
+                expect(p.regex).toBeInstanceOf(RegExp);
+            }
+        });
+    });
+    describe('Processor branch coverage', () => {
+        // Helper to build a minimal RegExpExecArray
+        function makeMatch(fullMatch, ...groups) {
+            return Object.assign([fullMatch, ...groups], {
+                index: 0,
+                input: fullMatch,
+            });
+        }
+        it('process.env processor returns [] when both capture groups are undefined (line 31)', () => {
+            const processor = ENV_PATTERNS.find((p) => p.name === 'process.env' && p.regex.source.includes('\\['))?.processor;
+            expect(processor?.(makeMatch('process.env.', undefined, undefined))).toEqual([]);
+        });
+        it('process.env destructuring processor returns empty string for part starting with : (line 58)', () => {
+            // `:ALIAS` splits to key='' which is falsy → returns '' → filtered out by uppercase check
+            const code = 'const { :ALIAS } = process.env;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('import.meta.env processor returns [] when both capture groups are undefined (line 79)', () => {
+            const processor = ENV_PATTERNS.find((p) => p.name === 'import.meta.env')?.processor;
+            expect(processor?.(makeMatch('import.meta.env.', undefined, undefined))).toEqual([]);
+        });
+        it('env destructuring processor returns [] for empty braces: const {} = env (line 106)', () => {
+            const code = 'const {} = env;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('env destructuring processor returns empty string for part starting with : (line 117)', () => {
+            // `:ALIAS` splits to key='' which is falsy → returns '' → filtered out by uppercase check
+            const code = 'const { :ALIAS } = env;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+    });
+    describe('Pattern edge cases', () => {
+        it('does not detect lowercase process.env keys', () => {
+            const code = 'const val = process.env.myKey;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('does not detect lowercase import.meta.env keys', () => {
+            const code = 'const val = import.meta.env.myKey;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('does not match env.lowercase (sveltekit pattern requires uppercase)', () => {
+            const code = 'const val = env.myKey;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('detects keys with numbers: MY_KEY_123', () => {
+            const code = 'const val = process.env.MY_KEY_123;';
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({ variable: 'MY_KEY_123' });
+        });
+        it('detects multiple keys on different lines', () => {
+            const code = [
+                'const a = process.env.KEY_ONE;',
+                'const b = process.env.KEY_TWO;',
+            ].join('\n');
+            const result = scanFile('test.js', code, baseOpts);
+            expect(result).toHaveLength(2);
+            const variables = result.map((r) => r.variable).sort();
+            expect(variables).toEqual(['KEY_ONE', 'KEY_TWO']);
+        });
+    });
+    describe('SvelteKit Static Named Imports', () => {
+        it('detects import from $env/static/private', () => {
+            const code = "import { SECRET_KEY } from '$env/static/private';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'SECRET_KEY',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects import from $env/static/public', () => {
+            const code = "import { PUBLIC_API_URL } from '$env/static/public';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'PUBLIC_API_URL',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects import with double quotes', () => {
+            const code = 'import { SECRET_KEY } from "$env/static/private";';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({ variable: 'SECRET_KEY' });
+        });
+    });
+    describe('SvelteKit Invalid Dynamic Named Imports', () => {
+        it('detects invalid named import from $env/dynamic/private', () => {
+            const code = "import { SECRET_KEY } from '$env/dynamic/private';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'SECRET_KEY',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects invalid named import from $env/dynamic/public', () => {
+            const code = "import { PUBLIC_KEY } from '$env/dynamic/public';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'PUBLIC_KEY',
+                pattern: 'sveltekit',
+            });
+        });
+    });
+    describe('SvelteKit Invalid Default Imports', () => {
+        it('detects invalid default import from $env/static/private', () => {
+            const code = "import SECRET_KEY from '$env/static/private';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'SECRET_KEY',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects invalid default import from $env/static/public', () => {
+            const code = "import PUBLIC_URL from '$env/static/public';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'PUBLIC_URL',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects invalid default import from $env/dynamic/private', () => {
+            const code = "import SECRET_KEY from '$env/dynamic/private';";
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'SECRET_KEY',
+                pattern: 'sveltekit',
+            });
+        });
+    });
+    describe('buildSveltekitAliasPatterns', () => {
+        function makeMatch(fullMatch, ...groups) {
+            return Object.assign([fullMatch, ...groups], {
+                index: 0,
+                input: fullMatch,
+            });
+        }
+        it('returns two patterns for a given alias', () => {
+            const patterns = buildSveltekitAliasPatterns('privateEnv');
+            expect(patterns).toHaveLength(2);
+            expect(patterns[0]?.regex).toBeInstanceOf(RegExp);
+            expect(patterns[1]?.regex).toBeInstanceOf(RegExp);
+            expect(patterns.every((p) => p.name === 'sveltekit')).toBe(true);
+        });
+        it('dot notation pattern matches alias.VAR', () => {
+            const [dotPattern] = buildSveltekitAliasPatterns('privateEnv');
+            expect(dotPattern.regex.test('privateEnv.MY_SECRET')).toBe(true);
+            expect(dotPattern.regex.test('env.MY_SECRET')).toBe(false);
+        });
+        it('destructuring processor returns [] for empty content (if !content branch)', () => {
+            const [, destructurePattern] = buildSveltekitAliasPatterns('privateEnv');
+            const result = destructurePattern.processor(makeMatch('{}', ''));
+            expect(result).toEqual([]);
+        });
+        it('destructuring processor returns [] when content is undefined', () => {
+            const [, destructurePattern] = buildSveltekitAliasPatterns('privateEnv');
+            const result = destructurePattern.processor(makeMatch('{}', undefined));
+            expect(result).toEqual([]);
+        });
+        it('destructuring processor returns empty string for part starting with : (key falsy branch)', () => {
+            // ':ALIAS' splits to key='' which is falsy → '' → filtered by uppercase check
+            const code = `import { env as privateEnv } from '$env/dynamic/private';
+const { :ALIAS } = privateEnv;`;
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(0);
+        });
+        it('destructuring processor extracts multiple vars from aliased import', () => {
+            const code = `import { env as privateEnv } from '$env/dynamic/private';
+const { SECRET_KEY, API_TOKEN } = privateEnv;`;
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result.map((u) => u.variable).sort()).toEqual([
+                'API_TOKEN',
+                'SECRET_KEY',
+            ]);
+        });
+        it('destructuring processor handles aliased keys: { VAR: alias } = privateEnv', () => {
+            const code = `import { env as privateEnv } from '$env/dynamic/private';
+const { SECRET_KEY: secret } = privateEnv;`;
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]?.variable).toBe('SECRET_KEY');
+        });
+    });
+    describe('SvelteKit env Object Access', () => {
+        it('detects env.VARIABLE_NAME access', () => {
+            const code = 'const token = env.KEYCLOAK_SECRET;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'KEYCLOAK_SECRET',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects destructuring from env: const { VAR1, VAR2 } = env', () => {
+            const code = 'const { KEYCLOAK_URL, KEYCLOAK_REALM } = env;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(2);
+            const variables = result.map((u) => u.variable).sort();
+            expect(variables).toEqual(['KEYCLOAK_REALM', 'KEYCLOAK_URL']);
+        });
+        it('detects destructuring with aliasing: const { VAR: alias } = env', () => {
+            const code = 'const { KEYCLOAK_URL: url } = env;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'KEYCLOAK_URL',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects destructuring with default values: const { VAR = "default" } = env', () => {
+            const code = 'const { KEYCLOAK_URL = "http://localhost:8080" } = env;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                variable: 'KEYCLOAK_URL',
+                pattern: 'sveltekit',
+            });
+        });
+        it('detects multiple mixed destructuring from env', () => {
+            const code = 'const { KEYCLOAK_URL, KEYCLOAK_REALM: realm, CLIENT_SECRET = "default" } = env;';
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(3);
+            const variables = result.map((u) => u.variable).sort();
+            expect(variables).toEqual([
+                'CLIENT_SECRET',
+                'KEYCLOAK_REALM',
+                'KEYCLOAK_URL',
+            ]);
+        });
+        it('detects multiline destructuring from env', () => {
+            const code = `
+        const { 
+          KEYCLOAK_URL,
+          KEYCLOAK_REALM,
+          CLIENT_ID
+        } = env;
+      `;
+            const result = scanFile('test.ts', code, baseOpts);
+            expect(result).toHaveLength(3);
+            const variables = result.map((u) => u.variable).sort();
+            expect(variables).toEqual([
+                'CLIENT_ID',
+                'KEYCLOAK_REALM',
+                'KEYCLOAK_URL',
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=patterns.test.js.map