@antv/gpt-vis 0.6.1 → 1.0.0-beta.2

package/dist/esm/syntax/parser.js

@@ -0,0 +1,559 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * GPT-Vis Syntax Parser
+ *
+ * Parses a markdown-like syntax for visualization configurations.
+ *
+ * Syntax rules:
+ * - `vis [chartType]` - Defines the chart type (required first line)
+ * - `data` - Starts a data array section
+ * - `  - key value` - Array item with key-value pairs
+ * - `  - value` - Simple array item (for flat arrays like histogram data)
+ * - `  - "value with spaces"` - Quoted string item; single or double quotes both supported.
+ *                               Quotes are required when the value contains spaces; optional otherwise.
+ *                               Quoted values are never coerced to numbers or booleans.
+ * - `key: value` or `key value` - Top-level key-value pair
+ * - `style` - Starts a style object section
+ * - `palette` inside `style` uses array syntax with dash-prefixed items
+ * - `children` - Nested array for hierarchical data (mind-map, treemap, etc.)
+ *
+ * @example
+ * ```
+ * vis pie
+ * data
+ *   - category 分类一
+ *     value 27
+ *   - category 分类二
+ *     value 25
+ * innerRadius: 0.6
+ * style
+ *   backgroundColor #333
+ *   palette
+ *     - #ff5a5f
+ *     - #1fb6ff
+ *     - #13ce66
+ * ```
+ *
+ * @example Simple array (histogram)
+ * ```
+ * vis histogram
+ * data
+ *   - 78
+ *   - 88
+ *   - 60
+ * binNumber 5
+ * ```
+ *
+ * @example Quoted string values (values containing spaces)
+ * ```
+ * vis dual-axes
+ * categories
+ *   - "North America"
+ *   - '东南 亚'
+ *   - 欧洲
+ * ```
+ *
+ * @example Hierarchical data (mind-map)
+ * ```
+ * vis mind-map
+ * data
+ *   - name 项目计划
+ *     children
+ *       - name 研究阶段
+ *         children
+ *           - name 市场调研
+ *           - name 技术可行性分析
+ *       - name 开发阶段
+ * ```
+ */
+
+/**
+ * Parsed chart configuration result
+ */
+
+// Known section names that contain arrays
+var ARRAY_SECTIONS = new Set(['data', 'categories', 'series', 'children', 'nodes', 'edges']);
+
+// Known section names that contain objects
+var OBJECT_SECTIONS = new Set(['style']);
+
+/**
+ * Try to parse a value as number, boolean, or keep as string
+ */
+function isQuotedString(s) {
+  if (s.length < 2) return false;
+  var quote = s[0];
+  if (quote !== '"' && quote !== "'") return false;
+  return s.endsWith(quote) && s.indexOf(quote, 1) === s.length - 1;
+}
+function parseValue(value) {
+  // Trim the value
+  var trimmed = value.trim();
+
+  // Empty string
+  if (trimmed === '') {
+    return '';
+  }
+
+  // Quoted string — strip quotes and return as-is, skipping numeric/boolean coercion
+  if (isQuotedString(trimmed)) {
+    return trimmed.slice(1, -1);
+  }
+
+  // Boolean values
+  if (trimmed === 'true') return true;
+  if (trimmed === 'false') return false;
+
+  // Numeric values
+  var num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== '') {
+    return num;
+  }
+  return trimmed;
+}
+
+/**
+ * Parse a key-value line (supports "key: value", "key=value" and "key value" formats)
+ * Supports Unicode characters (Chinese, Japanese, Korean, etc.) in key names
+ * Also supports special characters like parentheses, percent signs in key names
+ */
+function parseKeyValue(raw) {
+  var text = raw.trim();
+  if (!text) return null;
+  var match = text.match(/^([^:\s=]+)\s*[:=]\s*(.*)$/);
+  if (match) {
+    return {
+      key: match[1],
+      value: match[2]
+    };
+  }
+  var matchSpace = text.match(/^([^\s]+)\s+(.*)$/);
+  if (matchSpace) {
+    return {
+      key: matchSpace[1],
+      value: matchSpace[2]
+    };
+  }
+  return {
+    key: text,
+    value: ''
+  };
+}
+
+/**
+ * Check if a value is a simple value (not a key-value pair)
+ * Simple values are: numbers, strings that don't look like key-value pairs
+ */
+function isSimpleValue(line) {
+  var trimmed = line.trim();
+
+  // Quoted string is always a simple value, regardless of content
+  if (isQuotedString(trimmed)) {
+    return true;
+  }
+
+  // Check if it looks like a key-value pair
+  var hasKeyValue = parseKeyValue(trimmed);
+  if (hasKeyValue && hasKeyValue.value !== '') {
+    return false;
+  }
+
+  // It's a simple value (number, string without spaces matching key pattern)
+  return true;
+}
+
+/** Visual width of one tab for indent comparison (matches common 2-space nesting). */
+var TAB_INDENT_WIDTH = 2;
+
+/**
+ * Get the indentation level of a line (leading spaces + tabs; each tab counts as TAB_INDENT_WIDTH).
+ * This avoids treating a tab as "1 column" which breaks sibling vs child detection when users mix tabs and spaces.
+ */
+function getIndentLevel(line) {
+  var match = line.match(/^([\t ]*)/);
+  if (!match) return 0;
+  var w = 0;
+  var _iterator = _createForOfIteratorHelper(match[1]),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var ch = _step.value;
+      w += ch === '\t' ? TAB_INDENT_WIDTH : 1;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return w;
+}
+
+/**
+ * Check if a line is an array item marker (starts with -)
+ */
+function isArrayItemLine(line) {
+  return line.trim().startsWith('-');
+}
+
+/**
+ * Parse an array item line (removes the leading -)
+ */
+function parseArrayItemLine(line) {
+  return line.trim().replace(/^-\s*/, '');
+}
+
+/**
+ * Check if a key is a known section name (data, style, etc.)
+ */
+function isKnownSection(key) {
+  return ARRAY_SECTIONS.has(key) || OBJECT_SECTIONS.has(key);
+}
+
+/**
+ * Line information for parsing
+ */
+
+/**
+ * Parse lines into line info array
+ */
+function parseLines(syntax) {
+  var lines = syntax.split('\n');
+  var result = [];
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var trimmed = line.trim();
+
+    // Skip empty lines
+    if (trimmed === '') {
+      continue;
+    }
+    result.push({
+      line: line,
+      trimmed: trimmed,
+      indent: getIndentLevel(line),
+      lineNumber: i
+    });
+  }
+  return result;
+}
+
+/**
+ * Parse a single tree node object (for indented-tree / organization-chart root data).
+ * Handles key-value pairs and a nested `children` array.
+ */
+function parseTreeNode(lines, startIndex, baseIndent) {
+  var node = {};
+  var i = startIndex;
+  while (i < lines.length) {
+    var _lines$i = lines[i],
+      trimmed = _lines$i.trimmed,
+      indent = _lines$i.indent;
+    if (indent <= baseIndent) break;
+    var kv = parseKeyValue(trimmed);
+    if (kv) {
+      if (kv.key === 'children' && kv.value === '') {
+        var _parseArraySection = parseArraySection(lines, i + 1, indent),
+          childItems = _parseArraySection.items,
+          nextIndex = _parseArraySection.nextIndex;
+        node.children = childItems;
+        i = nextIndex;
+        continue;
+      } else {
+        node[kv.key] = parseValue(kv.value);
+      }
+    }
+    i++;
+  }
+  return {
+    node: node,
+    nextIndex: i
+  };
+}
+
+/**
+ * Parse an array of items (data, children, etc.)
+ * Supports nested children arrays for hierarchical data
+ */
+function parseArraySection(lines, startIndex, baseIndent) {
+  var items = [];
+  var currentItem = null;
+  var isSimpleArray = false;
+  var i = startIndex;
+  var firstItemIndent = -1;
+  while (i < lines.length) {
+    var _lines$i2 = lines[i],
+      trimmed = _lines$i2.trimmed,
+      indent = _lines$i2.indent;
+
+    // If we see something at base indent level or lower and it's not an array item,
+    // we're done with this section
+    if (indent <= baseIndent && !isArrayItemLine(trimmed)) {
+      break;
+    }
+
+    // If we see an array item strictly shallower than this `children` block, the list ends here
+    // (e.g. parent's next `- name` sibling). Use `<` not `<=`: when the first `-` bullet shares the
+    // same indent as the `children` keyword (common LLM/formatting), `<=` would break before any item.
+    if (isArrayItemLine(trimmed) && indent < baseIndent) {
+      break;
+    }
+
+    // Check if this is a new array item at our level
+    var isThisLevelItem = isArrayItemLine(trimmed) && (firstItemIndent === -1 || indent === firstItemIndent);
+
+    // Handle array item marker at our level
+    if (isThisLevelItem) {
+      // Set the first item indent if not yet set
+      if (firstItemIndent === -1) {
+        firstItemIndent = indent;
+      }
+
+      // Save previous item if exists
+      if (currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+      }
+      var itemContent = parseArrayItemLine(trimmed);
+      if (itemContent) {
+        // Determine if this is a simple value or a key-value pair
+        if (isSimpleValue(itemContent)) {
+          // Simple value array (e.g., histogram data: [78, 88, 60])
+          isSimpleArray = true;
+          items.push(parseValue(itemContent));
+          currentItem = null;
+        } else {
+          // Object array with key-value pairs
+          currentItem = {};
+          var kv = parseKeyValue(itemContent);
+          if (kv) {
+            currentItem[kv.key] = parseValue(kv.value);
+          }
+        }
+      } else {
+        // Empty array item marker, start a new object
+        currentItem = {};
+      }
+      i++;
+      continue;
+    }
+
+    // Array item at a different indent than the first bullet in this section
+    if (isArrayItemLine(trimmed) && firstItemIndent !== -1 && indent !== firstItemIndent) {
+      // Shallower bullet (still inside this section): new sibling — recover from mixed indent
+      if (indent < firstItemIndent && indent > baseIndent && currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+        var _itemContent = parseArrayItemLine(trimmed);
+        currentItem = {};
+        var _kv = parseKeyValue(_itemContent);
+        if (_kv) {
+          currentItem[_kv.key] = parseValue(_kv.value);
+        }
+        firstItemIndent = indent;
+        i++;
+        continue;
+      }
+      // Deeper bullet: treat as the next sibling (recover off-by-N indent). The old "implicit nested"
+      // branch merged these into currentItem.children and collapsed lists to a single branch — wrong
+      // for normal `children` blocks where bullets are only slightly deeper than the first.
+      if (indent > firstItemIndent && currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+        var _itemContent2 = parseArrayItemLine(trimmed);
+        currentItem = {};
+        var _kv2 = parseKeyValue(_itemContent2);
+        if (_kv2) {
+          currentItem[_kv2.key] = parseValue(_kv2.value);
+        }
+        firstItemIndent = indent;
+        i++;
+        continue;
+      }
+      i++;
+      continue;
+    }
+
+    // Handle properties of current item (including nested children)
+    if (currentItem !== null && !isSimpleArray) {
+      var _kv3 = parseKeyValue(trimmed);
+      if (_kv3) {
+        // Check if this is a 'children' key (start of nested array)
+        if (_kv3.key === 'children' && _kv3.value === '') {
+          // Parse nested children array - the children start after this line
+          var _parseArraySection2 = parseArraySection(lines, i + 1, indent),
+            childItems = _parseArraySection2.items,
+            nextIndex = _parseArraySection2.nextIndex;
+          currentItem.children = childItems;
+          i = nextIndex;
+          continue;
+        }
+        // Same as children: dual-axes `series` items use `data` followed by `- n` lines (see site examples).
+        if (_kv3.key === 'data' && _kv3.value === '') {
+          var _parseArraySection3 = parseArraySection(lines, i + 1, indent),
+            nestedData = _parseArraySection3.items,
+            _nextIndex = _parseArraySection3.nextIndex;
+          currentItem.data = nestedData;
+          i = _nextIndex;
+          continue;
+        }
+        currentItem[_kv3.key] = parseValue(_kv3.value);
+      }
+    }
+    i++;
+  }
+
+  // Save last item if exists
+  if (currentItem !== null && !isSimpleArray) {
+    items.push(currentItem);
+  }
+  return {
+    items: items,
+    nextIndex: i
+  };
+}
+
+/**
+ * Parse the visualization syntax string into a configuration object
+ */
+export function parse(syntax) {
+  var lines = parseLines(syntax);
+  var result = {
+    type: ''
+  };
+  var i = 0;
+  while (i < lines.length) {
+    var _lines$i3 = lines[i],
+      trimmed = _lines$i3.trimmed,
+      indent = _lines$i3.indent;
+
+    // Handle "vis [type]" declaration
+    if (trimmed.startsWith('vis ')) {
+      var chartType = trimmed.substring(4).trim();
+      result.type = chartType;
+      i++;
+      continue;
+    }
+
+    // Check for section headers (data, style, etc.) - single word, no indentation
+    var isSectionHeader = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed) && indent === 0 && isKnownSection(trimmed);
+    if (isSectionHeader) {
+      if (ARRAY_SECTIONS.has(trimmed)) {
+        // Check if the next non-empty indented line is a sub-section header (e.g. nodes/edges inside data)
+        var sectionName = trimmed;
+        var nextIndex = i + 1;
+        var hasSubSections = false;
+        if (nextIndex < lines.length && lines[nextIndex].indent > indent) {
+          var nextTrimmed = lines[nextIndex].trimmed;
+          hasSubSections = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(nextTrimmed) && !isArrayItemLine(nextTrimmed);
+        }
+        if (hasSubSections) {
+          // Parse as an object with named sub-arrays (e.g. data: { nodes: [], edges: [] })
+          var dataObj = {};
+          i++;
+          while (i < lines.length && lines[i].indent > indent) {
+            var subTrimmed = lines[i].trimmed;
+            var subIndent = lines[i].indent;
+            if (/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(subTrimmed) && !isArrayItemLine(subTrimmed)) {
+              var _parseArraySection4 = parseArraySection(lines, i + 1, subIndent),
+                subItems = _parseArraySection4.items,
+                subNext = _parseArraySection4.nextIndex;
+              dataObj[subTrimmed] = subItems;
+              i = subNext;
+            } else {
+              i++;
+            }
+          }
+          result[sectionName] = dataObj;
+          continue;
+        }
+
+        // Detect tree root object: first content is a key-value pair (not array item, not single-word section)
+        var isTreeRoot = false;
+        if (nextIndex < lines.length && lines[nextIndex].indent > indent) {
+          var firstTrimmed = lines[nextIndex].trimmed;
+          if (!isArrayItemLine(firstTrimmed) && !hasSubSections) {
+            isTreeRoot = true;
+          }
+        }
+        if (isTreeRoot) {
+          // Parse as a single tree root object (indented-tree / organization-chart data)
+          var _parseTreeNode = parseTreeNode(lines, i + 1, indent),
+            node = _parseTreeNode.node,
+            treeNext = _parseTreeNode.nextIndex;
+          result[sectionName] = node;
+          i = treeNext;
+          continue;
+        }
+
+        // Parse array section (standard behavior)
+        var _parseArraySection5 = parseArraySection(lines, i + 1, indent),
+          items = _parseArraySection5.items,
+          arrNext = _parseArraySection5.nextIndex;
+        if (items.length > 0) {
+          result[sectionName] = items;
+        }
+        i = arrNext;
+        continue;
+      } else if (OBJECT_SECTIONS.has(trimmed)) {
+        // Parse object section (style)
+        var _sectionName = trimmed;
+        var sectionObj = {};
+        result[_sectionName] = sectionObj;
+        var sectionIndent = indent;
+        i++;
+        while (i < lines.length) {
+          var _lines$i4 = lines[i],
+            innerTrimmed = _lines$i4.trimmed,
+            innerIndent = _lines$i4.indent;
+
+          // If indent goes back to section level or lower, we're done with this section
+          if (innerIndent <= sectionIndent) {
+            break;
+          }
+
+          // Check for array item lines (palette sub-array items)
+          if (isArrayItemLine(innerTrimmed)) {
+            i++;
+            continue;
+          }
+          var kv = parseKeyValue(innerTrimmed);
+          if (kv) {
+            // Check if this key is followed by dash-prefixed array items (e.g., palette)
+            if (kv.value === '' && i + 1 < lines.length) {
+              var nextLine = lines[i + 1];
+              if (nextLine.indent > innerIndent && isArrayItemLine(nextLine.trimmed)) {
+                var _parseArraySection6 = parseArraySection(lines, i + 1, innerIndent),
+                  _items = _parseArraySection6.items,
+                  _nextIndex2 = _parseArraySection6.nextIndex;
+                sectionObj[kv.key] = _items;
+                i = _nextIndex2;
+                continue;
+              }
+            }
+            sectionObj[kv.key] = parseValue(kv.value);
+          }
+          i++;
+        }
+        continue;
+      }
+    }
+
+    // Top-level key-value pair
+    if (indent === 0) {
+      var _kv4 = parseKeyValue(trimmed);
+      if (_kv4) {
+        result[_kv4.key] = parseValue(_kv4.value);
+      }
+    }
+    i++;
+  }
+  return result;
+}
+
+/**
+ * Check if a val is a valid visualization syntax
+ */
+export function isVisSyntax(input) {
+  if (typeof input !== 'string') return false;
+  var trimmed = input.trim();
+  return trimmed.startsWith('vis ');
+}

