@vigla/svelte 0.0.0-stage → 5.57.3

package/src/compiler/proxy.ts

@@ -0,0 +1,154 @@
+import type * as ES from 'estree';
+import type { ExpressionProjection, Unit } from 'vigla/compiler';
+
+type Source = Record<string, unknown>;
+
+function record(value: unknown): value is Source {
+	return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function property(node: ES.MemberExpression): string | null {
+	if (!node.computed && node.property.type === 'Identifier') return node.property.name;
+	return node.computed &&
+		node.property.type === 'Literal' &&
+		typeof node.property.value === 'string'
+		? node.property.value
+		: null;
+}
+
+function primitive(node: ES.Expression): boolean {
+	return (
+		node.type === 'Literal' ||
+		node.type === 'TemplateLiteral' ||
+		node.type === 'UnaryExpression' ||
+		node.type === 'BinaryExpression'
+	);
+}
+
+function optional(node: ES.Expression | ES.Super): boolean {
+	if (node.type === 'ChainExpression') return true;
+	if (node.type === 'MemberExpression') return node.optional || optional(node.object);
+	if (node.type === 'CallExpression') return node.optional || optional(node.callee);
+	return false;
+}
+
+function literal(value: string, loc?: ES.SourceLocation | null): ES.Literal {
+	return { type: 'Literal', value, loc };
+}
+
+function call(callee: ES.Expression, ...args: ES.Expression[]): ES.SimpleCallExpression {
+	return { type: 'CallExpression', callee, arguments: args, optional: false };
+}
+
+function helper(runtime: ES.Identifier, name: string): ES.MemberExpression {
+	return {
+		type: 'MemberExpression',
+		object: runtime,
+		property: { type: 'Identifier', name },
+		computed: false,
+		optional: false
+	};
+}
+
+export function proxyDiagnostics(unit: Unit, filename: string): ExpressionProjection {
+	const searches = new WeakSet<object>();
+	const assignments = new WeakMap<object, string>();
+	const visit = (value: unknown, path: Source[]): void => {
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child, path);
+			return;
+		}
+		if (!record(value)) return;
+		const parent = path.at(-1);
+		if (value.type === 'CallExpression') {
+			const node = value as unknown as ES.SimpleCallExpression;
+			const callee = node.callee;
+			if (
+				callee.type === 'MemberExpression' &&
+				!callee.optional &&
+				!node.optional &&
+				callee.object.type !== 'Super' &&
+				!optional(callee.object) &&
+				['includes', 'indexOf', 'lastIndexOf'].includes(property(callee) ?? '')
+			) {
+				searches.add(node);
+			}
+		}
+		if (value.type === 'AssignmentExpression') {
+			const node = value as unknown as ES.AssignmentExpression;
+			const left = node.left;
+			const event =
+				parent?.type === 'ArrowFunctionExpression' &&
+				path.some((ancestor) => {
+					if (
+						ancestor.kind !== 'attribute' ||
+						typeof ancestor.name !== 'string' ||
+						!ancestor.name.startsWith('on')
+					)
+						return false;
+					const value = ancestor.value;
+					return record(value) && value.expression === parent;
+				});
+			if (
+				left.type === 'MemberExpression' &&
+				left.object.type !== 'Super' &&
+				left.property.type !== 'PrivateIdentifier' &&
+				['=', '&&=', '||=', '??='].includes(node.operator) &&
+				parent?.type !== 'ExpressionStatement' &&
+				!event &&
+				!path.some((ancestor) => ancestor.kind === 'binding') &&
+				!primitive(node.right)
+			) {
+				const position = left.loc?.start;
+				assignments.set(node, `${filename}:${position?.line ?? 0}:${position?.column ?? 0}`);
+			}
+		}
+		for (const [key, child] of Object.entries(value)) {
+			if (key !== 'loc' && key !== 'leadingComments' && key !== 'trailingComments')
+				visit(child, [...path, value]);
+		}
+	};
+	visit(unit, []);
+	return ({ original, lowered, runtime }) => {
+		if (
+			searches.has(original) &&
+			lowered.type === 'CallExpression' &&
+			lowered.callee.type === 'MemberExpression'
+		) {
+			const member = lowered.callee;
+			if (member.object.type === 'Super') return lowered;
+			return {
+				...lowered,
+				callee: call(
+					helper(runtime, 'search'),
+					member.object,
+					literal(property(member)!, member.property.loc)
+				)
+			};
+		}
+		const location = assignments.get(original);
+		if (
+			location !== undefined &&
+			lowered.type === 'AssignmentExpression' &&
+			lowered.left.type === 'MemberExpression'
+		) {
+			const member = lowered.left;
+			if (member.object.type === 'Super' || member.property.type === 'PrivateIdentifier')
+				return lowered;
+			const key = member.computed
+				? member.property
+				: literal((member.property as ES.Identifier).name, member.property.loc);
+			return {
+				...lowered,
+				left: {
+					type: 'MemberExpression',
+					object: call(helper(runtime, 'assignmentTarget'), member.object, key, literal(location)),
+					property: { type: 'Identifier', name: 'current' },
+					computed: false,
+					optional: false
+				}
+			};
+		}
+		return lowered;
+	};
+}

