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

package/dist/cjs/index.d.ts

@@ -1,13 +1,44 @@
-/********** export chart **********/
-export * from './export';
-/********** export types **********/
-export * from './types';
-/********** export render **********/
-export * from './render';
-/********** export GPTVis **********/
-export { withChartCode, withDefaultChartCode } from './ChartCodeRender';
-export type { CodeBlockComponent, ErrorRender, WithChartCodeOptions } from './ChartCodeRender/type';
-export { default as ConfigProvider, type ConfigProviderProps } from './ConfigProvider';
-export { default as GPTVis, type GPTVisProps } from './GPTVis';
-export { default as GPTVisLite, useEventPublish, type GPTVisLiteProps } from './GPTVis/Lite';
-export { default as version } from './version';
+export { GPTVis } from './gpt-vis';
+export type { GPTVisConfig } from './gpt-vis';
+export { isVisSyntax } from './syntax';
+export type { VisualizationOptions } from './types';
+export { Area } from './vis/area';
+export type { AreaConfig, AreaDataItem } from './vis/area';
+export { Bar } from './vis/bar';
+export type { BarConfig, BarDataItem } from './vis/bar';
+export { Boxplot } from './vis/boxplot';
+export type { BoxplotConfig, BoxplotDataItem } from './vis/boxplot';
+export { Column } from './vis/column';
+export type { ColumnConfig, ColumnDataItem } from './vis/column';
+export { DualAxes } from './vis/dual-axes';
+export type { DualAxesConfig, DualAxesSeriesItem } from './vis/dual-axes';
+export { Funnel } from './vis/funnel';
+export type { FunnelConfig, FunnelDataItem } from './vis/funnel';
+export { Histogram } from './vis/histogram';
+export type { HistogramConfig } from './vis/histogram';
+export { Line } from './vis/line';
+export type { LineConfig, LineDataItem } from './vis/line';
+export { Liquid } from './vis/liquid';
+export type { LiquidConfig } from './vis/liquid';
+export { Pie } from './vis/pie';
+export type { PieConfig } from './vis/pie';
+export { Radar } from './vis/radar';
+export type { RadarConfig, RadarDataItem } from './vis/radar';
+export { Sankey } from './vis/sankey';
+export type { SankeyConfig, SankeyDataItem } from './vis/sankey';
+export { Scatter } from './vis/scatter';
+export type { ScatterConfig, ScatterDataItem } from './vis/scatter';
+export { Summary } from './vis/summary';
+export type { SummaryConfig } from './vis/summary';
+export { Table } from './vis/table';
+export type { TableConfig } from './vis/table';
+export { Treemap } from './vis/treemap';
+export type { TreemapConfig, TreemapDataItem } from './vis/treemap';
+export { Venn } from './vis/venn';
+export type { VennConfig, VennDataItem } from './vis/venn';
+export { Violin } from './vis/violin';
+export type { ViolinConfig, ViolinDataItem } from './vis/violin';
+export { Waterfall } from './vis/waterfall';
+export type { WaterfallConfig, WaterfallDataItem, WaterfallPalette } from './vis/waterfall';
+export { WordCloud } from './vis/word-cloud';
+export type { WordCloudConfig, WordCloudDataItem } from './vis/word-cloud';

