@formicoidea/labre-core 0.23.3 → 0.24.0

package/dist/_pkgs/affine-gfx-mindmap/toolbar/mindmap-tool-button.d.ts

@@ -16,7 +16,9 @@ export declare class EdgelessMindmapToolButton extends EdgelessMindmapToolButton
     initDragController(): void;
     render(): import("lit-html").TemplateResult<1>;
     updated(_changedProperties: Map<PropertyKey, unknown>): void;
-    accessor enableBlur: boolean;
+    /** `'mindmap'` → the dedicated Mind Map button; `'other'` → free-text +
+     * add-file ("Others"). Drives the tools, tooltip, `m` shortcut and menu. */
+    accessor variant: 'mindmap' | 'other';
     accessor mindmapElement: HTMLElement;
     accessor readyToDrop: boolean;
 }

package/dist/_pkgs/affine-gfx-mindmap/toolbar/mindmap-tool-button.js

@@ -35,7 +35,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 import { DefaultTool, EdgelessCRUDIdentifier, } from '../../affine-block-surface/index.js';
 import { EmptyTool } from '../../affine-gfx-pointer/index.js';
 import { TextTool } from '../../affine-gfx-text/index.js';
-import { EditPropsStore, ThemeProvider, ViewportElementProvider, } from '../../affine-shared/services/index.js';
+import { EditPropsStore, ViewportElementProvider, } from '../../affine-shared/services/index.js';
 import { EdgelessDraggableElementController, EdgelessToolbarToolMixin, } from '../../affine-widget-edgeless-toolbar/index.js';
 import { SignalWatcher } from '../../global/lit/index.js';
 import { computed } from '@preact/signals-core';
@@ -46,13 +46,13 @@ import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { getMindMaps } from './assets.js';
 import { getMindmapRender, mediaConfig, mediaRender, mindmapConfig, textConfig, textRender, toolConfig2StyleObj, } from './basket-elements.js';
