@craftile/core 0.1.0

package/src/commands/remove-block.ts

@@ -0,0 +1,94 @@
+import type { Block, Page } from '@craftile/types';
+import type { Command, EngineEmitFn } from '../types';
+
+export interface RemoveBlockOptions {
+  blockId: string;
+  emit: EngineEmitFn;
+}
+
+export class RemoveBlockCommand implements Command {
+  private page: Page;
+  private blockId: string;
+  private removedBlock?: Block;
+  private originalIndex?: number;
+  private originalParentId?: string;
+  private regionName?: string;
+  private emit: EngineEmitFn;
+
+  constructor(page: Page, options: RemoveBlockOptions) {
+    this.page = page;
+    this.blockId = options.blockId;
+    this.emit = options.emit;
+  }
+
+  apply(): void {
+    this.removedBlock = this.page.blocks[this.blockId];
+
+    if (!this.removedBlock) {
+      throw new Error(`Block not found: ${this.blockId}`);
+    }
+
+    this.originalParentId = this.removedBlock.parentId;
+
+    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);
+        }
+      }
+    } else {
+      const region = this.page.regions.find((r) => r.blocks.includes(this.blockId));
+      if (region) {
+        this.originalIndex = region.blocks.indexOf(this.blockId);
+        this.regionName = region.name;
+        region.blocks.splice(this.originalIndex, 1);
+      }
+    }
+
+    delete this.page.blocks[this.blockId];
+
+    this.emit('block:remove', {
+      blockId: this.blockId,
+      block: this.removedBlock,
+      parentId: this.originalParentId,
+    });
+  }
+
+  revert(): void {
+    if (!this.removedBlock || this.originalIndex === undefined) {
+      return;
+    }
+
+    this.page.blocks[this.blockId] = this.removedBlock;
+
+    if (this.originalParentId) {
+      const parent = this.page.blocks[this.originalParentId];
+      if (parent) {
+        parent.children.splice(this.originalIndex, 0, this.blockId);
+      }
+    } else if (this.regionName) {
+      const region = this.page.regions.find((r) => r.name === this.regionName);
+      if (region) {
+        region.blocks.splice(this.originalIndex, 0, this.blockId);
+      }
+    }
+
+    this.emit('block:insert', {
+      blockId: this.blockId,
+      block: this.removedBlock,
+      parentId: this.originalParentId,
+      index: this.originalIndex,
+      regionName: this.regionName,
+    });
+  }
+
+  getBlockId(): string {
+    return this.blockId;
+  }
+
+  getRemovedBlock(): Block | undefined {
+    return this.removedBlock;
+  }
+}

package/src/commands/set-block-property.ts

@@ -0,0 +1,84 @@
+import type { Block, Page } from '@craftile/types';
+import type { Command, EngineEmitFn } from '../types';
+
+export interface SetBlockPropertyOptions {
+  blockId: string;
+  propertyKey: string;
+  propertyValue: any;
+  emit: EngineEmitFn;
+}
+
+export class SetBlockPropertyCommand implements Command {
+  private page: Page;
+  private blockId: string;
+  private propertyKey: string;
+  private propertyValue: any;
+  private originalValue: any;
+  private block?: Block;
+  private emit: EngineEmitFn;
+
+  constructor(page: Page, options: SetBlockPropertyOptions) {
+    this.page = page;
+    this.blockId = options.blockId;
+    this.propertyKey = options.propertyKey;
+    this.propertyValue = options.propertyValue;
+    this.emit = options.emit;
+  }
+
+  apply(): void {
+    this.block = this.page.blocks[this.blockId];
+
+    if (!this.block) {
+      throw new Error(`Block not found: ${this.blockId}`);
+    }
+
+    if (!this.block.properties) {
+      this.block.properties = {};
+    }
+
+    this.originalValue = this.block.properties[this.propertyKey];
+    this.block.properties[this.propertyKey] = this.propertyValue;
+
+    this.emit('block:property:set', {
+      blockId: this.blockId,
+      key: this.propertyKey,
+      value: this.propertyValue,
+      oldValue: this.originalValue,
+    });
+  }
+
+  revert(): void {
+    if (!this.block || !this.block.properties) {
+      return;
+    }
+
+    if (this.originalValue !== undefined) {
+      this.block.properties[this.propertyKey] = this.originalValue;
+    } else {
+      delete this.block.properties[this.propertyKey];
+    }
+
+    this.emit('block:property:set', {
+      blockId: this.blockId,
+      key: this.propertyKey,
+      value: this.originalValue,
+      oldValue: this.propertyValue,
+    });
+  }
+
+  getBlockId(): string {
+    return this.blockId;
+  }
+
+  getPropertyKey(): string {
+    return this.propertyKey;
+  }
+
+  getPropertyValue(): any {
+    return this.propertyValue;
+  }
+
+  getOriginalValue(): any {
+    return this.originalValue;
+  }
+}

