@antv/infographic 0.1.2 → 0.1.4

package/src/syntax/mapper.ts

@@ -0,0 +1,362 @@
+import { parseInlineKeyValue } from './parser';
+import type {
+  SchemaNode,
+  SyntaxError,
+  SyntaxNode,
+  UnionSchema,
+  ValueNode,
+} from './types';
+
+function createValueNode(value: string, line: number): ValueNode {
+  return { kind: 'value', line, value };
+}
+
+function parseScalar(value: string) {
+  const trimmed = value.trim();
+  if (trimmed === 'true') return true;
+  if (trimmed === 'false') return false;
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return parseFloat(trimmed);
+  return trimmed;
+}
+
+function readScalar(node: SyntaxNode): string | undefined {
+  if (node.kind === 'value') return node.value;
+  if (node.kind === 'object') return node.value;
+  return undefined;
+}
+
+function addError(
+  errors: SyntaxError[],
+  node: SyntaxNode,
+  path: string,
+  code: SyntaxError['code'],
+  message: string,
+  raw?: string,
+) {
+  errors.push({
+    path,
+    line: node.line,
+    code,
+    message,
+    raw,
+  });
+}
+
+function splitArrayValue(
+  value: string,
+  split: 'space' | 'comma' | 'any' = 'any',
+) {
+  let text = value.trim();
+  if (text.startsWith('[') && text.endsWith(']')) {
+    text = text.slice(1, -1).trim();
+  }
+  if (!text) return [];
+  let parts: string[];
+  if (split === 'comma') {
+    parts = text.split(',');
+  } else if (split === 'space') {
+    parts = text.split(/\s+/);
+  } else {
+    parts = text.split(/[,\s]+/);
+  }
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+
+function mapUnknown(node: SyntaxNode): any {
+  if (node.kind === 'array') {
+    return node.items.map((item) => mapUnknown(item));
+  }
+  if (node.kind === 'value') return parseScalar(node.value);
+  const hasEntries = Object.keys(node.entries).length > 0;
+  if (!hasEntries && node.value !== undefined) {
+    return parseScalar(node.value);
+  }
+  const result: Record<string, any> = {};
+  if (node.value !== undefined) {
+    result.value = parseScalar(node.value);
+  }
+  Object.entries(node.entries).forEach(([key, child]) => {
+    result[key] = mapUnknown(child);
+  });
+  return result;
+}
+
+function mapUnion(
+  node: SyntaxNode,
+  schema: UnionSchema,
+  path: string,
+  errors: SyntaxError[],
+) {
+  let bestValue: any = undefined;
+  let bestErrors: SyntaxError[] | null = null;
+  for (const variant of schema.variants) {
+    const variantErrors: SyntaxError[] = [];
+    const value = mapWithSchema(node, variant, path, variantErrors);
+    if (bestErrors === null || variantErrors.length < bestErrors.length) {
+      bestErrors = variantErrors;
+      bestValue = value;
+    }
+  }
+  if (bestErrors) errors.push(...bestErrors);
+  return bestValue;
+}
+
+export function mapWithSchema(
+  node: SyntaxNode,
+  schema: SchemaNode,
+  path: string,
+  errors: SyntaxError[],
+): any {
+  switch (schema.kind) {
+    case 'union':
+      return mapUnion(node, schema, path, errors);
+    case 'string': {
+      const value = readScalar(node);
+      if (value === undefined) {
+        addError(
+          errors,
+          node,
+          path,
+          'schema_mismatch',
+          'Expected string value.',
+        );
+        return undefined;
+      }
+      return value;
+    }
+    case 'number': {
+      const value = readScalar(node);
+      if (value === undefined) {
+        addError(
+          errors,
+          node,
+          path,
+          'schema_mismatch',
+          'Expected number value.',
+        );
+        return undefined;
+      }
+      const trimmed = value.trim();
+      const match = trimmed.match(/^(-?\d+(\.\d+)?)(?:\s*(#|\/\/).*)?$/);
+      if (!match) {
+        addError(
+          errors,
+          node,
+          path,
+          'invalid_value',
+          'Invalid number value.',
+          value,
+        );
+        return undefined;
+      }
+      return parseFloat(match[1]);
+    }
+    case 'boolean': {
+      const value = readScalar(node);
+      if (value === undefined) {
+        addError(
+          errors,
+          node,
+          path,
+          'schema_mismatch',
+          'Expected boolean value.',
+        );
+        return undefined;
+      }
+      if (value !== 'true' && value !== 'false') {
+        addError(
+          errors,
+          node,
+          path,
+          'invalid_value',
+          'Invalid boolean value.',
+          value,
+        );
+        return undefined;
+      }
+      return value === 'true';
+    }
+    case 'enum': {
+      const value = readScalar(node);
+      if (value === undefined) {
+        addError(errors, node, path, 'schema_mismatch', 'Expected enum value.');
+        return undefined;
+      }
+      if (!schema.values.includes(value)) {
+        addError(
+          errors,
+          node,
+          path,
+          'invalid_value',
+          'Invalid enum value.',
+          value,
+        );
+        return undefined;
+      }
+      return value;
+    }
+    case 'array': {
+      if (node.kind === 'array') {
+        return node.items
+          .map((item, index) =>
+            mapWithSchema(item, schema.item, `${path}[${index}]`, errors),
+          )
+          .filter((value) => value !== undefined);
+      }
+      if (node.kind === 'object' && Object.keys(node.entries).length > 0) {
+        addError(
+          errors,
+          node,
+          path,
+          'schema_mismatch',
+          'Expected array value.',
+        );
+        return undefined;
+      }
+      const scalar = readScalar(node);
+      if (scalar === undefined) {
+        addError(
+          errors,
+          node,
+          path,
+          'schema_mismatch',
+          'Expected array value.',
+        );
+        return undefined;
+      }
+      const trimmed = scalar.trim();
+      if (trimmed.startsWith('[') && !trimmed.endsWith(']')) {
+        return undefined;
+      }
+      const parts = splitArrayValue(scalar, schema.split);
+      return parts
+        .map((part, index) =>
+          mapWithSchema(
+            createValueNode(part, node.line),
+            schema.item,
+            `${path}[${index}]`,
+            errors,
+          ),
+        )
+        .filter((value) => value !== undefined);
+    }
+    case 'object': {
+      if (node.kind === 'array') {
+        addError(
+          errors,
+          node,
+          path,
+          'schema_mismatch',
+          'Expected object value.',
+        );
+        return undefined;
+      }
+      const result: Record<string, any> = {};
+      if (node.kind === 'value') {
+        if (schema.shorthandKey) {
+          result[schema.shorthandKey] = node.value;
+          return result;
+        }
+        const inline = parseInlineKeyValue(node.value);
+        if (inline?.value !== undefined) {
+          if (schema.fields[inline.key]) {
+            const value = mapWithSchema(
+              createValueNode(inline.value, node.line),
+              schema.fields[inline.key],
+              `${path}.${inline.key}`,
+              errors,
+            );
+            if (value !== undefined) result[inline.key] = value;
+            return result;
+          }
+          if (schema.allowUnknown) {
+            result[inline.key] = parseScalar(inline.value);
+            return result;
+          }
+          addError(
+            errors,
+            node,
+            `${path}.${inline.key}`,
+            'unknown_key',
+            'Unknown key in object.',
+            inline.key,
+          );
+          return result;
+        }
+        if (schema.allowUnknown) {
+          result.value = parseScalar(node.value);
+          return result;
+        }
+        addError(errors, node, path, 'invalid_value', 'Expected object value.');
+        return undefined;
+      }
+
+      if (node.value !== undefined) {
+        if (schema.shorthandKey && result[schema.shorthandKey] === undefined) {
+          result[schema.shorthandKey] = node.value;
+        } else {
+          const inline = parseInlineKeyValue(node.value);
+          if (inline?.value !== undefined) {
+            if (schema.fields[inline.key]) {
+              const value = mapWithSchema(
+                createValueNode(inline.value, node.line),
+                schema.fields[inline.key],
+                `${path}.${inline.key}`,
+                errors,
+              );
+              if (value !== undefined && result[inline.key] === undefined) {
+                result[inline.key] = value;
+              }
+            } else if (schema.allowUnknown) {
+              result[inline.key] = parseScalar(inline.value);
+            } else {
+              addError(
+                errors,
+                node,
+                `${path}.${inline.key}`,
+                'unknown_key',
+                'Unknown key in object.',
+                inline.key,
+              );
+            }
+          } else if (schema.allowUnknown) {
+            result.value = parseScalar(node.value);
+          }
+        }
+      }
+
+      Object.entries(node.entries).forEach(([key, child]) => {
+        const fieldSchema = schema.fields[key];
+        if (!fieldSchema) {
+          if (schema.allowUnknown) {
+            result[key] = mapUnknown(child);
+            return;
+          }
+          addError(
+            errors,
+            child,
+            `${path}.${key}`,
+            'unknown_key',
+            'Unknown key in object.',
+            key,
+          );
+          return;
+        }
+        const value = mapWithSchema(
+          child,
+          fieldSchema,
+          `${path}.${key}`,
+          errors,
+        );
+        if (value !== undefined) result[key] = value;
+      });
+      return result;
+    }
+    default:
+      return undefined;
+  }
+}
+
+export function mapUnknownToObject(node: SyntaxNode) {
+  return mapUnknown(node);
+}

package/src/syntax/parser.ts

@@ -0,0 +1,171 @@
+import type { ArrayNode, ObjectNode, SyntaxError } from './types';
+
+interface StackFrame {
+  indent: number;
+  node: ObjectNode | ArrayNode;
+  parent?: ObjectNode | ArrayNode | null;
+  key?: string | null;
+}
+
+interface ParseResult {
+  ast: ObjectNode;
+  errors: SyntaxError[];
+}
+
+function isWhitespace(char: string) {
+  return char === ' ' || char === '\t';
+}
+
+function getIndentInfo(line: string) {
+  let indent = 0;
+  let index = 0;
+  while (index < line.length) {
+    const char = line[index];
+    if (char === ' ') {
+      indent += 1;
+      index += 1;
+      continue;
+    }
+    if (char === '\t') {
+      indent += 2;
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return { indent, content: line.slice(index) };
+}
+
+function stripComments(content: string) {
+  return content.trimEnd();
+}
+
+function parseKeyValue(raw: string) {
+  const text = raw.trim();
+  if (!text) return null;
+  const match = text.match(/^([^:\s=]+)\s*[:=]\s*(.*)$/);
+  if (match) {
+    return { key: match[1], value: match[2].trim() };
+  }
+  const matchSpace = text.match(/^([^\s]+)\s+(.*)$/);
+  if (matchSpace) {
+    return { key: matchSpace[1], value: matchSpace[2].trim() };
+  }
+  return { key: text, value: undefined };
+}
+
+function createObjectNode(line: number, value?: string): ObjectNode {
+  return { kind: 'object', line, value, entries: {} };
+}
+
+function createArrayNode(line: number): ArrayNode {
+  return { kind: 'array', line, items: [] };
+}
+
+export function parseSyntaxToAst(input: string): ParseResult {
+  const errors: SyntaxError[] = [];
+  const root: ObjectNode = createObjectNode(0);
+  const stack: StackFrame[] = [
+    { indent: -1, node: root, parent: null, key: null },
+  ];
+
+  const lines = input.split(/\r?\n/);
+  lines.forEach((line, index) => {
+    const lineNumber = index + 1;
+    if (!line.trim()) return;
+    const { indent, content } = getIndentInfo(line);
+    const stripped = stripComments(content);
+    if (!stripped.trim()) return;
+
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+
+    const parentFrame = stack[stack.length - 1];
+    let parentNode = parentFrame.node;
+
+    const trimmed = stripped.trim();
+    if (
+      trimmed.startsWith('-') &&
+      (trimmed.length === 1 || isWhitespace(trimmed[1]))
+    ) {
+      if (parentNode.kind !== 'array') {
+        if (
+          parentNode.kind === 'object' &&
+          Object.keys(parentNode.entries).length === 0 &&
+          parentNode.value === undefined &&
+          parentFrame.parent &&
+          parentFrame.key
+        ) {
+          const arrayNode = createArrayNode(parentNode.line);
+          if (parentFrame.parent.kind === 'object') {
+            parentFrame.parent.entries[parentFrame.key] = arrayNode;
+          } else if (parentFrame.parent.kind === 'array') {
+            const indexInParent = parentFrame.parent.items.indexOf(parentNode);
+            if (indexInParent >= 0)
+              parentFrame.parent.items[indexInParent] = arrayNode;
+          }
+          parentFrame.node = arrayNode;
+          parentNode = arrayNode;
+        } else {
+          errors.push({
+            path: '',
+            line: lineNumber,
+            code: 'bad_list',
+            message: 'List item is not under an array container.',
+            raw: trimmed,
+          });
+          return;
+        }
+      }
+
+      const itemContent = trimmed.slice(1).trim();
+      const itemNode = createObjectNode(lineNumber, itemContent || undefined);
+      parentNode.items.push(itemNode);
+      stack.push({
+        indent,
+        node: itemNode,
+        parent: parentNode,
+      });
+      return;
+    }
+
+    const parsed = parseKeyValue(trimmed);
+    if (!parsed) {
+      errors.push({
+        path: '',
+        line: lineNumber,
+        code: 'bad_syntax',
+        message: 'Invalid syntax line.',
+        raw: trimmed,
+      });
+      return;
+    }
+
+    if (parentNode.kind !== 'object') {
+      errors.push({
+        path: '',
+        line: lineNumber,
+        code: 'bad_syntax',
+        message: 'Key-value pair is not under an object container.',
+        raw: trimmed,
+      });
+      return;
+    }
+
+    const node = createObjectNode(lineNumber, parsed.value);
+    parentNode.entries[parsed.key] = node;
+    stack.push({
+      indent,
+      node,
+      parent: parentNode,
+      key: parsed.key,
+    });
+  });
+
+  return { ast: root, errors };
+}
+
+export function parseInlineKeyValue(value: string) {
+  return parseKeyValue(value);
+}

package/src/syntax/schema.ts

@@ -0,0 +1,98 @@
+import type { ObjectSchema, SchemaNode } from './types';
+
+const string = (): SchemaNode => ({ kind: 'string' });
+const number = (): SchemaNode => ({ kind: 'number' });
+// const boolean = (): SchemaNode => ({ kind: 'boolean' });
+const enumOf = (values: string[]): SchemaNode => ({ kind: 'enum', values });
+const array = (item: SchemaNode, split: 'space' | 'comma' | 'any' = 'any') => ({
+  kind: 'array' as const,
+  item,
+  split,
+});
+const object = (
+  fields: Record<string, SchemaNode>,
+  options: { allowUnknown?: boolean; shorthandKey?: string } = {},
+): ObjectSchema => ({
+  kind: 'object',
+  fields,
+  allowUnknown: options.allowUnknown,
+  shorthandKey: options.shorthandKey,
+});
+const union = (...variants: SchemaNode[]): SchemaNode => ({
+  kind: 'union',
+  variants,
+});
+
+const itemDatumSchema: ObjectSchema = object({});
+itemDatumSchema.fields = {
+  label: string(),
+  value: union(number(), string()),
+  desc: string(),
+  icon: string(),
+  children: array(itemDatumSchema),
+};
+
+export const ThemeSchema = object(
+  {
+    type: string(),
+    colorBg: string(),
+    colorPrimary: string(),
+    palette: array(string(), 'any'),
+    title: object({}, { allowUnknown: true }),
+    desc: object({}, { allowUnknown: true }),
+    base: object({
+      global: object({}, { allowUnknown: true }),
+      shape: object({}, { allowUnknown: true }),
+      text: object({}, { allowUnknown: true }),
+    }),
+    stylize: object(
+      {
+        type: enumOf(['rough', 'pattern']),
+        roughness: number(),
+        bowing: number(),
+        fillWeight: number(),
+        hachureGap: number(),
+        pattern: string(),
+        backgroundColor: string(),
+        foregroundColor: string(),
+        scale: number(),
+      },
+      { shorthandKey: 'type' },
+    ),
+  },
+  { shorthandKey: 'type' },
+);
+
+const designNodeSchema = object(
+  {},
+  { allowUnknown: true, shorthandKey: 'type' },
+);
+
+export const DesignSchema = object({
+  structure: designNodeSchema,
+  item: designNodeSchema,
+  items: array(designNodeSchema),
+  title: designNodeSchema,
+});
+
+export const DataSchema = object({
+  title: string(),
+  desc: string(),
+  items: array(itemDatumSchema),
+});
+
+export const TemplateSchema = object(
+  {
+    type: string(),
+  },
+  { shorthandKey: 'type' },
+);
+
+export const RootSchema = object({
+  template: TemplateSchema,
+  design: DesignSchema,
+  data: DataSchema,
+  theme: ThemeSchema,
+  width: union(number(), string()),
+  height: union(number(), string()),
+});

package/src/syntax/types.ts

@@ -0,0 +1,89 @@
+import type { InfographicOptions } from '../options';
+
+export type SyntaxNode = ValueNode | ObjectNode | ArrayNode;
+
+export interface ValueNode {
+  kind: 'value';
+  line: number;
+  value: string;
+}
+
+export interface ObjectNode {
+  kind: 'object';
+  line: number;
+  value?: string;
+  entries: Record<string, SyntaxNode>;
+}
+
+export interface ArrayNode {
+  kind: 'array';
+  line: number;
+  items: SyntaxNode[];
+}
+
+export type SyntaxErrorCode =
+  | 'unknown_key'
+  | 'schema_mismatch'
+  | 'invalid_value'
+  | 'bad_indent'
+  | 'bad_list'
+  | 'bad_syntax';
+
+export interface SyntaxError {
+  path: string;
+  line: number;
+  code: SyntaxErrorCode;
+  message: string;
+  raw?: string;
+}
+
+export interface SyntaxParseResult {
+  options: Partial<InfographicOptions>;
+  errors: SyntaxError[];
+  warnings: SyntaxError[];
+  ast?: ObjectNode;
+}
+
+export type SchemaNode =
+  | StringSchema
+  | NumberSchema
+  | BooleanSchema
+  | EnumSchema
+  | ArraySchema
+  | ObjectSchema
+  | UnionSchema;
+
+export interface StringSchema {
+  kind: 'string';
+}
+
+export interface NumberSchema {
+  kind: 'number';
+}
+
+export interface BooleanSchema {
+  kind: 'boolean';
+}
+
+export interface EnumSchema {
+  kind: 'enum';
+  values: string[];
+}
+
+export interface ArraySchema {
+  kind: 'array';
+  item: SchemaNode;
+  split?: 'space' | 'comma' | 'any';
+}
+
+export interface ObjectSchema {
+  kind: 'object';
+  fields: Record<string, SchemaNode>;
+  allowUnknown?: boolean;
+  shorthandKey?: string;
+}
+
+export interface UnionSchema {
+  kind: 'union';
+  variants: SchemaNode[];
+}