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

package/dist/esm/index.js

@@ -1,14 +1,20 @@
 export { GPTVis } from "./gpt-vis";
-export { isVisSyntax } from "./syntax";
+export { isVisSyntax, parse } from "./syntax";
 export { Area } from "./vis/area";
 export { Bar } from "./vis/bar";
 export { Boxplot } from "./vis/boxplot";
 export { Column } from "./vis/column";
 export { DualAxes } from "./vis/dual-axes";
+export { FishboneDiagram } from "./vis/fishbone-diagram";
+export { FlowDiagram } from "./vis/flow-diagram";
 export { Funnel } from "./vis/funnel";
 export { Histogram } from "./vis/histogram";
+export { IndentedTree } from "./vis/indented-tree";
 export { Line } from "./vis/line";
 export { Liquid } from "./vis/liquid";
+export { Mindmap } from "./vis/mindmap";
+export { NetworkGraph } from "./vis/network-graph";
+export { OrganizationChart } from "./vis/organization-chart";
 export { Pie } from "./vis/pie";
 export { Radar } from "./vis/radar";
 export { Sankey } from "./vis/sankey";

package/dist/esm/syntax/parser.d.ts

@@ -8,9 +8,12 @@
  * - `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
- * - Multiple values separated by spaces become arrays (e.g., `palette #ff5a5f #1fb6ff`)
+ * - `palette` inside `style` uses array syntax with dash-prefixed items
  * - `children` - Nested array for hierarchical data (mind-map, treemap, etc.)
  *
  * @example
@@ -24,7 +27,10 @@
  * innerRadius: 0.6
  * style
  *   backgroundColor #333
- *   palette #ff5a5f #1fb6ff #13ce66
+ *   palette
+ *     - #ff5a5f
+ *     - #1fb6ff
+ *     - #13ce66
  * ```
  *
  * @example Simple array (histogram)
@@ -37,6 +43,15 @@
  * binNumber 5
  * ```
  *
+ * @example Quoted string values (values containing spaces)
+ * ```
+ * vis dual-axes
+ * categories
+ *   - "North America"
+ *   - '东南 亚'
+ *   - 欧洲
+ * ```
+ *
  * @example Hierarchical data (mind-map)
  * ```
  * vis mind-map

package/dist/esm/syntax/parser.js

@@ -1,3 +1,6 @@
+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
  *
@@ -8,9 +11,12 @@
  * - `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
- * - Multiple values separated by spaces become arrays (e.g., `palette #ff5a5f #1fb6ff`)
+ * - `palette` inside `style` uses array syntax with dash-prefixed items
  * - `children` - Nested array for hierarchical data (mind-map, treemap, etc.)
  *
  * @example
@@ -24,7 +30,10 @@
  * innerRadius: 0.6
  * style
  *   backgroundColor #333
- *   palette #ff5a5f #1fb6ff #13ce66
+ *   palette
+ *     - #ff5a5f
+ *     - #1fb6ff
+ *     - #13ce66
  * ```
  *
  * @example Simple array (histogram)
@@ -37,6 +46,15 @@
  * binNumber 5
  * ```
  *