package/dist/esm/types/index.d.ts

@@ -1,2 +1,33 @@
-export * from './chart';
-export type { GlobalConfig } from './config';
+/**
+ * Common visualization options for all chart components.
+ * Defines the container and dimensions for rendering visualizations.
+ */
+export interface VisualizationOptions {
+    container: string | HTMLElement;
+    width?: number;
+    height?: number;
+    theme?: 'default' | 'light' | 'dark' | 'academy';
+    wrapper?: boolean;
+    locale?: string;
+}
+/**
+ * Tree graph data structure
+ */
+export interface TreeGraphData {
+    name: string;
+    description?: string;
+    children?: TreeGraphData[];
+}
+/**
+ * Network graph data structure
+ */
+export interface GraphData {
+    nodes: {
+        name: string;
+    }[];
+    edges: {
+        source: string;
+        target: string;
+        name?: string;
+    }[];
+}

package/dist/esm/types/index.js

@@ -1,2 +1 @@
-export * from "./chart";
 export {};

package/dist/esm/util/container.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolve a container parameter to an HTMLElement.
+ * Supports CSS selectors (e.g., '#container', '.my-chart') and direct HTMLElement references.
+ */
+export declare function resolveContainer(container: string | HTMLElement): HTMLElement;

package/dist/esm/util/container.js

