@symbiote-native/camera 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,147 @@
 {
   "name": "@symbiote-native/camera",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "expo-camera wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. The camera preview, pictures, video recording and barcode scanning.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/camera"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/camera#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "keywords": [
+    "react-native",
+    "symbiote-native",
+    "expo-camera",
+    "react",
+    "vue",
+    "svelte",
+    "solid",
+    "angular",
+    "camera"
+  ],
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./svelte": "./src/svelte/index.ts",
+    "./solid": {
+      "types": "./build/solid/index.d.ts",
+      "default": "./build/solid/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-camera": "57.0.6",
+    "expo-modules-core": "57.0.20",
+    "@symbiote-native/components": "3.2.0"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "solid-js": ">=1.9.0",
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "^3.3.0",
+    "@symbiote-native/engine": "^1.6.0",
+    "@symbiote-native/react": "^3.3.0",
+    "@symbiote-native/solid": "^3.2.0",
+    "@symbiote-native/svelte": "^3.2.0",
+    "@symbiote-native/vue": "^3.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/solid": {
+      "optional": true
+    },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "solid-js": "^1.9.14",
+    "svelte": "^5.56.0",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "3.3.0",
+    "@symbiote-native/engine": "1.6.0",
+    "@symbiote-native/react": "3.3.0",
+    "@symbiote-native/solid": "3.2.0",
+    "@symbiote-native/svelte": "3.2.0",
+    "@symbiote-native/test-utils": "0.4.7",
+    "@symbiote-native/vue": "3.3.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
 }

package/src/angular/camera-view/index.ts

