@platforma-sdk/ui-vue 1.40.6 → 1.41.1

package/src/internal/createAppV2.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createAppV2 } from './createAppV2';
+import { unwrapResult, type ValueOrErrors } from '@platforma-sdk/model';
+import { BlockStateMock } from './test-helpers/BlockMock';
+import { BlockMock } from './test-helpers/BlockMock';
+import { delay } from '@milaboratories/helpers';
+import { createMockApi } from './test-helpers/createMockApi';
+import { watch } from 'vue';
+import { patchPoolingDelay } from './createAppV2';
+
+type Args = {
+  x: number;
+  y: number;
+};
+
+type UiState = {
+  label: string;
+  delay?: number;
+};
+
+const defaultArgs = () => ({
+  x: 0,
+  y: 0,
+});
+
+type Outputs = {
+  sum: ValueOrErrors<number>;
+};
+
+const defaultOutputs = (): Outputs => {
+  return {
+    sum: {
+      ok: true,
+      value: 0,
+    },
+  };
+};
+
+const defaultState = (): BlockStateMock<Args, Outputs, UiState, `/${string}`> => {
+  return new BlockStateMock(defaultArgs(), defaultOutputs(), { label: '' }, '/');
+};
+
+class BlockSum extends BlockMock<Args, Outputs, UiState, `/${string}`> {
+  async process(): Promise<void> {
+    const { args, author } = this.state;
+    this.state.setState({ author, outputs: { sum: { ok: true, value: args.x + args.y } } });
+  }
+}
+
+export const platforma = createMockApi<Args, Outputs, UiState>(new BlockSum(defaultState()));
+
+describe('createApp', { timeout: 20_000 }, () => {
+  beforeEach(() => {
+    // Mock window.addEventListener to prevent actual event listeners
+    vi.stubGlobal('window', {
+      addEventListener: vi.fn(),
+    });
+  });
+
+  it('should create an app with reactive snapshot', async () => {
+    const initialState = await platforma.loadBlockState().then(unwrapResult);
+
+    const app = createAppV2(initialState, platforma, { debug: true, debounceSpan: 10 });
+
+    expect(app.model.args).toEqual({ x: 0, y: 0 });
+    expect(app.model.ui).toEqual({ label: '' });
+    expect(app.snapshot.navigationState.href).toBe('/');
+
+    let watchCountShallow = 0;
+
+    watch(() => app.model.args, () => {
+      watchCountShallow++;
+    });
+
+    app.model.args.x = 1;
+    app.model.args.y = 2;
+
+    const t1 = performance.now();
+    await app.allSettled();
+    await delay(100);
+    const t2 = performance.now();
+    console.log('allSettled', t2 - t1);
+
+    expect(app.model.args).toEqual(app.snapshot.args);
+    expect(app.model.args).toEqual({ x: 1, y: 2 });
+    expect(app.model.outputs.sum).toEqual(3);
+
+    app.model.args.x = 3;
+    app.model.args.y = 3;
+
+    const t3 = performance.now();
+    await app.allSettled();
+    await delay(patchPoolingDelay + 10);
+    const t4 = performance.now();
+    console.log('allSettled', t4 - t3);
+
+    expect(watchCountShallow).toBe(0); // no changes
+
+    expect(app.model.args).toEqual(app.snapshot.args);
+    expect(app.model.args).toEqual({ x: 3, y: 3 });
+    expect(app.model.outputs.sum).toEqual(6);
+
+    app.closedRef = true;
+  });
+
+  it('states should be synchronized', async () => {
+    const sharedBlock = new BlockSum(defaultState());
+    const platforma1 = createMockApi<Args, Outputs, UiState>(sharedBlock);
+    const platforma2 = createMockApi<Args, Outputs, UiState>(sharedBlock);
+
+    const initialState1 = await platforma1.loadBlockState().then(unwrapResult);
+    const initialState2 = await platforma2.loadBlockState().then(unwrapResult);
+
+    const app1 = createAppV2(initialState1, platforma1, { appId: 'app1', debug: true, debounceSpan: 10 });
+    const app2 = createAppV2(initialState2, platforma2, { appId: 'app2', debug: true, debounceSpan: 10 });
+
+    app1.model.args.x = 1;
+    app1.model.args.y = 2;
+
+    await app1.allSettled();
+    await app2.allSettled();
+
+    expect(app1.model.args).toEqual(app2.model.args);
+    expect(app1.model.args).toEqual({ x: 1, y: 2 });
+    expect(app1.model.outputs.sum).toEqual(3);
+    expect(app2.model.outputs.sum).toEqual(3);
+
+    app2.model.args.x = 3;
+    app2.model.args.y = 4;
+
+    await Promise.all([app1.allSettled(), app2.allSettled()]);
+    await delay(patchPoolingDelay + 10);
+
+    expect(app1.model.args).toEqual(app2.model.args);
+    expect(app1.model.args).toEqual({ x: 3, y: 4 });
+    expect(app1.model.outputs.sum).toEqual(7);
+    expect(app2.model.outputs.sum).toEqual(7);
+
+    app1.model.args.x = 5;
+    app1.model.args.y = 5;
+    app1.model.ui.delay = 20;
+    await delay(5);
+    app2.model.args.x = 7;
+    app2.model.args.y = 7;
+
+    await Promise.all([app1.allSettled(), app2.allSettled()]);
+    await delay(patchPoolingDelay + 10);
+
+    expect(app1.model.args).toEqual(app1.snapshot.args);
+    expect(app1.model.args).toEqual(app2.model.args);
+    expect(app1.model.args).toEqual({ x: 5, y: 5 });
+    expect(app1.model.outputs.sum).toEqual(10);
+    expect(app2.model.outputs.sum).toEqual(10);
+
+    app1.closedRef = true;
+    app2.closedRef = true;
+  });
+});

