@owear/core 0.1.2 → 0.1.3

package/dist/theme.d.ts

@@ -0,0 +1,30 @@
+export interface ThemeInfo {
+    dark: boolean;
+    source: 'system' | 'light' | 'dark';
+    highContrast: boolean;
+    reducedTransparency: boolean;
+}
+/**
+ * Tema nativo del sistema (módulo `theme`). `watch()` emite `theme.changed`
+ * (recibible con `channel.on('theme.changed', …)` o en el renderer con
+ * `ow.on('theme.changed', …)`).
+ */
+export declare const theme: {
+    get(): Promise<ThemeInfo>;
+    isDark(): Promise<boolean>;
+    /** Fuerza la preferencia: 'system' | 'light' | 'dark'. También aplica el
+     *  esquema al contenido (Windows: WebView2 `PreferredColorScheme`). */
+    setSource(source: "system" | "light" | "dark"): Promise<ThemeInfo>;
+    watch(): Promise<void>;
+    unwatch(): Promise<void>;
+};
+/** Alias estilo Electron de `theme`. */
+export declare const nativeTheme: {
+    get(): Promise<ThemeInfo>;
+    isDark(): Promise<boolean>;
+    /** Fuerza la preferencia: 'system' | 'light' | 'dark'. También aplica el
+     *  esquema al contenido (Windows: WebView2 `PreferredColorScheme`). */
+    setSource(source: "system" | "light" | "dark"): Promise<ThemeInfo>;
+    watch(): Promise<void>;
+    unwatch(): Promise<void>;
+};

package/dist/theme.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/theme.ts — nativeTheme (módulo `theme`).
+import { channel, invokeNative } from './channel.js';
+/**
+ * Tema nativo del sistema (módulo `theme`). `watch()` emite `theme.changed`
+ * (recibible con `channel.on('theme.changed', …)` o en el renderer con
+ * `ow.on('theme.changed', …)`).
+ */
+export const theme = {
+    get() {
+        return invokeNative('theme', 'get');
+    },
+    isDark() {
+        return invokeNative('theme', 'isDark');
+    },
+    /** Fuerza la preferencia: 'system' | 'light' | 'dark'. También aplica el
+     *  esquema al contenido (Windows: WebView2 `PreferredColorScheme`). */
+    async setSource(source) {
+        const info = await invokeNative('theme', 'setSource', source);
+        const scheme = source === 'dark' ? 2 : source === 'light' ? 1 : 0;
+        void channel.call('window.setColorScheme', { scheme }).catch(() => undefined);
+        return info;
+    },
+    watch() {
+        return invokeNative('theme', 'watch');
+    },
+    unwatch() {
+        return invokeNative('theme', 'unwatch');
+    },
+};
+/** Alias estilo Electron de `theme`. */
+export const nativeTheme = theme;

package/dist/tray.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'node:events';
+import { Menu } from './menu.js';
+import { NativeImage } from './nativeimage.js';
+/** Tray actual (solo uno). Lo lee el ruteo de eventos del SDK. */
+export declare let currentTray: Tray | null;
+export interface TrayEvent {
+    button: 'left' | 'right' | 'double';
+    windowId: number;
+}
+/**
+ * Icono de bandeja (intermedio Tauri/Electron). El menú contextual reutiliza
+ * `Menu`. Eventos: `click`, `right-click`, `double-click`.
+ *
+ *   const tray = new Tray(nativeImage.createFromPath('icon.png'))
+ *   tray.setContextMenu(Menu.buildFromTemplate([{ label: 'Mostrar', click: () => win.show() }]))
+ *   tray.on('click', () => win.show())
+ */
+export declare class Tray extends EventEmitter {
+    private _menu;
+    private _id;
+    constructor(image?: NativeImage | string);
+    get id(): string;
+    setImage(image: NativeImage | string): void;
+    setPressedImage(image: NativeImage | string): void;
+    setToolTip(tip: string): void;
+    setTitle(title: string): void;
+    setContextMenu(menu: Menu | null): void;
+    popupContextMenu(menu?: Menu): void;
+    destroy(): void;
+}

package/dist/tray.js

