plusui-native-core 0.1.96 → 0.1.98

package/Core/Features/API/index.ts

@@ -1,45 +1,12 @@
 /**
- * PlusUI API - Simple & Direct
+ * PlusUI API
  * 
  * window.show(), window.hide(), window.close()
  * window.maximize(), window.minimize(), window.restore()
- * window.setSize(w, h), window.setSize(x, y)
- * window.setTitle(title), window.center()
+ * window.setSize(w, h), window.setPosition(x, y)
  */
 
-if (typeof window !== 'undefined') {
-  const win = window as any;
-  if (!win.__invoke__) {
-    let callId = 0;
-    const pending = new Map<string, { resolve: (v: any) => void; reject: (e: any) => void }>();
-
-    win.__response__ = function (id: string, result: any, error?: any) {
-      const p = pending.get(id);
-      if (p) {
-        pending.delete(id);
-        error ? p.reject(new Error(error)) : p.resolve(result);
-      }
-    };
-
-    win.__invoke__ = function (method: string, params: any[] = []): Promise<any> {
-      if (!win.__native_invoke__) {
-        return Promise.resolve(null);
-      }
-      return new Promise((resolve, reject) => {
-        const id = String(++callId);
-        pending.set(id, { resolve, reject });
-        try {
-          win.__native_invoke__(JSON.stringify({ id, method, params }));
-        } catch (e) {
-          pending.delete(id);
-          reject(e);
-        }
-      });
-    };
-  }
-}
-
-export { window } from './window-api';
+export { window, win } from './window-api';
 export { clipboard } from './clipboard-api';
 export { app } from './app-api';
 export { browser } from './browser-api';
@@ -68,7 +35,7 @@ export type { RouteMap, RouteChangeCallback, RouteConfig } from './router-api';
 
 export { readFileAsText, readFileAsDataUrl, filterFilesByExtension, filterFilesByMimeType, isImageFile, isVideoFile, isAudioFile, isTextFile } from './filedrop-api';
 
-import { window } from './window-api';
+import { window, win } from './window-api';
 import { clipboard } from './clipboard-api';
 import { app } from './app-api';
 import { browser } from './browser-api';
