vigla 0.0.0 → 0.2.0

package/src/entries/compiler.ts

@@ -0,0 +1,206 @@
+import type * as ES from 'estree';
+import { print } from 'esrap';
+import ts from 'esrap/languages/ts';
+import { format, type Format } from '../shared/format.ts';
+export type { Format } from '../shared/format.ts';
+import { analyzeComponent, analyzeModule } from '../compiler/analysis/index.ts';
+import {
+	validateComponent,
+	validateModule,
+	type ValidateOptions
+} from '../compiler/analysis/validate/index.ts';
+import { speaking } from '../compiler/analysis/validate/report.ts';
+import { client, clientModule, type Fragments } from '../compiler/client/index.ts';
+import { analyzeStyle, injected, renderStyle, type Stylesheet } from '../compiler/css/index.ts';
+import type { Namespace } from '../compiler/ir/nodes.ts';
+import { chain, sourceName, type InputMap, type OutputMap } from '../compiler/ir/maps.ts';
+import type { ComponentUnit, Diagnostic, ModuleUnit } from '../compiler/ir/port.ts';
+import type { ExpressionProjection, Runtime } from '../compiler/ir/runtime.ts';
+export type {
+	ClientExpression,
+	ExpressionProjection,
+	Runtime,
+	RuntimeNames
+} from '../compiler/ir/runtime.ts';
+import { server, serverModule } from '../compiler/server/index.ts';
+
+export type * from '../compiler/ir/nodes.ts';
+export type {
+	ComponentUnit,
+	Diagnostic,
+	ExternalBinding,
+	FrontEnd,
+	Ignores,
+	Input,
+	ModuleUnit,
+	Reading,
+	Rune,
+	Runes,
+	Unit
+} from '../compiler/ir/port.ts';
+export { CompileError } from '../compiler/ir/port.ts';
+export { basename, combine, type InputMap } from '../compiler/ir/maps.ts';
+export { parseExpression, parseProgram } from '../compiler/ir/script.ts';
+export type * as Style from '../compiler/ir/style.ts';
+export {
+	analyzeStyle,
+	hash,
+	type Scoping,
+	type StyleAnalysis,
+	type StyleOptions,
+	type Stylesheet
+} from '../compiler/css/index.ts';
+export {
+	closest,
+	errorMessage,
+	validateComponent,
+	validateModule,
+	warningCodes,
+	warningMessage,
+	type Anchored,
+	type Catalog,
+	type Front,
+	type ValidateOptions,
+	type Wording
+} from '../compiler/analysis/validate/index.ts';
+
+export type Generate = 'client' | 'server';
+
+export interface ModuleOptions {
+	readonly generate: Generate;
+	readonly runtime?: Runtime;
+	readonly clientExpression?: ExpressionProjection;
+	readonly dev?: boolean;
+	readonly validation?: ValidateOptions;
+}
+
+export interface Mapping {
+	readonly outputFilename?: string;
+	readonly inputMap?: InputMap;
+}
+
+export interface CompileOptions extends ModuleOptions, Mapping {
+	readonly name: string;
+	readonly customElement?: boolean;
+	readonly preserveWhitespace?: boolean;
+	readonly preserveComments?: boolean;
+	readonly fragments?: Fragments;
+	readonly namespace?: Namespace;
+	readonly css?: CssOptions;
+	readonly hmr?: boolean;
+	readonly format?: Format;
+	readonly devFilename?: string;
+	readonly discloseVersion?: string | false;
+}
+
+export interface CssOptions {
+	readonly hash: string;
+	readonly inject: boolean;
+	readonly id?: string;
+	readonly outputFilename?: string;
+}
+
+export interface Code {
+	readonly code: string;
+	readonly map: object;
+}
+
+export interface Output {
+	readonly js: Code;
+	readonly css: Stylesheet | null;
+	readonly warnings: readonly Diagnostic[];
+}
+
+const runtimes: Runtime = { client: 'vigla/internal/client', server: 'vigla/internal/server' };
+
+function printed(program: ES.Program, unit: ComponentUnit | ModuleUnit, mapping: Mapping): Code {
+	const { code, map } = print(program as never, ts(), {
+		sourceMapSource: sourceName(unit.filename, mapping.outputFilename),
+		sourceMapContent: unit.source
+	});
+	if (mapping.inputMap !== undefined) chain(map as OutputMap, unit.filename, mapping.inputMap);
+	return { code, map: map as object };
+}
+
+export function compile(unit: ComponentUnit, options: CompileOptions): Output {
+	return speaking(options.validation?.wording, () => component(unit, options));
+}
+
+export function compileModule(unit: ModuleUnit, options: ModuleOptions): Output {
+	return speaking(options.validation?.wording, () => module(unit, options));
+}
+
+function component(unit: ComponentUnit, options: CompileOptions): Output {
+	const validated = validateComponent(unit, {
+		...options.validation,
+		customElement: options.customElement ?? options.validation?.customElement,
+		namespace: options.namespace
+	});
+	const style = analyzeStyle(unit, {
+		hash: options.css?.hash ?? '',
+		scope: options.hmr && !options.css?.inject ? 'all' : 'matched'
+	});
+	const warnings = [...validated, ...style.warnings];
+	const element = options.customElement === true || unit.options?.customElement != null;
+	const inject = injected(style, element || (options.css?.inject ?? false));
+	const css = renderStyle(style, {
+		dev: options.dev ?? false,
+		inject,
+		outputFilename: options.css?.outputFilename ?? null,
+		inputMap: options.inputMap
+	});
+	const analysis = analyzeComponent(
+		unit,
+		{
+			whitespace: options.preserveWhitespace ?? false,
+			comments: options.preserveComments ?? false
+		},
+		options.namespace ?? 'html',
+		unit.options?.customElement ??
+			(options.customElement ? { tag: null, shadow: null, props: null, extend: null } : null)
+	);
+	const runtime = options.runtime ?? runtimes;
+	const styles =
+		inject && css !== null ? { hash: options.css?.id ?? style.scoping.hash, code: css.code } : null;
+	const generation = {
+		name: options.name,
+		scoping: style.scoping,
+		styles,
+		format: options.format ?? format,
+		runtimeNames: runtime.names,
+		dev: options.dev ?? false,
+		filename: options.devFilename ?? unit.filename ?? '(unknown)'
+	};
+	const program =
+		options.generate === 'server'
+			? server(analysis, { ...generation, runtime: runtime.server })
+			: client(analysis, {
+					...generation,
+					runtime: runtime.client,
+					project: options.clientExpression,
+					hmr: options.hmr ?? false,
+					discloseVersion: options.discloseVersion ?? '0',
+					fragments: options.fragments ?? 'html'
+				});
+	return { js: printed(program, unit, options), css: inject ? null : css, warnings };
+}
+
+function module(unit: ModuleUnit, options: ModuleOptions): Output {
+	const warnings = validateModule(unit, options.validation);
+	const analysis = analyzeModule(unit);
+	const runtime = options.runtime ?? runtimes;
+	const program =
+		options.generate === 'server'
+			? serverModule(analysis, {
+					runtime: runtime.server,
+					runtimeNames: runtime.names,
+					dev: options.dev ?? false
+				})
+			: clientModule(analysis, {
+					project: options.clientExpression,
+					runtime: runtime.client,
+					runtimeNames: runtime.names,
+					dev: options.dev ?? false
+				});
+	return { js: printed(program, unit, {}), css: null, warnings };
+}

