@cossackframework/renderer 0.7.4 → 0.7.6

package/README.md

@@ -4,7 +4,9 @@ Cossack Renderer is a Lit-compatible rendering engine designed for **Light DOM**
 
 ## Installation
 
-This package is intended to use with the Cossack Framework via `create-cossack-app`, but can also be used standalone in any project that needs a lightweight rendering solution.
+This package is included by projects created with `cossack create`, but can
+also be used standalone in any project that needs a lightweight rendering
+solution.
 
 ```bash
 pnpm add @cossackframework/renderer

package/dist/component.js

@@ -0,0 +1,4 @@
+//#region src/component.ts
+var e = (e) => typeof e == "object" && !!e && e._type === "COMPONENT";
+//#endregion
+export { e as isComponentResult };

package/dist/context.js

@@ -0,0 +1,9 @@
+//#region src/context.ts
+function e(e) {
+	return {
+		id: Math.random().toString(36).slice(2),
+		defaultValue: e
+	};
+}
+//#endregion
+export { e as createContext };

package/dist/cossack-element.js

@@ -0,0 +1,166 @@
+import { getFinalizedStyles as e } from "./css.js";
+import { TemplateResult as t, html as n, hydrate as r, isTemplateResult as i, render as a } from "./cossack-html.js";
+//#region src/cossack-element.ts
+var o = [], s = (e) => o.push(e), c = () => o.pop(), l = /* @__PURE__ */ new WeakMap(), u = (e) => {
+	let n = [e];
+	return n.raw = n, new t(n, []);
+}, d = (e, t) => {
+	let n = l.get(e);
+	if (!n) {
+		let r = t.cssText.replace(/<\/style/gi, "<\\/style");
+		n = u(`<style data-cossack-style="${t.scopeId}">${r}</style>`), l.set(e, n);
+	}
+	return n;
+}, f = (e, t) => n`${e}${t}`, p = class {
+	static properties = {};
+	static _isCossackElement = !0;
+	static components = {};
+	static styles;
+	children = null;
+	props = {};
+	__parent = null;
+	_id = "";
+	_childCounter = 0;
+	__providedContexts = /* @__PURE__ */ new Map();
+	__properties = /* @__PURE__ */ new Map();
+	__updatePromise = null;
+	__changedProperties = /* @__PURE__ */ new Map();
+	__renderListeners = /* @__PURE__ */ new Set();
+	__controllers = /* @__PURE__ */ new Set();
+	__hasConnected = !1;
+	__eventListeners = /* @__PURE__ */ new Map();
+	constructor() {
+		this.initialize();
+	}
+	static get currentRenderingInstance() {
+		return o.length > 0 ? o[o.length - 1] : null;
+	}
+	resetRenderState() {
+		this._childCounter = 0;
+	}
+	addController(e) {
+		this.__controllers.add(e), this.__hasConnected && e.hostConnected && e.hostConnected();
+	}
+	removeController(e) {
+		this.__controllers.delete(e);
+	}
+	get updateComplete() {
+		return this.__updatePromise || Promise.resolve(!0);
+	}
+	initialize() {
+		let e = this.constructor.properties;
+		if (e) for (let [t, n] of Object.entries(e)) this.createProperty(t, n);
+	}
+	createProperty(e, t) {
+		Object.prototype.hasOwnProperty.call(this, e) && this.__properties.set(e, this[e]), Object.defineProperty(this, e, {
+			get() {
+				return this.__properties.get(e);
+			},
+			set(t) {
+				let n = this.__properties.get(e);
+				n !== t && (this.__properties.set(e, t), this.requestUpdate(e, n));
+			},
+			configurable: !0,
+			enumerable: !0
+		});
+	}
+	provide(e, t) {
+		this.__providedContexts.set(e, t);
+	}
+	consume(e) {
+		let t = this.__parent;
+		for (; t;) {
+			if (t.__providedContexts.has(e)) return t.__providedContexts.get(e);
+			t = t.__parent;
+		}
+		return e.defaultValue;
+	}
+	requestUpdate(e, t) {
+		return e !== void 0 && (this.__changedProperties.has(e) || this.__changedProperties.set(e, t)), this.__updatePromise ||= this.performUpdate(), this.__updatePromise;
+	}
+	async performUpdate() {
+		await Promise.resolve();
+		let e = !1;
+		try {
+			if (e = this.shouldUpdate(this.__changedProperties), e) {
+				this.__controllers.forEach((e) => e.hostUpdate && e.hostUpdate()), this.willUpdate(this.__changedProperties), this.resetRenderState(), s(this);
+				let e = this._finalizeRenderOutput(this.render());
+				this.__notifyListeners(e), c(), this.updated(this.__changedProperties), this.__controllers.forEach((e) => e.hostUpdated && e.hostUpdated());
+			}
+		} catch (e) {
+			console.error("Error during update:", e), o[o.length - 1] === this && c();
+		}
+		return this.__changedProperties = /* @__PURE__ */ new Map(), this.__updatePromise = null, e;
+	}
+	__notifyListeners(e) {
+		this.__renderListeners.forEach((t) => t(e));
+	}
+	addRenderListener(e) {
+		this.__renderListeners.add(e);
+	}
+	removeRenderListener(e) {
+		this.__renderListeners.delete(e);
+	}
+	_getStyleScopeId() {
+		return e(this.constructor)?.scopeId;
+	}
+	_finalizeRenderOutput(t) {
+		let n = e(this.constructor);
+		return this._claimTemplateOwnership(t, n?.scopeId), n ? f(d(this.constructor, n), t) : t;
+	}
+	_claimTemplateOwnership(e, t) {
+		if (!(!e || typeof e != "object")) {
+			if (e._type === "COMPONENT") {
+				let n = e;
+				n.parent = this, this._claimTemplateOwnership(n.children, t);
+				return;
+			}
+			if (i(e)) {
+				if (e.__cossackOwner && e.__cossackOwner !== this) return;
+				e.__cossackOwner = this, e.__cossackScope = t;
+				for (let n of e.values) this._claimTemplateOwnership(n, t);
+				return;
+			}
+			if (Array.isArray(e)) for (let n of e) this._claimTemplateOwnership(n, t);
+		}
+	}
+	mount(e, t = !1) {
+		let o = t;
+		this.addRenderListener((t) => {
+			if (t) {
+				let s = i(t) ? t : n`${t}`;
+				o ? (o = !1, r(s, e)) : a(s, e);
+			}
+		}), this.requestUpdate();
+	}
+	addEventListener(e, t, n) {
+		t && (this.__eventListeners.has(e) || this.__eventListeners.set(e, /* @__PURE__ */ new Set()), this.__eventListeners.get(e).add(t));
+	}
+	removeEventListener(e, t, n) {
+		if (!t) return;
+		let r = this.__eventListeners.get(e);
+		r && r.delete(t);
+	}
+	dispatchEvent(e) {
+		let t = this.__eventListeners.get(e.type);
+		return t && t.forEach((t) => {
+			typeof t == "function" ? t.call(this, e) : t.handleEvent(e);
+		}), !e.defaultPrevented;
+	}
+	shouldUpdate(e) {
+		return !0;
+	}
+	willUpdate(e) {}
+	render() {
+		return null;
+	}
+	updated(e) {}
+	connectedCallback() {
+		this.__hasConnected = !0, this.__controllers.forEach((e) => e.hostConnected && e.hostConnected());
+	}
+	disconnectedCallback() {
+		this.__hasConnected = !1, this.__controllers.forEach((e) => e.hostDisconnected && e.hostDisconnected());
+	}
+};
+//#endregion
+export { p as CossackElement, o as instanceStack, c as popCurrentInstance, s as pushCurrentInstance };