@@ -0,0 +1,69 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/tray.ts — Tray (C6).
+import { EventEmitter } from 'node:events';
+import { invokeNative } from './channel.js';
+import { app } from './app.js';
+import { nativeImage } from './nativeimage.js';
+/** Tray actual (solo uno). Lo lee el ruteo de eventos del SDK. */
+export let currentTray = null;
+function toPngBase64(image) {
+    const img = typeof image === 'string' ? nativeImage.createFromPath(image) : image;
+    return img.toPNG().toString('base64');
+}
+/**
+ * Icono de bandeja (intermedio Tauri/Electron). El menú contextual reutiliza
+ * `Menu`. Eventos: `click`, `right-click`, `double-click`.
+ *
+ *   const tray = new Tray(nativeImage.createFromPath('icon.png'))
+ *   tray.setContextMenu(Menu.buildFromTemplate([{ label: 'Mostrar', click: () => win.show() }]))
+ *   tray.on('click', () => win.show())
+ */
+export class Tray extends EventEmitter {
+    _menu = null;
+    _id;
+    constructor(image) {
+        super();
+        this._id = `tray-${Math.random().toString(36).slice(2, 8)}`;
+        currentTray = this;
+        app
+            .whenReady()
+            .then(async () => {
+            await invokeNative('tray', 'create', this._id).catch(() => undefined);
+            if (image)
+                this.setImage(image);
+        })
+            .catch(() => undefined);
+    }
+    get id() {
+        return this._id;
+    }
+    setImage(image) {
+        void invokeNative('tray', 'setImage', toPngBase64(image)).catch(() => undefined);
+    }
+    setPressedImage(image) {
+        void invokeNative('tray', 'setPressedImage', toPngBase64(image)).catch(() => undefined);
+    }
+    setToolTip(tip) {
+        void invokeNative('tray', 'setToolTip', tip).catch(() => undefined);
+    }
+    setTitle(title) {
+        void invokeNative('tray', 'setTitle', title).catch(() => undefined);
+    }
+    setContextMenu(menu) {
+        this._menu = menu;
+        void invokeNative('tray', 'setContextMenu', { items: menu ? menu._toJSON() : [] }).catch(() => undefined);
+    }
+    popupContextMenu(menu) {
+        const m = menu ?? this._menu;
+        if (m)
+            void invokeNative('tray', 'setContextMenu', { items: m._toJSON() }).catch(() => undefined);
+        void invokeNative('tray', 'popupContextMenu').catch(() => undefined);
+    }
+    destroy() {
+        if (currentTray === this)
+            currentTray = null;
+        void invokeNative('tray', 'destroy').catch(() => undefined);
+    }
+}

package/dist/webcontents.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from 'node:events';
+import { NativeImage } from './nativeimage.js';
+export interface WindowOpenDetails {
+    url: string;
+}
+export type WindowOpenHandler = (details: WindowOpenDetails) => {
+    action: 'allow' | 'deny';
+    overrideBrowserWindowOptions?: Record<string, unknown>;
+} | void;
+/** Eventos de ventana → nombres estilo Electron de webContents. */
+export declare const WC_EVENT_NAMES: Record<string, string>;
+/** Eventos de ventana → nombres estilo Electron (dash) que emite BrowserWindow. */
+export declare const WIN_EVENT_NAMES: Record<string, string>;
+/**
+ * Vista del contenido web de una ventana (estilo Electron).
+ * Eventos: `did-finish-load`, `did-fail-load`, `did-start-navigation`,
+ * `did-navigate`, `page-title-updated`, `before-input-event`.
+ * `setWindowOpenHandler` controla `window.open`/`target=_blank`.
+ */
+export declare class WebContents extends EventEmitter {
+    private _windowId;
+    constructor(windowId?: number | null);
+    _setWindowId(id: number): void;
+    get id(): number;
+    /** Envía un evento SOLO a esta ventana (renderer: `ow.on(name, cb)`). */
+    send(name: string, payload?: unknown): Promise<void>;
+    loadURL(url: string): Promise<void>;
+    reload(): Promise<void>;
+    openDevTools(): Promise<void>;
+    getURL(): Promise<string>;
+    getTitle(): Promise<string>;
+    executeJavaScript<T = unknown>(js: string): Promise<T>;
+    /** Captura la página (PNG) como `NativeImage` (resizable, toPNG/toDataURL). */
+    capturePage(): Promise<NativeImage>;
+    /** Exporta la página a PDF (Buffer). */
+    printToPDF(_options?: Record<string, unknown>): Promise<Buffer>;
+    /** Abre el diálogo de impresión del sistema. */
+    print(_options?: Record<string, unknown>): void;
+    /**
+     * Controla `window.open`/`target=_blank`. Devuelve `{action:'deny'}` para
+     * bloquear o `{action:'allow'}` para permitir (por defecto).
+     */
+    setWindowOpenHandler(handler: WindowOpenHandler | null): void;
+}

