@webview-native-ui/engine 0.0.0-stage → 0.0.2

package/dist/native/bootstrap.js

@@ -0,0 +1,138 @@
+import { startNativeSession } from './session.js';
+const sessions = new Map();
+const pending = new Map();
+const interactions = new Map();
+const documentID = Array.from(crypto.getRandomValues(new Uint32Array(4)), (part) => part.toString(16)).join('-');
+const notifications = new Map();
+/** Cordova plugins forward their existing notifications through NativeUIProjection.receive. */
+export const notify = (id, name, data) => notifications.get(id)?.get(name)?.(data);
+let sequence = 0;
+const send = (id, request) => new Promise((resolve, reject) => {
+    const key = `${id}:${documentID}:${++sequence}`;
+    const timer = setTimeout(() => {
+        pending.delete(key);
+        reject(new Error('Native UI session timed out'));
+    }, 5000);
+    pending.set(key, { resolve, reject, timer });
+    const message = JSON.stringify({ key, request });
+    const host = globalThis;
+    const channel = host.webkit?.messageHandlers?.[id] ?? host[id] ?? host.nativeUIEngine;
+    if (!channel) {
+        clearTimeout(timer);
+        pending.delete(key);
+        reject(new Error('Native UI session unavailable'));
+        return;
+    }
+    try {
+        channel.postMessage(message);
+    }
+    catch (error) {
+        clearTimeout(timer);
+        pending.delete(key);
+        reject(error);
+    }
+});
+export const receive = (id, key, value, error) => {
+    if (key === null) {
+        interactions.get(id)?.(value);
+        return;
+    }
+    const item = pending.get(key);
+    if (!item || !key.startsWith(`${id}:`))
+        return;
+    pending.delete(key);
+    clearTimeout(item.timer);
+    if (error)
+        item.reject(new Error(error));
+    else
+        item.resolve(value);
+};
+export const show = (id) => {
+    sessions.get(id)?.show();
+};
+export const hide = (id) => {
+    sessions.get(id)?.hide();
+    return true;
+};
+export const stop = async (id) => {
+    const session = sessions.get(id);
+    sessions.delete(id);
+    notifications.delete(id);
+    interactions.delete(id);
+    for (const [key, item] of pending) {
+        if (!key.startsWith(`${id}:`))
+            continue;
+        pending.delete(key);
+        clearTimeout(item.timer);
+        item.reject(new Error('Native UI session closed'));
+    }
+    await session?.destroy();
+};
+export const start = async (config) => {
+    if (sessions.has(config.id))
+        return;
+    // Reserve before asynchronous initialization, including duplicate Native init callbacks.
+    let actual;
+    let cancelled = false;
+    let pendingDestination;
+    const reservation = {
+        show: () => {
+            pendingDestination = 'native';
+            actual?.show();
+        },
+        hide: () => {
+            pendingDestination = 'none';
+            actual?.hide();
+        },
+        destroy: async () => {
+            cancelled = true;
+            await actual?.destroy();
+        },
+    };
+    sessions.set(config.id, reservation);
+    try {
+        if (document.readyState === 'loading')
+            await new Promise((resolve) => document.addEventListener('DOMContentLoaded', () => resolve(), { once: true }));
+        if (cancelled)
+            return;
+        const listeners = new Map();
+        if (config.runtime === 'cordova')
+            notifications.set(config.id, listeners);
+        actual = await startNativeSession(config, {
+            send: (request) => send(config.id, request),
+            listen: async (listener) => {
+                interactions.set(config.id, listener);
+                return {
+                    remove: () => {
+                        if (interactions.get(config.id) === listener)
+                            interactions.delete(config.id);
+                    },
+                };
+            },
+        }, config.runtime === 'cordova'
+            ? {
+                addListener: async (name, listener) => {
+                    listeners.set(name, listener);
+                    return {
+                        remove: () => {
+                            listeners.delete(name);
+                        },
+                    };
+                },
+            }
+            : undefined);
+        if (pendingDestination === 'none')
+            actual.hide();
+        else if (pendingDestination === 'native')
+            actual.show();
+        if (cancelled)
+            await actual.destroy();
+    }
+    catch (error) {
+        if (sessions.get(config.id) === reservation) {
+            sessions.delete(config.id);
+            notifications.delete(config.id);
+        }
+        throw error;
+    }
+};

