@plitzi/sdk-elements 0.30.19

package/dist/Component/ComponentHelper.d.ts

@@ -0,0 +1,5 @@
+import { ComponentOrigin, ComponentPluginWithHOC } from '@plitzi/sdk-shared';
+export declare const getPlugins: (component: ComponentPluginWithHOC | undefined) => Record<string, ComponentPluginWithHOC>;
+export declare const processLocalPlugins: (plugins?: Record<string, ComponentPluginWithHOC>) => {};
+export declare const nestedInject: (plugins: Record<string, ComponentPluginWithHOC> | undefined, origin: ComponentOrigin) => Record<string, ComponentPluginWithHOC>;
+export declare const processLocalCustomPlugins: (localComponents?: Record<string, ComponentPluginWithHOC>) => {};

package/dist/Component/ComponentHelper.mjs

@@ -0,0 +1,47 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.mjs";
+import t from "../Element/hocs/withElement.mjs";
+//#region src/Component/ComponentHelper.ts
+var n = /* @__PURE__ */ e({
+	getPlugins: () => r,
+	nestedInject: () => a,
+	processLocalCustomPlugins: () => o,
+	processLocalPlugins: () => i
+}), r = (e) => {
+	let t = {};
+	if (!e) return t;
+	t[e.type] = e;
+	let { plugins: n } = e;
+	return n && Object.keys(n).length > 0 && Object.keys(n).forEach((e) => {
+		t = {
+			...t,
+			...r(n[e])
+		};
+	}), t;
+}, i = (e) => {
+	let t = {};
+	return e && Object.values(e).forEach((e) => {
+		e.type && (t = {
+			...t,
+			...r(e)
+		});
+	}), t;
+}, a = (e, n) => {
+	if (!e) return {};
+	let r = {};
+	return Object.keys(e).forEach((i) => {
+		let o = e[i], { version: s, pluginSettings: c, initialItems: l, plugins: u, extraProps: d } = o;
+		r[i] = t(o), r[i].origin = n, r[i].version = s, r[i].type = i, r[i].initialItems = l, r[i].pluginSettings = c, r[i].extraProps = d, r[i].plugins = a(u, n);
+	}), r;
+}, o = (e) => {
+	let n = {};
+	return e && Object.values(e).forEach((e) => {
+		if (!e.type) return;
+		let { type: i, pluginSettings: o, version: s, initialItems: c, plugins: l, assets: u, content: d, extraProps: f } = e, p = t(e);
+		p.version = s, p.type = i, p.assets = u, p.initialItems = c, p.pluginSettings = o, p.origin = "local-custom", p.content = d, p.extraProps = f, p.plugins = a(l, "local-custom"), n = {
+			...n,
+			...r(p)
+		};
+	}), n;
+};
+//#endregion
+export { n as ComponentHelper_exports, r as getPlugins, a as nestedInject, o as processLocalCustomPlugins, i as processLocalPlugins };

package/dist/Component/ComponentProvider.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPluginWithHOC } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type ComponentProviderProps = {
+    localComponents?: Record<string, ComponentPluginWithHOC>;
+    localCustomComponents?: Record<string, ComponentPluginWithHOC>;
+    children?: ReactNode;
+};
+declare const ComponentProvider: ({ localComponents, localCustomComponents, children }: ComponentProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default ComponentProvider;

package/dist/Component/ComponentProvider.mjs

@@ -0,0 +1,98 @@
+import { defaultElements as e } from "../index.mjs";
+import { getPlugins as t, processLocalCustomPlugins as n, processLocalPlugins as r } from "./ComponentHelper.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";
+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)
+	}), [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];
+			return n ? {
+				[e]: n,
+				...c(t(n), [e])
+			} : {};
+		}
+		let r = {};
+		return e.forEach((e) => {
+			let i = g.current[e];
+			i && (n ? r = {
+				...r,
+				...c(t(i), [e])
+			} : r[e] = i);
+		}), r;
+	}, []), v = i((e = []) => {
+		let n = {};
+		return Array.isArray(e) || (e = [e]), e.forEach((e) => {
+			e.type && !g.current[e.type] && (n = {
+				...n,
+				[e.type]: e,
+				...t(e)
+			});
+		}), Object.keys(n).length === 0 ? n : (g.current = {
+			...h.current,
+			...n,
+			...m
+		}, h.current = {
+			...h.current,
+			...n
+		}, n);
+	}, [m]), y = i((e) => {
+		if (!e) return [];
+		Array.isArray(e) || (e = [e]);
+		let t = e;
+		return e.forEach((e) => {
+			let n = _([e], !0);
+			Object.keys(n).length > 0 && (t = [...t, ...Object.keys(c(n, e))]);
+		}), g.current = {
+			...c(h.current, t),
+			...m
+		}, h.current = c(h.current, t), t;
+	}, [_, m]), b = o(Object.keys(g.current).reduce((e, t) => {
+		let n = s(g.current, t, void 0);
+		return !n || !n.content ? e : {
+			...e,
+			[t]: {
+				...n.content,
+				initialItems: n.initialItems
+			}
+		};
+	}, {})), x = i((e) => {
+		b.current = {
+			...b.current,
+			...e
+		};
+	}, []), S = i((e) => {
+		let t = s(b.current, `${e}.builder.pluginChildren`, []);
+		b.current = c(b.current, [e, ...t]);
+	}, []);
+	return /* @__PURE__ */ u(l, {
+		value: a(() => ({
+			components: g,
+			componentDefinitions: b,
+			getComponent: _,
+			register: v,
+			unregister: y,
+			unregisterDefinition: S,
+			registerDefinition: x
+		}), [
+			v,
+			y,
+			x,
+			S,
+			_
+		]),
+		children: p
+	});
+};
+//#endregion
+export { d as default };

