@vigla/svelte 0.0.0-stage → 5.57.3

package/src/entries/store-server.ts

@@ -0,0 +1,44 @@
+import { get, 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 store = writable(read());
+	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 } {
+	return 'set' in store
+		? {
+				get current() {
+					return get(store);
+				},
+				set current(value: T) {
+					(store as Writable<T>).set(value);
+				}
+			}
+		: {
+				get current() {
+					return get(store);
+				}
+			};
+}

package/src/entries/store.ts

@@ -0,0 +1,201 @@
+import { untrack } from 'vigla/internal/index-client';
+import type { Subscribable } from 'vigla';
+
+export type Subscriber<T> = (value: T) => void;
+export type Unsubscriber = () => void;
+export type Updater<T> = (value: T) => T;
+export type StartStopNotifier<T> = (
+	set: (value: T) => void,
+	update: (fn: Updater<T>) => void
+) => void | Unsubscriber;
+
+export interface Readable<T> extends Subscribable<T> {
+	subscribe(this: void, run: Subscriber<T>, invalidate?: () => void): Unsubscriber;
+	subscribeSync?(run: Subscriber<T>): Unsubscriber;
+}
+
+export interface Writable<T> extends Readable<T> {
+	set(this: void, value: T): void;
+	update(this: void, updater: Updater<T>): void;
+}
+
+interface Subscription<T> {
+	readonly run: Subscriber<T>;
+	readonly invalidate: () => void;
+	readonly sync: boolean;
+	version: number;
+}
+
+export type Stores = Readable<unknown> | readonly Readable<unknown>[];
+export type StoresValues<S> =
+	S extends Readable<infer T> ? T : { [K in keyof S]: S[K] extends Readable<infer T> ? T : never };
+
+const notifications: (() => void)[] = [];
+let publishing = false;
+const noop = (): void => {};
+
+function changed<T>(before: T, after: T): boolean {
+	return before !== before
+		? after === after
+		: before !== after ||
+				(before !== null && typeof before === 'object') ||
+				typeof before === 'function';
+}
+
+export function subscribe<T>(
+	store: Readable<T> | null | undefined,
+	run: Subscriber<T>,
+	invalidate?: () => void,
+	sync = false
+): Unsubscriber {
+	if (store == null) {
+		run(undefined as T);
+		invalidate?.();
+		return noop;
+	}
+	const release = untrack(() =>
+		sync && store.subscribeSync ? store.subscribeSync(run) : store.subscribe(run, invalidate)
+	);
+	return typeof release === 'function'
+		? release
+		: () => (release as { unsubscribe(): void }).unsubscribe();
+}
+
+export function writable<T = undefined>(value?: T, start?: StartStopNotifier<T>): Writable<T> {
+	let current = value as T;
+	let stop: Unsubscriber | undefined;
+	let version = 0;
+	const subscribers = new Set<Subscription<T>>();
+	const set = (next: T): void => {
+		if (!changed(current, next)) return;
+		current = next;
+		if (stop === undefined) return;
+		const publication = ++version;
+		const drain = !publishing;
+		publishing = true;
+		try {
+			for (const subscriber of subscribers) {
+				subscriber.invalidate();
+				if (!subscriber.sync) {
+					const value = current;
+					notifications.push(() => subscriber.run(value));
+				}
+			}
+			for (const subscriber of subscribers) {
+				if (subscriber.sync && subscriber.version < publication) {
+					subscriber.version = publication;
+					subscriber.run(current);
+				}
+			}
+			if (drain) {
+				for (let index = 0; index < notifications.length; index++) notifications[index]?.();
+			}
+		} finally {
+			if (drain) {
+				notifications.length = 0;
+				publishing = false;
+			}
+		}
+	};
+	const update = (fn: Updater<T>): void => set(fn(current));
+	const listen = (run: Subscriber<T>, invalidate: () => void, sync: boolean): Unsubscriber => {
+		const subscriber = { run, invalidate, sync, version };
+		subscribers.add(subscriber);
+		if (subscribers.size === 1) stop = start?.(set, update) || noop;
+		run(current);
+		return () => {
+			subscribers.delete(subscriber);
+			if (subscribers.size === 0 && stop !== undefined) {
+				stop();
+				stop = undefined;
+			}
+		};
+	};
+	return {
+		set,
+		update,
+		subscribe: (run, invalidate = noop) => listen(run, invalidate, false),
+		subscribeSync: (run) => listen(run, noop, true)
+	};
+}
+
+export function readable<T = undefined>(value?: T, start?: StartStopNotifier<T>): Readable<T> {
+	const store = writable(value, start);
+	return { subscribe: store.subscribe, subscribeSync: store.subscribeSync };
+}
+
+export function derived<S extends Stores, T>(
+	stores: S,
+	fn: (
+		values: StoresValues<S>,
+		set: (value: T) => void,
+		update: (fn: Updater<T>) => void
+	) => Unsubscriber | void,
+	initial?: T
+): Readable<T>;
+export function derived<S extends Stores, T>(
+	stores: S,
+	fn: (values: StoresValues<S>) => T,
+	initial?: T
+): Readable<T>;
+export function derived<S extends Stores, T>(
+	stores: S,
+	fn: (
+		values: StoresValues<S>,
+		set: (value: T) => void,
+		update: (fn: Updater<T>) => void
+	) => T | Unsubscriber | void,
+	initial?: T
+): Readable<T> {
+	const inputs: readonly Readable<unknown>[] = Array.isArray(stores)
+		? stores
+		: [stores as Readable<unknown>];
+	if (inputs.some((input) => !input))
+		throw new Error('derived() expects stores as input, got a falsy value');
+	return readable(initial, (set, update) => {
+		const values: unknown[] = [];
+		const pending = new Set<number>();
+		let active = false;
+		let cleanup: Unsubscriber = noop;
+		const sync = (): void => {
+			if (pending.size > 0) return;
+			cleanup();
+			const value = (Array.isArray(stores) ? values : values[0]) as StoresValues<S>;
+			const result = fn(value, set, update);
+			if (fn.length < 2) set(result as T);
+			else cleanup = typeof result === 'function' ? (result as Unsubscriber) : noop;
+		};
+		const releases = inputs.map((input, index) =>
+			subscribe(
+				input,
+				(value) => {
+					values[index] = value;
+					pending.delete(index);
+					if (active) sync();
+				},
+				() => pending.add(index)
+			)
+		);
+		active = true;
+		sync();
+		return () => {
+			for (const release of releases) release();
+			cleanup();
+			active = false;
+		};
+	});
+}
+
+export function readonly<T>(store: Readable<T>): Readable<T> {
+	const sync = store.subscribeSync;
+	return {
+		subscribe: (run, invalidate) => store.subscribe(run, invalidate),
+		...(sync ? { subscribeSync: (run: Subscriber<T>) => sync.call(store, run) } : {})
+	};
+}
+
+export function get<T>(store: Readable<T>): T {
+	let value: T;
+	subscribe(store, (current) => (value = current))();
+	return value!;
+}