package/dist/native/bridge.d.ts

@@ -0,0 +1,4 @@
+import type { ListenerHandle as PluginListenerHandle } from '../types.js';
+export declare const bounded: <T>(promise: Promise<T>) => Promise<T>;
+/** A timed-out registration still owns a native resource if it eventually succeeds. */
+export declare const boundedListener: (registration: Promise<PluginListenerHandle>) => Promise<PluginListenerHandle>;

package/dist/native/bridge.js

@@ -0,0 +1,15 @@
+// A failed bridge must not leave the source inaccessible indefinitely.
+export const bounded = (promise) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('Native UI bridge timed out')), 5000);
+    promise.then(resolve, reject).finally(() => clearTimeout(timer));
+});
+/** A timed-out registration still owns a native resource if it eventually succeeds. */
+export const boundedListener = async (registration) => {
+    try {
+        return await bounded(registration);
+    }
+    catch (error) {
+        void registration.then((listener) => listener.remove()).catch(() => { });
+        throw error;
+    }
+};

package/dist/native/resource-url.d.ts

@@ -0,0 +1,2 @@
+/** Use the host's existing file server; never initialize a framework bridge. */
+export declare const projectionURL: (url: string) => string;

package/dist/native/resource-url.js

@@ -0,0 +1,11 @@
+/** Use the host's existing file server; never initialize a framework bridge. */
+export const projectionURL = (url) => {
+    const host = globalThis;
+    if (host.Capacitor?.convertFileSrc)
+        return host.Capacitor.convertFileSrc(url);
+    if (!url.startsWith('file:'))
+        return url;
+    if (host.WkWebView?.convertFilePath)
+        return host.WkWebView.convertFilePath(url);
+    throw new Error('Native UI file URL requires a host resource handler');
+};

package/dist/native/session.d.ts

@@ -0,0 +1,49 @@
+import { type ProjectionDestination } from '../projection/events.js';
+import type { ScrollPlacement, ListenerHandle, WebProjectionRequest } from '../types.js';
+/** Serialized by the native library. One registration owns one fixed fallback container. */
+export interface NativeSessionConfiguration {
+    id: string;
+    plugin: string;
+    runtime?: 'capacitor' | 'cordova';
+    projectionSelector: string;
+    captureDelayMs?: number;
+    /** Recovery while native is requested. Explicit web/none destinations take precedence. */
+    failedFallback?: 'web' | 'native';
+    captureMode?: 'composited' | 'view';
+    /** Native registration accepts a final placement in its reveal request. */
+    placementHandoff?: boolean;
+    receiveListeners?: {
+        update?: string[];
+        projection?: Partial<Record<ProjectionDestination, string[]>>;
+        match?: Record<string, string | number | boolean>;
+    };
+}
+export interface NativeSessionBridge {
+    send(request: WebProjectionRequest | {
+        action: 'resume';
+        token?: string;
+    } | {
+        action: 'visibility';
+        visible: boolean;
+    } | {
+        action: 'track';
+        viewportWidth: number;
+        scroll?: ScrollPlacement;
+    } | {
+        action: 'connect';
+    } | {
+        action: 'destination';
+        destination: ProjectionDestination;
+    }): Promise<any>;
+    listen(listener: (event: {
+        active: boolean;
+    }) => void): Promise<ListenerHandle>;
+}
+/** Native startup calls this; application code does not initialize or wrap the plugin. */
+export declare const startNativeSession: (config: NativeSessionConfiguration, nativeBridge: NativeSessionBridge, plugin?: {
+    addListener(name: string, listener: (event: unknown) => void): Promise<ListenerHandle>;
+}) => Promise<{
+    destroy: () => Promise<void>;
+    show: () => void;
+    hide: () => void;
+}>;