vigla 0.0.0 → 0.1.0

package/src/shared/diagnostics.ts

@@ -0,0 +1,83 @@
+import { DEV } from 'esm-env';
+import type { Format } from './format.ts';
+
+export type Values = Readonly<Record<string, string>>;
+
+export interface Notice {
+	readonly code: string;
+	readonly message: string;
+	readonly values: Values;
+	readonly dev: boolean;
+}
+
+export interface Reporter {
+	warn(notice: Notice): void;
+	error(notice: Notice): Error;
+	formatFrame?(frame: string): string | null;
+	unhandled?(error: unknown): void;
+}
+
+const none: Values = {};
+
+const native: Reporter = {
+	warn({ code, message, dev }) {
+		console.warn(dev ? `${code}: ${message}` : code);
+	},
+	error({ code, message, dev }) {
+		const error = new Error(dev ? `${code}\n${message}` : code);
+		error.name = 'Vigla error';
+		return error;
+	}
+};
+
+let realm: Reporter = native;
+const fronts = new Map<string, Reporter>();
+let speaking: () => Format | null = () => null;
+
+export function setReporter(next: Reporter, front?: Format): void {
+	if (front === undefined) realm = next;
+	else fronts.set(front.global, next);
+}
+
+export function locateFront(locate: () => Format | null): void {
+	speaking = locate;
+}
+
+function reporterOf(front: Format | null): Reporter {
+	return front === null ? realm : (fronts.get(front.global) ?? native);
+}
+
+export function warn(code: string, message: string, values: Values = none): void {
+	reporterOf(speaking()).warn({ code, message, values, dev: DEV });
+}
+
+const failures = new WeakSet<object>();
+
+export function failure(code: string, message: string, values: Values = none): Error {
+	const error = reporterOf(speaking()).error({ code, message, values, dev: DEV });
+	failures.add(error);
+	return error;
+}
+
+export function isFailure(error: unknown): boolean {
+	return typeof error === 'object' && error !== null && failures.has(error);
+}
+
+export function formatFrame(frame: string): string | null {
+	const reporter = reporterOf(speaking());
+	return reporter.formatFrame === undefined ? frame : reporter.formatFrame(frame);
+}
+
+export function unhandled(front: Format | null, error: unknown): void {
+	const reporter = reporterOf(front);
+	if (reporter.unhandled !== undefined) {
+		reporter.unhandled(error);
+		return;
+	}
+	const host = globalThis as { reportError?: (error: unknown) => void };
+	if (typeof host.reportError === 'function') host.reportError(error);
+	else
+		queueMicrotask(() => {
+			throw error;
+		});
+}

package/src/shared/escape.ts