package/src/internal/createAppV2.ts

@@ -0,0 +1,309 @@
+import { deepClone, delay, uniqueId } from '@milaboratories/helpers';
+import type { Mutable } from '@milaboratories/helpers';
+import type { NavigationState, BlockOutputsBase, BlockState, PlatformaV2, ValueWithUTag, AuthorMarker } from '@platforma-sdk/model';
+import { hasAbortError, unwrapResult } from '@platforma-sdk/model';
+import type { Ref } from 'vue';
+import { reactive, computed, ref } from 'vue';
+import type { StateModelOptions, UnwrapOutputs, OutputValues, OutputErrors, AppSettings } from '../types';
+import { createModel } from '../createModel';
+import { createAppModel } from './createAppModel';
+import { parseQuery } from '../urls';
+import { MultiError, unwrapValueOrErrors } from '../utils';
+import { applyPatch } from 'fast-json-patch';
+import { UpdateSerializer } from './UpdateSerializer';
+
+export const patchPoolingDelay = 100;
+
+export const createNextAuthorMarker = (marker: AuthorMarker | undefined): AuthorMarker => ({
+  authorId: marker?.authorId ?? uniqueId(),
+  localVersion: (marker?.localVersion ?? 0) + 1,
+});
+
+/**
+ * Creates an application instance with reactive state management, outputs, and methods for state updates and navigation.
+ *
+ * @template Args - The type of arguments used in the application.
+ * @template Outputs - The type of block outputs extending `BlockOutputsBase`.
+ * @template UiState - The type of the UI state.
+ * @template Href - The type of navigation href, defaulting to a string starting with `/`.
+ *
+ * @param state - Initial state of the application, including args, outputs, UI state, and navigation state.
+ * @param platforma - A platform interface for interacting with block states.
+ * @param settings - Application settings, such as debug flags.
+ *
+ * @returns A reactive application object with methods, getters, and state.
+ */
+export function createAppV2<
+  Args = unknown,
+  Outputs extends BlockOutputsBase = BlockOutputsBase,
+  UiState = unknown,
+  Href extends `/${string}` = `/${string}`,
+>(
+  state: ValueWithUTag<BlockState<Args, Outputs, UiState, Href>>,
+  platforma: PlatformaV2<Args, Outputs, UiState, Href>,
+  settings: AppSettings,
+) {
+  type AppModel = {
+    args: Args;
+    ui: UiState;
+  };
+
+  const debug = (msg: string, ...rest: unknown[]) => {
+    if (settings.debug) {
+      console.log(`%c>>> %c${msg}`, 'color: orange; font-weight: bold', 'color: orange', settings.appId, ...rest);
+    }
+  };
+
+  const error = (msg: string, ...rest: unknown[]) => {
+    console.error(`%c>>> %c${msg}`, 'color: red; font-weight: bold', 'color: red', settings.appId, ...rest);
+  };
+
+  const data = {
+    isExternalSnapshot: false,
+    author: {
+      authorId: uniqueId(),
+      localVersion: 0,
+    },
+  };
+
+  const nextAuthorMarker = () => {
+    data.author = createNextAuthorMarker(data.author);
+    debug('nextAuthorMarker', data.author);
+    return data.author;
+  };
+
+  const closedRef = ref(false);
+
+  const uTagRef = ref(state.uTag);
+
+  const debounceSpan = settings.debounceSpan ?? 200;
+
+  const setArgsQueue = new UpdateSerializer({ debounceSpan });
+  const setUiStateQueue = new UpdateSerializer({ debounceSpan });
+  const setArgsAndUiStateQueue = new UpdateSerializer({ debounceSpan });
+  const setNavigationStateQueue = new UpdateSerializer({ debounceSpan });
+  /**
+   * Reactive snapshot of the application state, including args, outputs, UI state, and navigation state.
+   */
+  const snapshot = ref<{
+    args: Args;
+    outputs: Partial<Outputs>;
+    ui: UiState;
+    navigationState: NavigationState<Href>;
+  }>(state.value) as Ref<{
+    args: Args;
+    outputs: Partial<Outputs>;
+    ui: UiState;
+    navigationState: NavigationState<Href>;
+  }>;
+
+  const setBlockArgs = async (args: Args) => {
+    return platforma.setBlockArgs(args, nextAuthorMarker());
+  };
+
+  const setBlockUiState = async (ui: UiState) => {
+    return platforma.setBlockUiState(ui, nextAuthorMarker());
+  };
+
+  const setBlockArgsAndUiState = async (args: Args, ui: UiState) => {
+    return platforma.setBlockArgsAndUiState(args, ui, nextAuthorMarker());
+  };
+
+  const setNavigationState = async (state: NavigationState<Href>) => {
+    return platforma.setNavigationState(state);
+  };
+
+  (async () => {
+    window.addEventListener('beforeunload', () => {
+      closedRef.value = true;
+      platforma.dispose().then(unwrapResult).catch((err) => {
+        error('error in dispose', err);
+      });
+    });
+
+    while (!closedRef.value) {
+      try {
+        const patches = await platforma.getPatches(uTagRef.value).then(unwrapResult);
+
+        debug('patches', JSON.stringify(patches, null, 2));
+        debug('uTagRef.value', uTagRef.value);
+        debug('patches.uTag', patches.uTag);
+        debug('patches.author', patches.author);
+        debug('data.author', data.author);
+
+        uTagRef.value = patches.uTag;
+
+        if (patches.value.length === 0) {
+          await new Promise((resolve) => setTimeout(resolve, patchPoolingDelay));
+          continue;
+        }
+
+        const isAuthorChanged = data.author?.authorId !== patches.author?.authorId;
+
+        // Immutable behavior, apply external changes to the snapshot
+        if (isAuthorChanged || data.isExternalSnapshot) {
+          debug('got external changes, applying them to the snapshot', JSON.stringify(snapshot.value, null, 2));
+          snapshot.value = applyPatch(snapshot.value, patches.value, false, false).newDocument;
+          data.isExternalSnapshot = isAuthorChanged;
+        } else {
+          // Mutable behavior
+          snapshot.value = applyPatch(snapshot.value, patches.value).newDocument;
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, patchPoolingDelay));
+      } catch (err) {
+        if (hasAbortError(err)) {
+          debug('patches loop aborted');
+          closedRef.value = true;
+        } else {
+          error('error in patches loop', err);
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+      }
+    }
+  })();
+
+  const outputs = computed<OutputValues<Outputs>>(() => {
+    const entries = Object.entries(snapshot.value.outputs as Partial<Readonly<Outputs>>).map(([k, vOrErr]) => [k, vOrErr.ok && vOrErr.value !== undefined ? vOrErr.value : undefined]);
+    return Object.fromEntries(entries);
+  });
+
+  const outputErrors = computed<OutputErrors<Outputs>>(() => {
+    const entries = Object.entries(snapshot.value.outputs as Partial<Readonly<Outputs>>).map(([k, vOrErr]) => [k, vOrErr && !vOrErr.ok ? new MultiError(vOrErr.errors) : undefined]);
+    return Object.fromEntries(entries);
+  });
+
+  const appModel = createAppModel(
+    {
+      get() {
+        return { args: snapshot.value.args, ui: snapshot.value.ui } as AppModel;
+      },
+      autoSave: true,
+      onSave(newData: AppModel) {
+        debug('onSave', newData);
+        setArgsAndUiStateQueue.run(() => setBlockArgsAndUiState(newData.args, newData.ui).then(unwrapResult));
+      },
+    },
+    {
+      outputs,
+      outputErrors,
+    },
+    settings,
+  );
+
+  const cloneArgs = () => deepClone(appModel.model.args) as Args;
+  const cloneUiState = () => deepClone(appModel.model.ui) as UiState;
+  const cloneNavigationState = () => deepClone(snapshot.value.navigationState) as Mutable<NavigationState<Href>>;
+
+  const methods = {
+    cloneArgs,
+    cloneUiState,
+    cloneNavigationState,
+    createArgsModel<T extends Args = Args>(options: StateModelOptions<Args, T> = {}) {
+      return createModel<T, Args>({
+        get() {
+          if (options.transform) {
+            return options.transform(snapshot.value.args as Args);
+          }
+
+          return snapshot.value.args as T;
+        },
+        validate: options.validate,
+        autoSave: true,
+        onSave(newArgs) {
+          setArgsQueue.run(() => setBlockArgs(newArgs).then(unwrapResult));
+        },
+      });
+    },
+    /**
+     * defaultUiState is temporarily here, remove it after implementing initialUiState
+     */
+    createUiModel<T extends UiState = UiState>(options: StateModelOptions<UiState, T> = {}, defaultUiState: () => UiState) {
+      return createModel<T, UiState>({
+        get() {
+          if (options.transform) {
+            return options.transform(snapshot.value.ui as UiState);
+          }
+
+          return (snapshot.value.ui ?? defaultUiState()) as T;
+        },
+        validate: options.validate,
+        autoSave: true,
+        onSave(newData) {
+          setUiStateQueue.run(() => setBlockUiState(newData).then(unwrapResult));
+        },
+      });
+    },
+    /**
+     * Retrieves the unwrapped values of outputs for the given keys.
+     *
+     * @template K - Keys of the outputs to unwrap.
+     * @param keys - List of output names.
+     * @throws Error if the outputs contain errors.
+     * @returns An object with unwrapped output values.
+     */
+    unwrapOutputs<K extends keyof Outputs>(...keys: K[]): UnwrapOutputs<Outputs, K> {
+      const outputs = snapshot.value.outputs as Partial<Readonly<Outputs>>;
+      const entries = keys.map((key) => [key, unwrapValueOrErrors(outputs[key])]);
+      return Object.fromEntries(entries);
+    },
+    /**
+     * Updates the arguments state by applying a callback.
+     *
+     * @param cb - Callback to modify the current arguments.
+     * @returns A promise resolving after the update is applied.
+     */
+    updateArgs(cb: (args: Args) => void): Promise<boolean> {
+      const newArgs = cloneArgs();
+      cb(newArgs);
+      debug('updateArgs', newArgs);
+      appModel.model.args = newArgs;
+      return setArgsQueue.run(() => setBlockArgs(newArgs).then(unwrapResult));
+    },
+    /**
+     * Updates the UI state by applying a callback.
+     *
+     * @param cb - Callback to modify the current UI state.
+     * @returns A promise resolving after the update is applied.
+     * @todo Make it mutable since there is already an initial one
+     */
+    updateUiState(cb: (args: UiState) => UiState): Promise<boolean> {
+      const newUiState = cb(cloneUiState());
+      debug('updateUiState', newUiState);
+      appModel.model.ui = newUiState;
+      return setUiStateQueue.run(() => setBlockUiState(newUiState).then(unwrapResult));
+    },
+    /**
+     * Navigates to a specific href by updating the navigation state.
+     *
+     * @param href - The target href to navigate to.
+     * @returns A promise resolving after the navigation state is updated.
+     */
+    navigateTo(href: Href) {
+      const newState = cloneNavigationState();
+      newState.href = href;
+      return setNavigationStateQueue.run(() => setNavigationState(newState).then(unwrapResult));
+    },
+    async allSettled() {
+      await delay(0);
+      return setArgsAndUiStateQueue.allSettled();
+    },
+  };
+
+  const getters = {
+    closedRef,
+    snapshot,
+    queryParams: computed(() => parseQuery<Href>(snapshot.value.navigationState.href as Href)),
+    href: computed(() => snapshot.value.navigationState.href),
+    hasErrors: computed(() => Object.values(snapshot.value.outputs as Partial<Readonly<Outputs>>).some((v) => !v?.ok)),
+  };
+
+  return reactive(Object.assign(appModel, methods, getters));
+}
+
+export type BaseAppV2<
+  Args = unknown,
+  Outputs extends BlockOutputsBase = BlockOutputsBase,
+  UiState = unknown,
+  Href extends `/${string}` = `/${string}`,
+> = ReturnType<typeof createAppV2<Args, Outputs, UiState, Href>>;

