@vigla/svelte 0.0.0-stage → 5.57.4

package/src/compiler/options.ts

@@ -0,0 +1,140 @@
+import { CompileError } from 'vigla/compiler';
+
+export interface Notice {
+	readonly code: string;
+	readonly message: string;
+}
+
+export type Kind = 'component' | 'module';
+
+const moduleKeys = ['filename', 'rootDir', 'dev', 'generate', 'warningFilter', 'experimental'];
+
+const componentKeys = new Set([
+	...moduleKeys,
+	'name',
+	'runes',
+	'css',
+	'cssHash',
+	'cssOutputFilename',
+	'outputFilename',
+	'customElement',
+	'discloseVersion',
+	'namespace',
+	'modernAst',
+	'preserveComments',
+	'preserveWhitespace',
+	'fragments',
+	'hmr',
+	'sourcemap',
+	'accessors',
+	'immutable',
+	'compatibility',
+	'legacy',
+	'format',
+	'tag',
+	'sveltePath',
+	'errorMode',
+	'varsReport',
+	'loopGuardTimeout',
+	'enableSourcemap',
+	'hydratable'
+]);
+
+const removed: Readonly<Record<string, string>> = {
+	legacy:
+		'The legacy option has been removed. If you are using this because of legacy.componentApi, use compatibility.componentApi instead',
+	format:
+		'The format option has been removed in Svelte 4, the compiler only outputs ESM now. Remove "format" from your compiler options. If you did not set this yourself, bump the version of your bundler plugin (vite-plugin-svelte/rollup-plugin-svelte/svelte-loader)',
+	tag: 'The tag option has been removed in Svelte 5. Use `<svelte:options customElement="tag-name" />` inside the component instead. If that does not solve your use case, please open an issue on GitHub with details.',
+	sveltePath:
+		'The sveltePath option has been removed in Svelte 5. If this option was crucial for you, please open an issue on GitHub with your use case.',
+	errorMode:
+		'The errorMode option has been removed. If you are using this through svelte-preprocess with TypeScript, use the https://www.typescriptlang.org/tsconfig#verbatimModuleSyntax setting instead',
+	varsReport:
+		'The vars option has been removed. If you are using this through svelte-preprocess with TypeScript, use the https://www.typescriptlang.org/tsconfig#verbatimModuleSyntax setting instead'
+};
+
+const retired: Readonly<Record<string, Notice>> = {
+	loopGuardTimeout: {
+		code: 'options_removed_loop_guard_timeout',
+		message: 'The `loopGuardTimeout` option has been removed'
+	},
+	enableSourcemap: {
+		code: 'options_removed_enable_sourcemap',
+		message:
+			'The `enableSourcemap` option has been removed. Source maps are always generated now, and tooling can choose to ignore them'
+	},
+	hydratable: {
+		code: 'options_removed_hydratable',
+		message: 'The `hydratable` option has been removed. Svelte components are always hydratable now'
+	}
+};
+
+const deprecated: Readonly<Record<string, Notice>> = {
+	accessors: {
+		code: 'options_deprecated_accessors',
+		message: 'The `accessors` option has been deprecated. It will have no effect in runes mode'
+	},
+	immutable: {
+		code: 'options_deprecated_immutable',
+		message: 'The `immutable` option has been deprecated. It will have no effect in runes mode'
+	}
+};
+
+function fail(code: string, message: string): never {
+	throw new CompileError({ code, message, start: 0, end: 0 });
+}
+
+function invalid(details: string): never {
+	fail('options_invalid_value', `Invalid compiler option: ${details}`);
+}
+
+function nested(value: unknown, path: string, allowed: readonly string[]): Record<string, unknown> {
+	if (value === undefined) return {};
+	if (typeof value !== 'object' || value === null) invalid(`${path} should be an object`);
+	const record = value as Record<string, unknown>;
+	for (const key of Object.keys(record)) {
+		if (!allowed.includes(key))
+			fail('options_unrecognised', `Unrecognised compiler option ${path}.${key}`);
+	}
+	return record;
+}
+
+export function validate(options: object, kind: Kind): Notice[] {
+	const given = options as Record<string, unknown>;
+	const notices: Notice[] = [];
+	for (const key of Object.keys(given)) {
+		if (!componentKeys.has(key))
+			fail('options_unrecognised', `Unrecognised compiler option ${key}`);
+		if (given[key] === undefined) continue;
+		if (kind === 'module' && !moduleKeys.includes(key)) continue;
+		const message = removed[key];
+		if (message !== undefined) fail('options_removed', `Invalid compiler option: ${message}`);
+		const notice = deprecated[key];
+		if (notice !== undefined) fail(notice.code, notice.message);
+		const retirement = retired[key];
+		if (retirement !== undefined) notices.push(retirement);
+	}
+	const experimental = nested(given.experimental, 'experimental', ['async']);
+	if (experimental.async === false) invalid('`experimental.async: false` — async is the only mode');
+	if (kind === 'module') return notices;
+	const compatibility = nested(given.compatibility, 'compatibility', ['componentApi']);
+	if (compatibility.componentApi === 4) {
+		invalid('`compatibility.componentApi: 4` — the Svelte 4 component API is not supported');
+	}
+	const runes =
+		typeof given.runes === 'function' ? given.runes({ filename: given.filename }) : given.runes;
+	if (runes === false) invalid('`runes: false` — legacy mode is not supported');
+	if (
+		given.namespace !== undefined &&
+		given.namespace !== 'html' &&
+		given.namespace !== 'svg' &&
+		given.namespace !== 'mathml'
+	) {
+		invalid('namespace should be one of "html", "mathml" or "svg"');
+	}
+	if (given.fragments !== undefined && given.fragments !== 'html' && given.fragments !== 'tree') {
+		invalid('fragments should be either "html" or "tree"');
+	}
+	return notices;
+}