package/src/entries/action.ts

@@ -0,0 +1 @@
+export type * from 'vigla/action';

package/src/entries/animate.ts

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

package/src/entries/attachments.ts

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

package/src/entries/context.ts

@@ -0,0 +1,50 @@
+import type { Contexts as Keys } from 'vigla/internal/client';
+import type { Context } from 'vigla/internal/index-client';
+
+export interface Contexts extends Keys {
+	getAllContexts<T extends Map<unknown, unknown>>(): T;
+	createContext<T>(): Context<T>;
+}
+
+export interface Scope {
+	readonly phase: () => 'initializing' | 'running' | null;
+	readonly failure: (code: string, message: string) => Error;
+	readonly provide: <T>(key: unknown, value: T) => T;
+	readonly keyed: <T>(keys: Keys) => Context<T>;
+}
+
+function outside(scope: Scope, name: string): Error {
+	return scope.failure(
+		'lifecycle_outside_component',
+		`\`${name}(...)\` can only be used during component initialisation`
+	);
+}
+
+export function guard(scope: Scope, name: string): void {
+	if (scope.phase() === null) throw outside(scope, name);
+}
+
+export function project(core: Contexts, scope: Scope): Contexts {
+	const keys: Keys = {
+		getContext(key) {
+			guard(scope, 'getContext');
+			return core.getContext(key);
+		},
+		setContext(key, value) {
+			guard(scope, 'setContext');
+			return scope.provide(key, value);
+		},
+		hasContext(key) {
+			guard(scope, 'hasContext');
+			return core.hasContext(key);
+		}
+	};
+	return {
+		...keys,
+		getAllContexts<T extends Map<unknown, unknown>>() {
+			guard(scope, 'getAllContexts');
+			return core.getAllContexts<T>();
+		},
+		createContext: <T>() => scope.keyed<T>(keys)
+	};
+}

package/src/entries/easing.ts

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

package/src/entries/events.ts

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

package/src/entries/index-server.ts

@@ -0,0 +1,17 @@
+import * as core from 'vigla/internal/index-server';
+import { guard, project, type Scope } from './context.ts';
+import { failure, keyed, phase, provide } from './internal/server.ts';
+
+export * from 'vigla/internal/index-server';
+
+const scope: Scope = { phase, failure, provide, keyed };
+
+export const { getContext, setContext, hasContext, getAllContexts, createContext } = project(
+	core,
+	scope
+);
+
+export function onDestroy(fn: () => void): void {
+	guard(scope, 'onDestroy');
+	core.onDestroy(fn);
+}

package/src/entries/index.ts

@@ -0,0 +1,41 @@
+import * as core from 'vigla/internal/index-client';
+import { guard, project, type Scope } from './context.ts';
+import { failure, keyed, phase, provide } from './internal/client.ts';
+import { format } from '../shared/format.ts';
+
+export * from 'vigla/internal/index-client';
+export { getReactionSignal as getAbortSignal } from './internal/client.ts';
+
+const scope: Scope = { phase, failure, provide, keyed };
+
+export const { getContext, setContext, hasContext, getAllContexts, createContext } = project(
+	core,
+	scope
+);
+
+export function mount<P extends core.Props, E extends core.Exports>(
+	component: core.Component<P, E>,
+	options: core.MountOptions<P>
+): E {
+	return core.mount(component, { ...options, format: options.format ?? format });
+}
+
+export function hydrate<P extends core.Props, E extends core.Exports>(
+	component: core.Component<P, E>,
+	options: core.HydrateOptions<P>
+): E {
+	return core.hydrate(component, { ...options, format: options.format ?? format });
+}
+
+export const createRawSnippet: typeof core.createRawSnippet = (factory) =>
+	core.createRawSnippet(factory, format);
+
+export function onMount(fn: () => unknown): void {
+	guard(scope, 'onMount');
+	core.onMount(fn);
+}
+
+export function onDestroy(fn: () => unknown): void {
+	guard(scope, 'onDestroy');
+	core.onDestroy(fn);
+}

