@sveltejs/vite-plugin-svelte 2.2.0 → 2.4.0

package/src/utils/__tests__/sourcemaps.spec.ts

@@ -1,79 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { removeLangSuffix, mapToRelative } from '../sourcemaps';
-import { lang_sep } from '../../preprocess';
-import { normalizePath } from 'vite';
-import path from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-
-const fixtureDir = normalizePath(
-	path.join(path.dirname(fileURLToPath(import.meta.url)), 'fixtures', 'preprocess')
-);
-const filename = 'File.svelte';
-
-describe('removeLangSuffix', () => {
-	it('removes suffix', () => {
-		const suffix = `${lang_sep}scss`;
-		const map = {
-			file: `${fixtureDir}/${filename}${suffix}`,
-			sources: ['foo.scss', `${fixtureDir}/${filename}${suffix}`],
-			sourceRoot: fixtureDir
-		};
-		removeLangSuffix(map, suffix);
-		expect(map.file).toBe(`${fixtureDir}/${filename}`);
-		expect(map.sourceRoot).toBe(fixtureDir);
-		expect(map.sources[0]).toBe('foo.scss');
-		expect(map.sources[1]).toBe(`${fixtureDir}/${filename}`);
-	});
-});
-
-describe('mapToRelative', () => {
-	it('converts absolute to relative', () => {
-		const file = `${fixtureDir}/File.svelte`;
-		const map = {
-			file,
-			sources: [`${fixtureDir}/foo.scss`, file]
-		};
-		mapToRelative(map, file);
-		expect(map.file).toBe('File.svelte');
-		expect(map.sources[0]).toBe('foo.scss');
-		expect(map.sources[1]).toBe('File.svelte');
-	});
-
-	it('accounts for sourceRoot', () => {
-		const file = `${fixtureDir}/File.svelte`;
-		const sourceRoot = normalizePath(path.resolve(fixtureDir, '..'));
-		const rootedBase = fixtureDir.replace(sourceRoot, '');
-		const map = {
-			file,
-			sourceRoot,
-			sources: [
-				`${rootedBase}/foo.scss`,
-				`${rootedBase}/File.svelte`,
-				`${pathToFileURL(`${fixtureDir}/bar.scss`)}`
-			]
-		};
-		mapToRelative(map, file);
-		expect(map.file).toBe('File.svelte');
-		expect(map.sources[0]).toBe('foo.scss');
-		expect(map.sources[1]).toBe('File.svelte');
-		expect(map.sources[2]).toBe('bar.scss');
-		expect(map.sources.length).toBe(3);
-		expect(map.sourceRoot).not.toBeDefined();
-	});
-
-	it('accounts for relative sourceRoot', () => {
-		const file = `${fixtureDir}/File.svelte`;
-		const map = {
-			file,
-			sourceRoot: './some-path/..',
-			sources: [`foo.scss`, `File.svelte`, `${pathToFileURL(`${fixtureDir}/bar.scss`)}`]
-		};
-		mapToRelative(map, file);
-		expect(map.file).toBe('File.svelte');
-		expect(map.sources[0]).toBe('./some-path/../foo.scss');
-		expect(map.sources[1]).toBe('./some-path/../File.svelte');
-		expect(map.sources[2]).toBe('bar.scss');
-		expect(map.sources.length).toBe(3);
-		expect(map.sourceRoot).not.toBeDefined();
-	});
-});

