@vis-pilot/engine 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present vis-pilot contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# @vis-pilot/engine
+
+Merged chart engine package for vis-pilot.
+
+Includes:
+
+- text DSL parser (`parseText`, `parseTextOrThrow`, `normalizeSchema`)
+- schema-to-option builders (`buildOption`, `registerChart`)
+- option/schema safeguards (`sanitizeOption`, `validateSchema`, `validateOption`)
+
+## Usage
+
+```ts
+import {
+  parseText,
+  parseTextOrThrow,
+  normalizeSchema,
+  validateSchema,
+  buildOption,
+  sanitizeOption
+} from '@vis-pilot/engine'
+
+const schema = normalizeSchema(
+  parseTextOrThrow(`
+chart: line
+title: Engine Demo
+x: month
+y: value
+data:
+  - month: Jan
+    value: 120
+  - month: Feb
+    value: 150
+`)
+)
+
+const result = parseText('chart: gauge')
+if (!result.ok) {
+  console.log(result.diagnostics)
+}
+
+validateSchema(schema)
+const option = sanitizeOption(buildOption(schema))
+```

package/dist/builder/bar.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function buildBar(schema: ChartSchema): EChartsOption;

package/dist/builder/bar.js

@@ -0,0 +1,44 @@
+import { alignSeriesValues, groupRowsByField, resolveCategoryValues } from './series.js';
+export function buildBar(schema) {
+    const seriesField = schema.encode?.series;
+    const stack = schema.options?.stacked ? 'total' : undefined;
+    if (seriesField && schema.encode?.x && schema.encode?.y) {
+        const xField = schema.encode.x;
+        const yField = schema.encode.y;
+        const xValues = resolveCategoryValues(schema.dataset.source, xField);
+        const groups = groupRowsByField(schema.dataset.source, seriesField);
+        return {
+            title: { text: schema.title },
+            tooltip: { trigger: 'axis' },
+            legend: { type: 'scroll', bottom: 0 },
+            xAxis: { type: 'category', data: xValues },
+            yAxis: { type: 'value' },
+            series: groups.map(({ name, rows }) => ({
+                name,
+                type: 'bar',
+                stack,
+                data: alignSeriesValues(rows, xField, yField, xValues)
+            }))
+        };
+    }
+    return {
+        title: { text: schema.title },
+        tooltip: { trigger: 'axis' },
+        dataset: {
+            dimensions: schema.dataset.dimensions,
+            source: schema.dataset.source
+        },
+        xAxis: { type: 'category' },
+        yAxis: { type: 'value' },
+        series: [
+            {
+                type: 'bar',
+                stack,
+                encode: {
+                    x: schema.encode?.x,
+                    y: schema.encode?.y
+                }
+            }
+        ]
+    };
+}

package/dist/builder/heatmap.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function buildHeatmap(schema: ChartSchema): EChartsOption;

package/dist/builder/heatmap.js

@@ -0,0 +1,31 @@
+export function buildHeatmap(schema) {
+    return {
+        title: { text: schema.title },
+        tooltip: { position: 'top' },
+        dataset: {
+            dimensions: schema.dataset.dimensions,
+            source: schema.dataset.source
+        },
+        xAxis: { type: 'category' },
+        yAxis: { type: 'category' },
+        grid: { bottom: 92 },
+        visualMap: {
+            min: 0,
+            max: 100,
+            calculable: true,
+            orient: 'horizontal',
+            left: 'center',
+            bottom: 10
+        },
+        series: [
+            {
+                type: 'heatmap',
+                encode: {
+                    x: schema.encode?.x,
+                    y: schema.encode?.y,
+                    value: schema.encode?.value
+                }
+            }
+        ]
+    };
+}

package/dist/builder/index.d.ts

@@ -0,0 +1,6 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+import type { ChartBuilderFn } from './types.js';
+export declare function registerChart(name: string, builder: ChartBuilderFn): void;
+export declare function getChartBuilder(name: string): ChartBuilderFn | undefined;
+export declare function buildOption(schema: ChartSchema): EChartsOption;
+export * from './types.js';

