@plitzi/sdk-interactions 0.33.2 → 0.34.0

package/dist/sources/AuthSource/callbacks.mjs

@@ -0,0 +1,71 @@
+//#region src/sources/AuthSource/callbacks.ts
+var e = {
+	login: {
+		source: "auth",
+		title: "Auth Login",
+		strictParams: !0,
+		params: {
+			mode: {
+				type: "select",
+				description: "Credentials to sign in with: a username and password, or a token obtained elsewhere.",
+				default: "normal",
+				options: ["normal", "token"],
+				optionLabels: {
+					normal: "User and Password",
+					token: "Token"
+				},
+				canBind: !1
+			},
+			username: {
+				type: "text",
+				description: "Username.",
+				default: "",
+				when: (e) => e.mode === "normal"
+			},
+			password: {
+				type: "text",
+				description: "Password.",
+				default: "",
+				when: (e) => e.mode === "normal"
+			},
+			token: {
+				type: "text",
+				description: "A token to exchange for a session.",
+				default: "",
+				when: (e) => e.mode === "token"
+			}
+		},
+		preview: {
+			ok: "",
+			reason: "",
+			errors: {
+				username: "",
+				password: "",
+				token: ""
+			},
+			accessToken: "",
+			expiresAt: "",
+			refreshToken: ""
+		}
+	},
+	refreshDetails: {
+		source: "auth",
+		title: "Auth Refresh Details",
+		strictParams: !0,
+		params: {},
+		preview: {
+			errors: "",
+			accessToken: "",
+			expiresAt: "",
+			refreshToken: ""
+		}
+	},
+	logout: {
+		source: "auth",
+		title: "Auth Logout",
+		strictParams: !0,
+		params: {}
+	}
+};
+//#endregion
+export { e as authCallbacks };

package/dist/sources/HostSource/HostInteractions.d.ts

@@ -0,0 +1,16 @@
+import { HostActions } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type HostInteractionsProps = {
+    children?: ReactNode;
+    /** What the embedding application is willing to be asked to do. Absent means it offers nothing. */
+    actions?: HostActions;
+};
+/**
+ * The bridge out of a space and into the application rendering it.
+ *
+ * It is registered whether or not the host offers anything, so a space authored against a host that has not been
+ * updated yet fails the way every other unresolved callback does — by doing nothing — rather than by throwing in
+ * the middle of a flow somebody is watching.
+ */
+declare const HostInteractions: ({ children, actions }: HostInteractionsProps) => ReactNode;
+export default HostInteractions;

package/dist/sources/HostSource/HostInteractions.mjs

@@ -0,0 +1,20 @@
+import e from "../../InteractionsContext.mjs";
+import t from "./callbacks.mjs";
+import { use as n, useCallback as r, useMemo as i } from "react";
+import { toInteractionCallbacks as a } from "@plitzi/sdk-shared/authoring/builder";
+//#region src/sources/HostSource/HostInteractions.tsx
+var o = ({ children: o, actions: s }) => {
+	let { useInteractions: c } = n(e), l = r((e) => {
+		let { action: t, value: n } = e, r = t ? s?.[t] : void 0;
+		r && r({
+			...e,
+			value: n
+		});
+	}, [s]);
+	return c({
+		id: "host",
+		callbacks: i(() => a(t, { hostAction: l }), [l])
+	}), o;
+};
+//#endregion
+export { o as default };

package/dist/sources/HostSource/callbacks.d.ts

@@ -0,0 +1,15 @@
+import { BuiltinGlobalCallback } from '@plitzi/sdk-shared/authoring/builder';
+/**
+ * The one way a rendered space can ask the application AROUND it to do something.
+ *
+ * Every other source acts on things the space owns — its own state, its own router, its own session. A space
+ * embedded in an application does not own the window: opening one of the host's screens, signing out of the host's
+ * keyring, quitting. Without this, anything shaped like an application shell had to be written in the host's own
+ * code, which is the one part of a product that then cannot be authored, themed or changed without a release.
+ *
+ * ONE declared action rather than one per verb, because what a host offers is the host's business and no catalog
+ * here can know it. `action` names the handler the host registered; a name it did not register does nothing, which
+ * is the same answer a space gets for every other callback that resolves to nothing.
+ */
+export declare const hostCallbacks: Record<string, BuiltinGlobalCallback>;
+export default hostCallbacks;