package/src/utils/__tests__/svelte-version.spec.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { compareToSvelte, atLeastSvelte, parseVersion } from '../svelte-version';
-import { VERSION } from 'svelte/compiler';
-const svelteVersion = parseVersion(VERSION);
-describe('svelte-version', () => {
-	describe('parseVersion', () => {
-		it('should fill major,minor,patch', () => {
-			expect(parseVersion('3')).toEqual([3, 0, 0]);
-			expect(parseVersion('3.1')).toEqual([3, 1, 0]);
-		});
-		it('should ignore additional segments', () => {
-			expect(parseVersion('1.2.3.4')).toEqual([1, 2, 3]);
-		});
-	});
-	describe('compareToSvelte', () => {
-		it('should return 0 for current', async () => {
-			expect(compareToSvelte(VERSION)).toBe(0);
-		});
-
-		it('should return 1 for patch bump', async () => {
-			const patch = svelteVersion.concat();
-			patch[2] += 1;
-			const patchBump = patch.join('.');
-			expect(compareToSvelte(patchBump)).toBe(1);
-		});
-		it('should return 1 for minor bump', async () => {
-			const minor = svelteVersion.concat();
-			minor[1] += 1;
-			const minorBump = minor.join('.');
-			expect(compareToSvelte(minorBump)).toBe(1);
-		});
-		it('should return 1 for major bump', async () => {
-			const major = svelteVersion.concat();
-			major[0] += 1;
-			const majorBump = major.join('.');
-			expect(compareToSvelte(majorBump)).toBe(1);
-		});
-
-		it('should return -1 for lower patch', async () => {
-			const patch = svelteVersion.concat();
-			patch[2] -= 1;
-			const lowerPatch = patch.join('.');
-			expect(compareToSvelte(lowerPatch)).toBe(-1);
-		});
-		it('should return -1 for lower minor', async () => {
-			const minor = svelteVersion.concat();
-			minor[1] -= 1;
-			const lowerMinor = minor.join('.');
-			expect(compareToSvelte(lowerMinor)).toBe(-1);
-		});
-		it('should return -1 for lower major', async () => {
-			const major = svelteVersion.concat();
-			major[0] -= 1;
-			const lowerMajor = major.join('.');
-			expect(compareToSvelte(lowerMajor)).toBe(-1);
-		});
-	});
-
-	describe('atLeastSvelte', () => {
-		it('should return true for current', async () => {
-			expect(atLeastSvelte(VERSION)).toBe(true);
-		});
-
-		it('should return false for higher patch', async () => {
-			const patch = svelteVersion.concat();
-			patch[2] += 1;
-			const patchBump = patch.join('.');
-			expect(atLeastSvelte(patchBump)).toBe(false);
-		});
-		it('should return false for higher minor', async () => {
-			const minor = svelteVersion.concat();
-			minor[1] += 1;
-			const minorBump = minor.join('.');
-			expect(atLeastSvelte(minorBump)).toBe(false);
-		});
-		it('should return false for higher major', async () => {
-			const major = svelteVersion.concat();
-			major[0] += 1;
-			const majorBump = major.join('.');
-			expect(atLeastSvelte(majorBump)).toBe(false);
-		});
-
-		it('should return true for lower patch', async () => {
-			const patch = svelteVersion.concat();
-			patch[2] -= 1;
-			const lowerPatch = patch.join('.');
-			expect(atLeastSvelte(lowerPatch)).toBe(true);
-		});
-		it('should return true for lower minor', async () => {
-			const minor = svelteVersion.concat();
-			minor[1] -= 1;
-			const lowerMinor = minor.join('.');
-			expect(atLeastSvelte(lowerMinor)).toBe(true);
-		});
-		it('should return true for lower major', async () => {
-			const major = svelteVersion.concat();
-			major[0] -= 1;
-			const lowerMajor = major.join('.');
-			expect(atLeastSvelte(lowerMajor)).toBe(true);
-		});
-	});
-});

package/src/utils/vite-plugin-svelte-cache.ts

