@eventusgo/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+type EventusTheme = "light" | "dark";
+type EventusUser = {
+    id: string;
+    name?: string;
+    displayName?: string;
+    avatarUrl?: string;
+    handle?: string;
+};
+type EventusContext = {
+    appId?: string;
+    locale: string;
+    theme: EventusTheme;
+    user?: EventusUser;
+};
+type EventusPermission = "user.profile.read" | "theme.read" | "storage.local";
+type EventusManifest = {
+    name: string;
+    appId: string;
+    version: string;
+    permissions?: Array<EventusPermission | string>;
+};
+type EventusRuntimeSource = "native" | "mock";
+type EventusEventMap = {
+    ready: {
+        context: EventusContext;
+        source: EventusRuntimeSource;
+    };
+    themeChange: {
+        theme: EventusTheme;
+        context: EventusContext;
+        source: EventusRuntimeSource;
+    };
+};
+type EventusEventName = keyof EventusEventMap;
+type EventusEventHandler<K extends EventusEventName> = (payload: EventusEventMap[K]) => void;
+type EventusClient = {
+    ready(): Promise<void>;
+    getContext(): Promise<EventusContext>;
+    getManifest(): EventusManifest | null;
+    request<T = unknown>(action: string, payload?: unknown): Promise<T>;
+    on<K extends EventusEventName>(event: K, handler: EventusEventHandler<K>): () => void;
+};
+type ConfigureMockEventusOptions = {
+    context?: Partial<EventusContext>;
+    manifest?: EventusManifest | null;
+    ready?: boolean;
+    reset?: boolean;
+};
+type NativeBridgeUser = Record<string, unknown>;
+type NativeBridgeRecord = Record<string, unknown>;
+type NativeEventusBridge = {
+    version?: string;
+    user?: NativeBridgeUser | null;
+    app?: NativeBridgeRecord;
+    device?: NativeBridgeRecord;
+    capabilities?: Record<string, boolean>;
+    request?<T = unknown>(action: string, payload?: unknown): Promise<T>;
+} & Record<string, unknown>;
+declare global {
+    interface Window {
+        Eventus?: NativeEventusBridge;
+    }
+}
+declare class EventusClientImpl implements EventusClient {
+    private emitter;
+    private lastReadySource;
+    private hasReadyRequest;
+    constructor();
+    ready(): Promise<void>;
+    getContext(): Promise<EventusContext>;
+    getManifest(): EventusManifest | null;
+    request<T = unknown>(action: string, payload?: unknown): Promise<T>;
+    on<K extends EventusEventName>(event: K, handler: EventusEventHandler<K>): () => void;
+    configureMock(options?: ConfigureMockEventusOptions): void;
+    private emitReady;
+    private handleBridgeReady;
+    private waitForNativeBridge;
+}
+declare const eventus: EventusClientImpl;
+declare function configureMockEventus(options?: ConfigureMockEventusOptions): void;
+
+export { type ConfigureMockEventusOptions, type EventusClient, type EventusContext, type EventusEventHandler, type EventusEventMap, type EventusEventName, type EventusManifest, type EventusPermission, type EventusRuntimeSource, type EventusTheme, type EventusUser, configureMockEventus, eventus };

package/dist/index.js