package/dist/builder/index.js

@@ -0,0 +1,28 @@
+import { buildLine } from './line.js';
+import { buildBar } from './bar.js';
+import { buildPie } from './pie.js';
+import { buildScatter } from './scatter.js';
+import { buildRadar } from './radar.js';
+import { buildHeatmap } from './heatmap.js';
+const registry = new Map();
+registry.set('line', buildLine);
+registry.set('area', buildLine);
+registry.set('bar', buildBar);
+registry.set('pie', buildPie);
+registry.set('scatter', buildScatter);
+registry.set('radar', buildRadar);
+registry.set('heatmap', buildHeatmap);
+export function registerChart(name, builder) {
+    registry.set(name, builder);
+}
+export function getChartBuilder(name) {
+    return registry.get(name);
+}
+export function buildOption(schema) {
+    const builder = registry.get(schema.type);
+    if (!builder) {
+        throw new Error(`No builder registered for chart type: ${schema.type}`);
+    }
+    return builder(schema);
+}
+export * from './types.js';

package/dist/builder/line.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function buildLine(schema: ChartSchema): EChartsOption;

package/dist/builder/line.js

@@ -0,0 +1,50 @@
+import { alignSeriesValues, groupRowsByField, resolveCategoryValues } from './series.js';
+export function buildLine(schema) {
+    const seriesField = schema.encode?.series;
+    const isArea = schema.options?.area || schema.type === 'area';
+    const smooth = schema.options?.smooth;
+    const stack = schema.options?.stacked ? 'total' : undefined;
+    if (seriesField && schema.encode?.x && schema.encode?.y) {
+        const xField = schema.encode.x;
+        const yField = schema.encode.y;
+        const xValues = resolveCategoryValues(schema.dataset.source, xField);
+        const groups = groupRowsByField(schema.dataset.source, seriesField);
+        return {
+            title: { text: schema.title },
+            tooltip: { trigger: 'axis' },
+            legend: { type: 'scroll', bottom: 0 },
+            xAxis: { type: 'category', data: xValues },
+            yAxis: { type: 'value' },
+            series: groups.map(({ name, rows }) => ({
+                name,
+                type: 'line',
+                smooth,
+                areaStyle: isArea ? {} : undefined,
+                stack,
+                data: alignSeriesValues(rows, xField, yField, xValues)
+            }))
+        };
+    }
+    return {
+        title: { text: schema.title },
+        tooltip: { trigger: 'axis' },
+        dataset: {
+            dimensions: schema.dataset.dimensions,
+            source: schema.dataset.source
+        },
+        xAxis: { type: 'category' },
+        yAxis: { type: 'value' },
+        series: [
+            {
+                type: 'line',
+                smooth,
+                areaStyle: isArea ? {} : undefined,
+                stack,
+                encode: {
+                    x: schema.encode?.x,
+                    y: schema.encode?.y
+                }
+            }
+        ]
+    };
+}

package/dist/builder/pie.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function buildPie(schema: ChartSchema): EChartsOption;

package/dist/builder/pie.js

@@ -0,0 +1,20 @@
+export function buildPie(schema) {
+    return {
+        title: { text: schema.title },
+        dataset: {
+            dimensions: schema.dataset.dimensions,
+            source: schema.dataset.source
+        },
+        tooltip: { trigger: 'item' },
+        series: [
+            {
+                type: 'pie',
+                radius: '60%',
+                encode: {
+                    itemName: schema.encode?.x,
+                    value: schema.encode?.y ?? schema.encode?.value
+                }
+            }
+        ]
+    };
+}

package/dist/builder/radar.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function buildRadar(schema: ChartSchema): EChartsOption;

package/dist/builder/radar.js

