@antv/gpt-vis 0.4.7 → 0.5.0-beta.0

package/dist/cjs/ssr/area.d.ts

@@ -0,0 +1,6 @@
+import { type AreaProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type AreaOptions = BaseChartConfig & {
+    type: 'area';
+} & AreaProps;
+export declare function Area(options: AreaOptions): Promise<import("@antv/g2-ssr").Chart>;

package/dist/cjs/ssr/area.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/area.ts
+var area_exports = {};
+__export(area_exports, {
+  Area: () => Area
+});
+module.exports = __toCommonJS(area_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function Area(options) {
+  const { data, title, width, height, stack, axisYTitle, axisXTitle } = options;
+  let encode = {};
+  let transform = [];
+  if (stack) {
+    encode = { x: "time", y: "value", color: "group" };
+    transform = [{ type: "stackY" }];
+  } else {
+    encode = { x: "time", y: "value" };
+  }
+  return await (0, import_g2_ssr.createChart)({
+    type: "view",
+    title,
+    data,
+    width,
+    height,
+    encode,
+    transform,
+    style: { minHeight: 1 },
+    axis: {
+      y: {
+        title: axisYTitle || false
+      },
+      x: {
+        title: axisXTitle || false
+      }
+    },
+    children: [
+      {
+        type: "area",
+        style: { opacity: 0.7 }
+      }
+    ]
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Area
+});

package/dist/cjs/ssr/bar.d.ts

@@ -0,0 +1,6 @@
+import { type BarProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type BarOptions = BaseChartConfig & {
+    type: 'bar';
+} & BarProps;
+export declare function Bar(options: BarOptions): Promise<import("@antv/g2-ssr").Chart>;

package/dist/cjs/ssr/bar.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/bar.ts
+var bar_exports = {};
+__export(bar_exports, {
+  Bar: () => Bar
+});
+module.exports = __toCommonJS(bar_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function Bar(options) {
+  var _a;
+  const { data, title, width, height, stack, group, axisYTitle, axisXTitle } = options;
+  const hasGroupField = ((_a = (data || [])[0]) == null ? void 0 : _a.group) !== void 0;
+  let transforms = [];
+  if (group) {
+    transforms = [
+      {
+        type: "dodgeX"
+      }
+    ];
+  }
+  if (stack) {
+    transforms = [
+      {
+        type: "stackY"
+      }
+    ];
+  }
+  return await (0, import_g2_ssr.createChart)({
+    width,
+    height,
+    title,
+    type: "interval",
+    data,
+    encode: hasGroupField ? {
+      x: "category",
+      y: "value",
+      color: "group"
+    } : {
+      x: "category",
+      y: "value"
+    },
+    transform: transforms,
+    coordinate: { transform: [{ type: "transpose" }] },
+    style: {
+      // 圆角样式
+      radiusTopLeft: 10,
+      radiusTopRight: 10
+    },
+    axis: {
+      x: {
+        title: axisXTitle
+      },
+      y: {
+        title: axisYTitle
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Bar
+});

package/dist/cjs/ssr/column.d.ts

@@ -0,0 +1,6 @@
+import { type ColumnProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type ColumnOptions = BaseChartConfig & {
+    type: 'column';
+} & ColumnProps;
+export declare function Column(options: ColumnOptions): Promise<import("@antv/g2-ssr").Chart>;

package/dist/cjs/ssr/column.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/column.ts
+var column_exports = {};
+__export(column_exports, {
+  Column: () => Column
+});
+module.exports = __toCommonJS(column_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function Column(options) {
+  var _a;
+  const { data, title, width, height, axisYTitle, axisXTitle, group, stack } = options;
+  const hasGroupField = ((_a = (data || [])[0]) == null ? void 0 : _a.group) !== void 0;
+  let transforms = [];
+  if (group) {
+    transforms = [
+      {
+        type: "dodgeX"
+      }
+    ];
+  }
+  if (stack) {
+    transforms = [
+      {
+        type: "stackY"
+      }
+    ];
+  }
+  return await (0, import_g2_ssr.createChart)({
+    width,
+    height,
+    title,
+    data,
+    type: "interval",
+    encode: hasGroupField ? {
+      x: "category",
+      y: "value",
+      color: "group"
+    } : {
+      x: "category",
+      y: "value"
+    },
+    transform: transforms,
+    style: {
+      radiusTopLeft: 10,
+      radiusTopRight: 10
+    },
+    axis: {
+      x: {
+        title: axisXTitle
+      },
+      y: {
+        title: axisYTitle
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Column
+});

package/dist/cjs/ssr/dual-axes.d.ts

@@ -0,0 +1,6 @@
+import { type DualAxesProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type DualAxespOptions = BaseChartConfig & {
+    type: 'dual-axes';
+} & DualAxesProps;
+export declare function DualAxes(options: DualAxespOptions): Promise<import("@antv/g2-ssr").Chart>;

package/dist/cjs/ssr/dual-axes.js

@@ -0,0 +1,98 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/dual-axes.ts
+var dual_axes_exports = {};
+__export(dual_axes_exports, {
+  DualAxes: () => DualAxes
+});
+module.exports = __toCommonJS(dual_axes_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function DualAxes(options) {
+  const { series, categories, title, width, height } = options;
+  let ChartType;
+  ((ChartType2) => {
+    ChartType2["Column"] = "column";
+    ChartType2["Line"] = "line";
+  })(ChartType || (ChartType = {}));
+  function transform(series2, categories2) {
+    const newChildren = series2.map((item) => {
+      const { type, axisYTitle, ...others } = item;
+      const baseConfig = {
+        ...others,
+        axis: { y: { title: axisYTitle } },
+        encode: { x: "category", y: axisYTitle, color: () => axisYTitle },
+        legend: {
+          color: {
+            itemMarker: (v) => {
+              if (v === axisYTitle)
+                return "smooth";
+              return "rect";
+            }
+          }
+        },
+        data: void 0
+      };
+      if (type === "column" /* Column */) {
+        return { ...baseConfig, type: "interval" };
+      }
+      if (type === "line" /* Line */) {
+        return {
+          ...baseConfig,
+          type,
+          axis: { y: { position: "right", title: axisYTitle } },
+          encode: { x: "category", y: axisYTitle, shape: "smooth", color: () => axisYTitle },
+          style: { lineWidth: 2, stroke: "#5AD8A6" },
+          scale: { y: { independent: true } }
+        };
+      }
+      return baseConfig;
+    });
+    const newData = categories2.map((item, index) => {
+      const temp = {
+        category: item
+      };
+      series2.forEach((s, i) => {
+        const defaultYField = s.axisYTitle || `value_${i + 1}`;
+        temp[defaultYField] = s.data[index];
+      });
+      return temp;
+    });
+    const legendTypeList = series2.map((item) => {
+      return item.type === "line" /* Line */ ? "smooth" : "rect";
+    });
+    return {
+      children: newChildren,
+      data: newData,
+      legendTypeList
+    };
+  }
+  const config = transform(series, categories);
+  return await (0, import_g2_ssr.createChart)({
+    type: "view",
+    autoFit: true,
+    title,
+    width,
+    height,
+    ...config
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DualAxes
+});

package/dist/cjs/ssr/fishbone-diagram.d.ts

@@ -0,0 +1,6 @@
+import { type FishboneDiagramProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type FishboneDiagramOptions = BaseChartConfig & {
+    type: 'fishbone-diagram';
+} & FishboneDiagramProps;
+export declare function FishboneDiagram(options: FishboneDiagramOptions): Promise<import("@antv/g6-ssr").Graph>;

package/dist/cjs/ssr/fishbone-diagram.js

@@ -0,0 +1,189 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/fishbone-diagram.ts
+var fishbone_diagram_exports = {};
+__export(fishbone_diagram_exports, {
+  FishboneDiagram: () => FishboneDiagram
+});
+module.exports = __toCommonJS(fishbone_diagram_exports);
+var import_g6 = require("@antv/g6");
+var import_g6_ssr = require("@antv/g6-ssr");
+var import_canvas = require("canvas");
+var canvas = null;
+var ctx = null;
+var measureText = (style) => {
+  if (!canvas) {
+    canvas = (0, import_canvas.createCanvas)(0, 0);
+    ctx = canvas.getContext("2d");
+  }
+  const font = [
+    style.fontStyle || "normal",
+    style.fontWeight || "normal",
+    `${style.fontSize || 12}px`,
+    style.fontFamily || "sans-serif"
+  ].join(" ");
+  ctx.font = font;
+  return ctx.measureText(style.text).width;
+};
+var _AssignColorByBranch = class extends import_g6.BaseTransform {
+  constructor(context, options) {
+    super(context, Object.assign({}, _AssignColorByBranch.defaultOptions, options));
+  }
+  beforeDraw(input) {
+    const nodes = this.context.model.getNodeData();
+    if (nodes.length === 0)
+      return input;
+    let colorIndex = 0;
+    const dfs = (nodeId, color) => {
+      var _a;
+      const node = nodes.find((datum) => datum.id == nodeId);
+      if (!node)
+        return;
+      node.style || (node.style = {});
+      node.style.color = color || this.options.colors[colorIndex++ % this.options.colors.length];
+      (_a = node.children) == null ? void 0 : _a.forEach((childId) => {
+        var _a2;
+        return dfs(childId, (_a2 = node.style) == null ? void 0 : _a2.color);
+      });
+    };
+    nodes.filter((node) => node.depth === 1).forEach((rootNode) => dfs(rootNode.id));
+    return input;
+  }
+};
+var AssignColorByBranch = _AssignColorByBranch;
+AssignColorByBranch.defaultOptions = {
+  colors: [
+    "#1783FF",
+    "#F08F56",
+    "#D580FF",
+    "#00C9C9",
+    "#7863FF",
+    "#DB9D0D",
+    "#60C42D",
+    "#FF80CA",
+    "#2491B3",
+    "#17C76F"
+  ]
+};
+(0, import_g6_ssr.register)(import_g6.ExtensionCategory.TRANSFORM, "assign-color-by-branch", AssignColorByBranch);
+var getNodeSize = (id, depth) => {
+  const FONT_FAMILY = "system-ui, sans-serif";
+  return depth === 0 ? [
+    measureText({ text: id, fontSize: 24, fontWeight: "bold", fontFamily: FONT_FAMILY }) + 80,
+    70
+  ] : depth === 1 ? [measureText({ text: id, fontSize: 18, fontFamily: FONT_FAMILY }) + 50, 42] : [2, 30];
+};
+function visTreeData2GraphData(data) {
+  return (0, import_g6.treeToGraphData)(data, {
+    getNodeData: (datum, depth) => {
+      datum.id = datum.name;
+      datum.depth = depth;
+      if (!datum.children)
+        return datum;
+      const { children, ...restDatum } = datum;
+      return {
+        ...restDatum,
+        children: children.map((child) => child.name)
+      };
+    },
+    getEdgeData: (source, target) => ({
+      source: source.name,
+      target: target.name
+    })
+  });
+}
+async function FishboneDiagram(options) {
+  const { data, width = 600, height = 400 } = options;
+  const dataParse = visTreeData2GraphData(data);
+  return await (0, import_g6_ssr.createGraph)({
+    autoFit: {
+      type: "view",
+      options: {
+        when: "overflow",
+        direction: "x"
+      }
+    },
+    width,
+    height,
+    data: dataParse,
+    padding: 20,
+    node: {
+      type: "rect",
+      // @ts-ignore
+      style: (d) => {
+        var _a;
+        const style = {
+          radius: 8,
+          size: getNodeSize(d.id, d.depth),
+          labelText: d.id,
+          labelPlacement: "left",
+          labelFontFamily: "Gill Sans"
+        };
+        if (d.depth === 0) {
+          Object.assign(style, {
+            fill: "#EFF0F0",
+            labelFill: "#262626",
+            labelFontWeight: "bold",
+            labelFontSize: 24,
+            labelOffsetY: 4,
+            labelPlacement: "center",
+            labelLineHeight: 24
+          });
+        } else if (d.depth === 1) {
+          Object.assign(style, {
+            labelFontSize: 18,
+            labelFill: "#fff",
+            labelFillOpacity: 0.9,
+            labelOffsetY: 5,
+            labelPlacement: "center",
+            fill: (_a = d.style) == null ? void 0 : _a.color
+          });
+        } else {
+          Object.assign(style, {
+            fill: "transparent",
+            labelFontSize: 16,
+            labeFill: "#262626"
+          });
+        }
+        return style;
+      }
+    },
+    edge: {
+      type: "polyline",
+      style: {
+        lineWidth: 3,
+        // @ts-ignore
+        stroke: function(data2) {
+          return this.getNodeData(data2.target).style.color || "#99ADD1";
+        }
+      }
+    },
+    transforms: ["assign-color-by-branch"],
+    layout: {
+      type: "fishbone",
+      direction: "RL",
+      hGap: 40,
+      vGap: 60
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FishboneDiagram
+});

package/dist/cjs/ssr/flow-diagram.d.ts

@@ -0,0 +1,6 @@
+import { type FlowDiagramProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type FlowDiagramOptions = BaseChartConfig & {
+    type: 'flow-diagram';
+} & FlowDiagramProps;
+export declare function FlowDiagram(options: FlowDiagramOptions): Promise<import("@antv/g6-ssr").Graph>;

package/dist/cjs/ssr/flow-diagram.js

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/flow-diagram.ts
+var flow_diagram_exports = {};
+__export(flow_diagram_exports, {
+  FlowDiagram: () => FlowDiagram
+});
+module.exports = __toCommonJS(flow_diagram_exports);
+var import_g6_ssr = require("@antv/g6-ssr");
+async function FlowDiagram(options) {
+  const { data, width = 600, height = 400 } = options;
+  const graphData = {
+    nodes: data.nodes.map((node) => ({ ...node, id: node.name })),
+    edges: data.edges.map((edge) => ({ ...edge, id: `${edge.source}-${edge.target}` }))
+  };
+  return await (0, import_g6_ssr.createGraph)({
+    data: graphData,
+    width,
+    height,
+    devicePixelRatio: 3,
+    autoFit: "view",
+    padding: 20,
+    animation: false,
+    node: {
+      type: "rect",
+      style: {
+        size: (d) => [d.name.length * 15 + 30, 35],
+        radius: 6,
+        // @ts-ignore
+        iconText: (d) => d.name,
+        iconFontSize: 12,
+        iconFontWeight: 800
+      }
+    },
+    edge: {
+      type: "polyline",
+      style: {
+        lineWidth: 2,
+        radius: 10,
+        stroke: "#99ADD1",
+        endArrow: true,
+        // @ts-ignore
+        labelText: (d) => d.name,
+        labelFill: "#555555",
+        labelFontWeight: 800,
+        labelBackground: true,
+        labelBackgroundFill: "rgba(255,255,255,0.6)",
+        labelBackgroundOpacity: 1,
+        labelBackgroundLineWidth: 2,
+        labelPadding: [2, 5],
+        labelBackgroundRadius: 2,
+        router: {
+          type: "orth"
+        }
+      }
+    },
+    layout: {
+      type: "dagre",
+      rankdir: "LR"
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowDiagram
+});

package/dist/cjs/ssr/histogram.d.ts

@@ -0,0 +1,6 @@
+import { type HistogramProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type HistogramOptions = BaseChartConfig & {
+    type: 'histogram';
+} & HistogramProps;
+export declare function Histogram(options: HistogramOptions): Promise<import("@antv/g2-ssr").Chart>;

package/dist/cjs/ssr/histogram.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ssr/histogram.ts
+var histogram_exports = {};
+__export(histogram_exports, {
+  Histogram: () => Histogram
+});
+module.exports = __toCommonJS(histogram_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function Histogram(options) {
+  const { data, title, width, height, axisYTitle, axisXTitle, binNumber } = options;
+  return await (0, import_g2_ssr.createChart)({
+    type: "interval",
+    width,
+    height,
+    data,
+    title,
+    encode: {
+      x: (d) => d,
+      y: "count"
+    },
+    transform: [{ type: "binX", y: "count", thresholds: binNumber }],
+    style: { minHeight: 1, columnWidthRatio: 1, inset: 0.5 },
+    axis: {
+      x: { title: axisXTitle },
+      y: { title: axisYTitle }
+    },
+    animate: false
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Histogram
+});