package/src/entries/easing.ts

@@ -0,0 +1 @@
+export * from '../runtime/transitions/easing.ts';

package/src/entries/events.ts

@@ -0,0 +1,10 @@
+import { listen } from '../runtime/dom/events.ts';
+
+export function on(
+	element: EventTarget,
+	type: string,
+	handler: EventListener,
+	options: AddEventListenerOptions = {}
+): () => void {
+	return listen(element, type, handler, options.capture ?? false, options.passive);
+}

package/src/entries/index-server.ts

@@ -0,0 +1,118 @@
+import { failure } from '../shared/diagnostics.ts';
+import type * as client from './index.ts';
+import { unit } from '../runtime/reactivity/units.ts';
+import { ambient } from '../runtime/reactivity/carried.ts';
+import type { Resource } from '../runtime/reactivity/public.ts';
+import { external as connect } from '../runtime/server/external.ts';
+import {
+	expose,
+	type External,
+	type Subscribable,
+	type WritableExternal,
+	type WritableSource
+} from '../shared/external.ts';
+
+export {
+	createContext,
+	getAllContexts,
+	getContext,
+	getOwner,
+	hasContext,
+	onDestroy,
+	root,
+	setContext
+} from '../runtime/reactivity/owners.ts';
+export { getAbortSignal } from '../runtime/server/context.ts';
+export { cell, memo as derived, cell as state } from '../runtime/server/cells.ts';
+export { untrack } from '../runtime/reactivity/tracking.ts';
+export { AsyncVariable, carryAcrossAwait, type AsyncStore } from '../runtime/reactivity/carried.ts';
+export type { Context } from '../shared/context.ts';
+export type {
+	External,
+	Subscribable,
+	Subscription,
+	WritableExternal,
+	WritableSource
+} from '../shared/external.ts';
+export type { Format } from '../shared/format.ts';
+export { hydratable, hydrated, openHydration } from '../runtime/server/hydration.ts';
+export type { HydrationOptions } from '../runtime/server/hydration.ts';
+export { createRawSnippet } from '../runtime/server/snippet.ts';
+export type { RawFactory, RawSnippet } from '../shared/snippet.ts';
+export type {
+	Component,
+	Exports,
+	HydrateOptions,
+	MountOptions,
+	Props
+} from '../runtime/dom/mount.ts';
+
+function unavailable(name: string): never {
+	throw failure(
+		'lifecycle_function_unavailable',
+		`\`${name}(...)\` is not available on the server`
+	);
+}
+
+export const onMount: typeof client.onMount = () => {};
+
+export function flushSync<T = void>(fn?: () => T): T {
+	return fn?.() as T;
+}
+
+export const mount: typeof client.mount = () => unavailable('mount');
+export const hydrate: typeof client.hydrate = () => unavailable('hydrate');
+export const unmount: typeof client.unmount = () => unavailable('unmount');
+export const fork: typeof client.fork = () => unavailable('fork');
+
+export type { Owner } from '../runtime/reactivity/owners.ts';
+export type { Cell } from '../runtime/reactivity/sources.ts';
+export type { Effects, Resource } from '../runtime/reactivity/public.ts';
+export { snapshot } from '../shared/clone.ts';
+
+const noop = (): void => {};
+
+export const effect: typeof client.effect = Object.assign(() => noop, {
+	pre: () => noop,
+	root: () => noop
+});
+
+export function external<T>(read: () => WritableSource<T> | null | undefined): WritableExternal<T>;
+export function external<T>(read: () => Subscribable<T> | null | undefined): External<T>;
+export function external<T>(read: () => Subscribable<T> | null | undefined): WritableExternal<T> {
+	return expose(connect(read));
+}
+
+export async function resource<T>(fn: () => T | PromiseLike<T>): Promise<Resource<T>> {
+	const finish = unit(ambient());
+	try {
+		return { current: await fn() };
+	} finally {
+		finish();
+	}
+}
+
+export function pending(): number {
+	return 0;
+}
+
+export function latest<T>(fn: () => T): T {
+	return fn();
+}
+
+export function tracking(): boolean {
+	return false;
+}
+
+export async function tick(): Promise<void> {}
+
+export { drained as settled } from '../runtime/reactivity/units.ts';
+
+export async function hold<T>(fn: () => T): Promise<Awaited<T>> {
+	const finish = unit(ambient());
+	try {
+		return await fn();
+	} finally {
+		finish();
+	}
+}