package/src/internal/test-helpers/BlockMock.ts

@@ -0,0 +1,144 @@
+import { deepClone, delay, uniqueId } from '@milaboratories/helpers';
+import {
+  type BlockOutputsBase,
+  type BlockState,
+  type NavigationState,
+  type AuthorMarker,
+  type ValueWithUTagAndAuthor,
+  wrapAsyncCallback,
+  type ResultOrError,
+  unwrapResult,
+} from '@platforma-sdk/model';
+import { compare, type Operation } from 'fast-json-patch';
+import type { BlockApiV2, ValueWithUTag } from '@platforma-sdk/model';
+
+export class BlockStateMock<
+  Args = unknown,
+  Outputs extends BlockOutputsBase = BlockOutputsBase,
+  UiState = unknown,
+  Href extends `/${string}` = `/${string}`,
+> {
+  constructor(
+    public args: Args,
+    public outputs: Outputs,
+    public ui: UiState,
+    public href: Href,
+    public author: AuthorMarker = { authorId: 'test', localVersion: 0 },
+    public uTag: string = uniqueId(),
+  ) {}
+
+  setState(_state: Partial<BlockStateMock<Args, Outputs, UiState, Href>>) {
+    const state = deepClone(_state);
+    this.args = state.args ?? this.args;
+    this.outputs = state.outputs ?? this.outputs;
+    this.ui = state.ui ?? this.ui;
+    this.href = state.href ?? this.href;
+    this.author = state.author ?? this.author;
+    console.log('set author', state.author);
+    this.uTag = uniqueId();
+  }
+}
+
+export abstract class BlockMock<
+  Args = unknown,
+  Outputs extends BlockOutputsBase = BlockOutputsBase,
+  UiState = unknown,
+  Href extends `/${string}` = `/${string}`,
+> implements BlockApiV2<Args, Outputs, UiState, Href> {
+  #previousState: {
+    uTag: string;
+    value: BlockState<Args, Outputs, UiState, Href>;
+  } | undefined;
+
+  constructor(
+    public state: BlockStateMock<Args, Outputs, UiState, Href>,
+  ) {
+    this.loadBlockState().then(unwrapResult).then(({ uTag, value }) => {
+      this.#previousState = { value, uTag };
+    });
+  }
+
+  get uTag(): string {
+    return this.state.uTag;
+  }
+
+  async setBlockArgs(args: Args, author?: AuthorMarker) {
+    return wrapAsyncCallback(() => {
+      this.state.setState({ args, author });
+      return this.doUpdate();
+    });
+  }
+
+  async setBlockUiState(ui: UiState, author?: AuthorMarker) {
+    return wrapAsyncCallback(async () => {
+      this.state.setState({ ui, author });
+      return this.doUpdate();
+    });
+  }
+
+  async setBlockArgsAndUiState(args: Args, ui: UiState, author?: AuthorMarker) {
+    return wrapAsyncCallback(async () => {
+      await delay(0);
+      if (typeof ui === 'object' && ui !== null && 'delay' in ui && ui.delay && typeof ui.delay === 'number') {
+        console.log('DELAY', ui.delay);
+        await delay(ui.delay);
+      }
+      this.state.setState({ args, ui, author });
+      return this.doUpdate();
+    });
+  }
+
+  async setNavigationState(navigationState: NavigationState<Href>) {
+    return wrapAsyncCallback(() => {
+      this.state.setState({ href: navigationState.href });
+      return this.doUpdate();
+    });
+  }
+
+  async loadBlockState(): Promise<ResultOrError<ValueWithUTag<BlockState<Args, Outputs, UiState, Href>>>> {
+    return wrapAsyncCallback(async () => {
+      return deepClone({
+        value: {
+          args: this.state.args,
+          ui: this.state.ui,
+          outputs: this.state.outputs,
+          navigationState: {
+            href: this.state.href,
+          },
+          author: this.state.author,
+        },
+        uTag: this.state.uTag,
+      });
+    });
+  }
+
+  async getPatches(uTag: string): Promise<ResultOrError<ValueWithUTagAndAuthor<Operation[]>>> {
+    return wrapAsyncCallback(async () => {
+      while (uTag === this.state.uTag) {
+        await delay(0);
+      }
+
+      if (this.#previousState?.uTag !== uTag) {
+        console.log('uTag mismatch, resetting previous state');
+        this.#previousState = undefined;
+      }
+
+      const currentState = await this.loadBlockState().then(unwrapResult).then(({ uTag, value }) => ({ uTag, value }));
+      const patches = compare(this.#previousState?.value ?? {}, currentState.value);
+      this.#previousState = currentState;
+      return {
+        uTag: this.state.uTag,
+        value: patches,
+        author: this.state.author,
+      };
+    });
+  }
+
+  private async doUpdate() {
+    await this.process();
+  }
+
+  abstract process(): Promise<void>;
+}
+
+export type InferState<B> = B extends BlockMock<infer S> ? S : never;

