@platforma-sdk/ui-vue 1.66.1 → 1.67.0

package/src/components/PlAgDataTable/sources/table-source-v2.ts

@@ -63,15 +63,15 @@ function columns2rows(
   axesResultIndices: number[],
 ): PlAgDataTableV2Row[] {
   const rowData: PlAgDataTableV2Row[] = [];
-  for (let iRow = 0; iRow < columns[0].data.length; ++iRow) {
-    const axesKey: PTableKey = axesResultIndices.map((ri) => pTableValue(columns[ri], iRow));
+  for (let rowIdx = 0; rowIdx < columns[0].data.length; ++rowIdx) {
+    const axesKey: PTableKey = axesResultIndices.map((ri) => pTableValue(columns[ri], rowIdx));
     const id = canonicalizeJson<PlTableRowId>(axesKey);
     const row = fields.reduce<PlAgDataTableV2Row>(
-      (acc, field, iCol) => {
+      (acc, field, colIdx) => {
         acc[field.toString() as `${number}`] =
-          fieldResultMapping[iCol] === -1
+          fieldResultMapping[colIdx] === -1
             ? PTableHidden
-            : pTableValue(columns[fieldResultMapping[iCol]], iRow);
+            : pTableValue(columns[fieldResultMapping[colIdx]], rowIdx);
         return acc;
       },
       { id, axesKey },
@@ -156,10 +156,10 @@ export async function calculateGridOptions({
   // request indices: non-hidden display fields + visible axes for row selection keys.
   // Axes replaced by label columns request label data (display); original axis values
   // are fetched via visibleAxes (row keys).
-  const { requestIndices, fieldResultMapping, axesResultIndices } = buildRequestIndices(
+  const { requestIndices, axesResultIndices, fieldResultMapping } = buildRequestIndices(
     indices,
+    visibleAxes.map(([idx]) => idx),
     specsToVisibleSpecsMapping,
-    visibleAxes.map(([i]) => i),
   );
 
   let rowCount = -1;
@@ -313,7 +313,12 @@ export function makeColDef(
             throw Error(`unsupported data type: ${valueType}`);
         }
       })(),
-      tooltip: readAnnotation(labeledSpec.spec, Annotation.Description)?.trim(),
+      tooltip:
+        readAnnotation(spec.spec, Annotation.Description)?.trim() ??
+        readAnnotation(labeledSpec.spec, Annotation.Description)?.trim(),
+      info:
+        readAnnotation(spec.spec, Annotation.Table.Info)?.trim() ??
+        readAnnotation(labeledSpec.spec, Annotation.Table.Info)?.trim(),
     } satisfies PlAgHeaderComponentParams,
     cellDataType: (() => {
       switch (valueType) {
@@ -465,26 +470,23 @@ function collectVisibleAxes(
  */
 function buildRequestIndices(
   indices: number[],
-  specsToVisibleSpecsMapping: Map<number, number>,
   visibleAxesIndices: number[],
+  specsToVisibleSpecsMapping: Map<number, number>,
 ): {
   requestIndices: number[];
-  fieldResultMapping: number[];
   axesResultIndices: number[];
+  fieldResultMapping: number[];
 } {
   const resolved = indices.map((displayField) => {
     const idx = specsToVisibleSpecsMapping.get(displayField);
-    return idx === undefined || idx === -1 ? null : idx;
+    return isNil(idx) || idx === -1 ? null : idx;
   });
-  const requestedFields = resolved.filter((v): v is number => v !== null);
-
-  const fieldResultMapping: number[] = [];
-  let pos = 0;
-  for (const v of resolved) {
-    fieldResultMapping.push(v === null ? -1 : pos++);
-  }
-
-  const requestIndices = uniq([...requestedFields, ...visibleAxesIndices]);
+  const requestIndices = uniq([
+    ...resolved.filter((v): v is number => v !== null),
+    ...visibleAxesIndices,
+  ]);
+  const fieldResultMapping = resolved.map((v) => (v === null ? -1 : requestIndices.indexOf(v)));
   const axesResultIndices = visibleAxesIndices.map((vi) => requestIndices.indexOf(vi));
-  return { requestIndices, fieldResultMapping, axesResultIndices };
+
+  return { requestIndices, axesResultIndices, fieldResultMapping };
 }

package/src/components/PlDatasetSelector/PlDatasetSelector.vue

@@ -0,0 +1,164 @@
+<script lang="ts">
+/**
+ * Select a dataset and (optionally) a filter column, emitting a `PrimaryRef`.
+ *
+ * Behaves like {@link PlDropdownRef} when none of the offered datasets carry
+ * filter options. When the selected dataset has compatible filters, a second
+ * dropdown appears with the filters plus a "No filter" entry.
+ *
+ * Accepts `PrimaryRef | PlRef | undefined` as `modelValue` (a plain `PlRef`
+ * is treated as an unfiltered dataset), but always emits `PrimaryRef`
+ * (or `undefined` when cleared).
+ */
+export default {
+  name: "PlDatasetSelector",
+};
+</script>
+
+<script lang="ts" setup>
+import type { DatasetOption, PlRef, PrimaryRef } from "@platforma-sdk/model";
+import { createPrimaryRef, isPrimaryRef, plRefsEqual } from "@platforma-sdk/model";
+import type { ListOption } from "@milaboratories/uikit";
+import { PlDropdown, PlDropdownRef } from "@milaboratories/uikit";
+import { computed } from "vue";
+
+const slots = defineSlots<{
+  tooltip?: () => unknown;
+}>();
+
+/**
+ * v-model value. Accepts `PrimaryRef`, plain `PlRef` (treated as unfiltered),
+ * or `undefined`. Writes always emit `PrimaryRef` or `undefined`.
+ */
+const model = defineModel<PrimaryRef | PlRef | undefined>();
+
+const props = withDefaults(
+  defineProps<{
+    /** Available datasets, each optionally carrying compatible filter choices. */
+    options?: Readonly<DatasetOption[]>;
+    /** Label above the dataset dropdown. */
+    label?: string;
+    /** Helper text below the dataset dropdown (shown when there is no error). */
+    helper?: string;
+    /** Helper text shown while `options` is undefined (loading). */
+    loadingOptionsHelper?: string;
+    /** Error message displayed below the dataset dropdown. */
+    error?: unknown;
+    /** Placeholder when no dataset is selected. */
+    placeholder?: string;
+    /** Label above the filter dropdown. */
+    filterLabel?: string;
+    /** Placeholder for the filter dropdown. */
+    filterPlaceholder?: string;
+    /** Label of the "no filter" entry prepended to the filter options. */
+    noFilterLabel?: string;
+    /** Show a clear button on the dataset dropdown. */
+    clearable?: boolean;
+    /** Mark the dataset dropdown as required. */
+    required?: boolean;
+    /** Disable all interaction. */
+    disabled?: boolean;
+  }>(),
+  {
+    options: undefined,
+    label: undefined,
+    helper: undefined,
+    loadingOptionsHelper: undefined,
+    error: undefined,
+    placeholder: "...",
+    filterLabel: "",
+    filterPlaceholder: "...",
+    noFilterLabel: "No filter",
+    clearable: false,
+    required: false,
+    disabled: false,
+  },
+);
+
+const selectedDataset = computed<PlRef | undefined>(() => {
+  const v = model.value;
+  if (v === undefined) return undefined;
+  return isPrimaryRef(v) ? v.column : v;
+});
+
+const selectedFilter = computed<PlRef | undefined>(() => {
+  const v = model.value;
+  return isPrimaryRef(v) ? v.filter : undefined;
+});
+
+const currentDatasetOption = computed<DatasetOption | undefined>(() => {
+  const dataset = selectedDataset.value;
+  if (!dataset) return undefined;
+  return props.options?.find((o) => plRefsEqual(o.ref, dataset, true));
+});
+
+const hasFilters = computed(() => (currentDatasetOption.value?.filters?.length ?? 0) > 0);
+
+/**
+ * Filter dropdown options. The first entry (`null`) is the "No filter" choice —
+ * null distinguishes it from `undefined` (dropdown clear button, disabled here).
+ */
+const filterOptions = computed<ListOption<PlRef | null>[]>(() => {
+  const filters = currentDatasetOption.value?.filters;
+  if (!filters) return [];
+  return [
+    { label: props.noFilterLabel, value: null } as ListOption<PlRef | null>,
+    ...filters.map((f) => ({ label: f.label, value: f.ref }) as ListOption<PlRef | null>),
+  ];
+});
+
+const filterValue = computed<PlRef | null>(() => selectedFilter.value ?? null);
+
+function emitValue(dataset: PlRef | undefined, filter: PlRef | undefined) {
+  model.value = dataset === undefined ? undefined : createPrimaryRef(dataset, filter);
+}
+
+function onDatasetChange(dataset: PlRef | undefined) {
+  emitValue(dataset, undefined);
+}
+
+function onFilterChange(value: PlRef | null | undefined) {
+  const dataset = selectedDataset.value;
+  if (!dataset) return;
+  emitValue(dataset, value ?? undefined);
+}
+</script>
+
+<template>
+  <div class="pl-dataset-selector">
+    <PlDropdownRef
+      :model-value="selectedDataset"
+      :options="options"
+      :label="label"
+      :helper="helper"
+      :loading-options-helper="loadingOptionsHelper"
+      :error="error"
+      :placeholder="placeholder"
+      :clearable="clearable"
+      :required="required"
+      :disabled="disabled"
+      @update:model-value="onDatasetChange"
+    >
+      <template v-if="slots.tooltip" #tooltip>
+        <slot name="tooltip" />
+      </template>
+    </PlDropdownRef>
+    <PlDropdown
+      v-if="hasFilters"
+      :model-value="filterValue"
+      :options="filterOptions"
+      :label="filterLabel"
+      :placeholder="filterPlaceholder"
+      :disabled="disabled"
+      @update:model-value="onFilterChange"
+    />
+  </div>
+</template>
+
+<style scoped>
+.pl-dataset-selector {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+</style>

package/src/components/PlDatasetSelector/__tests__/PlDatasetSelector.jsdomtest.ts

@@ -0,0 +1,257 @@
+import { flushPromises, mount } from "@vue/test-utils";
+import type { DatasetOption, PrimaryRef } from "@platforma-sdk/model";
+import { createPlRef, createPrimaryRef } from "@platforma-sdk/model";
+import { describe, expect, it } from "vitest";
+import PlDatasetSelector from "../PlDatasetSelector.vue";
+
+const datasetA = createPlRef("1", "out-a", true);
+const datasetB = createPlRef("2", "out-b", true);
+const filterA1 = createPlRef("1", "filter-a1");
+const filterA2 = createPlRef("1", "filter-a2");
+
+const optionsWithFilters: DatasetOption[] = [
+  {
+    label: "Dataset A",
+    ref: datasetA,
+    filters: [
+      { label: "Top 1000", ref: filterA1 },
+      { label: "High quality", ref: filterA2 },
+    ],
+  },
+  // Dataset B has no filters — filter dropdown must stay hidden.
+  { label: "Dataset B", ref: datasetB },
+];
+
+const datasetC = createPlRef("3", "out-c", true);
+
+const optionsNoFilters: DatasetOption[] = [{ label: "Dataset B", ref: datasetB }];
+
+const optionsWithEmptyFilters: DatasetOption[] = [
+  { label: "Dataset C", ref: datasetC, filters: [] },
+];
+
+async function pickOption(index: number) {
+  const options = [...document.body.querySelectorAll(".dropdown-list-item")] as HTMLElement[];
+  options[index].click();
+  await flushPromises();
+}
+
+describe("PlDatasetSelector", () => {
+  it("renders a single dropdown when no dataset has filters", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: { modelValue: undefined, options: optionsNoFilters },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    const selector = wrapper.find(".pl-dataset-selector");
+    expect(selector.exists()).toBe(true);
+    // Only PlDropdownRef is rendered — no filter dropdown.
+    expect(selector.element.children.length).toBe(1);
+    wrapper.unmount();
+  });
+
+  it("shows the filter dropdown when the selected dataset has filters", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: { modelValue: createPrimaryRef(datasetA), options: optionsWithFilters },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(2);
+    wrapper.unmount();
+  });
+
+  it("hides the filter dropdown when the selected dataset has no filters", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: { modelValue: createPrimaryRef(datasetB), options: optionsWithFilters },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(1);
+    wrapper.unmount();
+  });
+
+  it("emits PrimaryRef with filter: undefined when dataset changes", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: {
+        modelValue: createPrimaryRef(datasetA, filterA1),
+        options: optionsWithFilters,
+        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+      },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    // Open the dataset dropdown (the first input — dataset comes first).
+    const inputs = wrapper.findAll("input");
+    await inputs[0].trigger("focus");
+
+    // Dataset A is already selected (index 0); pick Dataset B (index 1).
+    await pickOption(1);
+
+    const emitted = wrapper.emitted("update:modelValue");
+    expect(emitted).toBeDefined();
+    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
+    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetB });
+    wrapper.unmount();
+  });
+
+  it("emits PrimaryRef with filter set when a filter is picked", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: {
+        modelValue: createPrimaryRef(datasetA),
+        options: optionsWithFilters,
+        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+      },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    // Open the filter dropdown — it's the second input in the component.
+    const inputs = wrapper.findAll("input");
+    expect(inputs.length).toBe(2);
+    await inputs[1].trigger("focus");
+
+    // Options are: [No filter, Top 1000, High quality]. Pick "Top 1000" (index 1).
+    await pickOption(1);
+
+    const emitted = wrapper.emitted("update:modelValue");
+    expect(emitted).toBeDefined();
+    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
+    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetA, filter: filterA1 });
+    wrapper.unmount();
+  });
+
+  it("emits PrimaryRef with filter: undefined when 'No filter' is picked", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: {
+        modelValue: createPrimaryRef(datasetA, filterA1),
+        options: optionsWithFilters,
+        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+      },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    const inputs = wrapper.findAll("input");
+    await inputs[1].trigger("focus");
+    // Pick "No filter" (index 0).
+    await pickOption(0);
+
+    const emitted = wrapper.emitted("update:modelValue");
+    expect(emitted).toBeDefined();
+    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
+    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetA });
+    expect("filter" in last).toBe(false);
+    wrapper.unmount();
+  });
+
+  it("accepts plain PlRef as modelValue for backward compat (filterless dataset)", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: { modelValue: datasetB, options: optionsWithFilters },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(1);
+    wrapper.unmount();
+  });
+
+  it("accepts plain PlRef as modelValue for backward compat (dataset with filters)", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: { modelValue: datasetA, options: optionsWithFilters },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    // PlRef matching dataset A — filter dropdown should appear since A has filters.
+    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(2);
+    wrapper.unmount();
+  });
+
+  it("hides filter dropdown when dataset has filters: [] (empty array)", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: { modelValue: createPrimaryRef(datasetC), options: optionsWithEmptyFilters },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(1);
+    wrapper.unmount();
+  });
+
+  it("filter dropdown defaults to 'No filter' when dataset has filters but none selected", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: {
+        modelValue: createPrimaryRef(datasetA),
+        options: optionsWithFilters,
+        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+      },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    // No emission on mount — the component does not auto-select a filter.
+    expect(wrapper.emitted("update:modelValue")).toBeUndefined();
+
+    // Filter dropdown is visible.
+    const inputs = wrapper.findAll("input");
+    expect(inputs.length).toBe(2);
+
+    // Open filter dropdown and verify "No filter" is the first option.
+    await inputs[1].trigger("focus");
+    const items = document.body.querySelectorAll(".dropdown-list-item");
+    expect(items.length).toBe(3); // No filter, Top 1000, High quality
+    expect(items[0].textContent).toContain("No filter");
+    wrapper.unmount();
+  });
+
+  it("emits PrimaryRef without filter key when selecting a filterless dataset", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: {
+        modelValue: undefined,
+        options: optionsNoFilters,
+        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+      },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    const inputs = wrapper.findAll("input");
+    await inputs[0].trigger("focus");
+    await pickOption(0);
+
+    const emitted = wrapper.emitted("update:modelValue");
+    expect(emitted).toBeDefined();
+    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
+    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetB });
+    expect("filter" in last).toBe(false);
+    wrapper.unmount();
+  });
+
+  it("emits undefined when cleared via the dataset dropdown", async () => {
+    const wrapper = mount(PlDatasetSelector, {
+      props: {
+        modelValue: createPrimaryRef(datasetA, filterA1),
+        options: optionsWithFilters,
+        clearable: true,
+        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+      },
+      attachTo: document.body,
+    });
+    await flushPromises();
+
+    // PlDropdown's clear button carries the ".clear" class.
+    const clearBtn = wrapper.find(".clear");
+    expect(clearBtn.exists()).toBe(true);
+    await clearBtn.trigger("click");
+
+    const emitted = wrapper.emitted("update:modelValue");
+    expect(emitted).toBeDefined();
+    const last = emitted![emitted!.length - 1][0];
+    expect(last).toBeUndefined();
+    wrapper.unmount();
+  });
+});