package/src/entries/index.ts

@@ -0,0 +1,50 @@
+export {
+	createContext,
+	getAllContexts,
+	getContext,
+	getOwner,
+	hasContext,
+	onDestroy,
+	root,
+	setContext
+} from '../runtime/reactivity/owners.ts';
+export { onMount } from '../runtime/dom/context.ts';
+export type { Context } from '../shared/context.ts';
+export type { Format } from '../shared/format.ts';
+export { hydratable, hydrated, openHydration } from '../runtime/dom/data.ts';
+export type { HydrationOptions } from '../runtime/dom/data.ts';
+export { createRawSnippet } from '../runtime/dom/snippet.ts';
+export type { RawFactory, RawSnippet } from '../shared/snippet.ts';
+export { hydrate, mount, unmount } from '../runtime/dom/mount.ts';
+export type {
+	Component,
+	Exports,
+	HydrateOptions,
+	MountOptions,
+	Props
+} from '../runtime/dom/mount.ts';
+
+export { tick } from '../runtime/reactivity/batch.ts';
+export { flushSync } from '../runtime/reactivity/scheduler.ts';
+export { settled } from '../runtime/reactivity/units.ts';
+export { getAbortSignal, tracking } from '../runtime/reactivity/effects.ts';
+export { hold, pending } from '../runtime/reactivity/async.ts';
+export { effect, external, resource } from '../runtime/reactivity/public.ts';
+export type { Effects, Resource } from '../runtime/reactivity/public.ts';
+export { latest } from '../runtime/reactivity/latest.ts';
+export { snapshot } from '../shared/clone.ts';
+export type {
+	External,
+	Subscribable,
+	Subscription,
+	WritableExternal,
+	WritableSource
+} from '../shared/external.ts';
+export { fork } from '../runtime/reactivity/fork.ts';
+export type { Fork } from '../runtime/reactivity/fork.ts';
+export type { Owner } from '../runtime/reactivity/owners.ts';
+export { AsyncVariable } from '../runtime/reactivity/carried.ts';
+export { cell, memo as derived } from '../runtime/reactivity/sources.ts';
+export { deep as state } from '../runtime/reactivity/proxy.ts';
+export type { Cell } from '../runtime/reactivity/sources.ts';
+export { untrack } from '../runtime/reactivity/tracking.ts';

