@attraccess/plugin-shelly 0.1.0-alpha.0

package/frontend/__federation_fn_import-DAGm_xmC.js

@@ -0,0 +1,2 @@
+import { n as getSharedFromRuntime, r as importShared, t as getSharedFromLocal } from "./_virtual___federation_fn_import-BXODRNto.js";
+export { importShared, getSharedFromLocal as importSharedLocal, getSharedFromRuntime as importSharedRuntime };

package/frontend/_virtual___federation_fn_import-BXODRNto.js

@@ -0,0 +1,261 @@
+//#region ../../../node_modules/.pnpm/@originjs+vite-plugin-federation@1.4.1/node_modules/@originjs/vite-plugin-federation/dist/satisfy.mjs
+var buildIdentifier = "[0-9A-Za-z-]+";
+var build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
+var numericIdentifier = "0|[1-9]\\d*";
+var numericIdentifierLoose = "[0-9]+";
+var nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+var preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
+var preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
+var preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
+var preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
+var xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
+var xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
+var hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`;
+var loosePlain = `[v=\\s]*${`(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`}${preReleaseLoose}?${build}?`;
+var gtlt = "((?:<|>)?=?)";
+var comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`;
+var loneTilde = "(?:~>?)";
+var tildeTrim = `(\\s*)${loneTilde}\\s+`;
+var loneCaret = "(?:\\^)";
+var caretTrim = `(\\s*)${loneCaret}\\s+`;
+var star = "(<|>)?=?\\s*\\*";
+var caret = `^${loneCaret}${xRangePlain}$`;
+var fullPlain = `v?${`(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`}${preRelease}?${build}?`;
+var tilde = `^${loneTilde}${xRangePlain}$`;
+var xRange = `^${gtlt}\\s*${xRangePlain}$`;
+var comparator = `^${gtlt}\\s*(${fullPlain})$|^$`;
+var gte0 = "^\\s*>=\\s*0.0.0\\s*$";
+function parseRegex(source) {
+	return new RegExp(source);
+}
+function isXVersion(version) {
+	return !version || version.toLowerCase() === "x" || version === "*";
+}
+function pipe(...fns) {
+	return (x) => {
+		return fns.reduce((v, f) => f(v), x);
+	};
+}
+function extractComparator(comparatorString) {
+	return comparatorString.match(parseRegex(comparator));
+}
+function combineVersion(major, minor, patch, preRelease2) {
+	const mainVersion2 = `${major}.${minor}.${patch}`;
+	if (preRelease2) return `${mainVersion2}-${preRelease2}`;
+	return mainVersion2;
+}
+function parseHyphen(range) {
+	return range.replace(parseRegex(hyphenRange), (_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) => {
+		if (isXVersion(fromMajor)) from = "";
+		else if (isXVersion(fromMinor)) from = `>=${fromMajor}.0.0`;
+		else if (isXVersion(fromPatch)) from = `>=${fromMajor}.${fromMinor}.0`;
+		else from = `>=${from}`;
+		if (isXVersion(toMajor)) to = "";
+		else if (isXVersion(toMinor)) to = `<${+toMajor + 1}.0.0-0`;
+		else if (isXVersion(toPatch)) to = `<${toMajor}.${+toMinor + 1}.0-0`;
+		else if (toPreRelease) to = `<=${toMajor}.${toMinor}.${toPatch}-${toPreRelease}`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	});
+}
+function parseComparatorTrim(range) {
+	return range.replace(parseRegex(comparatorTrim), "$1$2$3");
+}
+function parseTildeTrim(range) {
+	return range.replace(parseRegex(tildeTrim), "$1~");
+}
+function parseCaretTrim(range) {
+	return range.replace(parseRegex(caretTrim), "$1^");
+}
+function parseCarets(range) {
+	return range.trim().split(/\s+/).map((rangeVersion) => {
+		return rangeVersion.replace(parseRegex(caret), (_, major, minor, patch, preRelease2) => {
+			if (isXVersion(major)) return "";
+			else if (isXVersion(minor)) return `>=${major}.0.0 <${+major + 1}.0.0-0`;
+			else if (isXVersion(patch)) {
+				if (major === "0") return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
+				else return `>=${major}.${minor}.0 <${+major + 1}.0.0-0`;
+			} else if (preRelease2) {
+				if (major === "0") {
+					if (minor === "0") return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${minor}.${+patch + 1}-0`;
+					else return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${+minor + 1}.0-0`;
+				} else return `>=${major}.${minor}.${patch}-${preRelease2} <${+major + 1}.0.0-0`;
+			} else {
+				if (major === "0") {
+					if (minor === "0") return `>=${major}.${minor}.${patch} <${major}.${minor}.${+patch + 1}-0`;
+					else return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
+				}
+				return `>=${major}.${minor}.${patch} <${+major + 1}.0.0-0`;
+			}
+		});
+	}).join(" ");
+}
+function parseTildes(range) {
+	return range.trim().split(/\s+/).map((rangeVersion) => {
+		return rangeVersion.replace(parseRegex(tilde), (_, major, minor, patch, preRelease2) => {
+			if (isXVersion(major)) return "";
+			else if (isXVersion(minor)) return `>=${major}.0.0 <${+major + 1}.0.0-0`;
+			else if (isXVersion(patch)) return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
+			else if (preRelease2) return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${+minor + 1}.0-0`;
+			return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
+		});
+	}).join(" ");
+}
+function parseXRanges(range) {
+	return range.split(/\s+/).map((rangeVersion) => {
+		return rangeVersion.trim().replace(parseRegex(xRange), (ret, gtlt2, major, minor, patch, preRelease2) => {
+			const isXMajor = isXVersion(major);
+			const isXMinor = isXMajor || isXVersion(minor);
+			const isXPatch = isXMinor || isXVersion(patch);
+			if (gtlt2 === "=" && isXPatch) gtlt2 = "";
+			preRelease2 = "";
+			if (isXMajor) {
+				if (gtlt2 === ">" || gtlt2 === "<") return "<0.0.0-0";
+				else return "*";
+			} else if (gtlt2 && isXPatch) {
+				if (isXMinor) minor = 0;
+				patch = 0;
+				if (gtlt2 === ">") {
+					gtlt2 = ">=";
+					if (isXMinor) {
+						major = +major + 1;
+						minor = 0;
+						patch = 0;
+					} else {
+						minor = +minor + 1;
+						patch = 0;
+					}
+				} else if (gtlt2 === "<=") {
+					gtlt2 = "<";
+					if (isXMinor) major = +major + 1;
+					else minor = +minor + 1;
+				}
+				if (gtlt2 === "<") preRelease2 = "-0";
+				return `${gtlt2 + major}.${minor}.${patch}${preRelease2}`;
+			} else if (isXMinor) return `>=${major}.0.0${preRelease2} <${+major + 1}.0.0-0`;
+			else if (isXPatch) return `>=${major}.${minor}.0${preRelease2} <${major}.${+minor + 1}.0-0`;
+			return ret;
+		});
+	}).join(" ");
+}
+function parseStar(range) {
+	return range.trim().replace(parseRegex(star), "");
+}
+function parseGTE0(comparatorString) {
+	return comparatorString.trim().replace(parseRegex(gte0), "");
+}
+function compareAtom(rangeAtom, versionAtom) {
+	rangeAtom = +rangeAtom || rangeAtom;
+	versionAtom = +versionAtom || versionAtom;
+	if (rangeAtom > versionAtom) return 1;
+	if (rangeAtom === versionAtom) return 0;
+	return -1;
+}
+function comparePreRelease(rangeAtom, versionAtom) {
+	const { preRelease: rangePreRelease } = rangeAtom;
+	const { preRelease: versionPreRelease } = versionAtom;
+	if (rangePreRelease === void 0 && !!versionPreRelease) return 1;
+	if (!!rangePreRelease && versionPreRelease === void 0) return -1;
+	if (rangePreRelease === void 0 && versionPreRelease === void 0) return 0;
+	for (let i = 0, n = rangePreRelease.length; i <= n; i++) {
+		const rangeElement = rangePreRelease[i];
+		const versionElement = versionPreRelease[i];
+		if (rangeElement === versionElement) continue;
+		if (rangeElement === void 0 && versionElement === void 0) return 0;
+		if (!rangeElement) return 1;
+		if (!versionElement) return -1;
+		return compareAtom(rangeElement, versionElement);
+	}
+	return 0;
+}
+function compareVersion(rangeAtom, versionAtom) {
+	return compareAtom(rangeAtom.major, versionAtom.major) || compareAtom(rangeAtom.minor, versionAtom.minor) || compareAtom(rangeAtom.patch, versionAtom.patch) || comparePreRelease(rangeAtom, versionAtom);
+}
+function eq(rangeAtom, versionAtom) {
+	return rangeAtom.version === versionAtom.version;
+}
+function compare(rangeAtom, versionAtom) {
+	switch (rangeAtom.operator) {
+		case "":
+		case "=": return eq(rangeAtom, versionAtom);
+		case ">": return compareVersion(rangeAtom, versionAtom) < 0;
+		case ">=": return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0;
+		case "<": return compareVersion(rangeAtom, versionAtom) > 0;
+		case "<=": return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0;
+		case void 0: return true;
+		default: return false;
+	}
+}
+function parseComparatorString(range) {
+	return pipe(parseCarets, parseTildes, parseXRanges, parseStar)(range);
+}
+function parseRange(range) {
+	return pipe(parseHyphen, parseComparatorTrim, parseTildeTrim, parseCaretTrim)(range.trim()).split(/\s+/).join(" ");
+}
+function satisfy(version, range) {
+	if (!version) return false;
+	const comparators = parseRange(range).split(" ").map((rangeVersion) => parseComparatorString(rangeVersion)).join(" ").split(/\s+/).map((comparator2) => parseGTE0(comparator2));
+	const extractedVersion = extractComparator(version);
+	if (!extractedVersion) return false;
+	const [, versionOperator, , versionMajor, versionMinor, versionPatch, versionPreRelease] = extractedVersion;
+	const versionAtom = {
+		operator: versionOperator,
+		version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease),
+		major: versionMajor,
+		minor: versionMinor,
+		patch: versionPatch,
+		preRelease: versionPreRelease == null ? void 0 : versionPreRelease.split(".")
+	};
+	for (const comparator2 of comparators) {
+		const extractedComparator = extractComparator(comparator2);
+		if (!extractedComparator) return false;
+		const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease] = extractedComparator;
+		if (!compare({
+			operator: rangeOperator,
+			version: combineVersion(rangeMajor, rangeMinor, rangePatch, rangePreRelease),
+			major: rangeMajor,
+			minor: rangeMinor,
+			patch: rangePatch,
+			preRelease: rangePreRelease == null ? void 0 : rangePreRelease.split(".")
+		}, versionAtom)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region \0virtual:__federation_fn_import
+var moduleMap = {};
+var moduleCache = Object.create(null);
+async function importShared(name, shareScope = "default") {
+	return moduleCache[name] ? new Promise((r) => r(moduleCache[name])) : await getSharedFromRuntime(name, shareScope) || getSharedFromLocal(name);
+}
+async function getSharedFromRuntime(name, shareScope) {
+	let module = null;
+	if (globalThis?.__federation_shared__?.[shareScope]?.[name]) {
+		const versionObj = globalThis.__federation_shared__[shareScope][name];
+		const requiredVersion = moduleMap[name]?.requiredVersion;
+		if (!!requiredVersion) {
+			const versionKey = Object.keys(versionObj).find((version) => satisfy(version, requiredVersion));
+			if (versionKey) module = await (await versionObj[versionKey].get())();
+			else console.log(`provider support ${name}(${versionKey}) is not satisfied requiredVersion(\${moduleMap[name].requiredVersion})`);
+		} else module = await (await versionObj[Object.keys(versionObj)[0]].get())();
+	}
+	if (module) return flattenModule(module, name);
+}
+async function getSharedFromLocal(name) {
+	if (moduleMap[name]?.import) return flattenModule(await (await moduleMap[name].get())(), name);
+	else console.error(`consumer config import=false,so cant use callback shared module`);
+}
+function flattenModule(module, name) {
+	if (typeof module.default === "function") {
+		Object.keys(module).forEach((key) => {
+			if (key !== "default") module.default[key] = module[key];
+		});
+		moduleCache[name] = module.default;
+		return module.default;
+	}
+	if (module.default) module = Object.assign({}, module.default, module);
+	moduleCache[name] = module;
+	return module;
+}
+//#endregion
+export { getSharedFromRuntime as n, importShared as r, getSharedFromLocal as t };

package/frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<!--
+  Vite needs an HTML entry to start a build. The plugin itself is emitted as the
+  module-federation `remoteEntry.js` by the federation plugin; this file is just
+  the build seed and is not used by the host.
+-->
+<html>
+  <head>
+    <title>plugin-shelly remote</title>
+    <link rel="stylesheet" crossorigin href="/style.css">
+  </head>
+  <body></body>
+</html>

package/frontend/jsx-runtime-B9Qmn8k7.js

@@ -0,0 +1,42 @@
+import { t as __commonJSMin } from "./rolldown-runtime-EAsCxrDo.js";
+//#region ../../../node_modules/.pnpm/react@19.2.8/node_modules/react/cjs/react-jsx-runtime.production.js
+/**
+* @license React
+* react-jsx-runtime.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+	var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+	function jsxProd(type, config, maybeKey) {
+		var key = null;
+		void 0 !== maybeKey && (key = "" + maybeKey);
+		void 0 !== config.key && (key = "" + config.key);
+		if ("key" in config) {
+			maybeKey = {};
+			for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+		} else maybeKey = config;
+		config = maybeKey.ref;
+		return {
+			$$typeof: REACT_ELEMENT_TYPE,
+			type,
+			key,
+			ref: void 0 !== config ? config : null,
+			props: maybeKey
+		};
+	}
+	exports.Fragment = REACT_FRAGMENT_TYPE;
+	exports.jsx = jsxProd;
+	exports.jsxs = jsxProd;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/react@19.2.8/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_react_jsx_runtime_production();
+}));
+//#endregion
+export { require_jsx_runtime as t };

package/frontend/preload-helper-DxWiKyOd.js

@@ -0,0 +1,68 @@
+//#region \0vite/preload-helper.js
+var scriptRel = "modulepreload";
+var assetsURL = function(dep) {
+	return "/" + dep;
+};
+var seen = {};
+var __vitePreload = function preload(baseModule, deps, importerUrl) {
+	let promise = Promise.resolve();
+	if (deps && deps.length > 0) {
+		const links = document.getElementsByTagName("link");
+		const cspNonceMeta = document.querySelector("meta[property=csp-nonce]");
+		const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
+		function allSettled(promises) {
+			return Promise.all(promises.map((p) => Promise.resolve(p).then((value) => ({
+				status: "fulfilled",
+				value
+			}), (reason) => ({
+				status: "rejected",
+				reason
+			}))));
+		}
+		function importMetaResolve(specifier) {
+			if (import.meta.resolve) return import.meta.resolve(specifier);
+			return new URL(
+				specifier,
+				/** #__KEEP__ */
+				import.meta.url
+			).href;
+		}
+		promise = allSettled(deps.map((dep) => {
+			dep = assetsURL(dep, importerUrl);
+			dep = importMetaResolve(dep);
+			if (dep in seen) return;
+			seen[dep] = true;
+			const isCss = dep.endsWith(".css");
+			for (let i = links.length - 1; i >= 0; i--) {
+				const link = links[i];
+				if (link.href === dep && (!isCss || link.rel === "stylesheet")) return;
+			}
+			const link = document.createElement("link");
+			link.rel = isCss ? "stylesheet" : scriptRel;
+			if (!isCss) link.as = "script";
+			link.crossOrigin = "";
+			link.href = dep;
+			if (cspNonce) link.setAttribute("nonce", cspNonce);
+			document.head.appendChild(link);
+			if (isCss) return new Promise((res, rej) => {
+				link.addEventListener("load", res);
+				link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
+			});
+		}));
+	}
+	function handlePreloadError(err) {
+		const e = new Event("vite:preloadError", { cancelable: true });
+		e.payload = err;
+		window.dispatchEvent(e);
+		if (!e.defaultPrevented) throw err;
+	}
+	return promise.then((res) => {
+		for (const item of res || []) {
+			if (item.status !== "rejected") continue;
+			handlePreloadError(item.reason);
+		}
+		return baseModule().catch(handlePreloadError);
+	});
+};
+//#endregion
+export { __vitePreload as t };