@antv/infographic 0.1.2 → 0.1.4

package/esm/syntax/mapper.js

@@ -0,0 +1,238 @@
+import { parseInlineKeyValue } from './parser';
+function createValueNode(value, line) {
+    return { kind: 'value', line, value };
+}
+function parseScalar(value) {
+    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) {
+    if (node.kind === 'value')
+        return node.value;
+    if (node.kind === 'object')
+        return node.value;
+    return undefined;
+}
+function addError(errors, node, path, code, message, raw) {
+    errors.push({
+        path,
+        line: node.line,
+        code,
+        message,
+        raw,
+    });
+}
+function splitArrayValue(value, split = 'any') {
+    let text = value.trim();
+    if (text.startsWith('[') && text.endsWith(']')) {
+        text = text.slice(1, -1).trim();
+    }
+    if (!text)
+        return [];
+    let parts;
+    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) {
+    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 = {};
+    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, schema, path, errors) {
+    let bestValue = undefined;
+    let bestErrors = null;
+    for (const variant of schema.variants) {
+        const variantErrors = [];
+        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, schema, path, errors) {
+    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 = {};
+            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) {
+    return mapUnknown(node);
+}

package/esm/syntax/parser.d.ts

@@ -0,0 +1,14 @@
+import type { ObjectNode, SyntaxError } from './types';
+interface ParseResult {
+    ast: ObjectNode;
+    errors: SyntaxError[];
+}
+export declare function parseSyntaxToAst(input: string): ParseResult;
+export declare function parseInlineKeyValue(value: string): {
+    key: string;
+    value: string;
+} | {
+    key: string;
+    value: undefined;
+} | null;
+export {};

package/esm/syntax/parser.js

@@ -0,0 +1,142 @@
+function isWhitespace(char) {
+    return char === ' ' || char === '\t';
+}
+function getIndentInfo(line) {
+    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) {
+    return content.trimEnd();
+}
+function parseKeyValue(raw) {
+    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, value) {
+    return { kind: 'object', line, value, entries: {} };
+}
+function createArrayNode(line) {
+    return { kind: 'array', line, items: [] };
+}
+export function parseSyntaxToAst(input) {
+    const errors = [];
+    const root = createObjectNode(0);
+    const stack = [
+        { 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) {
+    return parseKeyValue(value);
+}

package/esm/syntax/schema.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectSchema } from './types';
+export declare const ThemeSchema: ObjectSchema;
+export declare const DesignSchema: ObjectSchema;
+export declare const DataSchema: ObjectSchema;
+export declare const TemplateSchema: ObjectSchema;
+export declare const RootSchema: ObjectSchema;

package/esm/syntax/schema.js

@@ -0,0 +1,74 @@
+const string = () => ({ kind: 'string' });
+const number = () => ({ kind: 'number' });
+// const boolean = (): SchemaNode => ({ kind: 'boolean' });
+const enumOf = (values) => ({ kind: 'enum', values });
+const array = (item, split = 'any') => ({
+    kind: 'array',
+    item,
+    split,
+});
+const object = (fields, options = {}) => ({
+    kind: 'object',
+    fields,
+    allowUnknown: options.allowUnknown,
+    shorthandKey: options.shorthandKey,
+});
+const union = (...variants) => ({
+    kind: 'union',
+    variants,
+});
+const itemDatumSchema = 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/esm/syntax/types.d.ts

@@ -0,0 +1,61 @@
+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[];
+}

package/esm/syntax/types.js

@@ -0,0 +1 @@
+export {};

package/esm/templates/built-in.js

@@ -1,5 +1,8 @@
+import { hierarchyMindmapTemplates } from './hierarchy-mindmap';
 import { hierarchyTreeTemplates } from './hierarchy-tree';
 import { registerTemplate } from './registry';
+import { sequenceStairsTemplates } from './sequence-stairs';
+import { wordCloudTemplate } from './word-cloud';
 const BUILT_IN_TEMPLATES = {
     'compare-hierarchy-left-right-circle-node-pill-badge': {
         design: {
@@ -207,7 +210,7 @@ const BUILT_IN_TEMPLATES = {
         design: {
             title: 'default',
             structure: { type: 'sequence-timeline', gap: 20 },
-            items: [{ type: 'simple' }],
+            items: [{ type: 'simple', positionV: 'middle' }],
         },
     },
     'sequence-cylinders-3d-simple': {
@@ -689,7 +692,119 @@ const BUILT_IN_TEMPLATES = {
             items: [{ type: 'compact-card' }],
         },
     },
+    'chart-bar-plain-text': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-bar',
+            },
+            items: [
+                {
+                    type: 'plain-text',
+                    positionH: 'flipped',
+                },
+            ],
+        },
+    },
+    'chart-line-plain-text': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-line',
+            },
+            items: [
+                {
+                    type: 'plain-text',
+                    lineNumber: 2,
+                },
+            ],
+        },
+    },
+    'chart-pie-plain-text': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-pie',
+            },
+            items: [
+                {
+                    type: 'plain-text',
+                },
+            ],
+        },
+    },
+    'chart-pie-compact-card': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-pie',
+            },
+            items: [
+                {
+                    type: 'compact-card',
+                },
+            ],
+        },
+    },
+    'chart-pie-pill-badge': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-pie',
+            },
+            items: [
+                {
+                    type: 'pill-badge',
+                },
+            ],
+        },
+    },
+    'chart-pie-donut-plain-text': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-pie',
+                innerRadius: 90,
+            },
+            items: [
+                {
+                    type: 'plain-text',
+                },
+            ],
+        },
+    },
+    'chart-pie-donut-compact-card': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-pie',
+                innerRadius: 90,
+            },
+            items: [
+                {
+                    type: 'compact-card',
+                },
+            ],
+        },
+    },
+    'chart-pie-donut-pill-badge': {
+        design: {
+            title: 'default',
+            structure: {
+                type: 'chart-pie',
+                innerRadius: 90,
+            },
+            items: [
+                {
+                    type: 'pill-badge',
+                },
+            ],
+        },
+    },
     ...hierarchyTreeTemplates,
+    ...hierarchyMindmapTemplates,
+    ...sequenceStairsTemplates,
+    ...wordCloudTemplate,
 };
 Object.entries(BUILT_IN_TEMPLATES).forEach(([name, options]) => {
     registerTemplate(name, options);

package/esm/templates/hierarchy-mindmap.d.ts

@@ -0,0 +1,2 @@
+import type { TemplateOptions } from '../designs';
+export declare const hierarchyMindmapTemplates: Record<string, TemplateOptions>;