package/src/commands/toggle-block.ts

@@ -0,0 +1,76 @@
+import type { Block, Page } from '@craftile/types';
+import type { Command, EngineEmitFn } from '../types';
+
+export interface ToggleBlockOptions {
+  blockId: string;
+  disabled?: boolean;
+  emit: EngineEmitFn;
+}
+
+export class ToggleBlockCommand implements Command {
+  private page: Page;
+  private blockId: string;
+  private targetDisabled?: boolean;
+  private originalDisabled?: boolean;
+  private block?: Block;
+  private emit: EngineEmitFn;
+
+  constructor(page: Page, options: ToggleBlockOptions) {
+    this.page = page;
+    this.blockId = options.blockId;
+    this.targetDisabled = options.disabled;
+    this.emit = options.emit;
+  }
+
+  apply(): void {
+    this.block = this.page.blocks[this.blockId];
+
+    if (!this.block) {
+      throw new Error(`Block not found: ${this.blockId}`);
+    }
+
+    this.originalDisabled = this.block.disabled;
+
+    if (this.targetDisabled !== undefined) {
+      this.block.disabled = this.targetDisabled;
+    } else {
+      this.block.disabled = !this.block.disabled;
+    }
+
+    this.emit('block:toggle', {
+      blockId: this.blockId,
+      disabled: this.block.disabled ?? false,
+      oldValue: this.originalDisabled,
+    });
+  }
+
+  revert(): void {
+    if (!this.block) {
+      return;
+    }
+
+    if (this.originalDisabled !== undefined) {
+      this.block.disabled = this.originalDisabled;
+    } else {
+      this.block.disabled = !this.block.disabled;
+    }
+
+    this.emit('block:toggle', {
+      blockId: this.blockId,
+      disabled: this.block.disabled ?? false,
+      oldValue: this.targetDisabled !== undefined ? this.targetDisabled : !this.originalDisabled,
+    });
+  }
+
+  getBlockId(): string {
+    return this.blockId;
+  }
+
+  getOriginalDisabled(): boolean | undefined {
+    return this.originalDisabled;
+  }
+
+  getNewDisabled(): boolean | undefined {
+    return this.block?.disabled;
+  }
+}

package/src/engine.ts