@@ -0,0 +1,235 @@
+// src/index.ts
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    const nextListeners = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    nextListeners.add(handler);
+    this.listeners.set(event, nextListeners);
+    return () => {
+      nextListeners.delete(handler);
+      if (nextListeners.size === 0) {
+        this.listeners.delete(event);
+      }
+    };
+  }
+  emit(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) {
+      return;
+    }
+    for (const handler of handlers) {
+      handler(payload);
+    }
+  }
+};
+function getBrowserLocale() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return "en";
+}
+function createDefaultMockContext() {
+  const manifest = readInjectedManifest();
+  return {
+    locale: getBrowserLocale(),
+    theme: "light",
+    ...manifest?.appId ? { appId: manifest.appId } : {},
+    user: {
+      id: "dev-user",
+      name: "Eventus Developer"
+    }
+  };
+}
+function readInjectedManifest() {
+  const manifest = globalThis.__EVENTUS_MANIFEST__;
+  if (typeof manifest === "undefined") {
+    return null;
+  }
+  return manifest ?? null;
+}
+function readWindowBridge() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.Eventus;
+}
+function readStringField(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function mapNativeUser(user) {
+  if (!user || typeof user.id !== "string" || !user.id.trim()) {
+    return void 0;
+  }
+  const displayName = typeof user.displayName === "string" ? user.displayName : void 0;
+  const name = typeof user.name === "string" ? user.name : displayName;
+  const avatarUrl = typeof user.avatarUrl === "string" ? user.avatarUrl : void 0;
+  const handle = typeof user.handle === "string" ? user.handle : void 0;
+  return {
+    id: user.id,
+    ...name ? { name } : {},
+    ...displayName ? { displayName } : {},
+    ...avatarUrl ? { avatarUrl } : {},
+    ...handle ? { handle } : {}
+  };
+}
+function mapNativeContext(bridge) {
+  const appId = readStringField(bridge.app, "slug") ?? readStringField(bridge.app, "id");
+  const locale = readStringField(bridge.device, "locale") ?? getBrowserLocale();
+  const themeValue = readStringField(bridge.device, "themeMode");
+  const theme = themeValue === "dark" ? "dark" : "light";
+  const user = mapNativeUser(bridge.user);
+  return {
+    locale,
+    theme,
+    ...appId ? { appId } : {},
+    ...user ? { user } : {}
+  };
+}
+var mockState = {
+  context: createDefaultMockContext(),
+  manifestOverride: void 0,
+  ready: false
+};
+var EventusClientImpl = class {
+  emitter = new EventEmitter();
+  lastReadySource;
+  hasReadyRequest = false;
+  constructor() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("eventus:ready", this.handleBridgeReady);
+    }
+  }
+  async ready() {
+    this.hasReadyRequest = true;
+    const bridge = await this.waitForNativeBridge();
+    if (bridge) {
+      this.emitReady(mapNativeContext(bridge), "native");
+      return;
+    }
+    mockState.ready = true;
+    this.emitReady(mockState.context, "mock");
+  }
+  async getContext() {
+    const bridge = readWindowBridge();
+    if (bridge) {
+      return mapNativeContext(bridge);
+    }
+    return mockState.context;
+  }
+  getManifest() {
+    const bridge = readWindowBridge();
+    if (bridge) {
+      return readInjectedManifest();
+    }
+    return mockState.manifestOverride === void 0 ? readInjectedManifest() : mockState.manifestOverride;
+  }
+  async request(action, payload) {
+    const bridge = readWindowBridge();
+    if (bridge) {
+      if (typeof bridge.request === "function") {
+        return bridge.request(action, payload);
+      }
+      const bridgeAction = bridge[action];
+      if (typeof bridgeAction === "function") {
+        return bridgeAction(payload);
+      }
+    }
+    const mockedResponse = {
+      mock: true,
+      action,
+      payload: payload ?? null,
+      message: "Eventus request used the browser mock fallback because no native bridge is connected."
+    };
+    return mockedResponse;
+  }
+  on(event, handler) {
+    return this.emitter.on(event, handler);
+  }
+  configureMock(options = {}) {
+    const previousTheme = mockState.context.theme;
+    if (options.reset) {
+      mockState.context = createDefaultMockContext();
+      mockState.manifestOverride = void 0;
+      mockState.ready = false;
+      this.lastReadySource = void 0;
+      this.hasReadyRequest = false;
+    }
+    if (options.context) {
+      const nextUser = options.context.user ? {
+        ...mockState.context.user ?? {},
+        ...options.context.user
+      } : mockState.context.user;
+      mockState.context = {
+        ...mockState.context,
+        ...options.context,
+        ...nextUser ? { user: nextUser } : {}
+      };
+    }
+    if ("manifest" in options) {
+      mockState.manifestOverride = options.manifest;
+    }
+    if (typeof options.ready === "boolean") {
+      mockState.ready = options.ready;
+      if (!options.ready) {
+        this.lastReadySource = void 0;
+      }
+    }
+    if (mockState.context.theme !== previousTheme) {
+      this.emitter.emit("themeChange", {
+        theme: mockState.context.theme,
+        context: mockState.context,
+        source: "mock"
+      });
+    }
+  }
+  emitReady(context, source) {
+    if (this.lastReadySource === source) {
+      return;
+    }
+    this.lastReadySource = source;
+    this.emitter.emit("ready", {
+      context,
+      source
+    });
+  }
+  handleBridgeReady = () => {
+    if (!this.hasReadyRequest && this.lastReadySource !== "mock") {
+      return;
+    }
+    const bridge = readWindowBridge();
+    if (!bridge) {
+      return;
+    }
+    this.emitReady(mapNativeContext(bridge), "native");
+  };
+  async waitForNativeBridge() {
+    const bridge = readWindowBridge();
+    if (bridge || typeof window === "undefined") {
+      return bridge;
+    }
+    return new Promise((resolve) => {
+      const timeout = window.setTimeout(() => {
+        cleanup();
+        resolve(readWindowBridge());
+      }, 120);
+      const onReady = () => {
+        cleanup();
+        resolve(readWindowBridge());
+      };
+      const cleanup = () => {
+        window.clearTimeout(timeout);
+        window.removeEventListener("eventus:ready", onReady);
+      };
+      window.addEventListener("eventus:ready", onReady, { once: true });
+    });
+  }
+};
+var eventus = new EventusClientImpl();
+function configureMockEventus(options = {}) {
+  eventus.configureMock(options);
+}
+export {
+  configureMockEventus,
+  eventus
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@eventusgo/sdk",
+  "version": "0.1.0",
+  "description": "Eventus mini-app SDK with a browser-friendly mock fallback.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}