@plitzi/sdk-interactions 0.30.19

package/dist/InteractionsContext.d.ts

@@ -0,0 +1,5 @@
+import { default as InteractionsManager } from './InteractionsManager';
+import { InteractionsContextValue as InteractionsContextValueShared } from '@plitzi/sdk-shared';
+export type InteractionsContextValue = InteractionsContextValueShared<InstanceType<typeof InteractionsManager>>;
+declare const InteractionsContext: import('react').Context<InteractionsContextValue>;
+export default InteractionsContext;

package/dist/InteractionsContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+var t = e({});
+t.displayName = "InteractionsContext";
+//#endregion
+export { t as default };

package/dist/InteractionsContextProvider.d.ts

@@ -0,0 +1,10 @@
+import { QueryParams, RouteParams } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type InteractionsContextProviderProps = {
+    children?: ReactNode;
+    currentPageId: string;
+    routeParams: RouteParams;
+    queryParams: QueryParams;
+};
+declare const InteractionsContextProvider: ({ children, currentPageId, routeParams, queryParams }: InteractionsContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default InteractionsContextProvider;

package/dist/InteractionsContextProvider.mjs

@@ -0,0 +1,26 @@
+import e from "./InteractionsContext.mjs";
+import t from "./hooks/useInteractions.mjs";
+import n from "./InteractionsManager.mjs";
+import { useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/InteractionsContextProvider.tsx
+var a = ({ children: a, currentPageId: o, routeParams: s, queryParams: c }) => {
+	let l = r(() => new n(o, s, c), []);
+	return l.interactionsData = r(() => ({
+		currentPageId: o,
+		...s,
+		...c
+	}), [
+		o,
+		s,
+		c
+	]), /* @__PURE__ */ i(e, {
+		value: r(() => ({
+			interactionsManager: l,
+			useInteractions: t
+		}), [l]),
+		children: a
+	});
+};
+//#endregion
+export { a as default };

package/dist/InteractionsHelper.d.ts

@@ -0,0 +1,7 @@
+import { ElementInteraction } from '@plitzi/sdk-shared';
+declare const flowTrigger: (triggerNode: ElementInteraction, nodes?: {}, callbacksAvailables?: {}, flowParams?: Record<string, unknown>, globalParams?: {}, postCallbacksTotal?: never[]) => Promise<void>;
+export { flowTrigger };
+declare const InteractionsHelper: {
+    flowTrigger: (triggerNode: ElementInteraction, nodes?: {}, callbacksAvailables?: {}, flowParams?: Record<string, unknown>, globalParams?: {}, postCallbacksTotal?: never[]) => Promise<void>;
+};
+export default InteractionsHelper;

package/dist/InteractionsHelper.mjs

@@ -0,0 +1,145 @@
+import e from "./utility/index.mjs";
+import { get as t, omit as n } from "@plitzi/plitzi-ui/helpers";
+import { QueryBuilderEvaluator as r } from "@plitzi/plitzi-ui/QueryBuilder";
+import { pConsole as i } from "@plitzi/sdk-shared/devTools/utils/PlitziConsole";
+import { hasValidToken as a, processTwig as o } from "@plitzi/sdk-shared/helpers/twigWrapper";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+//#region src/InteractionsHelper.tsx
+var l = (e, t, n, r, i) => e === "utility" && i === "twigTemplate" ? t : Object.keys(t).reduce((i, s) => {
+	let c = t[s];
+	if (e !== "trigger") {
+		let e = 5;
+		for (; typeof c == "string" && a(c) && e > 0;) c = o(c, {
+			...n,
+			...r
+		}, !1, !0), e--;
+	}
+	return {
+		...i,
+		[s]: c
+	};
+}, {}), u = async (n, i = {}, a = {}, o = {}) => {
+	let s = {}, c = [], { id: u, action: d, enabled: f, params: p, elementId: m, type: h, when: g } = n;
+	if (!d || !f) return {
+		status: "disabled",
+		result: s,
+		postCallbacks: c
+	};
+	let _ = {
+		...o,
+		...a,
+		[u]: p
+	};
+	if (g && !r(g, _)) return {
+		status: "skipped",
+		result: s,
+		postCallbacks: c,
+		whenParams: _
+	};
+	let v = {
+		...a,
+		...o,
+		...l(h, p, a, o, d)
+	};
+	switch (h) {
+		case "callback":
+		case "globalCallback": {
+			if (!m) return {
+				status: "failed",
+				result: s,
+				postCallbacks: c,
+				whenParams: _
+			};
+			let e = t(i, `${m}.${d}`);
+			if (!e) return {
+				status: "failed",
+				result: s,
+				postCallbacks: c,
+				whenParams: _
+			};
+			let { callback: n, postCallback: r } = e;
+			n && (s = await n(v)), r && c.push({
+				id: u,
+				callback: r,
+				params: {
+					...v,
+					[u]: s
+				}
+			});
+			break;
+		}
+		case "utility": {
+			let { callback: n, postCallback: r } = t(e, d, {});
+			n && (s = await n(v)), r && c.push({
+				id: u,
+				callback: r,
+				params: {
+					...v,
+					[u]: s
+				}
+			});
+			break;
+		}
+		default:
+	}
+	return {
+		status: "success",
+		result: s,
+		postCallbacks: c,
+		whenParams: _
+	};
+}, d = async (e = []) => {
+	let t = {};
+	return await Promise.all(e.reverse().map(async ({ id: e, callback: r, params: i }) => {
+		t[e] = await r?.(n(i, [e]), i[e]);
+	})), t;
+}, f = async (e, n = {}, r = {}, a = {}, o = {}, s = [], c = {}) => {
+	if (!e) return c;
+	let l = t(n, e.afterNode);
+	if (!l && s.length > 0 && await d(s), !l) return c;
+	let p = i.getTime().valueOf(), { status: m, result: h, postCallbacks: g, whenParams: _ } = await u(l, r, a, o);
+	return c[l.id] = {
+		node: l,
+		status: m,
+		result: h,
+		postCallbacks: g,
+		whenParams: _,
+		startTime: p,
+		endTime: i.getTime().valueOf()
+	}, s.push(...g), f(l, n, r, {
+		...a,
+		[l.id]: h
+	}, o, s, c);
+}, p = (e, t, n = {}, r) => {
+	let a = i.getTime().valueOf(), o = "skipped";
+	r === "completed" && (o = "success"), i.info("interactions", /* @__PURE__ */ c("span", { children: ["Interaction triggered ", /* @__PURE__ */ s("b", { children: `${e.title} [${e.action}]` })] }), {
+		status: r,
+		node: e,
+		elementId: e.elementId,
+		nodes: {
+			...n,
+			[e.id]: {
+				node: e,
+				status: o,
+				result: void 0,
+				postCallbacks: [],
+				startTime: t,
+				endTime: a
+			}
+		},
+		startTime: t,
+		endTime: a
+	});
+}, m = async (e, t = {}, n = {}, a = {}, o = {}, s = []) => {
+	let c = i.getTime().valueOf(), { action: l, enabled: u, when: d } = e;
+	if (!l || !u || d && !r(d, {
+		...o,
+		...a
+	})) {
+		p(e, c, {}, "skipped");
+		return;
+	}
+	p(e, c, await f(e, t, n, a, o, s), "completed");
+}, h = { flowTrigger: m };
+//#endregion
+export { h as default, m as flowTrigger };

package/dist/InteractionsManager.d.ts

@@ -0,0 +1,31 @@
+import { default as EventBridge } from '@plitzi/sdk-event-bridge';
+import { ElementInteraction, InteractionCallback, QueryParams, RouteParams, Subscriptor } from '@plitzi/sdk-shared';
+type InteractionUpdateListener = (timestamp: number) => void;
+declare class InteractionsManager {
+    eventBridge: InstanceType<typeof EventBridge>;
+    parentManager?: InteractionsManager;
+    childManagers: InteractionsManager[];
+    interactionsData: Record<string, string | number | boolean>;
+    subscriptors: Record<string, Subscriptor>;
+    callbacksAvailables: Record<string, Record<string, InteractionCallback<any>>>;
+    interactionsRunning: Record<string, boolean>;
+    lastUpdate: number;
+    private listeners;
+    constructor(currentPageId?: string, routeParams?: RouteParams, queryParams?: QueryParams);
+    eventBridgeCallback: (interactions?: Record<string, ElementInteraction>) => (subscriptorId: string, eventName: string, params: Record<string, unknown>) => Promise<void>;
+    subscribe<TParams extends Record<string, unknown> = Record<string, unknown>>(id: string, interactions?: Record<string, ElementInteraction>, triggers?: Record<string, InteractionCallback<TParams>>, callbacks?: Record<string, InteractionCallback<TParams>>, getAdditionalParams?: Subscriptor<TParams>['getAdditionalParams']): boolean;
+    unsubscribe(id: string): boolean;
+    getRootManager(): this | undefined;
+    private getSubscriptorInternal;
+    getSubscriptor(subscriptorId: string): Subscriptor | undefined;
+    private getCallbacksAvailablesInternal;
+    getCallbacksAvailables(): {
+        [x: string]: Record<string, InteractionCallback> | Record<string, InteractionCallback<any>>;
+    };
+    interactionTrigger(subscriptorId: string, eventName: string, params?: Record<string, unknown>): Promise<unknown[]>;
+    createChildManager: (routeParams?: Record<string, string>, queryParams?: Record<string, string>) => InteractionsManager;
+    removeChildManager: (childManager: InteractionsManager) => void;
+    onUpdate(listener: InteractionUpdateListener): () => void;
+    private touch;
+}
+export default InteractionsManager;

package/dist/InteractionsManager.mjs

@@ -0,0 +1,110 @@
+import { flowTrigger as e } from "./InteractionsHelper.mjs";
+import { get as t, set as n } from "@plitzi/plitzi-ui/helpers";
+import r from "@plitzi/sdk-event-bridge";
+//#region src/InteractionsManager.ts
+var i = class i {
+	eventBridge;
+	parentManager;
+	childManagers;
+	interactionsData;
+	subscriptors;
+	callbacksAvailables;
+	interactionsRunning;
+	lastUpdate;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(e = "", t = {}, n = {}) {
+		this.eventBridge = new r(), this.parentManager = void 0, this.childManagers = [], this.subscriptors = {}, this.callbacksAvailables = {}, this.interactionsRunning = {}, this.interactionsData = {
+			currentPageId: e,
+			...t,
+			...n
+		}, this.lastUpdate = Date.now();
+	}
+	eventBridgeCallback = (r) => async (i, a, o) => {
+		if (!r || !a || !i || t(this.interactionsRunning, `${i}.${a}`)) return;
+		n(this.interactionsRunning, `${i}.${a}`, !0);
+		let s = t(this.subscriptors, `${i}.getAdditionalParams`, void 0), c;
+		typeof s == "function" && ({dataSource: c} = s());
+		let l = Object.values(r).filter((e) => e.type === "trigger" && e.action === a && e.enabled);
+		await Promise.all(l.map((t) => e(t, r, this.getCallbacksAvailables(), { [t.id]: o }, {
+			...this.interactionsData,
+			...c
+		}))), n(this.interactionsRunning, `${i}.${a}`, !1);
+	};
+	subscribe(e, t = {}, r = {}, i = {}, a) {
+		if (this.subscriptors[e]) return !1;
+		n(this.subscriptors, e, {
+			id: e,
+			triggers: r,
+			getAdditionalParams: a
+		});
+		let o = Object.keys(i);
+		return o.length > 0 && (this.callbacksAvailables[e] = o.reduce((t, n) => {
+			let { title: r, callback: a, postCallback: o, params: s, preview: c, type: l } = i[n];
+			return typeof a == "function" ? {
+				...t,
+				[n]: {
+					elementId: e,
+					title: r,
+					action: n,
+					type: l,
+					callback: a,
+					postCallback: o,
+					params: s,
+					preview: c
+				}
+			} : t;
+		}, {})), Object.keys(r).length > 0 && this.eventBridge.on("interaction", e, this.eventBridgeCallback(t), { override: !0 }), this.touch(), !0;
+	}
+	unsubscribe(e) {
+		return this.subscriptors[e] ? (this.eventBridge.off("interaction", e), delete this.subscriptors[e], this.callbacksAvailables[e] && delete this.callbacksAvailables[e], this.touch(), !0) : !1;
+	}
+	getRootManager() {
+		return this.parentManager ? this.parentManager.getRootManager() : this;
+	}
+	getSubscriptorInternal(e) {
+		let n = t(this.subscriptors, e);
+		if (!n && this.childManagers.length > 0) {
+			for (let t of this.childManagers) if (n = t.getSubscriptorInternal(e), n) break;
+		}
+		return n;
+	}
+	getSubscriptor(e) {
+		return this.parentManager ? this.getRootManager()?.getSubscriptorInternal(e) : this.getSubscriptorInternal(e);
+	}
+	getCallbacksAvailablesInternal() {
+		let e = {};
+		if (this.childManagers.length > 0) for (let t of this.childManagers) e = {
+			...e,
+			...t.getCallbacksAvailablesInternal()
+		};
+		return {
+			...e,
+			...this.callbacksAvailables
+		};
+	}
+	getCallbacksAvailables() {
+		return this.parentManager ? this.getRootManager()?.getCallbacksAvailablesInternal() ?? {} : this.getCallbacksAvailablesInternal();
+	}
+	interactionTrigger(e, t, n = {}) {
+		return this.eventBridge.emit("interaction", e, e, t, n);
+	}
+	createChildManager = (e = {}, t = {}) => {
+		let n = new i(this.interactionsData.currentPageId, e, t);
+		return n.parentManager = this, this.childManagers.push(n), n;
+	};
+	removeChildManager = (e) => {
+		this.childManagers = this.childManagers.filter((t) => t !== e);
+	};
+	onUpdate(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	touch() {
+		let e = Date.now();
+		this.lastUpdate = e;
+		for (let t of this.listeners) t(e);
+	}
+};
+//#endregion
+export { i as default };

package/dist/hooks/useInteractions.d.ts

@@ -0,0 +1,10 @@
+import { ElementInteraction, InteractionCallback, Subscriptor } from '@plitzi/sdk-shared';
+export type UseInteractionsProps<TParams extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    interactions?: Record<string, ElementInteraction>;
+    triggers?: Record<string, InteractionCallback<TParams>>;
+    callbacks?: Record<string, InteractionCallback<TParams>>;
+    getAdditionalParams?: Subscriptor<TParams>['getAdditionalParams'];
+};
+declare const useInteractions: <TParams extends Record<string, unknown> = Record<string, unknown>>({ id, interactions, triggers, callbacks, getAdditionalParams }: UseInteractionsProps<TParams>) => void;
+export default useInteractions;

package/dist/hooks/useInteractions.mjs

@@ -0,0 +1,18 @@
+import e from "../InteractionsContext.mjs";
+import { use as t, useEffect as n } from "react";
+//#region src/hooks/useInteractions.ts
+var r = ({ id: r, interactions: i, triggers: a, callbacks: o, getAdditionalParams: s }) => {
+	let { interactionsManager: c } = t(e);
+	n(() => (c.subscribe(r, i, a, o, s), () => {
+		c.unsubscribe(r);
+	}), [
+		r,
+		i,
+		a,
+		o,
+		s,
+		c
+	]);
+};
+//#endregion
+export { r as default };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { default as useInteractions } from './hooks/useInteractions';
+import { default as InteractionsContext } from './InteractionsContext';
+import { default as InteractionsContextProvider } from './InteractionsContextProvider';
+import { default as InteractionsHelper } from './InteractionsHelper';
+import { default as InteractionsManager } from './InteractionsManager';
+import { AuthInteractions } from './sources';
+import { default as utility } from './utility';
+export * from './utility';
+export * from './InteractionsContext';
+export * from './InteractionsContextProvider';
+export * from './InteractionsHelper';
+export * from './hooks/useInteractions';
+export * from './sources';
+export * from './InteractionsManager';
+export { InteractionsManager, utility, InteractionsContext, InteractionsContextProvider, InteractionsHelper, useInteractions, AuthInteractions };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import e from "./InteractionsContext.mjs";
+import t from "./hooks/useInteractions.mjs";
+import n from "./utility/index.mjs";
+import r, { flowTrigger as i } from "./InteractionsHelper.mjs";
+import a from "./InteractionsManager.mjs";
+import o from "./InteractionsContextProvider.mjs";
+import s from "./sources/AuthSource/AuthInteractions.mjs";
+export { s as AuthInteractions, e as InteractionsContext, o as InteractionsContextProvider, r as InteractionsHelper, a as InteractionsManager, i as flowTrigger, t as useInteractions, n as utility };

package/dist/sources/AuthSource/AuthInteractions.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type AuthInteractionsProps = {
+    children?: ReactNode;
+    authProvider?: '' | 'auth0' | 'basic' | 'custom';
+};
+declare const AuthInteractions: ({ children, authProvider }: AuthInteractionsProps) => ReactNode;
+export default AuthInteractions;

package/dist/sources/AuthSource/AuthInteractions.mjs

@@ -0,0 +1,119 @@
+import e from "../../InteractionsContext.mjs";
+import { use as t, useCallback as n, useMemo as r } from "react";
+import { AuthContext as i } from "@plitzi/sdk-auth";
+//#region src/sources/AuthSource/AuthInteractions.tsx
+var a = ({ children: a, authProvider: o = "basic" }) => {
+	let { login: s, refresh: c, logout: l } = t(i), { useInteractions: u } = t(e), d = n((e) => s(e), [s]), f = n((e) => c(e), [c]), p = n(() => l(), [l]);
+	return u({
+		id: "auth",
+		callbacks: r(() => {
+			let e = {};
+			return o === "auth0" ? e = {
+				login: {
+					action: "authLogin",
+					title: "Auth Login",
+					type: "globalCallback",
+					callback: d,
+					params: {}
+				},
+				logout: {
+					action: "authLogout",
+					title: "Auth Logout",
+					type: "globalCallback",
+					callback: p,
+					params: {}
+				}
+			} : o === "basic" && (e = {
+				login: {
+					action: "authLogin",
+					title: "Auth Login",
+					type: "globalCallback",
+					callback: d,
+					params: {
+						mode: {
+							label: "Mode",
+							canBind: !1,
+							type: "select",
+							defaultValue: "normal",
+							options: [{
+								label: "Token",
+								value: "token"
+							}, {
+								label: "User and Password",
+								value: "normal"
+							}]
+						},
+						username: {
+							type: "text",
+							defaultValue: "",
+							when: (e) => e.mode === "normal"
+						},
+						password: {
+							type: "text",
+							defaultValue: "",
+							when: (e) => e.mode === "normal"
+						},
+						token: {
+							type: "text",
+							defaultValue: "",
+							when: (e) => e.mode === "token"
+						}
+					},
+					preview: {
+						errors: {
+							username: "",
+							password: "",
+							token: ""
+						},
+						success: "",
+						access_token: "",
+						expires_at: "",
+						details: {
+							id: "",
+							username: "",
+							email: "",
+							verified: "",
+							permissions: ""
+						}
+					}
+				},
+				refreshDetails: {
+					action: "authRefreshDetails",
+					title: "Auth Refresh Details",
+					type: "globalCallback",
+					callback: f,
+					params: {},
+					preview: {
+						errors: "",
+						success: "",
+						access_token: "",
+						expires_at: "",
+						details: {
+							id: "",
+							username: "",
+							email: "",
+							roles: "",
+							permissions: "",
+							verified: ""
+						}
+					}
+				},
+				logout: {
+					action: "authLogout",
+					title: "Auth Logout",
+					type: "globalCallback",
+					callback: p,
+					preview: {},
+					params: {}
+				}
+			}), e;
+		}, [
+			d,
+			p,
+			f,
+			o
+		])
+	}), a;
+};
+//#endregion
+export { a as default };

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

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

package/dist/sources/AuthSource/index.mjs

@@ -0,0 +1,2 @@
+import e from "./AuthInteractions.mjs";
+export { e as AuthInteractions };

package/dist/sources/index.d.ts

@@ -0,0 +1,3 @@
+import { AuthInteractions } from './AuthSource';
+export * from './AuthSource';
+export { AuthInteractions };

package/dist/sources/index.mjs

@@ -0,0 +1,2 @@
+import e from "./AuthSource/AuthInteractions.mjs";
+export { e as AuthInteractions };

package/dist/utility/delayTime.d.ts

@@ -0,0 +1,5 @@
+import { InteractionCallback } from '@plitzi/sdk-shared';
+declare const delayTime: InteractionCallback<{
+    time: number;
+}>;
+export default delayTime;

package/dist/utility/delayTime.mjs

@@ -0,0 +1,16 @@
+//#region src/utility/delayTime.ts
+var e = {
+	action: "delayTime",
+	title: "Delay Time",
+	type: "utility",
+	params: { time: {
+		label: "Time (Milliseconds)",
+		type: "text"
+	} },
+	preview: {},
+	callback: ({ time: e }) => new Promise((t) => {
+		setTimeout(t, e);
+	})
+};
+//#endregion
+export { e as default };

package/dist/utility/index.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    delayTime: import('@plitzi/sdk-shared').InteractionCallback<{
+        time: number;
+    }>;
+    twigTemplate: import('@plitzi/sdk-shared').InteractionCallback<{
+        returnMode: "jsonObject" | "json" | "text";
+        template: string;
+    }>;
+    webHook: import('@plitzi/sdk-shared').InteractionCallback<{
+        url: string;
+        method: string;
+        body: Record<string, string | Blob>;
+        authorizationToken: string;
+        credentials: RequestCredentials;
+    }>;
+};
+export default _default;

package/dist/utility/index.mjs

@@ -0,0 +1,11 @@
+import e from "./delayTime.mjs";
+import t from "./twigTemplate.mjs";
+import n from "./webHook.mjs";
+//#region src/utility/index.ts
+var r = {
+	delayTime: e,
+	twigTemplate: t,
+	webHook: n
+};
+//#endregion
+export { r as default };

package/dist/utility/transformer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utility/twigTemplate.d.ts

@@ -0,0 +1,6 @@
+import { InteractionCallback } from '@plitzi/sdk-shared';
+declare const delayTime: InteractionCallback<{
+    returnMode: 'jsonObject' | 'json' | 'text';
+    template: string;
+}>;
+export default delayTime;