package/src/entries/internal/client.ts

@@ -0,0 +1,135 @@
+export { clsx } from '../../shared/attributes.ts';
+export { assignment, mutationTarget } from '../../shared/assignment.ts';
+export type { AssignmentTarget } from '../../shared/assignment.ts';
+export { failure, setReporter } from '../../shared/diagnostics.ts';
+export type { Notice, Reporter, Values } from '../../shared/diagnostics.ts';
+export { snippet } from '../../shared/snippet.ts';
+export { snippetArgs } from '../../runtime/dom/snippet.ts';
+export {
+	attr,
+	attributes,
+	checked,
+	className,
+	CLASS,
+	customProp,
+	defaultChecked,
+	defaultValue,
+	optionValue,
+	removeInputDefaults,
+	removeTextareaChild,
+	style,
+	STYLE,
+	value,
+	xlink
+} from '../../runtime/dom/attributes.ts';
+export {
+	bindBox,
+	bindChecked,
+	bindContentEditable,
+	bindFiles,
+	bindFocused,
+	bindGroup,
+	bindIndeterminate,
+	bindProperty,
+	bindSize,
+	bindThis,
+	bindValue,
+	validateBinding
+} from '../../runtime/dom/bindings.ts';
+export {
+	bindCurrentTime,
+	bindMedia,
+	bindMediaControl,
+	bindPaused
+} from '../../runtime/dom/media.ts';
+export { async, deferredExports, prepareAsync, save, script } from '../../runtime/dom/async.ts';
+export { awaited } from '../../runtime/dom/await.ts';
+export { animation, transition } from '../../runtime/transitions/manager.ts';
+export { branch, key } from '../../runtime/dom/blocks.ts';
+export { list } from '../../runtime/dom/list.ts';
+export { boundary } from '../../runtime/dom/boundary.ts';
+export {
+	bindSelect,
+	initSelect,
+	selectDefault,
+	selected,
+	selectValue
+} from '../../runtime/dom/select.ts';
+export { appendStyles } from '../../runtime/dom/styles.ts';
+export { action, attach, attachment } from '../../runtime/dom/attachments.ts';
+export { html } from '../../runtime/dom/html.ts';
+export { head, title } from '../../runtime/dom/head.ts';
+export { element } from '../../runtime/dom/element.ts';
+export { inspect } from '../../runtime/dom/inspect.ts';
+export { slots, slotProps } from '../../shared/slots.ts';
+export { customElement, host, slot } from '../../runtime/dom/custom-element.ts';
+export { flushSync } from '../../runtime/reactivity/scheduler.ts';
+export { componentSource, disclose, frame, locate } from '../../runtime/dom/meta.ts';
+export { ownership } from '../../runtime/dom/ownership.ts';
+export { exclude, fallback, toArray } from '../../runtime/dom/values.ts';
+export {
+	bindActiveElement,
+	bindOnline,
+	bindWindowScroll,
+	bindWindowSize,
+	on
+} from '../../runtime/dom/targets.ts';
+export { phase, pop, provide, push, userEffect } from '../../runtime/dom/context.ts';
+export type { Phase } from '../../runtime/dom/context.ts';
+export { keyed } from '../../shared/context.ts';
+export type { Contexts } from '../../shared/context.ts';
+export { delegate, delegated, event as listen, invoke } from '../../runtime/dom/events.ts';
+export {
+	forwardProps,
+	mutableProps,
+	mutateProp,
+	prop,
+	propsId,
+	rest,
+	updateProp,
+	updatePropPre
+} from '../../runtime/dom/props.ts';
+export { component, noop, render, spreadProps } from '../../runtime/dom/swap.ts';
+export { cleanupStyles, HMR, hmr } from '../../runtime/dom/hot.ts';
+export {
+	append,
+	awaitedContent,
+	child,
+	content,
+	first,
+	fragment,
+	next,
+	reset,
+	richSelect,
+	sibling,
+	text,
+	tree
+} from '../../runtime/dom/template.ts';
+export { asyncDerived, pending, work } from '../../runtime/reactivity/async.ts';
+export { resumed, suspend } from '../../runtime/reactivity/views.ts';
+export {
+	effect,
+	effectRoot,
+	pre,
+	teardown,
+	template,
+	tracking
+} from '../../runtime/reactivity/effects.ts';
+export { getReactionSignal } from '../../runtime/reactivity/effects.ts';
+export { external } from '../../runtime/reactivity/external.ts';
+export { latest } from '../../runtime/reactivity/latest.ts';
+export { trackLoss, trackLossEach } from '../../runtime/reactivity/loss.ts';
+export { tag, tagProxy, traceStacks } from '../../runtime/reactivity/provenance.ts';
+export { trace } from '../../runtime/reactivity/trace.ts';
+export { original, proxy } from '../../runtime/reactivity/proxy.ts';
+export { snapshot } from '../../shared/clone.ts';
+export {
+	derived,
+	lapsingDerived,
+	set,
+	state,
+	update,
+	updatePre
+} from '../../runtime/reactivity/sources.ts';
+export { endReading as unsave, unowned } from '../../runtime/reactivity/tracking.ts';
+export { get } from '../../runtime/reactivity/reads.ts';

