@antv/infographic 0.2.13 → 0.2.15

package/esm/editor/plugins/reset-viewbox.js

@@ -0,0 +1,186 @@
+import { COMPONENT_ROLE } from '../../constants/index.js';
+import { getBoundViewBox, getViewBox, injectStyleOnce, parsePadding, setElementRole, viewBoxToString, } from '../../utils/index.js';
+import { UpdateOptionsCommand } from '../commands/index.js';
+import { Plugin } from './base.js';
+import { IconButton } from './components/index.js';
+import { RESET_ICON } from './components/icons.js';
+const MARGIN_X = 25;
+const MARGIN_Y = 25;
+const BUTTON_SIZE = 40;
+export class ResetViewBox extends Plugin {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.name = 'reset-viewBox';
+        this.viewBoxChanged = false;
+        this.handleResize = () => {
+            this.updateOriginViewBox();
+            this.updatePosition();
+        };
+        this.handleViewBoxChange = (viewBox) => {
+            const svg = this.editor.getDocument();
+            this.viewBoxChanged = viewBox !== this.originViewBox;
+            if (!this.viewBoxChanged) {
+                if (this.resetButton)
+                    this.hideButton(this.resetButton);
+                return;
+            }
+            const button = this.getOrCreateResetButton();
+            this.placeButton(button, svg);
+            this.showButton(button);
+        };
+        this.getOrCreateResetButton = () => {
+            if (this.resetButton)
+                return this.resetButton;
+            const { style, className } = this.options || {};
+            const button = IconButton({
+                icon: RESET_ICON,
+                onClick: this.resetViewBox,
+            });
+            button.classList.add(RESET_BUTTON_CLASS);
+            if (className) {
+                button.classList.add(className);
+            }
+            if (style) {
+                Object.assign(button.style, style);
+            }
+            setElementRole(button, COMPONENT_ROLE);
+            this.resetButton = button;
+            const { getContainer } = this.options || {};
+            const resolvedContainer = typeof getContainer === 'function' ? getContainer() : getContainer;
+            const containerParent = resolvedContainer !== null && resolvedContainer !== void 0 ? resolvedContainer : document.body;
+            containerParent === null || containerParent === void 0 ? void 0 : containerParent.appendChild(button);
+            return button;
+        };
+        /** Get CSS transform scale of an element */
+        this.getTransformScale = (element) => {
+            const rect = element.getBoundingClientRect();
+            const scaleX = element.offsetWidth > 0 ? rect.width / element.offsetWidth : 1;
+            const scaleY = element.offsetHeight > 0 ? rect.height / element.offsetHeight : 1;
+            return { scaleX, scaleY };
+        };
+        /** Find the nearest stable overflow container */
+        this.findStableContainer = (svg) => {
+            let current = svg.parentElement;
+            while (current) {
+                if (current instanceof HTMLElement) {
+                    const style = window.getComputedStyle(current);
+                    // Look for overflow container or positioned element as stable reference
+                    if ((style.overflow && style.overflow !== 'visible') ||
+                        (style.overflowX && style.overflowX !== 'visible') ||
+                        (style.overflowY && style.overflowY !== 'visible')) {
+                        return current;
+                    }
+                }
+                current = current.parentElement;
+            }
+            return null;
+        };
+        this.placeButton = (button, svg) => {
+            var _a;
+            if (!svg.isConnected)
+                return;
+            const svgRect = svg.getBoundingClientRect();
+            const offsetParent = (_a = button.offsetParent) !== null && _a !== void 0 ? _a : document.documentElement;
+            // Use stable container bounds to clamp button position when SVG overflows
+            const stableContainer = this.findStableContainer(svg);
+            const containerRect = stableContainer === null || stableContainer === void 0 ? void 0 : stableContainer.getBoundingClientRect();
+            // Prefer SVG bounds, but clamp to container if SVG overflows
+            const effectiveRect = containerRect
+                ? {
+                    right: Math.min(svgRect.right, containerRect.right),
+                    bottom: Math.min(svgRect.bottom, containerRect.bottom),
+                }
+                : svgRect;
+            if (offsetParent === document.body ||
+                offsetParent === document.documentElement) {
+                const scrollX = window.scrollX || document.documentElement.scrollLeft;
+                const scrollY = window.scrollY || document.documentElement.scrollTop;
+                const left = scrollX + effectiveRect.right - MARGIN_X - BUTTON_SIZE;
+                const top = scrollY + effectiveRect.bottom - MARGIN_Y - BUTTON_SIZE;
+                button.style.left = `${left}px`;
+                button.style.top = `${top}px`;
+                return;
+            }
+            const parentRect = offsetParent.getBoundingClientRect();
+            // Compensate for parent transform scale
+            const { scaleX, scaleY } = this.getTransformScale(offsetParent);
+            // Convert to offsetParent local coordinates
+            const left = (effectiveRect.right - parentRect.left) / scaleX - MARGIN_X - BUTTON_SIZE;
+            const top = (effectiveRect.bottom - parentRect.top) / scaleY - MARGIN_Y - BUTTON_SIZE;
+            button.style.left = `${left}px`;
+            button.style.top = `${top}px`;
+        };
+        this.updatePosition = () => {
+            if (this.resetButton && this.viewBoxChanged) {
+                this.placeButton(this.resetButton, this.editor.getDocument());
+            }
+        };
+        this.resetViewBox = () => {
+            const command = new UpdateOptionsCommand({
+                viewBox: this.originViewBox,
+            });
+            void this.commander.execute(command);
+        };
+        this.showButton = (button) => {
+            button.style.display = 'flex';
+            button.style.visibility = 'visible';
+        };
+        this.hideButton = (button) => {
+            button.style.display = 'none';
+        };
+        this.removeButton = () => {
+            var _a;
+            this.viewBoxChanged = false;
+            (_a = this.resetButton) === null || _a === void 0 ? void 0 : _a.remove();
+            this.resetButton = undefined;
+        };
+    }
+    init(options) {
+        super.init(options);
+        // Initialize originViewBox
+        this.ensureButtonStyle();
+        this.updateOriginViewBox();
+        this.unregisterSync = this.editor.registerSync('viewBox', this.handleViewBoxChange);
+        window.addEventListener('resize', this.handleResize);
+    }
+    destroy() {
+        var _a;
+        (_a = this.unregisterSync) === null || _a === void 0 ? void 0 : _a.call(this);
+        window.removeEventListener('resize', this.handleResize);
+        this.removeButton();
+    }
+    updateOriginViewBox() {
+        const svg = this.editor.getDocument();
+        // In Node env or before render, fallback to current viewBox attribute
+        if (!svg.getBBox) {
+            this.originViewBox = viewBoxToString(getViewBox(svg));
+            return;
+        }
+        // In Browser, calculate fit
+        const { padding } = this.state.getOptions();
+        this.originViewBox = getBoundViewBox(svg, parsePadding(padding));
+    }
+    ensureButtonStyle() {
+        injectStyleOnce(RESET_BUTTON_STYLE_ID, `
+      button.${RESET_BUTTON_CLASS} {
+        visibility: hidden;
+        position: absolute;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        width: ${BUTTON_SIZE}px;
+        height: ${BUTTON_SIZE}px;
+        border-radius: 50%;
+        padding: 4px;
+        background-color: #fff;
+        border: 1px solid #e5e7eb;
+        z-index: 1000;
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+        cursor: pointer;
+      }
+      `);
+    }
+}
+const RESET_BUTTON_CLASS = 'infographic-reset-viewbox-btn';
+const RESET_BUTTON_STYLE_ID = 'infographic-reset-viewbox-btn-style';