package/src/internal/test-helpers/createMockApi.ts

@@ -0,0 +1,92 @@
+import type {
+  ValueWithUTag,
+  ValueWithUTagAndAuthor,
+  BlockState,
+  PlatformaV2,
+  BlockOutputsBase,
+  ImportFileHandle,
+  FileLike,
+  ListFilesResult,
+  LocalImportFileHandle,
+  NavigationState,
+  OpenDialogOps,
+  OpenMultipleFilesResponse,
+  OpenSingleFileResponse,
+  StorageHandle,
+  ResultOrError,
+  AuthorMarker,
+} from '@platforma-sdk/model';
+import type { BlockMock } from './BlockMock';
+import type { Operation } from 'fast-json-patch';
+import { delay } from '@milaboratories/helpers';
+import { getLsFilesResult } from './utils';
+
+export function createMockApi<
+  Args,
+  Outputs extends BlockOutputsBase,
+  UiState = unknown,
+  Href extends `/${string}` = `/${string}`,
+>(block: BlockMock<Args, Outputs, UiState, Href>): PlatformaV2<Args, Outputs, UiState, Href> {
+  return {
+    apiVersion: 2,
+    sdkInfo: {
+      sdkVersion: 'dev',
+    },
+    loadBlockState: async function (): Promise<ResultOrError<ValueWithUTag<BlockState<Args, Outputs, UiState, Href>>>> {
+      return block.loadBlockState();
+    },
+    getPatches: async function (uTag: string): Promise<ResultOrError<ValueWithUTagAndAuthor<Operation[]>>> {
+      return block.getPatches(uTag);
+    },
+    async setBlockArgs(value: Args, author?: AuthorMarker): Promise<ResultOrError<void>> {
+      return block.setBlockArgs(value, author);
+    },
+    async setBlockUiState(value: UiState, author?: AuthorMarker): Promise<ResultOrError<void>> {
+      return block.setBlockUiState(value, author);
+    },
+    async setBlockArgsAndUiState(args: Args, uiState: UiState, author?: AuthorMarker): Promise<ResultOrError<void>> {
+      return block.setBlockArgsAndUiState(args, uiState, author);
+    },
+    async setNavigationState(navigationState: NavigationState<Href>): Promise<ResultOrError<void>> {
+      return block.setNavigationState(navigationState);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    blobDriver: undefined as any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logDriver: undefined as any,
+
+    lsDriver: {
+      async getStorageList() {
+        return [
+          {
+            name: 'local',
+            handle: 'local://test',
+            initialFullPath: '/',
+            isInitialPathHome: false,
+          },
+        ];
+      },
+      async listFiles(_storage: StorageHandle, fullPath: string): Promise<ListFilesResult> {
+        await delay(10);
+        return getLsFilesResult(fullPath);
+      },
+      async getLocalFileContent(_file: LocalImportFileHandle): Promise<Uint8Array> {
+        return Uint8Array.of(0, 1);
+      },
+      async getLocalFileSize(_file: LocalImportFileHandle): Promise<number> {
+        return 3;
+      },
+      async showOpenMultipleFilesDialog(_ops: OpenDialogOps): Promise<OpenMultipleFilesResponse> {
+        return {};
+      },
+      async showOpenSingleFileDialog(_ops: OpenDialogOps): Promise<OpenSingleFileResponse> {
+        return {};
+      },
+      async fileToImportHandle(_file: FileLike): Promise<ImportFileHandle> {
+        return '' as ImportFileHandle;
+      },
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    pFrameDriver: undefined as any,
+  };
+}