@torpor/view 0.3.0 → 0.3.1

package/dist/compile.d.cts

@@ -0,0 +1,210 @@
+import { Component } from "./Component-C6Y3UwGs.cjs";
+
+//#region src/types/BuildOptions.d.ts
+interface BuildOptions {
+  /**
+  * Whether to create the component for server side rendering
+  */
+  server?: boolean;
+  /**
+  * Whether to create source maps.
+  */
+  mapped?: boolean;
+  /**
+  * If true, fragments will be built with calls to createElement etc. If
+  * false, fragments will be built with innerHTML. Using createElement is a
+  * bit slower, but may be useful in the future for rendering to different
+  * targets
+  */
+  useCreateElement?: boolean;
+  /**
+  * For internal testing and benchmarking
+  */
+  renderFolder?: string;
+}
+//#endregion
+//#region src/compile/types/Import.d.ts
+interface Import {
+  name: string;
+  alias?: string;
+  path: string;
+  nonDefault: boolean;
+  component: boolean;
+}
+//#endregion
+//#region src/compile/types/SourceRange.d.ts
+interface SourceRange {
+  start: number;
+  end: number;
+}
+//#endregion
+//#region src/compile/types/ScriptChunk.d.ts
+interface ScriptChunk {
+  script: string;
+  range: SourceRange;
+}
+//#endregion
+//#region src/compile/types/nodes/Fragment.d.ts
+interface Fragment {
+  number: number;
+  text: string;
+  ns: boolean;
+  effects: {
+    functionBody: string;
+    ranges: SourceRange[];
+    offsets: number[];
+    lengths: number[];
+  }[];
+  events: {
+    varName: string;
+    eventName: string;
+    handler: string;
+  }[];
+  animations: string[];
+  endVarName?: string;
+}
+//#endregion
+//#region src/compile/types/nodes/NodeType.d.ts
+type NodeType = "root" | "control" | "component" | "element" | "text" | "special";
+//#endregion
+//#region src/compile/types/nodes/TemplateNode.d.ts
+interface TemplateNode {
+  type: NodeType;
+  scopeStyles?: boolean;
+  varName?: string;
+  handled?: boolean;
+}
+//#endregion
+//#region src/compile/types/nodes/ParentNode.d.ts
+interface ParentNode extends TemplateNode {
+  type: NodeType;
+  children: TemplateNode[];
+}
+//#endregion
+//#region src/compile/types/nodes/RootNode.d.ts
+interface RootNode extends ParentNode {
+  type: "root";
+  children: TemplateNode[];
+  fragment?: Fragment;
+}
+//#endregion
+//#region src/compile/types/styles/Attribute.d.ts
+interface Attribute {
+  name: string;
+  value: string;
+}
+//#endregion
+//#region src/compile/types/styles/StyleBlock.d.ts
+interface StyleBlock {
+  selector: string;
+  attributes: Attribute[];
+  children: StyleBlock[];
+}
+//#endregion
+//#region src/compile/types/styles/Style.d.ts
+interface Style {
+  global: boolean;
+  blocks: StyleBlock[];
+  hash: string;
+}
+//#endregion
+//#region src/types/TemplateComponent.d.ts
+interface TemplateComponent {
+  start?: number;
+  /** The component's name */
+  name?: string;
+  /** Whether the component is defined with a default function */
+  default?: boolean;
+  /** Params declared by the user in the component's function */
+  params?: string;
+  markup?: RootNode;
+  head?: RootNode;
+  style?: Style;
+  /** $props that are used in the component's function */
+  props?: string[];
+  /** $context props that are used in the component's function */
+  contextProps?: string[];
+  needsContext?: boolean;
+  /** $slot props that are used in the component's function */
+  slotProps?: string[];
+}
+//#endregion
+//#region src/types/Template.d.ts
+/**
+* The template for a component file, consisting of parts like script, markup and styles
+*/
+interface Template {
+  imports: Import[];
+  script: ScriptChunk[];
+  components: TemplateComponent[];
+}
+//#endregion
+//#region src/compile/types/SourceMapping.d.ts
+interface SourceMapping {
+  script: string;
+  source: SourceRange;
+  compiled: SourceRange;
+}
+//#endregion
+//#region src/compile/types/BuildResult.d.ts
+interface BuildResult {
+  code: string;
+  styles: {
+    style: string;
+    hash: string;
+  }[];
+  map: SourceMapping[];
+}
+//#endregion
+//#region src/compile/build.d.ts
+/**
+* Builds a component template into code and styles for rendering
+*
+* @param template The component template, possibly including script, markup and styles
+*
+* @returns The component's code and styles
+*/
+declare function build(template: Template, options?: BuildOptions): BuildResult;
+//#endregion
+//#region src/compile/buildType.d.ts
+/**
+* Builds a component template into a d.ts file
+*
+* @param name The name of the component
+* @param template The component template, possibly including script, markup and styles
+*
+* @returns The d.ts file content
+*/
+declare function buildType(template: Template, options?: BuildOptions): string;
+//#endregion
+//#region src/compile/types/CompileError.d.ts
+interface CompileError {
+  message: string;
+  startIndex: number;
+  startLine: number;
+  startChar: number;
+  endIndex: number;
+  endLine: number;
+  endChar: number;
+}
+//#endregion
+//#region src/compile/types/ParseResult.d.ts
+interface ParseResult {
+  ok: boolean;
+  errors: CompileError[];
+  template?: Template;
+}
+//#endregion
+//#region src/compile/parse.d.ts
+/**
+* Parses source code into a component template
+*
+* @param source The source code
+*
+* @returns A result indicating whether parsing was ok, and if so, containing
+* the component template's parts such as script, markup and styles
+*/
+declare function parse(source: string): ParseResult;
+//#endregion
+export { type Component, type Template, build, buildType, parse };
+//# sourceMappingURL=compile.d.cts.map

