dsh-remote-plugin 0.6.13 → 0.6.15

package/public/vendor/morphicons/dom.js

@@ -0,0 +1,206 @@
+import { a as buildPlan, c as interpPolar, n as Spring, o as allocOutputs, r as resampleIcon, t as SPRING_PRESETS } from "./spring-CFHloqPP.js";
+import { i as serialize, n as iconToCubics, r as cubicsToPathD } from "./normalize-CYnN3Npw.js";
+//#region src/dom/index.ts
+const tickers = /* @__PURE__ */ new Set();
+let rafId = 0;
+let last = -1;
+function loop(ts) {
+	const dt = last < 0 ? 0 : Math.min(Math.max((ts - last) / 1e3, 0), .1);
+	last = ts;
+	for (const tick of [...tickers]) tick(dt);
+	if (tickers.size > 0) rafId = requestAnimationFrame(loop);
+	else {
+		rafId = 0;
+		last = -1;
+	}
+}
+function addTicker(tick) {
+	tickers.add(tick);
+	if (rafId === 0) {
+		last = -1;
+		rafId = requestAnimationFrame(loop);
+	}
+}
+function removeTicker(tick) {
+	tickers.delete(tick);
+	if (tickers.size === 0 && rafId !== 0) {
+		cancelAnimationFrame(rafId);
+		rafId = 0;
+		last = -1;
+	}
+}
+const samples = /* @__PURE__ */ new WeakMap();
+const canon = /* @__PURE__ */ new WeakMap();
+const plans = /* @__PURE__ */ new WeakMap();
+function sampledOf(icon) {
+	if (typeof icon === "string") return resampleIcon(icon);
+	let s = samples.get(icon);
+	if (!s) {
+		s = resampleIcon(icon);
+		samples.set(icon, s);
+	}
+	return s;
+}
+/** Canonical `d` of an icon: the input string verbatim, or the real cubics
+*  quantized to 4 decimals (the at-rest snap; engine-stable bytes so SSR
+*  hydration matches, see fmtCanon in core/serialize). Exported because it
+*  is what a binding renders at SSR/rest before any runtime exists. */
+function canonicalD(icon) {
+	if (typeof icon === "string") return icon;
+	let d = canon.get(icon);
+	if (!d) {
+		d = cubicsToPathD(iconToCubics(icon));
+		canon.set(icon, d);
+	}
+	return d;
+}
+function planBetween(src, dst) {
+	if (typeof src === "string" || typeof dst === "string") return buildPlan(sampledOf(src), sampledOf(dst));
+	let inner = plans.get(src);
+	if (!inner) {
+		inner = /* @__PURE__ */ new WeakMap();
+		plans.set(src, inner);
+	}
+	let p = inner.get(dst);
+	if (!p) {
+		p = buildPlan(sampledOf(src), sampledOf(dst));
+		inner.set(dst, p);
+	}
+	return p;
+}
+function resolveSpring(s) {
+	if (typeof s === "string") return SPRING_PRESETS[s];
+	const d = SPRING_PRESETS.snappy;
+	return {
+		k: s?.stiffness ?? d.k,
+		c: s?.damping ?? d.c
+	};
+}
+/** Creates the morph instance over a `<path>` and paints the initial icon. */
+function createMorph(el, icon, options) {
+	const spring = new Spring();
+	let reducedMotion = options?.reducedMotion ?? "never";
+	let target = icon;
+	let rest = true;
+	let plan = null;
+	let out = null;
+	let closed = null;
+	let t = 1;
+	let flying = false;
+	let dead = false;
+	el.setAttribute("d", canonicalD(icon));
+	const render = (tt) => {
+		const p = plan;
+		const o = out;
+		const cl = closed;
+		if (!p || !o || !cl) return;
+		t = tt;
+		interpPolar(p, tt, o);
+		el.setAttribute("d", serialize(o, cl));
+	};
+	const stop = () => {
+		if (!flying) return;
+		flying = false;
+		removeTicker(tick);
+	};
+	const tick = (dt) => {
+		const settled = spring.step(dt);
+		render(spring.x);
+		if (settled) {
+			stop();
+			settle();
+		}
+	};
+	const settle = () => {
+		rest = true;
+		plan = null;
+		out = null;
+		closed = null;
+		t = 1;
+		spring.x = 1;
+		spring.v = 0;
+		el.setAttribute("d", canonicalD(target));
+	};
+	/** The current shape as plan source: the at-rest icon, or the rendered
+	*  buffers (already N points per subpath). */
+	const snapshot = () => {
+		const p = plan;
+		const o = out;
+		if (rest || !p || !o) return sampledOf(target);
+		return o.map((buf, k) => ({
+			pts: Float64Array.from(buf),
+			closed: p.items[k].closed
+		}));
+	};
+	const retarget = (icon) => {
+		plan = rest ? planBetween(target, icon) : buildPlan(snapshot(), sampledOf(icon));
+		out = allocOutputs(plan);
+		closed = plan.items.map((it) => it.closed);
+		target = icon;
+		rest = false;
+	};
+	const setNow = (icon) => {
+		stop();
+		target = icon;
+		settle();
+	};
+	/** True when the policy says this morphTo must jump instead of flying. */
+	const motionOff = () => {
+		if (reducedMotion === "always") return true;
+		if (reducedMotion !== "user") return false;
+		if (typeof matchMedia === "undefined") return false;
+		return matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
+	};
+	const seek = (icon, tt) => {
+		if (dead) return;
+		const reuse = !rest && plan !== null && icon === target;
+		stop();
+		spring.v = 0;
+		if (!reuse) retarget(icon);
+		render(tt);
+	};
+	return {
+		morphTo(icon, sp) {
+			if (dead) return;
+			if (icon === target && (rest || flying)) return;
+			if (motionOff()) {
+				setNow(icon);
+				return;
+			}
+			const { k, c } = resolveSpring(sp);
+			spring.config(k, c);
+			retarget(icon);
+			spring.start();
+			if (!flying) {
+				flying = true;
+				addTicker(tick);
+			}
+		},
+		set(icon) {
+			if (dead) return;
+			setNow(icon);
+		},
+		seek,
+		get progress() {
+			return rest ? 1 : t;
+		},
+		set progress(v) {
+			if (!dead) seek(target, v);
+		},
+		get reducedMotion() {
+			return reducedMotion;
+		},
+		set reducedMotion(v) {
+			reducedMotion = v;
+		},
+		destroy() {
+			stop();
+			dead = true;
+			plan = null;
+			out = null;
+			closed = null;
+		}
+	};
+}
+//#endregion
+export { canonicalD, createMorph };

