@vigla/sveltekit 0.0.0-stage → 3.1.1

package/package.json

@@ -1,6 +1,53 @@
 {
-  "name": "@vigla/sveltekit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@vigla/sveltekit",
+	"version": "3.1.1",
+	"type": "module",
+	"types": "./types/index.d.ts",
+	"files": [
+		"dist",
+		"src",
+		"types"
+	],
+	"bin": {
+		"svelte-kit": "./dist/bin.js"
+	},
+	"vigla": {
+		"facade": "@vigla/kit"
+	},
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./internal/env": "./dist/internal/env.js",
+		"./internal/server": "./dist/internal/server.js",
+		"./internal/client": "./dist/internal/client.js",
+		"./internal/payload": "./dist/internal/payload.js",
+		"./internal/restore": "./dist/internal/restore.js",
+		"./adapter": {
+			"types": "./dist/types/adapter.d.ts",
+			"default": "./dist/adapter.js"
+		},
+		"./node": "./dist/node.js",
+		"./hooks": {
+			"types": "./dist/types/hooks.d.ts",
+			"default": "./dist/hooks.js"
+		},
+		"./env": "./dist/env.js",
+		"./params": {
+			"types": "./dist/types/params.d.ts",
+			"default": "./dist/params.js"
+		},
+		"./vite": "./dist/vite.js"
+	},
+	"dependencies": {
+		"@vigla/kit": "0.1.1",
+		"@vigla/vite-plugin-svelte": "7.3.2",
+		"esm-env": "^1.2.2"
+	},
+	"peerDependencies": {
+		"svelte": "^5.57.1",
+		"vite": "^8.0.12"
+	}
+}

package/src/adapter.ts

@@ -0,0 +1,7 @@
+import type { applyReroute as kitApplyReroute } from '@vigla/kit/adapter';
+import { rerouter } from '@vigla/kit/internal/identity';
+import { identity } from './identity.ts';
+
+export * from '@vigla/kit/adapter';
+
+export const applyReroute: typeof kitApplyReroute = rerouter(identity);

package/src/bin.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { cli } from '@vigla/kit/cli';
+import { identity } from './identity.ts';
+
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+await cli(process.argv.slice(2), version, identity);

package/src/env.ts

@@ -0,0 +1 @@
+export * from '@vigla/kit/env';

package/src/history/adapter.ts

@@ -0,0 +1,44 @@
+import type { Adapter, Builder } from '@vigla/kit';
+import { throwDiagnostic, warnDiagnostic } from './diagnostics.ts';
+
+function generateManifest(): never {
+	throwDiagnostic(
+		'adapter_generate_manifest_removed',
+		'The `generateManifest` adapter API has been removed — use `generateServerInstance` or `builder.manifest` instead. You may need to update your adapter',
+		generateManifest
+	);
+}
+
+function configWithKit(config: Builder['config']): Builder['config'] {
+	let warned = false;
+	return Object.create(config, {
+		kit: {
+			get() {
+				if (!warned) {
+					warned = true;
+					warnDiagnostic(
+						'adapter_config_kit_deprecated',
+						'Reading `config.kit` inside adapters is deprecated — it should access configuration on the `config` object directly. You may need to update your adapter'
+					);
+				}
+				return config;
+			}
+		}
+	});
+}
+
+export function retiredBuilder(adapter: Adapter | undefined): Adapter | undefined {
+	if (typeof adapter?.adapt !== 'function') return adapter;
+	const { adapt } = adapter;
+	return {
+		...adapter,
+		adapt: (builder: Builder) =>
+			adapt.call(
+				adapter,
+				Object.create(builder, {
+					generateManifest: { value: generateManifest },
+					config: { value: configWithKit(builder.config) }
+				})
+			)
+	};
+}

package/src/history/app/forms.ts

@@ -0,0 +1,42 @@
+import { DEV } from 'esm-env';
+import { enhance as enhanceForm, type FormUpdateOptions, type SubmitFunction } from '$app/forms';
+import { warnDiagnostic } from '../diagnostics.ts';
+
+export * from '$app/forms';
+
+interface Submission {
+	update(options?: FormUpdateOptions): Promise<void>;
+}
+
+type Callback = (submission: Submission) => unknown;
+
+function current(options?: FormUpdateOptions): FormUpdateOptions | undefined {
+	if (options?.invalidateAll === undefined) return options;
+	if (DEV)
+		warnDiagnostic(
+			'enhance_invalidate_all_deprecated',
+			'The `update({ invalidateAll })` option has been deprecated in favour of `update({ refreshAll })`'
+		);
+	const { invalidateAll, ...rest } = options;
+	return { ...rest, refreshAll: rest.refreshAll ?? invalidateAll };
+}
+
+function wrap(callback: unknown): unknown {
+	if (typeof callback !== 'function') return callback;
+	return (submission: Submission) =>
+		(callback as Callback)({
+			...submission,
+			update: (options) => submission.update(current(options))
+		});
+}
+
+export function enhance<
+	Success extends Record<string, unknown> | undefined,
+	Failure extends Record<string, unknown> | undefined
+>(
+	form: HTMLFormElement,
+	submit: SubmitFunction<Success, Failure> = () => {}
+): ReturnType<typeof enhanceForm> {
+	return enhanceForm<Success, Failure>(form, (async (input) =>
+		wrap(await submit(input))) as SubmitFunction<Success, Failure>);
+}