package/dist/sources/HostSource/callbacks.mjs

@@ -0,0 +1,20 @@
+//#region src/sources/HostSource/callbacks.ts
+var e = { hostAction: {
+	source: "host",
+	title: "Host Action",
+	strictParams: !0,
+	params: {
+		action: {
+			type: "text",
+			description: "The name the host registered the handler under — `openSpace`, `signOut`, whatever it offers.",
+			default: ""
+		},
+		value: {
+			type: "scalar",
+			description: "What the action is about: the space to open, the workspace to switch to. Optional.",
+			default: ""
+		}
+	}
+} };
+//#endregion
+export { e as default, e as hostCallbacks };

package/dist/sources/HostSource/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './HostInteractions';
+export { default as HostInteractions } from './HostInteractions';
+export * from './callbacks';

package/dist/sources/HostSource/index.mjs

@@ -0,0 +1,3 @@
+import e from "./callbacks.mjs";
+import t from "./HostInteractions.mjs";
+export { t as HostInteractions, t as default, e as hostCallbacks };

package/dist/sources/NavigationSource/NavigationInteractions.mjs

@@ -1,68 +1,47 @@
 import e from "../../InteractionsContext.mjs";
-import { use as t, useCallback as n, useMemo as r } from "react";
-import { get as i, pick as a } from "@plitzi/plitzi-ui/helpers";
-import { useSdkStore as o } from "@plitzi/sdk-shared/store";
+import { navigationCallbacks as t } from "./callbacks.mjs";
+import { use as n, useCallback as r, useMemo as i } from "react";
+import { get as a, pick as o } from "@plitzi/plitzi-ui/helpers";
+import { useSdkStore as s } from "@plitzi/sdk-shared/store";
+import { toBuilderParams as c, toInteractionCallbacks as l } from "@plitzi/sdk-shared/authoring/builder";
 //#region src/sources/NavigationSource/NavigationInteractions.tsx