@@ -0,0 +1,46 @@
+export function buildRadar(schema) {
+    const { dimensions, source } = schema.dataset;
+    const labelDim = dimensions.find((d) => d !== schema.encode?.value && d !== schema.encode?.series);
+    const valueDim = schema.encode?.value ?? dimensions.find((d) => d !== labelDim);
+    if (labelDim &&
+        valueDim &&
+        dimensions.length === 2 &&
+        source.length > 0 &&
+        typeof source[0][labelDim] === 'string') {
+        const indicators = source.map((row) => ({
+            name: String(row[labelDim])
+        }));
+        const values = source.map((row) => row[valueDim]);
+        return {
+            title: { text: schema.title },
+            tooltip: {},
+            legend: { show: false },
+            radar: { indicator: indicators },
+            series: [
+                {
+                    type: 'radar',
+                    data: [{ value: values }]
+                }
+            ]
+        };
+    }
+    const seriesDim = schema.encode?.series;
+    const valueDims = dimensions.filter((d) => d !== seriesDim);
+    const indicators = valueDims.map((name) => ({ name }));
+    const data = source.map((row) => ({
+        name: seriesDim ? String(row[seriesDim]) : undefined,
+        value: valueDims.map((d) => row[d])
+    }));
+    return {
+        title: { text: schema.title },
+        tooltip: {},
+        legend: { type: 'scroll', bottom: 0 },
+        radar: { indicator: indicators },
+        series: [
+            {
+                type: 'radar',
+                data
+            }
+        ]
+    };
+}

package/dist/builder/scatter.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function buildScatter(schema: ChartSchema): EChartsOption;

package/dist/builder/scatter.js

@@ -0,0 +1,44 @@
+export function buildScatter(schema) {
+    const seriesField = schema.encode?.series;
+    if (seriesField) {
+        const groups = new Map();
+        for (const row of schema.dataset.source) {
+            const key = String(row[seriesField]);
+            if (!groups.has(key))
+                groups.set(key, []);
+            groups.get(key).push(row);
+        }
+        const dims = schema.dataset.dimensions.filter((d) => d !== seriesField);
+        return {
+            title: { text: schema.title },
+            tooltip: { trigger: 'item' },
+            legend: { type: 'scroll', bottom: 0 },
+            xAxis: { type: 'value', scale: true },
+            yAxis: { type: 'value', scale: true },
+            series: Array.from(groups, ([name, data]) => ({
+                name,
+                type: 'scatter',
+                data: data.map((row) => dims.map((d) => row[d]))
+            }))
+        };
+    }
+    return {
+        title: { text: schema.title },
+        tooltip: { trigger: 'item' },
+        dataset: {
+            dimensions: schema.dataset.dimensions,
+            source: schema.dataset.source
+        },
+        xAxis: { type: 'value', scale: true },
+        yAxis: { type: 'value', scale: true },
+        series: [
+            {
+                type: 'scatter',
+                encode: {
+                    x: schema.encode?.x,
+                    y: schema.encode?.y
+                }
+            }
+        ]
+    };
+}

package/dist/builder/series.d.ts

@@ -0,0 +1,9 @@
+type Row = Record<string, unknown>;
+export interface GroupedSeriesData {
+    name: string;
+    rows: Row[];
+}
+export declare function groupRowsByField(rows: Row[], field: string): GroupedSeriesData[];
+export declare function resolveCategoryValues(rows: Row[], field: string): unknown[];
+export declare function alignSeriesValues(rows: Row[], categoryField: string, valueField: string, categoryValues: unknown[]): unknown[];
+export {};

package/dist/builder/series.js

@@ -0,0 +1,26 @@
+export function groupRowsByField(rows, field) {
+    const groups = new Map();
+    for (const row of rows) {
+        const key = String(row[field]);
+        const group = groups.get(key);
+        if (group) {
+            group.push(row);
+        }
+        else {
+            groups.set(key, [row]);
+        }
+    }
+    return Array.from(groups, ([name, groupedRows]) => ({
+        name,
+        rows: groupedRows
+    }));
+}
+export function resolveCategoryValues(rows, field) {
+    return [...new Set(rows.map((row) => row[field]))];
+}
+export function alignSeriesValues(rows, categoryField, valueField, categoryValues) {
+    return categoryValues.map((categoryValue) => {
+        const row = rows.find((item) => item[categoryField] === categoryValue);
+        return row ? row[valueField] : null;
+    });
+}