package/src/compiler/preprocess/decode.ts

@@ -0,0 +1,85 @@
+import { decode } from '@jridgewell/sourcemap-codec';
+import type { Map, Segment } from './mapped.ts';
+
+interface GeneratorMapping {
+	generatedLine: number;
+	generatedColumn: number;
+	originalLine: number;
+	originalColumn: number;
+	source: string | null;
+	name: string | null;
+}
+
+interface Generator {
+	_version: number;
+	_file?: string | null;
+	_sources: { toArray(): string[] };
+	_names: { toArray(): string[] };
+	_mappings: { toArray(): GeneratorMapping[] };
+}
+
+function indexOf(values: readonly string[]): Record<string, number> {
+	const index: Record<string, number> = {};
+	values.forEach((value, position) => {
+		index[value] = position;
+	});
+	return index;
+}
+
+function same(a: GeneratorMapping, b: GeneratorMapping): boolean {
+	return (
+		a.generatedColumn === b.generatedColumn &&
+		a.originalColumn === b.originalColumn &&
+		a.name === b.name &&
+		a.generatedLine === b.generatedLine &&
+		a.originalLine === b.originalLine &&
+		a.source === b.source
+	);
+}
+
+function fromGenerator(generator: Generator): Map {
+	const sources = generator._sources.toArray();
+	const names = generator._names.toArray();
+	const sourceIndex = indexOf(sources);
+	const nameIndex = indexOf(names);
+	const mappings = generator._mappings.toArray();
+	const lines: Segment[][] = [[]];
+	let line = 1;
+	let current = lines[0] as Segment[];
+	mappings.forEach((mapping, index) => {
+		if (mapping.generatedLine > line) {
+			while (mapping.generatedLine > line) {
+				lines.push([]);
+				line++;
+			}
+			current = lines[mapping.generatedLine - 1] as Segment[];
+		} else if (index > 0 && same(mapping, mappings[index - 1] as GeneratorMapping)) {
+			return;
+		}
+		const segment: Segment = [mapping.generatedColumn];
+		if (mapping.source != null) {
+			segment.push(
+				sourceIndex[mapping.source] as number,
+				mapping.originalLine - 1,
+				mapping.originalColumn
+			);
+			if (mapping.name != null) segment.push(nameIndex[mapping.name] as number);
+		}
+		current.push(segment);
+	});
+	const map = { version: generator._version, sources, names, mappings: lines } as unknown as Map & {
+		file?: string;
+	};
+	if (generator._file != null) map.file = generator._file;
+	return map;
+}
+
+export function decodeMap(raw: string | object): Map {
+	let map = (typeof raw === 'string' ? JSON.parse(raw) : raw) as Map & { mappings: unknown };
+	if (typeof map.mappings === 'string') map.mappings = decode(map.mappings) as never;
+	const generator = map as unknown as Generator & { constructor: { name: string } };
+	if (generator._mappings && generator.constructor.name === 'SourceMapGenerator') {
+		map = fromGenerator(generator);
+	}
+	return map;
+}