package/dist/compile.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.cts","names":[],"sources":["../src/types/BuildOptions.ts","../src/compile/types/Import.ts","../src/compile/types/SourceRange.ts","../src/compile/types/ScriptChunk.ts","../src/compile/types/nodes/Fragment.ts","../src/compile/types/nodes/NodeType.ts","../src/compile/types/nodes/TemplateNode.ts","../src/compile/types/nodes/ParentNode.ts","../src/compile/types/nodes/RootNode.ts","../src/compile/types/styles/Attribute.ts","../src/compile/types/styles/StyleBlock.ts","../src/compile/types/styles/Style.ts","../src/types/TemplateComponent.ts","../src/types/Template.ts","../src/compile/types/SourceMapping.ts","../src/compile/types/BuildResult.ts","../src/compile/build.ts","../src/compile/buildType.ts","../src/compile/types/CompileError.ts","../src/compile/types/ParseResult.ts","../src/compile/parse.ts"],"sourcesContent":[],"mappings":";;;UAAyB,YAAA;;;;;;;;;;;;;;;EGAI,gBAEJ,CAAA,EAAA,OAAA;;;;ECFI,YAEJ,CAAA,EAAA,MAAA;;;;UHFA,MAAA;;;MDAA,EAAA,MAAA;;;;;;UEAA,WAAA;;;;;;UCEA,WAAA;;OHFA,EGIjB,WHJiB;;;;UIEA,QAAA;;MJFA,EAAA,MAAA;;;;UCAA,EGQf,WHRe,EAAA;;;;QCAA,EAAA;;;;ECAI,CAAA,EAEJ;;;;;;KEFpB,QAAA;;;UCEoB,YAAA;QAClB;aNHkB,CAAA,EAAA,OAAA;;;;;;UOGA,UAAA,SAAmB;MPHnB,EOIlB,QPJkB;YOKd;;;;APLc,UQIA,QAAA,SAAiB,URJjB,CAAA;;YQMd;aAGC;;;;UCTa,SAAA;;;;;;UCEA,UAAA;;YVFA,EUIZ,SVJY,EAAA;YUKd;;;;UCHc,KAAA;;QXFA,EWIhB,UXJgB,EAAA;;;;;UYGA,iBAAA;OZHA,CAAA,EAAA,MAAA;;;;SCAA,CAAA,EAAA,OAAA;;;WWWf;MVXe,CAAA,EUYjB,QVZiB;UUahB;;;ETboB;;;;ECAA,SAEJ,CAAA,EAAA,MAAA,EAAA;;;;;;;USKA,QAAA;SZPA,EYQf,MZRe,EAAA;UYShB;cACI;;;;UCRY,aAAA;;QdFA,EcIhB,WdJgB;YcKd;;;;UCHc,WAAA;;QfFA,EAAA;;;;KCAA,EcQnB,adRmB,EAAA;;;;;;;;;;;iBeeD,KAAA,WAAgB,oBAAoB,eAAe;;;;;;;;;;;iBCHnD,SAAA,WAAoB,oBAAoB;;;UCZvC,YAAA;;;WlBAA,EAAA,MAAA;;;;SCAA,EAAA,MAAA;;;;UkBGA,WAAA;MnBHA,OAAA;UmBKhB;aACG;;;;;;;;;;;;iBCKY,KAAA,kBAAuB"}