@@ -0,0 +1,20 @@
+/**
+ * Resolve a container parameter to an HTMLElement.
+ * Supports CSS selectors (e.g., '#container', '.my-chart') and direct HTMLElement references.
+ */
+export function resolveContainer(container) {
+  if (typeof container === 'string') {
+    if (typeof document === 'undefined') {
+      // In a non-browser (SSR) environment, a string container cannot be resolved to a real HTMLElement.
+      // Throwing an error here prevents a ReferenceError from document.querySelector
+      // and clearly indicates that DOM resolution is not possible in this environment.
+      throw new Error("Container element \"".concat(container, "\" cannot be resolved in a non-browser environment."));
+    }
+    var el = document.querySelector(container);
+    if (!el) {
+      throw new Error("Container element \"".concat(container, "\" not found"));
+    }
+    return el;
+  }
+  return container;
+}

package/dist/esm/util/theme.d.ts

@@ -0,0 +1,26 @@
+export declare const DEFAULT_COLOR_PALETTE: string[];
+export declare const ACADEMY_COLOR_PALETTE: string[];
+export declare const THEME_MAP: Record<string, any>;
+/**
+ * Get normalized theme name for G2.
+ * Converts 'default' to 'light' for G2 compatibility.
+ */
+export declare const getTheme: (theme: string) => string;
+/**
+ * Get theme object from THEME_MAP.
+ * This should be used for visualization components to properly support dark theme with multiple marks.
+ */
+export declare const getThemeObject: (theme: string) => any;
+/**
+ * Get theme color palette based on theme name.
+ */
+export declare const getThemeColors: (theme: string) => string[];
+/**
+ * Get background color based on theme.
+ */
+export declare const getBackgroundColor: (theme: string) => string;
+/**
+ * Normalize palette to always return an array.
+ * Handles the case where a single color is parsed as a string instead of an array.
+ */
+export declare const normalizePalette: (palette: string | string[] | undefined, theme: string) => string[];