package/src/compiler/preprocess/index.ts

@@ -0,0 +1,299 @@
+import { basename, combine } from 'vigla/compiler';
+import { locator } from '../../front/index.ts';
+import { decodeMap } from './decode.ts';
+import {
+	MappedCode,
+	addOffset,
+	slice,
+	type Map,
+	type Point,
+	type Segment,
+	type Source
+} from './mapped.ts';
+
+export interface Processed {
+	code: string;
+	map?: string | object;
+	dependencies?: string[];
+	attributes?: Record<string, string | boolean>;
+	toString?: () => string;
+}
+
+export type MarkupPreprocessor = (options: {
+	content: string;
+	filename?: string;
+}) => Processed | void | Promise<Processed | void>;
+
+export type Preprocessor = (options: {
+	content: string;
+	attributes: Record<string, string | boolean>;
+	markup: string;
+	filename?: string;
+}) => Processed | void | Promise<Processed | void>;
+
+export interface PreprocessorGroup {
+	name?: string;
+	markup?: MarkupPreprocessor;
+	style?: Preprocessor;
+	script?: Preprocessor;
+}
+
+interface Update {
+	string?: string;
+	map?: Map;
+	dependencies?: string[];
+}
+
+function pointer(text: string): (offset: number) => Point {
+	const locate = locator(text);
+	return (offset) => {
+		const { line, column } = locate(offset);
+		return { line: line - 1, column };
+	};
+}
+
+class Result implements Source {
+	source: string;
+	readonly filename: string | undefined;
+	readonly basename: string | null;
+	readonly maps: Map[] = [];
+	readonly dependencies: string[] = [];
+	locate: (offset: number) => Point;
+
+	constructor(source: string, filename: string | undefined) {
+		this.source = source;
+		this.filename = filename;
+		this.locate = pointer(source);
+		this.basename = filename == null ? null : basename(filename);
+	}
+
+	update({ string, map, dependencies }: Update): void {
+		if (string != null) {
+			this.source = string;
+			this.locate = pointer(string);
+		}
+		if (map) this.maps.unshift(map);
+		if (dependencies) this.dependencies.push(...dependencies);
+	}
+
+	processed(): Processed {
+		const code = this.source;
+		return {
+			code,
+			dependencies: [...new Set(this.dependencies)],
+			map: combine(this.basename, this.maps) as unknown as object,
+			toString: () => code
+		};
+	}
+}
+
+const dataUri = /data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(\S*)/;
+const mappingUrl = '[#@]\\s*sourceMappingURL\\s*=\\s*(\\S*)';
+const scriptMapping = new RegExp(`(?://${mappingUrl})|(?:/\\*${mappingUrl}\\s*\\*/)$`);
+const styleMapping = new RegExp(`/\\*${mappingUrl}\\s*\\*/$`);
+
+function decodeBase64(data: string): string {
+	if (typeof Buffer === 'function') return Buffer.from(data, 'base64').toString();
+	const bytes = Uint8Array.from(atob(data), (char) => char.charCodeAt(0));
+	return new TextDecoder().decode(bytes);
+}
+
+function attachedMap(processed: Processed, tag: 'script' | 'style'): void {
+	const warn = (message: string): void => {
+		const start =
+			processed.code.length < 100 ? processed.code : `${processed.code.slice(0, 100)} [...]`;
+		console.warn(`warning: ${message}. processed.code = ${JSON.stringify(start)}`);
+	};
+	processed.code = processed.code.replace(
+		tag === 'script' ? scriptMapping : styleMapping,
+		(_, first: string | undefined, second: string | undefined) => {
+			const url = (tag === 'script' ? first || second : first) as string;
+			const data = (url.match(dataUri) ?? [])[1];
+			if (data) {
+				if (processed.map) {
+					warn(
+						'Not implemented. Found sourcemap in both processed.code and processed.map. Please update your preprocessor to return only one sourcemap.'
+					);
+					return '';
+				}
+				processed.map = decodeBase64(data);
+				return '';
+			}
+			if (!processed.map) {
+				warn(
+					`Found sourcemap path ${JSON.stringify(url)} in processed.code, but no sourcemap data. Please update your preprocessor to return sourcemap data directly.`
+				);
+			}
+			return '';
+		}
+	);
+}
+
+function contentCode(processed: Processed, location: Point, basename: string | null): MappedCode {
+	let map: Map | undefined;
+	if (processed.map) {
+		map = decodeMap(processed.map);
+		if (map?.sources) {
+			const index = map.sources.indexOf(basename);
+			if (index !== -1) addOffset(map, location, index);
+		}
+	}
+	return MappedCode.processed(processed.code, map);
+}
+
+function tagCode(
+	processed: Processed,
+	tag: 'style' | 'script',
+	originalAttributes: string,
+	attributes: string,
+	source: Source
+): MappedCode {
+	const originalOpen = `<${tag}${originalAttributes}>`;
+	const open = `<${tag}${attributes}>`;
+	let openCode: MappedCode;
+	if (originalOpen.length !== open.length) {
+		const name = `<${tag}`.length;
+		const mappings: Segment[][] = [
+			[
+				[0, 0, 0, 0],
+				[name, 0, 0, name]
+			]
+		];
+		const line = open.split('\n').length - 1;
+		const column = open.length - (line === 0 ? 0 : open.lastIndexOf('\n')) - 1;
+		while (mappings.length <= line) mappings.push([[0, 0, 0, name]]);
+		(mappings[line] as Segment[]).push([
+			column,
+			0,
+			originalOpen.split('\n').length - 1,
+			originalOpen.length - originalOpen.lastIndexOf('\n') - 1
+		]);
+		const map = { version: 3, names: [], sources: [source.basename], mappings } as unknown as Map;
+		addOffset(map, source.locate(0), 0);
+		openCode = MappedCode.processed(open, map);
+	} else {
+		openCode = MappedCode.source(slice(open, 0, source));
+	}
+	const closeCode = MappedCode.source(
+		slice(`</${tag}>`, originalOpen.length + source.source.length, source)
+	);
+	attachedMap(processed, tag);
+	const content = contentCode(processed, source.locate(originalOpen.length), source.basename);
+	return openCode.concat(content).concat(closeCode);
+}
+
+const attributePattern = /([\w-$]+\b)(?:=(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+
+function parseAttributes(text: string): Record<string, string | boolean> {
+	const attributes: Record<string, string | boolean> = {};
+	for (const match of text.matchAll(attributePattern)) {
+		const value = match[2] || match[3] || match[4];
+		attributes[match[1] as string] = !value || value;
+	}
+	return attributes;
+}
+
+function stringifyAttributes(
+	attributes: Record<string, string | boolean> | undefined
+): string | undefined {
+	if (!attributes) return undefined;
+	const value = Object.entries(attributes)
+		.map(([key, value]) => (value === true ? key : `${key}="${value}"`))
+		.join(' ');
+	return value ? ` ${value}` : value;
+}
+
+const styleTags =
+	/<!--[^]*?-->|<style((?:\s+[^=>'"/\s]+=(?:"[^"]*"|'[^']*'|[^>\s]+)|\s+[^=>'"/\s]+)*\s*)(?:\/>|>([\S\s]*?)<\/style>)/g;
+const scriptTags =
+	/<!--[^]*?-->|<script((?:\s+[^=>'"/\s]+=(?:"[^"]*"|'[^']*'|[^>\s]+)|\s+[^=>'"/\s]+)*\s*)(?:\/>|>([\S\s]*?)<\/script>)/g;
+
+interface Replacement {
+	offset: number;
+	length: number;
+	code: MappedCode;
+}
+
+async function processTag(
+	tag: 'style' | 'script',
+	preprocessor: Preprocessor,
+	source: Source
+): Promise<Update> {
+	const dependencies: string[] = [];
+	const markup = source.source;
+	const single = async (
+		whole: string,
+		attributes = '',
+		content = '',
+		offset: number
+	): Promise<MappedCode> => {
+		const unchanged = (): MappedCode => MappedCode.source(slice(whole, offset, source));
+		if (!attributes && !content) return unchanged();
+		const processed = await preprocessor({
+			content: content || '',
+			attributes: parseAttributes(attributes || ''),
+			markup,
+			filename: source.filename
+		});
+		if (!processed) return unchanged();
+		if (processed.dependencies) dependencies.push(...processed.dependencies);
+		if (!processed.map && processed.code === content) return unchanged();
+		return tagCode(
+			processed,
+			tag,
+			attributes,
+			stringifyAttributes(processed.attributes) ?? attributes,
+			slice(content, offset, source)
+		);
+	};
+
+	const pending: Promise<Replacement>[] = [];
+	for (const match of markup.matchAll(tag === 'style' ? styleTags : scriptTags)) {
+		const offset = match.index;
+		pending.push(
+			single(match[0], match[1], match[2], offset).then((code) => ({
+				offset,
+				length: match[0].length,
+				code
+			}))
+		);
+	}
+	const replacements = await Promise.all(pending);
+	const out = new MappedCode();
+	let end = 0;
+	for (const { offset, length, code } of replacements) {
+		out.concat(MappedCode.source(slice(markup.slice(end, offset), end, source))).concat(code);
+		end = offset + length;
+	}
+	out.concat(MappedCode.source(slice(markup.slice(end), end, source)));
+	return { string: out.string, map: out.map, dependencies };
+}
+
+async function processMarkup(process: MarkupPreprocessor, source: Source): Promise<Update> {
+	const processed = await process({ content: source.source, filename: source.filename });
+	if (!processed) return {};
+	return {
+		string: processed.code,
+		map: processed.map
+			? ((typeof processed.map === 'string' ? JSON.parse(processed.map) : processed.map) as Map)
+			: undefined,
+		dependencies: processed.dependencies
+	};
+}
+
+export async function preprocess(
+	source: string,
+	preprocessor: PreprocessorGroup | PreprocessorGroup[],
+	options?: { filename?: string }
+): Promise<Processed> {
+	const filename =
+		(options && options.filename) || (preprocessor as { filename?: string } | undefined)?.filename;
+	const groups = preprocessor ? (Array.isArray(preprocessor) ? preprocessor : [preprocessor]) : [];
+	const result = new Result(source, filename);
+	for (const group of groups) {
+		if (group.markup) result.update(await processMarkup(group.markup, result));
+		if (group.script) result.update(await processTag('script', group.script, result));
+		if (group.style) result.update(await processTag('style', group.style, result));
+	}
+	return result.processed();
+}

package/src/compiler/preprocess/mapped.ts

@@ -0,0 +1,146 @@
+import type { DecodedSourceMap, SourceMapSegment } from '@jridgewell/remapping';
+
+export type Map = DecodedSourceMap;
+export type Segment = number[];
+
+export interface Point {
+	line: number;
+	column: number;
+}
+
+export interface Source {
+	source: string;
+	locate: (offset: number) => Point;
+	basename: string | null;
+	filename: string | undefined;
+}
+
+export function slice(code: string, offset: number, source: Source): Source {
+	return {
+		source: code,
+		locate: (index) => source.locate(index + offset),
+		basename: source.basename,
+		filename: source.filename
+	};
+}
+
+export function addOffset(map: Map, offset: Point, sourceIndex: number): void {
+	for (const line of map.mappings) {
+		for (const segment of line as unknown as Segment[]) {
+			if (segment[1] !== sourceIndex) continue;
+			if (segment[2] === 0) (segment[3] as number) += offset.column;
+			(segment[2] as number) += offset.line;
+		}
+	}
+}
+
+function merge<T>(
+	own: readonly T[],
+	other: readonly T[] | undefined
+): [T[], number[], boolean, boolean] {
+	const table = own.slice();
+	const indices: number[] = [];
+	let changed = false;
+	(other ?? []).forEach((value, index) => {
+		const existing = own.indexOf(value);
+		if (existing >= 0) {
+			indices[index] = existing;
+		} else {
+			indices[index] = table.length;
+			table.push(value);
+			changed = true;
+		}
+	});
+	const moved = changed && indices.some((value, index) => value !== index);
+	return [table, indices, changed, moved];
+}
+
+const lineToken = /([^\w\s]|\s+)/g;
+
+function emptyMap(): Map {
+	return { version: 3, mappings: [], sources: [], names: [] } as unknown as Map;
+}
+
+export class MappedCode {
+	string: string;
+	map: Map;
+
+	constructor(string = '', map: Map | null = null) {
+		this.string = string;
+		this.map = map ?? emptyMap();
+	}
+
+	concat(other: MappedCode): MappedCode {
+		if (other.string === '') return this;
+		if (this.string === '') {
+			this.string = other.string;
+			this.map = other.map;
+			return this;
+		}
+		const columnOffset = this.string.length - this.string.lastIndexOf('\n') - 1;
+		this.string += other.string;
+		const own = this.map;
+		const theirs = other.map;
+		if (theirs.mappings.length === 0) return this;
+		const [sources, sourceIndices, sourcesChanged, sourcesMoved] = merge(
+			own.sources,
+			theirs.sources
+		);
+		const [names, nameIndices, namesChanged, namesMoved] = merge(own.names, theirs.names);
+		if (sourcesChanged) own.sources = sources;
+		if (namesChanged) own.names = names;
+		if (sourcesMoved || namesMoved) {
+			for (const line of theirs.mappings) {
+				for (const segment of line as unknown as Segment[]) {
+					if (sourcesMoved && (segment[1] as number) >= 0)
+						segment[1] = sourceIndices[segment[1] as number] as number;
+					if (namesMoved && (segment[4] as number) >= 0)
+						segment[4] = nameIndices[segment[4] as number] as number;
+				}
+			}
+		}
+		const mappings = theirs.mappings as unknown as Segment[][];
+		if (columnOffset > 0) {
+			for (const segment of mappings[0] as Segment[]) (segment[0] as number) += columnOffset;
+		}
+		const ownMappings = own.mappings as unknown as Segment[][];
+		const lastLine = ownMappings[ownMappings.length - 1] as Segment[];
+		for (const segment of mappings.shift() as Segment[]) lastLine.push(segment);
+		for (const line of mappings) ownMappings.push(line);
+		return this;
+	}
+
+	static processed(string: string, map?: Map): MappedCode {
+		const lines = string.split('\n').length;
+		if (map) {
+			for (let missing = lines - map.mappings.length; missing > 0; missing--) map.mappings.push([]);
+			return new MappedCode(string, map);
+		}
+		if (string === '') return new MappedCode();
+		const fresh = emptyMap();
+		for (let index = 0; index < lines; index++) fresh.mappings.push([]);
+		return new MappedCode(string, fresh);
+	}
+
+	static source({ source, basename, locate }: Source): MappedCode {
+		const offset = locate(0) ?? { line: 0, column: 0 };
+		const map = { version: 3, names: [], sources: [basename], mappings: [] } as unknown as Map;
+		if (source === '') return new MappedCode(source, map);
+		const lines = source.split('\n');
+		const mappings = map.mappings as unknown as Segment[][];
+		lines.forEach((text, line) => {
+			const segments: Segment[] = [];
+			mappings.push(segments);
+			let column = 0;
+			for (const token of text.split(lineToken)) {
+				if (token === '') continue;
+				segments.push([column, 0, offset.line + line, column]);
+				column += token.length;
+			}
+		});
+		for (const segment of mappings[0] as Segment[]) (segment[3] as number) += offset.column;
+		return new MappedCode(source, map);
+	}
+}
+
+export type { SourceMapSegment };