@antv/infographic 0.2.15 → 0.2.17

package/src/syntax/index.ts

@@ -12,6 +12,16 @@ import {
 } from './schema';
 import type { ObjectSchema, SyntaxNode, SyntaxParseResult } from './types';
 
+const ALLOWED_ROOT_KEYS = new Set([
+  'infographic',
+  'template',
+  'design',
+  'data',
+  'theme',
+  'width',
+  'height',
+]);
+
 function normalizeItems(items: ItemDatum[]) {
   const seen = new Set<string>();
   const normalized: ItemDatum[] = [];
@@ -30,6 +40,14 @@ function normalizeItems(items: ItemDatum[]) {
   return normalized.reverse();
 }
 
+function assignMissingNodeIds(items: ItemDatum[]) {
+  items.forEach((item) => {
+    if (!item.id && item.label) {
+      item.id = item.label;
+    }
+  });
+}
+
 function resolveTemplate(
   node: SyntaxNode | undefined,
   errors: SyntaxParseResult['errors'],
@@ -44,12 +62,54 @@ function resolveTemplate(
   return undefined;
 }
 
+function inferTemplateFromBareFirstLine(
+  entries: Record<string, SyntaxNode>,
+  warnings: SyntaxParseResult['warnings'],
+) {
+  if ('infographic' in entries || 'template' in entries) {
+    return undefined;
+  }
+
+  const [firstEntry] = Object.entries(entries);
+  if (!firstEntry) return undefined;
+
+  const [key, node] = firstEntry;
+  if (ALLOWED_ROOT_KEYS.has(key) || node.kind !== 'object') {
+    return undefined;
+  }
+  if (node.value !== undefined || Object.keys(node.entries).length > 0) {
+    return undefined;
+  }
+
+  warnings.push({
+    path: 'template',
+    line: node.line,
+    code: 'implicit_template',
+    message:
+      'Inferred template from a bare first line. Prefix it with "infographic" or "template" to make the syntax explicit.',
+    raw: key,
+  });
+
+  return {
+    template: key,
+    inferredKey: key,
+  };
+}
+
 export function parseSyntax(input: string): SyntaxParseResult {
   const { ast, errors } = parseSyntaxToAst(input);
   const warnings: SyntaxParseResult['warnings'] = [];
   const options: Partial<InfographicOptions> = {};
 
   const mergedEntries = { ...ast.entries };
+  const inferredTemplate = inferTemplateFromBareFirstLine(
+    ast.entries,
+    warnings,
+  );
+  if (inferredTemplate) {
+    delete mergedEntries[inferredTemplate.inferredKey];
+  }
+
   const infographicNode = ast.entries.infographic;
   let templateFromInfographic: string | undefined;
   if (infographicNode && infographicNode.kind === 'object') {
@@ -59,17 +119,8 @@ export function parseSyntax(input: string): SyntaxParseResult {
     });
   }
 
-  const allowedRootKeys = new Set([
-    'infographic',
-    'template',
-    'design',
-    'data',
-    'theme',
-    'width',
-    'height',
-  ]);
   Object.keys(mergedEntries).forEach((key) => {
-    if (!allowedRootKeys.has(key)) {
+    if (!ALLOWED_ROOT_KEYS.has(key)) {
       errors.push({
         path: key,
         line: (mergedEntries[key] as SyntaxNode).line,
@@ -86,6 +137,9 @@ export function parseSyntax(input: string): SyntaxParseResult {
   if (!options.template && templateFromInfographic) {
     options.template = templateFromInfographic;
   }
+  if (!options.template && inferredTemplate) {
+    options.template = inferredTemplate.template;
+  }
 
   const designNode = mergedEntries.design as SyntaxNode | undefined;
   if (designNode) {
@@ -113,6 +167,13 @@ export function parseSyntax(input: string): SyntaxParseResult {
       if (parsed.relations.length > 0 || parsed.items.length > 0) {
         const current = (options.data ?? {}) as Record<string, any>;
 
+        if (Array.isArray(current.items)) {
+          assignMissingNodeIds(current.items as ItemDatum[]);
+        }
+        if (Array.isArray(current.nodes)) {
+          assignMissingNodeIds(current.nodes as ItemDatum[]);
+        }
+
         // 优先使用已存在的数据列表 (sequences, lists, etc.)
         const dataKeys = Object.keys(
           (DataSchema as ObjectSchema).fields,

package/src/syntax/mapper.ts

@@ -16,10 +16,18 @@ const HEX_COLOR_PATTERN =
   /^(#[0-9a-f]{8}|#[0-9a-f]{6}|#[0-9a-f]{4}|#[0-9a-f]{3})/i;
 const FUNCTION_COLOR_PATTERN = /^((?:rgb|rgba|hsl|hsla)\([^)]*\))/i;
 
+function normalizeBooleanLiteral(value: string) {
+  const trimmed = value.trim();
+  if (/^true$/i.test(trimmed)) return 'true';
+  if (/^false$/i.test(trimmed)) return 'false';
+  return undefined;
+}
+
 function parseScalar(value: string) {
   const trimmed = value.trim();
-  if (trimmed === 'true') return true;
-  if (trimmed === 'false') return false;
+  const normalizedBoolean = normalizeBooleanLiteral(trimmed);
+  if (normalizedBoolean === 'true') return true;
+  if (normalizedBoolean === 'false') return false;
   if (/^-?\d+(\.\d+)?$/.test(trimmed)) return parseFloat(trimmed);
   return trimmed;
 }
@@ -240,7 +248,8 @@ export function mapWithSchema(
         );
         return undefined;
       }
-      if (value !== 'true' && value !== 'false') {
+      const normalizedBoolean = normalizeBooleanLiteral(value);
+      if (!normalizedBoolean) {
         addError(
           errors,
           node,
@@ -251,7 +260,7 @@ export function mapWithSchema(
         );
         return undefined;
       }
-      return value === 'true';
+      return normalizedBoolean === 'true';
     }
     case 'enum': {
       const value = readScalar(node);
@@ -259,7 +268,12 @@ export function mapWithSchema(
         addError(errors, node, path, 'schema_mismatch', 'Expected enum value.');
         return undefined;
       }
-      if (!schema.values.includes(value)) {
+      const normalizedBoolean = normalizeBooleanLiteral(value);
+      const enumValue =
+        normalizedBoolean && schema.values.includes(normalizedBoolean)
+          ? normalizedBoolean
+          : value;
+      if (!schema.values.includes(enumValue)) {
         addError(
           errors,
           node,
@@ -270,7 +284,7 @@ export function mapWithSchema(
         );
         return undefined;
       }
-      return value;
+      return enumValue;
     }
     case 'array': {
       if (node.kind === 'array') {

package/src/syntax/parser.ts

@@ -40,6 +40,15 @@ function stripComments(content: string) {
   return content.trimEnd();
 }
 
+function isCommentLine(content: string) {
+  const trimmed = content.trimStart();
+  return trimmed.startsWith('#') || trimmed.startsWith('//');
+}
+
+function isCodeFenceLine(content: string) {
+  return /^```[\w-]*\s*$/.test(content.trim());
+}
+
 function looksLikeRelationExpression(text: string) {
   return /[<>=o.x-]{2,}/.test(text);
 }
@@ -58,6 +67,97 @@ function parseKeyValue(raw: string) {
   return { key: text, value: undefined };
 }
 
+interface AssignEntryResult {
+  parent: ObjectNode;
+  key: string;
+}
+
+function isUnsafeObjectKey(key: string) {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
+
+function assignObjectEntry(
+  parent: ObjectNode,
+  rawKey: string,
+  node: ObjectNode,
+  line: number,
+  errors: SyntaxError[],
+): AssignEntryResult | null {
+  if (!rawKey.includes('.')) {
+    if (isUnsafeObjectKey(rawKey)) {
+      errors.push({
+        path: rawKey,
+        line,
+        code: 'bad_syntax',
+        message: `Invalid key part: ${rawKey}`,
+        raw: rawKey,
+      });
+      return null;
+    }
+    parent.entries[rawKey] = node;
+    return { parent, key: rawKey };
+  }
+
+  const parts = rawKey.split('.');
+  if (parts.some((part) => !part)) {
+    errors.push({
+      path: rawKey,
+      line,
+      code: 'bad_syntax',
+      message: 'Invalid dotted key path.',
+      raw: rawKey,
+    });
+    return null;
+  }
+
+  let current = parent;
+  for (let index = 0; index < parts.length - 1; index += 1) {
+    const part = parts[index];
+    if (isUnsafeObjectKey(part)) {
+      errors.push({
+        path: rawKey,
+        line,
+        code: 'bad_syntax',
+        message: `Invalid key part in dotted path: ${part}`,
+        raw: rawKey,
+      });
+      return null;
+    }
+    const existing = current.entries[part];
+    if (!existing) {
+      const container = createObjectNode(line);
+      current.entries[part] = container;
+      current = container;
+      continue;
+    }
+    if (existing.kind !== 'object') {
+      errors.push({
+        path: parts.slice(0, index + 1).join('.'),
+        line,
+        code: 'bad_syntax',
+        message: 'Cannot assign dotted key under a list value.',
+        raw: rawKey,
+      });
+      return null;
+    }
+    current = existing;
+  }
+
+  const finalKey = parts[parts.length - 1];
+  if (isUnsafeObjectKey(finalKey)) {
+    errors.push({
+      path: rawKey,
+      line,
+      code: 'bad_syntax',
+      message: `Invalid key part in dotted path: ${finalKey}`,
+      raw: rawKey,
+    });
+    return null;
+  }
+  current.entries[finalKey] = node;
+  return { parent: current, key: finalKey };
+}
+
 function createObjectNode(line: number, value?: string): ObjectNode {
   return { kind: 'object', line, value, entries: {} };
 }
@@ -78,6 +178,7 @@ export function parseSyntaxToAst(input: string): ParseResult {
     const lineNumber = index + 1;
     if (!line.trim()) return;
     const { indent, content } = getIndentInfo(line);
+    if (isCommentLine(content) || isCodeFenceLine(content)) return;
     const stripped = stripComments(content);
     if (!stripped.trim()) return;
 
@@ -203,12 +304,19 @@ export function parseSyntaxToAst(input: string): ParseResult {
     }
 
     const node = createObjectNode(lineNumber, parsed.value);
-    parentNode.entries[parsed.key] = node;
+    const assigned = assignObjectEntry(
+      parentNode,
+      parsed.key,
+      node,
+      lineNumber,
+      errors,
+    );
+    if (!assigned) return;
     stack.push({
       indent,
       node,
-      parent: parentNode,
-      key: parsed.key,
+      parent: assigned.parent,
+      key: assigned.key,
     });
   });
 

package/src/syntax/types.ts

@@ -22,6 +22,7 @@ export interface ArrayNode {
 }
 
 export type SyntaxErrorCode =
+  | 'implicit_template'
   | 'unknown_key'
   | 'schema_mismatch'
   | 'invalid_value'

package/src/templates/built-in.ts

@@ -210,7 +210,7 @@ const BUILT_IN_TEMPLATES: Record<string, TemplateOptions> = {
   'sequence-timeline-plain-text': {
     design: {
       title: 'default',
-      structure: { type: 'sequence-timeline' },
+      structure: { type: 'sequence-timeline', showStepLabels: false },
       items: [{ type: 'plain-text' }],
     },
   },
@@ -231,7 +231,7 @@ const BUILT_IN_TEMPLATES: Record<string, TemplateOptions> = {
   'sequence-timeline-simple': {
     design: {
       title: 'default',
-      structure: { type: 'sequence-timeline', gap: 20 },
+      structure: { type: 'sequence-timeline', gap: 20, showStepLabels: false },
       items: [{ type: 'simple', positionV: 'middle' }],
     },
   },

package/src/templates/registry.ts

@@ -1,4 +1,5 @@
 import type { TemplateOptions } from './types';
+import { findClosestTemplateKey } from './utils';
 
 const TEMPLATE_REGISTRY = new Map<string, TemplateOptions>();
 
@@ -6,6 +7,11 @@ export function registerTemplate(type: string, template: TemplateOptions) {
   TEMPLATE_REGISTRY.set(type, template);
 }
 
+export function resolveTemplateKey(type: string): string | undefined {
+  if (TEMPLATE_REGISTRY.has(type)) return type;
+  return findClosestTemplateKey(type, TEMPLATE_REGISTRY.keys());
+}
+
 export function getTemplate(type: string): TemplateOptions | undefined {
   return TEMPLATE_REGISTRY.get(type);
 }

package/src/templates/utils.ts

@@ -0,0 +1,87 @@
+function normalizeTemplateKey(type: string): string {
+  return type
+    .trim()
+    .toLowerCase()
+    .replace(/[_\s]+/g, '-')
+    .replace(/-+/g, '-');
+}
+
+function getLevenshteinDistance(source: string, target: string): number {
+  if (source === target) return 0;
+  if (!source.length) return target.length;
+  if (!target.length) return source.length;
+
+  const previous = Array.from(
+    { length: target.length + 1 },
+    (_, index) => index,
+  );
+  const current = new Array<number>(target.length + 1);
+
+  for (let sourceIndex = 1; sourceIndex <= source.length; sourceIndex += 1) {
+    current[0] = sourceIndex;
+    const sourceCode = source.charCodeAt(sourceIndex - 1);
+
+    for (let targetIndex = 1; targetIndex <= target.length; targetIndex += 1) {
+      const replaceCost =
+        sourceCode === target.charCodeAt(targetIndex - 1) ? 0 : 1;
+      current[targetIndex] = Math.min(
+        previous[targetIndex] + 1,
+        current[targetIndex - 1] + 1,
+        previous[targetIndex - 1] + replaceCost,
+      );
+    }
+
+    for (let index = 0; index < current.length; index += 1) {
+      previous[index] = current[index];
+    }
+  }
+
+  return previous[target.length];
+}
+
+function getCommonPrefixLength(source: string, target: string): number {
+  const limit = Math.min(source.length, target.length);
+  let index = 0;
+
+  while (index < limit && source[index] === target[index]) {
+    index += 1;
+  }
+
+  return index;
+}
+
+export function findClosestTemplateKey(
+  type: string,
+  keys: Iterable<string>,
+): string | undefined {
+  const normalizedType = normalizeTemplateKey(type);
+  if (!normalizedType) return undefined;
+
+  let bestMatch: string | undefined;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let bestPrefixLength = -1;
+
+  for (const key of keys) {
+    const normalizedKey = normalizeTemplateKey(key);
+    if (normalizedKey === normalizedType) {
+      return key;
+    }
+
+    const distance = getLevenshteinDistance(normalizedType, normalizedKey);
+    const prefixLength = getCommonPrefixLength(normalizedType, normalizedKey);
+
+    if (
+      distance < bestDistance ||
+      (distance === bestDistance && prefixLength > bestPrefixLength) ||
+      (distance === bestDistance &&
+        prefixLength === bestPrefixLength &&
+        (!bestMatch || key < bestMatch))
+    ) {
+      bestMatch = key;
+      bestDistance = distance;
+      bestPrefixLength = prefixLength;
+    }
+  }
+
+  return bestMatch;
+}

package/src/themes/built-in.ts

@@ -1,5 +1,9 @@
 import { registerTheme } from './registry';
 
+registerTheme('light', {
+  colorBg: '#ffffff',
+});
+
 registerTheme('dark', {
   colorBg: '#1F1F1F',
   base: {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.2.15';
+export const VERSION = '0.2.17';