@@ -0,0 +1,20 @@
+const entities: Readonly<Record<string, string>> = { '&': '&amp;', '<': '&lt;', '"': '&quot;' };
+
+const content = /[&<]/g;
+const attribute = /[&<"]/g;
+const contentNeeded = /[&<]/;
+const attributeNeeded = /[&<"]/;
+
+function entity(char: string): string {
+	return entities[char] ?? char;
+}
+
+export function escapeContent(value: unknown): string {
+	const text = String(value ?? '');
+	return contentNeeded.test(text) ? text.replace(content, entity) : text;
+}
+
+export function escapeAttribute(value: unknown): string {
+	const text = String(value ?? '');
+	return attributeNeeded.test(text) ? text.replace(attribute, entity) : text;
+}

package/src/shared/external.ts

@@ -0,0 +1,113 @@
+import { failure } from './diagnostics.ts';
+
+export interface Subscription {
+	unsubscribe(): void;
+}
+
+export interface Subscribable<T> {
+	subscribe(run: (value: T) => void): (() => void) | Subscription;
+	subscribeSync?(run: (value: T) => void): (() => void) | Subscription;
+}
+
+export interface WritableSource<T> extends Subscribable<T> {
+	set(value: T): void;
+}
+
+export interface External<T> {
+	readonly current: T;
+	readonly peek: T;
+	refresh(): void;
+	dispose(): void;
+}
+
+export interface WritableExternal<T> extends External<T> {
+	current: T;
+}
+
+export interface Connected<T> {
+	current: T;
+	readonly peek: T;
+	refresh<R>(result: R): R;
+	mutate<R>(result: R): R;
+	dispose(): void;
+}
+
+export function expose<T>(connected: Connected<T>): WritableExternal<T> {
+	return {
+		get current() {
+			return connected.current;
+		},
+		set current(value: T) {
+			connected.current = value;
+		},
+		get peek() {
+			return connected.peek;
+		},
+		refresh() {
+			connected.refresh(undefined);
+		},
+		dispose() {
+			connected.dispose();
+		}
+	};
+}
+
+export class Connection<T> {
+	#source: Subscribable<T> | null | undefined;
+	#release: (() => void) | undefined;
+	#closed = false;
+	#selected = false;
+	readonly #notify: (before: T, value: T) => void;
+	value: T = undefined as T;
+
+	constructor(notify: (before: T, value: T) => void = () => {}) {
+		this.#notify = notify;
+	}
+
+	select(source: Subscribable<T> | null | undefined, name: string, reset = false): void {
+		if (this.#selected && source === this.#source && !this.#closed) return;
+		this.disconnect();
+		if (source != null && typeof source.subscribe !== 'function') {
+			throw failure(
+				'source_invalid',
+				`\`${name}\` is not a subscribable source with a \`subscribe\` method`,
+				{ name }
+			);
+		}
+		this.#source = source;
+		this.#selected = true;
+		if (reset) this.value = undefined as T;
+		if (source == null) {
+			this.value = undefined as T;
+			return;
+		}
+		let synchronous = true;
+		const subscribe = source.subscribeSync ?? source.subscribe;
+		const subscription = subscribe.call(source, (value) => {
+			const before = this.value;
+			this.value = value;
+			if (!synchronous) this.#notify(before, value);
+		});
+		synchronous = false;
+		const release =
+			typeof subscription === 'function' ? subscription : () => subscription.unsubscribe();
+		if (this.#closed) release();
+		else this.#release = release;
+	}
+
+	refresh(source: Subscribable<T> | null | undefined): void {
+		if (source !== this.#source) this.disconnect();
+	}
+
+	disconnect(): void {
+		const release = this.#release;
+		this.#release = undefined;
+		this.#selected = false;
+		release?.();
+	}
+
+	dispose(): void {
+		this.#closed = true;
+		this.disconnect();
+	}
+}

package/src/shared/format.ts

@@ -0,0 +1,17 @@
+export interface Format {
+	readonly global: string;
+	readonly meta: string;
+	readonly cssWrapper: string;
+	readonly htmlPolicy?: string;
+}
+
+export const format: Format = {
+	global: '__vigla',
+	meta: '__vigla_meta',
+	cssWrapper: 'vigla-css-wrapper',
+	htmlPolicy: 'vigla-html'
+};
+
+export function htmlPolicy(given: Format): string {
+	return given.htmlPolicy ?? (format.htmlPolicy as string);
+}

package/src/shared/hash.ts

@@ -0,0 +1,8 @@
+const returns = /\r/g;
+
+export function hash(text: string): string {
+	const input = text.replace(returns, '');
+	let value = 5381;
+	for (let i = input.length - 1; i >= 0; i--) value = ((value << 5) - value) ^ input.charCodeAt(i);
+	return (value >>> 0).toString(36);
+}

package/src/shared/html.ts

@@ -0,0 +1,298 @@
+const voids = new Set([
+	'area',
+	'base',
+	'br',
+	'col',
+	'command',
+	'embed',
+	'hr',
+	'img',
+	'input',
+	'keygen',
+	'link',
+	'meta',
+	'param',
+	'source',
+	'track',
+	'wbr'
+]);
+
+export function isVoid(name: string): boolean {
+	const lower = name.toLowerCase();
+	return voids.has(lower) || lower === '!doctype';
+}
+
+const reservedTags = new Set([
+	'annotation-xml',
+	'color-profile',
+	'font-face',
+	'font-face-format',
+	'font-face-name',
+	'font-face-src',
+	'font-face-uri',
+	'missing-glyph'
+]);
+
+export function isCustomTag(name: string): boolean {
+	return name.includes('-') && !reservedTags.has(name.toLowerCase());
+}
+
+const rawText = new Set(['textarea', 'script', 'style', 'title']);
+
+export function isRawText(name: string): boolean {
+	return rawText.has(name);
+}
+
+const booleans = new Set([
+	'allowfullscreen',
+	'async',
+	'autofocus',
+	'autoplay',
+	'checked',
+	'controls',
+	'default',
+	'disabled',
+	'formnovalidate',
+	'indeterminate',
+	'inert',
+	'ismap',
+	'loop',
+	'multiple',
+	'muted',
+	'nomodule',
+	'novalidate',
+	'open',
+	'playsinline',
+	'readonly',
+	'required',
+	'reversed',
+	'seamless',
+	'selected',
+	'webkitdirectory',
+	'defer',
+	'disablepictureinpicture',
+	'disableremoteplayback'
+]);
+
+export function isBooleanAttribute(name: string): boolean {
+	return booleans.has(name);
+}
+
+const aliases: Readonly<Record<string, string>> = {
+	formnovalidate: 'formNoValidate',
+	ismap: 'isMap',
+	nomodule: 'noModule',
+	playsinline: 'playsInline',
+	readonly: 'readOnly',
+	defaultvalue: 'defaultValue',
+	defaultchecked: 'defaultChecked',
+	srcobject: 'srcObject',
+	novalidate: 'noValidate',
+	allowfullscreen: 'allowFullscreen',
+	disablepictureinpicture: 'disablePictureInPicture',
+	disableremoteplayback: 'disableRemotePlayback'
+};
+
+export function propertyName(name: string): string {
+	const lower = name.toLowerCase();
+	return aliases[lower] ?? lower;
+}
+
+const properties = new Set([
+	...booleans,
+	'formNoValidate',
+	'isMap',
+	'noModule',
+	'playsInline',
+	'readOnly',
+	'value',
+	'volume',
+	'defaultValue',
+	'defaultChecked',
+	'srcObject',
+	'noValidate',
+	'allowFullscreen',
+	'disablePictureInPicture',
+	'disableRemotePlayback'
+]);
+
+export function isProperty(name: string): boolean {
+	return properties.has(name);
+}
+
+const delegated = new Set([
+	'beforeinput',
+	'click',
+	'change',
+	'dblclick',
+	'contextmenu',
+	'focusin',
+	'focusout',
+	'input',
+	'keydown',
+	'keyup',
+	'mousedown',
+	'mousemove',
+	'mouseout',
+	'mouseover',
+	'mouseup',
+	'pointerdown',
+	'pointermove',
+	'pointerout',
+	'pointerover',
+	'pointerup',
+	'touchend',
+	'touchmove',
+	'touchstart'
+]);
+
+export function isDelegated(event: string): boolean {
+	return delegated.has(event);
+}
+
+export function isPassive(event: string): boolean {
+	return event === 'touchstart' || event === 'touchmove';
+}
+
+export function isCapture(name: string): boolean {
+	return name.endsWith('capture') && name !== 'gotpointercapture' && name !== 'lostpointercapture';
+}
+
+const svg = new Set([
+	'altGlyph',
+	'altGlyphDef',
+	'altGlyphItem',
+	'animate',
+	'animateColor',
+	'animateMotion',
+	'animateTransform',
+	'circle',
+	'clipPath',
+	'color-profile',
+	'cursor',
+	'defs',
+	'desc',
+	'discard',
+	'ellipse',
+	'feBlend',
+	'feColorMatrix',
+	'feComponentTransfer',
+	'feComposite',
+	'feConvolveMatrix',
+	'feDiffuseLighting',
+	'feDisplacementMap',
+	'feDistantLight',
+	'feDropShadow',
+	'feFlood',
+	'feFuncA',
+	'feFuncB',
+	'feFuncG',
+	'feFuncR',
+	'feGaussianBlur',
+	'feImage',
+	'feMerge',
+	'feMergeNode',
+	'feMorphology',
+	'feOffset',
+	'fePointLight',
+	'feSpecularLighting',
+	'feSpotLight',
+	'feTile',
+	'feTurbulence',
+	'filter',
+	'font',
+	'font-face',
+	'font-face-format',
+	'font-face-name',
+	'font-face-src',
+	'font-face-uri',
+	'foreignObject',
+	'g',
+	'glyph',
+	'glyphRef',
+	'hatch',
+	'hatchpath',
+	'hkern',
+	'image',
+	'line',
+	'linearGradient',
+	'marker',
+	'mask',
+	'mesh',
+	'meshgradient',
+	'meshpatch',
+	'meshrow',
+	'metadata',
+	'missing-glyph',
+	'mpath',
+	'path',
+	'pattern',
+	'polygon',
+	'polyline',
+	'radialGradient',
+	'rect',
+	'set',
+	'solidcolor',
+	'stop',
+	'svg',
+	'switch',
+	'symbol',
+	'text',
+	'textPath',
+	'tref',
+	'tspan',
+	'unknown',
+	'use',
+	'view',
+	'vkern'
+]);
+
+export function isSvg(name: string): boolean {
+	return svg.has(name);
+}
+
+const mathml = new Set([
+	'annotation',
+	'annotation-xml',
+	'maction',
+	'math',
+	'merror',
+	'mfrac',
+	'mi',
+	'mmultiscripts',
+	'mn',
+	'mo',
+	'mover',
+	'mpadded',
+	'mphantom',
+	'mprescripts',
+	'mroot',
+	'mrow',
+	'ms',
+	'mspace',
+	'msqrt',
+	'mstyle',
+	'msub',
+	'msubsup',
+	'msup',
+	'mtable',
+	'mtd',
+	'mtext',
+	'mtr',
+	'munder',
+	'munderover',
+	'semantics'
+]);
+
+export function isMathml(name: string): boolean {
+	return mathml.has(name);
+}
+
+export const validTag =
+	/^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u{B7}\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{37D}\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{203F}-\u{2040}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}]*)?$/u;
+
+export const namespaces = {
+	html: 'http://www.w3.org/1999/xhtml',
+	svg: 'http://www.w3.org/2000/svg',
+	mathml: 'http://www.w3.org/1998/Math/MathML'
+} as const;

package/src/shared/markers.ts

@@ -0,0 +1,25 @@
+export const OPEN = '[';
+
+export const OPEN_ELSE = '[!';
+
+export const OPEN_FAILED = '[?';
+
+export const CLOSE = ']';
+
+export const open = `<!--${OPEN}-->`;
+
+export const openElse = `<!--${OPEN_ELSE}-->`;
+
+export const close = `<!--${CLOSE}-->`;
+
+export const empty = '<!---->';
+
+export const fallback = -1;
+
+export function arm(index: number): string {
+	return `<!--[${index}-->`;
+}
+
+export function armIndex(data: string): number {
+	return data.charCodeAt(0) === 91 ? Number.parseInt(data.slice(1), 10) : Number.NaN;
+}