package/public/vendor/morphicons/element.js

@@ -0,0 +1,261 @@
+import { n as createController, t as computeInitialD } from "./controller-CXZuwJ_M.js";
+//#region src/element/index.ts
+const SVG_NS = "http://www.w3.org/2000/svg";
+const REACTIVE = [
+	"icon",
+	"from",
+	"to",
+	"progress",
+	"spring",
+	"reducedMotion"
+];
+const PRESENTATION = /* @__PURE__ */ new Set([
+	"size",
+	"color",
+	"stroke-width",
+	"absolute-stroke-width",
+	"label"
+]);
+const Base = typeof HTMLElement === "undefined" ? class {} : HTMLElement;
+var MorphIconElement = class extends Base {
+	static observedAttributes = [
+		"icon",
+		"from",
+		"to",
+		"progress",
+		"spring",
+		"reduced-motion",
+		"size",
+		"color",
+		"stroke-width",
+		"absolute-stroke-width",
+		"label"
+	];
+	#props = {};
+	#ctrl = null;
+	#path = null;
+	#adopted = false;
+	#preConnectDirty = false;
+	#size = "24";
+	#color = "currentColor";
+	#strokeWidth = "2";
+	#absoluteStrokeWidth = false;
+	#label = null;
+	get icon() {
+		return this.#props.icon;
+	}
+	set icon(v) {
+		this.#props.icon = v;
+		this.#watch();
+	}
+	get from() {
+		return this.#props.from;
+	}
+	set from(v) {
+		this.#props.from = v;
+		this.#watch();
+	}
+	get to() {
+		return this.#props.to;
+	}
+	set to(v) {
+		this.#props.to = v;
+		this.#watch();
+	}
+	get progress() {
+		return this.#props.progress;
+	}
+	set progress(v) {
+		this.#props.progress = v;
+		this.#watch();
+	}
+	get spring() {
+		return this.#props.spring;
+	}
+	set spring(v) {
+		this.#props.spring = v;
+		this.#watch();
+	}
+	get reducedMotion() {
+		return this.#props.reducedMotion;
+	}
+	set reducedMotion(v) {
+		this.#props.reducedMotion = v;
+		this.#watch();
+	}
+	morphTo(icon, spring) {
+		const ctrl = this.#ctrl;
+		if (!ctrl) {
+			this.#imperativeBeforeDriver(icon);
+			return;
+		}
+		ctrl.morphTo(icon, spring ?? this.#props.spring);
+	}
+	set(icon) {
+		const ctrl = this.#ctrl;
+		if (!ctrl) {
+			this.#imperativeBeforeDriver(icon);
+			return;
+		}
+		ctrl.set(icon);
+	}
+	connectedCallback() {
+		for (const key of REACTIVE) this.#upgradeProperty(key);
+		if (!this.#path) this.#adoptOrRender();
+		if (this.style.display === "") this.style.display = "contents";
+		if (this.#path && !this.#ctrl) {
+			const path = this.#path;
+			const gate = this.#adopted && !this.#preConnectDirty;
+			this.#adopted = false;
+			this.#ctrl = createController(this.#props);
+			if (gate) {
+				let armed = false;
+				const gated = { setAttribute(name, value) {
+					if (armed) path.setAttribute(name, value);
+				} };
+				try {
+					this.#ctrl.mount(gated, this.#props);
+				} finally {
+					armed = true;
+				}
+			} else this.#ctrl.mount(path, this.#props);
+		}
+	}
+	disconnectedCallback() {
+		this.#ctrl?.destroy();
+		this.#ctrl = null;
+	}
+	attributeChangedCallback(name, _old, value) {
+		switch (name) {
+			case "icon":
+				this.#props.icon = value ?? void 0;
+				break;
+			case "from":
+				this.#props.from = value ?? void 0;
+				break;
+			case "to":
+				this.#props.to = value ?? void 0;
+				break;
+			case "progress": {
+				const n = value === null ? NaN : Number(value);
+				this.#props.progress = Number.isFinite(n) ? n : void 0;
+				break;
+			}
+			case "spring":
+				this.#props.spring = value ?? void 0;
+				break;
+			case "reduced-motion":
+				this.#props.reducedMotion = value ?? void 0;
+				break;
+			case "size":
+				this.#size = value ?? "24";
+				break;
+			case "color":
+				this.#color = value ?? "currentColor";
+				break;
+			case "stroke-width":
+				this.#strokeWidth = value ?? "2";
+				break;
+			case "absolute-stroke-width":
+				this.#absoluteStrokeWidth = value !== null;
+				break;
+			case "label": this.#label = value;
+		}
+		if (!this.#path) return;
+		if (PRESENTATION.has(name)) {
+			const svg = this.querySelector("svg");
+			if (svg) this.#applyPresentation(svg);
+			return;
+		}
+		this.#watch();
+	}
+	/** A property assigned before the element was defined lands as an own
+	*  value that shadows the accessor; re-route it through the setter. */
+	#upgradeProperty(key) {
+		if (Object.hasOwn(this, key)) {
+			const self = this;
+			const v = self[key];
+			delete self[key];
+			self[key] = v;
+		}
+	}
+	#watch() {
+		const ctrl = this.#ctrl;
+		if (!ctrl) {
+			this.#preConnectDirty = true;
+			return;
+		}
+		ctrl.watch(this.#props);
+	}
+	/** Imperative call before the controller exists: adopt the icon as the
+	*  mount state AND exit controlled mode — "every imperative call
+	*  invalidates the frozen pair" must hold pre-connect too, or a pending
+	*  pair would win the mount and silently discard this call. */
+	#imperativeBeforeDriver(icon) {
+		this.#props.icon = icon;
+		this.#props.from = void 0;
+		this.#props.to = void 0;
+		this.#preConnectDirty = true;
+	}
+	/** SSR markup is adopted verbatim (the element never rewrites server bytes
+	*  at rest); without it, the element renders its own <svg> like the
+	*  framework shells do. */
+	#adoptOrRender() {
+		const existing = this.querySelector("path");
+		if (existing) {
+			this.#path = existing;
+			this.#adopted = true;
+			const p = this.#props;
+			if (p.icon === void 0 && p.from === void 0 && p.to === void 0) {
+				const d = existing.getAttribute("d");
+				if (d) p.icon = d;
+			}
+			return;
+		}
+		const doc = this.ownerDocument;
+		const svg = doc.createElementNS(SVG_NS, "svg");
+		svg.setAttribute("xmlns", SVG_NS);
+		svg.setAttribute("viewBox", "0 0 24 24");
+		svg.setAttribute("fill", "none");
+		svg.setAttribute("stroke-linecap", "round");
+		svg.setAttribute("stroke-linejoin", "round");
+		this.#applyPresentation(svg);
+		const path = doc.createElementNS(SVG_NS, "path");
+		path.setAttribute("d", computeInitialD(this.#props));
+		svg.appendChild(path);
+		this.appendChild(svg);
+		this.#path = path;
+	}
+	#applyPresentation(svg) {
+		svg.setAttribute("width", this.#size);
+		svg.setAttribute("height", this.#size);
+		svg.setAttribute("stroke", this.#color);
+		const sw = this.#absoluteStrokeWidth ? String(Number(this.#strokeWidth) * 24 / Number(this.#size)) : this.#strokeWidth;
+		svg.setAttribute("stroke-width", sw);
+		const label = this.#label;
+		let title = svg.querySelector("title");
+		if (label) {
+			svg.setAttribute("role", "img");
+			svg.removeAttribute("aria-hidden");
+			if (!title) {
+				title = this.ownerDocument.createElementNS(SVG_NS, "title");
+				svg.insertBefore(title, svg.firstChild);
+			}
+			title.textContent = label;
+		} else {
+			svg.removeAttribute("role");
+			svg.setAttribute("aria-hidden", "true");
+			title?.remove();
+		}
+	}
+};
+let registered = false;
+/** Defines `<morph-icon>` (or a custom tag). Idempotent per tag; a no-op
+*  without a DOM (safe to call from code that also runs during SSR). */
+function defineMorphIcon(tag = "morph-icon") {
+	if (typeof customElements === "undefined" || customElements.get(tag)) return;
+	customElements.define(tag, registered ? class extends MorphIconElement {} : MorphIconElement);
+	registered = true;
+}
+//#endregion
+export { MorphIconElement, computeInitialD, defineMorphIcon };