@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

package/dist/modules/charts/runtime/features/charts/Editor/CsvImport/csvHelpers.js

@@ -0,0 +1,368 @@
+import { getColorIdAtIndex, parseNumericInput } from "../../../../helpers/index.js";
+export function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === "," || char === ";" || char === "	") {
+      cells.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current.trim());
+  return cells;
+}
+export function parseCsvText(text) {
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  const grid = lines.map((line) => parseCsvLine(line));
+  const cols = grid.reduce((max, row) => Math.max(max, row.length), 0);
+  return grid.map((row) => {
+    if (row.length === cols) return row;
+    const padded = row.slice();
+    while (padded.length < cols) padded.push("");
+    return padded;
+  });
+}
+export function transposeGrid(grid) {
+  if (grid.length === 0) return [];
+  const rows = grid.length;
+  const cols = grid[0].length;
+  const out = [];
+  for (let c = 0; c < cols; c++) {
+    const newRow = [];
+    for (let r = 0; r < rows; r++) {
+      newRow.push(grid[r][c] ?? "");
+    }
+    out.push(newRow);
+  }
+  return out;
+}
+export function reverseRowsKeepingHeader(grid) {
+  if (grid.length < 2) return grid;
+  const [header, ...rest] = grid;
+  return [header, ...rest.reverse()];
+}
+export function isMostlyNumeric(grid, colIdx) {
+  let nonEmpty = 0;
+  let numeric = 0;
+  for (let r = 1; r < grid.length; r++) {
+    const cell = grid[r]?.[colIdx] ?? "";
+    if (cell === "") continue;
+    nonEmpty++;
+    if (looksNumeric(cell)) numeric++;
+  }
+  if (nonEmpty === 0) return false;
+  return numeric / nonEmpty >= 0.8;
+}
+function looksNumeric(s) {
+  if (!s) return false;
+  const candidates = [
+    s.replace(/'/g, ""),
+    s.replace(/'/g, "").replace(/\./g, "").replace(",", ".")
+  ];
+  for (const c of candidates) {
+    if (c === "") continue;
+    if (!/^-?\d+(?:\.\d+)?$/.test(c)) continue;
+    if (Number.isFinite(parseFloat(c))) return true;
+  }
+  return false;
+}
+const BOOLEAN_TOKENS = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "0",
+  "1",
+  "yes",
+  "no",
+  "t",
+  "f"
+]);
+function isDateLikeCell(s) {
+  return /^\d{4}-\d{1,2}-\d{1,2}/.test(s) || /^\d{1,2}[./]\d{1,2}[./]\d{2,4}/.test(s);
+}
+function isIdNamedColumn(name) {
+  const n = name.trim().toLowerCase();
+  if (!n) return false;
+  if (n === "id" || n === "uuid" || n === "guid" || n === "pk") return true;
+  if (/^id[_-]/.test(n)) return true;
+  if (/[_-]id$/.test(n)) return true;
+  if (/[_-]nr$/.test(n)) return true;
+  if (/[_-]uuid$/.test(n)) return true;
+  return false;
+}
+function isGeoNamedColumn(name) {
+  const n = name.trim().toLowerCase();
+  return n === "lat" || n === "latitude" || n === "lon" || n === "lng" || n === "longitude" || n === "breitengrad" || n === "l\xE4ngengrad" || n === "laengengrad";
+}
+function isMeasureNamedColumn(name) {
+  const n = name.trim().toLowerCase();
+  if (!n) return false;
+  const tokens = [
+    "anzahl",
+    "besuche",
+    "count",
+    "total",
+    "sum",
+    "summe",
+    "wert",
+    "value",
+    "amount",
+    "betrag",
+    "menge",
+    "umsatz",
+    "einnahmen",
+    "ausgaben",
+    "kosten",
+    "preis",
+    "price"
+  ];
+  return tokens.some((t) => n === t || n.includes(t));
+}
+function analyzeColumn(grid, colIdx) {
+  const seen = /* @__PURE__ */ new Set();
+  const values = [];
+  let nonEmpty = 0;
+  let allNumeric = true;
+  let allBoolean = true;
+  let allDate = true;
+  let allYear = true;
+  for (let r = 1; r < grid.length; r++) {
+    const cell = grid[r]?.[colIdx] ?? "";
+    if (cell === "") continue;
+    nonEmpty++;
+    if (!seen.has(cell)) {
+      seen.add(cell);
+      values.push(cell);
+    }
+    if (allNumeric && !looksNumeric(cell)) allNumeric = false;
+    if (allBoolean && !BOOLEAN_TOKENS.has(cell.toLowerCase())) {
+      allBoolean = false;
+    }
+    if (allDate && !isDateLikeCell(cell)) allDate = false;
+    if (allYear) {
+      const n = Number(cell);
+      if (!Number.isInteger(n) || n < 1900 || n > 2100 || !/^\d{4}$/.test(cell)) {
+        allYear = false;
+      }
+    }
+  }
+  const distinct = values.length;
+  const name = grid[0]?.[colIdx] ?? "";
+  return {
+    index: colIdx,
+    name,
+    distinct,
+    isConstant: distinct === 1,
+    isAllNumeric: nonEmpty > 0 && allNumeric,
+    isYearLike: nonEmpty > 0 && allYear && distinct > 1,
+    isDateLike: nonEmpty > 0 && allDate,
+    isBooleanLike: nonEmpty > 0 && allBoolean,
+    isIdNamed: isIdNamedColumn(name),
+    isGeoNamed: isGeoNamedColumn(name),
+    isMeasureNamed: isMeasureNamedColumn(name),
+    values
+  };
+}
+export function inferSmartConfig(grid) {
+  const header = grid[0] ?? [];
+  if (header.length === 0) {
+    return { category: 0, values: [], groupBy: [], filters: [] };
+  }
+  const traits = header.map((_, i) => analyzeColumn(grid, i));
+  const usable = traits.filter(
+    (c) => !c.isConstant && !c.isBooleanLike && !c.isDateLike && !c.isIdNamed && !c.isGeoNamed
+  );
+  const categoricals = usable.filter((c) => !c.isAllNumeric && !c.isYearLike);
+  const yearCols = usable.filter((c) => c.isYearLike);
+  let measures = usable.filter((c) => c.isAllNumeric && !c.isYearLike);
+  const namedMeasures = measures.filter((c) => c.isMeasureNamed);
+  if (namedMeasures.length > 0) {
+    measures = namedMeasures;
+  }
+  let category;
+  if (categoricals.length > 0) {
+    category = categoricals.reduce(
+      (best, c) => c.distinct > best.distinct ? c : best
+    ).index;
+  } else if (yearCols.length > 0) {
+    category = yearCols[0].index;
+  } else {
+    category = 0;
+  }
+  const values = measures.map((c) => c.index).filter((i) => i !== category);
+  const groupBy = categoricals.filter((c) => c.index !== category && c.distinct >= 2 && c.distinct <= 50).map((c) => c.index);
+  const filters = yearCols.filter((c) => c.index !== category).map((c) => ({
+    column: c.index,
+    // Years are integers; the lexicographic max is also the numeric max.
+    values: [[...c.values].sort()[c.values.length - 1]]
+  }));
+  return { category, values, groupBy, filters };
+}
+export function columnLabelWithSample(grid, colIdx, maxValues = 3, maxValueLen = 24) {
+  const name = grid[0]?.[colIdx] || `Column ${colIdx + 1}`;
+  const distinct = distinctColumnValues(grid, colIdx);
+  if (distinct.length === 0) return name;
+  const sample = distinct.slice(0, maxValues).map(
+    (v) => v.length > maxValueLen ? `${v.slice(0, maxValueLen - 1)}\u2026` : v
+  );
+  return `${name} (${sample.join(", ")})`;
+}
+export function distinctColumnValues(grid, colIdx) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let r = 1; r < grid.length; r++) {
+    const v = grid[r]?.[colIdx] ?? "";
+    if (v === "" || seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+  }
+  return out;
+}
+function sortCategories(categories, mode) {
+  if (mode === "firstOccurrence") return categories;
+  const arr = [...categories];
+  if (mode === "alphabetical") {
+    arr.sort((a, b) => a.localeCompare(b));
+    return arr;
+  }
+  arr.sort((a, b) => {
+    const na = parseFloat(a);
+    const nb = parseFloat(b);
+    const aNum = Number.isFinite(na);
+    const bNum = Number.isFinite(nb);
+    if (aNum && bNum && na !== nb) return na - nb;
+    if (aNum && !bNum) return -1;
+    if (!aNum && bNum) return 1;
+    return a.localeCompare(b);
+  });
+  return arr;
+}
+export function gridToImportPayload(grid, config, colorOptions) {
+  const header = grid[0] ?? [];
+  const dataRows = grid.slice(1);
+  const categoryCol = config.roles.indexOf("category");
+  const valueCol = config.roles.indexOf("value");
+  const seriesCols = [];
+  const groupByCols = [];
+  for (let i = 0; i < config.roles.length; i++) {
+    const role = config.roles[i];
+    if (role === "series") seriesCols.push(i);
+    else if (role === "groupBy") groupByCols.push(i);
+  }
+  if (categoryCol < 0) {
+    return { categories: [], series: [], categoryColors: [] };
+  }
+  const activeFilters = [];
+  for (const f of config.filters) {
+    if (f.values.length > 0) {
+      activeFilters.push({ col: f.column, allowed: new Set(f.values) });
+    }
+  }
+  const kept = [];
+  for (const row of dataRows) {
+    let pass = true;
+    for (const f of activeFilters) {
+      if (!f.allowed.has(row[f.col] ?? "")) {
+        pass = false;
+        break;
+      }
+    }
+    if (pass) kept.push(row);
+  }
+  const categoryOrder = [];
+  const categoryIndex = /* @__PURE__ */ new Map();
+  function registerCategory(label) {
+    let idx = categoryIndex.get(label);
+    if (idx === void 0) {
+      idx = categoryOrder.length;
+      categoryIndex.set(label, idx);
+      categoryOrder.push(label);
+    }
+    return idx;
+  }
+  const seriesOrder = [];
+  const seriesIndex = /* @__PURE__ */ new Map();
+  function registerSeries(name) {
+    let idx = seriesIndex.get(name);
+    if (idx === void 0) {
+      idx = seriesOrder.length;
+      seriesIndex.set(name, idx);
+      seriesOrder.push(name);
+    }
+    return idx;
+  }
+  const values = /* @__PURE__ */ new Map();
+  function add(sIdx, cIdx, v) {
+    let row = values.get(sIdx);
+    if (!row) {
+      row = /* @__PURE__ */ new Map();
+      values.set(sIdx, row);
+    }
+    row.set(cIdx, (row.get(cIdx) ?? 0) + v);
+  }
+  if (valueCol >= 0) {
+    for (const row of kept) {
+      const catLabel = row[categoryCol] || "";
+      if (catLabel === "") continue;
+      const cIdx = registerCategory(catLabel);
+      const seriesName = groupByCols.length > 0 ? groupByCols.map((c) => row[c] ?? "").join(config.groupBySeparator) : header[valueCol] || "Value";
+      const sIdx = registerSeries(seriesName);
+      const v = parseNumericInput(row[valueCol] ?? "");
+      add(sIdx, cIdx, v);
+    }
+  } else {
+    for (const sCol of seriesCols) {
+      registerSeries(header[sCol] || `Series ${seriesOrder.length + 1}`);
+    }
+    for (const row of kept) {
+      const catLabel = row[categoryCol] || "";
+      if (catLabel === "") continue;
+      const cIdx = registerCategory(catLabel);
+      for (let si = 0; si < seriesCols.length; si++) {
+        const sCol = seriesCols[si];
+        const v = parseNumericInput(row[sCol] ?? "");
+        add(si, cIdx, v);
+      }
+    }
+  }
+  const sortedCategories = sortCategories(categoryOrder, config.sort);
+  const oldToNew = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sortedCategories.length; i++) {
+    const oldIdx = categoryIndex.get(sortedCategories[i]);
+    if (oldIdx !== void 0) oldToNew.set(oldIdx, i);
+  }
+  const categoryCount = sortedCategories.length;
+  const series = seriesOrder.map((name, si) => {
+    const row = values.get(si);
+    const data = new Array(categoryCount).fill(0);
+    if (row) {
+      for (const [oldIdx, v] of row) {
+        const newIdx = oldToNew.get(oldIdx);
+        if (newIdx !== void 0) data[newIdx] = v;
+      }
+    }
+    return {
+      name,
+      color: getColorIdAtIndex(si, colorOptions),
+      data
+    };
+  });
+  const categoryColors = sortedCategories.map(
+    (_, i) => getColorIdAtIndex(i, colorOptions)
+  );
+  return { categories: sortedCategories, series, categoryColors };
+}