package/esm/editor/types/editor.d.ts

@@ -1,4 +1,18 @@
+import type { InfographicOptionPath } from '../../options';
+import type { ICommandManager } from './command';
+import type { IInteractionManager } from './interaction';
+import type { IPluginManager } from './plugin';
+import type { IStateManager } from './state';
+import type { ISyncRegistry, SyncHandler } from './sync';
 export interface IEditor {
+    commander: ICommandManager;
+    interaction: IInteractionManager;
+    plugin: IPluginManager;
+    state: IStateManager;
+    syncRegistry: ISyncRegistry;
     getDocument(): SVGSVGElement;
+    registerSync(path: InfographicOptionPath | (string & {}), handler: SyncHandler, options?: {
+        immediate?: boolean;
+    }): () => void;
     destroy(): void;
 }

package/esm/editor/types/index.d.ts

@@ -5,3 +5,4 @@ export type * from './plugin';
 export type * from './selection';
 export type * from './shape';
 export type * from './state';
+export type * from './sync';

package/esm/editor/types/interaction.d.ts

@@ -3,6 +3,11 @@ import type { ICommandManager } from './command';
 import type { IEditor } from './editor';
 import type { Selection } from './selection';
 import type { IStateManager } from './state';
+/**
+ * Union type of common key codes, using (string & {}) trick to provide completion suggestions without limiting specific strings
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values
+ */
+export type KeyCode = 'Space' | 'ShiftLeft' | 'ShiftRight' | 'ControlLeft' | 'ControlRight' | 'AltLeft' | 'AltRight' | 'MetaLeft' | 'MetaRight' | 'CapsLock' | 'Tab' | 'Enter' | 'Escape' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | `Key${string}` | `Digit${number}` | (string & {});
 export interface IInteraction {
     name: string;
     init(options: InteractionInitOptions): void;
@@ -17,6 +22,10 @@ export interface SelectionChangePayload {
     removed: Selection;
     mode: SelectMode;
 }
+export interface viewBoxChangePayload {
+    type: 'viewBox:change';
+    viewBox: string | undefined;
+}
 export interface IInteractionManager {
     isActive(): boolean;
     select(items: Selection, mode: SelectMode): void;

package/esm/editor/types/state.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedInfographicOptions } from '../../options';
+import type { ParsedInfographicOptions, UpdatableInfographicOptions } from '../../options';
 import type { Element, IEventEmitter, ItemDatum } from '../../types';
 import type { ICommandManager } from './command';
 import type { IEditor } from './editor';
@@ -21,7 +21,9 @@ export interface IStateManager {
     removeItemDatum(indexes: number[], count?: number): void;
     updateData(key: string, value: any): void;
     updateElement(element: Element, props: Partial<ElementProps>): void;
-    updateOptions(options: ParsedInfographicOptions): void;
+    updateOptions(options: UpdatableInfographicOptions, execOptions?: {
+        bubbleUp?: boolean;
+    }): void;
     getOptions(): ParsedInfographicOptions;
     destroy(): void;
 }

package/esm/editor/types/sync.d.ts

@@ -0,0 +1,27 @@
+import type { InfographicOptionPath } from '../../options';
+/**
+ * Sync callback
+ * @param newValue The new value after modification
+ * @param oldValue The old value before modification. Note: This value is undefined when triggered by parent path bubbling notification (i.e., listening to a non-leaf node).
+ */
+export type SyncHandler = (newValue: any, oldValue: any) => void;
+export interface ISyncRegistry {
+    /**
+     * Register synchronization logic
+     * @param path Configuration path, such as 'design.background'
+     * @param handler Sync callback
+     * @param options.immediate Whether to execute immediately (used for view initialization)
+     * @returns unregister function
+     */
+    register(path: InfographicOptionPath | (string & {}), handler: SyncHandler, options?: {
+        immediate?: boolean;
+    }): () => void;
+    /**
+     * Trigger synchronization (usually called by StateManager)
+     * @param path Configuration path
+     * @param newVal New value
+     * @param oldVal Old value
+     */
+    trigger(path: string, newVal: any, oldVal: any): void;
+    destroy(): void;
+}

package/esm/editor/types/sync.js

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

package/esm/editor/utils/data.js

@@ -4,8 +4,10 @@ import { getDatumByIndexes } from '../../utils/index.js';
  */
 export function getChildrenDataByIndexes(data, indexes) {
     if (indexes.length === 0)
-        return data.data;
+        return data.items;
     const datum = getDatumByIndexes(data, indexes);
+    if (datum == null)
+        return [];
     datum.children || (datum.children = []);
     return datum.children;
 }

package/esm/editor/utils/event.d.ts

@@ -1,3 +1,4 @@
 import { Element } from '../../types';
 export declare function getEventTarget(element: SVGElement | null): Element | null;
 export declare function getSelectableTarget(element: SVGElement | null): Element | null;
+export declare function isTextSelectionTarget(target: EventTarget | null): boolean;

package/esm/editor/utils/event.js

@@ -62,3 +62,11 @@ const getIconEventTarget = (element) => {
     }
     return null;
 };
