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

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

@@ -0,0 +1,2 @@
+import type { Options } from './type';
+export declare function render(options: Options): Promise<import("@antv/g2-ssr").Chart>;

package/dist/cjs/ssr/index.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/index.ts
+var ssr_exports = {};
+__export(ssr_exports, {
+  render: () => render
+});
+module.exports = __toCommonJS(ssr_exports);
+var import_area = require("./area");
+var import_bar = require("./bar");
+var import_column = require("./column");
+var import_dual_axes = require("./dual-axes");
+var import_fishbone_diagram = require("./fishbone-diagram");
+var import_flow_diagram = require("./flow-diagram");
+var import_histogram = require("./histogram");
+var import_line = require("./line");
+var import_mind_map = require("./mind-map");
+var import_network_graph = require("./network-graph");
+var import_pie = require("./pie");
+var import_radar = require("./radar");
+var import_scatter = require("./scatter");
+var import_treemap = require("./treemap");
+var import_word_cloud = require("./word-cloud");
+async function render(options) {
+  switch (options.type) {
+    case "line":
+      return (0, import_line.Line)(options);
+    case "column":
+      return (0, import_column.Column)(options);
+    case "pie":
+      return (0, import_pie.Pie)(options);
+    case "area":
+      return (0, import_area.Area)(options);
+    case "bar":
+      return (0, import_bar.Bar)(options);
+    case "histogram":
+      return (0, import_histogram.Histogram)(options);
+    case "scatter":
+      return (0, import_scatter.Scatter)(options);
+    case "word-cloud":
+      return (0, import_word_cloud.WordCloud)(options);
+    case "treemap":
+      return (0, import_treemap.Treemap)(options);
+    case "dual-axes":
+      return (0, import_dual_axes.DualAxes)(options);
+    case "radar":
+      return (0, import_radar.Radar)(options);
+    case "mind-map":
+      return (0, import_mind_map.MindMap)(options);
+    case "network-graph":
+      return (0, import_network_graph.NetworkGraph)(options);
+    case "flow-diagram":
+      return (0, import_flow_diagram.FlowDiagram)(options);
+    case "fishbone-diagram":
+      return (0, import_fishbone_diagram.FishboneDiagram)(options);
+    default:
+      throw new Error(`Unknown chart type: ${options.type}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render
+});

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

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

package/dist/cjs/ssr/line.js

@@ -0,0 +1,62 @@
+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/line.ts
+var line_exports = {};
+__export(line_exports, {
+  Line: () => Line
+});
+module.exports = __toCommonJS(line_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function Line(options) {
+  var _a;
+  const { data, title, width = 600, height = 400, axisYTitle, axisXTitle } = options;
+  const hasGroupField = ((_a = (data || [])[0]) == null ? void 0 : _a.group) !== void 0;
+  let encode = {};
+  if (hasGroupField) {
+    encode = { x: "time", y: "value", color: "group" };
+  } else {
+    encode = { x: "time", y: "value" };
+  }
+  return await (0, import_g2_ssr.createChart)({
+    type: "view",
+    title,
+    data,
+    width,
+    height,
+    encode,
+    style: { minHeight: 1 },
+    axis: {
+      y: {
+        title: axisYTitle || false
+      },
+      x: {
+        title: axisXTitle || false
+      }
+    },
+    children: [
+      {
+        type: "line"
+      }
+    ]
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Line
+});

package/dist/cjs/ssr/mind-map.d.ts

@@ -0,0 +1,6 @@
+import { type MindMapProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type MindMapOptions = BaseChartConfig & {
+    type: 'mind-map';
+} & MindMapProps;
+export declare function MindMap(options: MindMapOptions): Promise<import("@antv/g6-ssr").Graph>;

package/dist/cjs/ssr/mind-map.js

@@ -0,0 +1,326 @@
+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/mind-map.ts
+var mind_map_exports = {};
+__export(mind_map_exports, {
+  MindMap: () => MindMap
+});
+module.exports = __toCommonJS(mind_map_exports);
+var import_g = require("@antv/g");
+var import_g6_ssr = require("@antv/g6-ssr");
+var import_canvas = require("canvas");
+var { register, BaseNode, BaseTransform, ExtensionCategory, idOf, positionOf, treeToGraphData } = import_g6_ssr.G6;
+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 RootNodeStyle = {
+  fill: "#EFF0F0",
+  labelFill: "#262626",
+  labelFontSize: 24,
+  labelFontWeight: 600,
+  labelOffsetY: 8,
+  labelPlacement: "center",
+  ports: [{ placement: "right" }, { placement: "left" }],
+  radius: 8
+};
+var NodeStyle = {
+  fill: "transparent",
+  labelPlacement: "center",
+  labelFontSize: 16,
+  ports: [{ placement: "right-bottom" }, { placement: "left-bottom" }]
+};
+var getNodeWidth = (nodeId, isRoot) => {
+  const padding = isRoot ? 40 : 30;
+  const nodeStyle = isRoot ? RootNodeStyle : NodeStyle;
+  return measureText({ text: nodeId, fontSize: nodeStyle.labelFontSize, fontFamily: "Gill Sans" }) + padding;
+};
+var getNodeSize = (nodeId, isRoot) => {
+  const width = getNodeWidth(nodeId, isRoot);
+  const height = isRoot ? 36 : 32;
+  return [width, height];
+};
+var MindmapNode = class extends BaseNode {
+  get childrenData() {
+    return this.context.model.getChildrenData(this.id);
+  }
+  get rootId() {
+    return idOf(this.context.model.getRootsData()[0]);
+  }
+  isShowCollapse(attributes) {
+    const { collapsed, showIcon } = attributes;
+    return !collapsed && showIcon && this.childrenData.length > 0;
+  }
+  getCollapseStyle(attributes) {
+    const { showIcon, color, direction } = attributes;
+    if (!this.isShowCollapse(attributes))
+      return false;
+    const [width, height] = this.getSize(attributes);
+    return {
+      backgroundFill: color,
+      backgroundHeight: 12,
+      backgroundWidth: 12,
+      cursor: "pointer",
+      fill: "#fff",
+      fontFamily: "iconfont",
+      fontSize: 8,
+      text: "",
+      textAlign: "center",
+      transform: direction === "left" ? [["rotate", 90]] : [["rotate", -90]],
+      visibility: showIcon ? "visible" : "hidden",
+      x: direction === "left" ? -6 : width + 6,
+      y: height
+    };
+  }
+  drawCollapseShape() {
+  }
+  getCountStyle(attributes) {
+    const { collapsed, color, direction } = attributes;
+    const count = this.context.model.getDescendantsData(this.id).length;
+    if (!collapsed || count === 0)
+      return false;
+    const [width, height] = this.getSize(attributes);
+    return {
+      backgroundFill: color,
+      backgroundHeight: 12,
+      backgroundWidth: 12,
+      cursor: "pointer",
+      fill: "#fff",
+      fontSize: 8,
+      text: count.toString(),
+      textAlign: "center",
+      x: direction === "left" ? -6 : width + 6,
+      y: height
+    };
+  }
+  drawCountShape() {
+  }
+  getAddStyle(attributes) {
+    const { collapsed, showIcon, direction } = attributes;
+    if (collapsed || !showIcon)
+      return false;
+    const [width, height] = this.getSize(attributes);
+    const color = "#ddd";
+    const offsetX = this.isShowCollapse(attributes) ? 24 : 12;
+    const isRoot = this.id === this.rootId;
+    return {
+      backgroundFill: "#fff",
+      backgroundHeight: 12,
+      backgroundLineWidth: 1,
+      backgroundStroke: color,
+      backgroundWidth: 12,
+      cursor: "pointer",
+      fill: color,
+      fontFamily: "iconfont",
+      fontSize: 8,
+      text: "",
+      textAlign: "center",
+      x: isRoot ? width + 12 : direction === "left" ? -offsetX : width + offsetX,
+      y: isRoot ? height / 2 : height
+    };
+  }
+  getAddBarStyle(attributes) {
+    const { collapsed, showIcon, direction, color = "#1783FF" } = attributes;
+    if (collapsed || !showIcon)
+      return false;
+    const [width, height] = this.getSize(attributes);
+    const offsetX = this.isShowCollapse(attributes) ? 12 : 0;
+    const isRoot = this.id === this.rootId;
+    const HEIGHT = 2;
+    const WIDTH = 6;
+    return {
+      cursor: "pointer",
+      fill: direction === "left" ? `linear-gradient(180deg, #fff 20%, ${color})` : `linear-gradient(0deg, #fff 20%, ${color})`,
+      height: HEIGHT,
+      width: WIDTH,
+      x: isRoot ? width : direction === "left" ? -offsetX - WIDTH : width + offsetX,
+      y: isRoot ? height / 2 - HEIGHT / 2 : height - HEIGHT / 2,
+      zIndex: -1
+    };
+  }
+  drawAddShape() {
+  }
+  forwardEvent() {
+  }
+  getKeyStyle(attributes) {
+    const [width, height] = this.getSize(attributes);
+    const keyShape = super.getKeyStyle(attributes);
+    return { width, height, ...keyShape };
+  }
+  drawKeyShape(attributes, container) {
+    const keyStyle = this.getKeyStyle(attributes);
+    return this.upsert("key", import_g.Rect, keyStyle, container);
+  }
+  render(attributes = this.parsedAttributes, container = this) {
+    super.render(attributes, container);
+  }
+};
+MindmapNode.defaultStyleProps = {
+  ...BaseNode.defaultStyleProps,
+  showIcon: false
+};
+var _AssignColorByBranch = class extends 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"
+  ]
+};
+register(ExtensionCategory.NODE, "mindmap", MindmapNode);
+register(ExtensionCategory.TRANSFORM, "assign-color-by-branch", AssignColorByBranch);
+var getNodeSide = (nodeData, parentData) => {
+  if (!parentData)
+    return "center";
+  const nodePositionX = positionOf(nodeData)[0];
+  const parentPositionX = positionOf(parentData)[0];
+  return parentPositionX > nodePositionX ? "left" : "right";
+};
+function visTreeData2GraphData(data) {
+  return 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 MindMap(options) {
+  const { data, width, height } = options;
+  const dataParse = visTreeData2GraphData(data);
+  const rootId = data.name;
+  return await (0, import_g6_ssr.createGraph)({
+    waitForRender: 300,
+    width,
+    height,
+    data: dataParse,
+    padding: 24,
+    autoFit: {
+      type: "view"
+    },
+    node: {
+      type: "mindmap",
+      // @ts-ignore
+      style: function(d) {
+        var _a, _b, _c;
+        const direction = getNodeSide(d, this.getParentData(idOf(d), "tree"));
+        const isRoot = idOf(d) === rootId;
+        const depth = d.depth;
+        return {
+          direction,
+          labelText: idOf(d),
+          size: getNodeSize(idOf(d), isRoot),
+          labelFontFamily: "Gill Sans",
+          lineWidth: 2,
+          radius: 8,
+          stroke: depth === 0 ? "#f1f4f5" : (_a = d.style) == null ? void 0 : _a.color,
+          labelBackground: true,
+          labelBackgroundFill: "transparent",
+          labelPadding: direction === "left" ? [2, 0, 10, 40] : [2, 40, 10, 0],
+          ...isRoot ? RootNodeStyle : NodeStyle,
+          fill: depth === 0 ? "#f1f4f5" : depth === 1 ? (_b = d.style) == null ? void 0 : _b.color : "transparent",
+          labelFill: depth === 0 ? "#262626" : depth === 1 ? "#FFF" : (_c = d.style) == null ? void 0 : _c.color,
+          ports: [{ placement: "left" }, { placement: "right" }]
+        };
+      }
+    },
+    edge: {
+      type: "cubic-horizontal",
+      style: {
+        lineWidth: 1.5,
+        // @ts-ignore
+        stroke: function(data2) {
+          return this.getNodeData(data2.target).depth > 1 ? (
+            // @ts-ignore
+            this.getNodeData(data2.target).style.color
+          ) : "#99ADD1";
+        }
+      }
+    },
+    layout: {
+      type: "mindmap",
+      direction: "H",
+      getHeight: () => 30,
+      getWidth: (node) => getNodeWidth(node.id, node.id === rootId),
+      getVGap: () => 14,
+      getHGap: () => 64,
+      animation: false
+    },
+    transforms: ["assign-color-by-branch"],
+    animation: false
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MindMap
+});

package/dist/cjs/ssr/network-graph.d.ts

@@ -0,0 +1,6 @@
+import { type NetworkGraphProps } from '../export';
+import { type BaseChartConfig } from './type';
+export type NetworkGraphOptions = BaseChartConfig & {
+    type: 'network-graph';
+} & NetworkGraphProps;
+export declare function NetworkGraph(options: NetworkGraphOptions): Promise<import("@antv/g6-ssr").Graph>;

package/dist/cjs/ssr/network-graph.js

@@ -0,0 +1,72 @@
+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/network-graph.ts
+var network_graph_exports = {};
+__export(network_graph_exports, {
+  NetworkGraph: () => NetworkGraph
+});
+module.exports = __toCommonJS(network_graph_exports);
+var import_g6_ssr = require("@antv/g6-ssr");
+async function NetworkGraph(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: "circle",
+      style: {
+        size: 20,
+        // @ts-ignore
+        labelText: (d) => d.name,
+        labelSize: 10,
+        labelFontSize: 10,
+        labelBackground: true
+      }
+    },
+    edge: {
+      style: {
+        // @ts-ignore
+        labelText: (d) => d.name,
+        labelFontSize: 10,
+        labelBackground: true,
+        endArrow: true
+      },
+      animation: { enter: false }
+    },
+    layout: {
+      type: "force-atlas2",
+      preventOverlap: true,
+      kr: 600
+    },
+    transforms: ["process-parallel-edges"]
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetworkGraph
+});

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

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

package/dist/cjs/ssr/pie.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/pie.ts
+var pie_exports = {};
+__export(pie_exports, {
+  Pie: () => Pie
+});
+module.exports = __toCommonJS(pie_exports);
+var import_g2_ssr = require("@antv/g2-ssr");
+async function Pie(options) {
+  const { data, title, width, height, innerRadius } = options;
+  return await (0, import_g2_ssr.createChart)({
+    type: "interval",
+    title,
+    width,
+    height,
+    data,
+    encode: { y: "value", color: "category" },
+    transform: [{ type: "stackY" }],
+    coordinate: {
+      type: "theta",
+      outerRadius: 0.95,
+      innerRadius
+    },
+    style: {
+      radius: 4,
+      stroke: "#fff",
+      lineWidth: 1
+    },
+    labels: [
+      {
+        text: (data2) => `${data2.category}: ${data2.value}`,
+        position: "outside",
+        radius: 0.85,
+        fontSize: 12
+      }
+    ],
+    legend: {
+      color: { position: "bottom", layout: { justifyContent: "center" } }
+    },
+    animate: false,
+    axis: false
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Pie
+});

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

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