@plitzi/sdk-shared 0.37.9 → 0.38.1

package/dist/actions/triggerParams.mjs

@@ -1,11 +1,12 @@
+import { isRecord as e } from "../helpers/isRecord.mjs";
 //#region src/actions/triggerParams.ts
-var e = (e) => {
+var t = (e) => {
 	if (typeof e == "string" && e.trim() !== "") try {
 		return JSON.parse(e);
 	} catch {
 		return;
 	}
-}, t = (e) => typeof e == "object" && !!e && !Array.isArray(e), n = (e) => {
+}, n = (e) => {
 	let { access: t } = e;
 	if (t === "public" || t === "session") return { mode: t };
 	if (t === "role") return {
@@ -13,8 +14,8 @@ var e = (e) => {
 		permissions: (e.permissions ?? "").split(",").map((e) => e.trim()).filter(Boolean)
 	};
 }, r = (n) => {
-	let r = e(n.input);
-	return t(r) ? r : {};
+	let r = t(n.input);
+	return e(r) ? r : {};
 }, i = (e) => {
 	let t = e.signatureCredential?.trim();
 	if (!t) return;
@@ -30,8 +31,8 @@ var e = (e) => {
 	};
 }, a = (n) => {
 	if (n.signatureCredential?.trim()) return !1;
-	let r = e(n.verify);
-	return t(r) && typeof r.credential == "string" && r.credential.trim() !== "";
+	let r = t(n.verify);
+	return e(r) && typeof r.credential == "string" && r.credential.trim() !== "";
 }, o = (e) => {
 	let t = Number.parseFloat(e.cacheSeconds ?? "");
 	return Number.isFinite(t) && t > 0 ? Math.round(t * 1e3) : 0;

package/dist/actions/validateDocument.d.ts

@@ -1,3 +1,4 @@
+import { ActionDocument } from '../types';
 /**
  * The one server-action validator.
  *
@@ -21,3 +22,5 @@ export type ActionDocumentReport = {
     warnings: ActionDocumentIssue[];
 };
 export declare const validateActionDocument: (document: unknown) => ActionDocumentReport;
+/** Whether a value read from outside — a deployment's store, a request — is an action document a server can run. */
+export declare const isActionDocument: (document: unknown) => document is ActionDocument;

package/dist/actions/validateDocument.mjs

@@ -1,25 +1,26 @@
 import { isKnownTimeZone as e, parseCron as t } from "./cron.mjs";
 import { FAILURE_HANDLER_TASK as n } from "./failureHandler.mjs";
-import { triggerAccess as r, triggerHasStaleVerify as i, triggerVerify as a } from "./triggerParams.mjs";
+import { isRecord as r } from "../helpers/isRecord.mjs";
+import { triggerAccess as i, triggerHasStaleVerify as a, triggerVerify as o } from "./triggerParams.mjs";
 //#region src/actions/validateDocument.ts
-var o = [
+var s = [
 	"text",
 	"number",
 	"boolean",
 	"date",
 	"json",
 	"file"
-], s = [
+], c = [
 	"public",
 	"session",
 	"role"
-], c = [
+], l = [
 	"call",
 	"webhook",
 	"schedule",
 	"render",
 	"custom"
-], l = ["sha256", "sha1"], u = /* @__PURE__ */ new Set([
+], u = ["sha256", "sha1"], d = /* @__PURE__ */ new Set([
 	"input",
 	"user",
 	"spaceId",
@@ -28,208 +29,208 @@ var o = [
 	"runId",
 	"now",
 	"failure"
-]), d = /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/, f = (e) => typeof e == "object" && !!e && !Array.isArray(e), p = (e) => typeof e == "string" && e.trim() !== "", m = (e) => {
+]), f = /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/, p = (e) => typeof e == "string" && e.trim() !== "", m = (e) => {
 	try {
 		let t = JSON.parse(e);
-		return f(t) ? t : void 0;
+		return r(t) ? t : void 0;
 	} catch {
 		return;
 	}
 }, h = (e, t, n) => {
 	if (e !== void 0) {
-		if (!f(e)) {
+		if (!r(e)) {
 			n.push({
 				path: t,
 				message: "must be an object of field definitions"
 			});
 			return;
 		}
-		Object.entries(e).forEach(([e, r]) => {
-			if (!f(r) || !p(r.type)) {
+		Object.entries(e).forEach(([e, i]) => {
+			if (!r(i) || !p(i.type)) {
 				n.push({
 					path: `${t}.${e}`,
 					message: "must declare a type"
 				});
 				return;
 			}
-			o.includes(r.type) || n.push({
+			s.includes(i.type) || n.push({
 				path: `${t}.${e}.type`,
-				message: `unknown field type "${r.type}"`,
-				hint: `one of ${o.join(", ")}`
+				message: `unknown field type "${i.type}"`,
+				hint: `one of ${s.join(", ")}`
 			});
 		});
 	}
-}, g = (n, o, u, d) => {
-	let g = `nodes.${n}`, _ = o.action;
-	if (!p(_) || !c.includes(_)) {
-		u.push({
+}, g = (n, s, d, f) => {
+	let g = `nodes.${n}`, _ = s.action;
+	if (!p(_) || !l.includes(_)) {
+		d.push({
 			path: `${g}.action`,
 			message: `"${String(_)}" is not a way an action can be started`,
-			hint: `one of ${c.join(", ")}`
+			hint: `one of ${l.join(", ")}`
 		});
 		return;
 	}
-	let v = f(o.params) ? o.params : {};
+	let v = r(s.params) ? s.params : {};
 	if (p(v.input)) {
 		let e = m(v.input);
-		e === void 0 ? u.push({
+		e === void 0 ? d.push({
 			path: `${g}.params.input`,
 			message: "is not valid JSON"
-		}) : h(e, `${g}.params.input`, u);
+		}) : h(e, `${g}.params.input`, d);
 	}
 	if (_ !== "schedule") {
-		if (!p(v.access) || !s.includes(v.access)) u.push({
+		if (!p(v.access) || !c.includes(v.access)) d.push({
 			path: `${g}.params.access`,
 			message: "must say who may start a run this way",
-			hint: `one of ${s.join(", ")}`
+			hint: `one of ${c.join(", ")}`
 		});
 		else if (v.access === "role") {
-			let e = r(v);
-			e?.mode === "role" && e.permissions.length === 0 && u.push({
+			let e = i(v);
+			e?.mode === "role" && e.permissions.length === 0 && d.push({
 				path: `${g}.params.permissions`,
 				message: "role access must name at least one permission"
 			});
 		}
 	}
-	if (_ === "schedule" && (p(v.cron) ? t(v.cron) || u.push({
+	if (_ === "schedule" && (p(v.cron) ? t(v.cron) || d.push({
 		path: `${g}.params.cron`,
 		message: `"${v.cron}" is not an expression this server can read, so it would never fire`,
 		hint: "five fields — minute hour day-of-month month day-of-week — with *, lists, ranges and steps"
-	}) : u.push({
+	}) : d.push({
 		path: `${g}.params.cron`,
 		message: "a scheduled trigger needs a cron expression"
-	}), p(v.timezone) && !e(v.timezone) && u.push({
+	}), p(v.timezone) && !e(v.timezone) && d.push({
 		path: `${g}.params.timezone`,
 		message: `"${v.timezone}" is not a time zone this server knows, so the schedule would never fire`,
 		hint: "an IANA name like America/Santiago or Europe/Madrid — leave it empty for UTC"
 	})), p(v.cacheSeconds)) {
 		let e = Number.parseFloat(v.cacheSeconds);
-		!Number.isFinite(e) || e < 0 ? u.push({
+		!Number.isFinite(e) || e < 0 ? d.push({
 			path: `${g}.params.cacheSeconds`,
 			message: "must be a number of seconds, or left empty"
-		}) : _ !== "render" && d.push({
+		}) : _ !== "render" && f.push({
 			path: `${g}.params.cacheSeconds`,
 			message: `a "${_}" trigger is never answered from a cache`,
 			hint: "reuse only applies to a render, where the same page is built for one visitor after another"
 		});
 	}
-	_ === "custom" && !p(v.name) && u.push({
+	_ === "custom" && !p(v.name) && d.push({
 		path: `${g}.params.name`,
 		message: "a custom trigger needs a name to be mounted under"
-	}), _ === "webhook" && (i(v) && u.push({
+	}), _ === "webhook" && (a(v) && d.push({
 		path: `${g}.params.signatureCredential`,
 		message: "this signature check is in a format nothing reads any more, so the webhook is unverified",
 		hint: "name the credential holding the signing secret in \"Signing secret\", and its header beside it"
-	}), a(v) || d.push({
+	}), o(v) || f.push({
 		path: `${g}.params.signatureCredential`,
 		message: "this webhook accepts unsigned requests",
 		hint: "name the credential holding the signing secret, and only the sender you expect can start a run"
-	}), p(v.signatureAlgorithm) && !l.includes(v.signatureAlgorithm) && d.push({
+	}), p(v.signatureAlgorithm) && !u.includes(v.signatureAlgorithm) && f.push({
 		path: `${g}.params.signatureAlgorithm`,
 		message: `"${v.signatureAlgorithm}" is not an algorithm this server signs with, so sha256 is used`,
-		hint: `one of ${l.join(", ")}`
-	}), p(v.signatureToleranceSeconds) && !p(v.signatureTimestampHeader) && d.push({
+		hint: `one of ${u.join(", ")}`
+	}), p(v.signatureToleranceSeconds) && !p(v.signatureTimestampHeader) && f.push({
 		path: `${g}.params.signatureToleranceSeconds`,
 		message: "a tolerance with no timestamp header expires nothing",
 		hint: "name the header the sender puts the signing time in, or drop the tolerance"
-	})), _ === "call" && v.access === "public" && d.push({
+	})), _ === "call" && v.access === "public" && f.push({
 		path: `${g}.params.access`,
 		message: "anyone can run this action, including signed-out visitors",
 		hint: "use session access unless the page needs it before anyone signs in"
 	});
-}, _ = (e, t, r, i) => {
-	if (!f(e)) {
-		r.push({
+}, _ = (e, t, i, a) => {
+	if (!r(e)) {
+		i.push({
 			path: "nodes",
 			message: "must be an object of steps"
 		});
 		return;
 	}
-	let a = Object.entries(e), o = a.filter(([, e]) => f(e) && e.type === "trigger");
-	o.length === 0 && r.push({
+	let o = Object.entries(e), s = o.filter(([, e]) => r(e) && e.type === "trigger");
+	s.length === 0 && i.push({
 		path: "nodes",
 		message: "this action has no way in",
 		hint: "add a trigger step — call, webhook, schedule, render or custom"
 	});
-	let s = /* @__PURE__ */ new Map();
-	o.forEach(([e, t]) => {
-		p(t.action) && s.set(t.action, [...s.get(t.action) ?? [], e]);
-	}), s.forEach((e, t) => {
-		e.length > 1 && r.push({
+	let c = /* @__PURE__ */ new Map();
+	s.forEach(([e, t]) => {
+		p(t.action) && c.set(t.action, [...c.get(t.action) ?? [], e]);
+	}), c.forEach((e, t) => {
+		e.length > 1 && i.push({
 			path: `nodes.${e[1]}`,
 			message: `this action has ${e.length} "${t}" triggers`,
 			hint: "one step per way in — a second flow starts from a different kind of trigger"
 		});
-	}), a.forEach(([t, n]) => {
-		let a = `nodes.${t}`;
-		if (!f(n)) {
-			r.push({
-				path: a,
+	}), o.forEach(([t, n]) => {
+		let o = `nodes.${t}`;
+		if (!r(n)) {
+			i.push({
+				path: o,
 				message: "must be an object"
 			});
 			return;
 		}
 		if (n.type === "trigger") {
-			g(t, n, r, i);
+			g(t, n, i, a);
 			return;
 		}
 		if (n.type !== "task") {
-			r.push({
-				path: `${a}.type`,
+			i.push({
+				path: `${o}.type`,
 				message: `"${String(n.type)}" steps run in the browser and cannot run on the server`,
 				hint: "a server action is made of task steps"
 			});
 			return;
 		}
-		if (!p(n.action) || !d.test(n.action)) {
-			r.push({
-				path: `${a}.action`,
+		if (!p(n.action) || !f.test(n.action)) {
+			i.push({
+				path: `${o}.action`,
 				message: "must name a task as <namespace>.<action>",
 				hint: "for example flow.output or http.request"
 			});
 			return;
 		}
-		p(n.afterNode) && !Object.hasOwn(e, n.afterNode) && r.push({
-			path: `${a}.afterNode`,
+		p(n.afterNode) && !Object.hasOwn(e, n.afterNode) && i.push({
+			path: `${o}.afterNode`,
 			message: `points at "${n.afterNode}", which is not a step here`
 		});
-	}), a.forEach(([e]) => {
-		u.has(e) && r.push({
+	}), o.forEach(([e]) => {
+		d.has(e) && i.push({
 			path: `nodes.${e}`,
 			message: `"${e}" is what the run itself publishes in the flow scope, so a step may not take the name`,
 			hint: `rename the step — every later step reads {{ ${e} }} expecting the run's own value`
 		});
 	});
-	let c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), m = [];
-	o.forEach(([t]) => {
+	let l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), m = [];
+	s.forEach(([t]) => {
 		let n = /* @__PURE__ */ new Set(), r = [], i = t;
 		for (; i;) {
 			if (n.has(i)) {
-				l.add(i);
+				u.add(i);
 				break;
 			}
-			n.add(i), r.push(i), c.add(i);
+			n.add(i), r.push(i), l.add(i);
 			let t = e[i];
 			i = p(t?.afterNode) ? t.afterNode : "";
 		}
 		m.push(r);
-	}), l.forEach((e) => {
-		r.push({
+	}), u.forEach((e) => {
+		i.push({
 			path: `nodes.${e}`,
 			message: "this step is reached again by its own chain, so the flow never ends",
 			hint: "break the `afterNode` chain that comes back to it"
 		});
-	}), a.forEach(([e]) => {
-		c.has(e) || i.push({
+	}), o.forEach(([e]) => {
+		l.has(e) || a.push({
 			path: `nodes.${e}`,
 			message: "no trigger reaches this step, so it never runs",
 			hint: "chain it with `afterNode` from a trigger, or delete it"
 		});
 	});
-	let h = (t) => e[t]?.action, _ = a.filter(([, e]) => f(e) && e.action === "flow.output");
+	let h = (t) => e[t]?.action, _ = o.filter(([, e]) => r(e) && e.action === "flow.output");
 	for (let [t, n] of _) {
 		let r = p(n.afterNode) && h(n.afterNode) === "flow.onFailure";
-		p(n.afterNode) && Object.hasOwn(e, n.afterNode) && !r && i.push({
+		p(n.afterNode) && Object.hasOwn(e, n.afterNode) && !r && a.push({
 			path: `nodes.${t}.afterNode`,
 			message: "the output step is not the last one, so the steps after it run for nothing",
 			hint: "move flow.output to the end of the flow"
@@ -241,37 +242,37 @@ var o = [
 	m.forEach((e) => {
 		let t = e.findIndex((e) => h(e) === n);
 		if (t === -1) return;
-		let a = e[t];
-		t === 1 && y(i, {
-			path: `nodes.${a}`,
+		let r = e[t];
+		t === 1 && y(a, {
+			path: `nodes.${r}`,
 			message: "nothing runs before this step, so nothing can fail and the steps after it never run",
 			hint: "put On Failure after the steps whose work it undoes"
-		}), t === e.length - 1 && y(i, {
-			path: `nodes.${a}`,
+		}), t === e.length - 1 && y(a, {
+			path: `nodes.${r}`,
 			message: "nothing follows this step, so a failed run undoes nothing",
 			hint: "add the steps that give back what the flow already did"
 		}), e.slice(t + 1).forEach((e) => {
-			h(e) === "flow.onFailure" && y(r, {
+			h(e) === "flow.onFailure" && y(i, {
 				path: `nodes.${e}`,
 				message: "a flow has one place its undo begins, and this is a second one",
 				hint: "keep one On Failure step and put every undo step after it"
-			}), h(e) === "flow.output" && y(r, {
+			}), h(e) === "flow.output" && y(i, {
 				path: `nodes.${e}`,
 				message: "an output step after On Failure answers a run that has already failed",
 				hint: "move flow.output before On Failure"
 			});
 		});
-	}), _.length === 0 && f(t) && Object.keys(t).length > 0 && i.push({
+	}), _.length === 0 && r(t) && Object.keys(t).length > 0 && a.push({
 		path: "nodes",
 		message: "this action is expected to answer values but no step names any",
 		hint: "add a flow.output step at the end naming what the caller should get"
 	});
 }, v = /\{\{\s*credential\./, y = (e, t) => {
 	Object.entries(e).forEach(([e, n]) => {
-		if (!f(n) || !f(n.params)) return;
-		let r = p(n.params.credential) ? n.params.credential : "";
-		Object.entries(n.params).forEach(([n, i]) => {
-			typeof i == "string" && v.test(i) && r === "" && t.push({
+		if (!r(n) || !r(n.params)) return;
+		let i = p(n.params.credential) ? n.params.credential : "";
+		Object.entries(n.params).forEach(([n, r]) => {
+			typeof r == "string" && v.test(r) && i === "" && t.push({
 				path: `nodes.${e}.params.${n}`,
 				message: "this step reads a credential it did not ask for, so the token resolves to nothing",
 				hint: "set the step’s `credential` to the identifier it should use"
@@ -280,10 +281,10 @@ var o = [
 	});
 }, b = (e) => {
 	let t = [], n = [];
-	return f(e) ? (p(e.name) || t.push({
+	return r(e) ? (p(e.name) || t.push({
 		path: "name",
 		message: "must have a name"
-	}), h(e.output, "output", t), _(e.nodes, e.output, t, n), y(f(e.nodes) ? e.nodes : {}, n), {
+	}), h(e.output, "output", t), _(e.nodes, e.output, t, n), y(r(e.nodes) ? e.nodes : {}, n), {
 		valid: t.length === 0,
 		errors: t,
 		warnings: n
@@ -295,6 +296,6 @@ var o = [
 		}],
 		warnings: n
 	};
-};
+}, x = (e) => b(e).valid;
 //#endregion
-export { b as validateActionDocument };
+export { x as isActionDocument, b as validateActionDocument };

package/dist/authoring/elementCallbacks.d.ts

@@ -1,5 +1,70 @@
 import { BuiltinActionSpec } from './builder';
+import { BuiltinParam } from './paramSpec';
 export type BuiltinElementCallback = BuiltinActionSpec;
+/**
+ * Moving what an element shows, on the element whose box scrolls (`overflow: auto` on a row of cards, a panel) — or,
+ * with `scrollIntoView`, the page to an element. Arrows over a carousel that still swipes on a phone, a "back to the
+ * top", a jump to the answer a form just showed. Its node names the element that moves; nothing happens where there is
+ * no page to move (a server render).
+ */
+export declare const SCROLL_CALLBACKS: {
+    scrollBy: {
+        title: string;
+        type: "callback";
+        strictParams: true;
+        params: {
+            x: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            y: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            behavior: BuiltinParam;
+        };
+    };
+    scrollTo: {
+        title: string;
+        type: "callback";
+        strictParams: true;
+        params: {
+            x: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            y: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            behavior: BuiltinParam;
+        };
+    };
+    scrollIntoView: {
+        title: string;
+        type: "callback";
+        strictParams: true;
+        params: {
+            block: {
+                type: "select";
+                description: string;
+                default: string;
+                options: ("start" | "center" | "end" | "nearest")[];
+            };
+            inline: {
+                type: "select";
+                description: string;
+                default: string;
+                options: ("start" | "center" | "end" | "nearest")[];
+            };
+            behavior: BuiltinParam;
+        };
+    };
+};
 export declare const BUILTIN_ELEMENT_CALLBACKS: Record<string, BuiltinElementCallback>;
 /** The built-in element callback for an action, or undefined when the action is not a known built-in (an
  *  element-type-specific/plugin callback whose schema is not knowable here). */

package/dist/authoring/elementCallbacks.mjs

@@ -1,6 +1,69 @@
 import { reconcileParams as e } from "./paramSpec.mjs";
+import { SCROLL_BEHAVIORS as t, SCROLL_POSITIONS as n } from "../helpers/scroll.mjs";
 //#region src/authoring/elementCallbacks.ts
-var t = {
+var r = {
+	type: "select",
+	description: "How it moves: \"smooth\" glides there, \"auto\" jumps.",
+	default: "smooth",
+	options: [...t]
+}, i = {
+	scrollBy: {
+		title: "Scroll By",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			x: {
+				type: "text",
+				description: "How far across: pixels (\"240\") or a share of what the box shows (\"80%\"); negative goes back.",
+				default: ""
+			},
+			y: {
+				type: "text",
+				description: "How far down, the same way; negative goes up.",
+				default: ""
+			},
+			behavior: r
+		}
+	},
+	scrollTo: {
+		title: "Scroll To",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			x: {
+				type: "text",
+				description: "Where across: \"start\", \"end\", pixels from the start, or a share of the way (\"50%\"). Empty stays.",
+				default: ""
+			},
+			y: {
+				type: "text",
+				description: "Where down, the same way. Empty stays.",
+				default: ""
+			},
+			behavior: r
+		}
+	},
+	scrollIntoView: {
+		title: "Scroll Into View",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			block: {
+				type: "select",
+				description: "Where the element lands, top to bottom.",
+				default: "start",
+				options: [...n]
+			},
+			inline: {
+				type: "select",
+				description: "Where it lands, side to side.",
+				default: "nearest",
+				options: [...n]
+			},
+			behavior: r
+		}
+	}
+}, a = {
 	setState: {
 		title: "Update Element (set attribute / state)",
 		type: "callback",
@@ -56,16 +119,17 @@ var t = {
 				label: "Revert changes after interaction"
 			}
 		}
-	}
-}, n = (e) => Object.hasOwn(t, e) ? t[e] : void 0, r = (t, r) => {
-	let i = n(t);
-	return i ? {
+	},
+	...i
+}, o = (e) => Object.hasOwn(a, e) ? a[e] : void 0, s = (t, n) => {
+	let r = o(t);
+	return r ? {
 		known: !0,
-		params: e(r, i.params, i.strictParams)
+		params: e(n, r.params, r.strictParams)
 	} : {
 		known: !1,
-		params: r
+		params: n
 	};
 };
 //#endregion
-export { t as BUILTIN_ELEMENT_CALLBACKS, r as applyElementCallback, n as getElementCallback };
+export { a as BUILTIN_ELEMENT_CALLBACKS, i as SCROLL_CALLBACKS, s as applyElementCallback, o as getElementCallback };

package/dist/authoring/index.mjs

@@ -1,6 +1,6 @@
 import { toBuilderParams as e, toInteractionCallback as t, toInteractionCallbacks as n } from "./builder.mjs";
 import { elementDeclaration as r, valuesOf as i } from "./declare.mjs";
 import { hiddenParams as a, invalidParams as o, missingRequiredParams as s, reconcileParams as c } from "./paramSpec.mjs";
-import { BUILTIN_ELEMENT_CALLBACKS as l, applyElementCallback as u, getElementCallback as d } from "./elementCallbacks.mjs";
-import { spaceCallbacks as f } from "./spaceCallbacks.mjs";
-export { l as BUILTIN_ELEMENT_CALLBACKS, u as applyElementCallback, r as elementDeclaration, d as getElementCallback, a as hiddenParams, o as invalidParams, s as missingRequiredParams, c as reconcileParams, f as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, i as valuesOf };
+import { BUILTIN_ELEMENT_CALLBACKS as l, SCROLL_CALLBACKS as u, applyElementCallback as d, getElementCallback as f } from "./elementCallbacks.mjs";
+import { spaceCallbacks as p } from "./spaceCallbacks.mjs";
+export { l as BUILTIN_ELEMENT_CALLBACKS, u as SCROLL_CALLBACKS, d as applyElementCallback, r as elementDeclaration, f as getElementCallback, a as hiddenParams, o as invalidParams, s as missingRequiredParams, c as reconcileParams, p as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, i as valuesOf };

package/dist/builder/contexts/BuilderContext.d.ts

@@ -1,7 +1,7 @@
 import { ComponentPluginWithHOC, DropPosition, Element, EventBridgeEvent, PluginBuilder, Schema, Style } from '../../types';
 import { Dispatch, SetStateAction } from 'react';
 export type BuilderContextValue = {
-    mode: 'normal' | 'template';
+    mode: 'normal' | 'snippet';
     schemaName: string;
     setMultiPagesMode: Dispatch<SetStateAction<boolean>>;
     multiPagesMode: boolean;
@@ -18,27 +18,38 @@ export type BuilderContextValue = {
     };
     builderHandler: (event: EventBridgeEvent, ...data: unknown[]) => void;
     updateElement: (elementId: string, attributeKey: string, attributeValue: unknown, category?: 'attributes' | 'definition') => void;
-    /** Saves an element as a template file in a public bucket of one of the space's CDNs. */
-    elementAsTemplate: (target: {
+    /**
+     * Saves an element and what it holds as a snippet file in a public bucket of one of the space's CDNs, and says
+     * whether it was saved — and why not, in words for whoever asked.
+     */
+    elementAsSnippet: (target: {
         cdnIdentifier: string;
         bucketIdentifier: string;
-    }, schema: Schema, style: Style, name: string, description: string, element: Element) => Promise<void>;
+    }, details: {
+        name: string;
+        description: string;
+    }, element: Element) => Promise<{
+        saved: true;
+    } | {
+        saved: false;
+        reason: string;
+    }>;
     builderGetBaseElement: (otherBaseElementId?: string) => undefined | {
         data: Element;
         Plugin: ComponentPluginWithHOC | Record<string, ComponentPluginWithHOC>;
     };
     builderDropElement: {
-        (type: 'add##plitzi-template', data: {
+        (type: 'add##plitzi-snippet', data: {
             elements: Record<string, Element>;
             baseElement?: Element;
             style: Style;
             variables: Schema['variables'];
         }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
-        <T extends string>(type: `add##${Exclude<T, 'plitzi-template'>}`, data: {
+        <T extends string>(type: `add##${Exclude<T, 'plitzi-snippet'>}`, data: {
             id?: string;
             element: Element;
         }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
-        <T extends string>(type: `move##${Exclude<T, 'plitzi-template'>}`, data: {
+        <T extends string>(type: `move##${Exclude<T, 'plitzi-snippet'>}`, data: {
             id: string;
             parentId: string;
             element: Element;

package/dist/connectors/index.d.ts

@@ -1,7 +1,7 @@
 export { BODYLESS_METHODS, CONNECTOR_HTTP_METHODS, DEFAULT_READ_ENDPOINT, EMPTY_RESPONSE_METHODS, READ_ENDPOINT_NAMES, WRITE_ENDPOINT_NAMES } from './constants';
 export { connectorTokens, getConnectorTokens } from './manifestTokens';
 export { connectorPresets, emptyManifest } from './presets';
-export { validateConnectorManifest } from './validateManifest';
+export { isConnectorManifestDraft, validateConnectorManifest } from './validateManifest';
 export type { ConnectorPreset } from './presets';
 export type { ConnectorToken, ConnectorTokenScope } from './manifestTokens';
 export type { ConnectorManifestIssue, ConnectorManifestReport } from './validateManifest';