@platforma-sdk/ui-vue 1.82.6 → 1.83.1

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

@@ -1,161 +0,0 @@
-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 };
-      });
-  }
-
-  async dispose(): Promise<ResultOrError<void>> {
-    console.log("unused");
-    return { value: undefined };
-  }
-
-  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

@@ -1,104 +0,0 @@
-import { delay } from "@milaboratories/helpers";
-import type {
-  AuthorMarker,
-  BlockOutputsBase,
-  BlockState,
-  FileLike,
-  ImportFileHandle,
-  ListFilesResult,
-  LocalImportFileHandle,
-  NavigationState,
-  OpenDialogOps,
-  OpenMultipleFilesResponse,
-  OpenSingleFileResponse,
-  PlatformaV2,
-  ResultOrError,
-  StorageHandle,
-  ValueWithUTag,
-  ValueWithUTagAndAuthor,
-} from "@platforma-sdk/model";
-import type { Operation } from "fast-json-patch";
-import type { BlockMock } from "./BlockMock";
-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",
-    },
-    async dispose(): Promise<ResultOrError<void>> {
-      return block.dispose();
-    },
-    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 [
-          {
-            id: "local",
-            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,
-  };
-}

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

@@ -1,65 +0,0 @@
-import { randomRangeInt, range, times, toList } from "@milaboratories/helpers";
-import { faker } from "@faker-js/faker";
-import type { ImportFileHandleUpload, ListFilesResult, LsEntry } from "@platforma-sdk/model";
-
-export const capitalizeFirstLetter = (str: string) => {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-};
-
-const d = new Map<string, LsEntry[]>();
-
-export const getLsFilesResult = (path: string): ListFilesResult => {
-  const length = randomRangeInt(1, 1000);
-
-  if (path.endsWith("11")) {
-    throw Error("Some error " + faker.lorem.paragraph() + faker.lorem.paragraph());
-  }
-
-  if (!d.has(path)) {
-    const dirPath = path === "/" ? "" : path;
-
-    d.set(
-      path,
-      toList(range(0, length)).map((i) => {
-        if (i < 10) {
-          let name = faker.word.noun();
-          if (Math.random() < 0.2) {
-            name = "." + name;
-          }
-          return {
-            type: "dir",
-            name,
-            fullPath: dirPath + "/" + name,
-          };
-        }
-
-        const name =
-          times(randomRangeInt(1, 40), () => {
-            if (Math.random() < 0.2) {
-              return capitalizeFirstLetter(faker.word.noun());
-            }
-
-            return faker.word.noun();
-          }).join(" ") + faker.system.commonFileName();
-
-        const handle = `upload://upload/${encodeURIComponent(
-          JSON.stringify({
-            localPath: dirPath + "/" + name,
-          }),
-        )}` as ImportFileHandleUpload;
-
-        return {
-          type: "file",
-          name,
-          fullPath: dirPath + "/" + name,
-          handle,
-        };
-      }),
-    );
-  }
-
-  return {
-    parent: "/",
-    entries: d.get(path)!,
-  };
-};

package/src/internal/v1.static-test.ts

@@ -1,107 +0,0 @@
-import type { Expect, Equal } from "@milaboratories/helpers";
-import { z } from "zod";
-import type { ModelOptions, Model } from "../types";
-import type {
-  BlockOutputsBase,
-  InferHrefType,
-  InferOutputsType,
-  OutputWithStatus,
-  Platforma,
-} from "@platforma-sdk/model";
-import type { BaseAppV1, createAppV1 } from "./createAppV1";
-import { type AppV1 } from "../defineApp";
-import { computed, type Component } from "vue";
-
-declare function __createModel<M, V = unknown>(options: ModelOptions<M, V>): Model<M>;
-
-declare const __args: {
-  seed: number;
-};
-
-const validate = z.coerce.number().int().parse;
-
-type _number = ReturnType<typeof validate>;
-
-const __model1 = __createModel({
-  get() {
-    return String(__args.seed);
-  },
-  validate,
-  autoSave: true,
-  onSave(_seed) {
-    //
-  },
-});
-
-const __model2 = __createModel({
-  get() {
-    return __args.seed;
-  },
-  validate,
-  autoSave: true,
-  onSave(_seed) {
-    //
-  },
-});
-
-type InferArgs<Pl extends Platforma> = Pl extends Platforma<infer Args> ? Args : never;
-type InferUiState<Pl extends Platforma> =
-  Pl extends Platforma<unknown, BlockOutputsBase, infer UiState> ? UiState : never;
-
-export type TestApp<P extends Platforma> = ReturnType<
-  typeof createAppV1<InferArgs<P>, InferOutputsType<P>, InferUiState<P>, InferHrefType<P>>
->;
-
-type _Args = {
-  x: number;
-  y: string[];
-};
-
-type _Outputs = {
-  sum: OutputWithStatus<number> & { __unwrap: true };
-};
-
-type _UiState = {
-  flag: boolean;
-};
-
-type _App1 = BaseAppV1<_Args, _Outputs, _UiState, "/">;
-type _App2 = TestApp<Platforma<_Args, _Outputs, _UiState, "/">>;
-
-const _local = () => {
-  const counter = computed(() => 1);
-  const label = computed(() => "aaaa");
-
-  const method = () => 100;
-
-  return {
-    counter,
-    label,
-    method,
-    routes: {
-      "/": undefined as unknown as Component,
-    },
-  };
-};
-
-type ExtApp = AppV1<1, BlockOutputsBase, unknown, "/", ReturnType<typeof _local>>;
-
-type _UpdateArgsParams = Parameters<Parameters<_App1["updateArgs"]>[0]>[0];
-
-type __cases = [
-  Expect<Equal<Model<string>, typeof __model1>>,
-  Expect<Equal<Model<number>, typeof __model2>>,
-  Expect<Equal<Model<string>, typeof __model1>>,
-  Expect<Equal<Model<number>, typeof __model2>>,
-  Expect<Equal<_App1, _App2>>,
-  Expect<Equal<ExtApp["counter"], number>>,
-  Expect<Equal<ExtApp["label"], string>>,
-  Expect<Equal<ExtApp["method"], () => number>>,
-  Expect<Equal<_App1["snapshot"]["args"], Readonly<_Args>>>,
-  Expect<Equal<_App1["model"]["outputs"]["sum"], number | undefined>>,
-  Expect<Equal<_App1["model"]["outputErrors"]["sum"], Error | undefined>>,
-  Expect<Equal<_App1["snapshot"]["ui"], Readonly<_UiState>>>,
-  Expect<Equal<_App1["model"]["args"], _Args>>,
-  Expect<Equal<_App1["model"]["ui"], _UiState>>,
-  Expect<Equal<_UpdateArgsParams, _Args>>,
-];

