@craftile/core 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftile/core",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Framework-agnostic block editor engine for Craftile",
   "keywords": [
     "craftile",
@@ -26,8 +26,8 @@
     "src"
   ],
   "dependencies": {
-    "@craftile/event-bus": "1.0.3",
-    "@craftile/types": "1.0.3"
+    "@craftile/event-bus": "1.0.4",
+    "@craftile/types": "1.0.4"
   },
   "devDependencies": {
     "vitest": "^3.2.4",

package/src/commands/insert-block-from-preset.ts

@@ -1,7 +1,6 @@
 import type { Block, BlockProperties, BlockSchema, BlockStructure, Page } from '@craftile/types';
-import { getRegionId } from '../utils';
+import { generateId, getRegionId, resolveInsertTarget } from '../utils';
 import type { Command, EngineEmitFn } from '../types';
-import { generateId } from '../utils';
 import type { BlocksManager } from '../blocks-manager';
 
 export interface InsertBlockFromPresetOptions {
@@ -69,10 +68,11 @@ export class InsertBlockFromPresetCommand implements Command {
   }
 
   apply(): void {
+    const target = resolveInsertTarget(this.page, this.parentId, this.regionId, this.index);
+
     const blockSchema = this.blocksManager.get(this.blockType);
 
     if (this.presetData) {
-      // Handle BlockStructure (paste operation)
       this.insertedBlock = {
         type: this.blockType,
         id: this.blockId,
@@ -94,7 +94,6 @@ export class InsertBlockFromPresetCommand implements Command {
         this.insertedBlock.children = this.createChildrenFromPreset(this.presetData.children, this.blockId);
       }
     } else if (this.presetIndex !== undefined) {
-      // Handle BlockPreset from schema (preset insertion)
       const preset = blockSchema?.presets?.[this.presetIndex];
       if (!preset) {
         throw new Error(`Preset at index ${this.presetIndex} not found`);
@@ -121,40 +120,18 @@ export class InsertBlockFromPresetCommand implements Command {
       throw new Error('Failed to create block');
     }
 
-    // Insert the root block in the appropriate location
-    if (this.parentId) {
-      const parent = this.page.blocks[this.parentId];
-
-      if (!parent) {
-        throw new Error(`Parent block not found: ${this.parentId}`);
-      }
-
-      this.insertedBlock.parentId = parent.id;
+    this.actualIndex = target.index;
 
-      if (this.index !== undefined && this.index >= 0 && this.index <= parent.children.length) {
-        parent.children.splice(this.index, 0, this.blockId);
-        this.actualIndex = this.index;
-      } else {
-        parent.children.push(this.blockId);
-        this.actualIndex = parent.children.length - 1;
-      }
+    if (target.kind === 'parent') {
+      this.insertedBlock.parentId = target.parent.id;
+      target.parent.children.splice(target.index, 0, this.blockId);
     } else {
-      // Insert as top-level block
-      const targetRegionId = this.regionId || getRegionId(this.page.regions[0]);
-      let targetRegion = this.page.regions.find((r) => getRegionId(r) === targetRegionId);
-
-      if (!targetRegion) {
-        targetRegion = { id: targetRegionId, name: targetRegionId, blocks: [] };
-        this.page.regions.push(targetRegion);
-      }
-
-      if (this.index !== undefined && this.index >= 0 && this.index <= targetRegion.blocks.length) {
-        targetRegion.blocks.splice(this.index, 0, this.blockId);
-        this.actualIndex = this.index;
-      } else {
-        targetRegion.blocks.push(this.blockId);
-        this.actualIndex = targetRegion.blocks.length - 1;
+      let region = this.page.regions.find((r) => getRegionId(r) === target.regionId);
+      if (!region) {
+        region = { id: target.regionId, name: target.regionId, blocks: [] };
+        this.page.regions.push(region);
       }
+      region.blocks.splice(target.index, 0, this.blockId);
     }
 
     this.emit('block:insert', {

package/src/commands/insert-block.ts

@@ -1,7 +1,6 @@
 import type { Block, BlockSchema, Page } from '@craftile/types';
-import { getRegionId } from '../utils';
+import { generateId, getRegionId, resolveInsertTarget } from '../utils';
 import type { Command, EngineEmitFn } from '../types';
-import { generateId } from '../utils';
 
 export interface InsertBlockOptions {
   blockType: string;
@@ -40,6 +39,8 @@ export class InsertBlockCommand implements Command {
   }
 
   apply(): void {
+    const target = resolveInsertTarget(this.page, this.parentId, this.regionId, this.index);
+
     const blockName = this.blockSchema?.meta?.name || this.blockType;
 
     this.insertedBlock = {
@@ -48,44 +49,22 @@ export class InsertBlockCommand implements Command {
       name: blockName,
       properties: this.properties,
       children: [],
-      parentId: undefined, // Will be set if inserting as child
+      parentId: undefined,
     };
 
     this.page.blocks[this.blockId] = this.insertedBlock;
+    this.actualIndex = target.index;
 
-    if (this.parentId) {
-      const parent = this.page.blocks[this.parentId];
-
-      if (!parent) {
-        throw new Error(`Parent block not found: ${this.parentId}`);
-      }
-
-      this.insertedBlock.parentId = parent.id;
-
-      if (this.index !== undefined && this.index >= 0 && this.index <= parent.children.length) {
-        parent.children.splice(this.index, 0, this.blockId);
-        this.actualIndex = this.index;
-      } else {
-        parent.children.push(this.blockId);
-        this.actualIndex = parent.children.length - 1;
-      }
+    if (target.kind === 'parent') {
+      this.insertedBlock.parentId = target.parent.id;
+      target.parent.children.splice(target.index, 0, this.blockId);
     } else {
-      // Insert as top-level block (to the specified region)
-      const targetRegionId = this.regionId || getRegionId(this.page.regions[0]);
-      let targetRegion = this.page.regions.find((r) => getRegionId(r) === targetRegionId);
-
-      if (!targetRegion) {
-        targetRegion = { id: targetRegionId, name: targetRegionId, blocks: [] };
-        this.page.regions.push(targetRegion);
-      }
-
-      if (this.index !== undefined && this.index >= 0 && this.index <= targetRegion.blocks.length) {
-        targetRegion.blocks.splice(this.index, 0, this.blockId);
-        this.actualIndex = this.index;
-      } else {
-        targetRegion.blocks.push(this.blockId);
-        this.actualIndex = targetRegion.blocks.length - 1;
+      let region = this.page.regions.find((r) => getRegionId(r) === target.regionId);
+      if (!region) {
+        region = { id: target.regionId, name: target.regionId, blocks: [] };
+        this.page.regions.push(region);
       }
+      region.blocks.splice(target.index, 0, this.blockId);
     }
 
     this.emit('block:insert', {

package/src/commands/move-block.ts

@@ -1,6 +1,7 @@
 import type { Block, Page } from '@craftile/types';
 import type { Command, EngineEmitFn } from '../types';
-import { getRegionId } from '../utils';
+import type { ResolvedTarget } from '../utils';
+import { canInsertDynamicChildAt, clampIndex, getRegionId, resolveRegionId } from '../utils';
 
 export interface MoveBlockOptions {
   blockId: string;
@@ -35,63 +36,31 @@ export class MoveBlockCommand implements Command {
   }
 
   apply(): void {
-    this.blockToMove = this.page.blocks[this.blockId];
-
-    if (!this.blockToMove) {
-      throw new Error(`Block not found: ${this.blockId}`);
-    }
-
-    if (this.targetParentId && !this.page.blocks[this.targetParentId]) {
-      throw new Error(`Target parent not found: ${this.targetParentId}`);
-    }
-
-    this.originalParentId = this.blockToMove.parentId;
+    const target = this.validateAndResolveTarget();
 
-    // First we remove the block from the current position
     if (this.originalParentId) {
-      const parent = this.page.blocks[this.originalParentId];
-      if (parent) {
-        this.originalIndex = parent.children.indexOf(this.blockId);
-        if (this.originalIndex !== -1) {
-          parent.children.splice(this.originalIndex, 1);
-        }
+      const sourceParent = this.page.blocks[this.originalParentId];
+      if (sourceParent && this.originalIndex !== -1) {
+        sourceParent.children.splice(this.originalIndex, 1);
       }
-    } else {
-      // it is a region level block
-      const region = this.page.regions.find((r) => r.blocks.includes(this.blockId));
-      if (region) {
-        this.originalIndex = region.blocks.indexOf(this.blockId);
-        this.originalRegionId = getRegionId(region);
-        region.blocks.splice(this.originalIndex, 1);
+    } else if (this.originalRegionId) {
+      const sourceRegion = this.page.regions.find((r) => getRegionId(r) === this.originalRegionId);
+      if (sourceRegion && this.originalIndex !== -1) {
+        sourceRegion.blocks.splice(this.originalIndex, 1);
       }
     }
 
-    // the we insert the block at the new position
-    if (this.targetParentId) {
-      const targetParent = this.page.blocks[this.targetParentId];
-      this.blockToMove.parentId = this.targetParentId;
-
-      if (this.targetIndex !== undefined && this.targetIndex >= 0 && this.targetIndex <= targetParent.children.length) {
-        targetParent.children.splice(this.targetIndex, 0, this.blockId);
-      } else {
-        targetParent.children.push(this.blockId);
-      }
+    if (target.kind === 'parent') {
+      this.blockToMove!.parentId = target.parent.id;
+      target.parent.children.splice(target.index, 0, this.blockId);
     } else {
-      this.blockToMove.parentId = undefined;
-
-      const regionId = this.targetRegionId || getRegionId(this.page.regions[0]) || 'main';
-      let targetRegion = this.page.regions.find((r) => getRegionId(r) === regionId);
-
-      if (!targetRegion) {
-        targetRegion = { id: regionId, name: regionId, blocks: [] };
-        this.page.regions.push(targetRegion);
-      }
-
-      if (this.targetIndex !== undefined && this.targetIndex >= 0 && this.targetIndex <= targetRegion.blocks.length) {
-        targetRegion.blocks.splice(this.targetIndex, 0, this.blockId);
-      } else {
-        targetRegion.blocks.push(this.blockId);
+      this.blockToMove!.parentId = undefined;
+      let region = this.page.regions.find((r) => getRegionId(r) === target.regionId);
+      if (!region) {
+        region = { id: target.regionId, name: target.regionId, blocks: [] };
+        this.page.regions.push(region);
       }
+      region.blocks.splice(target.index, 0, this.blockId);
     }
 
     this.emit('block:move', {
@@ -105,6 +74,63 @@ export class MoveBlockCommand implements Command {
     });
   }
 
+  /**
+   * Resolve the target parent/region and the splice index, asserting the
+   * dynamic-child placement rules against the prospective post-move layout.
+   * Captures the source position too so `revert()` can restore it. Pure read —
+   * does not mutate `page`.
+   */
+  private validateAndResolveTarget(): ResolvedTarget {
+    this.blockToMove = this.page.blocks[this.blockId];
+    if (!this.blockToMove) {
+      throw new Error(`Block not found: ${this.blockId}`);
+    }
+
+    this.originalParentId = this.blockToMove.parentId;
+    if (this.originalParentId) {
+      const sourceParent = this.page.blocks[this.originalParentId];
+      this.originalIndex = sourceParent ? sourceParent.children.indexOf(this.blockId) : -1;
+    } else {
+      const sourceRegion = this.page.regions.find((r) => r.blocks.includes(this.blockId));
+      if (sourceRegion) {
+        this.originalRegionId = getRegionId(sourceRegion);
+        this.originalIndex = sourceRegion.blocks.indexOf(this.blockId);
+      } else {
+        this.originalIndex = -1;
+      }
+    }
+
+    if (this.targetParentId) {
+      const parent = this.page.blocks[this.targetParentId];
+      if (!parent) {
+        throw new Error(`Target parent not found: ${this.targetParentId}`);
+      }
+
+      const sourceIsTarget = this.originalParentId === this.targetParentId;
+      const prospective = sourceIsTarget ? parent.children.filter((id) => id !== this.blockId) : parent.children;
+      const index = clampIndex(prospective.length, this.targetIndex);
+
+      if (!canInsertDynamicChildAt(prospective, this.page.blocks, index)) {
+        throw new Error(
+          `Cannot place at index ${index} of ${this.targetParentId}: not a valid slot for a dynamic child`
+        );
+      }
+
+      return { kind: 'parent', parent, index };
+    }
+
+    const regionId = resolveRegionId(this.page, this.targetRegionId);
+    const existing = this.page.regions.find((r) => getRegionId(r) === regionId);
+    const sourceIsTarget = this.originalRegionId === regionId;
+    const prospective = existing
+      ? sourceIsTarget
+        ? existing.blocks.filter((id) => id !== this.blockId)
+        : existing.blocks
+      : [];
+
+    return { kind: 'region', regionId, index: clampIndex(prospective.length, this.targetIndex) };
+  }
+
   revert(): void {
     if (!this.blockToMove || this.originalIndex === undefined) {
       return;

package/src/utils.ts

@@ -1,4 +1,8 @@
-import type { Region } from '@craftile/types';
+import type { Block, Page, Region } from '@craftile/types';
+
+export type ResolvedTarget =
+  | { kind: 'parent'; parent: Block; index: number }
+  | { kind: 'region'; regionId: string; index: number };
 
 export const generateId = (): string => {
   if (crypto.randomUUID) {
@@ -15,3 +19,85 @@ export const generateId = (): string => {
 export const getRegionId = (region: Region): string => {
   return region.id || region.name;
 };
+
+/**
+ * Clamp `index` to a valid splice position for an array of `length`. An
+ * undefined or out-of-range index falls back to `length` (i.e. append).
+ */
+export const clampIndex = (length: number, index: number | undefined): number => {
+  return index !== undefined && index >= 0 && index <= length ? index : length;
+};
+
+/**
+ * Resolve the effective region id, falling back to the first region or to
+ * `'main'` when none exist. Safe against an empty `page.regions` array.
+ */
+export const resolveRegionId = (page: Page, regionId: string | undefined): string => {
+  return regionId || (page.regions[0] && getRegionId(page.regions[0])) || 'main';
+};
+
+/**
+ * Resolve the target parent/region and the splice index, asserting the
+ * dynamic-child placement rules.
+ */
+export const resolveInsertTarget = (
+  page: Page,
+  parentId: string | undefined,
+  regionId: string | undefined,
+  index: number | undefined
+): ResolvedTarget => {
+  if (parentId) {
+    const parent = page.blocks[parentId];
+    if (!parent) {
+      throw new Error(`Parent block not found: ${parentId}`);
+    }
+    const resolvedIndex = clampIndex(parent.children.length, index);
+    if (!canInsertDynamicChildAt(parent.children, page.blocks, resolvedIndex)) {
+      throw new Error(`Cannot place at index ${resolvedIndex} of ${parentId}: not a valid slot for a dynamic child`);
+    }
+    return { kind: 'parent', parent, index: resolvedIndex };
+  }
+
+  const targetRegionId = resolveRegionId(page, regionId);
+  const existing = page.regions.find((r) => getRegionId(r) === targetRegionId);
+  return {
+    kind: 'region',
+    regionId: targetRegionId,
+    index: clampIndex(existing?.blocks.length ?? 0, index),
+  };
+};
+
+/**
+ * Returns true when inserting a dynamic block at `index` of the given children
+ * keeps all dynamic siblings contiguous and does not wedge between two adjacent
+ * static blocks.
+ */
+export const canInsertDynamicChildAt = (
+  childrenIds: string[],
+  blocks: Record<string, Block>,
+  index: number
+): boolean => {
+  if (index > 0 && index < childrenIds.length) {
+    const before = blocks[childrenIds[index - 1]];
+    const after = blocks[childrenIds[index]];
+    if (before?.static === true && after?.static === true) {
+      return false;
+    }
+  }
+
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < childrenIds.length; i++) {
+    const child = blocks[childrenIds[i]];
+    if (child && child.static !== true) {
+      if (first === -1) {
+        first = i;
+      }
+      last = i;
+    }
+  }
+  if (first === -1) {
+    return true;
+  }
+  return index >= first && index <= last + 1;
+};