@plitzi/sdk-elements 0.33.1 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # @plitzi/sdk-elements
 
+## 0.34.0
+
+### Minor Changes
+
+- 5aceda0: `authorSpace` returns test handles, and every element carries its id in the DOM.
+
+  An end-to-end suite had nothing stable to address a rendered element by: a class is a styling decision that
+  changes with the design, a text match breaks when the copy is edited, and an `nth-child` chain is invalidated by
+  inserting a section above. What does not move is the element's id — which is also its name, chosen by whoever
+  authored it and unique across the document.
+
+  ```ts
+  const { schema, style, handles } = authorSpace(spec);
+  const el = locate(page, handles);
+
+  await expect(el('hero-title')).toBeVisible();
+  await page.goto(handles.page('pricing').path);
+  ```
+
+  Elements now render `data-plitzi-el="<id>"`. It ships by default — the ids are already in the page, since the
+  schema the browser hydrates from carries every one of them — and a deployment turns it off with
+  `render.testAttributes: false`.
+
+  Each handle reports whether the AUTHOR wrote the id or authoring derived a positional `<type>-<n>`, which is
+  what makes one generic assertion possible for any space: everything a space names must be on screen. A name that
+  does not exist throws at author time with a suggestion, rather than resolving to an empty locator at test time.
+
+- v0.34.0
+
+### Patch Changes
+
+- Updated dependencies [5aceda0]
+- Updated dependencies
+- Updated dependencies [5aceda0]
+  - @plitzi/sdk-shared@0.34.0
+  - @plitzi/sdk-auth@0.34.0
+  - @plitzi/sdk-dev-tools@0.34.0
+  - @plitzi/sdk-event-bridge@0.34.0
+  - @plitzi/sdk-interactions@0.34.0
+  - @plitzi/sdk-navigation@0.34.0
+  - @plitzi/sdk-schema@0.34.0
+
+## 0.33.2
+
+### Patch Changes
+
+- v0.33.2
+- Updated dependencies
+  - @plitzi/sdk-auth@0.33.2
+  - @plitzi/sdk-dev-tools@0.33.2
+  - @plitzi/sdk-event-bridge@0.33.2
+  - @plitzi/sdk-interactions@0.33.2
+  - @plitzi/sdk-navigation@0.33.2
+  - @plitzi/sdk-schema@0.33.2
+  - @plitzi/sdk-shared@0.33.2
+
 ## 0.33.1
 
 ### Patch Changes

package/dist/Component/ComponentProvider.mjs

@@ -1,5 +1,5 @@
-import { defaultElements as e } from "../index.mjs";
-import { getPlugins as t, processLocalCustomPlugins as n, processLocalPlugins as r } from "./ComponentHelper.mjs";
+import { getPlugins as e, processLocalCustomPlugins as t, processLocalPlugins as n } from "./ComponentHelper.mjs";
+import { defaultElements as r } from "../index.mjs";
 import { useCallback as i, useMemo as a, useRef as o } from "react";
 import { get as s, omit as c } from "@plitzi/plitzi-ui/helpers";
 import l from "@plitzi/sdk-shared/elements/ComponentContext";