package/src/components/PlDatasetSelector/index.ts

@@ -0,0 +1 @@
+export { default as PlDatasetSelector } from "./PlDatasetSelector.vue";

package/src/internal/createAppV3.ts

@@ -22,11 +22,8 @@ import {
   getPluginData,
   isPluginOutputKey,
   pluginOutputPrefix,
-  createNodeServiceProxy,
-  buildServices,
 } from "@platforma-sdk/model";
 import { type UiServices as AllUiServices } from "@milaboratories/pl-model-common";
-import { createUiServiceRegistry } from "./service_factories";
 import type { Ref } from "vue";
 import { reactive, computed, ref, markRaw } from "vue";
 import type { OutputValues, OutputErrors, AppSettings } from "../types";
@@ -36,6 +33,8 @@ import { applyPatch } from "fast-json-patch";
 import { UpdateSerializer } from "./UpdateSerializer";
 import { watchIgnorable } from "@vueuse/core";
 import type { PluginState, PluginAccess } from "../usePlugin";
+import { logDebug, logError } from "./utils";
+import { getServices } from "./getServices";
 
 export const patchPoolingDelay = 150;
 
@@ -53,14 +52,6 @@ export const createNextAuthorMarker = (marker: AuthorMarker | undefined): Author
   localVersion: (marker?.localVersion ?? 0) + 1,
 });
 