package/dist/formatText-DufG5l83.cjs

@@ -0,0 +1,500 @@
+
+//#region src/render/context.ts
+const context = {
+	activeTarget: null,
+	previousEffect: null,
+	extent: 0,
+	batch: 0,
+	batchOperation: 0,
+	registerComputed: null,
+	firstEffectToRun: null,
+	firstSignalToUpdate: null,
+	activeRange: null,
+	previousRange: null,
+	rootRange: null,
+	mountEffects: [],
+	stashedEvents: [],
+	stashedAnimations: [],
+	hydrationNode: null
+};
+var context_default = context;
+
+//#endregion
+//#region src/types/constants.ts
+/**
+* The type of a Signal object.
+*/
+const SIGNAL_TYPE = 0;
+/**
+* The type of a Computed object.
+*/
+const COMPUTED_TYPE = 1;
+/**
+* The type of an Effect object.
+*/
+const EFFECT_TYPE = 2;
+
+//#endregion
+//#region src/watch/clearSources.ts
+/**
+* Clear unused source subscriptions after each Computed or Effect has been run.
+*/
+function clearSources(target) {
+	let previousSub = null;
+	for (let clearSub = target.firstSource; clearSub !== null; clearSub = clearSub.nextSource) if (target.didError || !clearSub.active) {
+		if (previousSub === null) target.firstSource = clearSub.nextSource;
+		else previousSub.nextSource = clearSub.nextSource;
+		if (clearSub.previousTarget === null) {
+			if (clearSub.source.firstTarget === clearSub) clearSub.source.firstTarget = clearSub.nextTarget;
+		} else clearSub.previousTarget.nextTarget = clearSub.nextTarget;
+	} else {
+		clearSub.recalc = false;
+		previousSub = clearSub;
+	}
+}
+
+//#endregion
+//#region src/watch/deactivateSources.ts
+/**
+* Sets source subscriptions to inactive for a Computed or Effect.
+*/
+function deactivateSources(target) {
+	for (let sourceSub = target.firstSource; sourceSub !== null; sourceSub = sourceSub.nextSource) sourceSub.active = false;
+}
+
+//#endregion
+//#region src/watch/trackEffect.ts
+/**
+* If there's an active target, subscribe it to this signal, so that it will be
+* run when the signal changes.
+*/
+function trackEffect(signal) {
+	const target = context_default.activeTarget;
+	if (target !== null) {
+		let sub = null;
+		let lastSub = null;
+		for (let nextSub = signal.firstTarget; nextSub !== null; nextSub = nextSub.nextTarget) {
+			lastSub = nextSub;
+			if (nextSub.target === target) {
+				sub = nextSub;
+				break;
+			}
+		}
+		if (sub === null) {
+			sub = {
+				source: signal,
+				target,
+				previousTarget: lastSub,
+				nextTarget: null,
+				nextSource: null,
+				active: true,
+				recalc: false
+			};
+			if (lastSub === null) signal.firstTarget = sub;
+			else lastSub.nextTarget = sub;
+			if (target.firstSource === null) target.firstSource = sub;
+			else {
+				let lastEffectSub = target.firstSource;
+				for (let nextSub = lastEffectSub.nextSource; nextSub !== null; nextSub = nextSub.nextSource) lastEffectSub = nextSub;
+				lastEffectSub.nextSource = sub;
+			}
+		} else sub.active = true;
+	}
+}
+
+//#endregion
+//#region src/watch/runComputed.ts
+function runComputed(computed) {
+	const oldActiveTarget = context_default.activeTarget;
+	computed.running = true;
+	computed.didError = false;
+	try {
+		context_default.activeTarget = computed;
+		computed.value = computed.run();
+	} catch (err) {
+		computed.didError = true;
+		computed.value = err;
+		throw err;
+	} finally {
+		context_default.activeTarget = oldActiveTarget;
+		computed.running = false;
+	}
+	trackEffect(computed);
+	return computed.value;
+}
+
+//#endregion
+//#region src/watch/checkComputed.ts
+/**
+* Checks whether a Computed value should be re-run (which will be true if any
+* of its sources have changed) and re-runs it if necessary.
+*/
+function checkComputed(computed) {
+	let rerun = checkSources(computed);
+	let changed = false;
+	if (rerun) {
+		deactivateSources(computed);
+		const oldValue = computed.value;
+		runComputed(computed);
+		changed = computed.value !== oldValue;
+		clearSources(computed);
+	}
+	computed.recalc = false;
+	if (!changed) for (let targetSub = computed.firstTarget; targetSub !== null; targetSub = targetSub.nextTarget) {
+		targetSub.active = true;
+		targetSub.recalc = false;
+	}
+	return changed;
+}
+
+//#endregion
+//#region src/watch/checkSources.ts
+/**
+* Checks whether a Computed or Effect should be re-run (which will be true if
+* any of its sources have changed).
+*/
+function checkSources(target) {
+	let haveComputed = false;
+	for (let sourceSub = target.firstSource; sourceSub !== null; sourceSub = sourceSub.nextSource) if (sourceSub.recalc) if (sourceSub.source.type === SIGNAL_TYPE) return true;
+	else if (sourceSub.source.recalc) haveComputed = true;
+	else return true;
+	if (haveComputed) {
+		for (let sourceSub = target.firstSource; sourceSub !== null; sourceSub = sourceSub.nextSource) if (sourceSub.recalc && sourceSub.source.type === COMPUTED_TYPE && sourceSub.source.recalc) {
+			const oldActiveTarget = context_default.activeTarget;
+			context_default.activeTarget = target;
+			const recalc = checkComputed(sourceSub.source);
+			context_default.activeTarget = oldActiveTarget;
+			if (recalc) return true;
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region src/watch/runCleanups.ts
+/**
+* Runs cleanup functions for the effect and its children.
+*/
+function runCleanups(effect) {
+	let effectToClean = effect;
+	for (let i = 0; i < effect.extent; i++) {
+		if (typeof effectToClean.cleanup === "function") {
+			const oldActiveTarget = context_default.activeTarget;
+			context_default.activeTarget = null;
+			try {
+				effectToClean.cleanup();
+			} catch (err) {
+				effectToClean.didError = true;
+				clearSources(effectToClean);
+				throw err;
+			} finally {
+				effectToClean.cleanup = void 0;
+				context_default.activeTarget = oldActiveTarget;
+			}
+		}
+		const nextEffect = effectToClean.nextEffect;
+		if (i !== 0 && effect.nextEffectToRun === effectToClean) {
+			effect.nextEffectToRun = effectToClean.nextEffectToRun;
+			effectToClean.nextEffect = effectToClean.nextEffectToRun = null;
+		}
+		effectToClean = nextEffect;
+	}
+}
+
+//#endregion
+//#region src/watch/batchStart.ts
+function batchStart() {
+	context_default.batch++;
+}
+
+//#endregion
+//#region src/watch/runEffect.ts
+function runEffect(effect) {
+	const oldActiveTarget = context_default.activeTarget;
+	const oldExtent = context_default.extent;
+	effect.didError = false;
+	batchStart();
+	try {
+		if (context_default.previousEffect !== null) context_default.previousEffect.nextEffect = effect;
+		context_default.activeTarget = effect;
+		context_default.previousEffect = effect;
+		context_default.extent = 1;
+		effect.cleanup = effect.run();
+		effect.extent = context_default.extent;
+	} catch (err) {
+		effect.didError = true;
+		clearSources(effect);
+		throw err;
+	} finally {
+		context_default.activeTarget = oldActiveTarget;
+		context_default.extent += oldExtent - 1;
+		batchEnd();
+	}
+}
+
+//#endregion
+//#region src/watch/checkEffect.ts
+/**
+* Checks whether an Effect should be re-run (which will be true if any
+* of its sources have changed) and re-runs it if necessary.
+*/
+function checkEffect(effect) {
+	if (checkSources(effect)) {
+		runCleanups(effect);
+		deactivateSources(effect);
+		runEffect(effect);
+		clearSources(effect);
+	}
+}
+
+//#endregion
+//#region src/watch/clearTargets.ts
+/**
+* Clear unused target subscriptions after all Effects have been run.
+*/
+function clearTargets(source) {
+	let previousSub = null;
+	for (let clearSub = source.firstTarget; clearSub !== null; clearSub = clearSub.nextTarget) if (!clearSub.active) if (previousSub === null) source.firstTarget = clearSub.nextTarget;
+	else previousSub.nextTarget = clearSub.nextTarget;
+	else previousSub = clearSub;
+}
+
+//#endregion
+//#region src/watch/triggerEffects.ts
+/**
+* Runs the effects that have been collected during the batch.
+*/
+function triggerEffects() {
+	let didError = false;
+	let error;
+	let effect = context_default.firstEffectToRun;
+	while (effect !== null) {
+		context_default.batchOperation++;
+		try {
+			checkEffect(effect);
+		} catch (err) {
+			if (!didError) {
+				didError = true;
+				error = err;
+			}
+		}
+		effect = effect.nextEffectToRun;
+	}
+	effect = context_default.firstEffectToRun;
+	context_default.firstEffectToRun = null;
+	while (effect !== null) {
+		let nextEffect = effect.nextEffectToRun;
+		effect.nextEffectToRun = null;
+		effect = nextEffect;
+	}
+	let signal = context_default.firstSignalToUpdate;
+	context_default.firstSignalToUpdate = null;
+	while (signal !== null) {
+		clearTargets(signal);
+		const nextSignal = signal.nextSignalToUpdate;
+		signal.nextSignalToUpdate = null;
+		signal = nextSignal;
+	}
+	if (didError) throw error;
+}
+
+//#endregion
+//#region src/watch/batchEnd.ts
+function batchEnd() {
+	if (context_default.batch > 1) {
+		context_default.batch--;
+		return;
+	}
+	try {
+		triggerEffects();
+	} finally {
+		context_default.batch = 0;
+		context_default.batchOperation = 0;
+		context_default.previousEffect = null;
+	}
+}
+
+//#endregion
+//#region src/render/$batch.ts
+/**
+* Runs updates to proxy values in a batch, where the updates are stored in
+* context, and dependent effects are run all at once at the end.
+*
+* @param fn The function containing the batched updates to run.
+*/
+function $batch(fn) {
+	if (context_default.batch > 0) return fn();
+	batchStart();
+	try {
+		return fn();
+	} finally {
+		batchEnd();
+	}
+}
+
+//#endregion
+//#region src/render/$cache.ts
+/**
+* Caches a computed value from signals accessed in a property getter.
+*
+* @param fn The function containing the signals to compute and cache.
+*/
+function $cache(fn) {
+	if (context_default.registerComputed === null) throw new Error("$cache must be used in a getter");
+	let computed = {
+		type: COMPUTED_TYPE,
+		value: null,
+		run: fn,
+		firstSource: null,
+		firstTarget: null,
+		recalc: false,
+		running: false,
+		didError: false,
+		rollback: null
+	};
+	context_default.registerComputed(computed);
+	runComputed(computed);
+	return computed.value;
+}
+
+//#endregion
+//#region src/render/$peek.ts
+function $peek(fn) {
+	const oldActiveTarget = context_default.activeTarget;
+	context_default.activeTarget = null;
+	const result = fn();
+	context_default.activeTarget = oldActiveTarget;
+	return result;
+}
+
+//#endregion
+//#region src/render/buildClasses.ts
+function buildClasses(value, styleHash) {
+	if (typeof value === "string") {
+		if (styleHash !== void 0) value += " " + styleHash;
+		return value;
+	} else {
+		let classes = [];
+		gatherNames("", value, classes);
+		if (styleHash !== void 0) classes.push(styleHash);
+		return classes.join(" ");
+	}
+}
+function gatherNames(name, value, classes) {
+	if (value) if (Array.isArray(value)) for (let v of value) gatherNames(v, v, classes);
+	else if (typeof value === "object") for (let [n, v] of Object.entries(value)) gatherNames(n, v, classes);
+	else classes.push(name);
+}
+
+//#endregion
+//#region src/render/buildStyles.ts
+function buildStyles(value) {
+	if (typeof value === "string") return value;
+	else {
+		let styles = [];
+		if (value) {
+			if (Array.isArray(value)) for (let v of value) styles.push(v);
+			else if (typeof value === "object") for (let [n, v] of Object.entries(value)) styles.push(`${n}: ${v}`);
+		}
+		return styles.join("; ");
+	}
+}
+
+//#endregion
+//#region src/render/formatText.ts
+function formatText(value) {
+	return value ?? "";
+}
+
+//#endregion
+Object.defineProperty(exports, '$batch', {
+  enumerable: true,
+  get: function () {
+    return $batch;
+  }
+});
+Object.defineProperty(exports, '$cache', {
+  enumerable: true,
+  get: function () {
+    return $cache;
+  }
+});
+Object.defineProperty(exports, '$peek', {
+  enumerable: true,
+  get: function () {
+    return $peek;
+  }
+});
+Object.defineProperty(exports, 'COMPUTED_TYPE', {
+  enumerable: true,
+  get: function () {
+    return COMPUTED_TYPE;
+  }
+});
+Object.defineProperty(exports, 'EFFECT_TYPE', {
+  enumerable: true,
+  get: function () {
+    return EFFECT_TYPE;
+  }
+});
+Object.defineProperty(exports, 'SIGNAL_TYPE', {
+  enumerable: true,
+  get: function () {
+    return SIGNAL_TYPE;
+  }
+});
+Object.defineProperty(exports, 'batchEnd', {
+  enumerable: true,
+  get: function () {
+    return batchEnd;
+  }
+});
+Object.defineProperty(exports, 'batchStart', {
+  enumerable: true,
+  get: function () {
+    return batchStart;
+  }
+});
+Object.defineProperty(exports, 'buildClasses', {
+  enumerable: true,
+  get: function () {
+    return buildClasses;
+  }
+});
+Object.defineProperty(exports, 'buildStyles', {
+  enumerable: true,
+  get: function () {
+    return buildStyles;
+  }
+});
+Object.defineProperty(exports, 'checkComputed', {
+  enumerable: true,
+  get: function () {
+    return checkComputed;
+  }
+});
+Object.defineProperty(exports, 'context_default', {
+  enumerable: true,
+  get: function () {
+    return context_default;
+  }
+});
+Object.defineProperty(exports, 'formatText', {
+  enumerable: true,
+  get: function () {
+    return formatText;
+  }
+});
+Object.defineProperty(exports, 'runEffect', {
+  enumerable: true,
+  get: function () {
+    return runEffect;
+  }
+});
+Object.defineProperty(exports, 'trackEffect', {
+  enumerable: true,
+  get: function () {
+    return trackEffect;
+  }
+});
+//# sourceMappingURL=formatText-DufG5l83.cjs.map