package/dist/cjs/index.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,47 +14,79 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ConfigProvider: () => import_ConfigProvider.default,
-  GPTVis: () => import_GPTVis.default,
-  GPTVisLite: () => import_Lite.default,
-  useEventPublish: () => import_Lite.useEventPublish,
-  version: () => import_version.default,
-  withChartCode: () => import_ChartCodeRender.withChartCode,
-  withDefaultChartCode: () => import_ChartCodeRender.withDefaultChartCode
+  Area: () => import_area.Area,
+  Bar: () => import_bar.Bar,
+  Boxplot: () => import_boxplot.Boxplot,
+  Column: () => import_column.Column,
+  DualAxes: () => import_dual_axes.DualAxes,
+  Funnel: () => import_funnel.Funnel,
+  GPTVis: () => import_gpt_vis.GPTVis,
+  Histogram: () => import_histogram.Histogram,
+  Line: () => import_line.Line,
+  Liquid: () => import_liquid.Liquid,
+  Pie: () => import_pie.Pie,
+  Radar: () => import_radar.Radar,
+  Sankey: () => import_sankey.Sankey,
+  Scatter: () => import_scatter.Scatter,
+  Summary: () => import_summary.Summary,
+  Table: () => import_table.Table,
+  Treemap: () => import_treemap.Treemap,
+  Venn: () => import_venn.Venn,
+  Violin: () => import_violin.Violin,
+  Waterfall: () => import_waterfall.Waterfall,
+  WordCloud: () => import_word_cloud.WordCloud,
+  isVisSyntax: () => import_syntax.isVisSyntax
 });
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./export"), module.exports);
-__reExport(src_exports, require("./types"), module.exports);
-__reExport(src_exports, require("./render"), module.exports);
-var import_ChartCodeRender = require("./ChartCodeRender");
-var import_ConfigProvider = __toESM(require("./ConfigProvider"));
-var import_GPTVis = __toESM(require("./GPTVis"));
-var import_Lite = __toESM(require("./GPTVis/Lite"));
-var import_version = __toESM(require("./version"));
+var import_gpt_vis = require("./gpt-vis");
+var import_syntax = require("./syntax");
+var import_area = require("./vis/area");
+var import_bar = require("./vis/bar");
+var import_boxplot = require("./vis/boxplot");
+var import_column = require("./vis/column");
+var import_dual_axes = require("./vis/dual-axes");
+var import_funnel = require("./vis/funnel");
+var import_histogram = require("./vis/histogram");
+var import_line = require("./vis/line");
+var import_liquid = require("./vis/liquid");
+var import_pie = require("./vis/pie");
+var import_radar = require("./vis/radar");
+var import_sankey = require("./vis/sankey");
+var import_scatter = require("./vis/scatter");
+var import_summary = require("./vis/summary");
+var import_table = require("./vis/table");
+var import_treemap = require("./vis/treemap");
+var import_venn = require("./vis/venn");
+var import_violin = require("./vis/violin");
+var import_waterfall = require("./vis/waterfall");
+var import_word_cloud = require("./vis/word-cloud");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ConfigProvider,
+  Area,
+  Bar,
+  Boxplot,
+  Column,
+  DualAxes,
+  Funnel,
   GPTVis,
-  GPTVisLite,
-  useEventPublish,
-  version,
-  withChartCode,
-  withDefaultChartCode,
-  ...require("./export"),
-  ...require("./types"),
-  ...require("./render")
+  Histogram,
+  Line,
+  Liquid,
+  Pie,
+  Radar,
+  Sankey,
+  Scatter,
+  Summary,
+  Table,
+  Treemap,
+  Venn,
+  Violin,
+  Waterfall,
+  WordCloud,
+  isVisSyntax
 });

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

@@ -0,0 +1,2 @@
+export { isVisSyntax, parse } from './parser';
+export type { ParsedConfig } from './parser';

package/dist/cjs/{Text/mini-charts/hooks → syntax}/index.js

@@ -16,14 +16,16 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/Text/mini-charts/hooks/index.ts
-var hooks_exports = {};
-__export(hooks_exports, {
-  useSvgWrapper: () => import_useSvgWrapper.useSvgWrapper
+// src/syntax/index.ts
+var syntax_exports = {};
+__export(syntax_exports, {
+  isVisSyntax: () => import_parser.isVisSyntax,
+  parse: () => import_parser.parse
 });
-module.exports = __toCommonJS(hooks_exports);
-var import_useSvgWrapper = require("./useSvgWrapper");
+module.exports = __toCommonJS(syntax_exports);
+var import_parser = require("./parser");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  useSvgWrapper
+  isVisSyntax,
+  parse
 });

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

