@wvb/bridge 0.1.0-next.e459de3

package/dist/index.js

@@ -0,0 +1,273 @@
+import { i as getWindow, n as INVOKE_MOCK_KEY, r as _defineProperty, t as PLATFORM_MOCK_KEY } from "./platform-mock-Dh3dBF3P.js";
+import { invoke as invoke$1, isTauri } from "@tauri-apps/api/core";
+//#region src/callback.ts
+var CallbackBag = class {
+	constructor() {
+		_defineProperty(this, "ids", []);
+	}
+	generate(callback) {
+		const w = getWindow();
+		w.__wvb_bridge_callbacks__ ?? (w.__wvb_bridge_callbacks__ = {});
+		const id = `cb_${generateId()}`;
+		w.__wvb_bridge_callbacks__[id] = callback;
+		this.ids.push(id);
+		return `(
+    function() {
+      var cb = __wvb_bridge_callbacks__ != null
+        ? __wvb_bridge_callbacks__["${id}"]
+        : undefined;
+      if (cb == null) {
+        throw new Error("cannot find callback: ${id}");
+      }
+      return cb.apply(undefined, arguments);
+    }
+    )`.replace(/(\n|\s{2,})/g, " ");
+	}
+	clean() {
+		const w = getWindow();
+		for (const id of this.ids) if (w.__wvb_bridge_callbacks__ != null) Reflect.deleteProperty(w.__wvb_bridge_callbacks__, id);
+		this.ids = [];
+	}
+};
+function generateId() {
+	const w = getWindow();
+	if (typeof w?.crypto?.randomUUID === "function") return w.crypto.randomUUID().replace(/-/g, "");
+	const bytes = new Uint8Array(16);
+	if (typeof w?.crypto?.getRandomValues === "function") w.crypto.getRandomValues(bytes);
+	else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+	bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	let id = "";
+	for (const byte of bytes) id += byte.toString(16).padStart(2, "0");
+	return id;
+}
+//#endregion
+//#region src/error.ts
+function unknownPlatform() {
+	throw new Error("Unknown platform. Make sure native webview supports webview-bundle.");
+}
+//#endregion
+//#region src/platform.ts
+function isElectron() {
+	return getWindow()?.wvbElectron != null;
+}
+function isAndroid() {
+	return getWindow()?.wvbAndroid != null;
+}
+function isIos() {
+	return getWindow()?.webkit?.messageHandlers?.wvbIos != null;
+}
+function resolveType() {
+	const mocked = getWindow()[PLATFORM_MOCK_KEY];
+	if (mocked != null) return mocked;
+	if (isElectron()) return "electron";
+	if (isTauri()) return "tauri";
+	if (isAndroid()) return "android";
+	if (isIos()) return "ios";
+}
+const platform = {
+	get type() {
+		return resolveType();
+	},
+	get isElectron() {
+		return resolveType() === "electron";
+	},
+	get isTauri() {
+		return resolveType() === "tauri";
+	},
+	get isAndroid() {
+		return resolveType() === "android";
+	},
+	get isIos() {
+		return resolveType() === "ios";
+	}
+};
+//#endregion
+//#region src/utils.ts
+function snakeCase(str) {
+	return str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").trim().replace(/ /g, "_").toLowerCase();
+}
+//#endregion
+//#region src/invoke.ts
+function invoke(name, params) {
+	const mock = getWindow()[INVOKE_MOCK_KEY];
+	if (mock != null) return mock(name, params);
+	switch (platform.type) {
+		case "electron": return getWindow().wvbElectron.invoke(name, params);
+		case "tauri": return invoke$1(toTauriCommand(name), params);
+		case "android":
+		case "ios": {
+			const bridge = getMobileBridge(platform.type);
+			return new Promise((resolve, reject) => {
+				const bag = new CallbackBag();
+				const success = bag.generate((result) => {
+					resolve(result);
+					bag.clean();
+				});
+				const error = bag.generate((error) => {
+					reject(error);
+					bag.clean();
+				});
+				try {
+					bridge.postMessage(name, params, success, error);
+				} catch (error) {
+					bag.clean();
+					reject(error);
+				}
+			});
+		}
+		default: unknownPlatform();
+	}
+}
+function getMobileBridge(platform) {
+	switch (platform) {
+		case "android": {
+			const w = getWindow();
+			return { postMessage: (name, params, success, error) => w.wvbAndroid.postMessage(JSON.stringify({
+				name,
+				params,
+				success,
+				error
+			})) };
+		}
+		case "ios": {
+			const w = getWindow();
+			return { postMessage: (name, params, success, error) => w.webkit.messageHandlers.wvbIos.postMessage({
+				name,
+				params,
+				success,
+				error
+			}) };
+		}
+	}
+}
+function toTauriCommand(name) {
+	return `plugin:wvb-tauri|${snakeCase(name)}`;
+}
+//#endregion
+//#region src/remote.ts
+async function listBundles$1(channel) {
+	return invoke("remoteListBundles", { channel });
+}
+async function getInfo(bundleName, channel) {
+	return invoke("remoteGetInfo", {
+		bundleName,
+		channel
+	});
+}
+async function download$1(bundleName, channel) {
+	return invoke("remoteDownload", {
+		bundleName,
+		channel
+	});
+}
+async function downloadVersion(bundleName, version) {
+	return invoke("remoteDownloadVersion", {
+		bundleName,
+		version
+	});
+}
+const remote = {
+	listBundles: listBundles$1,
+	getInfo,
+	download: download$1,
+	downloadVersion
+};
+//#endregion
+//#region src/source.ts
+async function listBundles() {
+	return invoke("sourceListBundles");
+}
+async function loadVersion(bundleName) {
+	return invoke("sourceLoadVersion", { bundleName });
+}
+async function updateVersion(bundleName, version) {
+	return invoke("sourceUpdateVersion", {
+		bundleName,
+		version
+	});
+}
+async function resolveFilepath(bundleName) {
+	return invoke("sourceResolveFilepath", { bundleName });
+}
+async function getBuiltinBundleFilepath(bundleName, version) {
+	return invoke("sourceGetBuiltinBundleFilepath", {
+		bundleName,
+		version
+	});
+}
+async function getRemoteBundleFilepath(bundleName, version) {
+	return invoke("sourceGetRemoteBundleFilepath", {
+		bundleName,
+		version
+	});
+}
+async function loadBuiltinMetadata(bundleName, version) {
+	return invoke("sourceLoadBuiltinMetadata", {
+		bundleName,
+		version
+	});
+}
+async function loadRemoteMetadata(bundleName, version) {
+	return invoke("sourceLoadRemoteMetadata", {
+		bundleName,
+		version
+	});
+}
+async function unloadDescriptor(bundleName) {
+	return invoke("sourceUnloadDescriptor", { bundleName });
+}
+async function removeRemoteBundle(bundleName, version) {
+	return invoke("sourceRemoveRemoteBundle", {
+		bundleName,
+		version
+	});
+}
+async function remoteRetainedVersions(bundleName) {
+	return invoke("sourceRemoteRetainedVersions", { bundleName });
+}
+async function pruneRemoteBundles(bundleName) {
+	return invoke("sourcePruneRemoteBundles", { bundleName });
+}
+const source = {
+	listBundles,
+	loadVersion,
+	updateVersion,
+	resolveFilepath,
+	getBuiltinBundleFilepath,
+	getRemoteBundleFilepath,
+	loadBuiltinMetadata,
+	loadRemoteMetadata,
+	unloadDescriptor,
+	removeRemoteBundle,
+	remoteRetainedVersions,
+	pruneRemoteBundles
+};
+//#endregion
+//#region src/updater.ts
+async function listRemotes() {
+	return invoke("updaterListRemotes");
+}
+async function getUpdate(bundleName) {
+	return invoke("updaterGetUpdate", { bundleName });
+}
+async function download(bundleName, version) {
+	return invoke("updaterDownload", {
+		bundleName,
+		version
+	});
+}
+async function install(bundleName, version) {
+	return invoke("updaterInstall", {
+		bundleName,
+		version
+	});
+}
+const updater = {
+	listRemotes,
+	getUpdate,
+	download,
+	install
+};
+//#endregion
+export { invoke, platform, remote, source, updater };

