@plitzi/sdk-elements 0.37.9 → 0.38.1

package/dist/elements/media/Svg/Svg.d.ts

@@ -0,0 +1,16 @@
+import { RefObject } from 'react';
+export type SvgProps = {
+    ref?: RefObject<HTMLElement>;
+    /** The drawing: one `<svg>…</svg>`, filling the box its class sizes; with `currentColor`, it takes the class's colour. */
+    content?: string;
+    /** What the drawing means, for one that means something; without it the drawing is decoration, hidden from readers. */
+    label?: string;
+    className?: string;
+};
+declare const Svg: ({ ref, content, label, className }: SvgProps) => import('react').JSX.Element;
+declare const _default: {
+    (props: import('../../../Element/hocs/withElement').WithElementProps<SvgProps>): import('react').JSX.Element;
+    displayName: string;
+};
+export default _default;
+export { Svg };

package/dist/elements/media/Svg/Svg.mjs

@@ -0,0 +1,31 @@
+import e from "../../../Element/hocs/withElement.mjs";
+import { RootElement as t } from "../../../Element/RootElement.mjs";
+import { fitSvg as n, isSvgMarkup as r, sanitizeSvg as i } from "./sanitizeSvg.mjs";
+import { useMemo as a } from "react";
+import o from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+import l from "clsx";
+//#region src/elements/media/Svg/Svg.tsx
+var u = ({ ref: e, content: u = "", label: d = "", className: f = "" }) => {
+	let { settings: { previewMode: p } } = o(), m = a(() => r(u) ? n(i(u)) : "", [u]), h = d ? {
+		role: "img",
+		"aria-label": d
+	} : { "aria-hidden": !0 };
+	return !m && !p ? /* @__PURE__ */ c(t, {
+		ref: e,
+		className: l("plitzi-component__svg svg--empty", f),
+		children: [
+			"Paste one ",
+			"<svg>…</svg>",
+			" here"
+		]
+	}) : /* @__PURE__ */ s(t, {
+		tag: "span",
+		ref: e,
+		className: l("plitzi-component__svg", f),
+		...h,
+		dangerouslySetInnerHTML: { __html: m }
+	});
+}, d = e(u);
+//#endregion
+export { u as Svg, d as default };

package/dist/elements/media/Svg/declaration.d.ts

@@ -0,0 +1,61 @@
+import { SvgProps } from './Svg';
+import { AuthorableAttributes } from '@plitzi/sdk-shared/authoring/declare';
+/** What this element can be authored with — its component's own props, minus what the runtime supplies. */
+export type SvgAttributes = AuthorableAttributes<SvgProps>;
+declare const declaration: {
+    readonly type: "svg";
+    readonly content: {
+        readonly attributes: {
+            readonly content: "";
+            readonly label: "";
+        };
+        readonly definition: {
+            readonly label: "SVG";
+            readonly type: "svg";
+            readonly description: "A drawing written as SVG markup, coloured by its class.";
+            readonly bindings: {};
+            readonly styleSelectors: {
+                readonly base: "";
+            };
+            readonly initialState: {
+                readonly visibility: true;
+            };
+        };
+        readonly builder: {
+            readonly canDelete: true;
+            readonly canSelect: true;
+            readonly canDragDrop: true;
+            readonly canMove: true;
+            readonly canSnippet: true;
+            readonly itemsAllowed: readonly [];
+            readonly itemsNotAllowed: readonly [];
+        };
+        readonly market: {
+            readonly category: "media";
+            readonly owner: "Plitzi";
+            readonly verified: true;
+            readonly license: "MIT";
+            readonly website: "https://plitzi.com";
+            readonly backgroundColor: "#4422ee";
+            readonly icon: "fa-solid fa-bezier-curve";
+        };
+        readonly defaultStyle: {
+            readonly name: "Svg";
+            readonly displayMode: "desktop";
+            readonly style: {
+                readonly base: {
+                    readonly default: {
+                        readonly display: "inline-flex";
+                        readonly width: "24px";
+                        readonly height: "24px";
+                    };
+                };
+            };
+        };
+        readonly settings: {};
+    };
+} & import('@plitzi/sdk-shared/authoring/declare').ElementAttributesBrand<Partial<{
+    label?: string | undefined;
+    content?: string | undefined;
+}>>;
+export default declaration;

package/dist/elements/media/Svg/declaration.mjs