+export function isTextSelectionTarget(target) {
+    if (!(target instanceof HTMLElement))
+        return false;
+    if (target.isContentEditable)
+        return true;
+    const tag = target.tagName.toLowerCase();
+    return tag === 'input' || tag === 'textarea';
+}

package/esm/editor/utils/index.d.ts

@@ -5,3 +5,4 @@ export * from './element';
 export * from './event';
 export * from './extension';
 export * from './hotkey';
+export * from './object';

package/esm/editor/utils/index.js

@@ -5,3 +5,4 @@ export * from './element.js';
 export * from './event.js';
 export * from './extension.js';
 export * from './hotkey.js';
+export * from './object.js';

package/esm/editor/utils/object.d.ts

@@ -0,0 +1,15 @@
+export interface ApplyOptionUpdatesOptions {
+    /** Whether to notify parent paths of changes (bubbling) */
+    bubbleUp?: boolean;
+    /** Callback triggered whenever a property value changes */
+    collector?: (path: string, newVal: any, oldVal: any) => void;
+}
+/**
+ * Recursively applies properties from 'source' to 'target' and collects changes.
+ *
+ * @param target - The object to be updated
+ * @param source - The source object containing partial updates
+ * @param basePath - Current path prefix for nested properties
+ * @param options - Configuration options
+ */
+export declare function applyOptionUpdates(target: any, source: any, basePath?: string, options?: ApplyOptionUpdatesOptions): void;