@@ -0,0 +1,67 @@
+/**
+ * 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)
+ * - `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`)
+ * - `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 Hierarchical data (mind-map)
+ * ```
+ * vis mind-map
+ * data
+ *   - name 项目计划
+ *     children
+ *       - name 研究阶段
+ *         children
+ *           - name 市场调研
+ *           - name 技术可行性分析
+ *       - name 开发阶段
+ * ```
+ */
+/**
+ * Parsed chart configuration result
+ */
+export interface ParsedConfig {
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * Parse the visualization syntax string into a configuration object
+ */
+export declare function parse(syntax: string): ParsedConfig;
+/**
+ * Check if a val is a valid visualization syntax
+ */
+export declare function isVisSyntax(input: any): boolean;

package/dist/cjs/syntax/parser.js

@@ -0,0 +1,235 @@
+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/syntax/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  isVisSyntax: () => isVisSyntax,
+  parse: () => parse
+});
+module.exports = __toCommonJS(parser_exports);
+var ARRAY_SECTIONS = /* @__PURE__ */ new Set(["data", "categories", "series", "children"]);
+var OBJECT_SECTIONS = /* @__PURE__ */ new Set(["style"]);
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return "";
+  }
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") {
+    return num;
+  }
+  return trimmed;
+}
+function parseMultipleValues(values) {
+  const trimmed = values.trim();
+  const parts = trimmed.split(/\s+/).filter((p) => p.length > 0);
+  if (parts.length === 0) {
+    return "";
+  }
+  if (parts.length === 1) {
+    return parseValue(parts[0]);
+  }
+  return parts.map(parseValue);
+}
+function parseKeyValue(line) {
+  const trimmed = line.trim();
+  const colonMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/);
+  if (colonMatch) {
+    return { key: colonMatch[1], value: colonMatch[2] };
+  }
+  const spaceMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s+(.+)$/);
+  if (spaceMatch) {
+    return { key: spaceMatch[1], value: spaceMatch[2] };
+  }
+  const singleKey = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)$/);
+  if (singleKey) {
+    return { key: singleKey[1], value: "" };
+  }
+  return null;
+}
+function isSimpleValue(line) {
+  const trimmed = line.trim();
+  const hasKeyValue = parseKeyValue(trimmed);
+  if (hasKeyValue && hasKeyValue.value !== "") {
+    return false;
+  }
+  return true;
+}
+function getIndentLevel(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+function isArrayItemLine(line) {
+  return line.trim().startsWith("-");
+}
+function parseArrayItemLine(line) {
+  return line.trim().replace(/^-\s*/, "");
+}
+function isKnownSection(key) {
+  return ARRAY_SECTIONS.has(key) || OBJECT_SECTIONS.has(key);
+}
+function parseLines(syntax) {
+  const lines = syntax.split("\n");
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    result.push({
+      line,
+      trimmed,
+      indent: getIndentLevel(line),
+      lineNumber: i
+    });
+  }
+  return result;
+}
+function parseArraySection(lines, startIndex, baseIndent) {
+  const items = [];
+  let currentItem = null;
+  let isSimpleArray = false;
+  let i = startIndex;
+  let firstItemIndent = -1;
+  while (i < lines.length) {
+    const { trimmed, indent } = lines[i];
+    if (indent <= baseIndent && !isArrayItemLine(trimmed)) {
+      break;
+    }
+    if (isArrayItemLine(trimmed) && indent <= baseIndent) {
+      break;
+    }
+    const isThisLevelItem = isArrayItemLine(trimmed) && (firstItemIndent === -1 || indent === firstItemIndent);
+    if (isThisLevelItem) {
+      if (firstItemIndent === -1) {
+        firstItemIndent = indent;
+      }
+      if (currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+      }
+      const itemContent = parseArrayItemLine(trimmed);
+      if (itemContent) {
+        if (isSimpleValue(itemContent)) {
+          isSimpleArray = true;
+          items.push(parseValue(itemContent));
+          currentItem = null;
+        } else {
+          currentItem = {};
+          const kv = parseKeyValue(itemContent);
+          if (kv) {
+            currentItem[kv.key] = parseValue(kv.value);
+          }
+        }
+      } else {
+        currentItem = {};
+      }
+      i++;
+      continue;
+    }
+    if (isArrayItemLine(trimmed) && firstItemIndent !== -1 && indent !== firstItemIndent) {
+      i++;
+      continue;
+    }
+    if (currentItem !== null && !isSimpleArray) {
+      const kv = parseKeyValue(trimmed);
+      if (kv) {
+        if (kv.key === "children" && kv.value === "") {
+          const { items: childItems, nextIndex } = parseArraySection(lines, i + 1, indent);
+          currentItem.children = childItems;
+          i = nextIndex;
+          continue;
+        } else {
+          currentItem[kv.key] = parseValue(kv.value);
+        }
+      }
+    }
+    i++;
+  }
+  if (currentItem !== null && !isSimpleArray) {
+    items.push(currentItem);
+  }
+  return { items, nextIndex: i };
+}
+function parse(syntax) {
+  const lines = parseLines(syntax);
+  const result = { type: "" };
+  let i = 0;
+  while (i < lines.length) {
+    const { trimmed, indent } = lines[i];
+    if (trimmed.startsWith("vis ")) {
+      const chartType = trimmed.substring(4).trim();
+      result.type = chartType;
+      i++;
+      continue;
+    }
+    const isSectionHeader = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed) && indent === 0 && isKnownSection(trimmed);
+    if (isSectionHeader) {
+      if (ARRAY_SECTIONS.has(trimmed)) {
+        const { items, nextIndex } = parseArraySection(lines, i + 1, indent);
+        if (items.length > 0) {
+          result[trimmed] = items;
+        }
+        i = nextIndex;
+        continue;
+      } else if (OBJECT_SECTIONS.has(trimmed)) {
+        const sectionName = trimmed;
+        result[sectionName] = {};
+        i++;
+        while (i < lines.length) {
+          const { trimmed: innerTrimmed, indent: innerIndent } = lines[i];
+          if (innerIndent === 0) {
+            break;
+          }
+          const kv = parseKeyValue(innerTrimmed);
+          if (kv) {
+            result[sectionName][kv.key] = parseMultipleValues(
+              kv.value
+            );
+          }
+          i++;
+        }
+        continue;
+      }
+    }
+    if (indent === 0) {
+      const kv = parseKeyValue(trimmed);
+      if (kv) {
+        result[kv.key] = parseValue(kv.value);
+      }
+    }
+    i++;
+  }
+  return result;
+}
+function isVisSyntax(input) {
+  if (typeof input !== "string")
+    return false;
+  const trimmed = input.trim();
+  return trimmed.startsWith("vis ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isVisSyntax,
+  parse
+});