package/dist/builder/types.d.ts

@@ -0,0 +1,5 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export interface ChartBuilder {
+    build(schema: ChartSchema): EChartsOption;
+}
+export type ChartBuilderFn = (schema: ChartSchema) => EChartsOption;

package/dist/builder/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './parser/index.js';
+export * from './builder/index.js';
+export * from './validator/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './parser/index.js';
+export * from './builder/index.js';
+export * from './validator/index.js';

package/dist/parser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './parseText.js';
+export * from './normalize.js';

package/dist/parser/index.js

@@ -0,0 +1,2 @@
+export * from './parseText.js';
+export * from './normalize.js';

package/dist/parser/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSchema } from '@vis-pilot/core';
+export declare function normalizeSchema(input: Partial<ChartSchema>): ChartSchema;

package/dist/parser/normalize.js

@@ -0,0 +1,33 @@
+import { inferChartType } from '@vis-pilot/core';
+export function normalizeSchema(input) {
+    const dataset = input.dataset ?? { dimensions: [], source: [] };
+    let dimensions;
+    if (dataset.dimensions.length) {
+        dimensions = dataset.dimensions;
+    }
+    else if (dataset.source.length) {
+        dimensions = Object.keys(dataset.source[0]);
+    }
+    else {
+        dimensions = [];
+    }
+    if (!dimensions.length) {
+        throw new Error('Cannot normalize schema: dataset.dimensions is empty');
+    }
+    const schema = {
+        type: input.type ?? 'bar',
+        title: input.title,
+        description: input.description,
+        dataset: {
+            dimensions,
+            source: dataset.source
+        },
+        encode: input.encode,
+        options: input.options,
+        theme: input.theme
+    };
+    if (!input.type) {
+        schema.type = inferChartType(schema);
+    }
+    return schema;
+}

package/dist/parser/parseText.d.ts

@@ -0,0 +1,21 @@
+import type { ChartSchema } from '@vis-pilot/core';
+export type ParseDiagnosticCode = 'invalid_indentation' | 'invalid_syntax' | 'unsupported_field' | 'unsupported_option' | 'invalid_option_value' | 'invalid_data' | 'invalid_schema' | 'unsupported_chart_type';
+export interface ParseDiagnostic {
+    code: ParseDiagnosticCode;
+    message: string;
+    line?: number;
+}
+export type ParseTextResult = {
+    ok: true;
+    schema: ChartSchema;
+    diagnostics: [];
+} | {
+    ok: false;
+    diagnostics: ParseDiagnostic[];
+};
+export declare class ParseTextError extends Error {
+    readonly diagnostics: ParseDiagnostic[];
+    constructor(diagnostic: ParseDiagnostic);
+}
+export declare function parseTextOrThrow(input: string): ChartSchema;
+export declare function parseText(input: string): ParseTextResult;

package/dist/parser/parseText.js