@@ -0,0 +1,329 @@
+import { EventBus } from '@craftile/event-bus';
+import type { EngineConfig, EngineEvents } from './types';
+import type { Block, BlockSchema, Page } from '@craftile/types';
+import { BlocksManager } from './blocks-manager';
+import { HistoryManager } from './history-manager';
+import { InsertBlockCommand } from './commands/insert-block';
+import { RemoveBlockCommand } from './commands/remove-block';
+import { MoveBlockCommand } from './commands/move-block';
+import { ToggleBlockCommand } from './commands/toggle-block';
+import { SetBlockPropertyCommand } from './commands/set-block-property';
+import { DuplicateBlockCommand } from './commands/duplicate-block';
+
+export class Engine extends EventBus<EngineEvents> {
+  protected page!: Page;
+  protected blocksManager: BlocksManager;
+  protected historyManager: HistoryManager;
+
+  constructor(config: EngineConfig = {}) {
+    super();
+
+    this.blocksManager = config.blocksManager || new BlocksManager();
+    this.historyManager = new HistoryManager();
+    this.setPage(config.page ? config.page : { blocks: {}, regions: [{ name: 'main', blocks: [] }] });
+
+    if (config.blockSchemas && config.blockSchemas.length > 0) {
+      config.blockSchemas.forEach((schema) => {
+        this.blocksManager.register(schema.type, schema);
+      });
+    }
+  }
+
+  /**
+   * Insert a new block into the page
+   *
+   * @param blockType - The type of block to insert (must be registered)
+   * @param options - Optional configuration for block insertion
+   * @param options.parentId - ID of parent block (for nested blocks)
+   * @param options.regionName - Target region name (defaults to 'main')
+   * @param options.index - Position to insert at (defaults to end)
+   * @returns The ID of the newly inserted block
+   * @throws {Error} When block type is not registered or parent-child relationship is invalid
+   * @emits block:insert - When the block is successfully inserted
+   */
+  insertBlock(
+    blockType: string,
+    options?: {
+      parentId?: string;
+      regionName?: string;
+      index?: number;
+    }
+  ): string {
+    const blockSchema = this.blocksManager.get(blockType);
+    if (!blockSchema) {
+      throw new Error(`Block type '${blockType}' is not registered`);
+    }
+
+    if (options?.parentId) {
+      const parentBlock = this.page.blocks[options.parentId];
+      if (!parentBlock) {
+        throw new Error(`Parent block not found: ${options.parentId}`);
+      }
+
+      if (!this.blocksManager.canBeChild(blockType, parentBlock.type)) {
+        throw new Error(`Block type '${blockType}' cannot be a child of '${parentBlock.type}'`);
+      }
+    }
+
+    const command = new InsertBlockCommand(this.page, {
+      blockType,
+      parentId: options?.parentId,
+      regionName: options?.regionName,
+      index: options?.index,
+      blockSchema,
+      emit: this.emit.bind(this),
+    });
+
+    command.apply();
+    this.historyManager.addCommand(command);
+
+    return command.getBlockId();
+  }
+
+  /**
+   * Remove a block from the page
+   *
+   * @param blockId - ID of the block to remove
+   * @throws {Error} When block is not found
+   * @emits block:remove - When the block is successfully removed
+   */
+  removeBlock(blockId: string): void {
+    const command = new RemoveBlockCommand(this.page, {
+      blockId,
+      emit: this.emit.bind(this),
+    });
+
+    command.apply();
+    this.historyManager.addCommand(command);
+  }
+
+  /**
+   * Move a block to a new location (reorder within parent or move to different parent/region)
+   *
+   * @param blockId - ID of the block to remove
+   * @param options - Optional configuration for block move operation
+   * @param options.targetParentId - ID of target parent block
+   * @param options.targetIndex - position in the target parent block children
+   * @param options.targetRegionName - target region name
+   */
+  moveBlock(
+    blockId: string,
+    options?: {
+      targetParentId?: string;
+      targetIndex?: number;
+      targetRegionName?: string;
+    }
+  ): void {
+    const block = this.page.blocks[blockId];
+
+    if (options?.targetParentId) {
+      const targetParent = this.page.blocks[options.targetParentId];
+      if (!targetParent) {
+        throw new Error(`Target parent block not found: ${options.targetParentId}`);
+      }
+
+      if (!this.blocksManager.canBeChild(block.type, targetParent.type)) {
+        throw new Error(`Block type '${block.type}' cannot be a child of '${targetParent.type}'`);
+      }
+    }
+
+    const command = new MoveBlockCommand(this.page, {
+      blockId,
+      targetParentId: options?.targetParentId,
+      targetIndex: options?.targetIndex,
+      targetRegionName: options?.targetRegionName,
+      emit: this.emit.bind(this),
+    });
+
+    command.apply();
+    this.historyManager.addCommand(command);
+  }
+
+  /**
+   * Toggle a block's disabled state (enable/disable)
+   */
+  toggleBlock(blockId: string, disabled?: boolean): void {
+    const command = new ToggleBlockCommand(this.page, {
+      blockId,
+      disabled,
+      emit: this.emit.bind(this),
+    });
+
+    command.apply();
+    this.historyManager.addCommand(command);
+  }
+
+  /**
+   * Set a property value for a block
+   *
+   * @param blockId - ID of the target block
+   * @param propertyKey - The property key to set
+   * @param propertyValue - The new value for the property
+   * @throws {Error} When block is not found
+   * @emits block:property:set - When the property is successfully set
+   */
+  setBlockProperty(blockId: string, propertyKey: string, propertyValue: any): void {
+    const command = new SetBlockPropertyCommand(this.page, {
+      blockId,
+      propertyKey,
+      propertyValue,
+      emit: this.emit.bind(this),
+    });
+
+    command.apply();
+    this.historyManager.addCommand(command);
+  }
+
+  /**
+   * Duplicate a block (creates a copy placed right after the original)
+   */
+  duplicateBlock(blockId: string): string {
+    const command = new DuplicateBlockCommand(this.page, {
+      blockId,
+      emit: this.emit.bind(this),
+    });
+
+    command.apply();
+    this.historyManager.addCommand(command);
+
+    return command.getDuplicatedBlockId();
+  }
+
+  getBlockById(blockId: string): Block | undefined {
+    return this.page.blocks[blockId];
+  }
+
+  /**
+   * Get current page state
+   */
+  getPage(): Page {
+    return structuredClone(this.page);
+  }
+
+  /**
+   * Set a new page (replaces current page and clears history)
+   *
+   * @param newPage - The new page object to set
+   * @throws {Error} When the page structure is invalid
+   * @emits page:set - When the page is successfully set
+   */
+  setPage(newPage: Page): void {
+    const beforePage = structuredClone(this.page);
+
+    this.page = structuredClone(newPage);
+
+    if (this.page.regions.length === 0) {
+      this.page.regions = [{ name: 'main', blocks: Object.keys(this.page.blocks) }];
+    }
+
+    // Initialize regions if not present
+    if (this.page.regions.length === 0) {
+      this.page.regions = [
+        {
+          name: 'main',
+          blocks: Object.values(this.page.blocks)
+            .filter((block) => !block.parentId)
+            .map((block) => block.id),
+        },
+      ];
+    }
+
+    this.initializeParentChildRelationships();
+
+    // Clear history since we're switching to a completely new page
+    // maybe we should keep a separate history per page
+    this.historyManager.clear();
+
+    this.emit('page:set', {
+      previousPage: beforePage,
+      newPage: structuredClone(this.page),
+    });
+  }
+
+  /**
+   * Get the blocks manager for this engine instance
+   */
+  getBlocksManager(): BlocksManager {
+    return this.blocksManager;
+  }
+
+  /**
+   * Get block schemas
+   */
+  getBlockSchemas(): Record<string, BlockSchema> {
+    return this.blocksManager.getAll();
+  }
+
+  /**
+   * Get a specific block schema by type
+   *
+   * @param type - The block type to get the schema for
+   * @returns The block schema or undefined if not found
+   */
+  getBlockSchema(type: string): BlockSchema | undefined {
+    return this.blocksManager.get(type);
+  }
+
+  /**
+   * Undo the last operation
+   */
+  undo(): boolean {
+    const command = this.historyManager.undo();
+
+    if (command !== null) {
+      this.emit('undo', { command });
+    }
+
+    return command !== null;
+  }
+
+  /**
+   * Redo the last undone operation
+   */
+  redo(): boolean {
+    const command = this.historyManager.redo();
+
+    if (command !== null) {
+      this.emit('redo', { command });
+    }
+
+    return command !== null;
+  }
+
+  /**
+   * Check if undo is possible
+   */
+  canUndo(): boolean {
+    return this.historyManager.canUndo();
+  }
+
+  /**
+   * Check if redo is possible
+   */
+  canRedo(): boolean {
+    return this.historyManager.canRedo();
+  }
+
+  /**
+   * Initialize parent-child relationships for blocks that have children but missing parentId
+   * Handles deep nesting recursively
+   */
+  private initializeParentChildRelationships(): void {
+    const processBlock = (block: Block): void => {
+      if (block.children && block.children.length > 0) {
+        block.children.forEach((childId: string) => {
+          const childBlock = this.page.blocks[childId];
+          if (childBlock) {
+            if (!childBlock.parentId) {
+              childBlock.parentId = block.id;
+            }
+
+            processBlock(childBlock);
+          }
+        });
+      }
+    };
+
+    Object.values(this.page.blocks).forEach(processBlock);
+  }
+}