-var s = ({ children: s, previewMode: c = !1 }) => {
-	let { useInteractions: l } = t(e), [[u, d, f]] = o([
+var u = ({ children: u, previewMode: d = !1 }) => {
+	let { useInteractions: f } = n(e), [[p, m, h]] = s([
 		"schema.pages",
 		"pageDefinitions",
 		"navigation.navigate"
-	]), p = r(() => {
-		let e = a(d, u);
+	]), g = i(() => {
+		let e = o(m, p);
 		return Object.keys(e).reduce((t, n) => {
-			let r = e[n], a = i(r, "attributes.name", n), o = i(r, "attributes.default", !1);
+			let r = e[n], i = a(r, "attributes.name", n), o = a(r, "attributes.default", !1);
 			return [...t, {
 				key: n,
-				label: a,
+				label: i,
 				defaultPage: o
 			}];
 		}, []);
-	}, [d, u]), m = n((e) => {
-		if (!c) return;
+	}, [m, p]), _ = r((e) => {
+		if (!d) return;
 		let { url: t, urlType: n } = e;
-		n === "page" || n === "internal" ? f(t) : f(t, !0);
-	}, [f, c]);
-	return l({
+		n === "page" || n === "internal" ? h(t) : h(t, !0);
+	}, [h, d]);
+	return f({
 		id: "navigation",
-		callbacks: r(() => ({ navigate: {
-			action: "navigate",
-			title: "Navigate",
-			type: "globalCallback",
-			callback: m,
-			preview: {},
-			params: {
-				urlType: {
-					label: "Url Type",
-					defaultValue: void 0,
-					type: "select",
-					options: [
-						{
-							value: "page",
-							label: "Space Page"
-						},
-						{
-							value: "internal",
-							label: "Inside Space"
-						},
-						{
-							value: "external",
-							label: "Outside Space"
-						}
-					]
-				},
+		callbacks: i(() => {
+			let { urlType: e, url: n } = c(t.navigate.params);
+			return l(t, { navigate: _ }, { navigate: { params: {
+				urlType: e,
 				url: {
-					defaultValue: p.find((e) => e.defaultPage)?.key ?? "",
-					type: (e) => e.urlType === "page" ? "select" : "text",
-					when: (e) => !!e.urlType,
-					options: p.map((e) => ({
+					...n,
+					defaultValue: g.find((e) => e.defaultPage)?.key ?? "",
+					options: g.map((e) => ({
 						value: e.key,
 						label: e.label
 					}))
 				}
-			}
-		} }), [m, p])
-	}), s;
+			} } });
+		}, [_, g])
+	}), u;
 };
 //#endregion
-export { s as default };
+export { u as default };

package/dist/sources/NavigationSource/callbacks.d.ts

@@ -0,0 +1,9 @@
+import { BuiltinGlobalCallback } from '@plitzi/sdk-shared/authoring/builder';
+/**
+ * Navigation's one action.
+ *
+ * `url` is the param whose control depends on the one above it: a page is picked from the space's own pages, and
+ * anything else is typed. The list of pages is the editor's to supply — it is a fact about the space being edited,
+ * not about the action — so the source adds it to what is declared here.
+ */
+export declare const navigationCallbacks: Record<string, BuiltinGlobalCallback>;

package/dist/sources/NavigationSource/callbacks.mjs

@@ -0,0 +1,30 @@
+//#region src/sources/NavigationSource/callbacks.ts
+var e = { navigate: {
+	source: "navigation",
+	title: "Navigate",
+	strictParams: !0,
+	params: {
+		urlType: {
+			type: "select",
+			description: "Target kind: a space page, an internal space path, or an external URL.",
+			options: [
+				"page",
+				"internal",
+				"external"
+			],
+			optionLabels: {
+				page: "Space Page",
+				internal: "Inside Space",
+				external: "Outside Space"
+			}
+		},
+		url: {
+			type: "text",
+			description: "Destination — a page id when urlType is \"page\", otherwise a URL/path.",
+			when: (e) => !!e.urlType,
+			builderType: (e) => e.urlType === "page" ? "select" : "text"
+		}
+	}
+} };
+//#endregion
+export { e as navigationCallbacks };

package/dist/sources/StateSource/StateInteractions.mjs

@@ -1,70 +1,75 @@
 import e from "../../InteractionsContext.mjs";
-import { use as t, useCallback as n, useMemo as r } from "react";
-import { useCommonStoreSetter as i } from "@plitzi/sdk-shared/store";
+import { stateCallbacks as t } from "./callbacks.mjs";
+import { use as n, useCallback as r, useMemo as i } from "react";
+import { useCommonStoreSetter as a } from "@plitzi/sdk-shared/store";
+import { toInteractionCallbacks as o } from "@plitzi/sdk-shared/authoring/builder";
 //#region src/sources/StateSource/StateInteractions.tsx
-var a = ({ children: a }) => {
-	let { useInteractions: o } = t(e), s = i(), c = n((e) => {
+var s = 0, c = () => typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `e${++s}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`, l = ({ children: s }) => {
+	let { useInteractions: l } = n(e), u = a(), d = r((e) => {
 		let { key: t, type: n } = e, { value: r } = e;
-		n === "boolean" ? r = r === "true" : n === "number" && (r = parseInt(r, 10)), s(`runtime.state.${t}`, r);
-	}, [s]), l = n(() => {
-		s("runtime.state", {});
-	}, [s]);
-	return o({
+		n === "boolean" ? r = r === !0 || r === "true" : n === "number" && (r = parseInt(r, 10)), u(`runtime.state.${t}`, r);
+	}, [u]), f = r((e) => {
+		let { key: t } = e;
+		t && u(`runtime.state.${t}`, (e) => e !== !0 && e !== "true");
+	}, [u]), p = (e) => e === !0 || e === "true", m = r((e) => {
+		let { key: t, value: n, unique: r, withId: i } = e;
+		t && u(`runtime.state.${t}`, (e) => {
+			let t = Array.isArray(e) ? e : [];
+			return p(i) ? [...t, {
+				id: c(),
+				value: n
+			}] : p(r) && t.includes(n) ? t : [...t, n];
+		});
+	}, [u]), h = r((e) => {
+		let { key: t, index: n, value: r, by: i } = e;
+		if (!t) return;
+		if (r !== void 0 && r !== "") {
+			u(`runtime.state.${t}`, (e) => Array.isArray(e) ? e.filter((e) => i ? e?.[i] !== r : e !== r) : []);
+			return;
+		}
+		let a = typeof n == "number" ? n : parseInt(n ?? "", 10);
+		Number.isNaN(a) || u(`runtime.state.${t}`, (e) => Array.isArray(e) ? e.filter((e, t) => t !== a) : []);
+	}, [u]), g = r((e) => {
+		let { from: t, to: n, value: r } = e;
+		if (!t || !n || r === void 0 || r === "") return;
+		let i = { moved: !1 };
+		u(`runtime.state.${t}`, (e) => {
+			let t = Array.isArray(e) ? e : [];
+			return i.moved = t.includes(r), i.moved ? t.filter((e) => e !== r) : t;
+		}), i.moved && u(`runtime.state.${n}`, (e) => {
+			let t = Array.isArray(e) ? e : [];
+			return t.includes(r) ? t : [...t, r];
+		});
+	}, [u]), _ = r((e) => {
+		let { key: t, value: n } = e;
+		t && n !== void 0 && n !== "" && u(`runtime.state.${t}`, (e) => {
+			let t = Array.isArray(e) ? e : [];
+			return t.includes(n) ? t.filter((e) => e !== n) : [...t, n];
+		});
+	}, [u]), v = r((e) => {
+		let { key: t } = e;
+		u(t ? `runtime.state.${t}` : "runtime.state", t ? [] : {});
+	}, [u]);
+	return l({
 		id: "state",
-		callbacks: r(() => ({
-			setState: {
-				action: "setState",
-				title: "Set State",
-				type: "globalCallback",
-				callback: c,
-				preview: {},
-				params: {
-					key: {
-						defaultValue: "",
-						type: "text"
-					},
-					type: {
-						defaultValue: void 0,
-						type: "select",
-						options: [
-							{
-								value: "boolean",
-								label: "True / False"
-							},
-							{
-								value: "number",
-								label: "Numeric"
-							},
-							{
-								value: "text",
-								label: "Text"
-							}
-						]
-					},
-					value: {
-						defaultValue: void 0,
-						type: (e) => e.type === "boolean" ? "select" : "text",
-						when: (e) => !!e.type,
-						options: [{
-							value: "true",
-							label: "True"
-						}, {
-							value: "false",
-							label: "False"
-						}]
-					}
-				}
-			},
-			clearState: {
-				action: "clearState",
-				title: "Clear State",
-				type: "globalCallback",
-				callback: l,
-				preview: {},
-				params: {}
-			}
-		}), [c, l])
-	}), a;
+		callbacks: i(() => o(t, {
+			setState: d,
+			toggleState: f,
+			appendState: m,
+			removeState: h,
+			moveState: g,
+			toggleInState: _,
+			clearState: v
+		}), [
+			d,
+			f,
+			m,
+			h,
+			g,
+			_,
+			v
+		])
+	}), s;
 };
 //#endregion
-export { a as default };
+export { l as default };

package/dist/sources/StateSource/callbacks.d.ts

@@ -0,0 +1,3 @@
+import { BuiltinGlobalCallback } from '@plitzi/sdk-shared/authoring/builder';
+/** What this source's actions are, for the editor that fills them in and for anything authoring one offline. */
+export declare const stateCallbacks: Record<string, BuiltinGlobalCallback>;

package/dist/sources/StateSource/callbacks.mjs

@@ -0,0 +1,151 @@
+//#region src/sources/StateSource/callbacks.ts
+var e = {
+	setState: {
+		source: "state",
+		title: "Set State",
+		strictParams: !0,
+		params: {
+			key: {
+				type: "text",
+				description: "The state key/path to set. Stored under `runtime.state.<key>`.",
+				default: ""
+			},
+			type: {
+				type: "select",
+				description: "The value type. What is stored is coerced to it — a boolean is a real boolean, not \"true\".",
+				options: [
+					"boolean",
+					"number",
+					"text"
+				],
+				optionLabels: {
+					boolean: "True / False",
+					number: "Numeric",
+					text: "Text"
+				}
+			},
+			value: {
+				type: "scalar",
+				description: "The value to store — its type follows the `type` param (a real boolean/number, or text).",
+				when: (e) => !!e.type,
+				builderType: (e) => e.type === "boolean" ? "select" : "text",
+				options: ["true", "false"]
+			}
+		}
+	},
+	toggleState: {
+		source: "state",
+		title: "Toggle State",
+		strictParams: !0,
+		params: { key: {
+			type: "text",
+			description: "The state key/path to flip, under `runtime.state.<key>`. Anything not already true is treated as false, so a key that has never been set toggles to true.",
+			default: ""
+		} }
+	},
+	appendState: {
+		source: "state",
+		title: "Append To State",
+		strictParams: !0,
+		params: {
+			key: {
+				type: "text",
+				description: "The state key/path holding the list, under `runtime.state.<key>`. Created if it is not there.",
+				default: ""
+			},
+			value: {
+				type: "scalar",
+				description: "What to add to the end of the list.",
+				default: ""
+			},
+			unique: {
+				type: "boolean",
+				description: "Skip the append when the list already holds this value. For a list whose entries are their own identity — anything referring to one refers to it by value, so a second copy is indistinguishable.",
+				default: !1
+			},
+			withId: {
+				type: "boolean",
+				description: "Store the entry as `{ id, value }` with an id of its own, so two entries that read the same are still two entries. Anything reading one back names `.value`; anything referring to one names `.id`.",
+				default: !1
+			}
+		}
+	},
+	removeState: {
+		source: "state",
+		title: "Remove From State",
+		strictParams: !0,
+		params: {
+			key: {
+				type: "text",
+				description: "The state key/path holding the list, under `runtime.state.<key>`.",
+				default: ""
+			},
+			value: {
+				type: "scalar",
+				description: "The entry to drop, by value — every copy of it. Prefer this wherever the list can change under the person: a position is only true until something before it moves.",
+				default: ""
+			},
+			by: {
+				type: "text",
+				description: "The FIELD carrying the identity, for a list of records rather than of scalars — `id` for entries appended with `withId`. Without it the whole entry is compared, which never matches a record.",
+				default: ""
+			},
+			index: {
+				type: "text",
+				description: "Which entry to drop, by position, when there is no value to go on. Inside a controlled list, `{{ <listSource>.index }}` is the row own position. An index that resolves to nothing removes nothing.",
+				default: ""
+			}
+		}
+	},
+	moveState: {
+		source: "state",
+		title: "Move Between Lists",
+		strictParams: !0,
+		params: {
+			from: {
+				type: "text",
+				description: "The list to take it out of, under `runtime.state.<key>`.",
+				default: ""
+			},
+			to: {
+				type: "text",
+				description: "The list to put it into. It is not added twice.",
+				default: ""
+			},
+			value: {
+				type: "scalar",
+				description: "The entry to move. Absent from `from` means nothing happens.",
+				default: ""
+			}
+		}
+	},
+	toggleInState: {
+		source: "state",
+		title: "Toggle In List",
+		strictParams: !0,
+		params: {
+			key: {
+				type: "text",
+				description: "The list to add to or drop from, under `runtime.state.<key>`.",
+				default: ""
+			},
+			value: {
+				type: "scalar",
+				description: "The entry the box stands for.",
+				default: ""
+			}
+		}
+	},
+	clearState: {
+		source: "state",
+		title: "Clear State",
+		strictParams: !0,
+		params: { key: {
+			type: "text",
+			description: "The list to empty, under `runtime.state.<key>`. Left blank it empties EVERYTHING the space is keeping — which on a page that holds notes beside a list means losing the notes to clear the list.",
+			default: ""
+		} }
+	}
+};
+//#endregion
+export { e as stateCallbacks };

package/dist/sources/index.d.ts

@@ -1,7 +1,11 @@
+import { ActionInteractions } from './ActionsSource';
 import { AuthInteractions } from './AuthSource';
+import { HostInteractions } from './HostSource';
 import { NavigationInteractions } from './NavigationSource';
 import { StateInteractions } from './StateSource';
+export * from './ActionsSource';
 export * from './AuthSource';
+export * from './HostSource';
 export * from './NavigationSource';
 export * from './StateSource';
-export { AuthInteractions, NavigationInteractions, StateInteractions };
+export { ActionInteractions, AuthInteractions, HostInteractions, NavigationInteractions, StateInteractions };

package/dist/sources/index.mjs

@@ -1,4 +1,7 @@
-import e from "./AuthSource/AuthInteractions.mjs";
-import t from "./NavigationSource/NavigationInteractions.mjs";
-import n from "./StateSource/StateInteractions.mjs";
-export { e as AuthInteractions, t as NavigationInteractions, n as StateInteractions };
+import e from "./ActionsSource/ActionInteractions.mjs";
+import t from "./AuthSource/AuthInteractions.mjs";
+import n from "./HostSource/callbacks.mjs";
+import r from "./HostSource/HostInteractions.mjs";
+import i from "./NavigationSource/NavigationInteractions.mjs";
+import a from "./StateSource/StateInteractions.mjs";
+export { e as ActionInteractions, t as AuthInteractions, r as HostInteractions, i as NavigationInteractions, a as StateInteractions, n as hostCallbacks };

package/dist/utility/webHook.mjs

@@ -82,30 +82,34 @@ var e = {
 		let { url: t, authorizationToken: n, body: r, credentials: i } = e, { method: a } = e, o = {};
 		try {
 			a = a.toUpperCase();
-			let e = {};
+			let e = { "Content-Type": "application/json" };
 			n && (e.Authorization = `Bearer ${n}`), Object.values(r).forEach((t) => {
 				if (t instanceof Blob && e["Content-Type"] !== "multipart/form-data") {
 					e["Content-Type"] = "multipart/form-data";
 					return;
 				}
 			});
-			let s = new FormData();
-			Object.entries(r).forEach(([e, t]) => {
-				s?.append(e, t);
-			});
-			let c = {
+			let s = {
 				method: a,
 				headers: e,
 				credentials: i
 			};
-			(!a || a.toLowerCase() !== "get") && (c.body = s);
-			let l = await fetch(t, c), u = "";
+			if (a && !["get", "delete"].includes(a.toLowerCase())) {
+				if (e["Content-Type"] === "application/json") s.body = JSON.stringify(r);
+				else if (e["Content-Type"] === "multipart/form-data") {
+					let e = new FormData();
+					Object.entries(r).forEach(([t, n]) => {
+						e?.append(t, n);
+					}), s.body = e;
+				}
+			}
+			let c = await fetch(t, s), l = "";
 			try {
-				u = await l.json();
+				l = await c.json();
 			} catch {}
 			o = {
-				status: l.status,
-				data: u
+				status: c.status,
+				data: l
 			};
 		} catch (e) {
 			console.error(e);