package/src/internal/v2.static-test.ts

@@ -1,107 +0,0 @@
-import type { Expect, Equal } from "@milaboratories/helpers";
-import { z } from "zod";
-import type { ModelOptions, Model } from "../types";
-import type {
-  BlockOutputsBase,
-  InferHrefType,
-  InferOutputsType,
-  OutputWithStatus,
-  Platforma,
-} from "@platforma-sdk/model";
-import type { BaseAppV2, createAppV2 } from "./createAppV2";
-import { type AppV2 } from "../defineApp";
-import { computed, type Component } from "vue";
-
-declare function __createModel<M, V = unknown>(options: ModelOptions<M, V>): Model<M>;
-
-declare const __args: {
-  seed: number;
-};
-
-const validate = z.coerce.number().int().parse;
-
-type _number = ReturnType<typeof validate>;
-
-const __model1 = __createModel({
-  get() {
-    return String(__args.seed);
-  },
-  validate,
-  autoSave: true,
-  onSave(_seed) {
-    //
-  },
-});
-
-const __model2 = __createModel({
-  get() {
-    return __args.seed;
-  },
-  validate,
-  autoSave: true,
-  onSave(_seed) {
-    //
-  },
-});
-
-type InferArgs<Pl extends Platforma> = Pl extends Platforma<infer Args> ? Args : never;
-type InferUiState<Pl extends Platforma> =
-  Pl extends Platforma<unknown, BlockOutputsBase, infer UiState> ? UiState : never;
-
-export type TestApp<P extends Platforma> = ReturnType<
-  typeof createAppV2<InferArgs<P>, InferOutputsType<P>, InferUiState<P>, InferHrefType<P>>
->;
-
-type _Args = {
-  x: number;
-  y: string[];
-};
-
-type _Outputs = {
-  sum: OutputWithStatus<number> & { __unwrap: true };
-};
-
-type _UiState = {
-  flag: boolean;
-};
-
-type _App1 = BaseAppV2<_Args, _Outputs, _UiState, "/">;
-type _App2 = TestApp<Platforma<_Args, _Outputs, _UiState, "/">>;
-
-const _local = () => {
-  const counter = computed(() => 1);
-  const label = computed(() => "aaaa");
-
-  const method = () => 100;
-
-  return {
-    counter,
-    label,
-    method,
-    routes: {
-      "/": undefined as unknown as Component,
-    },
-  };
-};
-
-type ExtApp = AppV2<1, BlockOutputsBase, unknown, "/", ReturnType<typeof _local>>;
-
-type _UpdateArgsParams = Parameters<Parameters<_App1["updateArgs"]>[0]>[0];
-
-type __cases = [
-  Expect<Equal<Model<string>, typeof __model1>>,
-  Expect<Equal<Model<number>, typeof __model2>>,
-  Expect<Equal<Model<string>, typeof __model1>>,
-  Expect<Equal<Model<number>, typeof __model2>>,
-  Expect<Equal<_App1, _App2>>,
-  Expect<Equal<ExtApp["counter"], number>>,
-  Expect<Equal<ExtApp["label"], string>>,
-  Expect<Equal<ExtApp["method"], () => number>>,
-  Expect<Equal<_App1["snapshot"]["args"], _Args>>,
-  Expect<Equal<_App1["model"]["outputs"]["sum"], number | undefined>>,
-  Expect<Equal<_App1["model"]["outputErrors"]["sum"], Error | undefined>>,
-  Expect<Equal<_App1["snapshot"]["ui"], _UiState>>,
-  Expect<Equal<_App1["model"]["args"], _Args>>,
-  Expect<Equal<_App1["model"]["ui"], _UiState>>,
-  Expect<Equal<_UpdateArgsParams, _Args>>,
-];