@plitzi/sdk-event-bridge 0.30.19

package/dist/EventBridge.d.ts

@@ -0,0 +1,35 @@
+import { EventBridgeEvent, EventBridgeModule } from '@plitzi/sdk-shared';
+export type EventBridgeCallback<T = any> = (...data: T[]) => T | Promise<T>;
+export type EventBridgeParams<T = unknown> = {
+    filter?: (params?: T) => boolean;
+    override?: boolean;
+};
+export type Event<T = unknown> = {
+    callback: EventBridgeCallback<T>;
+    filter?: EventBridgeParams<T>['filter'];
+};
+export type EventBridgeProps<T = unknown> = {
+    events?: Record<EventBridgeModule, Record<EventBridgeEvent, Event<T>[]>>;
+    debugMode?: boolean;
+};
+type EventBridgeUpdateListener = (events: Record<EventBridgeEvent, unknown>) => void;
+declare class EventBridge<T = unknown> {
+    debugMode: boolean;
+    events: Partial<Record<EventBridgeModule, Partial<Record<EventBridgeEvent, Event<T>[]>>>>;
+    private listeners;
+    constructor({ events, debugMode }?: EventBridgeProps<T> | undefined);
+    has(module: EventBridgeModule, event: EventBridgeEvent): Event<T>[] | undefined;
+    on(module: EventBridgeModule, event: EventBridgeEvent, callback?: EventBridgeCallback<T>, params?: EventBridgeParams<T>): void;
+    get(module: EventBridgeModule, event: EventBridgeEvent): Event<T>[] | undefined;
+    off(module: EventBridgeModule, event: EventBridgeEvent, callback?: EventBridgeCallback<T>): void;
+    emit(module: EventBridgeModule, events?: EventBridgeEvent[] | EventBridgeEvent, ...data: T[]): Promise<Awaited<T>[]>;
+    emitWithResponse(module: EventBridgeModule, event: EventBridgeEvent, ...data: T[]): Promise<T | Awaited<T>[] | undefined>;
+    once(module: EventBridgeModule, event: EventBridgeEvent, callback: EventBridgeCallback<T>, filter?: Event<T>['filter']): void;
+    clear(module?: EventBridgeModule): void;
+    getEvents(module?: EventBridgeModule): Partial<Record<EventBridgeEvent, Event<T>[]>> | Partial<Record<EventBridgeModule, Partial<Record<EventBridgeEvent, Event<T>[]>>>>;
+    getModuleEventsNames(module: EventBridgeModule): string[];
+    getModuleEventsCount(module: EventBridgeModule): number;
+    listen(events: EventBridgeEvent[] | EventBridgeEvent, listener: EventBridgeUpdateListener): () => void;
+    private touch;
+}
+export default EventBridge;

package/dist/EventBridge.mjs