package/src/entries/internal/server.ts

@@ -0,0 +1,46 @@
+export { failure, setReporter } from '../../shared/diagnostics.ts';
+export { assignment, mutationTarget } from '../../shared/assignment.ts';
+export type { Notice, Reporter, Values } from '../../shared/diagnostics.ts';
+export { snippet } from '../../shared/snippet.ts';
+export { snippetArgs } from '../../runtime/server/snippet.ts';
+export { escapeContent as escape } from '../../shared/escape.ts';
+export { external } from '../../runtime/server/external.ts';
+export { slots, slotProps } from '../../shared/slots.ts';
+export {
+	attr,
+	attrClass,
+	attributes,
+	attrStyle,
+	clsx,
+	html,
+	rawHtml
+} from '../../runtime/server/attributes.ts';
+export {
+	acquire,
+	leave,
+	phase,
+	pop,
+	push,
+	reenter,
+	save,
+	segment,
+	unsave
+} from '../../runtime/server/context.ts';
+export { setContext as provide } from '../../runtime/reactivity/owners.ts';
+export { keyed } from '../../shared/context.ts';
+export type { Contexts } from '../../shared/context.ts';
+export { popElement, pushElement } from '../../runtime/server/placement.ts';
+export { derived, held, updateDerived } from '../../runtime/server/derived.ts';
+export {
+	appendStyles,
+	bindProps,
+	boundary,
+	element,
+	head,
+	iterate,
+	Output,
+	propsId,
+	Settlement,
+	spreadProps
+} from '../../runtime/server/render.ts';
+export { snapshot } from '../../shared/clone.ts';