package/esm/editor/utils/object.js

@@ -0,0 +1,77 @@
+import { cloneDeep, isEqual, isPlainObject } from 'lodash-es';
+/**
+ * Recursively applies properties from 'source' to 'target' and collects changes.
+ *
+ * @param target - The object to be updated
+ * @param source - The source object containing partial updates
+ * @param basePath - Current path prefix for nested properties
+ * @param options - Configuration options
+ */
+export function applyOptionUpdates(target, source, basePath = '', options) {
+    const { bubbleUp = false, collector } = options !== null && options !== void 0 ? options : {};
+    const hasChange = applyOptionUpdatesInternal(target, source, basePath, collector, bubbleUp);
+    if (basePath === '' && hasChange && bubbleUp && collector) {
+        collector('', cloneDeep(target), undefined);
+    }
+}
+/**
+ * Internal recursive function.
+ * Returns true if any change occurred within this branch (or its children).
+ */
+function applyOptionUpdatesInternal(target, source, basePath, collector, bubbleUp) {
+    let hasChange = false;
+    Object.keys(source).forEach((key) => {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return;
+        }
+        const fullPath = basePath ? `${basePath}.${key}` : key;
+        const updateValue = source[key];
+        const oldValue = target[key];
+        let childChanged = false;
+        if (updateValue === undefined) {
+            // Handle deletion: Only delete and notify if the key actually exists
+            if (key in target) {
+                delete target[key];
+                collector === null || collector === void 0 ? void 0 : collector(fullPath, undefined, oldValue);
+                childChanged = true;
+            }
+        }
+        else if (isPlainObject(updateValue)) {
+            // Handle nested object
+            const oldValueIsObject = isPlainObject(target[key]);
+            if (!oldValueIsObject) {
+                target[key] = {};
+            }
+            const grandChildChanged = applyOptionUpdatesInternal(target[key], updateValue, fullPath, collector, bubbleUp);
+            if (!oldValueIsObject) {
+                // Overwriting a primitive with an object is always a change.
+                childChanged = true;
+                // If the object was empty (grandChildChanged is false), we still need to report it.
+                if (!grandChildChanged) {
+                    collector === null || collector === void 0 ? void 0 : collector(fullPath, target[key], oldValue);
+                }
+            }
+            else {
+                childChanged = grandChildChanged;
+            }
+        }
+        else {
+            // Handle primitive update
+            target[key] = updateValue;
+            if (!isEqual(updateValue, oldValue)) {
+                collector === null || collector === void 0 ? void 0 : collector(fullPath, updateValue, oldValue);
+                childChanged = true;
+            }
+        }
+        if (childChanged) {
+            hasChange = true;
+        }
+    });
+    // Bubbling: Notify if any child changed in this branch
+    // The recursion naturally ensures this happens in "deepest-first" (post-order) sequence.
+    if (hasChange && bubbleUp && basePath !== '') {
+        // Current target is now fully updated for this scope.
+        collector === null || collector === void 0 ? void 0 : collector(basePath, cloneDeep(target), undefined);
+    }
+    return hasChange;
+}