package/src/entries/internal/client.ts

@@ -0,0 +1,15 @@
+import { setReporter } from 'vigla/internal/client';
+import { format } from '../../shared/format.ts';
+import { reporter } from '../report.ts';
+
+setReporter(reporter);
+setReporter(reporter, format);
+
+export * from 'vigla/internal/client';
+export { assignmentTarget, search } from '../proxy.ts';
+export {
+	lapsingDerived as derived,
+	pre as user_pre_effect,
+	unowned as without_reactive_context,
+	userEffect as user_effect
+} from 'vigla/internal/client';

package/src/entries/internal/disclose-version.ts

@@ -0,0 +1,4 @@
+import { disclose } from 'vigla/internal/client';
+import { format } from '../../shared/format.ts';
+
+disclose(format.global, '5');

package/src/entries/internal/index.ts

@@ -0,0 +1,3 @@
+throw new Error(
+	"Your application, or one of its dependencies, imported from 'svelte/internal', which was a private module used by Svelte 4 components that no longer exists in Svelte 5. It is not intended to be public API. If you're a library author and you used 'svelte/internal' deliberately, please raise an issue on https://github.com/sveltejs/svelte/issues detailing your use case."
+);

package/src/entries/internal/server.ts

@@ -0,0 +1,8 @@
+import { setReporter } from 'vigla/internal/server';
+import { format } from '../../shared/format.ts';
+import { reporter } from '../report.ts';
+
+setReporter(reporter);
+setReporter(reporter, format);
+
+export * from 'vigla/internal/server';

package/src/entries/internal/tracing.ts

@@ -0,0 +1 @@
+export {};

package/src/entries/motion-server.ts

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

package/src/entries/motion.ts

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

package/src/entries/proxy.ts

@@ -0,0 +1,86 @@
+import { mutationTarget, original, type AssignmentTarget } from 'vigla/internal/client';
+import { untrack } from 'vigla/internal/index-client';
+import { reporter } from './report.ts';
+
+type Search = 'includes' | 'indexOf' | 'lastIndexOf';
+type Properties = Record<PropertyKey, unknown>;
+
+const searches = {
+	includes: Array.prototype.includes,
+	indexOf: Array.prototype.indexOf,
+	lastIndexOf: Array.prototype.lastIndexOf
+};
+
+function identity(value: unknown): unknown {
+	try {
+		return original(value);
+	} catch {
+		return value;
+	}
+}
+
+export function assignmentTarget(
+	receiver: unknown,
+	key: PropertyKey,
+	location: string
+): AssignmentTarget<unknown> {
+	const object = receiver as Properties;
+	let property: PropertyKey | undefined;
+	const reference = {
+		[Symbol.toPrimitive]() {
+			property = Reflect.ownKeys({ [key]: null })[0]!;
+			return property;
+		}
+	} as unknown as PropertyKey;
+	return mutationTarget(object, reference, (value) => {
+		if (value !== null && typeof value === 'object') {
+			const current = untrack(() => object[property!]);
+			if (current !== value && identity(current) !== current) {
+				reporter.warn({
+					code: 'assignment_value_stale',
+					message: `Assignment to \`${String(property)}\` property (${location}) will evaluate to the right-hand side, not the value of \`${String(property)}\` following the assignment. This may result in unexpected behaviour.`,
+					values: {},
+					dev: true
+				});
+			}
+		}
+	});
+}
+
+export function search(receiver: unknown, key: Search) {
+	const object = receiver as Properties;
+	const method = object[key] as (...args: unknown[]) => unknown;
+	return (...args: unknown[]): unknown => {
+		const intrinsic = method === searches[key];
+		let from: number | undefined;
+		const passed = [...args];
+		if (intrinsic && key !== 'includes' && args.length > 1 && args[1] != null) {
+			passed[1] = {
+				[Symbol.toPrimitive]() {
+					return (from = +(args[1] as number));
+				}
+			};
+		}
+		const result = Reflect.apply(method, receiver, passed);
+		if (intrinsic && (key === 'includes' ? result === false : result === -1)) {
+			untrack(() => {
+				const length = object.length as number;
+				const end = Math.min(key === 'lastIndexOf' ? (from ?? length - 1) + 1 : length, length);
+				const start = key === 'indexOf' ? Math.max(from ?? 0, 0) : 0;
+				for (let index = start; index < end; index++) {
+					const value = object[index];
+					if (value !== args[0] && identity(value) === args[0]) {
+						reporter.warn({
+							code: 'state_proxy_equality_mismatch',
+							message: `Reactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`array.${key}(...)\` will produce unexpected results`,
+							values: {},
+							dev: true
+						});
+						break;
+					}
+				}
+			});
+		}
+		return result;
+	};
+}