package/src/entries/motion-server.ts

@@ -0,0 +1,5 @@
+export { prefersReducedMotion } from '../runtime/classes/server.ts';
+export { Spring } from '../runtime/classes/spring.ts';
+export type { SpringOptions, SpringUpdateOptions } from '../runtime/classes/spring.ts';
+export { Tween } from '../runtime/classes/tween.ts';
+export type { Interpolator, TweenOptions } from '../runtime/classes/tween.ts';

package/src/entries/motion.ts

@@ -0,0 +1,5 @@
+export { prefersReducedMotion } from '../runtime/classes/motion.ts';
+export { Spring } from '../runtime/classes/spring.ts';
+export type { SpringOptions, SpringUpdateOptions } from '../runtime/classes/spring.ts';
+export { Tween } from '../runtime/classes/tween.ts';
+export type { Interpolator, TweenOptions } from '../runtime/classes/tween.ts';

package/src/entries/reactivity-server.ts

@@ -0,0 +1,7 @@
+export { createSubscriber, MediaQuery } from '../runtime/classes/server.ts';
+
+export const ReactiveDate = globalThis.Date;
+export const ReactiveMap = globalThis.Map;
+export const ReactiveSet = globalThis.Set;
+export const ReactiveURL = globalThis.URL;
+export const ReactiveURLSearchParams = globalThis.URLSearchParams;

package/src/entries/reactivity.ts

@@ -0,0 +1,7 @@
+export { ReactiveDate } from '../runtime/classes/date.ts';
+export { ReactiveMap } from '../runtime/classes/map.ts';
+export { MediaQuery } from '../runtime/classes/media.ts';
+export { ReactiveURLSearchParams } from '../runtime/classes/search.ts';
+export { ReactiveSet } from '../runtime/classes/set.ts';
+export { createSubscriber } from '../runtime/classes/subscriber.ts';
+export { ReactiveURL } from '../runtime/classes/url.ts';

package/src/entries/server.ts

@@ -0,0 +1,11 @@
+export { render } from '../runtime/server/render.ts';
+export type {
+	Component,
+	Hashes,
+	Props,
+	Rendered,
+	Rendering,
+	RenderOptions
+} from '../runtime/server/render.ts';
+export type { Csp } from '../runtime/server/hydration.ts';
+export type { Format } from '../shared/format.ts';

package/src/entries/transition.ts

@@ -0,0 +1,12 @@
+export { blur, crossfade, draw, fade, fly, scale, slide } from '../runtime/transitions/presets.ts';
+export type {
+	BlurParams,
+	CrossfadeParams,
+	DrawParams,
+	FlyParams,
+	ScaleParams,
+	SlideParams,
+	Timing as FadeParams
+} from '../runtime/transitions/presets.ts';
+export type { AnimationConfig as TransitionConfig } from '../runtime/transitions/animate.ts';
+export type { Easing as EasingFunction } from '../runtime/transitions/easing.ts';

package/src/entries/window-server.ts

@@ -0,0 +1,12 @@
+export {
+	devicePixelRatio,
+	innerHeight,
+	innerWidth,
+	online,
+	outerHeight,
+	outerWidth,
+	screenLeft,
+	screenTop,
+	scrollX,
+	scrollY
+} from '../runtime/classes/window-server.ts';

package/src/entries/window.ts

@@ -0,0 +1,12 @@
+export {
+	devicePixelRatio,
+	innerHeight,
+	innerWidth,
+	online,
+	outerHeight,
+	outerWidth,
+	screenLeft,
+	screenTop,
+	scrollX,
+	scrollY
+} from '../runtime/classes/window.ts';