@@ -7,36 +7,36 @@ import { jsx as u } from "react/jsx-runtime";
 //#region src/Component/ComponentProvider.tsx
 var d = ({ localComponents: d, localCustomComponents: f, children: p }) => {
 	let m = a(() => ({
-		...r(e),
-		...r(d),
-		...n(f)
+		...n(r),
+		...n(d),
+		...t(f)
 	}), [d, f]), h = o({}), g = o({
 		...h.current,
 		...m
-	}), _ = i((e = [], n = !1) => {
-		if (typeof e == "string" && !n) return g.current[e];
-		if (typeof e == "string" && n) {
-			let n = g.current[e];
+	}), _ = i((t = [], n = !1) => {
+		if (typeof t == "string" && !n) return g.current[t];
+		if (typeof t == "string" && n) {
+			let n = g.current[t];
 			return n ? {
-				[e]: n,
-				...c(t(n), [e])
+				[t]: n,
+				...c(e(n), [t])
 			} : {};
 		}
 		let r = {};
-		return e.forEach((e) => {
-			let i = g.current[e];
+		return t.forEach((t) => {
+			let i = g.current[t];
 			i && (n ? r = {
 				...r,
-				...c(t(i), [e])
-			} : r[e] = i);
+				...c(e(i), [t])
+			} : r[t] = i);
 		}), r;
-	}, []), v = i((e = []) => {
+	}, []), v = i((t = []) => {
 		let n = {};
-		return Array.isArray(e) || (e = [e]), e.forEach((e) => {
-			e.type && !g.current[e.type] && (n = {
+		return Array.isArray(t) || (t = [t]), t.forEach((t) => {
+			t.type && !g.current[t.type] && (n = {
 				...n,
-				[e.type]: e,
-				...t(e)
+				[t.type]: t,
+				...e(t)
 			});
 		}), Object.keys(n).length === 0 ? n : (g.current = {
 			...h.current,

package/dist/Component/index.mjs

@@ -1,3 +1,3 @@
-import e from "./ComponentProvider.mjs";
-import { ComponentHelper_exports as t, getPlugins as n, nestedInject as r, processLocalCustomPlugins as i, processLocalPlugins as a } from "./ComponentHelper.mjs";
-export { t as ComponentHelper, e as ComponentProvider, n as getPlugins, r as nestedInject, i as processLocalCustomPlugins, a as processLocalPlugins };
+import { ComponentHelper_exports as e, getPlugins as t, nestedInject as n, processLocalCustomPlugins as r, processLocalPlugins as i } from "./ComponentHelper.mjs";
+import a from "./ComponentProvider.mjs";
+export { e as ComponentHelper, a as ComponentProvider, t as getPlugins, n as nestedInject, r as processLocalCustomPlugins, i as processLocalPlugins };

package/dist/Element/ElementContext.d.ts

@@ -1,16 +1,28 @@
 import { Element, ElementLayout } from '@plitzi/sdk-shared';
 import { CSSProperties } from 'react';
 export type ElementContextValue<T extends 'skipHOC' | 'full' = 'full'> = {
+    /** The one name this element answers to: its key in the schema, the `<type>_<id>` it publishes its data source
+     *  under, and the target an interaction wires to. */
     id: string;
-    idRef?: string;
     rootId?: string;
     /**
      * Whether this element is on screen: its own `visibility` state AND every ancestor's, chained through this context.
-     * A hidden element still renders its subtree (it is hidden in CSS, not unmounted), so anything that DOES something
-     * rather than just paint — fetching, polling, submitting — reads this instead of its own state to stay inert while
-     * the branch it lives in is hidden.
+     * A hidden element is hidden in CSS by default, subtree and all, so anything that DOES something rather than just
+     * paint — fetching, polling, submitting — reads this instead of its own state to stay inert while the branch it
+     * lives in is hidden. An element whose `loadStrategy` unmounts its items is the exception, and it does not change
+     * what this means: the ones still mounted must still go quiet.
      */
     visible: boolean;
+    /**
+     * This INSTANCE, for tracing — and only for tracing.
+     *
+     * `id` names the element; a controlled list renders that same element once per row, and the render tree the
+     * dev-tools draw has to tell those rows apart or it collapses them into one. React's own identity is per mounted
+     * component, so this comes from `useId` and is what `withElement` labels its `Profiler` with and links parents by.
+     *
+     * Nothing that is not the tracing panel should read it: it is an opaque handle with no meaning in the schema.
+     */
+    traceId: string;
 } & (T extends 'skipHOC' ? {
     plitziJsxSkipHOC: true;
 } : {

package/dist/Element/JsxManager.mjs

@@ -1,12 +1,12 @@
-import e from "../elements/internal/NotFound/NotFound.mjs";
-import t from "./PluginRemote.mjs";
-import { getRemoteSettings as n } from "./helpers/pluginSelector.mjs";
+import e from "./PluginRemote.mjs";
+import { getRemoteSettings as t } from "./helpers/pluginSelector.mjs";
+import n from "../elements/internal/NotFound/NotFound.mjs";
 import { memo as r, use as i, useMemo as a } from "react";
 import o from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
 import s from "@plitzi/sdk-shared/elements/ComponentContext";
 import { jsx as c } from "react/jsx-runtime";
 var l = r(({ plitziJsxSkipHOC: r = !0, as: l = "", internalProps: u, children: d, ...f }) => {
-	let { contexts: { PluginsContext: p } } = o(), { components: m } = i(s), { plugins: h } = i(p), g = l ? m.current[l] : void 0, _ = a(() => g ? void 0 : n({
+	let { contexts: { PluginsContext: p } } = o(), { components: m } = i(s), { plugins: h } = i(p), g = l ? m.current[l] : void 0, _ = a(() => g ? void 0 : t({
 		type: l,
 		plugins: h
 	}), [
@@ -14,13 +14,12 @@ var l = r(({ plitziJsxSkipHOC: r = !0, as: l = "", internalProps: u, children: d
 		h,
 		l
 	]);
-	return l ? !g && _ ? /* @__PURE__ */ c(t, {
+	return l ? !g && _ ? /* @__PURE__ */ c(e, {
 		internalProps: u,
 		url: _.url,
-		scope: _.scope,
 		plitziJsxSkipHOC: r,
 		plitziJsxProps: f
-	}) : (g ||= e, /* @__PURE__ */ c(g, {
+	}) : (g ||= n, /* @__PURE__ */ c(g, {
 		plitziJsxSkipHOC: r,
 		...f,
 		internalProps: u,

package/dist/Element/PluginRemote.d.ts

@@ -1,11 +1,10 @@
 import { InternalPropsSTG1 } from '@plitzi/sdk-shared';
 export type PluginRemoteProps = {
     url: string;
-    scope: string;
     internalProps: InternalPropsSTG1;
     autoRegister?: boolean;
     plitziJsxSkipHOC?: boolean;
     plitziJsxProps?: Record<string, unknown>;
 };
-declare const PluginRemote: ({ url, scope, internalProps, autoRegister, plitziJsxSkipHOC, plitziJsxProps }: PluginRemoteProps) => import("react").JSX.Element;
+declare const PluginRemote: ({ url, internalProps, autoRegister, plitziJsxSkipHOC, plitziJsxProps }: PluginRemoteProps) => import("react").JSX.Element | null;
 export default PluginRemote;

package/dist/Element/PluginRemote.mjs

@@ -1,16 +1,18 @@
 import e from "./helpers/loadComponent.mjs";
-import { Suspense as t, lazy as n, use as r, useMemo as i } from "react";
-import a from "@plitzi/sdk-shared/elements/ComponentContext";
-import { emptyObject as o } from "@plitzi/sdk-shared/helpers/utils";
-import { jsx as s } from "react/jsx-runtime";
+import { Suspense as t, lazy as n, use as r, useEffect as i, useMemo as a, useState as o } from "react";
+import s from "@plitzi/sdk-shared/elements/ComponentContext";
+import { emptyObject as c } from "@plitzi/sdk-shared/helpers/utils";
+import { jsx as l } from "react/jsx-runtime";
 //#region src/Element/PluginRemote.tsx
-var c = ({ url: c = "", scope: l = "", internalProps: u, autoRegister: d = !0, plitziJsxSkipHOC: f = !1, plitziJsxProps: p = o }) => {
-	let { register: m } = r(a), h = i(() => n(e(c, l, m, d, f)), [c, l]);
-	return f ? /* @__PURE__ */ s(t, { children: /* @__PURE__ */ s(h, {
-		internalProps: u,
-		plitziJsxSkipHOC: f,
-		...p
-	}) }) : /* @__PURE__ */ s(t, { children: /* @__PURE__ */ s(h, { internalProps: u }) });
+var u = ({ url: u = "", internalProps: d, autoRegister: f = !0, plitziJsxSkipHOC: p = !1, plitziJsxProps: m = c }) => {
+	let { register: h } = r(s), [g, _] = o(!1);
+	i(() => _(!0), []);
+	let v = a(() => n(e(u, h, f, p)), [u]);
+	return g ? p ? /* @__PURE__ */ l(t, { children: /* @__PURE__ */ l(v, {
+		internalProps: d,
+		plitziJsxSkipHOC: p,
+		...m
+	}) }) : /* @__PURE__ */ l(t, { children: /* @__PURE__ */ l(v, { internalProps: d }) }) : null;
 };
 //#endregion
-export { c as default };
+export { u as default };

package/dist/Element/RootElement.d.ts

@@ -3,7 +3,7 @@ import { CSSProperties, JSX, ReactNode, RefObject } from 'react';
 export type RootElementProps<T extends keyof JSX.IntrinsicElements> = {
     ref?: RefObject<HTMLElement | null>;
     children?: ReactNode;
-    tag?: T;
+    tag?: T | '';
     className?: string;
     interactionTriggers?: Record<string, InteractionCallback>;
     interactionCallbacks?: Record<string, InteractionCallback>;

package/dist/Element/RootElement.mjs

@@ -15,7 +15,7 @@ var o = ({ ref: o, children: s, tag: c = "div", className: l = "", interactionTr
 		otherProps: p,
 		children: s
 	});
-	let { root: { baseElementId: y }, contexts: b } = g, x = b.InteractionsContext, { id: S, rootId: C, style: w, definition: { type: T, label: E, runtime: D } } = h, O = D === "server" ? { "data-rsc-id": S } : void 0, k = !v && (_ || !T || C !== y) ? {} : {
+	let { root: { baseElementId: y }, contexts: b } = g, x = b.InteractionsContext, { id: S, rootId: C, style: w, definition: { type: T, label: E, runtime: D } } = h, O = D === "server" ? { "data-rsc-id": S } : void 0, k = g.settings.testAttributes === !1 ? void 0 : { "data-plitzi-el": S }, A = !v && (_ || !T || C !== y) ? {} : {
 		"data-id": S,
 		"data-name": E || T || "unknown",
 		"data-root-id": C,
@@ -31,11 +31,12 @@ var o = ({ ref: o, children: s, tag: c = "div", className: l = "", interactionTr
 		},
 		className: l,
 		otherProps: p,
-		params: k,
+		params: A,
 		serverMarker: O,
+		testMarker: k,
 		children: s
 	});
-	let { className: A, events: j } = r({
+	let { className: j, events: M } = r({
 		elementContext: h,
 		InteractionsContext: x,
 		previewMode: _,
@@ -53,11 +54,12 @@ var o = ({ ref: o, children: s, tag: c = "div", className: l = "", interactionTr
 			...w,
 			...m
 		},
-		className: A,
+		className: j,
 		otherProps: p,
-		params: k,
+		params: A,
 		serverMarker: O,
-		events: j,
+		testMarker: k,
+		events: M,
 		children: s
 	});
 };

package/dist/Element/ServerStaticShell.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'react';
+import { ReactNode } from 'react';
 /**
  * Renders a runtime:'server' element as frozen server HTML.
  *
@@ -10,15 +10,15 @@ import { CSSProperties } from 'react';
  * The actual plugin component is never mounted in the browser, so no useEffect or
  * useState from the plugin ever runs. React hydrates the snapshot element without
  * touching its children (dangerouslySetInnerHTML takes ownership of innerHTML).
+ *
+ * When there is nothing to freeze, `children` — the element itself — is rendered instead. That is not the
+ * hydration case, where the server always sent the markup; it is the SPA one: a route change mounts a page whose
+ * server elements were never in this document, and freezing an element against markup that does not exist used to
+ * render nothing at all. The element then resolves the way it does anywhere else, from the payload `useRscSync`
+ * fetches for the new location.
  */
-declare const ServerStaticShell: ({ id }: {
+declare const ServerStaticShell: ({ id, children }: {
     id: string;
-}) => import('react').DOMElement<{
-    dangerouslySetInnerHTML: {
-        __html: string;
-    };
-    'data-rsc-id': string;
-    className: string | undefined;
-    style: CSSProperties | undefined;
-}, Element> | null;
+    children?: ReactNode;
+}) => ReactNode;
 export default ServerStaticShell;

package/dist/Element/ServerStaticShell.mjs

@@ -12,8 +12,8 @@ var n = (e) => {
 		}
 	}
 	return t;
-}, r = ({ id: r }) => {
-	let [i] = t(() => {
+}, r = ({ id: r, children: i }) => {
+	let [a] = t(() => {
 		if (typeof document > "u") return null;
 		let e = document.querySelector(`[data-rsc-id="${r}"]`);
 		if (!e) return null;
@@ -31,13 +31,13 @@ var n = (e) => {
 			html: e.innerHTML
 		};
 	});
-	return i ? e(i.tag, {
+	return a ? e(a.tag, {
 		"data-rsc-id": r,
-		className: i.className || void 0,
-		style: i.style,
-		...i.attrs,
-		dangerouslySetInnerHTML: { __html: i.html }
-	}) : null;
+		className: a.className || void 0,
+		style: a.style,
+		...a.attrs,
+		dangerouslySetInnerHTML: { __html: a.html }
+	}) : i;
 };
 //#endregion
 export { r as default };

package/dist/Element/helpers/elementConstants.mjs

@@ -78,6 +78,41 @@ var e = {
 			type: "boolean",
 			label: "Propagate Event"
 		} }
+	},
+	onFlowEnd: {
+		action: "onFlowEnd",
+		title: "On Server Action End",
+		type: "trigger",
+		preview: {
+			actionId: "",
+			runId: "",
+			status: "",
+			output: {}
+		},
+		params: {}
+	},
+	onFlowError: {
+		action: "onFlowError",
+		title: "On Server Action Error",
+		type: "trigger",
+		preview: {
+			actionId: "",
+			runId: "",
+			error: "",
+			reason: ""
+		},
+		params: {}
+	},
+	onFlowProgress: {
+		action: "onFlowProgress",
+		title: "On Server Action Progress",
+		type: "trigger",
+		preview: {
+			actionId: "",
+			runId: "",
+			chunk: ""
+		},
+		params: {}
 	}
 }, t = [
 	"onClick",

package/dist/Element/helpers/elementUtils.d.ts

@@ -5,4 +5,11 @@ export type PlitziModule = {
     initialItems?: string[];
     plugins?: Record<string, ComponentPlugin>;
 };
-export declare const generatePluginModule: (url: string, asESM?: boolean, pluginScope?: string) => Promise<PlitziModule | undefined>;
+/**
+ * A remote plugin, fetched and imported as an ES module.
+ *
+ * Always as a module, whatever the URL is called: nothing about an address says which format it serves, and every
+ * plugin the template builds is ESM. There is no second path for the webpack bundles that registered themselves on a
+ * `window` global — nothing produces those any more.
+ */
+export declare const generatePluginModule: (url: string) => Promise<PlitziModule | undefined>;

package/dist/Element/helpers/elementUtils.mjs

@@ -1,43 +1,16 @@
-import { RootElement as e } from "../RootElement.mjs";
-import t from "../../Component/ComponentProvider.mjs";
-import * as n from "react";
-import r from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
-import { get as i } from "@plitzi/plitzi-ui/helpers";
-import a from "@plitzi/sdk-shared/elements/ComponentContext";
-import * as o from "react/jsx-runtime";
-import * as s from "react-dom";
 //#region src/Element/helpers/elementUtils.ts
-var c = async (c, l = !0, u = "") => {
-	let d;
+var e = async (e) => {
 	try {
-		if (l) {
-			let e = await fetch(c), t = new Blob([await e.text()], { type: "text/javascript" });
-			d = await import(
-				/* @vite-ignore */
-				/* webpackIgnore: true */
-				URL.createObjectURL(t)
+		let t = await fetch(e), n = new Blob([await t.text()], { type: "text/javascript" });
+		return await import(
+			/* @vite-ignore */
+			/* webpackIgnore: true */
+			URL.createObjectURL(n)
 );
-		} else {
-			let c = {
-				default: void 0,
-				ComponentProvider: t,
-				ComponentContext: a,
-				usePlitziServiceContext: r,
-				RootElement: e
-			}, l = {
-				__WEBPACK_EXTERNAL_MODULE_react__: n,
-				__WEBPACK_EXTERNAL_MODULE_react_dom__: s,
-				__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__: o,
-				__WEBPACK_EXTERNAL_MODULE__plitzi_plitzi_sdk__: c
-			}, f = i(window, `plitziPlugins.${u}`);
-			if (!f || typeof f != "function") return;
-			d = await f(c, void 0, l);
-		}
 	} catch (e) {
 		console.log(e);
 		return;
 	}
-	return d;
 };
 //#endregion
-export { c as generatePluginModule };
+export { e as generatePluginModule };

package/dist/Element/helpers/getInteractions.d.ts

@@ -1,3 +1,3 @@
 import { Element, InteractionCallback, InteractionPostCallback } from '@plitzi/sdk-shared';
-declare const getInteractions: (attributes: Element["attributes"], definition: Element["definition"], callback: InteractionCallback["callback"], postCallback: InteractionPostCallback) => Record<string, InteractionCallback>;
+declare const getInteractions: (attributes: Element["attributes"], definition: Element["definition"], callback: InteractionCallback["callback"], postCallback: InteractionPostCallback, toggleCallback: InteractionCallback["callback"]) => Record<string, InteractionCallback>;
 export default getInteractions;

package/dist/Element/helpers/getInteractions.mjs

@@ -1,68 +1,65 @@
+import { toBuilderParams as e, toInteractionCallback as t } from "@plitzi/sdk-shared/authoring/builder";
+import { BUILTIN_ELEMENT_CALLBACKS as n } from "@plitzi/sdk-shared/authoring/elementCallbacks";
 //#region src/Element/helpers/getInteractions.ts
-var e = (e, t, n, r) => ({ setState: {
-	action: "setState",
-	title: `Update ${t.label}`,
-	type: "callback",
-	callback: n,
-	postCallback: r,
-	preview: {},
-	params: {
-		category: {
-			label: "Category",
-			defaultValue: "attribute",
-			type: "select",
-			options: [{
-				value: "attribute",
-				label: "Attribute"
-			}, {
-				value: "state",
-				label: "State"
-			}]
-		},
-		key: {
-			label: "Key",
-			defaultValue: void 0,
-			type: "select",
-			when: (e) => e.category === "attribute" || e.category === "state",
-			options: (n) => {
-				let { category: r } = n;
-				return r === "attribute" ? Object.keys(e).map((e) => ({
-					value: e,
-					label: e
-				})) : r === "state" ? [{
-					value: "visibility",
-					label: "Visibility"
-				}, ...Object.keys(t.styleSelectors).map((e) => ({
-					value: `styleSelectors.${e}`,
-					label: `Selector - ${e}`
-				}))] : [];
+var r = (e, t) => (n) => {
+	let { category: r } = n;
+	return r === "attribute" ? Object.keys(e).map((e) => ({
+		value: e,
+		label: e
+	})) : r === "state" ? [{
+		value: "visibility",
+		label: "Visibility"
+	}, ...Object.keys(t.styleSelectors).map((e) => ({
+		value: `styleSelectors.${e}`,
+		label: `Selector - ${e}`
+	}))] : [];
+}, i = (i, a, o, s, c) => {
+	let l = n.setState, u = e(l.params), d = n.toggleState, f = e(d.params), p = {
+		type: "select",
+		options: r(i, a),
+		when: (e) => e.category === "attribute" || e.category === "state"
+	};
+	return {
+		setState: t("setState", l, o, {
+			title: `Update ${a.label}`,
+			postCallback: s,
+			params: {
+				...u,
+				key: {
+					...u.key,
+					...p
+				},
+				value: {
+					...u.value,
+					type: (e) => typeof i[e.key] == "boolean" ? "select" : "text",
+					options: (e) => {
+						let { key: t } = e;
+						return typeof i[t] == "boolean" ? [{
+							value: "true",
+							label: "True"
+						}, {
+							value: "false",
+							label: "False"
+						}] : Object.keys(i).map((e) => ({
+							value: e,
+							label: e
+						}));
+					}
+				}
 			}
-		},
-		value: {
-			label: "Value",
-			defaultValue: void 0,
-			type: (t) => typeof e[t.key] == "boolean" ? "select" : "text",
-			when: (e) => !!e.category,
-			options: (t) => {
-				let { key: n } = t;
-				return typeof e[n] == "boolean" ? [{
-					value: "true",
-					label: "True"
-				}, {
-					value: "false",
-					label: "False"
-				}] : Object.keys(e).map((e) => ({
-					value: e,
-					label: e
-				}));
+		}),
+		toggleState: t("toggleState", d, c, {
+			title: `Toggle ${a.label}`,
+			postCallback: s,
+			params: {
+				...f,
+				key: {
+					...f.key,
+					...p
+				}
 			}
-		},
-		revertOnFinish: {
-			label: "Revert changes after interaction",
-			defaultValue: !1,
-			type: "boolean"
-		}
-	}
-} });
+		})
+	};
+};
 //#endregion
-export { e as default };
+export { i as default };

package/dist/Element/helpers/loadComponent.d.ts

@@ -1,5 +1,5 @@
 import { ComponentContextValue, ComponentPluginWithHOC } from '@plitzi/sdk-shared';
-declare const loadComponent: (url: string, pluginScope: string, registerCallback: ComponentContextValue["register"], autoRegister?: boolean, plitziJsxSkipHOC?: boolean) => () => Promise<{
+declare const loadComponent: (url: string, registerCallback: ComponentContextValue["register"], autoRegister?: boolean, plitziJsxSkipHOC?: boolean) => () => Promise<{
     default: ComponentPluginWithHOC;
 }>;
 export default loadComponent;