package/dist/modules/charts/runtime/features/charts/Editor/CsvImport/index.d.vue.ts

@@ -1,19 +1,8 @@
-import type { ChartSeries, ChartColor } from '../../../../types.js';
-type __VLS_Props = {
-    colors: Record<string, ChartColor>;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    import: (payload: {
-        categories: string[];
-        series: ChartSeries[];
-        categoryColors: string[];
-    }) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onImport?: ((payload: {
-        categories: string[];
-        series: ChartSeries[];
-        categoryColors: string[];
-    }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+import { type CsvImportPayload } from './csvHelpers.js';
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    import: (payload: CsvImportPayload) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onImport?: ((payload: CsvImportPayload) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/modules/charts/runtime/features/charts/Editor/CsvImport/index.vue

@@ -1,11 +1,4 @@
 <template>
-  <button
-    type="button"
-    class="bk-button bk-is-small"
-    @click="fileInputEl?.click()"
-  >
-    {{ $t("chartsImportCsv", "Import CSV") }}
-  </button>
   <input
     ref="fileInputEl"
     type="file"
@@ -13,77 +6,57 @@
     class="bk-chart-data-table-file-input"
     @change="onFileChange"
   />
+  <PanelAction
+    :title="$t('chartsImportCsv', 'Import CSV')"
+    icon="bk_mdi_csv"
+    @click="fileInputEl?.click()"
+  />
+  <Teleport :to="ui.mainLayoutElement.value">
+    <BlokkliTransition name="slide-up">
+      <PreviewDialog
+        v-if="grid && showDialog"
+        :grid="grid"
+        :file-name="fileName"
+        @submit="onDialogSubmit"
+        @cancel="grid = null"
+      />
+    </BlokkliTransition>
+  </Teleport>
 </template>
 
 <script setup>
-import { useTemplateRef, useBlokkli } from "#imports";
-import { getColorIdAtIndex, parseNumericInput } from "../../../../helpers";
-const props = defineProps({
-  colors: { type: Object, required: true }
-});
+import { ref, useTemplateRef, useBlokkli } from "#imports";
+import { BlokkliTransition } from "#blokkli/editor/components";
+import PanelAction from "#blokkli/editor/components/Panel/Action/index.vue";
+import PreviewDialog from "./PreviewDialog.vue";
+import { parseCsvText } from "./csvHelpers";
+import { useDialog } from "#blokkli/editor/composables";
 const emit = defineEmits(["import"]);
-const { $t } = useBlokkli();
+const { $t, ui } = useBlokkli();
 const fileInputEl = useTemplateRef("fileInputEl");
-function parseCsvLine(line) {
-  const cells = [];
-  let current = "";
-  let inQuotes = false;
-  for (let i = 0; i < line.length; i++) {
-    const char = line[i];
-    if (inQuotes) {
-      if (char === '"' && line[i + 1] === '"') {
-        current += '"';
-        i++;
-      } else if (char === '"') {
-        inQuotes = false;
-      } else {
-        current += char;
-      }
-    } else if (char === '"') {
-      inQuotes = true;
-    } else if (char === "," || char === ";" || char === "	") {
-      cells.push(current.trim());
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  cells.push(current.trim());
-  return cells;
-}
+const grid = ref(null);
+const fileName = ref("");
+const showDialog = useDialog("charts-csv-preview", "center", "high");
 function onFileChange(event) {
   const input = event.target;
   const file = input.files?.[0];
+  input.value = "";
   if (!file) return;
   const reader = new FileReader();
   reader.onload = (e) => {
     const text = e.target?.result;
     if (typeof text !== "string") return;
-    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
-    if (lines.length < 2) return;
-    const header = parseCsvLine(lines[0]);
-    const seriesNames = header.slice(1);
-    if (seriesNames.length === 0) return;
-    const categories = [];
-    const seriesData = seriesNames.map(() => []);
-    for (let i = 1; i < lines.length; i++) {
-      const cells = parseCsvLine(lines[i]);
-      categories.push(cells[0] || `Category ${i}`);
-      for (let si = 0; si < seriesNames.length; si++) {
-        seriesData[si].push(parseNumericInput(cells[si + 1] || ""));
-      }
-    }
-    const series = seriesNames.map((name, i) => ({
-      name: name || `Series ${i + 1}`,
-      color: getColorIdAtIndex(i, props.colors),
-      data: seriesData[i]
-    }));
-    const categoryColors = categories.map(
-      (_, i) => getColorIdAtIndex(i, props.colors)
-    );
-    emit("import", { categories, series, categoryColors });
+    const parsed = parseCsvText(text);
+    if (parsed.length === 0) return;
+    fileName.value = file.name;
+    grid.value = parsed;
+    showDialog.value = true;
   };
   reader.readAsText(file);
-  input.value = "";
+}
+function onDialogSubmit(payload) {
+  emit("import", payload);
+  grid.value = null;
+  showDialog.value = false;
 }
 </script>

package/dist/modules/charts/runtime/features/charts/Editor/CsvImport/index.vue.d.ts

@@ -1,19 +1,8 @@
-import type { ChartSeries, ChartColor } from '../../../../types.js';
-type __VLS_Props = {
-    colors: Record<string, ChartColor>;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    import: (payload: {
-        categories: string[];
-        series: ChartSeries[];
-        categoryColors: string[];
-    }) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onImport?: ((payload: {
-        categories: string[];
-        series: ChartSeries[];
-        categoryColors: string[];
-    }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+import { type CsvImportPayload } from './csvHelpers.js';
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    import: (payload: CsvImportPayload) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onImport?: ((payload: CsvImportPayload) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/modules/charts/runtime/features/charts/Editor/DataSourcePicker/index.d.vue.ts

@@ -0,0 +1,16 @@
+import type { ChartDataSource, ChartDataSourceCapabilities } from '../../../../types.js';
+type __VLS_Props = {
+    capabilities: ChartDataSourceCapabilities;
+    selected: ChartDataSource | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (args_0: ChartDataSource) => any;
+    clear: () => any;
+    "update:knownIds": (args_0: Set<string>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((args_0: ChartDataSource) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:knownIds"?: ((args_0: Set<string>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/features/charts/Editor/DataSourcePicker/index.vue

@@ -0,0 +1,80 @@
+<template>
+  <div class="_bk_p-panel-gap _bk_flex _bk_flex-col _bk_gap-10">
+    <FormSearch
+      :id="searchId"
+      v-model:query="query"
+      :label="$t('chartsDynamicPickSource', 'Pick a data source')"
+      :placeholder="$t('chartsDynamicSearchPlaceholder', 'Search\u2026')"
+      :items
+      :loading="status === 'pending'"
+      :mode="formMode"
+      :selected-label="selected?.label"
+      disable-grouping
+      @select="onSelect"
+      @clear="$emit('clear')"
+    />
+    <div v-if="error" class="_bk_text-sm _bk_text-red-normal">
+      {{ error.message }}
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { computed, ref, useAsyncData, useBlokkli, watch } from "#imports";
+import { FormSearch } from "#blokkli/editor/components";
+const props = defineProps({
+  capabilities: { type: Object, required: true },
+  selected: { type: [Object, null], required: true }
+});
+const emit = defineEmits(["select", "clear", "update:knownIds"]);
+const { $t, adapter } = useBlokkli();
+const searchId = "bk-chart-data-source-picker";
+const query = ref("");
+const debouncedQuery = ref("");
+let debounceTimer = null;
+watch(query, (next) => {
+  if (!props.capabilities.supportsSearch) {
+    debouncedQuery.value = next;
+    return;
+  }
+  if (debounceTimer) clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(() => {
+    debouncedQuery.value = next.trim();
+  }, 300);
+});
+const formMode = computed(
+  () => props.capabilities.supportsSearch ? "async" : "fzf"
+);
+const {
+  data: sources,
+  status,
+  error
+} = await useAsyncData(
+  async () => {
+    if (!adapter.getChartDataSources) return [];
+    const args = props.capabilities.supportsSearch ? { text: debouncedQuery.value, page: 0 } : {};
+    const result = await adapter.getChartDataSources(args);
+    return Array.isArray(result) ? result : result.items;
+  },
+  {
+    watch: [debouncedQuery],
+    default: () => []
+  }
+);
+watch(
+  sources,
+  (list) => emit("update:knownIds", new Set(list.map((s) => s.id))),
+  { immediate: true }
+);
+const items = computed(
+  () => sources.value.map((s) => ({
+    key: s.id,
+    label: s.label,
+    description: s.description
+  }))
+);
+function onSelect(item) {
+  const source = sources.value.find((s) => s.id === item.key);
+  if (source) emit("select", source);
+}
+</script>

package/dist/modules/charts/runtime/features/charts/Editor/DataSourcePicker/index.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ChartDataSource, ChartDataSourceCapabilities } from '../../../../types.js';
+type __VLS_Props = {
+    capabilities: ChartDataSourceCapabilities;
+    selected: ChartDataSource | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (args_0: ChartDataSource) => any;
+    clear: () => any;
+    "update:knownIds": (args_0: Set<string>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((args_0: ChartDataSource) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:knownIds"?: ((args_0: Set<string>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/features/charts/Editor/DataTable/index.d.vue.ts

@@ -1,12 +1,10 @@
-import type { ChartSeries, ChartColor } from '../../../../types.js';
+import type { ChartSeries } from '../../../../types.js';
 type __VLS_Props = {
     categories: string[];
     series: ChartSeries[];
     categoryColors: string[];
-    hasMultipleSeries: boolean;
     hasSeriesColors: boolean;
     hasCategoryColors: boolean;
-    colors: Record<string, ChartColor>;
     removeRow: (index: number) => void;
     removeSeries: (index: number) => void;
 };
@@ -14,10 +12,12 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "update:categories": (value: string[]) => any;
     "update:series": (value: ChartSeries[]) => any;
     "update:categoryColors": (value: string[]) => any;
+    addColumn: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:categories"?: ((value: string[]) => any) | undefined;
     "onUpdate:series"?: ((value: ChartSeries[]) => any) | undefined;
     "onUpdate:categoryColors"?: ((value: string[]) => any) | undefined;
+    onAddColumn?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;