@@ -0,0 +1,95 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import { createCameraView } from '../../core';
+import type { ICameraViewHandle, ICameraViewProps } from '../../core';
+
+// One list is the inputs of the component and the props it hands to the native view
+const CAMERA_VIEW_INPUTS = [
+  'facing',
+  'flash',
+  'zoom',
+  'mode',
+  'mute',
+  'mirror',
+  'autofocus',
+  'active',
+  'videoQuality',
+  'videoBitrate',
+  'animateShutter',
+  'pictureSize',
+  'selectedLens',
+  'enableTorch',
+  'videoStabilizationMode',
+  'barcodeScannerSettings',
+  'responsiveOrientationWhenOrientationLocked',
+  'ratio',
+  'onCameraReady',
+  'onMountError',
+  'onBarcodeScanned',
+  'onResponsiveOrientationChanged',
+  'onAvailableLensesChanged',
+] as const;
+
+/** Angular twin of `expo-camera`'s `CameraView` */
+@Component({
+  selector: 'CameraView',
+  standalone: true,
+  imports: [DescriptorOutlet],
+  inputs: [...CAMERA_VIEW_INPUTS],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+})
+export class CameraView extends NativeViewBase {
+  // The inputs are named by `inputs`, these only type them for the template
+  declare facing?: ICameraViewProps['facing'];
+  declare flash?: ICameraViewProps['flash'];
+  declare zoom?: ICameraViewProps['zoom'];
+  declare mode?: ICameraViewProps['mode'];
+  declare mute?: ICameraViewProps['mute'];
+  declare mirror?: ICameraViewProps['mirror'];
+  declare autofocus?: ICameraViewProps['autofocus'];
+  declare active?: ICameraViewProps['active'];
+  declare videoQuality?: ICameraViewProps['videoQuality'];
+  declare videoBitrate?: ICameraViewProps['videoBitrate'];
+  declare animateShutter?: ICameraViewProps['animateShutter'];
+  declare pictureSize?: ICameraViewProps['pictureSize'];
+  declare selectedLens?: ICameraViewProps['selectedLens'];
+  declare enableTorch?: ICameraViewProps['enableTorch'];
+  declare videoStabilizationMode?: ICameraViewProps['videoStabilizationMode'];
+  declare barcodeScannerSettings?: ICameraViewProps['barcodeScannerSettings'];
+  declare responsiveOrientationWhenOrientationLocked?: ICameraViewProps['responsiveOrientationWhenOrientationLocked'];
+  declare ratio?: ICameraViewProps['ratio'];
+  declare onCameraReady?: ICameraViewProps['onCameraReady'];
+  declare onMountError?: ICameraViewProps['onMountError'];
+  declare onBarcodeScanned?: ICameraViewProps['onBarcodeScanned'];
+  declare onResponsiveOrientationChanged?: ICameraViewProps['onResponsiveOrientationChanged'];
+  declare onAvailableLensesChanged?: ICameraViewProps['onAvailableLensesChanged'];
+
+  private readonly view = createCameraView(() => this.hostNode());
+
+  // The functions of the view are copied onto the component, a `@ViewChild` reaches them
+  declare readonly takePictureAsync: ICameraViewHandle['takePictureAsync'];
+  declare readonly recordAsync: ICameraViewHandle['recordAsync'];
+  declare readonly toggleRecordingAsync: ICameraViewHandle['toggleRecordingAsync'];
+  declare readonly stopRecording: ICameraViewHandle['stopRecording'];
+  declare readonly pausePreview: ICameraViewHandle['pausePreview'];
+  declare readonly resumePreview: ICameraViewHandle['resumePreview'];
+  declare readonly getAvailablePictureSizesAsync: ICameraViewHandle['getAvailablePictureSizesAsync'];
+  declare readonly getAvailableLensesAsync: ICameraViewHandle['getAvailableLensesAsync'];
+  declare readonly getSupportedFeatures: ICameraViewHandle['getSupportedFeatures'];
+  declare readonly getHostNode: ICameraViewHandle['getHostNode'];
+
+  constructor() {
+    super();
+    Object.assign(this, this.view.handle);
+  }
+
+  protected override readonly propNames = CAMERA_VIEW_INPUTS;
+
+  protected override renderView(props: object): IDescriptor | null {
+    return this.view.render(props);
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,8 @@
+// @symbiote-native/camera/angular: камера, съёмка, запись видео и сканирование кодов на общем ядре
+
+export { CameraView } from './camera-view';
+export {
+  CameraPermissionsService,
+  MicrophonePermissionsService,
+} from './services/camera-permissions.service';
+export * from '../core';

package/src/angular/services/camera-permissions.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import {
+  cameraPermissionMethods,
+  microphonePermissionMethods,
+} from '../../core/camera-api';
+import type { PermissionResponse } from 'expo-modules-core';
+
+// Angular twin of `../../react`'s camera permission hooks
+@Injectable({ providedIn: 'root' })
+export class CameraPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+  constructor() {
+    super(
+      cameraPermissionMethods.getMethod,
+      cameraPermissionMethods.requestMethod,
+    );
+  }
+}
+
+@Injectable({ providedIn: 'root' })
+export class MicrophonePermissionsService extends PermissionsServiceBase<PermissionResponse> {
+  constructor() {
+    super(
+      microphonePermissionMethods.getMethod,
+      microphonePermissionMethods.requestMethod,
+    );
+  }
+}

package/src/core/android-barcode.ts

@@ -0,0 +1,51 @@
+// What Google's code scanner adds to a result, Android only
+
+type IAndroidBarcodeKind<TType extends string> = { type: TType };
+
+export type IAndroidBarcode =
+  | (IAndroidBarcodeKind<'contactInfo'> & {
+      firstName?: string;
+      middleName?: string;
+      lastName?: string;
+      title?: string;
+      organization?: string;
+      email?: string;
+      phone?: string;
+      url?: string;
+      address?: string;
+    })
+  | (IAndroidBarcodeKind<'geoPoint'> & { lat: string; lng: string })
+  | (IAndroidBarcodeKind<'sms'> & { phoneNumber?: string; message?: string })
+  | (IAndroidBarcodeKind<'url'> & { url?: string })
+  | (IAndroidBarcodeKind<'calendarEvent'> & {
+      summary?: string;
+      description?: string;
+      location?: string;
+      start?: string;
+      end?: string;
+    })
+  | (IAndroidBarcodeKind<'driverLicense'> & {
+      firstName?: string;
+      middleName?: string;
+      lastName?: string;
+      licenseNumber?: string;
+      expiryDate?: string;
+      issueDate?: string;
+      addressStreet?: string;
+      addressCity?: string;
+      addressState?: string;
+    })
+  | (IAndroidBarcodeKind<'email'> & {
+      address?: string;
+      subject?: string;
+      body?: string;
+    })
+  | (IAndroidBarcodeKind<'phone'> & {
+      number?: string;
+      phoneNumberType?: string;
+    })
+  | (IAndroidBarcodeKind<'wifi'> & {
+      ssid?: string;
+      password?: string;
+      encryptionType?: string;
+    });

package/src/core/camera-api.ts

@@ -0,0 +1,99 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import type { EventSubscription, PermissionResponse } from 'expo-modules-core';
+import { CAMERA_PACKAGE_NAME, MODERN_SCANNER_EVENT } from './constants';
+import { expoCamera } from './native-module';
+import type {
+  ICameraBarcodeScanningResult,
+  ICameraBarcodeType,
+  ICameraScanningOptions,
+  ICameraScanningResult,
+  ICameraVideoCodec,
+} from './types';
+
+/** Whether the device has a camera, the permissions are a separate question */
+export async function isCameraAvailableAsync(): Promise<boolean> {
+  if (!expoCamera.isAvailableAsync) {
+    throw new UnavailabilityError(CAMERA_PACKAGE_NAME, 'isAvailableAsync');
+  }
+  return expoCamera.isAvailableAsync();
+}
+
+/** iOS only */
+export async function getAvailableVideoCodecsAsync(): Promise<
+  ICameraVideoCodec[]
+> {
+  if (!expoCamera.getAvailableVideoCodecsAsync) {
+    throw new UnavailabilityError('Camera', 'getAvailableVideoCodecsAsync');
+  }
+  return expoCamera.getAvailableVideoCodecsAsync();
+}
+
+/** Whether the device has `DataScannerViewController` (iOS 16+) or Google's code scanner */
+export function isModernBarcodeScannerAvailable(): boolean {
+  return expoCamera.isModernBarcodeScannerAvailable;
+}
+
+/** A device without the modern scanner does nothing here */
+export async function launchScanner(
+  options: ICameraScanningOptions = { barcodeTypes: [] },
+): Promise<void> {
+  if (expoCamera.isModernBarcodeScannerAvailable) {
+    await expoCamera.launchScanner(options);
+  }
+}
+
+/** Dismisses the scanner on iOS, on Android it closes itself after a scan */
+export async function dismissScanner(): Promise<void> {
+  if (expoCamera.isModernBarcodeScannerAvailable) {
+    await expoCamera.dismissScanner();
+  }
+}
+
+export function onModernBarcodeScanned(
+  listener: (event: ICameraScanningResult) => void,
+): EventSubscription {
+  return expoCamera.addListener(MODERN_SCANNER_EVENT, listener);
+}
+
+/** Only QR codes are scanned on iOS */
+export async function scanFromURLAsync(
+  url: string,
+  barcodeTypes: ICameraBarcodeType[] = ['qr'],
+): Promise<ICameraBarcodeScanningResult[]> {
+  return expoCamera.scanFromURLAsync(url, barcodeTypes);
+}
+
+async function getCameraPermissionsAsync(): Promise<PermissionResponse> {
+  return expoCamera.getCameraPermissionsAsync();
+}
+
+async function requestCameraPermissionsAsync(): Promise<PermissionResponse> {
+  return expoCamera.requestCameraPermissionsAsync();
+}
+
+async function getMicrophonePermissionsAsync(): Promise<PermissionResponse> {
+  return expoCamera.getMicrophonePermissionsAsync();
+}
+
+async function requestMicrophonePermissionsAsync(): Promise<PermissionResponse> {
+  return expoCamera.requestMicrophonePermissionsAsync();
+}
+
+export const Camera = {
+  getCameraPermissionsAsync,
+  requestCameraPermissionsAsync,
+  getMicrophonePermissionsAsync,
+  requestMicrophonePermissionsAsync,
+  scanFromURLAsync,
+};
+
+// What every adapter's `createPermissionHook` binds, `useCameraPermissions` and its twin
+export const cameraPermissionMethods = {
+  getMethod: getCameraPermissionsAsync,
+  requestMethod: requestCameraPermissionsAsync,
+};
+
+export const microphonePermissionMethods = {
+  getMethod: getMicrophonePermissionsAsync,
+  requestMethod: requestMicrophonePermissionsAsync,
+};

package/src/core/camera-view-events.ts

@@ -0,0 +1,108 @@
+import type { ISymbioteEvent } from '@symbiote-native/engine';
+import { BARCODE_EVENT_THROTTLE_MS } from './constants';
+import { handlePictureSaved } from './picture-options';
+import type {
+  ICameraAvailableLenses,
+  ICameraBarcodeScanningResult,
+  ICameraCapturedPicture,
+  ICameraMountError,
+  ICameraResponsiveOrientation,
+} from './types';
+
+type IGuard<TPayload> = (value: unknown) => value is TPayload;
+
+function hasField(value: unknown, key: string, kind: string): boolean {
+  return typeof Reflect.get(Object(value), key) === kind;
+}
+
+const isMountError: IGuard<ICameraMountError> = (
+  value,
+): value is ICameraMountError => hasField(value, 'message', 'string');
+
+const isOrientation: IGuard<ICameraResponsiveOrientation> = (
+  value,
+): value is ICameraResponsiveOrientation =>
+  hasField(value, 'orientation', 'string');
+
+const isLenses: IGuard<ICameraAvailableLenses> = (
+  value,
+): value is ICameraAvailableLenses =>
+  Array.isArray(Reflect.get(Object(value), 'lenses'));
+
+const isScanningResult: IGuard<ICameraBarcodeScanningResult> = (
+  value,
+): value is ICameraBarcodeScanningResult =>
+  hasField(value, 'type', 'string') && hasField(value, 'data', 'string');
+
+function isPictureSaved(
+  value: unknown,
+): value is { data: ICameraCapturedPicture; id: number } {
+  return hasField(value, 'id', 'number') && hasField(value, 'data', 'object');
+}
+
+// Hands the callback the payload inside the native event, and only when it has the expected shape
+function forward<TPayload>(
+  props: object,
+  name: string,
+  isPayload: IGuard<TPayload>,
+) {
+  return (event: ISymbioteEvent): void => {
+    const callback: unknown = Reflect.get(props, name);
+    if (typeof callback === 'function' && isPayload(event.nativeEvent)) {
+      callback(event.nativeEvent);
+    }
+  };
+}
+
+export type ICameraViewEvents = (props: object) => Record<string, unknown>;
+
+/** One per view, the throttle of the barcode events belongs to the view */
+export function createCameraViewEvents(): ICameraViewEvents {
+  const lastScans = new Map<string, { json: string; at: number }>();
+
+  // Equal events of one type inside the window are the same scan seen again
+  const throttledScan =
+    (callback: (result: ICameraBarcodeScanningResult) => void) =>
+    (event: ISymbioteEvent): void => {
+      const result = event.nativeEvent;
+      if (!isScanningResult(result)) return;
+      const json = JSON.stringify(result);
+      const now = Date.now();
+      const last = lastScans.get(result.type);
+      if (last?.json === json && now - last.at < BARCODE_EVENT_THROTTLE_MS) {
+        return;
+      }
+      callback(result);
+      lastScans.set(result.type, { json, at: now });
+    };
+
+  return props => {
+    const onBarcodeScanned: unknown = Reflect.get(props, 'onBarcodeScanned');
+    const onCameraReady: unknown = Reflect.get(props, 'onCameraReady');
+    return {
+      onCameraReady: () => {
+        if (typeof onCameraReady === 'function') onCameraReady();
+      },
+      onMountError: forward(props, 'onMountError', isMountError),
+      onBarcodeScanned:
+        typeof onBarcodeScanned === 'function'
+          ? throttledScan(result => onBarcodeScanned(result))
+          : undefined,
+      onAvailableLensesChanged: forward(
+        props,
+        'onAvailableLensesChanged',
+        isLenses,
+      ),
+      onResponsiveOrientationChanged: forward(
+        props,
+        'onResponsiveOrientationChanged',
+        isOrientation,
+      ),
+      onPictureSaved: (event: ISymbioteEvent): void => {
+        if (isPictureSaved(event.nativeEvent)) {
+          handlePictureSaved({ nativeEvent: event.nativeEvent });
+        }
+      },
+    };
+  };
+}

package/src/core/camera-view-handle.ts

@@ -0,0 +1,105 @@
+import { Platform, requireNativeModule } from 'expo-modules-core';
+import { defineExpoViewMethods, getNativeTag } from '@symbiote-native/engine';
+import type { ISymbioteNode } from '@symbiote-native/engine';
+import { CAMERA_MODULE_NAME } from './constants';
+import { expoCamera } from './native-module';
+import type { ICameraPictureRef } from './native-module';
+import {
+  ensurePictureOptions,
+  ensureRecordingOptions,
+} from './picture-options';
+import type {
+  ICameraCapturedPicture,
+  ICameraPictureOptions,
+  ICameraRecordingOptions,
+  ICameraSupportedFeatures,
+} from './types';
+
+export type ICameraViewHandle = {
+  /** Waits for `onCameraReady` first. With `pictureRef` it resolves to a native image reference */
+  takePictureAsync(
+    options: ICameraPictureOptions & { pictureRef: true },
+  ): Promise<ICameraPictureRef | undefined>;
+  takePictureAsync(
+    options?: ICameraPictureOptions,
+  ): Promise<ICameraCapturedPicture | undefined>;
+  /** Resolves when `stopRecording` runs, a limit is reached or the preview stops */
+  recordAsync(
+    options?: ICameraRecordingOptions,
+  ): Promise<{ uri: string } | undefined>;
+  /** Pauses or resumes the recording, iOS 18 and later on iOS */
+  toggleRecordingAsync(): Promise<void>;
+  stopRecording(): void;
+  pausePreview(): Promise<void>;
+  resumePreview(): Promise<void>;
+  getAvailablePictureSizesAsync(): Promise<string[]>;
+  /** Lenses exist on iOS only */
+  getAvailableLensesAsync(): Promise<string[]>;
+  getSupportedFeatures(): ICameraSupportedFeatures;
+  /** The host node of the mounted view, `createCameraTextureAsync` of a GL view takes it */
+  getHostNode(): ISymbioteNode | null;
+};
+
+const callViewFunction = defineExpoViewMethods(
+  requireNativeModule,
+  CAMERA_MODULE_NAME,
+);
+
+export function createCameraViewHandle(
+  getNode: () => ISymbioteNode | null | undefined,
+): ICameraViewHandle {
+  // Like upstream's `ref.current?.`, a view that has not committed yet answers nothing
+  function call<TResult>(
+    method: string,
+    args: readonly unknown[] = [],
+  ): TResult | undefined {
+    const node = getNode();
+    if (!node || getNativeTag(node) === undefined) return undefined;
+    return callViewFunction<TResult>(node, method, args);
+  }
+
+  async function takePictureAsync(
+    options: ICameraPictureOptions & { pictureRef: true },
+  ): Promise<ICameraPictureRef | undefined>;
+  async function takePictureAsync(
+    options?: ICameraPictureOptions,
+  ): Promise<ICameraCapturedPicture | undefined>;
+  async function takePictureAsync(options?: ICameraPictureOptions) {
+    const pictureOptions = ensurePictureOptions(options);
+    // The picture ref is an iOS feature, Android answers a plain picture
+    if (
+      Platform.select({ ios: Boolean(options?.pictureRef), default: false })
+    ) {
+      return call<Promise<ICameraPictureRef>>('takePictureRef', [
+        pictureOptions,
+      ]);
+    }
+    return call<Promise<ICameraCapturedPicture>>('takePicture', [
+      pictureOptions,
+    ]);
+  }
+
+  return {
+    takePictureAsync,
+    recordAsync: async options =>
+      call<Promise<{ uri: string }>>('record', [
+        ensureRecordingOptions(options),
+      ]),
+    toggleRecordingAsync: async () => call<Promise<void>>('toggleRecording'),
+    stopRecording: () => {
+      call('stopRecording');
+    },
+    pausePreview: async () => call<Promise<void>>('pausePreview'),
+    resumePreview: async () => call<Promise<void>>('resumePreview'),
+    getAvailablePictureSizesAsync: async () =>
+      (await call<Promise<string[]>>('getAvailablePictureSizes')) ?? [],
+    getAvailableLensesAsync: async () =>
+      (await call<Promise<string[]>>('getAvailableLenses')) ?? [],
+    getSupportedFeatures: () => ({
+      isModernBarcodeScannerAvailable:
+        expoCamera.isModernBarcodeScannerAvailable,
+      toggleRecordingAsyncAvailable: expoCamera.toggleRecordingAsyncAvailable,
+    }),
+    getHostNode: () => getNode() ?? null,
+  };
+}