@vigla/svelte 0.0.0-stage → 5.57.4

package/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="./types/index.d.ts" />
+export {};

package/motion.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="./types/index.d.ts" />
+export {};

package/package.json

@@ -1,6 +1,129 @@
 {
-  "name": "@vigla/svelte",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@vigla/svelte",
+	"version": "5.57.4",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/runlith/vigla.git",
+		"directory": "packages/svelte"
+	},
+	"type": "module",
+	"types": "./types/index.d.ts",
+	"files": [
+		"dist",
+		"src",
+		"compiler",
+		"types",
+		"elements.d.ts",
+		"svelte-html.d.ts",
+		"index.d.ts",
+		"compiler.d.ts",
+		"action.d.ts",
+		"animate.d.ts",
+		"easing.d.ts",
+		"motion.d.ts",
+		"store.d.ts",
+		"transition.d.ts"
+	],
+	"vigla": {
+		"frontEnd": {
+			"compiler": "./compiler",
+			"components": [
+				".svelte"
+			],
+			"modules": {
+				"infixes": [
+					".svelte."
+				],
+				"extensions": [
+					".js",
+					".ts"
+				]
+			},
+			"condition": "svelte",
+			"config": "svelte.config"
+		}
+	},
+	"exports": {
+		".": {
+			"types": "./types/index.d.ts",
+			"worker": "./dist/entries/index-server.js",
+			"browser": "./dist/entries/index.js",
+			"default": "./dist/entries/index-server.js"
+		},
+		"./package.json": "./package.json",
+		"./action": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/action.js"
+		},
+		"./animate": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/animate.js"
+		},
+		"./attachments": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/attachments.js"
+		},
+		"./easing": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/easing.js"
+		},
+		"./compiler": {
+			"types": "./types/index.d.ts",
+			"require": "./compiler/index.js",
+			"default": "./dist/compiler/index.js"
+		},
+		"./elements": {
+			"types": "./elements.d.ts"
+		},
+		"./events": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/events.js"
+		},
+		"./internal": "./dist/entries/internal/index.js",
+		"./internal/client": "./dist/entries/internal/client.js",
+		"./internal/disclose-version": "./dist/entries/internal/disclose-version.js",
+		"./internal/flags/tracing": "./dist/entries/internal/tracing.js",
+		"./internal/server": "./dist/entries/internal/server.js",
+		"./motion": {
+			"types": "./types/index.d.ts",
+			"worker": "./dist/entries/motion-server.js",
+			"browser": "./dist/entries/motion.js",
+			"default": "./dist/entries/motion-server.js"
+		},
+		"./reactivity": {
+			"types": "./types/index.d.ts",
+			"worker": "./dist/entries/reactivity-server.js",
+			"browser": "./dist/entries/reactivity.js",
+			"default": "./dist/entries/reactivity-server.js"
+		},
+		"./reactivity/window": {
+			"types": "./types/index.d.ts",
+			"worker": "./dist/entries/window-server.js",
+			"browser": "./dist/entries/window.js",
+			"default": "./dist/entries/window-server.js"
+		},
+		"./server": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/server.js"
+		},
+		"./store": {
+			"types": "./types/index.d.ts",
+			"worker": "./dist/entries/store-server.js",
+			"browser": "./dist/entries/store-client.js",
+			"default": "./dist/entries/store-server.js"
+		},
+		"./transition": {
+			"types": "./types/index.d.ts",
+			"default": "./dist/entries/transition.js"
+		}
+	},
+	"dependencies": {
+		"@jridgewell/remapping": "^2.3.5",
+		"@jridgewell/sourcemap-codec": "^1.6.0",
+		"@sveltejs/acorn-typescript": "^1.0.13",
+		"@types/estree": "^1.0.9",
+		"acorn": "^8.18.0",
+		"vigla": "0.2.0",
+		"esrap": "^2.3.6"
+	}
+}

package/src/compiler/diagnostics.ts