package/src/entries/reactivity-server.ts

@@ -0,0 +1,9 @@
+export {
+	createSubscriber,
+	MediaQuery,
+	ReactiveDate as SvelteDate,
+	ReactiveMap as SvelteMap,
+	ReactiveSet as SvelteSet,
+	ReactiveURL as SvelteURL,
+	ReactiveURLSearchParams as SvelteURLSearchParams
+} from 'vigla/internal/reactivity-server';

package/src/entries/reactivity.ts

@@ -0,0 +1,9 @@
+export {
+	createSubscriber,
+	MediaQuery,
+	ReactiveDate as SvelteDate,
+	ReactiveMap as SvelteMap,
+	ReactiveSet as SvelteSet,
+	ReactiveURL as SvelteURL,
+	ReactiveURLSearchParams as SvelteURLSearchParams
+} from 'vigla/internal/reactivity-client';

package/src/entries/report.ts

@@ -0,0 +1,81 @@
+import type { Notice, Reporter, Values } from 'vigla/internal/server';
+
+interface Projection {
+	readonly code: string;
+	readonly message: (values: Values) => string;
+}
+
+const projections: Readonly<Record<string, Projection>> = {
+	boundary_reset_noop: {
+		code: 'svelte_boundary_reset_noop',
+		message: () =>
+			'A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called'
+	},
+	boundary_reset_onerror: {
+		code: 'svelte_boundary_reset_onerror',
+		message: () =>
+			'A `<svelte:boundary>` `reset` function cannot be called while an error is still being handled'
+	},
+	dynamic_element_invalid_tag: {
+		code: 'dynamic_element_invalid_tag',
+		message: ({ tag }) =>
+			`\`<svelte:element this="${tag}">\` is not a valid element name — the element will not be rendered`
+	},
+	source_invalid: {
+		code: 'store_invalid_shape',
+		message: ({ name }) => `\`${name}\` is not a store with a \`subscribe\` method`
+	}
+};
+
+const explained = new Set([
+	'async_local_storage_unavailable',
+	'await_invalid',
+	'dynamic_element_invalid_tag',
+	'html_deprecated',
+	'hydratable_clobbering',
+	'hydratable_serialization_failed',
+	'invalid_csp',
+	'invalid_id_prefix',
+	'lifecycle_function_unavailable',
+	'server_context_required'
+]);
+
+const entries = /\/svelte\/src\/entries\//;
+
+function link(code: string): string {
+	return `https://svelte.dev/e/${code}`;
+}
+
+function project({ code, message, values, dev }: Notice): [string, string | null] {
+	const found = projections[code];
+	const shown = found === undefined ? code : found.code;
+	if (!dev && !explained.has(shown)) return [shown, null];
+	return [shown, found === undefined ? message : found.message(values)];
+}
+
+export const reporter: Reporter = {
+	warn(notice) {
+		const [code, message] = project(notice);
+		if (message === null) console.warn(link(code));
+		else {
+			console.warn(
+				`%c[svelte] ${code}\n%c${message}\n${link(code)}`,
+				'font-weight: bold',
+				'font-weight: normal'
+			);
+		}
+	},
+	error(notice) {
+		const [code, message] = project(notice);
+		const error = new Error(message === null ? link(code) : `${code}\n${message}\n${link(code)}`);
+		error.name = 'Svelte error';
+		return error;
+	},
+	formatFrame(frame) {
+		if (entries.test(frame.replaceAll('\\', '/'))) return null;
+		return frame.replace(/\bReactive(Map|Set|Date|URLSearchParams|URL)\./g, 'Svelte$1.');
+	},
+	unhandled(error) {
+		throw error;
+	}
+};

