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

package/dist/modules/charts/index.mjs

@@ -1,27 +1,225 @@
-import { createResolver } from '@nuxt/kit';
+import { resolveFiles, createResolver } from '@nuxt/kit';
 import { defineBlokkliModule } from '../index.mjs';
 import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { C as Collector, a as CollectedFile, e as extractFirstStringArg } from '../../shared/editor.Gu7mgJ5Q.mjs';
 import { d as defineCodeTemplate } from '../../shared/editor.6D5vApr0.mjs';
+import 'typescript';
+import 'oxc-walker';
 
-function chartsConfigTemplate(options) {
+const DEFINITION_FILENAMES = ["definition.ts", "definition.js"];
+const RENDER_FILENAME = "render.vue";
+const ILLUSTRATION_FILENAME = "illustration.vue";
+function isDefinitionFile(filePath) {
+  return DEFINITION_FILENAMES.includes(path.basename(filePath));
+}
+function toImportName(rawId) {
+  const cleaned = rawId.split(/[^a-z0-9]/i).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  return `chartType${cleaned || "Anonymous"}`;
+}
+class CollectedChartTypeFile extends CollectedFile {
+  /**
+   * The chart-type id, parsed only for `definition.ts` files. Render and
+   * illustration files leave this `null` — they're tracked only so the
+   * watcher rebuilds the templates on add/change/unlink.
+   */
+  id = null;
+  isDefinition;
+  isRender;
+  isIllustration;
+  typeDir;
+  constructor(filePath, fileContents) {
+    super(filePath, fileContents);
+    const base = path.basename(filePath);
+    this.isDefinition = isDefinitionFile(filePath);
+    this.isRender = base === RENDER_FILENAME;
+    this.isIllustration = base === ILLUSTRATION_FILENAME;
+    this.typeDir = path.dirname(filePath);
+  }
+  async handleChange() {
+    if (this.isDefinition) {
+      this.id = extractFirstStringArg(this.fileContents, ["defineChartType"]) ?? null;
+    }
+    return true;
+  }
+}
+class ChartTypeCollector extends Collector {
+  needsFileContents = true;
+  options;
+  constructor(helper, options) {
+    super(helper);
+    this.options = options;
+  }
+  async init() {
+    for (const dir of this.options.dirs) {
+      try {
+        await fs.promises.access(dir);
+      } catch {
+        continue;
+      }
+      const files = await resolveFiles(
+        dir,
+        [
+          ...DEFINITION_FILENAMES.map((name) => `**/${name}`),
+          `**/${RENDER_FILENAME}`,
+          `**/${ILLUSTRATION_FILENAME}`
+        ],
+        { followSymbolicLinks: false }
+      );
+      for (const filePath of files) {
+        await this.addFile(filePath);
+      }
+    }
+  }
+  runHooks() {
+    return Promise.resolve();
+  }
+  async applies(filePath) {
+    const base = path.basename(filePath);
+    if (!isDefinitionFile(filePath) && base !== RENDER_FILENAME && base !== ILLUSTRATION_FILENAME) {
+      return false;
+    }
+    return this.options.dirs.some((dir) => filePath.startsWith(dir));
+  }
+  createCollectedFile(filePath, fileContents) {
+    return new CollectedChartTypeFile(filePath, fileContents);
+  }
+  getDependencyTypes() {
+    return ["chart-types"];
+  }
+  /**
+   * Returns one item per directory where both `definition.ts` (with an
+   * extracted id) and `render.vue` exist.
+   */
+  getItems() {
+    const byDir = /* @__PURE__ */ new Map();
+    for (const file of this.files.values()) {
+      const slot = byDir.get(file.typeDir) ?? {};
+      if (file.isDefinition) slot.definition = file;
+      if (file.isRender) slot.render = file;
+      if (file.isIllustration) slot.illustration = file;
+      byDir.set(file.typeDir, slot);
+    }
+    const items = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const { definition, render, illustration } of byDir.values()) {
+      if (!definition || !render || !definition.id) continue;
+      const id = definition.id;
+      if (seenIds.has(id)) {
+        this.helper.logger.warn(
+          `Duplicate chart-type id "${id}" at ${definition.filePath}. Skipping.`
+        );
+        continue;
+      }
+      seenIds.add(id);
+      items.push({
+        id,
+        importName: toImportName(id),
+        definitionPath: definition.filePath,
+        renderPath: render.filePath,
+        illustrationPath: illustration?.filePath ?? null
+      });
+    }
+    items.sort((a, b) => a.id.localeCompare(b.id));
+    return items;
+  }
+}
+
+function createDefinitionsTemplate(collector) {
   return defineCodeTemplate(
-    "charts-config",
-    () => {
-      return `
-export const COLORS = ${JSON.stringify(options.colors)}
+    "charts-definitions",
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.(ts|js)$/, "");
+      const items = collector.getItems();
+      const imports = items.map(
+        (it) => `import ${it.importName} from '${rel(it.definitionPath)}'`
+      );
+      const entries = items.map((it) => `  ${it.importName}`).join(",\n");
+      const ids = items.map((it) => `'${it.id}'`).join(", ");
+      return `${imports.join("\n")}
+
+export const definitions = [
+${entries}
+]
+
+export const definitionIds = [${ids}]
 `;
     },
-    () => {
-      return `
-import type { ChartColor } from '#blokkli/charts/types'
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.(ts|js)$/, "");
+      const items = collector.getItems();
+      const typeImports = items.map(
+        (it, i) => `import type { TypeOptions as _Opt${i} } from '${rel(it.definitionPath)}'`
+      ).join("\n");
+      const mapEntries = items.map((it, i) => `  '${it.id}': _Opt${i}`).join("\n");
+      const idUnion = items.length > 0 ? items.map((it) => `'${it.id}'`).join(" | ") : "never";
+      const header = `import type { ChartTypeDefinitionEntry } from '#blokkli/charts/types'`;
+      const body = `export const definitions: ChartTypeDefinitionEntry<any>[]
+export const definitionIds: readonly (${idUnion})[]
 
-export const COLORS: Record<string, ChartColor>
+export type ChartTypeOptionsMap = {
+${mapEntries}
+}
+export type ChartTypeId = keyof ChartTypeOptionsMap
 `;
+      return `${header}
+${typeImports}
+
+${body}`;
     },
-    {
-      context: "both",
-      write: true
-    }
+    { dependencies: ["chart-types"], write: true }
+  );
+}
+
+function createComponentsTemplate(collector) {
+  return defineCodeTemplate(
+    "charts-components",
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p);
+      const items = collector.getItems();
+      const entries = items.map(
+        (it) => `  '${it.id}': defineAsyncComponent(() => import('${rel(it.renderPath)}')),`
+      ).join("\n");
+      return `import { defineAsyncComponent } from 'vue'
+
+export const chartTypeComponents = {
+${entries}
+}
+`;
+    },
+    () => `import type { Component } from 'vue'
+import type { ChartTypeId } from '#blokkli-build/charts-definitions'
+
+export const chartTypeComponents: Record<ChartTypeId, Component>
+`,
+    { dependencies: ["chart-types"], write: true }
+  );
+}
+
+function createIllustrationsTemplate(collector) {
+  return defineCodeTemplate(
+    "charts-illustrations",
+    (ctx) => {
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.vue$/, "");
+      const items = collector.getItems().filter((it) => it.illustrationPath !== null);
+      const imports = items.map(
+        (it) => `import ${it.importName}Illustration from '${rel(it.illustrationPath)}'`
+      ).join("\n");
+      const entries = items.map((it) => `  '${it.id}': ${it.importName}Illustration,`).join("\n");
+      return `${imports}
+
+export const chartTypeIllustrations = {
+${entries}
+}
+`;
+    },
+    () => `import type { Component } from 'vue'
+import type { ChartTypeId } from '#blokkli-build/charts-definitions'
+
+export const chartTypeIllustrations: Partial<Record<ChartTypeId, Component>>
+`,
+    { dependencies: ["chart-types"], write: true }
   );
 }
 