-import { basketIconDark, basketIconLight, mindmapMenuMediaIcon, textIcon, } from './icons.js';
+import { mindmapMenuMediaIcon, textIcon } from './icons.js';
 import { importMindmap } from './utils/import-mindmap.js';
 let EdgelessMindmapToolButton = (() => {
     let _classSuper = EdgelessToolbarToolMixin(SignalWatcher(LitElement));
-    let _enableBlur_decorators;
-    let _enableBlur_initializers = [];
-    let _enableBlur_extraInitializers = [];
+    let _variant_decorators;
+    let _variant_initializers = [];
+    let _variant_extraInitializers = [];
     let _mindmapElement_decorators;
     let _mindmapElement_initializers = [];
     let _mindmapElement_extraInitializers = [];
@@ -62,10 +62,10 @@ let EdgelessMindmapToolButton = (() => {
     return class EdgelessMindmapToolButton extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _enableBlur_decorators = [property({ type: Boolean })];
+            _variant_decorators = [property({ attribute: false })];
             _mindmapElement_decorators = [query('.basket-tool-item.mindmap')];
             _readyToDrop_decorators = [state()];
-            __esDecorate(this, null, _enableBlur_decorators, { kind: "accessor", name: "enableBlur", static: false, private: false, access: { has: obj => "enableBlur" in obj, get: obj => obj.enableBlur, set: (obj, value) => { obj.enableBlur = value; } }, metadata: _metadata }, _enableBlur_initializers, _enableBlur_extraInitializers);
+            __esDecorate(this, null, _variant_decorators, { kind: "accessor", name: "variant", static: false, private: false, access: { has: obj => "variant" in obj, get: obj => obj.variant, set: (obj, value) => { obj.variant = value; } }, metadata: _metadata }, _variant_initializers, _variant_extraInitializers);
             __esDecorate(this, null, _mindmapElement_decorators, { kind: "accessor", name: "mindmapElement", static: false, private: false, access: { has: obj => "mindmapElement" in obj, get: obj => obj.mindmapElement, set: (obj, value) => { obj.mindmapElement = value; } }, metadata: _metadata }, _mindmapElement_initializers, _mindmapElement_extraInitializers);
             __esDecorate(this, null, _readyToDrop_decorators, { kind: "accessor", name: "readyToDrop", static: false, private: false, access: { has: obj => "readyToDrop" in obj, get: obj => obj.readyToDrop, set: (obj, value) => { obj.readyToDrop = value; } }, metadata: _metadata }, _readyToDrop_initializers, _readyToDrop_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -77,6 +77,11 @@ let EdgelessMindmapToolButton = (() => {
       display: flex;
       justify-content: center;
       align-items: center;
+      /* Make this button the containing block of the popup's clip wrapper so
+         the "Others" sub-menu anchors to THIS button (not the whole toolbar)
+         and can be right-aligned to it — mirrors the framework senior buttons.
+         Without this the menu drifts when senior buttons are hidden. */
+      position: relative;
     }
     .partial-clip {
       flex-shrink: 0;
@@ -86,88 +91,57 @@ let EdgelessMindmapToolButton = (() => {
       padding: 0 10px;
       overflow: hidden;
     }
+    /* Icons sit centered in the slot — no basket tray. */
     .basket-wrapper {
       pointer-events: auto;
       height: 64px;
       width: 96px;
       display: flex;
       justify-content: center;
-      align-items: flex-end;
+      align-items: center;
+      gap: 4px;
       position: relative;
     }
-    .basket,
-    .basket-tool-item {
-      transition: transform 0.3s ease-in-out;
-      position: absolute;
-    }
-
-    .basket {
-      bottom: 0;
-      height: 17px;
-      width: 76px;
-    }
-    .basket > div,
-    .basket > svg {
-      position: absolute;
-    }
-    .glass {
-      width: 76px;
-      height: 17px;
-      border-radius: 2px;
-      mask: url(#mindmap-basket-body-mask);
-    }
-    .glass.enabled {
-      backdrop-filter: blur(2px);
-    }
-    @-moz-document url-prefix() {
-      .glass.enabled {
-        backdrop-filter: none;
-      }
-    }
-
-    .basket {
-      z-index: 3;
-    }
     .basket-tool-item {
+      position: relative;
       cursor: grab;
+      transition: transform 0.3s ease-in-out;
     }
     .basket-tool-item svg {
       display: block;
+      max-width: 46px;
+      max-height: 46px;
+      width: auto;
+      height: auto;
     }
-    .basket-tool-item {
-      transform: translate(var(--default-x, 0), var(--default-y, 0))
-        rotate(var(--default-r, 0)) scale(var(--default-s, 1));
-      z-index: var(--default-z, 0);
-    }
-
+    /* the drag clone flies in/out using its captured offsets */
     .basket-tool-item.next {
+      position: absolute;
       transform: translate(var(--next-x, 0), var(--next-y, 0))
         rotate(var(--next-r, 0)) scale(var(--next-s, 1));
       z-index: var(--next-z, 0);
     }
-
-    /* active & hover */
-    .basket-wrapper:hover .basket,
-    .basket-wrapper.active .basket {
-      z-index: 0;
-    }
     .basket-wrapper:hover .basket-tool-item.current,
     .basket-wrapper.active .basket-tool-item.current {
-      transform: translate(var(--active-x, 0), var(--active-y, 0))
-        rotate(var(--active-r, 0)) scale(var(--active-s, 1));
-      z-index: var(--active-z, 0);
-    }
-
-    .basket-tool-item.next.coming,
-    .basket-wrapper:hover .basket-tool-item.current:hover {
-      transform: translate(var(--hover-x, 0), var(--hover-y, 0))
-        rotate(var(--hover-r, 0)) scale(var(--hover-s, 1));
-      z-index: var(--hover-z, 0);
+      transform: translateY(-6px) scale(1.06);
     }
   `; }
         get draggableTools() {
-            const style = this._style$.value;
-            const mindmap = this.mindmaps.find(m => m.style === style) || this.mindmaps[0];
+            // The dedicated "Mind Map" button carries only the mindmap tool; the
+            // "Others" button keeps free-text + add-file.
+            if (this.variant === 'mindmap') {
+                const style = this._style$.value;
+                const mindmap = this.mindmaps.find(m => m.style === style) || this.mindmaps[0];
+                return [
+                    {
+                        name: 'mindmap',
+                        icon: mindmap.icon,
+                        config: mindmapConfig,
+                        standardWidth: 350,
+                        render: getMindmapRender(style),
+                    },
+                ];
+            }
             return [
                 {
                     name: 'media',
@@ -183,13 +157,6 @@ let EdgelessMindmapToolButton = (() => {
                     standardWidth: 100,
                     render: textRender,
                 },
-                {
-                    name: 'mindmap',
-                    icon: mindmap.icon,
-                    config: mindmapConfig,
-                    standardWidth: 350,
-                    render: getMindmapRender(style),
-                },
             ];
         }
         get mindmaps() {
@@ -205,6 +172,7 @@ let EdgelessMindmapToolButton = (() => {
             const menu = this.createPopper('edgeless-mindmap-menu', this);
             Object.assign(menu.element, {
                 edgeless: this.edgeless,
+                variant: this.variant,
                 onActiveStyleChange: (style) => {
                     this.edgeless.std.get(EditPropsStore).recordLastProps('mindmap', {
                         style,
@@ -228,6 +196,20 @@ let EdgelessMindmapToolButton = (() => {
                     });
                 },
             });
+            // Right-align the menu's right edge to this button's right edge, like the
+            // framework senior buttons. Stays correct however many buttons are hidden.
+            const el = menu.element;
+            const wrap = el.parentElement;
+            if (wrap) {
+                wrap.style.overflow = 'visible';
+                wrap.style.justifyContent = 'flex-end';
+            }
+            Object.assign(el.style, {
+                position: 'static',
+                width: 'max-content',
+                maxWidth: 'calc(100vw - 16px)',
+                marginLeft: '0',
+            });
         }
         initDragController() {
             if (!this.edgeless || !this.toolbarContainer)
@@ -291,38 +273,41 @@ let EdgelessMindmapToolButton = (() => {
                         .catch(console.error);
                 },
             });
-            this.edgeless.bindHotKey({
-                m: () => {
-                    const gfx = this.gfx;
-                    const locked = gfx.viewport.locked;
-                    if (locked)
-                        return;
-                    if (gfx.selection.editing)
-                        return;
-                    if (this.readyToDrop) {
-                        // change the style
-                        const activeIndex = this.mindmaps.findIndex(m => m.style === this._style$.value);
-                        const nextIndex = (activeIndex + 1) % this.mindmaps.length;
-                        const next = this.mindmaps[nextIndex];
-                        this.edgeless.std.get(EditPropsStore).recordLastProps('mindmap', {
-                            style: next.style,
-                        });
-                        const tool = this.draggableTools.find(t => t.name === 'mindmap');
-                        this.draggableController.updateElementInfo({
-                            data: tool,
-                            preview: next.icon,
-                        });
-                        return;
-                    }
-                    this.setEdgelessTool(EmptyTool);
-                    const icon = this.mindmapElement;
-                    const { x, y } = gfx.tool.lastMouseViewPos$.peek();
-                    const { viewport } = this.edgeless.std.get(ViewportElementProvider);
-                    const { left, top } = viewport;
-                    const clientPos = { x: x + left, y: y + top };
-                    this.draggableController.dragAndMoveTo(icon, clientPos);
-                },
-            }, { global: true });
+            // The `m` shortcut belongs to the dedicated Mind Map button only.
+            if (this.variant === 'mindmap') {
+                this.edgeless.bindHotKey({
+                    m: () => {
+                        const gfx = this.gfx;
+                        const locked = gfx.viewport.locked;
+                        if (locked)
+                            return;
+                        if (gfx.selection.editing)
+                            return;
+                        if (this.readyToDrop) {
+                            // change the style
+                            const activeIndex = this.mindmaps.findIndex(m => m.style === this._style$.value);
+                            const nextIndex = (activeIndex + 1) % this.mindmaps.length;
+                            const next = this.mindmaps[nextIndex];
+                            this.edgeless.std.get(EditPropsStore).recordLastProps('mindmap', {
+                                style: next.style,
+                            });
+                            const tool = this.draggableTools.find(t => t.name === 'mindmap');
+                            this.draggableController.updateElementInfo({
+                                data: tool,
+                                preview: next.icon,
+                            });
+                            return;
+                        }
+                        this.setEdgelessTool(EmptyTool);
+                        const icon = this.mindmapElement;
+                        const { x, y } = gfx.tool.lastMouseViewPos$.peek();
+                        const { viewport } = this.edgeless.std.get(ViewportElementProvider);
+                        const { left, top } = viewport;
+                        const clientPos = { x: x + left, y: y + top };
+                        this.draggableController.dragAndMoveTo(icon, clientPos);
+                    },
+                }, { global: true });
+            }
             // since there is not a tool called mindmap, we need to cancel the drag when the tool is changed
             this.disposables.add(this.gfx.tool.currentToolName$.subscribe(toolName => {
                 // FIXME: remove the assertion after gfx tool refactor
@@ -333,15 +318,12 @@ let EdgelessMindmapToolButton = (() => {
         }
         render() {
             const { popper } = this;
-            const appTheme = this.edgeless.std.get(ThemeProvider).app$.value;
-            const basketIcon = appTheme === 'light' ? basketIconLight : basketIconDark;
-            const glassBg = appTheme === 'light' ? 'rgba(255,255,255,0.5)' : 'rgba(74, 74, 74, 0.6)';
             const { cancelled, dragOut, draggingElement } = this.draggableController?.states || {};
             const active = popper || draggingElement;
             return html `<edgeless-toolbar-button
       class="edgeless-mindmap-button"
       ?withHover=${true}
-      .tooltip=${popper ? '' : 'Others'}
+      .tooltip=${popper ? '' : this.variant === 'mindmap' ? 'Mind Map' : 'Others'}
       .tooltipOffset=${4}
       @click=${this._toggleMenu}
       style="width: 100%; height: 100%; display: inline-block"
@@ -389,41 +371,8 @@ let EdgelessMindmapToolButton = (() => {
                   ${tool.icon}
                 </div>`;
             })}
-
-          <div class="basket">
-            <div
-              class="glass ${this.enableBlur ? 'enabled' : ''}"
-              style="background: ${glassBg}"
-            ></div>
-            ${basketIcon}
-          </div>
         </div>
       </div>
-
-      <svg width="0" height="0" style="opacity: 0; pointer-events: none">
-        <defs>
-          <mask id="mindmap-basket-body-mask">
-            <rect
-              x="2"
-              width="71.8"
-              y="2"
-              height="15"
-              rx="1.5"
-              ry="1.5"
-              fill="white"
-            />
-            <rect
-              width="32"
-              height="6"
-              x="22"
-              y="5.9"
-              fill="black"
-              rx="3"
-              ry="3"
-            />
-          </mask>
-        </defs>
-      </svg>
     </edgeless-toolbar-button>`;
         }
         updated(_changedProperties) {
@@ -433,9 +382,11 @@ let EdgelessMindmapToolButton = (() => {
                 this.initDragController();
             }
         }
-        #enableBlur_accessor_storage;
-        get enableBlur() { return this.#enableBlur_accessor_storage; }
-        set enableBlur(value) { this.#enableBlur_accessor_storage = value; }
+        #variant_accessor_storage;
+        /** `'mindmap'` → the dedicated Mind Map button; `'other'` → free-text +
+         * add-file ("Others"). Drives the tools, tooltip, `m` shortcut and menu. */
+        get variant() { return this.#variant_accessor_storage; }
+        set variant(value) { this.#variant_accessor_storage = value; }
         #mindmapElement_accessor_storage;
         get mindmapElement() { return this.#mindmapElement_accessor_storage; }
         set mindmapElement(value) { this.#mindmapElement_accessor_storage = value; }
@@ -450,8 +401,8 @@ let EdgelessMindmapToolButton = (() => {
             });
             this.enableActiveBackground = true;
             this.type = [EmptyTool, TextTool];
-            this.#enableBlur_accessor_storage = __runInitializers(this, _enableBlur_initializers, true);
-            this.#mindmapElement_accessor_storage = (__runInitializers(this, _enableBlur_extraInitializers), __runInitializers(this, _mindmapElement_initializers, void 0));
+            this.#variant_accessor_storage = __runInitializers(this, _variant_initializers, 'other');
+            this.#mindmapElement_accessor_storage = (__runInitializers(this, _variant_extraInitializers), __runInitializers(this, _mindmapElement_initializers, void 0));
             this.#readyToDrop_accessor_storage = (__runInitializers(this, _mindmapElement_extraInitializers), __runInitializers(this, _readyToDrop_initializers, false));
             __runInitializers(this, _readyToDrop_extraInitializers);
         }

package/dist/_pkgs/affine-gfx-mindmap/toolbar/senior-tool.d.ts

@@ -1 +1,3 @@
 export declare const mindMapSeniorTool: import("../../store/index.js").ExtensionType;
+/** The "Others" button: free-text + add-file (mindmap moved to its own tool). */
+export declare const otherSeniorTool: import("../../store/index.js").ExtensionType;

package/dist/_pkgs/affine-gfx-mindmap/toolbar/senior-tool.js

@@ -6,6 +6,18 @@ export const mindMapSeniorTool = SeniorToolExtension('mindMap', ({ block, toolba
         content: html `<edgeless-mindmap-tool-button
         .edgeless=${block}
         .toolbarContainer=${toolbarContainer}
+        .variant=${'mindmap'}
+      ></edgeless-mindmap-tool-button>`,
+    };
+});
+/** The "Others" button: free-text + add-file (mindmap moved to its own tool). */
+export const otherSeniorTool = SeniorToolExtension('other', ({ block, toolbarContainer }) => {
+    return {
+        name: 'Others',
+        content: html `<edgeless-mindmap-tool-button
+        .edgeless=${block}
+        .toolbarContainer=${toolbarContainer}
+        .variant=${'other'}
       ></edgeless-mindmap-tool-button>`,
     };
 });

package/dist/_pkgs/affine-gfx-mindmap/view.d.ts

@@ -1,6 +1,22 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '../affine-ext-loader/index.js';
-export declare class MindmapViewExtension extends ViewExtensionProvider {
+/**
+ * Mindmap rendering — ALWAYS registered, independent of any flag. Disabling the
+ * `mindmap` / `other` flags hides only their senior buttons (see below); placed
+ * mindmaps must still paint, stay editable, and Templates-panel insertion must
+ * still render them.
+ */
+export declare class MindmapRenderViewExtension extends ViewExtensionProvider {
     name: string;
     effect(): void;
     setup(context: ViewExtensionContext): void;
 }
+/** The dedicated "Mind Map" senior button — flag-gated (`mindmap`). */
+export declare class MindmapToolViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/** The "Others" senior button (free-text + add-file) — flag-gated (`other`). */
+export declare class OtherToolViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}

package/dist/_pkgs/affine-gfx-mindmap/view.js

@@ -1,24 +1,32 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
+import { extendTemplateCategory } from '../affine-gfx-template/index.js';
 import { effects } from './effects';
 import { MindmapElementRendererExtension } from './element-renderer';
 import { MindMapIndicatorOverlay } from './indicator-overlay';
 import { MindMapDragExtension } from './interactivity';
 import { mindmapToolbarExtension, shapeMindmapToolbarExtension, } from './toolbar/config';
-import { mindMapSeniorTool } from './toolbar/senior-tool';
+import { mindMapSeniorTool, otherSeniorTool } from './toolbar/senior-tool';
+import { mindmapTemplateCategory } from './templates';
 import { MindMapInteraction, MindMapView } from './view/view';
-export class MindmapViewExtension extends ViewExtensionProvider {
+/**
+ * Mindmap rendering — ALWAYS registered, independent of any flag. Disabling the
+ * `mindmap` / `other` flags hides only their senior buttons (see below); placed
+ * mindmaps must still paint, stay editable, and Templates-panel insertion must
+ * still render them.
+ */
+export class MindmapRenderViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
-        this.name = 'affine-mindmap-gfx';
+        this.name = 'affine-mindmap-render-gfx';
     }
     effect() {
         super.effect();
         effects();
+        extendTemplateCategory(mindmapTemplateCategory);
     }
     setup(context) {
         super.setup(context);
         context.register(MindmapElementRendererExtension);
-        context.register(mindMapSeniorTool);
         context.register(mindmapToolbarExtension);
         context.register(shapeMindmapToolbarExtension);
         context.register(MindMapView);
@@ -27,3 +35,29 @@ export class MindmapViewExtension extends ViewExtensionProvider {
         context.register(MindMapInteraction);
     }
 }
+/** The dedicated "Mind Map" senior button — flag-gated (`mindmap`). */
+export class MindmapToolViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-mindmap-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        if (this.isEdgeless(context.scope)) {
+            context.register(mindMapSeniorTool);
+        }
+    }
+}
+/** The "Others" senior button (free-text + add-file) — flag-gated (`other`). */
+export class OtherToolViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-other-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        if (this.isEdgeless(context.scope)) {
+            context.register(otherSeniorTool);
+        }
+    }
+}

package/dist/_pkgs/affine-gfx-template/services/template-middlewares.js

@@ -35,7 +35,7 @@ export const replaceIdMiddleware = (job) => {
                 regeneratedIdMap.set(id, newId);
                 val.id = newId;
                 elements[newId] = val;
-                if (['connector', 'group'].includes(val['type'])) {
+                if (['connector', 'group', 'mindmap'].includes(val['type'])) {
                     defered.push(newId);
                 }
             });
@@ -73,6 +73,21 @@ export const replaceIdMiddleware = (job) => {
                             }
                         }
                         break;
+                    case 'mindmap':
+                        {
+                            const children = element['children'];
+                            const newJson = {};
+                            Object.entries(children.json).forEach(([key, val]) => {
+                                const newVal = { ...val };
+                                if (newVal.parent) {
+                                    newVal.parent =
+                                        regeneratedIdMap.get(newVal.parent) ?? newVal.parent;
+                                }
+                                newJson[regeneratedIdMap.get(key) ?? key] = newVal;
+                            });
+                            children.json = newJson;
+                        }
+                        break;
                 }
             });
             blockJson.props.elements = elements;

package/dist/_pkgs/affine-model/elements/core-domain/core-domain.d.ts

@@ -0,0 +1,36 @@
+import type { IVec, SerializedXYWH } from '../../../global/gfx/index.js';
+import { Bound } from '../../../global/gfx/index.js';
+import type { BaseElementProps } from '../../../std/gfx/index.js';
+import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+export type CoreDomainChartProps = BaseElementProps & {
+    /** When false the resize handles are hidden — toggled from the toolbar. */
+    resizeEnabled?: boolean;
+    /** When false the translucent Core / Supporting / Generic zone bands are hidden. */
+    showZones?: boolean;
+    /** When false the axis titles, Low/High ticks and zone names are hidden. */
+    showLabels?: boolean;
+};
+/**
+ * The Core Domain Chart background (DDD Crew): the two axes (Complexity ×
+ * Business differentiation) with their Low/High ticks and the translucent
+ * Generic / Supporting / Core zone bands. The user places sub-domain dots,
+ * movement arrows and the Notation legend on top of it.
+ *
+ * Mirrors the Wardley / EDGY / Cynefin backgrounds: extends
+ * {@link GfxPrimitiveElementModel} so it inherits selection, move, copy/paste,
+ * duplicate, align and undo/redo. Authored in a fixed reference space and scaled
+ * uniformly to the element bounds by the renderer.
+ */
+export declare class CoreDomainChartElementModel extends GfxPrimitiveElementModel<CoreDomainChartProps> {
+    get type(): string;
+    get connectable(): boolean;
+    containsBound(bounds: Bound): boolean;
+    getLineIntersections(start: IVec, end: IVec): import("../../../global/gfx/index.js").PointLocation[] | null;
+    getNearestPoint(point: IVec): IVec;
+    includesPoint(x: number, y: number): boolean;
+    accessor resizeEnabled: boolean;
+    accessor showZones: boolean;
+    accessor showLabels: boolean;
+    accessor rotate: number;
+    accessor xywh: SerializedXYWH;
+}