Tal500/legacy-builds revitalized 2026 bare merge

.changeset/mighty-carrots-whisper.md

@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': minor
+---
+
+[feat] add legacy support on JS bundling by auto-integrating with @vitejs/plugin-legacy

packages/kit/package.json

@@ -1,14 +1,16 @@
 {
-	"name": "@sveltejs/kit",
+	"name": "@tg-svelte/kit",
 	"version": "2.49.4",
-	"description": "SvelteKit is the fastest way to build Svelte apps",
+	"description": "SvelteKit fork with legacy browser support (IE11) and static builds",
 	"keywords": [
 		"framework",
 		"official",
 		"svelte",
 		"sveltekit",
 		"vite"
 	],
+	"author": "Shane Jaroch <chown_tee@proton.me>",
+	"contributors": ["Tal Hadad <tal_hd@hotmail.com>"],
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/sveltejs/kit.git",
@@ -133,5 +135,11 @@
 	"types": "types/index.d.ts",
 	"engines": {
 		"node": ">=18.13"
-	}
+	},
+	"browserslist": [
+		"> 0.05% and not ie < 11 and not safari < 10 and not chrome < 14",
+		"ie >= 11",
+		"chrome >= 14",
+		"safari >= 10"
+	]
 }

packages/kit/src/exports/vite/dev/index.js