package/dist/cjs/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/cjs/types/index.js

@@ -10,14 +10,8 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/types/index.ts
 var types_exports = {};
 module.exports = __toCommonJS(types_exports);
-__reExport(types_exports, require("./chart"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./chart")
-});

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

@@ -0,0 +1,21 @@
+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;

package/dist/cjs/{theme.js → util/theme.js}

@@ -16,14 +16,42 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/theme.ts
+// src/util/theme.ts
 var theme_exports = {};
 __export(theme_exports, {
-  G6THEME_MAP: () => G6THEME_MAP,
-  THEME_MAP: () => THEME_MAP
+  ACADEMY_COLOR_PALETTE: () => ACADEMY_COLOR_PALETTE,
+  DEFAULT_COLOR_PALETTE: () => DEFAULT_COLOR_PALETTE,
+  THEME_MAP: () => THEME_MAP,
+  getBackgroundColor: () => getBackgroundColor,
+  getTheme: () => getTheme,
+  getThemeColors: () => getThemeColors,
+  getThemeObject: () => getThemeObject
 });
 module.exports = __toCommonJS(theme_exports);
-var import_palette = require("./utils/palette");
+var DEFAULT_COLOR_PALETTE = [
+  "#1783FF",
+  "#F08F56",
+  "#D580FF",
+  "#00C9C9",
+  "#7863FF",
+  "#DB9D0D",
+  "#60C42D",
+  "#FF80CA",
+  "#2491B3",
+  "#17C76F"
+];
+var ACADEMY_COLOR_PALETTE = [
+  "#4e79a7",
+  "#f28e2c",
+  "#e15759",
+  "#76b7b2",
+  "#59a14f",
+  "#edc949",
+  "#af7aa1",
+  "#ff9da7",
+  "#9c755f",
+  "#bab0ab"
+];
 var DEFAULT_THEME = {
   type: "light",
   view: {
@@ -116,18 +144,39 @@ var THEME_MAP = {
   academy: ACADEMY_THEME,
   dark: DARK_THEME
 };
-var G6THEME_MAP = {
-  default: {
-    type: "assign-color-by-branch",
-    colors: import_palette.DEFAULT_COLOR_PALETTE
-  },
-  academy: {
-    type: "assign-color-by-branch",
-    colors: import_palette.ACADEMY_COLOR_PALETTE
+var getTheme = (theme) => {
+  return theme === "default" ? "light" : theme;
+};
+var getThemeObject = (theme) => {
+  return THEME_MAP[theme] || THEME_MAP.default;
+};
+var getThemeColors = (theme) => {
+  switch (theme) {
+    case "academy":
+      return ACADEMY_COLOR_PALETTE;
+    case "dark":
+    case "default":
+    default:
+      return DEFAULT_COLOR_PALETTE;
+  }
+};
+var getBackgroundColor = (theme) => {
+  switch (theme) {
+    case "dark":
+      return "#000";
+    case "academy":
+    case "default":
+    default:
+      return "#FFF";
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  G6THEME_MAP,
-  THEME_MAP
+  ACADEMY_COLOR_PALETTE,
+  DEFAULT_COLOR_PALETTE,
+  THEME_MAP,
+  getBackgroundColor,
+  getTheme,
+  getThemeColors,
+  getThemeObject
 });