vigla 0.0.0 → 0.1.0

package/src/shared/nesting.ts

@@ -0,0 +1,156 @@
+interface Rule {
+	readonly direct?: readonly string[];
+	readonly descendant?: readonly string[];
+	readonly only?: readonly string[];
+	readonly resetBy?: readonly string[];
+}
+
+const headings = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+
+const blocks = [
+	'address',
+	'article',
+	'aside',
+	'blockquote',
+	'div',
+	'dl',
+	'fieldset',
+	'footer',
+	'form',
+	'h1',
+	'h2',
+	'h3',
+	'h4',
+	'h5',
+	'h6',
+	'header',
+	'hgroup',
+	'hr',
+	'main',
+	'menu',
+	'nav',
+	'ol',
+	'p',
+	'pre',
+	'section',
+	'table',
+	'ul'
+];
+
+const sections = ['tr', 'style', 'script', 'template'];
+
+const rules: Readonly<Record<string, Rule>> = {
+	li: { direct: ['li'] },
+	dt: { descendant: ['dt', 'dd'], resetBy: ['dl'] },
+	dd: { descendant: ['dt', 'dd'], resetBy: ['dl'] },
+	p: { descendant: blocks },
+	rt: { descendant: ['rt', 'rp'] },
+	rp: { descendant: ['rt', 'rp'] },
+	optgroup: { descendant: ['optgroup'] },
+	option: { descendant: ['option', 'optgroup'] },
+	thead: { only: sections },
+	tbody: { only: sections },
+	tfoot: { only: sections },
+	tr: { only: ['th', 'td', 'style', 'script', 'template'] },
+	td: { direct: ['td', 'th', 'tr'] },
+	th: { direct: ['td', 'th', 'tr'] },
+	form: { descendant: ['form'] },
+	a: { descendant: ['a'] },
+	button: { descendant: ['button'] },
+	h1: { descendant: headings },
+	h2: { descendant: headings },
+	h3: { descendant: headings },
+	h4: { descendant: headings },
+	h5: { descendant: headings },
+	h6: { descendant: headings },
+	colgroup: { only: ['col', 'template'] },
+	table: {
+		only: ['caption', 'colgroup', 'tbody', 'thead', 'tfoot', 'style', 'script', 'template']
+	},
+	head: {
+		only: [
+			'base',
+			'basefont',
+			'bgsound',
+			'link',
+			'meta',
+			'title',
+			'noscript',
+			'noframes',
+			'style',
+			'script',
+			'template'
+		]
+	},
+	html: { only: ['head', 'body', 'frameset'] },
+	frameset: { only: ['frame'] },
+	'#document': { only: ['html'] }
+};
+
+function tag(name: string, at?: string): string {
+	return at === undefined ? `\`<${name}>\`` : `\`<${name}>\` (${at})`;
+}
+
+export function invalidUnder(
+	child: string,
+	ancestors: readonly string[],
+	childAt?: string,
+	ancestorAt?: string
+): string | null {
+	if (child.includes('-')) return null;
+	const ancestor = ancestors[ancestors.length - 1] as string;
+	const rule = rules[ancestor];
+	if (rule === undefined) return null;
+	if (rule.resetBy !== undefined) {
+		for (let index = ancestors.length - 2; index >= 0; index--) {
+			const name = ancestors[index] as string;
+			if (name.includes('-')) return null;
+			if (rule.resetBy.includes(name)) return null;
+		}
+	}
+	if (rule.descendant?.includes(child))
+		return `${tag(child, childAt)} cannot be a descendant of ${tag(ancestor, ancestorAt)}`;
+	return null;
+}
+
+export function invalidIn(
+	child: string,
+	parent: string,
+	childAt?: string,
+	parentAt?: string
+): string | null {
+	if (child.includes('-') || parent.includes('-')) return null;
+	if (parent === 'template') return null;
+	const rule = rules[parent];
+	const own = tag(child, childAt);
+	const outer = tag(parent, parentAt);
+	if (rule !== undefined) {
+		if (rule.direct?.includes(child)) return `${own} cannot be a direct child of ${outer}`;
+		if (rule.descendant?.includes(child)) return `${own} cannot be a child of ${outer}`;
+		if (rule.only !== undefined) {
+			if (rule.only.includes(child)) return null;
+			return `${own} cannot be a child of ${outer}. ${tag(parent)} only allows these children: ${rule.only.map((name) => tag(name)).join(', ')}`;
+		}
+	}
+	switch (child) {
+		case 'body':
+		case 'caption':
+		case 'col':
+		case 'colgroup':
+		case 'frameset':
+		case 'frame':
+		case 'head':
+		case 'html':
+			return `${own} cannot be a child of ${outer}`;
+		case 'thead':
+		case 'tbody':
+		case 'tfoot':
+			return `${own} must be the child of a \`<table>\`, not a ${outer}`;
+		case 'td':
+		case 'th':
+			return `${own} must be the child of a \`<tr>\`, not a ${outer}`;
+		case 'tr':
+			return `\`<tr>\` must be the child of a \`<thead>\`, \`<tbody>\`, or \`<tfoot>\`, not a ${outer}`;
+	}
+	return null;
+}

package/src/shared/slots.ts

@@ -0,0 +1,16 @@
+export type SlotNames = Readonly<Record<string, boolean>>;
+
+const names = new WeakMap<object, SlotNames>();
+
+interface Slotted {
+	readonly children?: unknown;
+}
+
+export function slotProps<P extends object>(props: P, slots: SlotNames): P {
+	names.set(props, slots);
+	return props;
+}
+
+export function slots(props: Slotted): SlotNames {
+	return names.get(props) ?? (props.children === undefined ? {} : { default: true });
+}

package/src/shared/snippet.ts

@@ -0,0 +1,29 @@
+import { failure } from './diagnostics.ts';
+
+export function invalidArgs(): never {
+	throw failure(
+		'invalid_snippet_arguments',
+		'A snippet function was passed invalid arguments. Snippets should only be instantiated via `{@render ...}`'
+	);
+}
+
+export function snippet<T extends (...args: never[]) => unknown>(fn: T): T {
+	fn.toString = () => {
+		throw failure(
+			'snippet_without_render_tag',
+			'Attempted to render a snippet without a `{@render}` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change `{snippet}` to `{@render snippet()}`.'
+		);
+	};
+	return fn;
+}
+
+export interface RawSnippet {
+	render(): string;
+	setup?(element: Element): void | (() => void);
+}
+
+export type SnippetArgs<Values extends unknown[]> = {
+	[Key in keyof Values]: () => Values[Key];
+};
+
+export type RawFactory<Values extends unknown[]> = (...args: SnippetArgs<Values>) => RawSnippet;