add initial marp implementation with sample content and build configuration

node_modules/webdriver-bidi-protocol/src/gen/permissions.ts

@@ -0,0 +1,27 @@
+export type PermissionsCommand = Permissions.SetPermission;
+export namespace Permissions {
+  export type PermissionDescriptor = {
+    name: string;
+  };
+}
+export namespace Permissions {
+  export const enum PermissionState {
+    Granted = 'granted',
+    Denied = 'denied',
+    Prompt = 'prompt',
+  }
+}
+export namespace Permissions {
+  export type SetPermission = {
+    method: 'permissions.setPermission';
+    params: Permissions.SetPermissionParameters;
+  };
+}
+export namespace Permissions {
+  export type SetPermissionParameters = {
+    descriptor: Permissions.PermissionDescriptor;
+    state: Permissions.PermissionState;
+    origin: string;
+    userContext?: string;
+  };
+}

node_modules/webdriver-bidi-protocol/src/gen/web-bluetooth.ts

@@ -0,0 +1,315 @@
+export namespace Bluetooth {
+  export type BluetoothUuid = string;
+}
+export namespace Bluetooth {
+  export type BluetoothManufacturerData = {
+    key: number;
+    data: string;
+  };
+}
+export namespace Bluetooth {
+  export type CharacteristicProperties = {
+    broadcast?: boolean;
+    read?: boolean;
+    writeWithoutResponse?: boolean;
+    write?: boolean;
+    notify?: boolean;
+    indicate?: boolean;
+    authenticatedSignedWrites?: boolean;
+    extendedProperties?: boolean;
+  };
+}
+export namespace Bluetooth {
+  export type RequestDevice = string;
+}
+export namespace Bluetooth {
+  export type RequestDeviceInfo = {
+    id: Bluetooth.RequestDevice;
+    name: string | null;
+  };
+}
+export namespace Bluetooth {
+  export type RequestDevicePrompt = string;
+}
+export namespace Bluetooth {
+  export type ScanRecord = {
+    name?: string;
+    uuids?: [...Bluetooth.BluetoothUuid[]];
+    appearance?: number;
+    manufacturerData?: [...Bluetooth.BluetoothManufacturerData[]];
+  };
+}
+export type BluetoothCommand =
+  | Bluetooth.HandleRequestDevicePrompt
+  | Bluetooth.SimulateAdapter
+  | Bluetooth.DisableSimulation
+  | Bluetooth.SimulatePreconnectedPeripheral
+  | Bluetooth.SimulateAdvertisement
+  | Bluetooth.SimulateGattConnectionResponse
+  | Bluetooth.SimulateGattDisconnection
+  | Bluetooth.SimulateService
+  | Bluetooth.SimulateCharacteristic
+  | Bluetooth.SimulateCharacteristicResponse
+  | Bluetooth.SimulateDescriptor
+  | Bluetooth.SimulateDescriptorResponse
+  | Record<string, never>;
+export namespace Bluetooth {
+  export type HandleRequestDevicePrompt = {
+    method: 'bluetooth.handleRequestDevicePrompt';
+    params: Bluetooth.HandleRequestDevicePromptParameters;
+  };
+}
+export namespace Bluetooth {
+  export type HandleRequestDevicePromptParameters = {
+    context: string;
+    prompt: Bluetooth.RequestDevicePrompt;
+  } & (
+    | Bluetooth.HandleRequestDevicePromptAcceptParameters
+    | Bluetooth.HandleRequestDevicePromptCancelParameters
+  );
+}
+export namespace Bluetooth {
+  export type HandleRequestDevicePromptAcceptParameters = {
+    accept: true;
+    device: Bluetooth.RequestDevice;
+  };
+}
+export namespace Bluetooth {
+  export type HandleRequestDevicePromptCancelParameters = {
+    accept: false;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateAdapter = {
+    method: 'bluetooth.simulateAdapter';
+    params: Bluetooth.SimulateAdapterParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateAdapterParameters = {
+    context: string;
+    leSupported?: boolean;
+    state: 'absent' | 'powered-off' | 'powered-on';
+  };
+}
+export namespace Bluetooth {
+  export type DisableSimulation = {
+    method: 'bluetooth.disableSimulation';
+    params: Bluetooth.DisableSimulationParameters;
+  };
+}
+export namespace Bluetooth {
+  export type DisableSimulationParameters = {
+    context: string;
+  };
+}
+export namespace Bluetooth {
+  export type SimulatePreconnectedPeripheral = {
+    method: 'bluetooth.simulatePreconnectedPeripheral';
+    params: Bluetooth.SimulatePreconnectedPeripheralParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulatePreconnectedPeripheralParameters = {
+    context: string;
+    address: string;
+    name: string;
+    manufacturerData: [...Bluetooth.BluetoothManufacturerData[]];
+    knownServiceUuids: [...Bluetooth.BluetoothUuid[]];
+  };
+}
+export namespace Bluetooth {
+  export type SimulateAdvertisement = {
+    method: 'bluetooth.simulateAdvertisement';
+    params: Bluetooth.SimulateAdvertisementParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateAdvertisementParameters = {
+    context: string;
+    scanEntry: Bluetooth.SimulateAdvertisementScanEntryParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateAdvertisementScanEntryParameters = {
+    deviceAddress: string;
+    rssi: number;
+    scanRecord: Bluetooth.ScanRecord;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateGattConnectionResponse = {
+    method: 'bluetooth.simulateGattConnectionResponse';
+    params: Bluetooth.SimulateGattConnectionResponseParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateGattConnectionResponseParameters = {
+    context: string;
+    address: string;
+    code: number;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateGattDisconnection = {
+    method: 'bluetooth.simulateGattDisconnection';
+    params: Bluetooth.SimulateGattDisconnectionParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateGattDisconnectionParameters = {
+    context: string;
+    address: string;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateService = {
+    method: 'bluetooth.simulateService';
+    params: Bluetooth.SimulateServiceParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateServiceParameters = {
+    context: string;
+    address: string;
+    uuid: Bluetooth.BluetoothUuid;
+    type: 'add' | 'remove';
+  };
+}
+export namespace Bluetooth {
+  export type SimulateCharacteristic = {
+    method: 'bluetooth.simulateCharacteristic';
+    params: Bluetooth.SimulateCharacteristicParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateCharacteristicParameters = {
+    context: string;
+    address: string;
+    serviceUuid: Bluetooth.BluetoothUuid;
+    characteristicUuid: Bluetooth.BluetoothUuid;
+    characteristicProperties?: Bluetooth.CharacteristicProperties;
+    type: 'add' | 'remove';
+  };
+}
+export namespace Bluetooth {
+  export type SimulateCharacteristicResponse = {
+    method: 'bluetooth.simulateCharacteristicResponse';
+    params: Bluetooth.SimulateCharacteristicResponseParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateCharacteristicResponseParameters = {
+    context: string;
+    address: string;
+    serviceUuid: Bluetooth.BluetoothUuid;
+    characteristicUuid: Bluetooth.BluetoothUuid;
+    type:
+      | 'read'
+      | 'write'
+      | 'subscribe-to-notifications'
+      | 'unsubscribe-from-notifications';
+    code: number;
+    data?: [...number[]];
+  };
+}
+export namespace Bluetooth {
+  export type SimulateDescriptor = {
+    method: 'bluetooth.simulateDescriptor';
+    params: Bluetooth.SimulateDescriptorParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateDescriptorParameters = {
+    context: string;
+    address: string;
+    serviceUuid: Bluetooth.BluetoothUuid;
+    characteristicUuid: Bluetooth.BluetoothUuid;
+    descriptorUuid: Bluetooth.BluetoothUuid;
+    type: 'add' | 'remove';
+  };
+}
+export namespace Bluetooth {
+  export type SimulateDescriptorResponse = {
+    method: 'bluetooth.simulateDescriptorResponse';
+    params: Bluetooth.SimulateDescriptorResponseParameters;
+  };
+}
+export namespace Bluetooth {
+  export type SimulateDescriptorResponseParameters = {
+    context: string;
+    address: string;
+    serviceUuid: Bluetooth.BluetoothUuid;
+    characteristicUuid: Bluetooth.BluetoothUuid;
+    descriptorUuid: Bluetooth.BluetoothUuid;
+    type: 'read' | 'write';
+    code: number;
+    data?: [...number[]];
+  };
+}
+export type BluetoothEvent =
+  | Bluetooth.RequestDevicePromptUpdated
+  | Bluetooth.GattConnectionAttempted;
+export namespace Bluetooth {
+  export type RequestDevicePromptUpdated = {
+    method: 'bluetooth.requestDevicePromptUpdated';
+    params: Bluetooth.RequestDevicePromptUpdatedParameters;
+  };
+}
+export namespace Bluetooth {
+  export type RequestDevicePromptUpdatedParameters = {
+    context: string;
+    prompt: Bluetooth.RequestDevicePrompt;
+    devices: [...Bluetooth.RequestDeviceInfo[]];
+  };
+}
+export namespace Bluetooth {
+  export type GattConnectionAttempted = {
+    method: 'bluetooth.gattConnectionAttempted';
+    params: Bluetooth.GattConnectionAttemptedParameters;
+  };
+}
+export namespace Bluetooth {
+  export type GattConnectionAttemptedParameters = {
+    context: string;
+    address: string;
+  };
+}
+export namespace Bluetooth {
+  export type CharacteristicEventGenerated = {
+    method: 'bluetooth.characteristicEventGenerated';
+    params: Bluetooth.CharacteristicEventGeneratedParameters;
+  };
+}
+export namespace Bluetooth {
+  export type CharacteristicEventGeneratedParameters = {
+    context: string;
+    address: string;
+    serviceUuid: Bluetooth.BluetoothUuid;
+    characteristicUuid: Bluetooth.BluetoothUuid;
+    type:
+      | 'read'
+      | 'write-with-response'
+      | 'write-without-response'
+      | 'subscribe-to-notifications'
+      | 'unsubscribe-from-notifications';
+    data?: [...number[]];
+  };
+}
+export namespace Bluetooth {
+  export type DescriptorEventGenerated = {
+    method: 'bluetooth.descriptorEventGenerated';
+    params: Bluetooth.DescriptorEventGeneratedParameters;
+  };
+}
+export namespace Bluetooth {
+  export type DescriptorEventGeneratedParameters = {
+    context: string;
+    address: string;
+    serviceUuid: Bluetooth.BluetoothUuid;
+    characteristicUuid: Bluetooth.BluetoothUuid;
+    descriptorUuid: Bluetooth.BluetoothUuid;
+    type: 'read' | 'write';
+    data?: [...number[]];
+  };
+}

node_modules/webdriver-bidi-protocol/src/index.ts

@@ -0,0 +1,295 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Bidi from './gen/main.js';
+import * as BidiPermissions from './gen/permissions.js';
+import * as BidiBluetooth from './gen/web-bluetooth.js';
+
+export * from './gen/main.js';
+export * from './gen/permissions.js';
+export * from './gen/web-bluetooth.js';
+
+type ExternalSpecCommand<T> = {
+  // id is defined by the main WebDriver BiDi spec and extension specs do
+  // not re-define it. Therefore, it's not part of generated types.
+  id: Bidi.JsUint;
+} & T;
+
+type ExternalSpecEvent<T> = {
+  // type is defined by the main WebDriver BiDi spec and extension specs do
+  // not re-define it. Therefore, it's not part of generated types.
+  type: 'event';
+} & T &
+  Bidi.Extensible;
+
+export type Command =
+  | Bidi.Command
+  | ExternalSpecCommand<BidiPermissions.PermissionsCommand>
+  | ExternalSpecCommand<BidiBluetooth.BluetoothCommand>;
+
+export type Event =
+  | Bidi.Event
+  | ExternalSpecEvent<BidiBluetooth.BluetoothEvent>;
+
+// TODO: is there a way to generate this mapping?
+export interface Commands {
+  'bluetooth.handleRequestDevicePrompt': {
+    params: BidiBluetooth.Bluetooth.HandleRequestDevicePromptParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.disableSimulation': {
+    params: BidiBluetooth.Bluetooth.DisableSimulationParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.simulateAdapter': {
+    params: BidiBluetooth.Bluetooth.SimulateAdapterParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.simulateAdvertisement': {
+    params: BidiBluetooth.Bluetooth.SimulateAdvertisementParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.simulatePreconnectedPeripheral': {
+    params: BidiBluetooth.Bluetooth.SimulatePreconnectedPeripheralParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.simulateGattDisconnection': {
+    params: BidiBluetooth.Bluetooth.SimulateGattDisconnectionParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.simulateDescriptor': {
+    params: BidiBluetooth.Bluetooth.SimulateDescriptorParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'bluetooth.simulateDescriptorResponse': {
+    params: BidiBluetooth.Bluetooth.SimulateDescriptorResponseParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'browser.close': {
+    params: Bidi.EmptyParams;
+    returnType: Bidi.EmptyResult;
+  };
+  'browser.getgetClientWindows': {
+    params: Bidi.EmptyParams;
+    returnType: Bidi.Browser.GetClientWindowsResult;
+  };
+  'browser.createUserContext': {
+    params: Bidi.EmptyParams;
+    returnType: Bidi.Browser.CreateUserContextResult;
+  };
+  'browser.getUserContexts': {
+    params: Bidi.EmptyParams;
+    returnType: Bidi.Browser.GetUserContextsResult;
+  };
+  'browser.removeUserContext': {
+    params: {
+      userContext: Bidi.Browser.UserContext;
+    };
+    returnType: Bidi.Browser.RemoveUserContext;
+  };
+  'browser.setClientWindowState': {
+    params: Bidi.Browser.SetClientWindowStateParameters;
+    returnType: Bidi.Browser.ClientWindowInfo;
+  };
+
+  'browsingContext.activate': {
+    params: Bidi.BrowsingContext.ActivateParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'browsingContext.create': {
+    params: Bidi.BrowsingContext.CreateParameters;
+    returnType: Bidi.BrowsingContext.CreateResult;
+  };
+  'browsingContext.close': {
+    params: Bidi.BrowsingContext.CloseParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'browsingContext.getTree': {
+    params: Bidi.BrowsingContext.GetTreeParameters;
+    returnType: Bidi.BrowsingContext.GetTreeResult;
+  };
+  'browsingContext.locateNodes': {
+    params: Bidi.BrowsingContext.LocateNodesParameters;
+    returnType: Bidi.BrowsingContext.LocateNodesResult;
+  };
+  'browsingContext.navigate': {
+    params: Bidi.BrowsingContext.NavigateParameters;
+    returnType: Bidi.BrowsingContext.NavigateResult;
+  };
+  'browsingContext.reload': {
+    params: Bidi.BrowsingContext.ReloadParameters;
+    returnType: Bidi.BrowsingContext.NavigateResult;
+  };
+  'browsingContext.print': {
+    params: Bidi.BrowsingContext.PrintParameters;
+    returnType: Bidi.BrowsingContext.PrintResult;
+  };
+  'browsingContext.captureScreenshot': {
+    params: Bidi.BrowsingContext.CaptureScreenshotParameters;
+    returnType: Bidi.BrowsingContext.CaptureScreenshotResult;
+  };
+  'browsingContext.handleUserPrompt': {
+    params: Bidi.BrowsingContext.HandleUserPromptParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'browsingContext.setViewport': {
+    params: Bidi.BrowsingContext.SetViewportParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'browsingContext.traverseHistory': {
+    params: Bidi.BrowsingContext.TraverseHistoryParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'emulation.setForcedColorsModeThemeOverride': {
+    params: Bidi.Emulation.SetForcedColorsModeThemeOverrideParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'emulation.setGeolocationOverride': {
+    params: Bidi.Emulation.SetGeolocationOverrideParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'emulation.setLocaleOverride': {
+    params: Bidi.Emulation.SetLocaleOverrideParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'emulation.setScreenOrientationOverride': {
+    params: Bidi.Emulation.SetScreenOrientationOverrideParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'emulation.setTimezoneOverride': {
+    params: Bidi.Emulation.SetTimezoneOverrideParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'input.performActions': {
+    params: Bidi.Input.PerformActionsParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'input.releaseActions': {
+    params: Bidi.Input.ReleaseActionsParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'input.setFiles': {
+    params: Bidi.Input.SetFilesParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'permissions.setPermission': {
+    params: BidiPermissions.Permissions.SetPermissionParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'script.evaluate': {
+    params: Bidi.Script.EvaluateParameters;
+    returnType: Bidi.Script.EvaluateResult;
+  };
+  'script.callFunction': {
+    params: Bidi.Script.CallFunctionParameters;
+    returnType: Bidi.Script.EvaluateResult;
+  };
+  'script.disown': {
+    params: Bidi.Script.DisownParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'script.addPreloadScript': {
+    params: Bidi.Script.AddPreloadScriptParameters;
+    returnType: Bidi.Script.AddPreloadScriptResult;
+  };
+  'script.removePreloadScript': {
+    params: Bidi.Script.RemovePreloadScriptParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'session.end': {
+    params: Bidi.EmptyParams;
+    returnType: Bidi.EmptyResult;
+  };
+  'session.new': {
+    params: Bidi.Session.NewParameters;
+    returnType: Bidi.Session.NewResult;
+  };
+  'session.status': {
+    params: object;
+    returnType: Bidi.Session.StatusResult;
+  };
+  'session.subscribe': {
+    params: Bidi.Session.SubscriptionRequest;
+    returnType: Bidi.EmptyResult;
+  };
+  'session.unsubscribe': {
+    params: Bidi.Session.SubscriptionRequest;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'storage.deleteCookies': {
+    params: Bidi.Storage.DeleteCookiesParameters;
+    returnType: Bidi.Storage.DeleteCookiesResult;
+  };
+  'storage.getCookies': {
+    params: Bidi.Storage.GetCookiesParameters;
+    returnType: Bidi.Storage.GetCookiesResult;
+  };
+  'storage.setCookie': {
+    params: Bidi.Storage.SetCookieParameters;
+    returnType: Bidi.Storage.SetCookieParameters;
+  };
+
+  'network.addDataCollector': {
+    params: Bidi.Network.AddDataCollectorParameters;
+    returnType: Bidi.Network.AddDataCollectorResult;
+  };
+  'network.addIntercept': {
+    params: Bidi.Network.AddInterceptParameters;
+    returnType: Bidi.Network.AddInterceptResult;
+  };
+  'network.removeIntercept': {
+    params: Bidi.Network.RemoveInterceptParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.continueRequest': {
+    params: Bidi.Network.ContinueRequestParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.continueWithAuth': {
+    params: Bidi.Network.ContinueWithAuthParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.failRequest': {
+    params: Bidi.Network.FailRequestParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.provideResponse': {
+    params: Bidi.Network.ProvideResponseParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.disownData': {
+    params: Bidi.Network.DisownDataParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.getData': {
+    params: Bidi.Network.GetDataParameters;
+    returnType: Bidi.Network.GetDataResult;
+  };
+  'network.setCacheBehavior': {
+    params: Bidi.Network.SetCacheBehaviorParameters;
+    returnType: Bidi.EmptyResult;
+  };
+  'network.setExtraHeaders': {
+    params: Bidi.Network.SetExtraHeadersParameters;
+    returnType: Bidi.EmptyResult;
+  };
+
+  'webExtension.install': {
+    params: Bidi.WebExtension.InstallParameters;
+    returnType: Bidi.WebExtension.InstallResult;
+  };
+  'webExtension.uninstall': {
+    params: Bidi.WebExtension.UninstallParameters;
+    returnType: Bidi.EmptyResult;
+  };
+}