@@ -83,7 +50,7 @@ import { connect, createChannel } from './Connect_API';
 
 const plusui = {
   window,
-  win: window,
+  win,
   clipboard,
   app,
   api: app,

package/Core/Features/API/window-api.ts

@@ -1,7 +1,2 @@
-/**
- * Window API
- * Simple, direct window control - no events, just methods.
- */
-
 export type { WindowSize, WindowPosition, WindowRect } from '../Window/window';
-export { window } from '../Window/window';
+export { window, win } from '../Window/window';

package/Core/Features/App/app.ts

@@ -1,181 +1,52 @@
-import { plusui } from "@plusui";
-
 export interface AppConfig {
   title?: string;
   width?: number;
   height?: number;
   resizable?: boolean;
   devtools?: boolean;
-  trayIcon?: string;
-  trayTooltip?: string;
-  alwaysOnTop?: boolean;
-  centered?: boolean;
-  transparent?: boolean;
-  decorations?: boolean;
-  skipTaskbar?: boolean;
-  scrollbars?: boolean;
-  enableFileDrop?: boolean;
-}
-
-export interface InvokeOptions {
-  timeout?: number;
-}
-
-let _invoke: ((name: string, args?: unknown[]) => Promise<unknown>) | null = null;
-let _event: ((event: string, callback: (...args: unknown[]) => void) => () => void) | null = null;
-let _initialized = false;
-
-export function setInvokeFn(fn: (name: string, args?: unknown[]) => Promise<unknown>) {
-  _invoke = fn;
-}
-
-export function setEventFn(fn: (event: string, callback: (...args: unknown[]) => void) => () => void) {
-  _event = fn;
 }
 
-function init(): void {
-  if (_initialized) return;
-  _initialized = true;
-
-  if (typeof window !== 'undefined') {
-    const win = window as Window & {
-      __plusui_listeners__?: Map<string, Set<(...args: unknown[]) => void>>;
-    };
-
-    win.__plusui_listeners__ = new Map();
+let callId = 0;
+const pending = new Map<string, { resolve: (v: any) => void; reject: (e: any) => void }>();
 
-    window.addEventListener('message', (event: MessageEvent) => {
-      if (event.data?.type === '__plusui_event__') {
-        const { event: eventName, payload } = event.data;
-        const listeners = win.__plusui_listeners__?.get(eventName);
-        if (listeners) {
-          listeners.forEach(cb => cb(payload));
-        }
-      }
-    });
-  }
+function getGlobal(): any {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis;
+  return {};
 }
 
-async function invoke<T = unknown>(name: string, args?: unknown[], options: InvokeOptions = {}): Promise<T> {
-  const { timeout = 30000 } = options;
+const g = getGlobal();
 
-  if (_invoke) {
-    return _invoke(name, args) as Promise<T>;
+g.__response__ = function(id: string, result: any, error?: any) {
+  const p = pending.get(id);
+  if (p) {
+    pending.delete(id);
+    error ? p.reject(new Error(error)) : p.resolve(result);
   }
+};
 
-  if (typeof window !== 'undefined') {
-    const win = window as Window & {
-      __invoke__?: (name: string, args?: unknown[]) => Promise<unknown>;
-      __native_invoke__?: (request: string) => void;
-    };
-    if (win.__invoke__) {
-      return win.__invoke__(name, args) as Promise<T>;
-    }
-  }
-
-  return new Promise((_, reject) => {
-    setTimeout(() => reject(new Error(`Invocation ${name} timed out`)), timeout);
-  });
-}
-
-function eventHandler(event: string, callback: (...args: unknown[]) => void): () => void {
-  init();
+async function invoke<T>(method: string, params: any[] = []): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const id = String(++callId);
+    pending.set(id, { resolve, reject });
+    const payload = JSON.stringify({ id, method, params });
 
-  if (!_event) {
-    if (typeof window !== 'undefined' && (window as any).__on__) {
-      _event = (window as any).__on__;
+    if (g.__native_invoke__) {
+      g.__native_invoke__(payload);
+    } else if (g.chrome && g.chrome.webview && g.chrome.webview.postMessage) {
+      g.chrome.webview.postMessage(payload);
     } else {
-      const win = window as Window & {
-        __plusui_listeners__?: Map<string, Set<(...args: unknown[]) => void>>;
-      };
-
-      if (!win.__plusui_listeners__) {
-        win.__plusui_listeners__ = new Map();
-      }
-
-      const listeners = win.__plusui_listeners__!;
-
-      if (!listeners.has(event)) {
-        listeners.set(event, new Set());
-      }
-
-      listeners.get(event)!.add(callback);
-
-      return () => {
-        listeners.get(event)?.delete(callback);
-      };
+      pending.delete(id);
+      console.warn('[PlusUI] ' + method + ' - native bridge not ready');
+      resolve(null as T);
     }
-  }
-  return _event!(event, callback);
+  });
 }
 
 export const app = {
-  async invoke<T = unknown>(name: string, args?: unknown[], options: InvokeOptions = {}): Promise<T> {
-    return invoke<T>(name, args, options);
-  },
-
-  async quit(): Promise<void> {
-    await invoke('app.quit');
-  },
-
-  async getVersion(): Promise<string> {
-    return invoke<string>('app.getVersion');
-  },
-
-  async getName(): Promise<string> {
-    return invoke<string>('app.getName');
-  },
-
-  async getPath(name: 'home' | 'appData' | 'userData' | 'temp' | 'desktop' | 'documents' | 'downloads'): Promise<string> {
-    return invoke<string>('app.getPath', [name]);
-  },
-
-  async setBadge(count: number): Promise<void> {
-    await invoke('app.setBadge', [count]);
-  },
-
-  async getBadge(): Promise<number> {
-    return invoke<number>('app.getBadge');
-  },
-
-  onReady(callback: () => void): () => void {
-    return eventHandler('app:ready', callback);
-  },
-
-  onQuit(callback: (reason?: string) => void): () => void {
-    return eventHandler('app:quit', callback as (...args: unknown[]) => void);
-  },
-
-  onActivate(callback: () => void): () => void {
-    return eventHandler('app:activate', callback);
-  },
-
-  onWindowAllClosed(callback: () => void): () => void {
-    return eventHandler('app:windowAllClosed', callback);
-  },
-
-  onSecondInstance(callback: (args: string[], cwd: string) => void): () => void {
-    return eventHandler('app:secondInstance', callback as (...args: unknown[]) => void);
-  },
-
-  on(event: string, callback: (...args: unknown[]) => void): () => void {
-    return eventHandler(event, callback);
-  },
-
-  once(event: string, callback: (...args: unknown[]) => void): () => void {
-    const unsubscribe = this.on(event, (...args) => {
-      unsubscribe();
-      callback(...args);
-    });
-    return unsubscribe;
-  },
-
-  emit(event: string, payload?: unknown): void {
-    if (typeof window !== 'undefined') {
-      const customEvent = new CustomEvent(event, { detail: payload });
-      window.dispatchEvent(customEvent);
-    }
-  },
+  quit: () => invoke<void>('app.quit'),
+  getVersion: () => invoke<string>('app.getVersion'),
+  getName: () => invoke<string>('app.getName'),
 };
 
 export default app;

package/Core/Features/Window/window.ts

@@ -18,62 +18,69 @@ export interface WindowRect {
 let callId = 0;
 const pending = new Map<string, { resolve: (v: any) => void; reject: (e: any) => void }>();
 
-async function invoke<T>(method: string, params: any[] = []): Promise<T> {
-  const win = window as any;
-  
-  if (!win.__native_invoke__) {
-    console.warn(`[PlusUI] ${method} - native bridge not ready`);
-    return null as T;
+function getGlobal() {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis as any;
+  return {} as any;
+}
+
+const g = getGlobal();
+
+g.__response__ = function(id: string, result: any, error?: any) {
+  const p = pending.get(id);
+  if (p) {
+    pending.delete(id);
+    error ? p.reject(new Error(error)) : p.resolve(result);
   }
+};
 
+async function invoke<T>(method: string, params: any[] = []): Promise<T> {
   return new Promise((resolve, reject) => {
     const id = String(++callId);
     pending.set(id, { resolve, reject });
-    
-    win.__response__ = (respId: string, result: any, error?: any) => {
-      const p = pending.get(respId);
-      if (p) {
-        pending.delete(respId);
-        error ? p.reject(new Error(error)) : p.resolve(result);
-      }
-    };
 
-    try {
-      win.__native_invoke__(JSON.stringify({ id, method, params }));
-    } catch (e) {
+    const payload = JSON.stringify({ id, method, params });
+
+    if (g.__native_invoke__) {
+      g.__native_invoke__(payload);
+    } else if (g.chrome && g.chrome.webview && g.chrome.webview.postMessage) {
+      g.chrome.webview.postMessage(payload);
+    } else {
       pending.delete(id);
-      reject(e);
+      console.warn('[PlusUI] ' + method + ' - native bridge not ready');
+      resolve(null as T);
     }
   });
 }
 
-export const window = {
-  show: () => invoke('window.show'),
-  hide: () => invoke('window.hide'),
-  close: () => invoke('window.close'),
-  minimize: () => invoke('window.minimize'),
-  maximize: () => invoke('window.maximize'),
-  restore: () => invoke('window.restore'),
-  focus: () => invoke('window.focus'),
-  center: () => invoke('window.center'),
+export const win = {
+  show: () => invoke<void>('window.show'),
+  hide: () => invoke<void>('window.hide'),
+  close: () => invoke<void>('window.close'),
+  minimize: () => invoke<void>('window.minimize'),
+  maximize: () => invoke<void>('window.maximize'),
+  restore: () => invoke<void>('window.restore'),
+  focus: () => invoke<void>('window.focus'),
+  center: () => invoke<void>('window.center'),
 
-  setTitle: (title: string) => invoke('window.setTitle', [title]),
-  setSize: (width: number, height: number) => invoke('window.setSize', [width, height]),
-  setPosition: (x: number, y: number) => invoke('window.setPosition', [x, y]),
-  setFullscreen: (enabled: boolean) => invoke('window.setFullscreen', [enabled]),
-  setAlwaysOnTop: (enabled: boolean) => invoke('window.setAlwaysOnTop', [enabled]),
-  setResizable: (enabled: boolean) => invoke('window.setResizable', [enabled]),
-  setDecorations: (enabled: boolean) => invoke('window.setDecorations', [enabled]),
-  setTransparency: (alpha: number) => invoke('window.setTransparency', [alpha]),
-  setIcon: (path: string) => invoke('window.setIcon', [path]),
+  setTitle: (title: string) => invoke<void>('window.setTitle', [title]),
+  setSize: (width: number, height: number) => invoke<void>('window.setSize', [width, height]),
+  setPosition: (x: number, y: number) => invoke<void>('window.setPosition', [x, y]),
+  setFullscreen: (enabled: boolean) => invoke<void>('window.setFullscreen', [enabled]),
+  setAlwaysOnTop: (enabled: boolean) => invoke<void>('window.setAlwaysOnTop', [enabled]),
+  setResizable: (enabled: boolean) => invoke<void>('window.setResizable', [enabled]),
+  setDecorations: (enabled: boolean) => invoke<void>('window.setDecorations', [enabled]),
+  setTransparency: (alpha: number) => invoke<void>('window.setTransparency', [alpha]),
+  setIcon: (path: string) => invoke<void>('window.setIcon', [path]),
 
-  getSize: (): Promise<WindowSize> => invoke('window.getSize'),
-  getPosition: (): Promise<WindowPosition> => invoke('window.getPosition'),
-  getRect: (): Promise<WindowRect> => invoke('window.getRect'),
+  getSize: () => invoke<WindowSize>('window.getSize'),
+  getPosition: () => invoke<WindowPosition>('window.getPosition'),
+  getRect: () => invoke<WindowRect>('window.getRect'),
   
-  isMaximized: (): Promise<boolean> => invoke('window.isMaximized'),
-  isMinimized: (): Promise<boolean> => invoke('window.isMinimized'),
-  isVisible: (): Promise<boolean> => invoke('window.isVisible'),
+  isMaximized: () => invoke<boolean>('window.isMaximized'),
+  isMinimized: () => invoke<boolean>('window.isMinimized'),
+  isVisible: () => invoke<boolean>('window.isVisible'),
 };
 
-export default window;
+export { win as window };
+export default win;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native-core",
-  "version": "0.1.96",
+  "version": "0.1.98",
   "description": "PlusUI Core framework (frontend + backend implementations)",
   "type": "module",
   "main": "./Core/Features/API/index.ts",