package/dist/platform-mock-BmiQzf2l.cjs

@@ -0,0 +1,73 @@
+//#region src/window.ts
+function getWindow() {
+	return globalThis || window;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/invoke-mock.ts
+const INVOKE_MOCK_KEY = "__wvb_invoke_mock__";
+//#endregion
+//#region src/platform-mock.ts
+const PLATFORM_MOCK_KEY = "__wvb_platform_mock__";
+//#endregion
+Object.defineProperty(exports, "INVOKE_MOCK_KEY", {
+	enumerable: true,
+	get: function() {
+		return INVOKE_MOCK_KEY;
+	}
+});
+Object.defineProperty(exports, "PLATFORM_MOCK_KEY", {
+	enumerable: true,
+	get: function() {
+		return PLATFORM_MOCK_KEY;
+	}
+});
+Object.defineProperty(exports, "_defineProperty", {
+	enumerable: true,
+	get: function() {
+		return _defineProperty;
+	}
+});
+Object.defineProperty(exports, "getWindow", {
+	enumerable: true,
+	get: function() {
+		return getWindow;
+	}
+});

package/dist/platform-mock-Dh3dBF3P.js

@@ -0,0 +1,50 @@
+//#region src/window.ts
+function getWindow() {
+	return globalThis || window;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/invoke-mock.ts
+const INVOKE_MOCK_KEY = "__wvb_invoke_mock__";
+//#endregion
+//#region src/platform-mock.ts
+const PLATFORM_MOCK_KEY = "__wvb_platform_mock__";
+//#endregion
+export { getWindow as i, INVOKE_MOCK_KEY as n, _defineProperty as r, PLATFORM_MOCK_KEY as t };

package/dist/testing/index.cjs

@@ -0,0 +1,117 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_platform_mock = require("../platform-mock-BmiQzf2l.cjs");
+//#region src/testing/mock.ts
+const store = /* @__PURE__ */ new Map();
+function ensureMocked() {
+	const w = require_platform_mock.getWindow();
+	if (w["__wvb_invoke_mock__"] != null) return;
+	w[require_platform_mock.INVOKE_MOCK_KEY] = (name, params) => {
+		const handler = store.get(name);
+		if (handler == null) return Promise.reject(/* @__PURE__ */ new Error(`[@wvb/bridge/testing] no mock registered for invoke "${name}"`));
+		const args = params == null ? [] : Object.values(params);
+		return Promise.resolve().then(() => handler(...args));
+	};
+}
+function toInvokeName(command) {
+	const [namespace = "", method = ""] = command.split(".");
+	return `${namespace}${method.charAt(0).toUpperCase()}${method.slice(1)}`;
+}
+function registerMockInvoke(command, handler) {
+	ensureMocked();
+	const name = toInvokeName(command);
+	store.set(name, handler);
+	const clear = () => {
+		if (store.get(name) === handler) store.delete(name);
+	};
+	return {
+		clear,
+		[Symbol.dispose]: clear
+	};
+}
+function clearInvokeMocks() {
+	store.clear();
+}
+//#endregion
+//#region src/testing/index.ts
+let _Symbol$dispose;
+/**
+* Registers a mock handler that responds a single bridge `invoke` command.
+*
+* Returns a `MockInvoke` (a `Disposable`): declare it with `using` to clear the mock
+* automatically when the scope exits, call `.clear()` to remove it manually, or let it
+* persist until {@link clearInvokeMocks}.
+*
+* @example
+* ```ts
+* import { source } from '@wvb/bridge';
+* import { mockInvoke } from '@wvb/bridge/testing';
+* import { expect, test } from 'vitest';
+*
+* test('loads the active version', async () => {
+*   using _mock = mockInvoke('source.loadVersion', bundleName => {
+*     expect(bundleName).toBe('app');
+*     return { type: 'remote', version: '1.0.0' };
+*   });
+*   await expect(source.loadVersion('app')).resolves.toEqual({ type: 'remote', version: '1.0.0' });
+* });
+* ```
+*/
+function mockInvoke(command, handler) {
+	return registerMockInvoke(command, handler);
+}
+/**
+* Mock platform type.
+*/
+function mockPlatform(type) {
+	const host = require_platform_mock.getWindow();
+	const previous = host[require_platform_mock.PLATFORM_MOCK_KEY];
+	host[require_platform_mock.PLATFORM_MOCK_KEY] = type;
+	return { [Symbol.dispose]() {
+		host[require_platform_mock.PLATFORM_MOCK_KEY] = previous;
+	} };
+}
+_Symbol$dispose = Symbol.dispose;
+var MockBridgeImpl = class {
+	constructor(options) {
+		require_platform_mock._defineProperty(this, "disposables", []);
+		if (options?.platform != null) this.disposables.push(mockPlatform(options.platform));
+	}
+	mockInvoke(command, handler) {
+		this.disposables.push(mockInvoke(command, handler));
+		return this;
+	}
+	clear() {
+		for (const disposable of this.disposables.reverse()) disposable[Symbol.dispose]();
+		this.disposables = [];
+	}
+	[_Symbol$dispose]() {
+		this.clear();
+	}
+};
+/**
+* Create a mock bridge instance.
+*
+* @example
+* ```ts
+* import { source } from '@wvb/bridge';
+* import { mockBridge } from '@wvb/bridge/testing';
+* import { expect, test } from 'vitest';
+*
+* test('loads the active version', async () => {
+*   using bridge = mockBridge()
+*     .mockInvoke('source.loadVersion', bundleName => {
+*       expect(bundleName).toBe('app');
+*       return { type: 'remote', version: '1.0.0' };
+*     });
+*
+*   await expect(source.loadVersion('app')).resolves.toEqual({ type: 'remote', version: '1.0.0' });
+* });
+*/
+function mockBridge(options) {
+	return new MockBridgeImpl(options);
+}
+//#endregion
+exports.clearInvokeMocks = clearInvokeMocks;
+exports.mockBridge = mockBridge;
+exports.mockInvoke = mockInvoke;
+exports.mockPlatform = mockPlatform;

package/dist/testing/index.d.cts

@@ -0,0 +1,75 @@
+import { f as RemoteApi, h as PlatformType, l as SourceApi, n as UpdaterApi } from "../index-B2ggQzrN.cjs";
+
+//#region src/testing/mock.d.ts
+interface MockInvoke extends Disposable {
+  clear(): void;
+}
+declare function clearInvokeMocks(): void;
+//#endregion
+//#region src/testing/typesmap.d.ts
+type Commands<Namespace extends string, Api> = { [K in keyof Api as `${Namespace}.${K & string}`]: Api[K] extends ((...args: infer P) => infer R) ? {
+  params: P;
+  result: Awaited<R>;
+} : never };
+type BridgeCommandMap = Commands<"source", SourceApi> & Commands<"remote", RemoteApi> & Commands<"updater", UpdaterApi>;
+type MockInvokeCommand = keyof BridgeCommandMap;
+type MockInvokeHandler<K extends MockInvokeCommand> = (...params: BridgeCommandMap[K]["params"]) => BridgeCommandMap[K]["result"] | Promise<BridgeCommandMap[K]["result"]>;
+//#endregion
+//#region src/testing/index.d.ts
+/**
+* Registers a mock handler that responds a single bridge `invoke` command.
+*
+* Returns a `MockInvoke` (a `Disposable`): declare it with `using` to clear the mock
+* automatically when the scope exits, call `.clear()` to remove it manually, or let it
+* persist until {@link clearInvokeMocks}.
+*
+* @example
+* ```ts
+* import { source } from '@wvb/bridge';
+* import { mockInvoke } from '@wvb/bridge/testing';
+* import { expect, test } from 'vitest';
+*
+* test('loads the active version', async () => {
+*   using _mock = mockInvoke('source.loadVersion', bundleName => {
+*     expect(bundleName).toBe('app');
+*     return { type: 'remote', version: '1.0.0' };
+*   });
+*   await expect(source.loadVersion('app')).resolves.toEqual({ type: 'remote', version: '1.0.0' });
+* });
+* ```
+*/
+declare function mockInvoke<K extends MockInvokeCommand>(command: K, handler: MockInvokeHandler<K>): MockInvoke;
+/**
+* Mock platform type.
+*/
+declare function mockPlatform(type: PlatformType): Disposable;
+interface MockBridge extends Disposable {
+  mockInvoke<K extends MockInvokeCommand>(command: K, handler: MockInvokeHandler<K>): this;
+  clear(): void;
+}
+interface MockBridgeOptions {
+  /** Platform type to mock. */
+  platform?: PlatformType;
+}
+/**
+* Create a mock bridge instance.
+*
+* @example
+* ```ts
+* import { source } from '@wvb/bridge';
+* import { mockBridge } from '@wvb/bridge/testing';
+* import { expect, test } from 'vitest';
+*
+* test('loads the active version', async () => {
+*   using bridge = mockBridge()
+*     .mockInvoke('source.loadVersion', bundleName => {
+*       expect(bundleName).toBe('app');
+*       return { type: 'remote', version: '1.0.0' };
+*     });
+*
+*   await expect(source.loadVersion('app')).resolves.toEqual({ type: 'remote', version: '1.0.0' });
+* });
+*/
+declare function mockBridge(options?: MockBridgeOptions): MockBridge;
+//#endregion
+export { type BridgeCommandMap, MockBridge, MockBridgeOptions, type MockInvoke, type MockInvokeCommand, type MockInvokeHandler, clearInvokeMocks, mockBridge, mockInvoke, mockPlatform };

package/dist/testing/index.d.ts

@@ -0,0 +1,75 @@
+import { f as RemoteApi, h as PlatformType, l as SourceApi, n as UpdaterApi } from "../index-B2ggQzrN.js";
+
+//#region src/testing/mock.d.ts
+interface MockInvoke extends Disposable {
+  clear(): void;
+}
+declare function clearInvokeMocks(): void;
+//#endregion
+//#region src/testing/typesmap.d.ts
+type Commands<Namespace extends string, Api> = { [K in keyof Api as `${Namespace}.${K & string}`]: Api[K] extends ((...args: infer P) => infer R) ? {
+  params: P;
+  result: Awaited<R>;
+} : never };
+type BridgeCommandMap = Commands<"source", SourceApi> & Commands<"remote", RemoteApi> & Commands<"updater", UpdaterApi>;
+type MockInvokeCommand = keyof BridgeCommandMap;
+type MockInvokeHandler<K extends MockInvokeCommand> = (...params: BridgeCommandMap[K]["params"]) => BridgeCommandMap[K]["result"] | Promise<BridgeCommandMap[K]["result"]>;
+//#endregion
+//#region src/testing/index.d.ts
+/**
+* Registers a mock handler that responds a single bridge `invoke` command.
+*
+* Returns a `MockInvoke` (a `Disposable`): declare it with `using` to clear the mock
+* automatically when the scope exits, call `.clear()` to remove it manually, or let it
+* persist until {@link clearInvokeMocks}.
+*
+* @example
+* ```ts
+* import { source } from '@wvb/bridge';
+* import { mockInvoke } from '@wvb/bridge/testing';
+* import { expect, test } from 'vitest';
+*
+* test('loads the active version', async () => {
+*   using _mock = mockInvoke('source.loadVersion', bundleName => {
+*     expect(bundleName).toBe('app');
+*     return { type: 'remote', version: '1.0.0' };
+*   });
+*   await expect(source.loadVersion('app')).resolves.toEqual({ type: 'remote', version: '1.0.0' });
+* });
+* ```
+*/
+declare function mockInvoke<K extends MockInvokeCommand>(command: K, handler: MockInvokeHandler<K>): MockInvoke;
+/**
+* Mock platform type.
+*/
+declare function mockPlatform(type: PlatformType): Disposable;
+interface MockBridge extends Disposable {
+  mockInvoke<K extends MockInvokeCommand>(command: K, handler: MockInvokeHandler<K>): this;
+  clear(): void;
+}
+interface MockBridgeOptions {
+  /** Platform type to mock. */
+  platform?: PlatformType;
+}
+/**
+* Create a mock bridge instance.
+*
+* @example
+* ```ts
+* import { source } from '@wvb/bridge';
+* import { mockBridge } from '@wvb/bridge/testing';
+* import { expect, test } from 'vitest';
+*
+* test('loads the active version', async () => {
+*   using bridge = mockBridge()
+*     .mockInvoke('source.loadVersion', bundleName => {
+*       expect(bundleName).toBe('app');
+*       return { type: 'remote', version: '1.0.0' };
+*     });
+*
+*   await expect(source.loadVersion('app')).resolves.toEqual({ type: 'remote', version: '1.0.0' });
+* });
+*/
+declare function mockBridge(options?: MockBridgeOptions): MockBridge;
+//#endregion
+export { type BridgeCommandMap, MockBridge, MockBridgeOptions, type MockInvoke, type MockInvokeCommand, type MockInvokeHandler, clearInvokeMocks, mockBridge, mockInvoke, mockPlatform };