package/dist/Component/index.d.ts

@@ -0,0 +1,5 @@
+import { default as ComponentProvider } from './ComponentProvider';
+import * as ComponentHelper from './ComponentHelper';
+export * from './ComponentHelper';
+export * from './ComponentProvider';
+export { ComponentProvider, ComponentHelper };

package/dist/Component/index.mjs

@@ -0,0 +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 };

package/dist/Element/JsxManager.d.ts

@@ -0,0 +1,11 @@
+import { InternalPropsSTG1 } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type JsxManagerProps = {
+    plitziJsxSkipHOC?: boolean;
+    as: string;
+    plitziJsxProps: Record<string, unknown>;
+    internalProps: InternalPropsSTG1;
+    children: ReactNode;
+};
+declare const _default: import('react').MemoExoticComponent<({ plitziJsxSkipHOC, as: type, internalProps, children, ...plitziJsxProps }: JsxManagerProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default _default;

package/dist/Element/JsxManager.mjs

@@ -0,0 +1,37 @@
+import e from "../elements/internal/NotFound/NotFound.mjs";
+import t from "./PluginRemote.mjs";
+import { memo as n, use as r, useCallback as i, useMemo as a } from "react";
+import o from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { get as s } from "@plitzi/plitzi-ui/helpers";
+import c from "@plitzi/sdk-shared/elements/ComponentContext";
+import { jsx as l } from "react/jsx-runtime";
+var u = n(({ plitziJsxSkipHOC: n = !0, as: u = "", internalProps: d, children: f, ...p }) => {
+	let { contexts: { PluginsContext: m } } = o(), { components: h } = r(c), { plugins: g } = r(m), _ = i((e) => Object.values(g).find((t) => t.subPlugins.find((t) => t === e)), [g]), v = u ? h.current[u] : void 0, y = a(() => {
+		let e = (u ? g[u] : void 0) ?? _(u);
+		if (v || !e) return;
+		let t = s(e, "assets", []).filter((e) => e.type === "script"), { scope: n } = e;
+		return {
+			url: t.find((e) => e.isMain)?.params.src ?? s(t, "0.params.src", ""),
+			scope: n
+		};
+	}, [
+		v,
+		_,
+		g,
+		u
+	]);
+	return u ? !v && y ? /* @__PURE__ */ l(t, {
+		internalProps: d,
+		url: y.url,
+		scope: y.scope,
+		plitziJsxSkipHOC: n,
+		plitziJsxProps: p
+	}) : (v ||= e, /* @__PURE__ */ l(v, {
+		plitziJsxSkipHOC: n,
+		...p,
+		internalProps: d,
+		children: f
+	})) : null;
+});
+//#endregion
+export { u as default };

package/dist/Element/PluginManager.d.ts

@@ -0,0 +1,8 @@
+import { InternalPropsSTG0, ElementLayout } from '@plitzi/sdk-shared';
+export type PluginManagerProps = {
+    plitziElementLayout?: ElementLayout;
+    type: string;
+    internalProps: InternalPropsSTG0;
+};
+declare const _default: import('react').MemoExoticComponent<({ plitziElementLayout, type, internalProps }: PluginManagerProps) => import("react/jsx-runtime").JSX.Element | undefined>;
+export default _default;

package/dist/Element/PluginManager.mjs

@@ -0,0 +1,19 @@
+import e from "./helpers/pluginSelector.mjs";
+import { memo as t, use as n } from "react";
+import r from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import i from "@plitzi/sdk-shared/elements/ComponentContext";
+var a = t(({ plitziElementLayout: t = void 0, type: a = "", internalProps: o }) => {
+	let { components: s } = n(i), { contexts: { PluginsContext: c } } = r(), { plugins: l } = n(c);
+	return e({
+		type: a,
+		internalProps: {
+			...o,
+			plitziElementLayout: t
+		},
+		plitziElementLayout: t,
+		components: s.current,
+		plugins: l
+	});
+});
+//#endregion
+export { a as default };

package/dist/Element/PluginRemote.d.ts

@@ -0,0 +1,11 @@
+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-runtime").JSX.Element;
+export default PluginRemote;

package/dist/Element/PluginRemote.mjs

@@ -0,0 +1,16 @@
+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";
+//#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 }) });
+};
+//#endregion
+export { c as default };