package/dist/webcontents.js

@@ -0,0 +1,109 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/webcontents.ts — objeto webContents (C3).
+import { EventEmitter } from 'node:events';
+import { channel, invokeNative } from './channel.js';
+import { nativeImage } from './nativeimage.js';
+/** Eventos de ventana → nombres estilo Electron de webContents. */
+export const WC_EVENT_NAMES = {
+    didFinishLoad: 'did-finish-load',
+    didFailLoad: 'did-fail-load',
+    navigationStarted: 'did-start-navigation',
+    loadCommitted: 'did-navigate',
+    pageTitleUpdated: 'page-title-updated',
+    beforeInput: 'before-input-event',
+};
+/** Eventos de ventana → nombres estilo Electron (dash) que emite BrowserWindow. */
+export const WIN_EVENT_NAMES = {
+    pageTitleUpdated: 'page-title-updated',
+    enterFullScreen: 'enter-full-screen',
+    leaveFullScreen: 'leave-full-screen',
+    alwaysOnTopChanged: 'always-on-top-changed',
+};
+let windowOpenHandler = null;
+channel.on('webContents.windowOpen', (params) => {
+    const { id, url } = params ?? {};
+    let action = 'allow';
+    try {
+        const r = windowOpenHandler?.({ url });
+        if (r && r.action === 'deny')
+            action = 'deny';
+    }
+    catch {
+        /* handler lanzó → allow */
+    }
+    void channel.call('webContents.respondWindowOpen', { id, action });
+});
+/**
+ * Vista del contenido web de una ventana (estilo Electron).
+ * Eventos: `did-finish-load`, `did-fail-load`, `did-start-navigation`,
+ * `did-navigate`, `page-title-updated`, `before-input-event`.
+ * `setWindowOpenHandler` controla `window.open`/`target=_blank`.
+ */
+export class WebContents extends EventEmitter {
+    _windowId;
+    constructor(windowId = null) {
+        super();
+        this._windowId = windowId;
+    }
+    _setWindowId(id) {
+        this._windowId = id;
+    }
+    get id() {
+        return this._windowId ?? -1;
+    }
+    /** Envía un evento SOLO a esta ventana (renderer: `ow.on(name, cb)`). */
+    send(name, payload) {
+        if (this._windowId == null)
+            return Promise.reject(new Error('ventana aún no creada'));
+        return channel.call('node.emit', { name, payload, windowId: this._windowId });
+    }
+    loadURL(url) {
+        return channel.call('window.loadURL', { windowId: this.id, url });
+    }
+    reload() {
+        return invokeNative('window', 'reload', this.id);
+    }
+    openDevTools() {
+        return invokeNative('window', 'openDevTools', this.id);
+    }
+    getURL() {
+        return invokeNative('window', 'getURL', this.id);
+    }
+    getTitle() {
+        return invokeNative('window', 'getTitle', this.id);
+    }
+    executeJavaScript(js) {
+        return channel.call('window.eval', { windowId: this.id, js });
+    }
+    /** Captura la página (PNG) como `NativeImage` (resizable, toPNG/toDataURL). */
+    async capturePage() {
+        const r = await channel.call('window.capturePage', {
+            windowId: this.id,
+            base64: true,
+        });
+        return nativeImage.createFromBuffer(Buffer.from(r.data, 'base64'));
+    }
+    /** Exporta la página a PDF (Buffer). */
+    async printToPDF(_options = {}) {
+        const r = await channel.call('window.printToPDF', {
+            windowId: this.id,
+        });
+        return Buffer.from(r.data, 'base64');
+    }
+    /** Abre el diálogo de impresión del sistema. */
+    print(_options = {}) {
+        void invokeNative('window', 'print', this.id).catch(() => undefined);
+    }
+    /**
+     * Controla `window.open`/`target=_blank`. Devuelve `{action:'deny'}` para
+     * bloquear o `{action:'allow'}` para permitir (por defecto).
+     */
+    setWindowOpenHandler(handler) {
+        windowOpenHandler = handler ?? null;
+        void channel
+            .call('webContents.setWindowOpenHandler', { windowId: this.id, enabled: !!handler })
+            .catch(() => undefined);
+    }
+}