@@ -0,0 +1,241 @@
+import { inferChartType } from '@vis-pilot/core';
+export class ParseTextError extends Error {
+    constructor(diagnostic) {
+        super(diagnostic.message);
+        this.name = 'ParseTextError';
+        this.diagnostics = [diagnostic];
+    }
+}
+const ROOT_FIELDS = new Set(['chart', 'title', 'x', 'y', 'series', 'data', 'options']);
+const OPTION_FIELDS = new Set(['stacked', 'smooth', 'area', 'sort']);
+const SUPPORTED_CHART_TYPES = new Set(['line', 'area', 'bar', 'pie', 'scatter', 'radar', 'heatmap']);
+const LEADING_WHITESPACE_REGEX = /^\s*/;
+const ROOT_FIELD_REGEX = /^([a-zA-Z]+):\s*(.*)$/;
+const KEY_VALUE_REGEX = /^([a-zA-Z_][\w-]*):\s*(.+)$/;
+const FENCED_BLOCK_REGEX = /^```(?:vispilot|text|yaml|yml)?\s*\n([\s\S]*?)\n```$/i;
+function unwrapFencedBlock(input) {
+    const trimmed = input.trim();
+    const match = FENCED_BLOCK_REGEX.exec(trimmed);
+    return match?.[1] ?? input;
+}
+function stripInlineComment(line) {
+    let quote = null;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if ((character === '"' || character === "'") && line[index - 1] !== '\\') {
+            quote = quote === character ? null : (quote ?? character);
+            continue;
+        }
+        if (character === '#' && !quote) {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+function normalizeIdentifier(value) {
+    return value.trim().toLowerCase();
+}
+function parseError(code, message, line) {
+    return new ParseTextError({
+        code,
+        message,
+        line
+    });
+}
+function parseScalar(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    const normalized = normalizeIdentifier(trimmed);
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    if (trimmed !== '' && !Number.isNaN(Number(trimmed)))
+        return Number(trimmed);
+    return trimmed;
+}
+function assertIndent(line, expected, message, lineNumber) {
+    const indentMatch = LEADING_WHITESPACE_REGEX.exec(line);
+    const indent = indentMatch?.[0].length ?? 0;
+    if (indent !== expected) {
+        throw parseError('invalid_indentation', message, lineNumber);
+    }
+}
+function parseBooleanOption(rawValue, optionKey, lineNumber) {
+    const normalized = rawValue.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0') {
+        return false;
+    }
+    throw parseError('invalid_option_value', `Invalid boolean value for options.${optionKey} at line ${lineNumber}, expected true/false`, lineNumber);
+}
+function isTrueOptionValue(value) {
+    return value === true;
+}
+function parseDataBlock(lines, startIndex) {
+    const list = [];
+    let blockIndex = startIndex;
+    while (blockIndex < lines.length && lines[blockIndex].startsWith('  - ')) {
+        const firstLine = lines[blockIndex];
+        assertIndent(firstLine, 2, `Invalid data item indentation at line ${blockIndex + 1}, expected 2 spaces`, blockIndex + 1);
+        const firstPair = firstLine.slice(4);
+        const match = KEY_VALUE_REGEX.exec(firstPair);
+        if (!match) {
+            throw parseError('invalid_data', `Invalid data item at line ${blockIndex + 1}`, blockIndex + 1);
+        }
+        const item = {
+            [match[1]]: parseScalar(match[2])
+        };
+        blockIndex += 1;
+        while (blockIndex < lines.length && lines[blockIndex].startsWith('    ')) {
+            const nestedLine = lines[blockIndex];
+            assertIndent(nestedLine, 4, `Invalid data key indentation at line ${blockIndex + 1}, expected 4 spaces`, blockIndex + 1);
+            const nestedMatch = KEY_VALUE_REGEX.exec(nestedLine.trim());
+            if (!nestedMatch) {
+                throw parseError('invalid_data', `Invalid data key-value at line ${blockIndex + 1}`, blockIndex + 1);
+            }
+            item[nestedMatch[1]] = parseScalar(nestedMatch[2]);
+            blockIndex += 1;
+        }
+        list.push(item);
+    }
+    return {
+        data: list,
+        nextIndex: blockIndex
+    };
+}
+function parseOptionsBlock(lines, startIndex) {
+    const options = {};
+    let blockIndex = startIndex;
+    while (blockIndex < lines.length && lines[blockIndex].startsWith('  ')) {
+        const optionLine = lines[blockIndex];
+        assertIndent(optionLine, 2, `Invalid options indentation at line ${blockIndex + 1}, expected 2 spaces`, blockIndex + 1);
+        if (optionLine.startsWith('  - ')) {
+            break;
+        }
+        const optionMatch = KEY_VALUE_REGEX.exec(optionLine.trim());
+        if (!optionMatch) {
+            throw parseError('invalid_syntax', `Invalid option item at line ${blockIndex + 1}`, blockIndex + 1);
+        }
+        const optionKey = normalizeIdentifier(optionMatch[1]);
+        if (!OPTION_FIELDS.has(optionKey)) {
+            throw parseError('unsupported_option', `Unsupported option "${optionKey}" at line ${blockIndex + 1}`, blockIndex + 1);
+        }
+        options[optionKey] = parseBooleanOption(optionMatch[2], optionKey, blockIndex + 1);
+        blockIndex += 1;
+    }
+    return {
+        options,
+        nextIndex: blockIndex
+    };
+}
+export function parseTextOrThrow(input) {
+    const lines = unwrapFencedBlock(input)
+        .split(/\r?\n/)
+        .map(stripInlineComment)
+        .map((line) => line.replace(/\s+$/, ''))
+        .filter((line) => line.trim().length > 0);
+    const root = {};
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        assertIndent(line, 0, `Invalid root indentation at line ${index + 1}, expected 0 spaces`, index + 1);
+        const rootMatch = ROOT_FIELD_REGEX.exec(line);
+        if (!rootMatch) {
+            throw parseError('invalid_syntax', `Invalid DSL syntax at line ${index + 1}`, index + 1);
+        }
+        const key = normalizeIdentifier(rootMatch[1]);
+        const rawValue = rootMatch[2];
+        if (!ROOT_FIELDS.has(key)) {
+            throw parseError('unsupported_field', `Unsupported field "${key}" at line ${index + 1}`, index + 1);
+        }
+        if (key === 'data') {
+            if (rawValue.length > 0) {
+                throw parseError('invalid_syntax', 'data field must not have inline value', index + 1);
+            }
+            const parsedData = parseDataBlock(lines, index + 1);
+            root.data = parsedData.data;
+            index = parsedData.nextIndex;
+            continue;
+        }
+        if (key === 'options') {
+            if (rawValue.length > 0) {
+                throw parseError('invalid_syntax', 'options field must not have inline value', index + 1);
+            }
+            const parsedOptions = parseOptionsBlock(lines, index + 1);
+            root.options = parsedOptions.options;
+            index = parsedOptions.nextIndex;
+            continue;
+        }
+        root[key] = parseScalar(rawValue);
+        index += 1;
+    }
+    const source = root.data ?? [];
+    const dimensions = source.length > 0 ? Object.keys(source[0]) : [root.x, root.y].filter(Boolean);
+    if (!dimensions.length) {
+        throw parseError('invalid_schema', 'dataset dimensions cannot be empty');
+    }
+    if (root.chart !== undefined) {
+        if (typeof root.chart !== 'string') {
+            throw parseError('invalid_schema', 'chart must be a string');
+        }
+        root.chart = normalizeIdentifier(root.chart);
+        if (!SUPPORTED_CHART_TYPES.has(root.chart)) {
+            throw parseError('unsupported_chart_type', `Unsupported chart type "${root.chart}"`);
+        }
+    }
+    const schema = {
+        type: root.chart ?? 'bar',
+        title: root.title,
+        dataset: {
+            dimensions,
+            source
+        },
+        encode: {
+            x: root.x,
+            y: root.y,
+            series: root.series
+        },
+        options: {
+            stacked: isTrueOptionValue(root.options?.stacked),
+            smooth: isTrueOptionValue(root.options?.smooth),
+            area: isTrueOptionValue(root.options?.area),
+            sort: isTrueOptionValue(root.options?.sort)
+        }
+    };
+    if (!root.chart) {
+        schema.type = inferChartType(schema);
+    }
+    return schema;
+}
+export function parseText(input) {
+    try {
+        return {
+            ok: true,
+            schema: parseTextOrThrow(input),
+            diagnostics: []
+        };
+    }
+    catch (error) {
+        if (error instanceof ParseTextError) {
+            return {
+                ok: false,
+                diagnostics: error.diagnostics
+            };
+        }
+        return {
+            ok: false,
+            diagnostics: [
+                {
+                    code: 'invalid_syntax',
+                    message: error instanceof Error ? error.message : 'Unknown parse error'
+                }
+            ]
+        };
+    }
+}