package/dist/Element/ReplicaProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export type ReplicaProviderProps = {
+    children?: ReactNode;
+};
+declare const ReplicaProvider: ({ children }: ReplicaProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default ReplicaProvider;

package/dist/Element/ReplicaProvider.mjs

@@ -0,0 +1,18 @@
+import { use as e, useEffect as t, useMemo as n } from "react";
+import r from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/Element/ReplicaProvider.tsx
+var a = ({ children: a }) => {
+	let { contexts: { InteractionsContext: o } } = r(), s = e(o), c = n(() => s.interactionsManager.createChildManager(), [s]), l = n(() => ({
+		...s,
+		interactionsManager: c
+	}), [s, c]);
+	return t(() => () => {
+		s.interactionsManager.removeChildManager(c);
+	}, [s, c]), /* @__PURE__ */ i(o, {
+		value: l,
+		children: a
+	});
+};
+//#endregion
+export { a as default };

package/dist/Element/RootElement.d.ts

@@ -0,0 +1,14 @@
+import { InteractionCallback } from '@plitzi/sdk-shared';
+import { CSSProperties, JSX, ReactNode, RefObject } from 'react';
+export type RootElementProps<T extends keyof JSX.IntrinsicElements> = {
+    ref?: RefObject<HTMLElement | null>;
+    children?: ReactNode;
+    tag?: T;
+    className?: string;
+    interactionTriggers?: Record<string, InteractionCallback>;
+    interactionCallbacks?: Record<string, InteractionCallback>;
+    style?: string | CSSProperties;
+} & Omit<Partial<JSX.IntrinsicElements[T]>, 'ref' | 'style'>;
+declare const RootElement: <T extends keyof JSX.IntrinsicElements = "div">({ ref, children, tag, className, interactionTriggers, interactionCallbacks, style: styleProp, ...otherProps }: RootElementProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default RootElement;
+export { RootElement };

package/dist/Element/RootElement.mjs

@@ -0,0 +1,127 @@
+import e from "./hooks/useElementDataSource.mjs";
+import { interactionBasicTriggers as t, nativeEventsList as n } from "./helpers/elementConstants.mjs";
+import r from "./helpers/parseStyle.mjs";
+import i from "./hooks/useElementInteractions.mjs";
+import a from "./hooks/useInternalClassName.mjs";
+import { use as o, useCallback as s, useEffect as c, useMemo as l, useRef as u } from "react";
+import d from "@plitzi/sdk-shared/elements/ElementContext";
+import ee from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { get as f } from "@plitzi/plitzi-ui/helpers";
+import { jsx as p } from "react/jsx-runtime";
+import m from "clsx";
+import { pConsole as h } from "@plitzi/sdk-shared/devTools/utils/PlitziConsole";
+//#region src/Element/RootElement.tsx
+var g = ({ ref: g, children: _, tag: v = "div", className: y = "", interactionTriggers: b, interactionCallbacks: x, style: S, ...C }) => {
+	let w = l(() => r(S), [S]), T = v, E = o(d);
+	if (!E) throw Error("This element can be rendered only under withElement HOC or inside ElementContext");
+	let { id: D, rootId: O } = E;
+	if (!T) throw Error(`One of these parameters [tag] is missing in elementId: ${D}`);
+	if (!E) throw Error("This element can be rendered only under withElement HOC");
+	if (E.plitziJsxSkipHOC) return /* @__PURE__ */ p(T, {
+		ref: g,
+		style: w,
+		className: y,
+		...C,
+		children: _
+	});
+	let k = ee(), A = f(k, "settings.previewMode", !0), j = f(k, "settings.debugMode", !1), M = f(k, "root.baseElementId"), { className: N, attributes: P, definition: F, definition: { interactions: I, type: L, label: R, runtime: z }, plitziElementLayout: B, style: V, elementState: H, setElementState: U } = E, W = z === "server" ? { "data-rsc-id": D } : void 0, G = l(() => !j && (A || !L || O !== M) ? {} : {
+		"data-id": D,
+		"data-name": R || L || "unknown",
+		"data-root-id": O,
+		"data-type": L || "unknown",
+		"data-root-render-element": !0
+	}, [
+		j,
+		A,
+		O,
+		M,
+		D,
+		R,
+		L
+	]), K = f(k, "contexts.InteractionsContext");
+	if (!K) return /* @__PURE__ */ p(T, {
+		ref: g,
+		style: {
+			...V,
+			...w
+		},
+		className: y,
+		...C,
+		...G,
+		...W,
+		children: _
+	});
+	let { interactionsManager: q, useInteractions: J } = o(K), Y = s((e, t, n, r, i = !1) => {
+		i || e.preventDefault(), r && r(e), i || e.preventDefault(), q.interactionTrigger(t, n, { event: e });
+	}, [q]), X = l(() => !A || !I ? {} : Object.values(I).filter((e) => e.type === "trigger" && e.action && n.includes(e.action) && e.enabled).reduce((e, t) => {
+		let n = f(t, "params.propagateEvent", !1);
+		return {
+			...e,
+			[t.action]: (e) => Y(e, D, t.action, C[t.action], n)
+		};
+	}, {}), [
+		D,
+		I,
+		C,
+		A,
+		Y
+	]), Z = l(() => !j && (!I || !Object.keys(I).length) ? "hard" : "soft", [j, I]), Q = u({});
+	Q.current = e({
+		id: D,
+		bindings: F.bindings,
+		filterMode: Z,
+		sources: Z === "hard" ? ["variables"] : []
+	});
+	let te = s(() => ({ dataSource: Q.current }), [Q]), ne = l(() => ({
+		...t,
+		...b
+	}), [b]), $ = i({
+		attributes: P,
+		definition: F,
+		setElementState: U
+	});
+	J({
+		id: D,
+		interactions: I,
+		triggers: ne,
+		callbacks: l(() => ({
+			...x,
+			...$
+		}), [x, $]),
+		getAdditionalParams: te
+	}), c(() => {
+		!A || !I || !Object.keys(I).length || q.interactionTrigger(D, "onLoad", {});
+	}, []), c(() => {
+		if (j) return h.addProviderMethod(`getElementDataSource-${D}`, () => Q.current), () => {
+			h.removeProviderMethod(`getElementDataSource-${D}`);
+		};
+	}, [
+		j,
+		Q,
+		D
+	]);
+	let re = a({
+		id: D,
+		className: y,
+		previewMode: A,
+		baseElementId: M,
+		definition: F,
+		elementState: H,
+		plitziElementLayout: B
+	});
+	return /* @__PURE__ */ p(T, {
+		ref: g,
+		style: {
+			...V,
+			...w
+		},
+		className: m(N, re),
+		...C,
+		...G,
+		...X,
+		...W,
+		children: _
+	});
+};
+//#endregion
+export { g as default };

package/dist/Element/ServerStaticShell.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties } from 'react';
+/**
+ * Renders a runtime:'server' element as frozen server HTML.
+ *
+ * During the initial client render (hydrateRoot), React calls useState initializers
+ * synchronously before it has modified the DOM. We use this window to read the
+ * server-rendered element from the DOM via its data-plitzi-id attribute, capture its
+ * tag, attributes, and innerHTML, then render it back via dangerouslySetInnerHTML.
+ *
+ * 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).
+ */
+declare const ServerStaticShell: ({ id }: {
+    id: string;
+}) => import('react').DOMElement<{
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+    'data-rsc-id': string;
+    className: string | undefined;
+    style: CSSProperties | undefined;
+}, Element> | null;
+export default ServerStaticShell;

package/dist/Element/ServerStaticShell.mjs

@@ -0,0 +1,43 @@
+import { createElement as e, useState as t } from "react";
+//#region src/Element/ServerStaticShell.tsx
+var n = (e) => {
+	let t = {};
+	for (let n of e.split(";")) {
+		let e = n.indexOf(":");
+		if (e === -1) continue;
+		let r = n.slice(0, e).trim(), i = n.slice(e + 1).trim();
+		if (r && i) {
+			let e = r.replace(/-([a-z])/g, (e, t) => t.toUpperCase());
+			t[e] = i;
+		}
+	}
+	return t;
+}, r = ({ id: r }) => {
+	let [i] = t(() => {
+		if (typeof document > "u") return null;
+		let e = document.querySelector(`[data-rsc-id="${r}"]`);
+		if (!e) return null;
+		let t = {};
+		for (let n = 0; n < e.attributes.length; n++) {
+			let { name: r, value: i } = e.attributes[n];
+			r !== "class" && r !== "style" && r !== "data-rsc-id" && (t[r] = i);
+		}
+		let i = e.getAttribute("style");
+		return {
+			tag: e.tagName.toLowerCase(),
+			className: e.className,
+			style: i ? n(i) : void 0,
+			attrs: t,
+			html: e.innerHTML
+		};
+	});
+	return i ? e(i.tag, {
+		"data-rsc-id": r,
+		className: i.className || void 0,
+		style: i.style,
+		...i.attrs,
+		dangerouslySetInnerHTML: { __html: i.html }
+	}) : null;
+};
+//#endregion
+export { r as default };

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

@@ -0,0 +1,3 @@
+import { InteractionCallback } from '@plitzi/sdk-shared';
+export declare const interactionBasicTriggers: Record<string, InteractionCallback>;
+export declare const nativeEventsList: string[];

package/dist/Element/helpers/elementConstants.mjs

@@ -0,0 +1,91 @@
+//#region src/Element/helpers/elementConstants.ts
+var e = {
+	onLoad: {
+		action: "onLoad",
+		title: "On Load",
+		type: "trigger",
+		preview: {},
+		params: {}
+	},
+	onClick: {
+		action: "onClick",
+		title: "On Click",
+		type: "trigger",
+		preview: { propagateEvent: "" },
+		params: { propagateEvent: {
+			canBind: !1,
+			defaultValue: !1,
+			type: "boolean",
+			label: "Propagate Event"
+		} }
+	},
+	onMouseEnter: {
+		action: "onMouseEnter",
+		title: "On Mouse Enter",
+		type: "trigger",
+		preview: { propagateEvent: "" },
+		params: { propagateEvent: {
+			canBind: !1,
+			defaultValue: !1,
+			type: "boolean",
+			label: "Propagate Event"
+		} }
+	},
+	onMouseLeave: {
+		action: "onMouseLeave",
+		title: "On Mouse Leave",
+		type: "trigger",
+		preview: { propagateEvent: "" },
+		params: { propagateEvent: {
+			canBind: !1,
+			defaultValue: !1,
+			type: "boolean",
+			label: "Propagate Event"
+		} }
+	},
+	onHover: {
+		action: "onHover",
+		title: "On Hover",
+		type: "trigger",
+		preview: { propagateEvent: "" },
+		params: { propagateEvent: {
+			canBind: !1,
+			defaultValue: !1,
+			type: "boolean",
+			label: "Propagate Event"
+		} }
+	},
+	onFocus: {
+		action: "onFocus",
+		title: "On Focus",
+		type: "trigger",
+		preview: { propagateEvent: "" },
+		params: { propagateEvent: {
+			canBind: !1,
+			defaultValue: !1,
+			type: "boolean",
+			label: "Propagate Event"
+		} }
+	},
+	onBlur: {
+		action: "onBlur",
+		title: "On Blur",
+		type: "trigger",
+		preview: { propagateEvent: "" },
+		params: { propagateEvent: {
+			canBind: !1,
+			defaultValue: !1,
+			type: "boolean",
+			label: "Propagate Event"
+		} }
+	}
+}, t = [
+	"onClick",
+	"onHover",
+	"onFocus",
+	"onBlur",
+	"onMouseEnter",
+	"onMouseLeave"
+];
+//#endregion
+export { e as interactionBasicTriggers, t as nativeEventsList };

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

@@ -0,0 +1,8 @@
+import { ComponentPlugin } from '@plitzi/sdk-shared';
+export type PlitziModule = {
+    default: ComponentPlugin;
+    version?: string;
+    initialItems?: string[];
+    plugins?: Record<string, ComponentPlugin>;
+};
+export declare const generatePluginModule: (url: string, asESM?: boolean, pluginScope?: string) => Promise<PlitziModule | undefined>;

package/dist/Element/helpers/elementUtils.mjs

@@ -0,0 +1,43 @@
+import 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;
+	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)
+);
+		} 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 };