@@ -0,0 +1,49 @@
+import { elementDeclaration as e } from "@plitzi/sdk-shared/authoring/declare";
+//#region src/elements/media/Svg/declaration.ts
+var t = e()({
+	type: "svg",
+	content: {
+		attributes: {
+			content: "",
+			label: ""
+		},
+		definition: {
+			label: "SVG",
+			type: "svg",
+			description: "A drawing written as SVG markup, coloured by its class.",
+			bindings: {},
+			styleSelectors: { base: "" },
+			initialState: { visibility: !0 }
+		},
+		builder: {
+			canDelete: !0,
+			canSelect: !0,
+			canDragDrop: !0,
+			canMove: !0,
+			canSnippet: !0,
+			itemsAllowed: [],
+			itemsNotAllowed: []
+		},
+		market: {
+			category: "media",
+			owner: "Plitzi",
+			verified: !0,
+			license: "MIT",
+			website: "https://plitzi.com",
+			backgroundColor: "#4422ee",
+			icon: "fa-solid fa-bezier-curve"
+		},
+		defaultStyle: {
+			name: "Svg",
+			displayMode: "desktop",
+			style: { base: { default: {
+				display: "inline-flex",
+				width: "24px",
+				height: "24px"
+			} } }
+		},
+		settings: {}
+	}
+});
+//#endregion
+export { t as default };

package/dist/elements/media/Svg/index.d.ts

@@ -0,0 +1,60 @@
+declare const Svg: {
+    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./Svg').SvgProps>): import('react').JSX.Element;
+    displayName: string;
+} & {
+    readonly type: "svg";
+    readonly content: {
+        readonly attributes: {
+            readonly content: "";
+            readonly label: "";
+        };
+        readonly definition: {
+            readonly label: "SVG";
+            readonly type: "svg";
+            readonly description: "A drawing written as SVG markup, coloured by its class.";
+            readonly bindings: {};
+            readonly styleSelectors: {
+                readonly base: "";
+            };
+            readonly initialState: {
+                readonly visibility: true;
+            };
+        };
+        readonly builder: {
+            readonly canDelete: true;
+            readonly canSelect: true;
+            readonly canDragDrop: true;
+            readonly canMove: true;
+            readonly canSnippet: true;
+            readonly itemsAllowed: readonly [];
+            readonly itemsNotAllowed: readonly [];
+        };
+        readonly market: {
+            readonly category: "media";
+            readonly owner: "Plitzi";
+            readonly verified: true;
+            readonly license: "MIT";
+            readonly website: "https://plitzi.com";
+            readonly backgroundColor: "#4422ee";
+            readonly icon: "fa-solid fa-bezier-curve";
+        };
+        readonly defaultStyle: {
+            readonly name: "Svg";
+            readonly displayMode: "desktop";
+            readonly style: {
+                readonly base: {
+                    readonly default: {
+                        readonly display: "inline-flex";
+                        readonly width: "24px";
+                        readonly height: "24px";
+                    };
+                };
+            };
+        };
+        readonly settings: {};
+    };
+} & import('@plitzi/sdk-shared/authoring/declare').ElementAttributesBrand<Partial<{
+    label?: string | undefined;
+    content?: string | undefined;
+}>>;
+export default Svg;

package/dist/elements/media/Svg/index.mjs

@@ -0,0 +1,6 @@
+import e from "./declaration.mjs";
+import t from "./Svg.mjs";
+//#region src/elements/media/Svg/index.ts
+var n = Object.assign(t, e);
+//#endregion
+export { n as default };

package/dist/elements/media/Svg/sanitizeSvg.d.ts

@@ -0,0 +1,13 @@
+/** Whether the markup is an SVG at all — what the element refuses to draw otherwise. */
+export declare const isSvgMarkup: (markup: string) => boolean;
+/**
+ * The SVG with everything that runs taken out: what `sanitizeHtml` takes out of rich text — scripts, handlers,
+ * `javascript:` and `data:` URLs — and what only SVG has, HTML inside a `foreignObject` and animations that write a
+ * script into a link. An SVG is drawing; nothing in one needs to run.
+ */
+export declare const sanitizeSvg: (markup: string) => string;
+/**
+ * The drawing sized by its box: the root fills the element, so the element's class says how big it is. A `width` or
+ * `height` on the root would say otherwise — or, absent with only a `viewBox`, let it grow to the whole line.
+ */
+export declare const fitSvg: (markup: string) => string;

package/dist/elements/media/Svg/sanitizeSvg.mjs

