@antv/infographic 0.1.3 → 0.2.0

package/lib/runtime/utils.js

@@ -1,21 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeOptions = mergeOptions;
+exports.cloneOptions = cloneOptions;
+exports.isCompleteParsedInfographicOptions = isCompleteParsedInfographicOptions;
+const lodash_es_1 = require("lodash-es");
+const utils_1 = require("../utils");
 function mergeOptions(object, source) {
-    return {
+    const base = {
         ...object,
         ...source,
-        design: {
-            ...object.design,
-            ...source.design,
-        },
-        themeConfig: {
-            ...object.themeConfig,
-            ...source.themeConfig,
-        },
-        svg: {
-            ...object.svg,
-            ...source.svg,
-        },
     };
+    if (object.design || source.design) {
+        base.design = { ...object.design, ...source.design };
+    }
+    if (object.themeConfig || source.themeConfig) {
+        base.themeConfig = { ...object.themeConfig, ...source.themeConfig };
+    }
+    if (object.svg || source.svg) {
+        base.svg = { ...object.svg, ...source.svg };
+    }
+    return base;
+}
+function cloneOptions(options) {
+    const cloned = { ...options };
+    if (cloned.data)
+        cloned.data = (0, lodash_es_1.cloneDeep)(cloned.data);
+    if (cloned.elements)
+        cloned.elements = (0, lodash_es_1.cloneDeep)(cloned.elements);
+    return cloned;
+}
+function isCompleteParsedInfographicOptions(options) {
+    const { design, data } = options;
+    if (!design)
+        return false;
+    if (!(0, utils_1.isNonNullableParsedDesignsOptions)(design))
+        return false;
+    if (!data)
+        return false;
+    if (!Array.isArray(data.items) || data.items.length < 1)
+        return false;
+    return true;
 }

package/lib/syntax/index.d.ts

@@ -0,0 +1,3 @@
+import type { SyntaxParseResult } from './types';
+export declare function parseSyntax(input: string): SyntaxParseResult;
+export type { SyntaxError, SyntaxNode, SyntaxParseResult } from './types';

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,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapWithSchema = mapWithSchema;
+exports.mapUnknownToObject = mapUnknownToObject;
+const tinycolor2_1 = __importDefault(require("tinycolor2"));
+const parser_1 = require("./parser");
+function createValueNode(value, line) {
+    return { kind: 'value', line, value };
+}
+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 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]+/);
+    }
+    const normalized = [];
+    for (const part of parts) {
+        const trimmedPart = part.trim();
+        if (!trimmedPart)
+            continue;
+        if (trimmedPart === '#' || trimmedPart === '//')
+            break;
+        normalized.push(trimmedPart);
+    }
+    return normalized;
+}
+function stripColorComments(value) {
+    let trimmed = value.trim();
+    const hashIndex = trimmed.search(/\s+#(?![0-9a-f])/i);
+    if (hashIndex >= 0) {
+        trimmed = trimmed.slice(0, hashIndex).trimEnd();
+    }
+    const slashIndex = trimmed.indexOf('//');
+    if (slashIndex >= 0) {
+        trimmed = trimmed.slice(0, slashIndex).trimEnd();
+    }
+    return trimmed;
+}
+function normalizeExplicitColor(value) {
+    const trimmed = stripColorComments(value);
+    if (!trimmed)
+        return undefined;
+    const hexMatch = trimmed.match(HEX_COLOR_PATTERN);
+    if (hexMatch && hexMatch[0].length === trimmed.length) {
+        return trimmed;
+    }
+    const funcMatch = trimmed.match(FUNCTION_COLOR_PATTERN);
+    if (funcMatch && funcMatch[1].length === trimmed.length) {
+        return trimmed;
+    }
+    if ((0, tinycolor2_1.default)(trimmed).isValid())
+        return trimmed;
+    return undefined;
+}
+function mapColor(node, path, errors, options = {}) {
+    const value = readScalar(node);
+    if (value === undefined) {
+        addError(errors, node, path, 'schema_mismatch', 'Expected color value.');
+        return undefined;
+    }
+    const normalized = normalizeExplicitColor(value);
+    if (!normalized) {
+        if (!options.soft) {
+            addError(errors, node, path, 'invalid_value', 'Invalid color value.', value);
+        }
+        return undefined;
+    }
+    return normalized;
+}
+function shouldTreatPaletteStringAsArray(trimmed, parts) {
+    if (parts.length > 1)
+        return true;
+    if (trimmed.startsWith('[') && trimmed.endsWith(']'))
+        return true;
+    return normalizeExplicitColor(trimmed) !== undefined;
+}
+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 'palette': {
+            if (node.kind === 'array') {
+                const values = mapWithSchema(node, { kind: 'array', item: { kind: 'color' }, split: 'any' }, path, errors);
+                return Array.isArray(values) && values.length > 0 ? values : undefined;
+            }
+            if (node.kind === 'object' && Object.keys(node.entries).length > 0) {
+                addError(errors, node, path, 'schema_mismatch', 'Expected palette value.');
+                return undefined;
+            }
+            const scalar = readScalar(node);
+            if (scalar === undefined) {
+                addError(errors, node, path, 'schema_mismatch', 'Expected palette value.');
+                return undefined;
+            }
+            const trimmed = scalar.trim();
+            if (trimmed.startsWith('[') && !trimmed.endsWith(']')) {
+                return undefined;
+            }
+            const directColor = normalizeExplicitColor(trimmed);
+            if (directColor) {
+                return [directColor];
+            }
+            const parts = splitArrayValue(scalar, 'any');
+            if (shouldTreatPaletteStringAsArray(trimmed, parts)) {
+                const values = parts
+                    .map((part, index) => mapColor(createValueNode(part, node.line), `${path}[${index}]`, errors))
+                    .filter((value) => value !== undefined);
+                return values.length > 0 ? values : undefined;
+            }
+            return scalar;
+        }
+        case 'color': {
+            return mapColor(node, path, errors, { soft: schema.soft });
+        }
+        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;