package/dist/validator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sanitize.js';
+export * from './validate.js';

package/dist/validator/index.js

@@ -0,0 +1,2 @@
+export * from './sanitize.js';
+export * from './validate.js';

package/dist/validator/sanitize.d.ts

@@ -0,0 +1,2 @@
+import type { EChartsOption } from '@vis-pilot/core';
+export declare function sanitizeOption(option: unknown): EChartsOption;

package/dist/validator/sanitize.js

@@ -0,0 +1,36 @@
+const BLOCKED_KEYS = new Set([
+    'toolbox',
+    'graphic',
+    'animationDelay',
+    'animationDelayUpdate',
+    'renderItem'
+]);
+function deepSanitize(value) {
+    if (typeof value === 'function') {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => deepSanitize(item)).filter((item) => item !== undefined);
+    }
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [key, nested] of Object.entries(value)) {
+            if (BLOCKED_KEYS.has(key)) {
+                continue;
+            }
+            const sanitized = deepSanitize(nested);
+            if (sanitized !== undefined) {
+                result[key] = sanitized;
+            }
+        }
+        return result;
+    }
+    return value;
+}
+export function sanitizeOption(option) {
+    const sanitized = deepSanitize(option);
+    if (!sanitized || typeof sanitized !== 'object' || Array.isArray(sanitized)) {
+        throw new Error('Invalid ECharts option after sanitization');
+    }
+    return sanitized;
+}