@@ -0,0 +1,5 @@
+import { sanitizeHtml as e } from "../../basic/RichText/sanitizeHtml.mjs";
+//#region src/elements/media/Svg/sanitizeSvg.ts
+var t = /<\s*foreignObject\b[\s\S]*?<\s*\/\s*foreignObject\s*>|<\s*\/?\s*foreignObject\b[^>]*>/gi, n = /\s(to|from|values|by)\s*=\s*(?:"[^"]*javascript\s*:[^"]*"|'[^']*javascript\s*:[^']*')/gi, r = /^\s*(?:<!--[\s\S]*?-->\s*)*<svg\b[\s\S]*<\/svg>\s*$/i, i = (e) => r.test(e), a = (r) => e(r).replace(t, "").replace(n, ""), o = /<svg\b[^>]*>/i, s = (e) => e.replace(o, (e) => e.replace(/\s(width|height)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/^<svg\b/i, "<svg width=\"100%\" height=\"100%\""));
+//#endregion
+export { s as fitSvg, i as isSvgMarkup, a as sanitizeSvg };

package/dist/elements/media/Video/declaration.d.ts

@@ -29,7 +29,7 @@ declare const declaration: {
             readonly canSelect: true;
             readonly canDragDrop: true;
             readonly canMove: true;
-            readonly canTemplate: true;
+            readonly canSnippet: true;
             readonly itemsAllowed: readonly [];
             readonly itemsNotAllowed: readonly [];
         };

package/dist/elements/media/Video/declaration.mjs