+ * @example Quoted string values (values containing spaces)
+ * ```
+ * vis dual-axes
+ * categories
+ *   - "North America"
+ *   - '东南 亚'
+ *   - 欧洲
+ * ```
+ *
  * @example Hierarchical data (mind-map)
  * ```
  * vis mind-map
@@ -56,7 +74,7 @@
  */
 
 // Known section names that contain arrays
-var ARRAY_SECTIONS = new Set(['data', 'categories', 'series', 'children']);
+var ARRAY_SECTIONS = new Set(['data', 'categories', 'series', 'children', 'nodes', 'edges']);
 
 // Known section names that contain objects
 var OBJECT_SECTIONS = new Set(['style']);
@@ -64,6 +82,12 @@ 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();
@@ -73,6 +97,11 @@ function parseValue(value) {
     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;
@@ -86,60 +115,31 @@ function parseValue(value) {
 }
 
 /**
- * Parse multiple space-separated values into an array or single value
- * Used for style properties like palette where multiple colors are expected
+ * 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 parseMultipleValues(values) {
-  var trimmed = values.trim();
-
-  // Split by spaces, but handle the case where we want a single value
-  var parts = trimmed.split(/\s+/).filter(function (p) {
-    return p.length > 0;
-  });
-  if (parts.length === 0) {
-    return '';
-  }
-  if (parts.length === 1) {
-    return parseValue(parts[0]);
-  }
-
-  // Multiple values become an array
-  return parts.map(parseValue);
-}
-
-/**
- * Parse a key-value line (supports both "key: value" and "key value" formats)
- */
-function parseKeyValue(line) {
-  var trimmed = line.trim();
-
-  // Try "key: value" format first
-  var colonMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/);
-  if (colonMatch) {
+function parseKeyValue(raw) {
+  var text = raw.trim();
+  if (!text) return null;
+  var match = text.match(/^([^:\s=]+)\s*[:=]\s*(.*)$/);
+  if (match) {
     return {
-      key: colonMatch[1],
-      value: colonMatch[2]
+      key: match[1],
+      value: match[2]
     };
   }
-
-  // Try "key value" format (key must be a valid identifier)
-  var spaceMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s+(.+)$/);
-  if (spaceMatch) {
+  var matchSpace = text.match(/^([^\s]+)\s+(.*)$/);
+  if (matchSpace) {
     return {
-      key: spaceMatch[1],
-      value: spaceMatch[2]
+      key: matchSpace[1],
+      value: matchSpace[2]
     };
   }
-
-  // Single key without value
-  var singleKey = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)$/);
-  if (singleKey) {
-    return {
-      key: singleKey[1],
-      value: ''
-    };
-  }
-  return null;
+  return {
+    key: text,
+    value: ''
+  };
 }
 
 /**
@@ -149,6 +149,11 @@ function parseKeyValue(line) {
 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 !== '') {
@@ -159,12 +164,30 @@ function isSimpleValue(line) {
   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 (normalized to units of 2 spaces)
+ * 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(/^(\s*)/);
-  return match ? match[1].length : 0;
+  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;
 }
 
 /**
@@ -216,6 +239,39 @@ function parseLines(syntax) {
   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
@@ -227,9 +283,9 @@ function parseArraySection(lines, startIndex, baseIndent) {
   var i = startIndex;
   var firstItemIndent = -1;
   while (i < lines.length) {
-    var _lines$i = lines[i],
-      trimmed = _lines$i.trimmed,
-      indent = _lines$i.indent;
+    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
@@ -237,9 +293,10 @@ function parseArraySection(lines, startIndex, baseIndent) {
       break;
     }
 
-    // If we see an array item at a lower or equal indent to base,
-    // we've reached a sibling at the parent level - return
-    if (isArrayItemLine(trimmed) && indent <= baseIndent) {
+    // 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;
     }
 
@@ -281,30 +338,64 @@ function parseArraySection(lines, startIndex, baseIndent) {
       continue;
     }
 
-    // If we have a first item indent set and we see an array item at a different indent,
-    // it might be a nested child's item - just skip for now, let nested parsing handle it
+    // Array item at a different indent than the first bullet in this section
     if (isArrayItemLine(trimmed) && firstItemIndent !== -1 && indent !== firstItemIndent) {
-      // This shouldn't happen if we're parsing correctly - skip and continue
+      // 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 _kv = parseKeyValue(trimmed);
-      if (_kv) {
+      var _kv3 = parseKeyValue(trimmed);
+      if (_kv3) {
         // Check if this is a 'children' key (start of nested array)
-        if (_kv.key === 'children' && _kv.value === '') {
+        if (_kv3.key === 'children' && _kv3.value === '') {
           // Parse nested children array - the children start after this line
-          var _parseArraySection = parseArraySection(lines, i + 1, indent),
-            childItems = _parseArraySection.items,
-            nextIndex = _parseArraySection.nextIndex;
+          var _parseArraySection2 = parseArraySection(lines, i + 1, indent),
+            childItems = _parseArraySection2.items,
+            nextIndex = _parseArraySection2.nextIndex;
           currentItem.children = childItems;
           i = nextIndex;
           continue;
-        } else {
-          currentItem[_kv.key] = parseValue(_kv.value);
         }
+        // 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++;
@@ -330,9 +421,9 @@ export function parse(syntax) {
   };
   var i = 0;
   while (i < lines.length) {
-    var _lines$i2 = lines[i],
-      trimmed = _lines$i2.trimmed,
-      indent = _lines$i2.indent;
+    var _lines$i3 = lines[i],
+      trimmed = _lines$i3.trimmed,
+      indent = _lines$i3.indent;
 
     // Handle "vis [type]" declaration
     if (trimmed.startsWith('vis ')) {
@@ -346,32 +437,99 @@ export function parse(syntax) {
     var isSectionHeader = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed) && indent === 0 && isKnownSection(trimmed);
     if (isSectionHeader) {
       if (ARRAY_SECTIONS.has(trimmed)) {
-        // Parse array section
-        var _parseArraySection2 = parseArraySection(lines, i + 1, indent),
-          items = _parseArraySection2.items,
-          nextIndex = _parseArraySection2.nextIndex;
+        // 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[trimmed] = items;
+          result[sectionName] = items;
         }
-        i = nextIndex;
+        i = arrNext;
         continue;
       } else if (OBJECT_SECTIONS.has(trimmed)) {
         // Parse object section (style)
-        var sectionName = trimmed;
-        result[sectionName] = {};
+        var _sectionName = trimmed;
+        var sectionObj = {};
+        result[_sectionName] = sectionObj;
+        var sectionIndent = indent;
         i++;
         while (i < lines.length) {
-          var _lines$i3 = lines[i],
-            innerTrimmed = _lines$i3.trimmed,
-            innerIndent = _lines$i3.indent;
+          var _lines$i4 = lines[i],
+            innerTrimmed = _lines$i4.trimmed,
+            innerIndent = _lines$i4.indent;
 
-          // If indent goes back to 0, we're done with this section
-          if (innerIndent === 0) {
+          // 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) {
-            result[sectionName][kv.key] = parseMultipleValues(kv.value);
+            // 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++;
         }
@@ -381,9 +539,9 @@ export function parse(syntax) {
 
     // Top-level key-value pair
     if (indent === 0) {
-      var _kv2 = parseKeyValue(trimmed);
-      if (_kv2) {
-        result[_kv2.key] = parseValue(_kv2.value);
+      var _kv4 = parseKeyValue(trimmed);
+      if (_kv4) {
+        result[_kv4.key] = parseValue(_kv4.value);
       }
     }
     i++;

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

@@ -19,3 +19,8 @@ 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[];

package/dist/esm/util/theme.js

@@ -138,4 +138,13 @@ export var getBackgroundColor = function getBackgroundColor(theme) {
     default:
       return '#FFF';
   }
+};
+
+/**
+ * Normalize palette to always return an array.
+ * Handles the case where a single color is parsed as a string instead of an array.
+ */
+export var normalizePalette = function normalizePalette(palette, theme) {
+  if (!palette || Array.isArray(palette) && palette.length === 0) return getThemeColors(theme);
+  return Array.isArray(palette) ? palette : [palette];
 };

package/dist/esm/vis/area/index.js

@@ -5,7 +5,7 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { Chart } from '@antv/g2';
-import { getBackgroundColor, getThemeColors, getThemeObject } from "../../util/theme";
+import { getBackgroundColor, getThemeObject, normalizePalette } from "../../util/theme";
 
 /**
  * AreaDataItem is the type for each data item in the area chart.
@@ -82,7 +82,7 @@ export var Area = function Area(options) {
     var _style$lineWidth = style.lineWidth,
       lineWidth = _style$lineWidth === void 0 ? 2 : _style$lineWidth;
     var hasGroupField = data.length > 0 && ((_data$ = data[0]) === null || _data$ === void 0 ? void 0 : _data$.group) !== undefined;
-    var colors = style.palette || getThemeColors(theme);
+    var colors = normalizePalette(style.palette, theme);
     var backgroundColor = style.backgroundColor || getBackgroundColor(theme);
     var fillColor = getLinearGradientColor(colors[0] || DEFAULT_COLOR);
 
@@ -177,6 +177,7 @@ export var Area = function Area(options) {
     // Note: Using 'any' type due to G2's complex type system with transformations
     // This is consistent with how G2 5.0 is used elsewhere in the codebase
     var chartOptions = {
+      animate: false,
       type: 'view',
       data: data,
       title: title !== null && title !== void 0 ? title : '',