@@ -0,0 +1,101 @@
+import { pConsole as e } from "@plitzi/sdk-shared/devTools/utils/PlitziConsole";
+//#region src/EventBridge.ts
+var t = class {
+	debugMode = !1;
+	events;
+	listeners = /* @__PURE__ */ new Map();
+	constructor({ events: e, debugMode: t = !1 } = {}) {
+		this.events = e ?? {}, this.debugMode = t;
+	}
+	has(e, t) {
+		if (!e) throw Error("Module name is required");
+		return this.events[e] && this.events[e][t];
+	}
+	on(e, t, n, r = {}) {
+		let { filter: i, override: a = !1 } = r;
+		if (!e) throw Error("Module name is required");
+		if (!n || typeof n != "function") throw Error("Callback must be a function");
+		this.events[e] || (this.events[e] = {}), (!this.events[e][t] || a && this.events[e][t].length > 0) && (this.events[e][t] = []), this.events[e][t].push({
+			callback: n,
+			filter: i
+		});
+	}
+	get(e, t) {
+		return this.has(e, t) ? this.events[e]?.[t] : [];
+	}
+	off(e, t, n) {
+		!this.has(e, t) || !this.events[e] || (n ? this.events[e][t] = this.events[e][t]?.filter((e) => e.callback !== n) : this.events[e][t] = [], this.events[e][t]?.length === 0 && delete this.events[e][t], Object.keys(this.events[e]).length === 0 && delete this.events[e]);
+	}
+	async emit(t, n = [], ...r) {
+		this.debugMode && e.info("eventBridge", "Event Triggered", {
+			module: t,
+			events: n,
+			data: r
+		});
+		let i;
+		i = Array.isArray(n) ? n : [n];
+		let a = [];
+		i.forEach((e) => {
+			if (!this.has(t, e)) return;
+			let n = this.get(t, e);
+			n && n.forEach((e) => {
+				let { callback: t, filter: n } = e;
+				(!n || typeof n != "function" || n(...r)) && a.push(t(...r));
+			});
+		});
+		let o = await Promise.all(a);
+		return this.touch(i.reduce((e, t) => ({
+			...e,
+			[t]: r
+		}), {})), o;
+	}
+	async emitWithResponse(e, t, ...n) {
+		if (!this.has(e, t)) return;
+		let r = this.get(e, t);
+		if (!r) return;
+		let i = await Promise.all(r.filter((e) => !e.filter || e.filter(...n)).map((e) => e.callback(...n)));
+		return i.length === 1 ? i[0] : i;
+	}
+	once(e, t, n, r) {
+		if (!e) throw Error("Module name is required");
+		let i = async (r) => {
+			await n(r), this.off(e, t, i);
+		};
+		this.on(e, t, i, { filter: r });
+	}
+	clear(e) {
+		if (!e) {
+			this.events = {};
+			return;
+		}
+		this.events[e] && delete this.events[e];
+	}
+	getEvents(e) {
+		return e ? this.events[e] ? this.events[e] : {} : this.events;
+	}
+	getModuleEventsNames(e) {
+		return !e || !this.events[e] ? [] : Object.keys(this.events[e]);
+	}
+	getModuleEventsCount(e) {
+		return this.getModuleEventsNames(e).length;
+	}
+	listen(e, t) {
+		let n = Array.isArray(e) ? e : [e];
+		return n.forEach((e) => {
+			this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e)?.add(t);
+		}), () => {
+			n.forEach((e) => {
+				let n = this.listeners.get(e);
+				n && (n.delete(t), n.size === 0 && this.listeners.delete(e));
+			});
+		};
+	}
+	touch(e) {
+		for (let t in e) {
+			let n = this.listeners.get(t);
+			if (n) for (let t of n) t(e);
+		}
+	}
+};
+//#endregion
+export { t as default };

package/dist/EventBridgeContext.d.ts

@@ -0,0 +1,5 @@
+import { default as EventBridge } from './EventBridge';
+import { EventBridgeContextValue as EventBridgeContextValueShared } from '@plitzi/sdk-shared';
+export type EventBridgeContextValue<T = unknown> = EventBridgeContextValueShared<InstanceType<typeof EventBridge<T>>>;
+declare const EventBridgeContext: import('react').Context<EventBridgeContextValue<unknown>>;
+export default EventBridgeContext;

package/dist/EventBridgeContext.mjs

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

package/dist/EventBridgeContextProvider.d.ts