package/src/entries/transition.ts

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

package/src/entries/window-server.ts

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

package/src/entries/window.ts

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

package/src/front/ast.ts

@@ -0,0 +1,369 @@
+import type * as ES from 'estree';
+
+export interface Located {
+	start: number;
+	end: number;
+}
+
+export interface Position {
+	line: number;
+	column: number;
+	character: number;
+}
+
+export interface NameLocation {
+	start: Position;
+	end: Position;
+}
+
+export type Expression = ES.Expression & Partial<Located>;
+
+export type Pattern = ES.Pattern & Partial<Located>;
+
+export interface JSComment extends Located {
+	type: 'Line' | 'Block';
+	value: string;
+	loc?: { start: { line: number; column: number }; end: { line: number; column: number } };
+}
+
+export interface Fragment {
+	type: 'Fragment';
+	nodes: TemplateNode[];
+}
+
+export interface Text extends Located {
+	type: 'Text';
+	raw: string;
+	data: string;
+}
+
+export interface Comment extends Located {
+	type: 'Comment';
+	data: string;
+}
+
+export interface ExpressionTag extends Located {
+	type: 'ExpressionTag';
+	expression: Expression;
+}
+
+export interface HtmlTag extends Located {
+	type: 'HtmlTag';
+	expression: Expression;
+}
+
+export interface ConstTag extends Located {
+	type: 'ConstTag';
+	declaration: ES.VariableDeclaration &
+		Located & { declarations: [ES.VariableDeclarator & Located] };
+}
+
+export interface DeclarationTag extends Located {
+	type: 'DeclarationTag';
+	declaration: ES.VariableDeclaration & Located;
+}
+
+export interface DebugTag extends Located {
+	type: 'DebugTag';
+	identifiers: (ES.Identifier & Located)[];
+}
+
+export interface RenderTag extends Located {
+	type: 'RenderTag';
+	expression: (ES.SimpleCallExpression | ES.ChainExpression) & Located;
+}
+
+export interface AttachTag extends Located {
+	type: 'AttachTag';
+	expression: Expression;
+}
+
+export type AttributeValue = true | ExpressionTag | (Text | ExpressionTag)[];
+
+export interface Attribute extends Located {
+	type: 'Attribute';
+	name: string;
+	name_loc: NameLocation | null;
+	value: AttributeValue;
+}
+
+export interface SpreadAttribute extends Located {
+	type: 'SpreadAttribute';
+	expression: Expression;
+}
+
+export type DirectiveType =
+	| 'AnimateDirective'
+	| 'BindDirective'
+	| 'ClassDirective'
+	| 'LetDirective'
+	| 'OnDirective'
+	| 'TransitionDirective'
+	| 'UseDirective';
+
+export interface Directive extends Located {
+	type: DirectiveType;
+	name: string;
+	name_loc: NameLocation | null;
+	expression: Expression | null;
+	modifiers: string[];
+	intro?: boolean;
+	outro?: boolean;
+}
+
+export interface StyleDirective extends Located {
+	type: 'StyleDirective';
+	name: string;
+	name_loc: NameLocation | null;
+	modifiers: string[];
+	value: AttributeValue;
+}
+
+export type AttributeLike = Attribute | SpreadAttribute | Directive | StyleDirective | AttachTag;
+
+export type ElementType =
+	| 'RegularElement'
+	| 'Component'
+	| 'TitleElement'
+	| 'SlotElement'
+	| 'SvelteHead'
+	| 'SvelteOptions'
+	| 'SvelteWindow'
+	| 'SvelteDocument'
+	| 'SvelteBody'
+	| 'SvelteElement'
+	| 'SvelteComponent'
+	| 'SvelteSelf'
+	| 'SvelteFragment'
+	| 'SvelteBoundary';
+
+export interface ElementLike extends Located {
+	type: ElementType;
+	name: string;
+	name_loc: NameLocation;
+	attributes: AttributeLike[];
+	fragment: Fragment;
+	tag?: Expression;
+	expression?: Expression;
+}
+
+export interface IfBlock extends Located {
+	type: 'IfBlock';
+	elseif: boolean;
+	test: Expression;
+	consequent: Fragment;
+	alternate: Fragment | null;
+}
+
+export interface EachBlock extends Located {
+	type: 'EachBlock';
+	expression: Expression;
+	context: Pattern | null;
+	body: Fragment;
+	fallback?: Fragment;
+	index?: string;
+	key?: Expression;
+}
+
+export interface AwaitBlock extends Located {
+	type: 'AwaitBlock';
+	expression: Expression;
+	value: Pattern | null;
+	error: Pattern | null;
+	pending: Fragment | null;
+	then: Fragment | null;
+	catch: Fragment | null;
+}
+
+export interface KeyBlock extends Located {
+	type: 'KeyBlock';
+	expression: Expression;
+	fragment: Fragment;
+}
+
+export interface SnippetBlock extends Located {
+	type: 'SnippetBlock';
+	expression: ES.Identifier & Located;
+	typeParams?: string;
+	parameters: Pattern[];
+	body: Fragment;
+}
+
+export type Tag = ExpressionTag | HtmlTag | ConstTag | DeclarationTag | DebugTag | RenderTag;
+
+export type Block = IfBlock | EachBlock | AwaitBlock | KeyBlock | SnippetBlock;
+
+export type TemplateNode = Text | Comment | Tag | Block | ElementLike;
+
+export interface Script extends Located {
+	type: 'Script';
+	context: 'default' | 'module';
+	content: ES.Program & Located;
+	attributes: AttributeLike[];
+}
+
+export interface CustomElementProp {
+	type?: 'String' | 'Number' | 'Boolean' | 'Array' | 'Object';
+	reflect?: boolean;
+	attribute?: string;
+}
+
+export interface CustomElementOptions {
+	tag?: string;
+	shadow?: 'open' | 'none' | ES.ObjectExpression;
+	props?: Record<string, CustomElementProp>;
+	extend?: Expression;
+}
+
+export interface SvelteOptions extends Located {
+	attributes: AttributeLike[];
+	runes?: boolean;
+	immutable?: boolean;
+	accessors?: boolean;
+	preserveWhitespace?: boolean;
+	namespace?: 'html' | 'svg' | 'mathml';
+	css?: 'injected';
+	customElement?: CustomElementOptions;
+}
+
+export interface Root extends Located {
+	type: 'Root';
+	css: Css.StyleSheet | null;
+	js: never[];
+	fragment: Fragment;
+	options: SvelteOptions | null;
+	comments: JSComment[];
+	instance?: Script;
+	module?: Script;
+}
+
+export namespace Css {
+	export interface Comment extends Located {
+		type: 'CSSComment';
+		value: string;
+		position?: number;
+	}
+
+	export interface StyleSheet extends Located {
+		type: 'StyleSheet';
+		attributes: AttributeLike[];
+		children: (Rule | Atrule)[];
+		comments: Comment[];
+		content: {
+			start: number;
+			end: number;
+			styles: string;
+			comment: import('./ast.ts').Comment | null;
+		};
+	}
+
+	export interface Atrule extends Located {
+		type: 'Atrule';
+		name: string;
+		prelude: string;
+		block: Block | null;
+	}
+
+	export interface Rule extends Located {
+		type: 'Rule';
+		prelude: SelectorList;
+		block: Block;
+	}
+
+	export interface SelectorList extends Located {
+		type: 'SelectorList';
+		children: ComplexSelector[];
+	}
+
+	export interface ComplexSelector extends Located {
+		type: 'ComplexSelector';
+		children: RelativeSelector[];
+	}
+
+	export interface RelativeSelector extends Located {
+		type: 'RelativeSelector';
+		combinator: Combinator | null;
+		selectors: SimpleSelector[];
+	}
+
+	export interface Combinator extends Located {
+		type: 'Combinator';
+		name: string;
+	}
+
+	export interface Named extends Located {
+		name: string;
+	}
+
+	export interface TypeSelector extends Named {
+		type: 'TypeSelector';
+		namespace?: string;
+	}
+
+	export interface IdSelector extends Named {
+		type: 'IdSelector';
+	}
+
+	export interface ClassSelector extends Named {
+		type: 'ClassSelector';
+	}
+
+	export interface NestingSelector extends Named {
+		type: 'NestingSelector';
+	}
+
+	export interface PseudoElementSelector extends Named {
+		type: 'PseudoElementSelector';
+		args?: SelectorList;
+	}
+
+	export interface PseudoClassSelector extends Named {
+		type: 'PseudoClassSelector';
+		args: SelectorList | null;
+	}
+
+	export interface AttributeSelector extends Named {
+		type: 'AttributeSelector';
+		matcher: string | null;
+		value: string | null;
+		flags: string | null;
+	}
+
+	export interface Nth extends Located {
+		type: 'Nth';
+		value: string;
+	}
+
+	export interface Percentage extends Located {
+		type: 'Percentage';
+		value: string;
+	}
+
+	export type SimpleSelector =
+		| TypeSelector
+		| IdSelector
+		| ClassSelector
+		| NestingSelector
+		| PseudoElementSelector
+		| PseudoClassSelector
+		| AttributeSelector
+		| Nth
+		| Percentage;
+
+	export interface Block extends Located {
+		type: 'Block';
+		children: (Declaration | Rule | Atrule)[];
+	}
+
+	export interface Declaration extends Located {
+		type: 'Declaration';
+		property: string;
+		value: string;
+	}
+
+	export interface StyleSheetFile extends Located {
+		type: 'StyleSheetFile';
+		children: (Rule | Atrule)[];
+		comments: Comment[];
+	}
+}