package/dist/validator/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ChartSchema, EChartsOption } from '@vis-pilot/core';
+export declare function isVisSyntax(input: string): boolean;
+export declare function validateSchema(schema: ChartSchema): void;
+export declare function validateOption(option: EChartsOption): void;

package/dist/validator/validate.js

@@ -0,0 +1,70 @@
+const VIS_ROOT_FIELDS = new Set(['chart', 'title', 'x', 'y', 'series', 'data', 'options']);
+function unwrapVisPilotFence(input) {
+    const fencedMatch = /```vispilot\s*([\s\S]*?)```/i.exec(input);
+    if (fencedMatch?.[1]) {
+        return fencedMatch[1].trim();
+    }
+    return input;
+}
+export function isVisSyntax(input) {
+    if (typeof input !== 'string') {
+        return false;
+    }
+    const text = input.trim();
+    if (!text) {
+        return false;
+    }
+    const candidate = unwrapVisPilotFence(text);
+    if (!candidate) {
+        return false;
+    }
+    const lines = candidate.split(/\r?\n/);
+    let rootFieldHits = 0;
+    let hasDataOrOptionsRoot = false;
+    const lineLimit = Math.min(lines.length, 80);
+    for (let index = 0; index < lineLimit; index += 1) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('- ')) {
+            continue;
+        }
+        if (line[0] === ' ' || line[0] === '\t') {
+            continue;
+        }
+        const separatorIndex = trimmed.indexOf(':');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = trimmed.slice(0, separatorIndex).trim().toLowerCase();
+        if (!VIS_ROOT_FIELDS.has(key)) {
+            continue;
+        }
+        rootFieldHits += 1;
+        if (key === 'data' || key === 'options') {
+            hasDataOrOptionsRoot = true;
+        }
+        if (rootFieldHits >= 2) {
+            return true;
+        }
+    }
+    return rootFieldHits === 1 && hasDataOrOptionsRoot;
+}
+export function validateSchema(schema) {
+    if (!schema.type) {
+        throw new Error('schema.type is required');
+    }
+    if (!schema.dataset) {
+        throw new Error('schema.dataset is required');
+    }
+    if (!Array.isArray(schema.dataset.dimensions) || schema.dataset.dimensions.length === 0) {
+        throw new TypeError('schema.dataset.dimensions must be a non-empty array');
+    }
+    if (!Array.isArray(schema.dataset.source)) {
+        throw new TypeError('schema.dataset.source must be an array');
+    }
+}
+export function validateOption(option) {
+    if (!option || typeof option !== 'object') {
+        throw new TypeError('option must be an object');
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@vis-pilot/engine",
+  "version": "0.1.0",
+  "description": "Text parser, option builder, and validation engine for vis-pilot.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@vis-pilot/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
+}