@@ -33,13 +231,40 @@ const index = defineBlokkliModule({
     options.blokkliDirs ??= [];
     options.blokkliDirs.push(resolve("./runtime/blokkli"));
   },
-  setup({ context, helper, $t }, options) {
-    context.addTemplate(chartsConfigTemplate(options));
+  setup({ context, helper, $t }) {
     helper.addAlias("#blokkli/charts/types", resolve("./runtime/types"));
+    helper.addAlias(
+      "#blokkli/charts/definition",
+      resolve("./runtime/chart-types/definition")
+    );
+    helper.addAlias(
+      "#blokkli/charts/adapter",
+      resolve("./runtime/helpers/adapterTypes")
+    );
     helper.addAlias(
       "#blokkli/charts/components",
       resolve("./runtime/components")
     );
+    const nuxt = helper.nuxt;
+    const moduleBlokkliDirs = helper.options.blokkliDirs || [];
+    const projectChartsDir = path.resolve(
+      nuxt.options.rootDir,
+      "blokkli/chart-types"
+    );
+    const chartTypes = new ChartTypeCollector(helper, {
+      dirs: [
+        projectChartsDir,
+        ...moduleBlokkliDirs.map((d) => path.join(d, "chart-types"))
+      ]
+    });
+    context.addCollector(chartTypes);
+    context.addTemplate(createDefinitionsTemplate(chartTypes));
+    context.addTemplate(createComponentsTemplate(chartTypes));
+    context.addTemplate(createIllustrationsTemplate(chartTypes));
+    helper.addAppTsInclude(projectChartsDir);
+    for (const dir of moduleBlokkliDirs) {
+      helper.addAppTsInclude(path.join(dir, "chart-types"));
+    }
     context.registerComplexOptionType({
       id: "chart",
       typeName: "BlokkliChartData",

package/dist/modules/charts/runtime/blokkli/chart-types/advanced/definition.d.ts

@@ -0,0 +1,5 @@
+export type TypeOptions = Record<string, never>;
+export declare const ADVANCED_DEFAULT_SOURCE: string;
+export declare const ADVANCED_DEFAULT_PARSED: Record<string, unknown>;
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/advanced/definition.js

@@ -0,0 +1,26 @@
+import { defineChartType } from "#blokkli/charts/definition";
+const DEFAULT_OBJECT = {
+  title: { text: "Advanced chart" },
+  tooltip: { trigger: "axis" },
+  xAxis: {
+    type: "category",
+    data: ["Mon", "Tue", "Wed", "Thu", "Fri"]
+  },
+  yAxis: { type: "value" },
+  series: [{ type: "bar", data: [120, 200, 150, 80, 70] }]
+};
+export const ADVANCED_DEFAULT_SOURCE = JSON.stringify(DEFAULT_OBJECT, null, 2);
+export const ADVANCED_DEFAULT_PARSED = DEFAULT_OBJECT;
+export default defineChartType("advanced", ($t) => ({
+  hasSeriesColors: false,
+  hasCategoryColors: false,
+  editor: {
+    label: $t("advanced", "Advanced"),
+    description: $t(
+      "chartsTypeAdvancedDescription",
+      "Paste a raw ECharts configuration. Full control, no structured data table."
+    ),
+    icon: "bk_mdi_data_object",
+    options: {}
+  }
+}));

package/dist/modules/charts/runtime/blokkli/chart-types/advanced/render.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<any, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/advanced/render.vue

@@ -0,0 +1,120 @@
+<template>
+  <VChart :option="option" autoresize style="height: 550px; width: 100%" />
+</template>
+
+<script setup>
+import { computed } from "#imports";
+import VChart from "vue-echarts";
+import { use } from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import {
+  BarChart,
+  LineChart,
+  PieChart,
+  ScatterChart,
+  RadarChart,
+  HeatmapChart,
+  GaugeChart,
+  FunnelChart,
+  GraphChart,
+  TreeChart,
+  TreemapChart,
+  SunburstChart,
+  BoxplotChart,
+  CandlestickChart,
+  EffectScatterChart,
+  MapChart,
+  ParallelChart,
+  LinesChart,
+  SankeyChart,
+  PictorialBarChart,
+  ThemeRiverChart,
+  CustomChart
+} from "echarts/charts";
+import {
+  GridComponent,
+  TooltipComponent,
+  LegendComponent,
+  TitleComponent,
+  DataZoomComponent,
+  MarkLineComponent,
+  MarkPointComponent,
+  MarkAreaComponent,
+  ToolboxComponent,
+  PolarComponent,
+  VisualMapComponent,
+  GeoComponent,
+  ParallelComponent,
+  SingleAxisComponent,
+  TimelineComponent,
+  CalendarComponent,
+  GraphicComponent,
+  AxisPointerComponent,
+  BrushComponent,
+  DatasetComponent,
+  TransformComponent,
+  AriaComponent
+} from "echarts/components";
+use([
+  CanvasRenderer,
+  BarChart,
+  LineChart,
+  PieChart,
+  ScatterChart,
+  RadarChart,
+  HeatmapChart,
+  GaugeChart,
+  FunnelChart,
+  GraphChart,
+  TreeChart,
+  TreemapChart,
+  SunburstChart,
+  BoxplotChart,
+  CandlestickChart,
+  EffectScatterChart,
+  MapChart,
+  ParallelChart,
+  LinesChart,
+  SankeyChart,
+  PictorialBarChart,
+  ThemeRiverChart,
+  CustomChart,
+  GridComponent,
+  TooltipComponent,
+  LegendComponent,
+  TitleComponent,
+  DataZoomComponent,
+  MarkLineComponent,
+  MarkPointComponent,
+  MarkAreaComponent,
+  ToolboxComponent,
+  PolarComponent,
+  VisualMapComponent,
+  GeoComponent,
+  ParallelComponent,
+  SingleAxisComponent,
+  TimelineComponent,
+  CalendarComponent,
+  GraphicComponent,
+  AxisPointerComponent,
+  BrushComponent,
+  DatasetComponent,
+  TransformComponent,
+  AriaComponent
+]);
+const props = defineProps({
+  title: { type: String, required: true },
+  categories: { type: Array, required: true },
+  series: { type: Array, required: true },
+  seriesHexColors: { type: Array, required: true },
+  categoryHexColors: { type: Array, required: true },
+  typeOptions: { type: Object, required: true },
+  numberFormat: { type: Object, required: false },
+  isEditing: { type: Boolean, required: true },
+  advancedConfig: { type: Object, required: false }
+});
+const option = computed(() => ({
+  animation: !props.isEditing,
+  ...props.advancedConfig
+}));
+</script>

package/dist/modules/charts/runtime/blokkli/chart-types/advanced/render.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<any, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/definition.d.ts

@@ -0,0 +1,6 @@
+import type { DataLabelsTypeOptions, GridTypeOptions, LegendTypeOptions } from '#blokkli/charts/types';
+export type TypeOptions = {
+    splitIndex?: number;
+} & DataLabelsTypeOptions & GridTypeOptions & LegendTypeOptions;
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/definition.js

@@ -0,0 +1,40 @@
+import { defineChartType } from "#blokkli/charts/definition";
+import {
+  dataLabelsOptions,
+  gridOptions,
+  legendOptions,
+  mergeShared
+} from "#blokkli/charts/definition/options";
+export default defineChartType("agePyramid", ($t) => {
+  const shared = mergeShared(
+    dataLabelsOptions($t),
+    gridOptions($t),
+    legendOptions($t)
+  );
+  return {
+    hasSeriesColors: true,
+    hasCategoryColors: false,
+    editor: {
+      label: $t("chartsTypeAgePyramid", "Age pyramid"),
+      description: $t(
+        "chartsTypeAgePyramidDescription",
+        "Back-to-back horizontal bars by category, with series before the split index rendered on the left and the rest on the right. Multiple series on the same side stack."
+      ),
+      icon: "bk_mdi_groups_2",
+      options: {
+        splitIndex: {
+          type: "number",
+          nullable: true,
+          label: $t("chartsAgePyramidSplitIndex", "Right-side start index"),
+          description: $t(
+            "chartsAgePyramidSplitIndexDescription",
+            "Index of the first series rendered on the right. Series before this index render on the left. Defaults to half the number of series."
+          ),
+          min: 0,
+          group: "display"
+        },
+        ...shared.options
+      }
+    }
+  };
+});

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/illustration.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/illustration.vue

@@ -0,0 +1,41 @@
+<template>
+  <svg viewBox="0 0 120 80" xmlns="http://www.w3.org/2000/svg">
+    <template v-for="row in rows" :key="row.y">
+      <rect
+        :x="60 - row.left"
+        :y="row.y"
+        :width="row.left"
+        height="8"
+        rx="1.5"
+        class="_bk_fill-accent-500"
+      />
+      <rect
+        x="61"
+        :y="row.y"
+        :width="row.right"
+        height="8"
+        rx="1.5"
+        class="_bk_fill-accent-300"
+      />
+    </template>
+    <line
+      x1="60"
+      y1="8"
+      x2="60"
+      y2="72"
+      stroke-width="1.5"
+      stroke-linecap="round"
+      class="_bk_stroke-accent-900"
+    />
+  </svg>
+</template>
+
+<script setup>
+const rows = [
+  { y: 11, left: 16, right: 14 },
+  { y: 22, left: 22, right: 20 },
+  { y: 33, left: 28, right: 26 },
+  { y: 44, left: 34, right: 30 },
+  { y: 55, left: 26, right: 24 }
+];
+</script>

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/illustration.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/render.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<any, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/render.vue

@@ -0,0 +1,94 @@
+<template>
+  <VChart :option="option" autoresize style="height: 550px; width: 100%" />
+</template>
+
+<script setup>
+import { computed } from "#imports";
+import VChart from "vue-echarts";
+import { use } from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import { BarChart } from "echarts/charts";
+import {
+  GridComponent,
+  TooltipComponent,
+  LegendComponent,
+  TitleComponent
+} from "echarts/components";
+import { legendPositionToEcharts } from "../../../helpers/echarts";
+import { createNumberFormatter } from "../../../helpers/numberFormat";
+use([
+  CanvasRenderer,
+  BarChart,
+  GridComponent,
+  TooltipComponent,
+  LegendComponent,
+  TitleComponent
+]);
+const props = defineProps({
+  title: { type: String, required: true },
+  categories: { type: Array, required: true },
+  series: { type: Array, required: true },
+  seriesHexColors: { type: Array, required: true },
+  categoryHexColors: { type: Array, required: true },
+  typeOptions: { type: Object, required: true },
+  numberFormat: { type: Object, required: false },
+  isEditing: { type: Boolean, required: true },
+  advancedConfig: { type: Object, required: false }
+});
+const opts = computed(() => {
+  const t = props.typeOptions;
+  const rawSplit = Number(t.splitIndex);
+  const defaultSplit = Math.ceil(props.series.length / 2);
+  const split = Number.isFinite(rawSplit) ? rawSplit : defaultSplit;
+  return {
+    splitIndex: Math.max(0, Math.min(props.series.length, split)),
+    dataLabels: t.dataLabels ?? false,
+    gridLines: t.gridLines ?? true,
+    legendPosition: t.legendPosition ?? "bottom"
+  };
+});
+const option = computed(() => {
+  const o = opts.value;
+  const valueFormatter = createNumberFormatter(props.numberFormat);
+  const abs = (v) => Math.abs(v);
+  return {
+    title: props.title ? { text: props.title, left: "left" } : void 0,
+    animation: !props.isEditing,
+    tooltip: {
+      trigger: "axis",
+      axisPointer: { type: "shadow" },
+      valueFormatter: (v) => valueFormatter(abs(v))
+    },
+    legend: {
+      ...legendPositionToEcharts(o.legendPosition),
+      data: props.series.map((s) => s.name)
+    },
+    grid: { containLabel: true, top: 50, left: 10, right: 10, bottom: 40 },
+    xAxis: {
+      type: "value",
+      axisLabel: { formatter: (v) => valueFormatter(abs(v)) },
+      splitLine: { show: o.gridLines }
+    },
+    yAxis: {
+      type: "category",
+      data: props.categories,
+      axisTick: { alignWithLabel: true }
+    },
+    series: props.series.map((s, i) => {
+      const isLeft = i < o.splitIndex;
+      return {
+        type: "bar",
+        name: s.name,
+        stack: "pyramid",
+        data: isLeft ? s.data.map((v) => -v) : s.data,
+        itemStyle: { color: props.seriesHexColors[i] },
+        emphasis: { focus: "series" },
+        label: {
+          show: o.dataLabels,
+          formatter: (p) => valueFormatter(abs(p.value))
+        }
+      };
+    })
+  };
+});
+</script>

package/dist/modules/charts/runtime/blokkli/chart-types/agePyramid/render.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<any, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/charts/runtime/blokkli/chart-types/area/definition.d.ts

@@ -0,0 +1,7 @@
+import type { XAxisTypeOptions, DataLabelsTypeOptions, LegendTypeOptions, GridTypeOptions, StrokeWidthTypeOptions, YAxisMinTypeOptions, CategoryFilterTypeOptions } from '#blokkli/charts/types';
+export type TypeOptions = {
+    curved: boolean;
+    markers: boolean;
+} & XAxisTypeOptions & DataLabelsTypeOptions & LegendTypeOptions & GridTypeOptions & StrokeWidthTypeOptions & YAxisMinTypeOptions & CategoryFilterTypeOptions;
+declare const _default: any;
+export default _default;