@@ -145,10 +145,14 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 			_: {
 				client: {
 					start: `${runtime_base}/client/entry.js`,
+					legacy_start: undefined, // No legacy support in dev mode
 					app: `${to_fs(svelte_config.kit.outDir)}/generated/client/app.js`,
+					legacy_app: undefined,
 					imports: [],
 					stylesheets: [],
 					fonts: [],
+					legacy_polyfills_file: undefined,
+					modern_polyfills_file: undefined,
 					uses_env_dynamic_public: true,
 					nodes:
 						svelte_config.kit.router.resolution === 'client'

packages/kit/src/exports/vite/index.js

@@ -206,6 +206,8 @@ async function kit({ svelte_config }) {
 	/** @type {import('vite').ConfigEnv} */
 	let vite_config_env;
 
+	let output_count = 0;
+
 	/** @type {boolean} */
 	let is_build;
 
@@ -1015,7 +1017,7 @@ async function kit({ svelte_config }) {
 		},
 
 		/**
-		 * Vite builds a single bundle. We need three bundles: client, server, and service worker.
+		 * Vite builds a single bundle(or two on legacy). We need three bundles: client, server, and service worker.
 		 * The user's package.json scripts will invoke the Vite CLI to execute the server build. We
 		 * then use this hook to kick off builds for the client and service worker.
 		 */
@@ -1024,6 +1026,13 @@ async function kit({ svelte_config }) {
 			async handler(_options, bundle) {
 				if (secondary_build_started) return; // only run this once
 
+				++output_count;
+				const config_output = vite_config.build.rollupOptions.output;
+				const config_output_length = Array.isArray(config_output) ? config_output.length : 1;
+				if (output_count < config_output_length) {
+					return; // Wait untill all output will be done building, since we need the manifest
+				}
+
 				const verbose = vite_config.logLevel === 'info';
 				const log = logger({ verbose });
 
@@ -1084,25 +1093,29 @@ async function kit({ svelte_config }) {
 				let client_chunks;
 
 				try {
+					const getLastFlat = (/** @type {unknown} */ arrOrObj) =>
+						Array.isArray(arrOrObj) ? arrOrObj[arrOrObj.length - 1] : arrOrObj;
+
+					const buildResult = await vite.build({
+						configFile: vite_config.configFile,
+						// CLI args
+						mode: vite_config_env.mode,
+						logLevel: vite_config.logLevel,
+						clearScreen: vite_config.clearScreen,
+						build: {
+							minify: initial_config.build?.minify,
+							assetsInlineLimit: vite_config.build.assetsInlineLimit,
+							sourcemap: vite_config.build.sourcemap
+						},
+						optimizeDeps: {
+							force: vite_config.optimizeDeps.force
+						}
+					});
 					const bundle = /** @type {import('vite').Rollup.RollupOutput} */ (
-						await vite.build({
-							configFile: vite_config.configFile,
-							// CLI args
-							mode: vite_config_env.mode,
-							logLevel: vite_config.logLevel,
-							clearScreen: vite_config.clearScreen,
-							build: {
-								minify: initial_config.build?.minify,
-								assetsInlineLimit: vite_config.build.assetsInlineLimit,
-								sourcemap: vite_config.build.sourcemap
-							},
-							optimizeDeps: {
-								force: vite_config.optimizeDeps.force
-							}
-						})
+						getLastFlat(buildResult)
 					);
 
-					client_chunks = bundle.output;
+					client_chunks = bundle.output || Object.values(bundle);
 				} catch (e) {
 					const error =
 						e instanceof Error ? e : new Error(/** @type {any} */ (e).message ?? e ?? '<unknown>');
@@ -1154,6 +1167,46 @@ async function kit({ svelte_config }) {
 				/** @type {import('vite').Manifest} */
 				const client_manifest = JSON.parse(read(`${out}/client/.vite/manifest.json`));
 
+				/**
+				 *
+				 * @param {string} entry
+				 */
+				const find_file_if_exist = (entry) =>
+					entry in client_manifest ? client_manifest[entry].file : null;
+
+				/**
+				 *
+				 * @param {string} dir
+				 * @param {string} entry_name
+				 * @returns {import('types').AssetDependenciesWithLegacy}
+				 */
+				const find_deps_with_optional_legacy = (dir, entry_name) => ({
+					...find_deps(
+						client_manifest,
+						posixify(path.relative('.', `${dir}/${entry_name}.js`)),
+						false
+					),
+					legacy_file: find_file_if_exist(
+						posixify(path.relative('.', `${dir}/${entry_name}-legacy.js`))
+					)
+				});
+
+				const start_deps = find_deps_with_optional_legacy(`${runtime_directory}/client`, 'entry');
+				const app_deps = find_deps_with_optional_legacy(`${kit.outDir}/generated/client-optimized`, 'app');
+
+				build_data.client = {
+					start: start_deps.file,
+					legacy_start: start_deps.legacy_file || undefined,
+					app: app_deps.file,
+					legacy_app: app_deps.legacy_file || undefined,
+					imports: [...start_deps.imports, ...app_deps.imports],
+					stylesheets: [...start_deps.stylesheets, ...app_deps.stylesheets],
+					fonts: [...start_deps.fonts, ...app_deps.fonts],
+					legacy_polyfills_file: find_file_if_exist('vite/legacy-polyfills-legacy') || undefined,
+					modern_polyfills_file: find_file_if_exist('vite/legacy-polyfills') || undefined,
+					uses_env_dynamic_public: false // Default to false if not split?
+				};
+
 				/**
 				 * @param {string} entry
 				 * @param {boolean} [add_dynamic_css]
@@ -1162,15 +1215,20 @@ async function kit({ svelte_config }) {
 					find_deps(client_manifest, posixify(path.relative('.', entry)), add_dynamic_css);
 
 				if (svelte_config.kit.output.bundleStrategy === 'split') {
-					const start = deps_of(`${runtime_directory}/client/entry.js`);
-					const app = deps_of(`${kit.outDir}/generated/client-optimized/app.js`);
+					// Legacy PR: Use the legacy-aware objects we created above, but ensure imports/stylesheets/fonts are merged
+					const start_legacy = find_deps_with_optional_legacy(`${runtime_directory}/client`, 'entry');
+					const app_legacy = find_deps_with_optional_legacy(`${kit.outDir}/generated/client-optimized`, 'app');
 
 					build_data.client = {
-						start: start.file,
-						app: app.file,
-						imports: [...start.imports, ...app.imports],
-						stylesheets: [...start.stylesheets, ...app.stylesheets],
-						fonts: [...start.fonts, ...app.fonts],
+						start: start_legacy.file,
+						legacy_start: start_legacy.legacy_file || undefined,
+						app: app_legacy.file,
+						legacy_app: app_legacy.legacy_file || undefined,
+						imports: [...start_legacy.imports, ...app_legacy.imports],
+						stylesheets: [...start_legacy.stylesheets, ...app_legacy.stylesheets],
+						fonts: [...start_legacy.fonts, ...app_legacy.fonts],
+						legacy_polyfills_file: find_file_if_exist('vite/legacy-polyfills-legacy') || undefined,
+						modern_polyfills_file: find_file_if_exist('vite/legacy-polyfills') || undefined,
 						uses_env_dynamic_public: client_chunks.some(
 							(chunk) => chunk.type === 'chunk' && chunk.modules[env_dynamic_public]
 						)
@@ -1192,25 +1250,27 @@ async function kit({ svelte_config }) {
 								return { file, css: deps.stylesheets };
 							}
 						});
-						build_data.client.nodes = nodes.map((node) => node?.file);
-						build_data.client.css = nodes.map((node) => node?.css);
-
-						build_data.client.routes = compact(
-							manifest_data.routes.map((route) => {
-								if (!route.page) return;
-
-								return {
-									id: route.id,
-									pattern: route.pattern,
-									params: route.params,
-									layouts: route.page.layouts.map((l) =>
-										l !== undefined ? [metadata.nodes[l].has_server_load, l] : undefined
-									),
-									errors: route.page.errors,
-									leaf: [metadata.nodes[route.page.leaf].has_server_load, route.page.leaf]
-								};
-							})
-						);
+						if (build_data.client) {
+							build_data.client.nodes = nodes.map((node) => node?.file);
+							build_data.client.css = nodes.map((node) => node?.css);
+
+							build_data.client.routes = compact(
+								manifest_data.routes.map((route) => {
+									if (!route.page) return;
+
+									return {
+										id: route.id,
+										pattern: route.pattern,
+										params: route.params,
+										layouts: route.page.layouts.map((l) =>
+											l !== undefined ? [metadata.nodes[l].has_server_load, l] : undefined
+										),
+										errors: route.page.errors,
+										leaf: [metadata.nodes[route.page.leaf].has_server_load, route.page.leaf]
+									};
+								})
+							);
+						}
 					}
 				} else {
 					const start = deps_of(`${runtime_directory}/client/bundle.js`);

packages/kit/src/runtime/app/forms.js

@@ -193,7 +193,11 @@ export function enhance(form_element, submit = () => {}) {
 				headers,
 				cache: 'no-store',
 				body,
-				signal: controller.signal
+				signal: controller.signal,
+				// Althought the default value of `credentials` is 'same-origin', we must specify it explicitly,
+				//  since the default value of the (recomended) `whatwg-fetch` polyfill is different (sadly :-( )),
+				//  and equals to 'omit' instead.
+				credentials: 'same-origin'
 			});
 
 			result = deserialize(await response.text());

packages/kit/src/runtime/client/client.js

@@ -2895,12 +2895,58 @@ async function load_data(url, invalid) {
 	// TODO: fix eslint error / figure out if it actually applies to our situation
 	// eslint-disable-next-line
 	return new Promise(async (resolve) => {
+		/**
+		 * Kinda support somehow legacy environments that don't support the Stream API.
+		 * @param {Response} response
+		 */
+		const sloppy_legacy_friendly_reader_decoder = (response) => {
+			if ('body' in response && typeof TextDecoder !== 'undefined') {
+				return {
+					reader: /** @type {ReadableStream<Uint8Array>} */ (res.body).getReader(),
+					decoder: /** @type {{decode: (value: BufferSource | string | undefined) => string}} */ (
+						new TextDecoder()
+					)
+				};
+			}
+			// otherwise, we're in a legacy environment that doesn't support `Response.body`, so we shall simulate it
+
+			/** @type {string[] | undefined} */
+			let text_lines = undefined;
+			let current_line = 0;
+
+			return {
+				reader: {
+					read: async () => {
+						if (text_lines === undefined) {
+							const text = await res.text();
+
+							// Split the string on \n or \r characters
+							text_lines = text.split(/\r?\n|\r|\n/g);
+						}
+
+						if (current_line >= text_lines.length) {
+							return { done: true, value: undefined };
+						} else {
+							return { done: false, value: text_lines[current_line++] };
+						}
+					}
+				},
+				decoder: {
+					/**
+					 *
+					 * @param {BufferSource | string | undefined} value
+					 */
+					decode: (value) => /** @type {string} */ (value)
+				}
+			};
+		};
+
 		/**
 		 * Map of deferred promises that will be resolved by a subsequent chunk of data
 		 * @type {Map<string, import('types').Deferred>}
 		 */
 		const deferreds = new Map();
-		const reader = /** @type {ReadableStream<Uint8Array>} */ (res.body).getReader();
+		const { reader } = sloppy_legacy_friendly_reader_decoder(res);
 
 		/**
 		 * @param {any} data
@@ -2923,7 +2969,12 @@ async function load_data(url, invalid) {
 			const { done, value } = await reader.read();
 			if (done && !text) break;
 
-			text += !value && text ? '\n' : text_decoder.decode(value, { stream: true }); // no value -> final chunk -> add a new line to trigger the last parse
+			text +=
+				!value && text
+					? '\n'
+					: typeof value === 'string'
+						? value
+						: text_decoder.decode(/** @type {any} */ (value), { stream: true }); // no value -> final chunk -> add a new line to trigger the last parse
 
 			while (true) {
 				const split = text.indexOf('\n');