package/src/history/app/hooks.ts

@@ -0,0 +1,45 @@
+import { DEV } from 'esm-env';
+import { warnDiagnostic } from '../diagnostics.ts';
+
+interface ErrorInput {
+	kind: string;
+	error: unknown;
+}
+
+interface Fallback {
+	status: number;
+	message: string;
+}
+
+type HandleError = (input: ErrorInput) => unknown;
+
+export function retiredProperties(handle: HandleError | undefined): HandleError | undefined {
+	if (!DEV || !handle) return handle;
+	return (input) => {
+		const fallback: Fallback =
+			input.kind === 'unknown'
+				? { status: 500, message: 'Internal Error' }
+				: (input.error as Fallback);
+		Object.defineProperties(input, {
+			status: {
+				get() {
+					warnDiagnostic(
+						'handle_error_status_deprecated',
+						'The `status` property of `handleError` is deprecated. Use `error.status` for expected and framework errors, or `500` for unexpected errors.'
+					);
+					return fallback.status;
+				}
+			},
+			message: {
+				get() {
+					warnDiagnostic(
+						'handle_error_message_deprecated',
+						"The `message` property of `handleError` is deprecated. Use `error.message` for expected and framework errors, or `'Internal Error'` for unexpected errors."
+					);
+					return fallback.message;
+				}
+			}
+		});
+		return handle(input);
+	};
+}

package/src/history/app/navigation.server.ts

@@ -0,0 +1,11 @@
+import { shallow } from '@vigla/kit/internal/shallow';
+
+export * from '$app/navigation';
+
+export function pushState(url: string | URL, state: App.PageState): never {
+	return shallow('pushState', url, state);
+}
+
+export function replaceState(url: string | URL, state: App.PageState): never {
+	return shallow('replaceState', url, state);
+}

package/src/history/app/navigation.ts

@@ -0,0 +1,65 @@
+import { DEV } from 'esm-env';
+import { goto as navigate, type GotoOptions } from '$app/navigation';
+import { shallow } from '@vigla/kit/internal/shallow';
+import { throwDiagnostic, warnDiagnostic } from '../diagnostics.ts';
+
+export * from '$app/navigation';
+
+interface RetiredGotoOptions extends GotoOptions {
+	noScroll?: boolean;
+	keepFocus?: boolean;
+}
+
+const warned = new Set<string>();
+
+function warnOnce(code: string, text: string): void {
+	if (warned.has(code)) return;
+	warned.add(code);
+	warnDiagnostic(code, text);
+}
+
+export async function goto(url: string | URL, options: RetiredGotoOptions = {}): Promise<void> {
+	const { replaceState, invalidateAll, noScroll, keepFocus, ...current } = options;
+	if (DEV) {
+		if ('replaceState' in options)
+			warnOnce(
+				'goto_replace_state_deprecated',
+				`The \`goto(..., { replaceState: ${String(replaceState)} })\` option has been deprecated in favour of \`replace\``
+			);
+		if ('noScroll' in options || 'keepFocus' in options)
+			throwDiagnostic(
+				'goto_options_removed',
+				'The `goto(..., { noScroll: true, keepFocus: true })` options have been replaced by `reset: false`',
+				goto
+			);
+	}
+	const navigation = navigate(url, {
+		...current,
+		replace: current.replace ?? replaceState,
+		refreshAll: current.refreshAll ?? invalidateAll
+	});
+	if (!DEV || !('invalidateAll' in options) || current.shallow) return navigation;
+	await navigation;
+	warnOnce(
+		'goto_invalidate_all_deprecated',
+		`The \`goto(..., { invalidateAll: ${String(invalidateAll)} })\` option has been deprecated in favour of \`refreshAll\``
+	);
+}
+
+export async function pushState(url: string | URL, state: App.PageState): Promise<void> {
+	if (DEV)
+		warnOnce(
+			'push_state_deprecated',
+			'`pushState(...)` is deprecated. Use `goto(url, { state, shallow: true })` instead.'
+		);
+	return shallow('pushState', url, state);
+}
+
+export async function replaceState(url: string | URL, state: App.PageState): Promise<void> {
+	if (DEV)
+		warnOnce(
+			'replace_state_deprecated',
+			'`replaceState(...)` is deprecated. Use `goto(url, { state, shallow: true, replace: true })` instead.'
+		);
+	return shallow('replaceState', url, state);
+}