package/esm/index.d.ts

@@ -1,7 +1,8 @@
 export * from './designs';
 export { getItemProps, getThemeColors } from './designs/utils';
-export { BrushSelect, ClickSelect, DblClickEditText, DragElement, HotkeyHistory, Interaction, SelectHighlight, ZoomWheel, } from './editor/interactions';
-export { EditBar, Plugin, ResizeElement } from './editor/plugins';
+export { BatchCommand, UpdateElementCommand, UpdateOptionsCommand, UpdateTextCommand, } from './editor/commands';
+export { BrushSelect, ClickSelect, DblClickEditText, DragCanvas, DragElement, HotkeyHistory, Interaction, SelectHighlight, ZoomWheel, } from './editor/interactions';
+export { EditBar, Plugin, ResetViewBox, ResizeElement } from './editor/plugins';
 export { exportToSVG } from './exporter';
 export { Defs, Ellipse, Fragment, Group, Path, Polygon, Rect, Text, cloneElement, createFragment, createLayout, getCombinedBounds, getElementBounds, getElementsBounds, jsx, jsxDEV, jsxs, renderSVG, } from './jsx';
 export { getFont, getFonts, getPalette, getPaletteColor, getPalettes, registerFont, registerPalette, registerPattern, setDefaultFont, } from './renderer';
@@ -12,7 +13,7 @@ export { getTemplate, getTemplates, registerTemplate } from './templates';
 export { getTheme, getThemes, registerTheme } from './themes';
 export { parseSVG, setFontExtendFactor } from './utils';
 export { VERSION } from './version';
-export type { EditBarOptions } from './editor';
+export type { EditBarOptions, ICommand, ICommandManager, IEditor, IInteraction, IInteractionManager, IPlugin, IPluginManager, IStateManager, ISyncRegistry, InteractionInitOptions, KeyCode, PluginInitOptions, SelectMode, Selection, SyncHandler, } from './editor';
 export type { ExportOptions, PNGExportOptions, SVGExportOptions, } from './exporter';
 export type { Bounds, ComponentType, DefsProps, EllipseProps, FragmentProps, GroupProps, JSXElement, JSXElementConstructor, JSXNode, PathProps, Point, PolygonProps, RectProps, RenderableNode, SVGAttributes, SVGProps, TextProps, WithChildren, } from './jsx';
 export type { InfographicOptions, ParsedInfographicOptions } from './options';

package/esm/index.js

@@ -1,7 +1,8 @@
 export * from './designs/index.js';
 export { getItemProps, getThemeColors } from './designs/utils/index.js';