package/src/history-manager.ts

@@ -0,0 +1,78 @@
+import type { Command } from './types';
+
+export class HistoryManager {
+  private history: Command[] = [];
+  private currentIndex = -1;
+
+  /**
+   * @param maxHistorySize Max number of commands to retain in memory.
+   */
+  private readonly maxHistorySize: number;
+
+  constructor(maxHistorySize = 100) {
+    this.maxHistorySize = maxHistorySize;
+  }
+
+  /**
+   * Add command to the history.
+   * The command is expected to be executed by the caller.
+   */
+  addCommand(cmd: Command): void {
+    if (this.currentIndex < this.history.length - 1) {
+      this.history.splice(this.currentIndex + 1);
+    }
+
+    if (this.history.length >= this.maxHistorySize) {
+      this.history.shift();
+      this.currentIndex--;
+    }
+
+    this.history.push(cmd);
+    this.currentIndex++;
+  }
+
+  undo(): Command | null {
+    if (!this.canUndo()) {
+      return null;
+    }
+
+    const cmd = this.history[this.currentIndex];
+    cmd.revert();
+    this.currentIndex--;
+
+    return cmd;
+  }
+
+  redo(): Command | null {
+    if (!this.canRedo()) {
+      return null;
+    }
+
+    this.currentIndex++;
+    const cmd = this.history[this.currentIndex];
+    cmd.apply();
+
+    return cmd;
+  }
+
+  canUndo(): boolean {
+    return this.currentIndex >= 0;
+  }
+
+  canRedo(): boolean {
+    return this.currentIndex < this.history.length - 1;
+  }
+
+  clear(): void {
+    this.history = [];
+    this.currentIndex = -1;
+  }
+
+  getCurrentIndex(): number {
+    return this.currentIndex;
+  }
+
+  getHistorySize(): number {
+    return this.history.length;
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export { Engine } from './engine';
+// export { Engine }

package/src/types.ts

@@ -0,0 +1,46 @@
+import type { Block, BlockSchema, Page } from '@craftile/types';
+import type { BlocksManager } from './blocks-manager';
+
+export interface EngineConfig {
+  page?: Page;
+  blockSchemas?: BlockSchema[];
+  blocksManager?: BlocksManager;
+}
+
+export interface Command {
+  apply(): void;
+  revert(): void;
+}
+
+// Event system types
+export interface EngineEvents {
+  'page:set': { previousPage?: Page; newPage: Page };
+  'block:insert': { blockId: string; block: Block; parentId?: string; index?: number; regionName?: string };
+  'block:remove': { blockId: string; block: Block; parentId?: string };
+  'block:toggle': { blockId: string; disabled: boolean; oldValue?: boolean };
+  'block:property:set': { blockId: string; key: string; value: any; oldValue: any };
+  'block:move': {
+    blockId: string;
+    targetParentId?: string;
+    targetIndex?: number;
+    targetRegionName?: string;
+    sourceParentId?: string | null;
+    sourceRegionName?: string | null;
+    sourceIndex: number;
+  };
+  'block:duplicate': {
+    originalBlockId: string;
+    newBlockId: string;
+    newBlock: Block;
+    parentId?: string;
+    index?: number;
+    regionName?: string;
+  };
+  undo: { command: any };
+  redo: { command: any };
+}
+
+export type EngineEmitFn = <K extends keyof EngineEvents>(
+  event: K,
+  ...args: EngineEvents[K] extends void ? [] : [EngineEvents[K]]
+) => void;