@@ -1,182 +0,0 @@
-import { SvelteRequest } from './id';
-import { Code, CompileData } from './compile';
-import { readFileSync } from 'fs';
-import { dirname } from 'path';
-//eslint-disable-next-line node/no-missing-import
-import { findClosestPkgJsonPath } from 'vitefu';
-import { normalizePath } from 'vite';
-
-interface PackageInfo {
-	name: string;
-	version: string;
-	svelte?: string;
-	path: string;
-}
-
-export class VitePluginSvelteCache {
-	private _css = new Map<string, Code>();
-	private _js = new Map<string, Code>();
-	private _dependencies = new Map<string, string[]>();
-	private _dependants = new Map<string, Set<string>>();
-	private _resolvedSvelteFields = new Map<string, string>();
-	private _errors = new Map<string, any>();
-	private _packageInfos: PackageInfo[] = [];
-
-	public update(compileData: CompileData) {
-		this._errors.delete(compileData.normalizedFilename);
-		this.updateCSS(compileData);
-		this.updateJS(compileData);
-		this.updateDependencies(compileData);
-	}
-
-	public has(svelteRequest: SvelteRequest) {
-		const id = svelteRequest.normalizedFilename;
-		return this._errors.has(id) || this._js.has(id) || this._css.has(id);
-	}
-
-	public setError(svelteRequest: SvelteRequest, error: any) {
-		// keep dependency info, otherwise errors in dependants would not trigger an update after fixing
-		// because they are no longer watched
-		this.remove(svelteRequest, true);
-		this._errors.set(svelteRequest.normalizedFilename, error);
-	}
-
-	private updateCSS(compileData: CompileData) {
-		this._css.set(compileData.normalizedFilename, compileData.compiled.css);
-	}
-
-	private updateJS(compileData: CompileData) {
-		if (!compileData.ssr) {
-			// do not cache SSR js
-			this._js.set(compileData.normalizedFilename, compileData.compiled.js);
-		}
-	}
-
-	private updateDependencies(compileData: CompileData) {
-		const id = compileData.normalizedFilename;
-		const prevDependencies = this._dependencies.get(id) || [];
-		const dependencies = compileData.dependencies;
-		this._dependencies.set(id, dependencies);
-		const removed = prevDependencies.filter((d) => !dependencies.includes(d));
-		const added = dependencies.filter((d) => !prevDependencies.includes(d));
-		added.forEach((d) => {
-			if (!this._dependants.has(d)) {
-				this._dependants.set(d, new Set<string>());
-			}
-			this._dependants.get(d)!.add(compileData.filename);
-		});
-		removed.forEach((d) => {
-			this._dependants.get(d)!.delete(compileData.filename);
-		});
-	}
-
-	public remove(svelteRequest: SvelteRequest, keepDependencies: boolean = false): boolean {
-		const id = svelteRequest.normalizedFilename;
-		let removed = false;
-		if (this._errors.delete(id)) {
-			removed = true;
-		}
-		if (this._js.delete(id)) {
-			removed = true;
-		}
-		if (this._css.delete(id)) {
-			removed = true;
-		}
-		if (!keepDependencies) {
-			const dependencies = this._dependencies.get(id);
-			if (dependencies) {
-				removed = true;
-				dependencies.forEach((d) => {
-					const dependants = this._dependants.get(d);
-					if (dependants && dependants.has(svelteRequest.filename)) {
-						dependants.delete(svelteRequest.filename);
-					}
-				});
-				this._dependencies.delete(id);
-			}
-		}
-
-		return removed;
-	}
-
-	public getCSS(svelteRequest: SvelteRequest) {
-		return this._css.get(svelteRequest.normalizedFilename);
-	}
-
-	public getJS(svelteRequest: SvelteRequest) {
-		if (!svelteRequest.ssr) {
-			// SSR js isn't cached
-			return this._js.get(svelteRequest.normalizedFilename);
-		}
-	}
-
-	public getError(svelteRequest: SvelteRequest) {
-		return this._errors.get(svelteRequest.normalizedFilename);
-	}
-
-	public getDependants(path: string): string[] {
-		const dependants = this._dependants.get(path);
-		return dependants ? [...dependants] : [];
-	}
-
-	public getResolvedSvelteField(name: string, importer?: string): string | void {
-		return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
-	}
-
-	public hasResolvedSvelteField(name: string, importer?: string) {
-		return this._resolvedSvelteFields.has(this._getResolvedSvelteFieldKey(name, importer));
-	}
-	public setResolvedSvelteField(
-		importee: string,
-		importer: string | undefined = undefined,
-		resolvedSvelte: string
-	) {
-		this._resolvedSvelteFields.set(
-			this._getResolvedSvelteFieldKey(importee, importer),
-			resolvedSvelte
-		);
-	}
-
-	private _getResolvedSvelteFieldKey(importee: string, importer?: string): string {
-		return importer ? `${importer} > ${importee}` : importee;
-	}
-
-	public async getPackageInfo(file: string): Promise<PackageInfo> {
-		let info = this._packageInfos.find((pi) => file.startsWith(pi.path));
-		if (!info) {
-			info = await findPackageInfo(file);
-			this._packageInfos.push(info);
-		}
-		return info;
-	}
-}
-
-/**
- * utility to get some info from the closest package.json with a "name" set
- *
- * @param {string} file to find info for
- * @returns {PackageInfo}
- */
-async function findPackageInfo(file: string): Promise<PackageInfo> {
-	const info: PackageInfo = {
-		name: '$unknown',
-		version: '0.0.0-unknown',
-		path: '$unknown'
-	};
-	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
-		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-		if (pkg.name != null) {
-			info.name = pkg.name;
-			if (pkg.version != null) {
-				info.version = pkg.version;
-			}
-			info.svelte = pkg.svelte;
-			return true;
-		}
-		return false;
-	});
-	// return normalized path with appended '/' so .startsWith works for future file checks
-	path = normalizePath(dirname(path ?? file)) + '/';
-	info.path = path;
-	return info;
-}