package/dist/webrequest.d.ts

@@ -0,0 +1,23 @@
+export interface WebRequestDetails {
+    id: number;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+}
+export type WebRequestResult = {
+    cancel?: boolean;
+    redirectURL?: string;
+} | void;
+export type WebRequestHandler = (details: WebRequestDetails) => WebRequestResult | Promise<WebRequestResult>;
+/**
+ * Intercepción de requests (webRequest). `onBeforeRequest` puede cancelar o
+ * redirigir. En **Windows** intercepta todos los requests; en **Linux** solo
+ * navegaciones (WebKitGTK 2.52 ya no expone `send-request` para subrecursos).
+ *
+ *   webRequest.onBeforeRequest({ urls: ['https://ads.example.com/w'] }, () => ({ cancel: true }))
+ */
+export declare const webRequest: {
+    onBeforeRequest(filter: {
+        urls?: string[];
+    } | string[], handler: WebRequestHandler): () => void;
+};

package/dist/webrequest.js

@@ -0,0 +1,76 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/webrequest.ts — intercepción de requests (webRequest).
+import { channel } from './channel.js';
+import { app } from './index.js';
+const webRequestRegistrations = [];
+function globMatch(pattern, url) {
+    if (pattern === '<all_urls>' || pattern === '*')
+        return true;
+    const re = '^' +
+        pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.') +
+        '$';
+    try {
+        return new RegExp(re).test(url);
+    }
+    catch {
+        return false;
+    }
+}
+function webRequestPatterns() {
+    const set = new Set();
+    for (const r of webRequestRegistrations)
+        for (const p of r.patterns)
+            set.add(p);
+    return [...set];
+}
+function syncWebRequest() {
+    app
+        .whenReady()
+        .then(() => channel.call('webRequest.register', { urls: webRequestPatterns() }))
+        .catch(() => undefined);
+}
+channel.on('webRequest.request', (params) => {
+    const { id, url, method, headers } = params ?? {};
+    const matched = webRequestRegistrations.filter((r) => r.patterns.some((p) => globMatch(p, url)));
+    Promise.resolve()
+        .then(async () => {
+        for (const r of matched) {
+            const res = await r.handler({ id, url, method, headers: headers ?? {} });
+            if (res && (res.cancel || res.redirectURL))
+                return res;
+        }
+        return null;
+    })
+        .then((res) => channel.call('webRequest.respond', {
+        id,
+        cancel: !!(res && res.cancel),
+        redirectURL: res && res.redirectURL,
+    }))
+        .catch(() => channel.call('webRequest.respond', { id, cancel: false }));
+});
+/**
+ * Intercepción de requests (webRequest). `onBeforeRequest` puede cancelar o
+ * redirigir. En **Windows** intercepta todos los requests; en **Linux** solo
+ * navegaciones (WebKitGTK 2.52 ya no expone `send-request` para subrecursos).
+ *
+ *   webRequest.onBeforeRequest({ urls: ['https://ads.example.com/w'] }, () => ({ cancel: true }))
+ */
+export const webRequest = {
+    onBeforeRequest(filter, handler) {
+        const patterns = Array.isArray(filter) ? filter : filter?.urls ?? ['<all_urls>'];
+        const reg = { patterns, handler };
+        webRequestRegistrations.push(reg);
+        syncWebRequest();
+        return () => {
+            const i = webRequestRegistrations.indexOf(reg);
+            if (i >= 0)
+                webRequestRegistrations.splice(i, 1);
+            syncWebRequest();
+        };
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owear/core",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Owear core SDK — controla el kernel nativo desde JavaScript",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,6 +32,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test test/worker.test.mjs test/port.test.mjs test/app.test.mjs test/nativeimage.test.mjs test/menu.test.mjs test/c10.test.mjs"
   }
 }