package/src/front/diagnostics.ts

@@ -0,0 +1,53 @@
+import { CompileError, errorMessage, warningMessage, type Diagnostic } from 'vigla/compiler';
+import { warningCodes as codes, wording } from './wording.ts';
+
+export type At = number | { readonly start?: number | null; readonly end?: number | null };
+
+export type Args = Readonly<Record<string, string | null | undefined>>;
+
+function span(at: At): { start: number; end: number } {
+	if (typeof at === 'number') return { start: at, end: at };
+	const start = at.start ?? 0;
+	return { start, end: at.end ?? start };
+}
+
+export function diagnostic(code: string, at: At, args: Args = {}): Diagnostic {
+	return { code, message: errorMessage(code, args, wording), ...span(at) };
+}
+
+export function fail(code: string, at: At, args: Args = {}): never {
+	throw new CompileError(diagnostic(code, at, args));
+}
+
+const legacyMessages: Readonly<Record<string, (args: Args) => string>> = {
+	component_event_directive_invalid: ({ name }) =>
+		`\`on:${name}\` on a component is Svelte 4 event syntax, which is not supported — pass a callback prop such as \`on${name}={...}\` instead`,
+	let_directive_invalid: () =>
+		'`let:` directives belong to Svelte 4 slots, which are not supported — use snippets instead',
+	svelte_fragment_invalid: () =>
+		'`<svelte:fragment>` belongs to Svelte 4 slots, which are not supported — use snippets instead',
+	slot_attribute_unsupported: () =>
+		"The `slot` attribute assigns content to a component's Svelte 4 slot, which is not supported — pass a snippet instead",
+	runes_mode_required: () =>
+		'Components must use runes mode — `runes: false` and legacy mode are not supported'
+};
+
+export function legacy(code: string, at: At, args: Args = {}): never {
+	const own = legacyMessages[code];
+	const message = own === undefined ? warningMessage(code, args, wording) : own(args);
+	throw new CompileError({ code, message, ...span(at) });
+}
+
+export function unsupported(what: string, at: At): never {
+	throw new CompileError({
+		code: 'unsupported',
+		message: `${what} is not supported yet`,
+		...span(at)
+	});
+}
+
+export function warning(code: string, at: At, args: Args = {}): Diagnostic {
+	return { code, message: warningMessage(code, args, wording), ...span(at) };
+}
+
+export const warningCodes: readonly string[] = codes;