@vigla/sveltekit 0.0.0-stage → 3.1.0

package/src/history/plugin.ts

@@ -0,0 +1,151 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { Plugin } from 'vite';
+import { identity } from '../identity.ts';
+import { diagnosticText, throwDiagnostic, warningSource } from './diagnostics.ts';
+
+const prefix = `\0${identity.name}:`;
+const docs = 'https://svelte.dev/docs/kit/';
+const legacyEnvironment = /^\$env\/(static|dynamic)\/(public|private)$/;
+const extension = path.extname(fileURLToPath(import.meta.url));
+const wrapper = (name: string) =>
+	fileURLToPath(new URL(`./app/${name}${extension}`, import.meta.url));
+const wrapped = new Map(
+	['navigation', 'paths', 'forms'].map((name) => [
+		`$app/${name}`,
+		{ client: wrapper(name), server: wrapper(name === 'navigation' ? 'navigation.server' : name) }
+	])
+);
+const wrappers = new Set([...wrapped.values()].flatMap(({ client, server }) => [client, server]));
+const handleErrorWrapper = fileURLToPath(new URL(`./app/hooks${extension}`, import.meta.url));
+
+function removedModule(id: string, aliases: Record<string, string>): void {
+	const name = id.startsWith('$lib') ? '$lib' : '$service-worker';
+	if (name in aliases || `${name}/*` in aliases) return;
+	if (name === '$lib')
+		throwDiagnostic(
+			'module_removed_lib',
+			`\`$lib\` has been removed. Use \`#lib\` instead: ${docs}$lib. To keep using \`$lib\`, add \`alias: { '$lib': 'src/lib' }\` to your ${identity.product} config.`,
+			removedModule
+		);
+	throwDiagnostic(
+		'module_removed_service_worker',
+		`\`$service-worker\` has been removed. Use \`immutable\`, \`assets\` and \`prerendered\` from \`$app/manifest\`, \`version\` from \`$app/env\`, and \`resolve(...)\` from \`$app/paths\` instead: ${docs}$service-worker`,
+		removedModule
+	);
+}
+
+function stores(dev: boolean): string {
+	const message = dev
+		? diagnosticText(
+				'app_stores_removed',
+				'`$app/stores` has been removed in favour of `$app/state`'
+			)
+		: `${identity.diagnostics}app_stores_removed`;
+	return `function removed() { const error = new Error(${JSON.stringify(message)}); ${dev ? `error.name = ${JSON.stringify(`${identity.product} error`)}; ` : ''}throw error; }
+export const getStores = removed;
+export const page = { subscribe: removed };
+export const navigating = { subscribe: removed };
+export const updated = { subscribe: removed, check: removed };`;
+}
+
+function environment(dev: boolean, client: boolean): string {
+	const warning =
+		dev && client
+			? warningSource(
+					'app_environment_deprecated',
+					'`$app/environment` is deprecated, use `$app/env` instead'
+				)
+			: '';
+	return `export { browser, dev, building, version } from '$app/env';\n${warning}`;
+}
+
+function legacy(kind: string, visibility: string, dev: boolean): string {
+	const target = `$app/env/${visibility}`;
+	const exports =
+		kind === 'dynamic'
+			? `import * as env from ${JSON.stringify(target)}; export { env };`
+			: `export * from ${JSON.stringify(target)};`;
+	const warning = dev
+		? warningSource(
+				'env_module_deprecated',
+				`\`$env/${kind}/${visibility}\` is deprecated, use \`${target}\` instead`
+			)
+		: '';
+	return `${exports}\n${warning}`;
+}
+
+export type HookEntries = Record<'server' | 'client', string | null>;
+
+export function appModules(entries: () => HookEntries): Plugin {
+	const hooks = `${prefix}hooks:`;
+	return {
+		name: `${identity.name}:history-app`,
+		enforce: 'pre',
+		resolveId(id, importer) {
+			const target = wrapped.get(id);
+			if (target && !wrappers.has(importer?.split('?')[0] ?? ''))
+				return this.environment.config.consumer === 'server' ? target.server : target.client;
+			if (importer?.startsWith(hooks) || !path.isAbsolute(id)) return;
+			const { server, client } = entries();
+			if (id === server || id === client) return hooks + id;
+		},
+		load(id) {
+			if (!id.startsWith(hooks)) return;
+			const file = JSON.stringify(id.slice(hooks.length));
+			return `import * as hooks from ${file};\nimport { retiredProperties } from ${JSON.stringify(handleErrorWrapper)};\nexport * from ${file};\nexport const handleError = retiredProperties(hooks.handleError);`;
+		}
+	};
+}
+
+export function history(config: { alias?: Record<string, string> } = {}): Plugin {
+	let dev = false;
+	return {
+		name: `${identity.name}:history`,
+		config(user, env) {
+			dev = env.command === 'serve';
+			const root = path.resolve(user.root ?? process.cwd());
+			for (const file of ['svelte.config.js', 'svelte.config.ts'])
+				if (existsSync(path.join(root, file)))
+					throwDiagnostic(
+						'config_file_unsupported',
+						`\`${file}\` is no longer used. Please pass configuration via the \`${identity.plugin}(...)\` plugin in your Vite config.`,
+						history
+					);
+			return {
+				optimizeDeps: {
+					rolldownOptions: {
+						plugins: [
+							{
+								name: `${identity.name}:scan-history`,
+								resolveId: {
+									filter: { id: /^\$env\// },
+									handler: (id) => ({ id, external: true })
+								}
+							}
+						]
+					}
+				}
+			};
+		},
+		async resolveId(id, importer, options) {
+			if (id === '$app/environment' || id === '$app/stores') return prefix + id.slice(1);
+			if (legacyEnvironment.test(id)) return prefix + id.slice(1);
+			if (id === '$lib' || /^\$lib[/?]/.test(id) || /^\$service-worker(?:\?|$)/.test(id)) {
+				const resolved = await this.resolve(id, importer, { ...options, skipSelf: true });
+				if (resolved) return resolved;
+				removedModule(id, config.alias ?? {});
+			}
+		},
+		load(id) {
+			if (!id.startsWith(prefix)) return;
+			const name = id.slice(prefix.length);
+			const client = this.environment.config.consumer === 'client';
+			if (name === 'app/stores') return stores(dev);
+			if (name === 'app/environment') return environment(dev, client);
+			const match = /^env\/(static|dynamic)\/(public|private)$/.exec(name);
+			if (match) return legacy(match[1]!, match[2]!, dev);
+		}
+	};
+}

package/src/hooks.ts

@@ -0,0 +1,16 @@
+import type { sequence as kitSequence } from '@vigla/kit/hooks';
+import { sequencer } from '@vigla/kit/internal/sequence';
+import { throwDiagnostic } from './history/diagnostics.ts';
+import { identity } from './identity.ts';
+
+export * from '@vigla/kit/hooks';
+
+export const sequence: typeof kitSequence = sequencer(identity);
+
+export function defineEnvVars(): never {
+	throwDiagnostic(
+		'define_env_vars_moved',
+		'`defineEnvVars` has moved — import it from `@sveltejs/kit/env` instead',
+		defineEnvVars
+	);
+}

package/src/identity.ts

@@ -0,0 +1,30 @@
+import type { Identity } from '@vigla/kit/vite';
+
+const docs = 'https://svelte.dev/docs/kit/';
+
+export const identity: Identity = {
+	name: 'sveltekit',
+	product: 'SvelteKit',
+	framework: 'Svelte',
+	plugin: 'sveltekit',
+	command: 'svelte-kit',
+	outDir: '.svelte-kit',
+	assets: '/_svelte_kit_assets',
+	announcer: 'svelte-announcer',
+	packages: ['@sveltejs/kit', '@vigla/kit'],
+	diagnostics: 'https://svelte.dev/e/kit/',
+	links: {
+		formFields: `${docs}remote-functions#form-Fields`,
+		formValidation: `${docs}remote-functions#form-Programmatic-validation`,
+		prerender: `${docs}@sveltejs-kit-vite#prerender`,
+		prerenderConflicts: `${docs}page-options#prerender-Route-conflicts`,
+		namedActions: `${docs}form-actions#Named-actions`,
+		enhance: `${docs}form-actions#Progressive-enhancement-use:enhance`,
+		transport: `${docs}hooks#transport`,
+		handle: `${docs}hooks#handle`,
+		observability: `${docs}observability#opentelemetry-api`,
+		fetch: `${docs}web-standards#Fetch-APIs`,
+		adapters: `${docs}adapters`
+	},
+	replacedLinkOptions: { keepfocus: 'reset="false"', noscroll: 'reset="false"' }
+};

package/src/index.ts

@@ -0,0 +1,39 @@
+import { DEV } from 'esm-env';
+import type { redirect as kitRedirect } from '@vigla/kit';
+import { outcomes } from '@vigla/kit/internal/identity';
+import { warnDiagnostic } from './history/diagnostics.ts';
+import { identity } from './identity.ts';
+import type { ErrorFunction, ErrorProperties, LegacyErrorBody } from './types/index.ts';
+
+export * from '@vigla/kit';
+export type {
+	AdapterEntry,
+	Builder,
+	ErrorFunction,
+	ErrorProperties,
+	LegacyErrorBody
+} from './types/index.ts';
+export const VERSION = '3.1.0';
+
+type Raise = (status: number, message?: string, properties?: ErrorProperties) => never;
+
+const bound = outcomes(identity);
+const raise = bound.error as Raise;
+
+export const redirect: typeof kitRedirect = bound.redirect;
+
+export const error = ((
+	status: number,
+	message?: string | LegacyErrorBody,
+	properties?: ErrorProperties
+): never => {
+	if (message === undefined || typeof message === 'string')
+		return raise(status, message, properties);
+	if (DEV)
+		warnDiagnostic(
+			'error_body_deprecated',
+			'Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third'
+		);
+	const { message: text, ...rest } = message;
+	return raise(status, text, rest);
+}) as ErrorFunction;

package/src/internal/client.ts

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

package/src/internal/env.ts

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

package/src/internal/payload.ts

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

package/src/internal/restore.ts

@@ -0,0 +1,57 @@
+import { DEV } from 'esm-env';
+import type { Snapshot } from '@vigla/kit';
+import type { Restorer } from '@vigla/kit/internal/restore';
+import { warnDiagnostic } from '../history/diagnostics.ts';
+import { identity } from '../identity.ts';
+
+interface Instance {
+	snapshot?: Snapshot;
+}
+
+const key = `${identity.name}:snapshot`;
+
+function read(): Record<string, unknown[]> {
+	try {
+		return JSON.parse(sessionStorage.getItem(key) ?? '{}') ?? {};
+	} catch {
+		return {};
+	}
+}
+
+class Exported implements Restorer {
+	readonly #snapshots = read();
+	#warned = false;
+
+	capture(navigation: number, components: Instance[]): void {
+		if (!components.some((component) => component?.snapshot)) return;
+		if (DEV && !this.#warned) {
+			this.#warned = true;
+			warnDiagnostic(
+				'snapshot_export_deprecated',
+				'`export const snapshot` is deprecated. Use the `snapshot` helper from `$app/navigation` instead.'
+			);
+		}
+		this.#snapshots[navigation] = components.map((component) => component?.snapshot?.capture());
+	}
+
+	restore(navigation: number, components: Instance[]): void {
+		this.#snapshots[navigation]?.forEach((value, depth) => {
+			components[depth]?.snapshot?.restore(value);
+		});
+	}
+
+	prune(navigation: number): void {
+		for (let index = navigation + 1; this.#snapshots[index]; index++) delete this.#snapshots[index];
+	}
+
+	persist(): void {
+		const data = JSON.stringify(this.#snapshots);
+		try {
+			sessionStorage.setItem(key, data);
+		} catch {}
+	}
+}
+
+export function restorer(): Restorer {
+	return new Exported();
+}

package/src/internal/server.ts

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

package/src/node.ts

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

package/src/params.ts

@@ -0,0 +1,7 @@
+import type { defineParams as kitDefineParams } from '@vigla/kit/params';
+import { paramsDefiner } from '@vigla/kit/internal/identity';
+import { identity } from './identity.ts';
+
+export * from '@vigla/kit/params';
+
+export const defineParams: typeof kitDefineParams = paramsDefiner(identity);

package/src/types/adapter.ts

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

package/src/types/hooks.ts

@@ -0,0 +1,3 @@
+export * from '@vigla/kit/hooks';
+
+export declare function defineEnvVars(): never;

package/src/types/index.ts

@@ -0,0 +1,29 @@
+/// <reference path="../../types/history.d.ts" preserve="true" />
+import type {
+	Builder as KitBuilder,
+	error as kitError,
+	redirect as kitRedirect,
+	RouteDefinition
+} from '@vigla/kit';
+
+export * from '@vigla/kit';
+
+export type ErrorProperties = Omit<App.Error, 'status' | 'message'>;
+export type LegacyErrorBody = Omit<App.Error, 'status'> & { status?: App.Error['status'] };
+export type ErrorFunction = typeof kitError & ((status: number, body: LegacyErrorBody) => never);
+
+export interface AdapterEntry {
+	id: string;
+	filter(route: RouteDefinition): boolean;
+	complete(entry: {
+		generateManifest(options: { relativePath: string }): string;
+	}): void | Promise<void>;
+}
+export interface Builder extends KitBuilder {
+	createEntries?: (fn: (route: RouteDefinition) => AdapterEntry) => Promise<void>;
+	generateManifest?: (options: { relativePath: string; routes?: RouteDefinition[] }) => string;
+}
+
+export declare const VERSION: string;
+export declare const error: ErrorFunction;
+export declare const redirect: typeof kitRedirect;

package/src/types/params.ts

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

package/src/vite.test-d.ts

@@ -0,0 +1,11 @@
+import type { Config } from './vite.ts';
+
+export const upstream: Config = {
+	prebundleSvelteLibraries: false,
+	experimental: { disableSvelteResolveWarnings: true, remoteFunctions: true }
+};
+
+export const native: Config = {
+	// @ts-expect-error
+	prebundleLibraries: false
+};

package/src/vite.ts

@@ -0,0 +1,31 @@
+import {
+	createKit,
+	type Config as KitConfig,
+	type ExperimentalConfig as KitExperimentalConfig,
+	type Framework as KitFramework
+} from '@vigla/kit/vite';
+import { svelte, type Options } from '@vigla/vite-plugin-svelte';
+import { retiredBuilder } from './history/adapter.ts';
+import { componentWarnings } from './history/components.ts';
+import { checkConfig } from './history/config.ts';
+import { appModules, history, type HookEntries } from './history/plugin.ts';
+import { identity } from './identity.ts';
+
+export type * from '@vigla/kit/vite';
+export type Config = KitConfig<Options>;
+export type ExperimentalConfig = KitExperimentalConfig<Options>;
+export type Framework = KitFramework<Options>;
+
+const kit = createKit(identity, svelte);
+
+export const sveltekit: Framework = async (config: Config = {}) => {
+	checkConfig(config);
+	const plugins = await kit({ ...config, adapter: retiredBuilder(config.adapter) });
+	const setup = plugins.find((plugin) => plugin.name === 'kit:setup')!;
+	return [
+		appModules((): HookEntries => setup.api.hooks()),
+		history(config),
+		componentWarnings(),
+		...plugins
+	];
+};

package/types/history.d.ts

@@ -0,0 +1,14 @@
+declare module '$app/navigation' {
+	export interface GotoOptions {
+		replaceState?: boolean;
+		invalidateAll?: boolean;
+	}
+	export function pushState(url: string | URL, state: App.PageState): Promise<void>;
+	export function replaceState(url: string | URL, state: App.PageState): Promise<void>;
+}
+
+declare module '$app/forms' {
+	export interface FormUpdateOptions {
+		invalidateAll?: boolean;
+	}
+}

package/types/index.d.ts

@@ -0,0 +1 @@
+import '@vigla/kit';

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.