package/src/history/app/paths.ts

@@ -0,0 +1,17 @@
+import { DEV } from 'esm-env';
+import { asset as resolveAsset } from '$app/paths';
+import type { AssetPath } from '$app/types';
+import { warnDiagnostic } from '../diagnostics.ts';
+
+export * from '$app/paths';
+
+export function asset(file: AssetPath): string {
+	if (!file.startsWith('/')) return resolveAsset(file);
+	const fixed = file.slice(1) as AssetPath;
+	if (DEV)
+		warnDiagnostic(
+			'asset_leading_slash',
+			`\`asset('${file}')\` should now be \`asset('${fixed}')\``
+		);
+	return resolveAsset(fixed);
+}

package/src/history/components.ts

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import type { Plugin } from 'vite';
+import { identity } from '../identity.ts';
+import { warnDiagnostic } from './diagnostics.ts';
+
+type Mode = 'code' | 'single' | 'double' | 'template' | 'line' | 'block' | 'html';
+
+const quotes: Partial<Record<Mode, string>> = { single: "'", double: '"', template: '`' };
+const pageOption = /(export\s+const\s+(prerender|csr|ssr|trailingSlash))\s*=/s;
+const scripts = /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+const warned = new Set<string>();
+const docs = 'https://svelte.dev/docs/kit/';
+
+function insideStringOrComment(source: string, end: number): boolean {
+	let mode: Mode = 'code';
+	for (let index = 0; index < end; index++) {
+		const char = source[index]!;
+		const pair = source.slice(index, index + 2);
+		if (mode === 'line') {
+			if (char === '\n') mode = 'code';
+		} else if (mode === 'block') {
+			if (pair === '*/') {
+				mode = 'code';
+				index++;
+			}
+		} else if (mode === 'html') {
+			if (source.startsWith('-->', index)) {
+				mode = 'code';
+				index += 2;
+			}
+		} else if (mode !== 'code') {
+			if (char === '\\') index++;
+			else if (char === quotes[mode]) mode = 'code';
+		} else if (char === "'") mode = 'single';
+		else if (char === '"') mode = 'double';
+		else if (char === '`') mode = 'template';
+		else if (pair === '//') {
+			mode = 'line';
+			index++;
+		} else if (pair === '/*') {
+			mode = 'block';
+			index++;
+		} else if (source.startsWith('<!--', index)) {
+			mode = 'html';
+			index += 3;
+		}
+	}
+	return mode !== 'code';
+}
+
+function hasChildren(source: string): boolean {
+	return (
+		source.includes('<slot') ||
+		source.includes('{@render') ||
+		source.includes('{children}') ||
+		source.includes('children={')
+	);
+}
+
+function once(key: string, warn: () => void): void {
+	if (warned.has(key)) return;
+	warned.add(key);
+	warn();
+}
+
+export function componentWarnings(): Plugin {
+	return {
+		name: `${identity.name}:history-components`,
+		transform: {
+			filter: { id: /[/\\]\+(?:page|layout)[^/\\]*\.svelte$/ },
+			handler(code, id) {
+				const name = path.basename(id.split('?')[0]!);
+				const file = path.relative(process.cwd(), id.split('?')[0]!);
+				for (const script of code.matchAll(scripts)) {
+					const content = script[1]!;
+					const match = pageOption.exec(content);
+					if (match && !insideStringOrComment(content, match.index))
+						once(`page_option_in_component:${file}:${match[1]}`, () =>
+							warnDiagnostic(
+								'page_option_in_component',
+								`\`${file}\`: \`${match[1]}\` will be ignored — move it to \`${name.replace('.svelte', '(.server).js/ts')}\` instead. See ${docs}page-options for more information.`
+							)
+						);
+				}
+				if (name.startsWith('+layout.') && !hasChildren(code))
+					once(`layout_children_missing:${file}`, () =>
+						warnDiagnostic(
+							'layout_children_missing',
+							`\`${file}\`: \`<slot />\` or \`{@render ...}\` tag missing — inner content will not be rendered`
+						)
+					);
+				return null;
+			}
+		}
+	};
+}

package/src/history/config.ts