@@ -23,7 +23,7 @@ var t = e()({
 			canSelect: !0,
 			canDragDrop: !0,
 			canMove: !0,
-			canTemplate: !0,
+			canSnippet: !0,
 			itemsAllowed: [],
 			itemsNotAllowed: []
 		},

package/dist/elements/media/Video/index.d.ts

@@ -28,7 +28,7 @@ declare const Video: {
             readonly canSelect: true;
             readonly canDragDrop: true;
             readonly canMove: true;
-            readonly canTemplate: true;
+            readonly canSnippet: true;
             readonly itemsAllowed: readonly [];
             readonly itemsNotAllowed: readonly [];
         };

package/dist/elements/provider/ApiContainer/ApiContainer.d.ts

@@ -48,6 +48,11 @@ export type ApiContainerProps = {
     pageParam?: string;
     /** Renders children while the first client-side request is still in flight, so a loading state can be bound. */
     renderWhileLoading?: boolean;
+    /**
+     * The id of a child shown in place of the others until the first answer arrives — a skeleton of what is coming — and
+     * gone after it. In the builder every child shows, so the slot can be edited beside what it stands for.
+     */
+    loadingSlot?: string;
     /**
      * Keep a browser request's answer in the page's query cache, shared with every provider asking the same thing.
      * Off by default: an author opts in knowing the page may show an answer up to `staleTime` old.
@@ -70,7 +75,7 @@ export type ApiContainerProps = {
      */
     refreshSeconds?: number | string;
 };
-declare const ApiContainer: ({ ref, className, children, query, method, accessToken, when, headers, mockData, subType, credentials, singleRecord, pagination, pageParam, renderWhileLoading, cache, staleTime, gcTime, refreshSeconds }: ApiContainerProps) => import('react').JSX.Element;
+declare const ApiContainer: ({ ref, className, children, query, method, accessToken, when, headers, mockData, subType, credentials, singleRecord, pagination, pageParam, renderWhileLoading, loadingSlot, cache, staleTime, gcTime, refreshSeconds }: ApiContainerProps) => import('react').JSX.Element;
 declare const _default: {
     (props: import('../../../Element/hocs/withElement').WithElementProps<ApiContainerProps>): import('react').JSX.Element;
     displayName: string;

package/dist/elements/provider/ApiContainer/ApiContainer.mjs

@@ -3,61 +3,62 @@ import t from "../../../Element/hooks/useElement.mjs";
 import ee from "../../../Element/hooks/useRscData.mjs";
 import { RootElement as te } from "../../../Element/RootElement.mjs";
 import n from "./declaration.mjs";
-import { isEmptyAnswer as r } from "./helpers/isEmptyAnswer.mjs";
-import ne from "./helpers/providerOutcome.mjs";
-import { queryInputOf as i } from "./helpers/queryInput.mjs";
-import re from "./hooks/useApi.mjs";
-import ie from "./hooks/useAutoRefresh.mjs";
-import ae from "./hooks/useProviderPagination.mjs";
-import oe from "./hooks/useProviderWrite.mjs";
-import se from "../../../dataSource/pathFields.mjs";
-import { use as ce, useCallback as a, useEffect as le, useMemo as o, useRef as ue } from "react";
-import de from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
-import { useSdkStore as s } from "@plitzi/sdk-shared/store";
-import { StoreProvider as fe } from "@plitzi/nexus/react";
+import { isEmptyAnswer as ne } from "./helpers/isEmptyAnswer.mjs";
+import { childrenWhile as re } from "./helpers/loadingSlot.mjs";
+import ie from "./helpers/providerOutcome.mjs";
+import { queryInputOf as ae } from "./helpers/queryInput.mjs";
+import r from "./hooks/useApi.mjs";
+import i from "./hooks/useAutoRefresh.mjs";
+import oe from "./hooks/useProviderPagination.mjs";
+import se from "./hooks/useProviderWrite.mjs";
+import ce from "../../../dataSource/pathFields.mjs";
+import { use as le, useCallback as a, useEffect as ue, useMemo as o, useRef as de } from "react";
+import fe from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { useSdkStore as pe } from "@plitzi/sdk-shared/store";
+import { StoreProvider as s } from "@plitzi/nexus/react";
 import { emptyObject as c } from "@plitzi/sdk-shared/helpers/utils";
 import { jsx as l } from "react/jsx-runtime";
-import { currentRscLocation as pe } from "@plitzi/sdk-shared/server/rsc/refreshRsc";
-import me from "clsx";
-import he from "@plitzi/sdk-shared/dataSource/helpers/getSourceName";
-import ge from "@plitzi/sdk-shared/dataSource/hooks/useRegisterSource";
-import { QueryBuilderEvaluator as _e } from "@plitzi/plitzi-ui/QueryBuilder";
+import { currentRscLocation as me } from "@plitzi/sdk-shared/server/rsc/refreshRsc";
+import he from "clsx";
+import ge from "@plitzi/sdk-shared/dataSource/helpers/getSourceName";
+import _e from "@plitzi/sdk-shared/dataSource/hooks/useRegisterSource";
+import { QueryBuilderEvaluator as ve } from "@plitzi/plitzi-ui/QueryBuilder";
 //#region src/elements/provider/ApiContainer/ApiContainer.tsx
-var u = ({ ref: e, className: u = "", children: d, query: f = "", method: p = "get", accessToken: m = "", when: h = c, headers: g = c, mockData: _ = "{}", subType: v = "", credentials: ve = "same-origin", singleRecord: y = !1, pagination: ye = "none", pageParam: be = "page", renderWhileLoading: xe = !1, cache: b = !1, staleTime: Se = 30, gcTime: Ce = 300, refreshSeconds: we = 0 }) => {
-	let { id: x, visible: S, definition: { label: C = "Api Container", runtime: Te, items: Ee } } = t(), w = Te === "server", { loaded: T, stale: E, location: D, elementData: O, refresh: k } = ee(), A = he(n.sourceType, x), { settings: { previewMode: j }, contexts: { InteractionsContext: De } } = de(), { interactionsManager: M } = ce(De), [[N, P, Oe]] = s([
+var u = ({ ref: e, className: u = "", children: d, query: f = "", method: p = "get", accessToken: m = "", when: h = c, headers: g = c, mockData: _ = "{}", subType: ye = "", credentials: be = "same-origin", singleRecord: v = !1, pagination: xe = "none", pageParam: Se = "page", renderWhileLoading: Ce = !1, loadingSlot: y = "", cache: we = !1, staleTime: Te = 30, gcTime: Ee = 300, refreshSeconds: De = 0 }) => {
+	let { id: b, visible: x, definition: { label: S = "Api Container", runtime: Oe, items: ke } } = t(), C = Oe === "server", { loaded: w, stale: T, location: E, elementData: D, refresh: O } = ee(), k = ge(n.sourceType, b), { settings: { previewMode: A }, contexts: { InteractionsContext: Ae } } = fe(), { interactionsManager: j } = le(Ae), [[M, N, je]] = pe([
 		"navigation.routeParams",
 		"navigation.queryParams",
 		"navigation.navigate"
-	]), ke = o(() => m ? {
+	]), Me = o(() => m ? {
 		...g,
 		Authorization: `Bearer ${m}`
-	} : g, [g, m]), F = o(() => w || !S ? !1 : !!(j && f && (h === c || _e(h, {
-		...N,
-		...P
-	})) || !j && (f || _ && _ !== "{}" && _ !== c)), [
-		w,
-		S,
-		j,
+	} : g, [g, m]), P = o(() => C || !x ? !1 : !!(A && f && (h === c || ve(h, {
+		...M,
+		...N
+	})) || !A && (f || _ && _ !== "{}" && _ !== c)), [
+		C,
+		x,
+		A,
 		f,
 		h,
+		M,
 		N,
-		P,
 		_
-	]), Ae = o(() => [x], [x]), { isLoading: je, isFetching: Me, data: I, refetch: L, isSuccess: Ne, isError: Pe } = re({
+	]), Ne = o(() => [b], [b]), { isLoading: Pe, isFetching: Fe, data: F, refetch: I, isSuccess: Ie, isError: Le } = r({
 		url: f,
 		method: p,
-		credentials: ve,
-		mock: j ? void 0 : _,
-		customHeaders: ke,
-		enabled: F,
-		cache: b,
-		staleTime: Se,
-		gcTime: Ce,
-		tags: Ae
-	}), R = w && !!D && D !== pe(), z = w && T && !R && O === null, B = o(() => {
-		if (!w) return I ?? c;
-		if (O) return O;
-		if (T) return c;
+		credentials: be,
+		mock: A ? void 0 : _,
+		customHeaders: Me,
+		enabled: P,
+		cache: we,
+		staleTime: Te,
+		gcTime: Ee,
+		tags: Ne
+	}), L = C && !!E && E !== me(), R = C && w && !L && D === null, z = o(() => {
+		if (!C) return F ?? c;
+		if (D) return D;
+		if (w) return c;
 		if (typeof _ != "string") return _;
 		try {
 			return JSON.parse(_ || "{}");
@@ -65,137 +66,142 @@ var u = ({ ref: e, className: u = "", children: d, query: f = "", method: p = "g
 			return c;
 		}
 	}, [
+		C,
+		F,
+		D,
 		w,
-		I,
-		O,
-		T,
 		_
-	]), V = w ? R : Me, Fe = w ? R : je, H = ue({}), U = a((e, t) => k(e, {
+	]), B = C ? L : Fe, V = C ? L : Pe, H = de({}), U = a((e, t) => O(e, {
 		...H.current,
 		...t
-	}), [k]), W = a(async () => {
-		if (!w) {
-			L();
+	}), [O]), W = a(async () => {
+		if (!C) {
+			I();
 			return;
 		}
-		await U([x]);
+		await U([b]);
 	}, [
-		w,
-		L,
+		C,
+		I,
 		U,
-		x
+		b
 	]), G = a(async ({ input: e } = {}) => {
-		let t = i(e);
+		let t = ae(e);
 		t && (H.current = t), await W();
 	}, [W]);
-	ie({
-		seconds: we,
-		enabled: S && (w ? T && !R : F),
+	i({
+		seconds: De,
+		enabled: x && (C ? w && !L : P),
 		refresh: W
 	});
-	let K = B, Ie = o(() => Array.isArray(K.records) ? K.records : [], [K.records]), { records: q, isLoadingMore: J, goToPage: Y, loadMore: X } = ae({
-		elementId: x,
-		mode: ye,
-		pageParam: be,
-		records: Ie,
+	let K = z, Re = o(() => Array.isArray(K.records) ? K.records : [], [K.records]), { records: q, isLoadingMore: J, goToPage: Y, loadMore: X } = oe({
+		elementId: b,
+		mode: xe,
+		pageParam: Se,
+		records: Re,
 		page: K.pageInfo?.page ?? 1,
 		refresh: U,
-		navigate: Oe
-	}), Z = ne({
-		serverMode: w,
-		isSuccess: Ne,
-		isError: Pe,
-		rscResolved: T,
-		rscPending: R,
-		elementData: O
+		navigate: je
+	}), Z = ie({
+		serverMode: C,
+		isSuccess: Ie,
+		isError: Le,
+		rscResolved: w,
+		rscPending: L,
+		elementData: D
 	});
-	le(() => {
-		!V && x && Z && M.interactionTrigger(x, Z === "success" ? "onApiSuccess" : "onApiError", {
+	ue(() => {
+		!B && b && Z && j.interactionTrigger(b, Z === "success" ? "onApiSuccess" : "onApiError", {
 			url: f,
 			method: p,
-			...B
+			...z
 		});
 	}, [
+		z,
+		b,
+		j,
 		B,
-		x,
-		M,
-		V,
 		p,
 		Z,
 		f
 	]);
 	let Q = o(() => ({
-		...B,
+		...z,
 		...Array.isArray(K.records) ? { records: q } : c,
-		isLoading: V || J,
-		isEmpty: r(K, q, y),
-		hasError: z,
-		errorMessage: z ? "The data provider could not be reached" : "",
-		isStale: w && E
+		isLoading: B || J,
+		isEmpty: ne(K, q, v),
+		hasError: R,
+		errorMessage: R ? "The data provider could not be reached" : "",
+		isStale: C && T
 	}), [
-		B,
+		z,
 		K.records,
 		K.record,
 		q,
-		V,
+		B,
 		J,
-		y,
-		z,
-		w,
-		E
-	]), Le = a(() => se(Q), [Q]);
-	ge({
-		id: x,
-		source: A,
-		name: C || `API - ${x}`,
-		fields: Le
+		v,
+		R,
+		C,
+		T
+	]), ze = a(() => ce(Q), [Q]);
+	_e({
+		id: b,
+		source: k,
+		name: S || `API - ${b}`,
+		fields: ze
 	});
-	let { writeRecord: $ } = oe({
-		elementId: x,
-		enabled: w,
+	let { writeRecord: $ } = se({
+		elementId: b,
+		enabled: C,
 		onDone: W
-	}), Re = o(() => {
+	}), Be = o(() => {
 		let e = {
 			performQuery: {
 				...n.callbacks.performQuery,
-				title: `Perform Query ${C}`,
+				title: `Perform Query ${S}`,
 				callback: G
 			},
 			loadMore: {
 				...n.callbacks.loadMore,
-				title: `Load More ${C}`,
+				title: `Load More ${S}`,
 				callback: X
 			},
 			goToPage: {
 				...n.callbacks.goToPage,
-				title: `Go To Page ${C}`,
+				title: `Go To Page ${S}`,
 				callback: ({ page: e }) => Y(Number(e) || 1)
 			}
 		};
-		return w && (e.writeRecord = {
+		return C && (e.writeRecord = {
 			...n.callbacks.writeRecord,
-			title: `Write Record ${C}`,
+			title: `Write Record ${S}`,
 			callback: $
 		}), e;
 	}, [
-		C,
+		S,
 		G,
 		X,
 		Y,
-		w,
+		C,
 		$
-	]), ze = o(() => A ? { runtime: { sources: { [A]: Q } } } : c, [Q, A]);
+	]), Ve = o(() => y && A ? re(d, y, V) : d, [
+		d,
+		V,
+		y,
+		A
+	]), He = o(() => k ? { runtime: { sources: { [k]: Q } } } : c, [Q, k]);
 	return /* @__PURE__ */ l(te, {
 		ref: e,
-		tag: !j && !Ee?.length ? "div" : v,
-		className: me("plitzi-component__api-container", u),
+		tag: !A && !ke?.length ? "div" : ye,
+		className: he("plitzi-component__api-container", u),
 		interactionTriggers: n.triggers,
-		interactionCallbacks: Re,
-		children: (!Fe || xe) && /* @__PURE__ */ l(fe, {
+		interactionCallbacks: Be,
+		children: (!V || Ce || y) && /* @__PURE__ */ l(s, {
 			inherit: "live",
-			name: `Api:${x}`,
-			value: ze,
-			children: d
+			name: `Api:${b}`,
+			value: He,
+			children: Ve
 		})
 	});
 }, d = e(u);

package/dist/elements/provider/ApiContainer/Settings.d.ts

@@ -21,11 +21,12 @@ type SettingsProps = {
     pagination?: 'none' | 'url' | 'append';
     pageParam?: string;
     renderWhileLoading?: boolean;
+    loadingSlot?: string;
     cache?: boolean;
     staleTime?: number | string;
     gcTime?: number | string;
     refreshSeconds?: number | string;
     onUpdate?: (key: string, value: string | boolean | number | object, isDefinition?: boolean) => void;
 };
-declare const Settings: ({ query, method, accessToken, headers, when, subType, mockData, credentials, runtime, connector, action, endpoint, resource, limit, singleRecord, filters, pagination, pageParam, renderWhileLoading, cache, staleTime, gcTime, refreshSeconds, onUpdate }: SettingsProps) => import('react').JSX.Element;
+declare const Settings: ({ query, method, accessToken, headers, when, subType, mockData, credentials, runtime, connector, action, endpoint, resource, limit, singleRecord, filters, pagination, pageParam, renderWhileLoading, loadingSlot, cache, staleTime, gcTime, refreshSeconds, onUpdate }: SettingsProps) => import('react').JSX.Element;
 export default Settings;