-export { BrushSelect, ClickSelect, DblClickEditText, DragElement, HotkeyHistory, Interaction, SelectHighlight, ZoomWheel, } from './editor/interactions/index.js';
-export { EditBar, Plugin, ResizeElement } from './editor/plugins/index.js';
+export { BatchCommand, UpdateElementCommand, UpdateOptionsCommand, UpdateTextCommand, } from './editor/commands/index.js';
+export { BrushSelect, ClickSelect, DblClickEditText, DragCanvas, DragElement, HotkeyHistory, Interaction, SelectHighlight, ZoomWheel, } from './editor/interactions/index.js';
+export { EditBar, Plugin, ResetViewBox, ResizeElement } from './editor/plugins/index.js';
 export { exportToSVG } from './exporter/index.js';
 export { Defs, Ellipse, Fragment, Group, Path, Polygon, Rect, Text, cloneElement, createFragment, createLayout, getCombinedBounds, getElementBounds, getElementsBounds, jsx, jsxDEV, jsxs, renderSVG, } from './jsx/index.js';
 export { getFont, getFonts, getPalette, getPaletteColor, getPalettes, registerFont, registerPalette, registerPattern, setDefaultFont, } from './renderer/index.js';

package/esm/options/types.d.ts

@@ -2,6 +2,7 @@ import type { DesignOptions, ParsedDesignsOptions } from '../designs';
 import type { ElementProps, IInteraction, IPlugin } from '../editor';
 import type { ThemeConfig } from '../themes';
 import type { Data, Padding, ParsedData } from '../types';