@@ -0,0 +1,126 @@
+import { identity } from '../identity.ts';
+import { throwDiagnostic, warnDiagnostic } from './diagnostics.ts';
+
+type Step = [path: string, check: (keypath: string, value: unknown) => void];
+
+const docs = 'https://svelte.dev/docs/kit/';
+
+function removed(code: string, text: (keypath: string) => string): Step[1] {
+	return (keypath) => throwDiagnostic(code, text(keypath), removed);
+}
+
+const generic = removed(
+	'config_option_removed',
+	(keypath) =>
+		`The \`${keypath}\` option has been removed. Please see the list of breaking changes for your major release`
+);
+
+const steps: Step[] = [
+	[
+		'alias',
+		(keypath) =>
+			warnDiagnostic(
+				'config_option_deprecated_alias',
+				`The \`${keypath}\` option is deprecated, and will be removed in a future version of ${identity.product}. Use subpath imports instead: ${docs}$lib`
+			)
+	],
+	[
+		'csrf.checkOrigin',
+		removed(
+			'config_option_removed_check_origin',
+			(keypath) => `\`${keypath}\` has been removed in favour of \`csrf.trustedOrigins\``
+		)
+	],
+	[
+		'experimental.tracing',
+		removed(
+			'config_option_removed_experimental_tracing',
+			(keypath) =>
+				`\`${keypath}\` has been removed. Server-side tracing is now configured via \`tracing.server\``
+		)
+	],
+	[
+		'experimental.instrumentation',
+		removed(
+			'config_option_removed_experimental_instrumentation',
+			(keypath) =>
+				`\`${keypath}\` has been removed. \`src/instrumentation.server.js\` is now included in the build automatically when it exists; no opt-in is required`
+		)
+	],
+	['experimental.handleRenderingErrors', generic],
+	[
+		'files.lib',
+		removed(
+			'config_option_removed_files_lib',
+			(keypath) => `\`${keypath}\` has been removed. Use \`#lib\` instead of \`$lib\`: ${docs}$lib`
+		)
+	],
+	[
+		'kit',
+		(_, value) =>
+			throwDiagnostic(
+				'config_kit_namespace',
+				`${identity.product} configuration (${Object.keys(value as object)
+					.map((key) => `\`${key}\``)
+					.join(
+						', '
+					)}) no longer lives inside a \`kit\` namespace. Pass it directly to the \`${identity.plugin}(...)\` Vite plugin`,
+				checkConfig
+			)
+	],
+	[
+		'output.preloadStrategy',
+		removed(
+			'config_option_removed_preload_strategy',
+			(keypath) => `\`${keypath}\` has been removed. \`modulepreload\` will always be used`
+		)
+	],
+	[
+		'prerender.origin',
+		removed(
+			'config_option_removed_prerender_origin',
+			(keypath) => `\`${keypath}\` has been removed in favour of \`config.paths.origin\``
+		)
+	],
+	['serviceWorker.files', generic],
+	[
+		'typescript',
+		(keypath) =>
+			warnDiagnostic(
+				'config_option_deprecated_typescript',
+				`The \`${keypath}\` option is deprecated, and will be removed in a future version. Add configuration to \`tsconfig.json\` directly`
+			)
+	],
+	[
+		'vitePlugin',
+		removed(
+			'config_option_removed_vite_plugin',
+			(keypath) =>
+				`\`${keypath}\` has been removed. Pass plugin options directly to the \`${identity.plugin}(...)\` Vite plugin`
+		)
+	]
+];
+
+function read(config: object, path: string): unknown {
+	let value: unknown = config;
+	for (const key of path.split('.')) {
+		if (!value || typeof value !== 'object') return undefined;
+		value = (value as Record<string, unknown>)[key];
+	}
+	return value;
+}
+
+export function checkConfig(config: unknown): void {
+	if (!config || typeof config !== 'object' || Array.isArray(config)) return;
+	try {
+		for (const [path, check] of steps) {
+			const value = read(config, path);
+			if (value !== undefined) check(`config.${path}`, value);
+		}
+	} catch (error) {
+		console.log(`\n${error instanceof Error ? error.message : String(error)}\n`);
+		const failure = new Error(`Failed to load ${identity.product} options from Vite config`);
+		failure.stack = '';
+		throw failure;
+	}
+}

package/src/history/diagnostics.ts

@@ -0,0 +1,24 @@
+import { identity } from '../identity.ts';
+
+export function diagnosticText(code: string, text: string): string {
+	return `${code}\n${text}\n${identity.diagnostics}${code}`;
+}
+
+export function throwDiagnostic(code: string, text: string, caller: Function): never {
+	const error = new Error(diagnosticText(code, text));
+	error.name = `${identity.product} error`;
+	Error.captureStackTrace?.(error, caller);
+	throw error;
+}
+
+export function warningSource(code: string, text: string): string {
+	return `console.warn(${JSON.stringify(`%c[${identity.name}] ${diagnosticText(code, text).replace('\n', '\n%c')}`)}, 'font-weight: bold', 'font-weight: normal');`;
+}
+
+export function warnDiagnostic(code: string, text: string): void {
+	console.warn(
+		`%c[${identity.name}] ${code}\n%c${text}\n${identity.diagnostics}${code}`,
+		'font-weight: bold',
+		'font-weight: normal'
+	);
+}