package/src/entries/server.ts

@@ -0,0 +1,76 @@
+import * as core from 'vigla/server';
+import { failure } from 'vigla/internal/server';
+import { format } from '../shared/format.ts';
+
+export * from 'vigla/server';
+
+export interface Rendered extends core.Rendered {
+	readonly html: string;
+}
+
+export type Rendering = Rendered & PromiseLike<Rendered>;
+
+class Settled implements Rendered {
+	readonly head: string;
+	readonly body: string;
+	readonly hashes: core.Hashes;
+
+	constructor(value: core.Rendered) {
+		this.head = value.head;
+		this.body = value.body;
+		this.hashes = value.hashes;
+	}
+
+	get html(): string {
+		throw failure(
+			'html_deprecated',
+			'The `html` property of server render results has been deprecated. Use `body` instead.'
+		);
+	}
+}
+
+class Result implements Rendering {
+	readonly #result: core.Rendering;
+
+	constructor(result: core.Rendering) {
+		this.#result = result;
+	}
+
+	get head(): string {
+		return this.#result.head;
+	}
+
+	get body(): string {
+		return this.#result.body;
+	}
+
+	get html(): string {
+		return this.#result.body;
+	}
+
+	get hashes(): core.Hashes {
+		return this.#result.hashes;
+	}
+
+	then<A = Rendered, B = never>(
+		fulfilled?: ((value: Rendered) => A | PromiseLike<A>) | null,
+		rejected?: ((reason: unknown) => B | PromiseLike<B>) | null
+	): PromiseLike<A | B> {
+		return Promise.resolve(this.#result)
+			.then((value): Rendered => new Settled(value))
+			.then(fulfilled, rejected);
+	}
+}
+
+export function render<P extends core.Props>(
+	component: core.Component<P>,
+	options: core.RenderOptions<P> = {}
+): Rendering {
+	return new Result(
+		core.render(component, {
+			...options,
+			format: options.format ?? format,
+			inheritContext: options.inheritContext ?? false
+		})
+	);
+}

package/src/entries/store-client.ts

@@ -0,0 +1,80 @@
+import { effect, getOwner, tracking } from 'vigla/internal/index-client';
+import { createSubscriber } from 'vigla/internal/reactivity-client';
+import { get, subscribe, writable, type Readable, type Writable } from './store.ts';
+
+export { derived, get, readable, readonly, writable } from './store.ts';
+export type {
+	Readable,
+	StartStopNotifier,
+	Subscriber,
+	Unsubscriber,
+	Updater,
+	Writable
+} from './store.ts';
+
+export function toStore<T>(read: () => T, write: (value: T) => void): Writable<T>;
+export function toStore<T>(read: () => T): Readable<T>;
+export function toStore<T>(read: () => T, write?: (value: T) => void): Readable<T> | Writable<T> {
+	const owner = getOwner();
+	const initial = read();
+	const store = writable(initial, (publish) => {
+		let ran = initial !== read();
+		const start = (): (() => void) =>
+			effect.root(() => {
+				effect.pre(() => {
+					const value = read();
+					if (ran) publish(value);
+				});
+			});
+		const stop = owner !== null && !owner.disposed ? owner.run(start) : start();
+		ran = true;
+		return stop;
+	});
+	return write === undefined
+		? { subscribe: store.subscribe, subscribeSync: store.subscribeSync }
+		: {
+				subscribe: store.subscribe,
+				subscribeSync: store.subscribeSync,
+				set: write,
+				update: (fn) => write(fn(read()))
+			};
+}
+
+export function fromStore<T>(store: Writable<T>): { current: T };
+export function fromStore<T>(store: Readable<T>): { readonly current: T };
+export function fromStore<T>(store: Readable<T>): { readonly current: T } {
+	let value: T;
+	const track = createSubscriber((update) => {
+		let active = false;
+		const release = subscribe(
+			store,
+			(next) => {
+				value = next;
+				if (active) update();
+			},
+			undefined,
+			true
+		);
+		active = true;
+		return release;
+	});
+	const read = (): T => {
+		if (!tracking()) return get(store);
+		track();
+		return value;
+	};
+	return 'set' in store
+		? {
+				get current() {
+					return read();
+				},
+				set current(value: T) {
+					(store as Writable<T>).set(value);
+				}
+			}
+		: {
+				get current() {
+					return read();
+				}
+			};
+}