+import type { Path } from '../utils';
 export interface InfographicOptions {
     /** 容器，可以是选择器或者 HTMLElement */
     container?: string | HTMLElement;
@@ -49,6 +50,7 @@ export interface ParsedInfographicOptions {
     interactions?: IInteraction[];
     shapes?: ElementProps[];
 }
+export type UpdatableInfographicOptions = Partial<Omit<ParsedInfographicOptions, 'container'>>;
 interface SVGOptions {
     style?: Record<string, string | number>;
     attributes?: Record<string, string | number | boolean>;
@@ -57,4 +59,9 @@ interface SVGOptions {
     /** 是否启用背景 */
     background?: boolean;
 }
+/**
+ * All valid property paths for Infographic Options.
+ * Use this to validate paths in SyncRegistry and other places.
+ */
+export type InfographicOptionPath = Path<UpdatableInfographicOptions>;
 export {};

package/esm/runtime/Infographic.js

@@ -13,7 +13,7 @@ import { Editor } from '../editor/index.js';
 import { exportToPNGString, exportToSVGString, } from '../exporter/index.js';
 import { renderSVG } from '../jsx/index.js';
 import { parseOptions, } from '../options/index.js';
-import { Renderer } from '../renderer/index.js';
+import { DEFAULT_FONT, Renderer, setDefaultFont } from '../renderer/index.js';
 import { waitForSvgLoads } from '../resource/index.js';
 import { parseSyntax } from '../syntax/index.js';
 import { getTypes, parseSVG } from '../utils/index.js';
@@ -99,18 +99,31 @@ export class Infographic {
      * Compose the SVG template
      */
     compose(parsedOptions) {
-        const { design, data } = parsedOptions;
+        var _a, _b;
+        const { design, data, themeConfig } = parsedOptions;
         const { title, item, items, structure } = design;
         const { component: Structure, props: structureProps } = structure;
         const Title = title.component;
         const Item = item.component;
         const Items = items.map((it) => it.component);
-        const svg = renderSVG(_jsx(Structure, Object.assign({ data: data, Title: Title, Item: Item, Items: Items, options: parsedOptions }, structureProps)));
-        const template = parseSVG(svg);
-        if (!template) {
-            throw new Error('Failed to parse SVG template');
+        // Apply theme font-family before measurement so measureText uses the correct font
+        const themeFontFamily = (_b = (_a = themeConfig === null || themeConfig === void 0 ? void 0 : themeConfig.base) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b['font-family'];
+        const previousDefaultFont = DEFAULT_FONT;
+        if (themeFontFamily)
+            setDefaultFont(themeFontFamily);
+        try {
+            const svg = renderSVG(_jsx(Structure, Object.assign({ data: data, Title: Title, Item: Item, Items: Items, options: parsedOptions }, structureProps)));
+            const template = parseSVG(svg);
+            if (!template) {
+                throw new Error('Failed to parse SVG template');
+            }
+            return template;
+        }
+        finally {
+            // Restore previous default font
+            if (themeFontFamily)
+                setDefaultFont(previousDefaultFont);
         }
-        return template;
     }
     getTypes() {
         const parsedOptions = this.parsedOptions;

package/esm/runtime/options.js

@@ -1,6 +1,11 @@
-import { BrushSelect, ClickSelect, DblClickEditText, DragElement, EditBar, HotkeyHistory, ResizeElement, SelectHighlight, ZoomWheel, } from '../editor/index.js';
-const createDefaultPlugins = () => [new EditBar(), new ResizeElement()];
+import { BrushSelect, ClickSelect, DblClickEditText, DragCanvas, DragElement, EditBar, HotkeyHistory, ResetViewBox, ResizeElement, SelectHighlight, ZoomWheel, } from '../editor/index.js';
+const createDefaultPlugins = () => [
+    new EditBar(),
+    new ResizeElement(),
+    new ResetViewBox(),
+];
 const createDefaultInteractions = () => [
+    new DragCanvas(),
     new DblClickEditText(),
     new BrushSelect(),
     new ClickSelect(),

package/esm/syntax/index.js

@@ -111,27 +111,47 @@ export function parseSyntax(input) {
             const parsed = parseRelationsNode(relationsNode, errors, 'data.relations');
             if (parsed.relations.length > 0 || parsed.items.length > 0) {
                 const current = ((_a = options.data) !== null && _a !== void 0 ? _a : {});
-                const existingItems = Array.isArray(current.items)
-                    ? current.items
-                    : [];
-                const normalizedItems = normalizeItems(existingItems);
-                const itemMap = new Map();
-                normalizedItems.forEach((item) => {
-                    if (item.id)
-                        itemMap.set(item.id, item);
-                });
-                parsed.items.forEach((item) => {
-                    const existing = itemMap.get(item.id);
-                    if (existing) {
-                        if (!existing.label && item.label)
-                            existing.label = item.label;
+                // 优先使用已存在的数据列表 (sequences, lists, etc.)
+                const dataKeys = Object.keys(DataSchema.fields).filter((key) => key !== 'items' && key !== 'relations');
+                let hasStructuredData = false;
+                // 尝试找到一个非空的数据源
+                for (const key of dataKeys) {
+                    if (Array.isArray(current[key]) && current[key].length > 0) {
+                        hasStructuredData = true;
+                        break;
                     }
-                    else {
-                        normalizedItems.push(item);
-                        itemMap.set(item.id, item);
-                    }
-                });
-                current.items = normalizedItems;
+                }
+                // 如果 items 已包含层级结构数据（带 children），也视为结构化数据
+                if (!hasStructuredData &&
+                    Array.isArray(current.items) &&
+                    current.items.length > 0 &&
+                    current.items.some((item) => Array.isArray(item.children) && item.children.length > 0)) {
+                    hasStructuredData = true;
+                }
+                // 如果没有找到其他数据源，才尝试合并 items
+                if (!hasStructuredData) {
+                    const existingItems = Array.isArray(current.items)
+                        ? current.items
+                        : [];
+                    const normalizedItems = normalizeItems(existingItems);
+                    const itemMap = new Map();
+                    normalizedItems.forEach((item) => {
+                        if (item.id)
+                            itemMap.set(item.id, item);
+                    });
+                    parsed.items.forEach((item) => {
+                        const existing = itemMap.get(item.id);
+                        if (existing) {
+                            if (!existing.label && item.label)
+                                existing.label = item.label;
+                        }
+                        else {
+                            normalizedItems.push(item);
+                            itemMap.set(item.id, item);
+                        }
+                    });
+                    current.items = normalizedItems;
+                }
                 current.relations = parsed.relations;
                 options.data = current;
             }