@vectoriox/iox-builder 4.0.0 → 4.1.1

package/index.d.ts

@@ -585,7 +585,9 @@ declare enum ToolbarAction {
     Copy = "copy",
     Paste = "paste",
     AddSlide = "add-slide",
-    Wrap = "wrap"
+    Wrap = "wrap",
+    /** Open the components panel to insert into / after the selection (B2 quick-add). */
+    AddElement = "add-element"
 }
 declare enum NodeAction {
     Delete = "delete",
@@ -739,7 +741,11 @@ declare enum PanelEventTypes {
      *  Repeater/Slider listen so their PREVIEW CLONES are re-cloned with the new interactions —
      *  clones are attached by ELEMENT at render time, so without this a new interaction only starts
      *  working after a save + reload. */
-    INTERACTION_CHANGED = "interactionchanged"
+    INTERACTION_CHANGED = "interactionchanged",
+    /** CLICK-TO-INSERT (B2): a components-panel entry was clicked. Carries the same payload a drag
+     *  would (`string` component type, or a block / symbol object). The builder resolves WHERE from
+     *  the current selection — see `resolveInsertTarget`. */
+    INSERT_COMPONENT = "insertcomponent"
 }
 interface PanelEvent {
     type: PanelEventTypes;
@@ -813,6 +819,27 @@ declare class DragEngineService {
     private overlayService;
     constructor(registry: ComponentRegistryService, symbolRegistry: SymbolRegistryService, overlayService: OverlayService);
     handleDrop(children: ComponentNode[], event: IoxDropEvent, dropListId: string, cdr: ChangeDetectorRef, afterDrop?: () => void): void;
+    /**
+     * Turn a components-panel payload into a fresh ComponentNode: a built-in type string via the
+     * registry, or a block / symbol / bare node deep-cloned with fresh ids (so each copy owns its
+     * CSS rules and its intra-subtree references stay self-consistent). Prefers `symbol.node`
+     * (always current) over a block's original snapshot.
+     *
+     * The ONE place a panel payload becomes a node — drag-drop and click-to-insert both use it, so
+     * a clicked element is identical to a dragged one.
+     */
+    materialize(data: unknown): ComponentNode | null;
+    /**
+     * CLICK-TO-INSERT (B2): place a panel payload at a resolved target without a drag. Emits
+     * `dropComplete$` exactly like a drop, so the builder selects the new node and records one undo
+     * step through the same path. Returns the inserted node, or null if the payload was unusable.
+     */
+    insertPayload(children: ComponentNode[], index: number, data: unknown): ComponentNode | null;
+    /** True when `children` is a registered drop zone's array — i.e. a real container that can hold
+     *  children. Click-to-insert uses the same test a drag does, so it can't insert where a drop
+     *  couldn't. */
+    isDropContainer(children: unknown): boolean;
+    private cdrForData;
     private ids;
     private elMap;
     private dataMap;
@@ -846,6 +873,7 @@ declare class DragEngineService {
     private _deepTargetId;
     /** Injected overlay div marking the active drop target. */
     private _targetOverlay;
+    private _targetChip;
     private _indicator;
     private _indicatorContainerId;
     private _indicatorIndex;
@@ -890,6 +918,8 @@ declare class DragEngineService {
     refreshDragOverlays(): void;
     private _moveTargetOverlay;
     private _removeTargetOverlay;
+    /** Name the drop target and the slot: "into Card grid · position 2 of 4". */
+    private _updateTargetChip;
     private _isRootContainer;
     /**
      * Returns true if the dropzone with `childId` is a DOM descendant of the
@@ -1590,8 +1620,19 @@ declare class BuilderComponent implements OnInit, AfterViewInit, OnChanges, OnDe
      *  a structural change (e.g. wrapping a template child) propagates to every repeated row. No-op
      *  when the node is not inside a repeater. */
     private _refreshRepeaterFor;
-    /** Emit ELEMENT_SELECT with the ancestors the panels need (symbol + repeater item scope). */
+    /**
+     * Emit ELEMENT_SELECT with the ancestors the panels need (symbol + repeater item scope).
+     * THE place the builder's own selection is set too — every path that announces a selection goes
+     * through here, so `selectedItem` (breadcrumb, click-to-insert target) can't drift from what the
+     * panels show. "Select parent" used to announce the parent while leaving selectedItem behind.
+     */
     private _emitElementSelect;
+    /**
+     * Insert a components-panel payload at the position the SELECTION implies (B2):
+     * nothing selected → end of the page; a container → inside it; a leaf → right after it.
+     * `dropComplete$` then selects the new node and records the undo step, exactly as a drop does.
+     */
+    insertFromPanel(data: unknown): void;
     private refreshBreakpointCounts;
     /** Read a node's current `display` value. The style panel mutates `styleTraits` in place at edit
      *  time, so that is the live source of truth; fall back to a preset's `styleOverrides` map, then
@@ -1793,6 +1834,9 @@ declare class OverlayComponent implements OnInit, OnDestroy {
     ngOnInit(): void;
     ngOnDestroy(): void;
     onSelectParent(event: MouseEvent): void;
+    /** Quick-add (B2): open the components panel. The new element lands inside this node when it is
+     *  a container, otherwise right after it. */
+    onAddElement(event: MouseEvent): void;
     onDuplicate(event: MouseEvent): void;
     onDelete(event: MouseEvent): void;
     onWrap(event: MouseEvent, wrapType: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectoriox/iox-builder",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "peerDependencies": {
     "@angular/common": ">=20.0.0",
     "@angular/core": ">=20.0.0",