@antv/infographic 0.1.3 → 0.1.4

package/lib/syntax/index.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSyntax = parseSyntax;
+const mapper_1 = require("./mapper");
+const parser_1 = require("./parser");
+const schema_1 = require("./schema");
+function resolveTemplate(node, errors) {
+    if (!node)
+        return undefined;
+    const mapped = (0, mapper_1.mapWithSchema)(node, schema_1.TemplateSchema, 'template', errors);
+    if (!mapped)
+        return undefined;
+    if (typeof mapped === 'string')
+        return mapped;
+    if (typeof mapped === 'object' && typeof mapped.type === 'string') {
+        return mapped.type;
+    }
+    return undefined;
+}
+function parseSyntax(input) {
+    const { ast, errors } = (0, parser_1.parseSyntaxToAst)(input);
+    const warnings = [];
+    const options = {};
+    const mergedEntries = { ...ast.entries };
+    const infographicNode = ast.entries.infographic;
+    let templateFromInfographic;
+    if (infographicNode && infographicNode.kind === 'object') {
+        if (infographicNode.value)
+            templateFromInfographic = infographicNode.value;
+        Object.entries(infographicNode.entries).forEach(([key, value]) => {
+            if (!(key in mergedEntries))
+                mergedEntries[key] = value;
+        });
+    }
+    const allowedRootKeys = new Set([
+        'infographic',
+        'template',
+        'design',
+        'data',
+        'theme',
+        'width',
+        'height',
+    ]);
+    Object.keys(mergedEntries).forEach((key) => {
+        if (!allowedRootKeys.has(key)) {
+            errors.push({
+                path: key,
+                line: mergedEntries[key].line,
+                code: 'unknown_key',
+                message: 'Unknown top-level key.',
+                raw: key,
+            });
+        }
+    });
+    const templateNode = mergedEntries.template;
+    const templateValue = resolveTemplate(templateNode, errors);
+    if (templateValue)
+        options.template = templateValue;
+    if (!options.template && templateFromInfographic) {
+        options.template = templateFromInfographic;
+    }
+    const designNode = mergedEntries.design;
+    if (designNode) {
+        const design = (0, mapper_1.mapWithSchema)(designNode, schema_1.DesignSchema, 'design', errors);
+        if (design)
+            options.design = design;
+    }
+    const dataNode = mergedEntries.data;
+    if (dataNode) {
+        const data = (0, mapper_1.mapWithSchema)(dataNode, schema_1.DataSchema, 'data', errors);
+        if (data)
+            options.data = data;
+    }
+    const themeNode = mergedEntries.theme;
+    if (themeNode) {
+        const theme = (0, mapper_1.mapWithSchema)(themeNode, schema_1.ThemeSchema, 'theme', errors);
+        if (theme && typeof theme === 'object') {
+            const { type, ...rest } = theme;
+            if (typeof type === 'string' && type)
+                options.theme = type;
+            if (Object.keys(rest).length > 0) {
+                options.themeConfig = rest;
+            }
+        }
+    }
+    const widthNode = mergedEntries.width;
+    if (widthNode) {
+        const width = (0, mapper_1.mapWithSchema)(widthNode, schema_1.RootSchema.fields.width, 'width', errors);
+        if (width !== undefined)
+            options.width = width;
+    }
+    const heightNode = mergedEntries.height;
+    if (heightNode) {
+        const height = (0, mapper_1.mapWithSchema)(heightNode, schema_1.RootSchema.fields.height, 'height', errors);
+        if (height !== undefined)
+            options.height = height;
+    }
+    return {
+        options,
+        errors,
+        warnings,
+        ast,
+    };
+}

package/lib/syntax/mapper.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaNode, SyntaxError, SyntaxNode } from './types';
+export declare function mapWithSchema(node: SyntaxNode, schema: SchemaNode, path: string, errors: SyntaxError[]): any;
+export declare function mapUnknownToObject(node: SyntaxNode): any;

package/lib/syntax/mapper.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapWithSchema = mapWithSchema;
+exports.mapUnknownToObject = mapUnknownToObject;
+const parser_1 = require("./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;
+}
+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 = (0, parser_1.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 = (0, parser_1.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;
+    }
+}
+function mapUnknownToObject(node) {
+    return mapUnknown(node);
+}

package/lib/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/lib/syntax/parser.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSyntaxToAst = parseSyntaxToAst;
+exports.parseInlineKeyValue = parseInlineKeyValue;
+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: [] };
+}
+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 };
+}
+function parseInlineKeyValue(value) {
+    return parseKeyValue(value);
+}

package/lib/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/lib/syntax/schema.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootSchema = exports.TemplateSchema = exports.DataSchema = exports.DesignSchema = exports.ThemeSchema = void 0;
+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),
+};
+exports.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' });
+exports.DesignSchema = object({
+    structure: designNodeSchema,
+    item: designNodeSchema,
+    items: array(designNodeSchema),
+    title: designNodeSchema,
+});
+exports.DataSchema = object({
+    title: string(),
+    desc: string(),
+    items: array(itemDatumSchema),
+});
+exports.TemplateSchema = object({
+    type: string(),
+}, { shorthandKey: 'type' });
+exports.RootSchema = object({
+    template: exports.TemplateSchema,
+    design: exports.DesignSchema,
+    data: exports.DataSchema,
+    theme: exports.ThemeSchema,
+    width: union(number(), string()),
+    height: union(number(), string()),
+});

package/lib/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/lib/syntax/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/templates/built-in.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const hierarchy_mindmap_1 = require("./hierarchy-mindmap");
 const hierarchy_tree_1 = require("./hierarchy-tree");
 const registry_1 = require("./registry");
+const sequence_stairs_1 = require("./sequence-stairs");
+const word_cloud_1 = require("./word-cloud");
 const BUILT_IN_TEMPLATES = {
     'compare-hierarchy-left-right-circle-node-pill-badge': {
         design: {
@@ -803,6 +805,8 @@ const BUILT_IN_TEMPLATES = {
     },
     ...hierarchy_tree_1.hierarchyTreeTemplates,
     ...hierarchy_mindmap_1.hierarchyMindmapTemplates,
+    ...sequence_stairs_1.sequenceStairsTemplates,
+    ...word_cloud_1.wordCloudTemplate,
 };
 Object.entries(BUILT_IN_TEMPLATES).forEach(([name, options]) => {
     (0, registry_1.registerTemplate)(name, options);