@@ -0,0 +1,233 @@
+import { CompileError as Fault, type Diagnostic } from 'vigla/compiler';
+import { locator, type Locator } from '../front/index.ts';
+
+export interface Location {
+	line: number;
+	column: number;
+	character: number;
+}
+
+export interface Warning {
+	code: string;
+	message: string;
+	filename?: string;
+	start?: Location;
+	end?: Location;
+	position?: [number, number];
+	frame?: string;
+}
+
+const unknownFilename = '(unknown)';
+const leadingTabs = /^\t+/;
+
+function tabsToSpaces(line: string): string {
+	return line.replace(leadingTabs, (tabs) => '  '.repeat(tabs.length));
+}
+
+function codeFrame(lines: readonly string[], line: number, column: number): string {
+	const first = Math.max(0, line - 2);
+	const last = Math.min(line + 3, lines.length);
+	const digits = String(last + 1).length;
+	const out: string[] = [];
+	for (let index = first; index < last; index++) {
+		const text = lines[index] as string;
+		const number = String(index + 1).padStart(digits, ' ');
+		out.push(`${number}: ${tabsToSpaces(text)}`);
+		if (index === line) {
+			const indent = digits + 2 + tabsToSpaces(text.slice(0, column)).length;
+			out.push(`${' '.repeat(indent)}^`);
+		}
+	}
+	return out.join('\n');
+}
+
+function link(diagnostic: { code: string; message: string }): string {
+	return `${diagnostic.message}\nhttps://svelte.dev/e/${diagnostic.code}`;
+}
+
+interface Located {
+	readonly filename?: string;
+	readonly position?: [number, number];
+	readonly start?: Location;
+	readonly end?: Location;
+	readonly frame?: () => string;
+}
+
+function place(target: object, at: Located): void {
+	const { frame, ...rest } = at;
+	Object.assign(target, rest);
+	if (frame === undefined) return;
+	let text: string | undefined;
+	Object.defineProperty(target, 'frame', {
+		enumerable: true,
+		configurable: true,
+		get: () => (text ??= frame()),
+		set: (value: string) => {
+			text = value;
+		}
+	});
+}
+
+function described(code: string, message: string, at: Warning): string {
+	let out = `${code}: ${message}`;
+	if (at.filename !== undefined) {
+		out += `\n${at.filename}`;
+		if (at.start !== undefined) out += `:${at.start.line}:${at.start.column}`;
+	}
+	if (at.frame !== undefined) out += `\n${at.frame}`;
+	return out;
+}
+
+export class CompileWarning implements Warning {
+	readonly name = 'CompileWarning';
+	code: string;
+	message: string;
+	declare filename?: string;
+	declare position?: [number, number];
+	declare start?: Location;
+	declare end?: Location;
+	declare frame?: string;
+
+	constructor(code: string, message: string, at: Located) {
+		this.code = code;
+		this.message = message;
+		place(this, at);
+	}
+
+	toString(): string {
+		return described(this.code, this.message, this);
+	}
+
+	toJSON(): Warning {
+		const { code, message, filename, start, end, position, frame } = this;
+		return { code, message, filename, start, end, position, frame };
+	}
+}
+
+export class CompileError extends Error {
+	override message = '';
+	code: string;
+	declare filename?: string;
+	declare position?: [number, number];
+	declare start?: Location;
+	declare end?: Location;
+	declare frame?: string;
+
+	constructor(code: string, message: string, at: Located) {
+		super(message);
+		this.stack = '';
+		this.message = message;
+		this.code = code;
+		place(this, at);
+		this.name = 'CompileError';
+	}
+
+	override toString(): string {
+		return described(this.code, this.message, this);
+	}
+
+	toJSON(): Warning {
+		const { code, message, filename, start, end, position, frame } = this;
+		return { code, message, filename, start, end, position, frame };
+	}
+}
+
+export interface Notice {
+	readonly code: string;
+	readonly message: string;
+}
+
+export interface Place {
+	readonly filename?: string;
+	readonly rootDir?: string;
+}
+
+function normalized(filename: string | undefined): string {
+	return (filename ?? unknownFilename).replace(/\\/g, '/');
+}
+
+export function relativeFilename(place: Place): string {
+	const filename = normalized(place.filename);
+	const root = place.rootDir?.replace(/\\/g, '/');
+	if (root === undefined || !filename.startsWith(root)) return filename;
+	return filename.replace(root, '').replace(/^[/\\]/, '');
+}
+
+export class Diagnostics {
+	readonly source: string;
+	readonly #place: Place;
+	readonly #filter: (warning: Warning) => boolean;
+	#filename: string;
+	#locate: Locator | undefined;
+	#lines: string[] | undefined;
+
+	constructor(source: string, place: Place, filter?: (warning: Warning) => boolean) {
+		this.source = source;
+		this.#place = place;
+		this.#filter = filter ?? (() => true);
+		this.#filename = normalized(place.filename);
+	}
+
+	analysing(): void {
+		this.#filename = relativeFilename(this.#place);
+	}
+
+	get locate(): Locator {
+		this.#locate ??= locator(this.source);
+		return this.#locate;
+	}
+
+	located(start: number | undefined, end: number | undefined): Located {
+		const filename = this.#filename === unknownFilename ? undefined : this.#filename;
+		if (start === undefined) return filename === undefined ? {} : { filename };
+		const finish = end ?? start;
+		const from = this.locate(start);
+		const to = this.locate(finish);
+		this.#lines ??= this.source.split('\n');
+		const lines = this.#lines;
+		const frame = (): string => codeFrame(lines, from.line - 1, to.column);
+		return {
+			...(filename === undefined ? {} : { filename }),
+			position: [start, finish],
+			start: from,
+			end: to,
+			frame
+		};
+	}
+
+	notices(notices: readonly Notice[]): Warning[] {
+		return notices
+			.map(
+				(notice) =>
+					new CompileWarning(notice.code, link(notice), this.located(undefined, undefined))
+			)
+			.filter(this.#filter);
+	}
+
+	warnings(diagnostics: readonly Diagnostic[]): Warning[] {
+		const reshaped: Warning[] = [];
+		for (const diagnostic of diagnostics) {
+			const warning = new CompileWarning(
+				diagnostic.code,
+				link(diagnostic),
+				this.located(diagnostic.start, diagnostic.end)
+			);
+			if (this.#filter(warning)) reshaped.push(warning);
+		}
+		return reshaped;
+	}
+
+	guard<T>(run: () => T): T {
+		try {
+			return run();
+		} catch (error) {
+			if (error instanceof Fault) {
+				const { code, start, end } = error.diagnostic;
+				const unplaced = code.startsWith('options_');
+				const at = unplaced ? this.located(undefined, undefined) : this.located(start, end);
+				throw new CompileError(code, link(error.diagnostic), at);
+			}
+			throw error;
+		}
+	}
+}

package/src/compiler/index.ts

@@ -0,0 +1,292 @@
+import {
+	analyzeStyle,
+	compile as compileUnit,
+	hash,
+	compileModule as compileModuleUnit,
+	validateComponent as validateUnit,
+	validateModule as validateModuleUnit,
+	type Code,
+	type Diagnostic,
+	type InputMap,
+	type Runtime,
+	type ValidateOptions
+} from 'vigla/compiler';
+import {
+	front,
+	legacy,
+	lowerComponent,
+	parseComponent,
+	parseStylesheet,
+	validateComponent,
+	validateModuleSyntax,
+	wording,
+	type AST,
+	type Parsed
+} from '../front/index.ts';
+import { Diagnostics, relativeFilename, type Warning } from './diagnostics.ts';
+import { validate } from './options.ts';
+import { format } from '../shared/format.ts';
+import { proxyDiagnostics } from './proxy.ts';
+
+export { CompileError, CompileWarning, type Location, type Warning } from './diagnostics.ts';
+export { format } from '../shared/format.ts';
+export { print, type PrintOptions, type Printed } from '../front/index.ts';
+export {
+	preprocess,
+	type MarkupPreprocessor,
+	type Preprocessor,
+	type PreprocessorGroup,
+	type Processed
+} from './preprocess/index.ts';
+export type { AST };
+
+export const VERSION = '5.57.4';
+
+export interface Experimental {
+	async?: boolean;
+}
+
+export interface ModuleCompileOptions {
+	filename?: string;
+	rootDir?: string;
+	dev?: boolean;
+	generate?: 'client' | 'server' | false;
+	warningFilter?: (warning: Warning) => boolean;
+	experimental?: Experimental;
+}
+
+export interface CssHashInput {
+	name: string;
+	filename: string;
+	css: string;
+	hash: (input: string) => string;
+}
+
+export interface CompileOptions extends ModuleCompileOptions {
+	name?: string;
+	runes?: boolean;
+	css?: 'injected' | 'external';
+	cssHash?: (input: CssHashInput) => string;
+	cssOutputFilename?: string;
+	outputFilename?: string;
+	customElement?: boolean;
+	discloseVersion?: boolean;
+	namespace?: 'html' | 'svg' | 'mathml';
+	modernAst?: boolean;
+	preserveComments?: boolean;
+	preserveWhitespace?: boolean;
+	fragments?: 'html' | 'tree';
+	hmr?: boolean;
+	sourcemap?: InputMap;
+}
+
+export interface Metadata {
+	runes: boolean;
+}
+
+export interface CssResult {
+	code: string;
+	map: unknown;
+	hasGlobal: boolean;
+}
+
+export interface CompileResult {
+	js: Code | null;
+	css: CssResult | null;
+	warnings: Warning[];
+	metadata: Metadata;
+	ast?: AST.Root | Record<string, any>;
+}
+
+export interface ParseOptions {
+	filename?: string;
+	rootDir?: string;
+	modern?: boolean;
+	loose?: boolean;
+}
+
+const stores = ['svelte/store'];
+
+const runtime: Runtime = {
+	client: 'svelte/internal/client',
+	server: 'svelte/internal/server',
+	names: { pre: 'user_pre_effect', userEffect: 'user_effect' }
+};
+
+function generated(options: ModuleCompileOptions): 'client' | 'server' {
+	return options.generate === 'server' ? 'server' : 'client';
+}
+
+function sourceName(filename: string | undefined): string {
+	const parts = (filename ?? '(unknown)').split(/[/\\]/);
+	const base = parts.pop() as string;
+	const directory = parts.at(-1);
+	let name = base.replace('.svelte', '');
+	if (name === 'index' && directory && directory !== 'src') name = directory;
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function functionName(preferred: string): string {
+	return preferred.replace(/[^a-zA-Z0-9_$]/g, '_').replace(/^[0-9]/, '_');
+}
+
+function styleHash(root: AST.Root, options: CompileOptions, name: string): string {
+	if (root.css === null) return '';
+	const css = root.css.content.styles;
+	const filename = relativeFilename(options);
+	if (options.cssHash) return options.cssHash({ name, filename, css, hash });
+	return `svelte-${hash(filename === '(unknown)' ? css : filename)}`;
+}
+
+function publicAst(
+	source: string,
+	parsed: Parsed,
+	modern: boolean | undefined
+): AST.Root | Record<string, any> {
+	return modern ? parsed.root : legacy(source, parsed.root, parsed.options);
+}
+
+function withoutBom(source: string): string {
+	return source.charCodeAt(0) === 0xfeff ? source.slice(1) : source;
+}
+
+export function parse(source: string, options: ParseOptions & { modern: true }): AST.Root;
+export function parse(source: string, options?: ParseOptions): Record<string, any>;
+export function parse(
+	input: string,
+	{ modern, loose }: ParseOptions = {}
+): AST.Root | Record<string, any> {
+	if (typeof input !== 'string') throw new TypeError('Template must be a string');
+	const source = withoutBom(input);
+	return new Diagnostics(source, {}).guard(() => {
+		const parsed = parseComponent(source, loose);
+		return modern ? parsed.root : legacy(source, parsed.root, parsed.options);
+	});
+}
+
+export function parseCss(input: string): AST.Css.StyleSheetFile {
+	const source = withoutBom(input);
+	return new Diagnostics(source, {}).guard(() => parseStylesheet(source));
+}
+
+export function compile(input: string, options: CompileOptions = {}): CompileResult {
+	const source = withoutBom(input);
+	const diagnostics = new Diagnostics(source, options, options.warningFilter);
+	return diagnostics.guard(() => {
+		const notices = diagnostics.notices(validate(options, 'component'));
+		const parsed = parseComponent(source);
+		diagnostics.analysing();
+		const reading = lowerComponent(parsed, source, options.filename ?? null);
+		const syntax = validateComponent(parsed, source, {
+			customElement: options.customElement === true,
+			filename: options.filename
+		});
+		const validation: ValidateOptions = {
+			customElement: options.customElement === true,
+			namespace: options.namespace,
+			stores,
+			wording,
+			front: {
+				before: syntax.before,
+				at: syntax.anchors.translated(reading.lowered, reading.anchored)
+			}
+		};
+		const reported = (core: readonly Diagnostic[]): Warning[] => [
+			...notices,
+			...diagnostics.warnings([...syntax.parse, ...core])
+		];
+		const named = sourceName(options.filename);
+		const name = functionName(options.name ?? named);
+		const css = {
+			hash: styleHash(parsed.root, options, named),
+			id:
+				options.cssHash === undefined && relativeFilename(options) === '(unknown)'
+					? `svelte-${hash(source)}`
+					: undefined,
+			inject: options.css === 'injected',
+			outputFilename: options.cssOutputFilename
+		};
+		if (options.generate === false) {
+			const core = validateUnit(reading.unit, validation);
+			const style = analyzeStyle(reading.unit, { hash: css.hash });
+			return {
+				js: null,
+				css: null,
+				warnings: reported([...core, ...style.warnings]),
+				metadata: { runes: true },
+				ast: publicAst(source, parsed, options.modernAst)
+			};
+		}
+		const output = compileUnit(reading.unit, {
+			generate: generated(options),
+			runtime,
+			clientExpression:
+				options.dev && generated(options) === 'client'
+					? proxyDiagnostics(reading.unit, relativeFilename(options))
+					: undefined,
+			format,
+			devFilename: relativeFilename(options),
+			discloseVersion: options.discloseVersion === false ? false : '5',
+			name,
+			customElement: options.customElement ?? false,
+			css,
+			dev: options.dev,
+			namespace: options.namespace,
+			preserveWhitespace: options.preserveWhitespace,
+			preserveComments: options.preserveComments,
+			fragments: options.fragments,
+			validation,
+			outputFilename: options.outputFilename,
+			inputMap: options.sourcemap,
+			hmr: options.hmr
+		});
+		return {
+			js: output.js,
+			css: output.css,
+			warnings: reported(output.warnings),
+			metadata: { runes: true },
+			ast: publicAst(source, parsed, options.modernAst)
+		};
+	});
+}
+
+export function compileModule(input: string, options: ModuleCompileOptions = {}): CompileResult {
+	const source = withoutBom(input);
+	const diagnostics = new Diagnostics(source, options, options.warningFilter);
+	return diagnostics.guard(() => {
+		const notices = diagnostics.notices(validate(options, 'module'));
+		diagnostics.analysing();
+		const reading = front.module({ source, filename: options.filename ?? null });
+		const program = reading.unit.program;
+		const validation: ValidateOptions = {
+			stores,
+			wording,
+			front: { at: validateModuleSyntax(program).translated(new Map(), new Map()) }
+		};
+		if (options.generate === false) {
+			const core = validateModuleUnit(reading.unit, validation);
+			return {
+				js: null,
+				css: null,
+				warnings: [...notices, ...diagnostics.warnings(core)],
+				metadata: { runes: true }
+			};
+		}
+		const output = compileModuleUnit(reading.unit, {
+			generate: generated(options),
+			runtime,
+			clientExpression:
+				options.dev && generated(options) === 'client'
+					? proxyDiagnostics(reading.unit, relativeFilename(options))
+					: undefined,
+			dev: options.dev,
+			validation
+		});
+		return {
+			js: output.js,
+			css: null,
+			warnings: [...notices, ...diagnostics.warnings(output.warnings)],
+			metadata: { runes: true }
+		};
+	});
+}