plusui-native-core 0.1.66 → 0.1.68

package/Core/Features/Connection/connect.ts

@@ -1,272 +1,190 @@
-export type ConnectionKind =
-  | "call"
-  | "fire"
-  | "result"
-  | "event"
-  | "stream"
-  | "sub"
-  | "unsub"
-  | "publish"
-  | "error";
-
-export type ConnectionEnvelope = {
-  kind: ConnectionKind;
-  id?: string;
-  name: string;
-  payload?: unknown;
-  error?: string;
-};
-
-type MessageCallback = (payload: any) => void;
-
-class ConnectionClient {
-  private pending = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
-  private listeners = new Map<string, Set<MessageCallback>>();
-
-  constructor() {
-    const host = globalThis as any;
-
-    host.__plusuiConnectionMessage = (message: unknown) => {
-      this.handleIncoming(message);
-    };
-
-    if (typeof window !== "undefined") {
-      window.addEventListener("plusui:connection:message", (ev: Event) => {
-        const custom = ev as CustomEvent<unknown>;
-        this.handleIncoming(custom.detail);
-      });
-    }
-  }
-
-  private nextId(): string {
-    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  }
-
-  private async send(env: ConnectionEnvelope): Promise<any> {
-    const host = globalThis as any;
-
-    if (typeof host.__invoke__ === "function") {
-      return host.__invoke__("connection.dispatch", env);
-    }
-
-    if (host.ipc?.postMessage) {
-      host.ipc.postMessage(JSON.stringify(env));
-      return null;
-    }
-
-    return null;
-  }
-
-  private decode(message: unknown): ConnectionEnvelope | null {
-    if (!message) {
-      return null;
-    }
-    if (typeof message === "string") {
-      try {
-        return JSON.parse(message) as ConnectionEnvelope;
-      } catch {
-        return null;
-      }
-    }
-    if (typeof message === "object") {
-      return message as ConnectionEnvelope;
-    }
-    return null;
-  }
-
-  private handleIncoming(message: unknown): void {
-    const env = this.decode(message);
-    if (!env) {
-      return;
-    }
-
-    if ((env.kind === "result" || env.kind === "error") && env.id) {
-      const entry = this.pending.get(env.id);
-      if (!entry) {
-        return;
-      }
-      this.pending.delete(env.id);
-      if (env.kind === "error") {
-        entry.reject(new Error(env.error || "Connection call failed"));
-      } else {
-        entry.resolve(env.payload);
-      }
-      return;
-    }
-
-    if (env.kind === "event" || env.kind === "stream" || env.kind === "publish") {
-      const handlers = this.listeners.get(env.name);
-      if (!handlers) {
-        return;
-      }
-      for (const handler of handlers) {
-        handler(env.payload);
-      }
-    }
-  }
-
-  async call<TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn): Promise<TOut> {
-    const id = this.nextId();
-    const promise = new Promise<TOut>((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-    });
-
-    await this.send({ kind: "call", id, name, payload });
-    return promise;
-  }
-
-  fire<TIn = Record<string, unknown>>(name: string, payload: TIn): void {
-    void this.send({ kind: "fire", name, payload });
-  }
-
-  on<TData = unknown>(name: string, callback: (payload: TData) => void): () => void {
-    const existing = this.listeners.get(name) ?? new Set<MessageCallback>();
-    existing.add(callback as MessageCallback);
-    this.listeners.set(name, existing);
-
-    return () => {
-      const current = this.listeners.get(name);
-      if (!current) {
-        return;
-      }
-      current.delete(callback as MessageCallback);
-      if (current.size === 0) {
-        this.listeners.delete(name);
-      }
-    };
-  }
-
-  stream<TData = unknown>(name: string) {
-    return {
-      subscribe: (callback: (payload: TData) => void): (() => void) => {
-        void this.send({ kind: "sub", name });
-        const off = this.on<TData>(name, callback);
-        return () => {
-          off();
-          void this.send({ kind: "unsub", name });
-        };
-      },
-    };
-  }
-
-  channel<TData = unknown>(name: string) {
-    return {
-      subscribe: (callback: (payload: TData) => void): (() => void) => {
-        void this.send({ kind: "sub", name });
-        const off = this.on<TData>(name, callback);
-        return () => {
-          off();
-          void this.send({ kind: "unsub", name });
-        };
-      },
-      publish: (payload: TData): void => {
-        void this.send({ kind: "publish", name, payload });
-      },
-    };
-  }
-}
-
-// Create the connection client instance
-const connectionClient = new ConnectionClient();
-
-// Simple connection API - just emit() and on()
-export const connect = {
-  // Send a message to backend
-  emit: <TIn = Record<string, unknown>>(name: string, payload: TIn): void => {
-    connectionClient.fire(name, payload);
-  },
-
-  // Listen for messages from backend
-  on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
-    return connectionClient.on<TData>(name, callback);
-  },
-
-  feature: (scope: string): FeatureConnect => {
-    return createFeatureConnect(scope);
-  },
-};
-
-// Export the raw client for advanced use cases (call, fire, stream, channel)
-export const connection = connectionClient;
-
-export type FeatureConnect = {
-  emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => void;
-  on: <TData = unknown>(name: string, callback: (payload: TData) => void) => (() => void);
-  call: <TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn) => Promise<TOut>;
-  stream: <TData = unknown>(name: string) => {
-    subscribe: (callback: (payload: TData) => void) => (() => void);
-  };
-  channel: <TData = unknown>(name: string) => {
-    subscribe: (callback: (payload: TData) => void) => (() => void);
-    publish: (payload: TData) => void;
-  };
-  scoped: (scope: string) => FeatureConnect;
-};
-
-function scopeName(scope: string, name: string): string {
-  if (name.startsWith(`${scope}.`)) {
-    return name;
-  }
-  return `${scope}.${name}`;
-}
-
-async function invokeScoped(method: string, payload?: unknown): Promise<unknown> {
-  const host = globalThis as any;
-  if (typeof host.__invoke__ !== 'function') {
-    return undefined;
-  }
-
-  const args = payload === undefined ? [] : [payload];
-  return host.__invoke__(method, args);
-}
-
-export function createFeatureConnect(scope: string): FeatureConnect {
-  return {
-    emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => {
-      const scoped = scopeName(scope, name);
-      void invokeScoped(scoped, payload);
-      connect.emit(scoped, payload);
-
-      if (typeof window !== 'undefined') {
-        window.dispatchEvent(new CustomEvent(`plusui:${scoped}`, { detail: payload }));
-      }
-    },
-    on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
-      const scoped = scopeName(scope, name);
-      const offConnect = connect.on<TData>(scoped, callback);
-
-      if (typeof window === 'undefined') {
-        return offConnect;
-      }
-
-      const domHandler = (event: Event) => {
-        const custom = event as CustomEvent<TData>;
-        callback(custom.detail);
-      };
-
-      window.addEventListener(`plusui:${scoped}`, domHandler as EventListener);
-
-      return () => {
-        offConnect();
-        window.removeEventListener(`plusui:${scoped}`, domHandler as EventListener);
-      };
-    },
-    call: <TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn): Promise<TOut> => {
-      const scoped = scopeName(scope, name);
-      const host = globalThis as any;
-
-      if (typeof host.__invoke__ === 'function') {
-        return invokeScoped(scoped, payload) as Promise<TOut>;
-      }
-
-      return connection.call<TOut, TIn>(scoped, payload);
-    },
-    stream: <TData = unknown>(name: string) => {
-      return connection.stream<TData>(scopeName(scope, name));
-    },
-    channel: <TData = unknown>(name: string) => {
-      return connection.channel<TData>(scopeName(scope, name));
-    },
-    scoped: (childScope: string) => createFeatureConnect(scopeName(scope, childScope)),
-  };
-}
+/**
+ * PlusUI Connection
+ * 
+ * TWO METHODS. FIVE PRIMITIVES. EVERYTHING YOU NEED.
+ * 
+ *   name.on(callback)   - Listen for messages
+ *   name.emit(data)     - Send messages
+ * 
+ * Built-in features (win, clipboard, app) are imported from 'plusui'.
+ * Custom channels are auto-generated by `plusui connect`.
+ */
+
+export type ConnectionKind =
+  | "call"
+  | "fire"
+  | "result"
+  | "event"
+  | "stream"
+  | "sub"
+  | "unsub"
+  | "publish"
+  | "error";
+
+export type ConnectionEnvelope = {
+  kind: ConnectionKind;
+  id?: string;
+  name: string;
+  payload?: unknown;
+  error?: string;
+};
+
+type MessageCallback = (payload: any) => void;
+
+class ConnectionClient {
+  private pending = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
+  private listeners = new Map<string, Set<MessageCallback>>();
+
+  constructor() {
+    const host = globalThis as any;
+    host.__plusuiConnectionMessage = (message: unknown) => {
+      this.handleIncoming(message);
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("plusui:connection:message", (ev: Event) => {
+        const custom = ev as CustomEvent<unknown>;
+        this.handleIncoming(custom.detail);
+      });
+    }
+  }
+
+  private nextId(): string {
+    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  }
+
+  private async send(env: ConnectionEnvelope): Promise<any> {
+    const host = globalThis as any;
+    if (typeof host.__invoke__ === "function") {
+      return host.__invoke__("connection.dispatch", env);
+    }
+    if (host.ipc?.postMessage) {
+      host.ipc.postMessage(JSON.stringify(env));
+      return null;
+    }
+    return null;
+  }
+
+  private decode(message: unknown): ConnectionEnvelope | null {
+    if (!message) return null;
+    if (typeof message === "string") {
+      try {
+        return JSON.parse(message) as ConnectionEnvelope;
+      } catch {
+        return null;
+      }
+    }
+    if (typeof message === "object") {
+      return message as ConnectionEnvelope;
+    }
+    return null;
+  }
+
+  private handleIncoming(message: unknown): void {
+    const env = this.decode(message);
+    if (!env) return;
+
+    if ((env.kind === "result" || env.kind === "error") && env.id) {
+      const entry = this.pending.get(env.id);
+      if (!entry) return;
+      this.pending.delete(env.id);
+      if (env.kind === "error") {
+        entry.reject(new Error(env.error || "Connection call failed"));
+      } else {
+        entry.resolve(env.payload);
+      }
+      return;
+    }
+
+    if (env.kind === "event" || env.kind === "stream" || env.kind === "publish") {
+      const handlers = this.listeners.get(env.name);
+      if (!handlers) return;
+      for (const handler of handlers) {
+        handler(env.payload);
+      }
+    }
+  }
+
+  async call<TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn): Promise<TOut> {
+    const id = this.nextId();
+    const promise = new Promise<TOut>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+    await this.send({ kind: "call", id, name, payload });
+    return promise;
+  }
+
+  fire<TIn = Record<string, unknown>>(name: string, payload: TIn): void {
+    void this.send({ kind: "fire", name, payload });
+  }
+
+  on<TData = unknown>(name: string, callback: (payload: TData) => void): () => void {
+    const existing = this.listeners.get(name) ?? new Set<MessageCallback>();
+    existing.add(callback as MessageCallback);
+    this.listeners.set(name, existing);
+    return () => {
+      const current = this.listeners.get(name);
+      if (!current) return;
+      current.delete(callback as MessageCallback);
+      if (current.size === 0) {
+        this.listeners.delete(name);
+      }
+    };
+  }
+}
+
+const _client = new ConnectionClient();
+
+/**
+ * connect - Custom channel API
+ * 
+ * Use for app-specific communication:
+ *   connect.emit('myEvent', { data: 123 });
+ *   connect.on('myEvent', (data) => { ... });
+ */
+export const connect = {
+  emit: <TIn = Record<string, unknown>>(name: string, payload: TIn): void => {
+    _client.fire(name, payload);
+  },
+  on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
+    return _client.on<TData>(name, callback);
+  },
+  feature: createFeatureConnect,
+};
+
+export type FeatureConnect = {
+  on: <TData = unknown>(name: string, callback: (payload: TData) => void) => (() => void);
+  emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => void;
+};
+
+function scopeName(scope: string, name: string): string {
+  if (name.startsWith(`${scope}.`)) return name;
+  return `${scope}.${name}`;
+}
+
+export function createFeatureConnect(scope: string): FeatureConnect {
+  return {
+    emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => {
+      const scoped = scopeName(scope, name);
+      _client.fire(scoped, payload);
+      if (typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent(`plusui:${scoped}`, { detail: payload }));
+      }
+    },
+    on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
+      const scoped = scopeName(scope, name);
+      const off = _client.on<TData>(scoped, callback);
+      if (typeof window === 'undefined') return off;
+      const domHandler = (event: Event) => {
+        callback((event as CustomEvent<TData>).detail);
+      };
+      window.addEventListener(`plusui:${scoped}`, domHandler as EventListener);
+      return () => {
+        off();
+        window.removeEventListener(`plusui:${scoped}`, domHandler as EventListener);
+      };
+    },
+  };
+}
+
+export { _client };
+export default connect;