-const stringifyForDebug = (v: unknown) => {
-  try {
-    return JSON.stringify(v, null, 2);
-  } catch (err) {
-    return err instanceof Error ? err.message : String(err);
-  }
-};
-
 /**
  * Creates an application instance with reactive state management, outputs, and methods for state updates and navigation.
  *
@@ -87,25 +78,8 @@ export function createAppV3<
   platforma: PlatformaExtended<PlatformaV3<Data, Args, Outputs, Href, Plugins, UiServices>>,
   settings: AppSettings,
 ) {
-  const debug = (msg: string, ...rest: unknown[]) => {
-    if (settings.debug) {
-      console.log(
-        `%c>>> %c${msg}`,
-        "color: orange; font-weight: bold",
-        "color: orange",
-        ...rest.map((r) => stringifyForDebug(r)),
-      );
-    }
-  };
-
-  const error = (msg: string, ...rest: unknown[]) => {
-    console.error(
-      `%c>>> %c${msg}`,
-      "color: red; font-weight: bold",
-      "color: red",
-      ...rest.map((r) => stringifyForDebug(r)),
-    );
-  };
+  const debug = settings.debug ? logDebug : () => {};
+  const error = logError;
 
   const data = {
     isExternalSnapshot: false,
@@ -230,11 +204,12 @@ export function createAppV3<
   (async () => {
     window.addEventListener("beforeunload", () => {
       closedRef.value = true;
-      Promise.allSettled([uiRegistry.dispose(), platforma.dispose().then(unwrapResult)]).catch(
-        (err) => {
+      platforma
+        .dispose()
+        .then(unwrapResult)
+        .catch((err) => {
           error("error in dispose", err);
-        },
-      );
+        });
     });
 
     while (!closedRef.value) {
@@ -334,9 +309,7 @@ export function createAppV3<
     },
   };
 
-  const proxy = createNodeServiceProxy(platforma.serviceDispatch);
-  const uiRegistry = createUiServiceRegistry({ proxy });
-  const services = buildServices<UiServices>(platforma.serviceDispatch, uiRegistry);
+  const services = getServices<UiServices>({ platforma });
 
   /** Creates a lazily-cached per-plugin reactive state. */
   const createPluginState = <F extends PluginFactoryLike>(

package/src/internal/getServices.ts

@@ -0,0 +1,36 @@
+import {
+  BlockDefaultUiServices,
+  buildServices,
+  createServiceProxy,
+  getRawPlatformaInstance,
+  PlatformaV3,
+  UiServices,
+} from "@platforma-sdk/model";
+import { createUiServiceRegistry } from "./service_factories";
+import { isNil } from "es-toolkit";
+import { logError } from "./utils";
+
+let cachedServices: null | Partial<UiServices> = null;
+
+export function getServices<Services extends Partial<UiServices> = BlockDefaultUiServices>(deps?: {
+  platforma?: PlatformaV3<any, any, any, any, any, Services>;
+}): Services {
+  if (!isNil(cachedServices)) {
+    return cachedServices as Services;
+  }
+
+  const platforma =
+    deps?.platforma ??
+    (getRawPlatformaInstance() as PlatformaV3<any, any, any, any, any, Services>);
+  const proxy = createServiceProxy(platforma.serviceDispatch);
+  const uiRegistry = createUiServiceRegistry({ proxy });
+  const services = buildServices<Services>(platforma.serviceDispatch, uiRegistry);
+
+  window.addEventListener("beforeunload", () => {
+    uiRegistry.dispose().catch((err) => {
+      logError("uiRegistry error in dispose", err);
+    });
+  });
+
+  return (cachedServices = services) as Services;
+}

package/src/internal/service_factories.ts

@@ -9,10 +9,10 @@
 
 import { Services, UiServiceRegistry } from "@milaboratories/pl-model-common";
 import { SpecDriver } from "@milaboratories/pf-spec-driver";
-import type { NodeServiceProxy } from "@platforma-sdk/model";
+import type { ServiceProxy } from "@platforma-sdk/model";
 
 export type UiServiceOptions = {
-  proxy: NodeServiceProxy;
+  proxy: ServiceProxy;
 };
 
 export function createUiServiceRegistry(options: UiServiceOptions) {

package/src/internal/utils.ts

@@ -0,0 +1,25 @@
+export const logDebug = (msg: string, ...rest: unknown[]) => {
+  console.log(
+    `%c>>> %c${msg}`,
+    "color: orange; font-weight: bold",
+    "color: orange",
+    ...rest.map((r) => stringifyForDebug(r)),
+  );
+};
+
+export const logError = (msg: string, ...rest: unknown[]) => {
+  console.error(
+    `%c>>> %c${msg}`,
+    "color: red; font-weight: bold",
+    "color: red",
+    ...rest.map((r) => stringifyForDebug(r)),
+  );
+};
+
+const stringifyForDebug = (v: unknown) => {
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+};

package/src/lib.ts

@@ -33,6 +33,8 @@ export * from "./components/PlBtnExportArchive";
 
 export * from "./components/PlAdvancedFilter";
 
+export * from "./components/PlDatasetSelector";
+
 export * from "./defineApp";
 
 export { usePlugin } from "./usePlugin";