@wvb/bridge 0.1.0-next.3603a22

package/dist/platform-mock-Bvaw9qjP.js

@@ -0,0 +1,50 @@
+//#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/window.ts
+function getWindow() {
+	return globalThis || window;
+}
+//#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 { _defineProperty as i, INVOKE_MOCK_KEY as n, getWindow as r, PLATFORM_MOCK_KEY as t };

package/dist/platform-mock-DrAsRJ91.cjs

@@ -0,0 +1,73 @@
+//#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/window.ts
+function getWindow() {
+	return globalThis || window;
+}
+//#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/testing/index.cjs

@@ -0,0 +1,117 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_platform_mock = require("../platform-mock-DrAsRJ91.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-eeBgJJSy.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-eeBgJJSy.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 };

package/dist/testing/index.js

@@ -0,0 +1,113 @@
+import { i as _defineProperty, n as INVOKE_MOCK_KEY, r as getWindow, t as PLATFORM_MOCK_KEY } from "../platform-mock-Bvaw9qjP.js";
+//#region src/testing/mock.ts
+const store = /* @__PURE__ */ new Map();
+function ensureMocked() {
+	const w = getWindow();
+	if (w["__wvb_invoke_mock__"] != null) return;
+	w[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 = getWindow();
+	const previous = host[PLATFORM_MOCK_KEY];
+	host[PLATFORM_MOCK_KEY] = type;
+	return { [Symbol.dispose]() {
+		host[PLATFORM_MOCK_KEY] = previous;
+	} };
+}
+_Symbol$dispose = Symbol.dispose;
+var MockBridgeImpl = class {
+	constructor(options) {
+		_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
+export { clearInvokeMocks, mockBridge, mockInvoke, mockPlatform };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@wvb/bridge",
+  "version": "0.1.0-next.3603a22",
+  "description": "WebView bridge",
+  "homepage": "https://github.com/webview-bundle/webview-bundle",
+  "bugs": {
+    "url": "https://github.com/webview-bundle/webview-bundle/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Seokju Na",
+    "email": "seokju.me@gmail.com",
+    "url": "https://github.com/seokju-na"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webview-bundle/webview-bundle",
+    "directory": "packages/bridge"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./testing": {
+      "import": "./dist/testing/index.js",
+      "require": "./dist/testing/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "prepack": "yarn build",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2"
+  },
+  "devDependencies": {
+    "tsdown": "0.22.1",
+    "type-fest": "^4.40.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8"
+  }
+}