@@ -0,0 +1,9 @@
+import { EventBridgeContextValue } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type EventBridgeContextProviderProps = {
+    children?: ReactNode;
+    debugMode: boolean;
+    onInit?: (instance: EventBridgeContextValue) => void;
+};
+declare const EventBridgeContextProvider: ({ children, debugMode, onInit }: EventBridgeContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default EventBridgeContextProvider;

package/dist/EventBridgeContextProvider.mjs

@@ -0,0 +1,20 @@
+import e from "./EventBridge.mjs";
+import t from "./EventBridgeContext.mjs";
+import { useEffect as n, useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/EventBridgeContextProvider.tsx
+var a = ({ children: a, debugMode: o, onInit: s }) => {
+	let c = r(() => new e({ debugMode: o }), [o]);
+	n(() => () => {
+		c.clear();
+	}, [c]);
+	let l = r(() => ({ eventBridge: c }), [c]);
+	return n(() => {
+		s?.(l);
+	}, [s, l]), /* @__PURE__ */ i(t, {
+		value: l,
+		children: a
+	});
+};
+//#endregion
+export { a as default };

package/dist/EventBridgeHelper.d.ts

@@ -0,0 +1,3 @@
+import { EventBridgeEvent, EventBridgeModule } from '@plitzi/sdk-shared';
+declare const EventBridgeTypesPerModule: Record<EventBridgeModule, EventBridgeEvent[]>;
+export { EventBridgeTypesPerModule };

package/dist/EventBridgeHelper.mjs

@@ -0,0 +1,15 @@
+//#region src/EventBridgeHelper.ts
+var e = {
+	main: /* @__PURE__ */ "schemaAddPage.schemaHomePage.schemaUpdatePage.schemaRemovePage.schemaAddPageFolder.schemaUpdatePageFolder.schemaRemovePageFolder.schemaUpdateSettings.schemaUpdate.schemaAddElement.schemaUpdateElement.schemaRemoveElement.schemaMoveElement.schemaCloneElement.schemaAddVariable.schemaUpdateVariable.schemaRemoveVariable.schemaAddTemplate.styleUpdate.styleAddSelector.styleUpdateSelector.styleRemoveSelector.styleAddSelectorVariable.styleUpdateSelectorVariable.styleRemoveSelectorVariable.styleAddVariable.styleUpdateVariable.styleRemoveVariable.styleAddTemplate.styleUpdateSettings".split("."),
+	builder: [
+		"builderSetBaseContext",
+		"builderSetSelected",
+		"builderSetHovered"
+	],
+	segment: [],
+	template: [],
+	interaction: [],
+	element: []
+};
+//#endregion
+export { e as EventBridgeTypesPerModule };

package/dist/hooks/useEventBridge.d.ts

@@ -0,0 +1,4 @@
+import { EventBridgeCallback, EventBridgeParams, default as EventBridge } from '../EventBridge';
+import { EventBridgeEvent, EventBridgeModule } from '@plitzi/sdk-shared';
+declare const useEventBridge: (module: EventBridgeModule, callbacks?: Partial<Record<EventBridgeEvent, EventBridgeCallback>>, params?: EventBridgeParams, context?: import('react').Context<import('..').EventBridgeContextValue<unknown>>, disabled?: boolean) => EventBridge<unknown>;
+export default useEventBridge;

package/dist/hooks/useEventBridge.mjs

@@ -0,0 +1,22 @@
+import e from "../EventBridgeContext.mjs";
+import { use as t, useEffect as n } from "react";
+//#region src/hooks/useEventBridge.ts
+var r = (r, i = {}, a = {}, o = e, s = !1) => {
+	let { eventBridge: c } = t(o);
+	return n(() => {
+		if (s || !c || !r) return;
+		let e = Object.entries(i);
+		for (let [t, n] of e) typeof n == "function" && c.on(r, t, n, a);
+		return () => {
+			for (let [t, n] of e) typeof n == "function" && c.off(r, t, n);
+		};
+	}, [
+		r,
+		i,
+		c,
+		a,
+		s
+	]), c;
+};
+//#endregion
+export { r as default };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { default as EventBridge } from './EventBridge';
+import { default as EventBridgeContext } from './EventBridgeContext';
+import { default as EventBridgeContextProvider } from './EventBridgeContextProvider';
+import { default as useEventBridge } from './hooks/useEventBridge';
+export * from './EventBridge';
+export * from './EventBridgeContext';
+export * from './EventBridgeContextProvider';
+export * from './EventBridgeHelper';
+export * from './hooks/useEventBridge';
+export { EventBridge, EventBridgeContext, EventBridgeContextProvider, useEventBridge };
+export default EventBridge;

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import e from "./EventBridge.mjs";
+import t from "./EventBridgeContext.mjs";
+import n from "./EventBridgeContextProvider.mjs";
+import r from "./hooks/useEventBridge.mjs";
+import { EventBridgeTypesPerModule as i } from "./EventBridgeHelper.mjs";
+//#region src/index.ts
+var a = e;
+//#endregion
+export { e as EventBridge, t as EventBridgeContext, n as EventBridgeContextProvider, i as EventBridgeTypesPerModule, a as default, r as useEventBridge };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@plitzi/sdk-event-bridge",
+  "version": "0.30.19",
+  "license": "AGPL-3.0",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./EventBridge": {
+      "types": "./dist/EventBridge.d.ts",
+      "import": "./dist/EventBridge.mjs"
+    },
+    "./EventBridgeContext": {
+      "types": "./dist/EventBridgeContext.d.ts",
+      "import": "./dist/EventBridgeContext.mjs"
+    },
+    "./EventBridgeContextProvider": {
+      "types": "./dist/EventBridgeContextProvider.d.ts",
+      "import": "./dist/EventBridgeContextProvider.mjs"
+    },
+    "./EventBridgeHelper": {
+      "types": "./dist/EventBridgeHelper.d.ts",
+      "import": "./dist/EventBridgeHelper.mjs"
+    },
+    "./hooks/useEventBridge": {
+      "types": "./dist/hooks/useEventBridge.d.ts",
+      "import": "./dist/hooks/useEventBridge.mjs"
+    },
+    "./index": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "lint": "eslint ./src",
+    "typecheck": "tsc -p tsconfig.app.json --noEmit",
+    "build:dev": "vite build --mode development --minify false && node ../sdk-shared/scripts/generate-exports.mjs",
+    "build:dev-watch": "vite build --mode development --watch --minify false",
+    "build:prod": "vite build && node ../sdk-shared/scripts/generate-exports.mjs"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "dependencies": {
+    "@plitzi/sdk-shared": "0.30.19",
+    "prop-types": "^15.8.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.4",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.10"
+  }
+}