@templatical/core 0.9.1 → 0.10.1

package/dist/index.js

@@ -1,619 +1,503 @@
-// src/editor.ts
-import { createDefaultTemplateContent } from "@templatical/types";
-import {
-  computed,
-  reactive,
-  readonly
-} from "@vue/reactivity";
+import { createBlock, createDefaultTemplateContent, generateId } from "@templatical/types";
+import { computed, reactive, readonly, ref, watch } from "@vue/reactivity";
+//#region src/editor.ts
 function getColumnCount(layout) {
-  if (layout === "1") return 1;
-  if (layout === "3") return 3;
-  return 2;
+	if (layout === "1") return 1;
+	if (layout === "3") return 3;
+	return 2;
 }
 function useEditor(options) {
-  const state = reactive({
-    content: options.content ?? createDefaultTemplateContent(
-      options.defaultFontFamily,
-      options.templateDefaults
-    ),
-    selectedBlockId: null,
-    viewport: "desktop",
-    darkMode: false,
-    previewMode: false,
-    isDirty: false,
-    uiTheme: "auto"
-  });
-  const content = computed({
-    get: () => state.content,
-    set: (value) => {
-      state.content = value;
-      state.isDirty = true;
-    }
-  });
-  const selectedBlock = computed(() => {
-    if (!state.selectedBlockId) return null;
-    return findBlockById(state.content.blocks, state.selectedBlockId);
-  });
-  function findBlockById(blocks, id) {
-    for (const block of blocks) {
-      if (block.id === id) return block;
-      if (block.type === "section") {
-        for (const column of block.children) {
-          const found = findBlockById(column, id);
-          if (found) return found;
-        }
-      }
-    }
-    return null;
-  }
-  function collectBlockIds(block, ids) {
-    ids.add(block.id);
-    if (block.type === "section") {
-      for (const column of block.children) {
-        for (const child of column) {
-          collectBlockIds(child, ids);
-        }
-      }
-    }
-  }
-  function findBlockParent(blocks, id, parent = { blocks }) {
-    for (let i = 0; i < blocks.length; i++) {
-      const block = blocks[i];
-      if (block.id === id) return parent;
-      if (block.type === "section") {
-        for (let colIdx = 0; colIdx < block.children.length; colIdx++) {
-          const result = findBlockParent(block.children[colIdx], id, {
-            blocks: block.children[colIdx],
-            sectionId: block.id,
-            columnIndex: colIdx
-          });
-          if (result) return result;
-        }
-      }
-    }
-    return null;
-  }
-  function isBlockLocked(blockId) {
-    return options.lockedBlocks?.value.has(blockId) ?? false;
-  }
-  function findBlockLocation(blockId) {
-    const parent = findBlockParent(state.content.blocks, blockId);
-    if (!parent) return null;
-    const index = parent.blocks.findIndex((b) => b.id === blockId);
-    if (index === -1) return null;
-    return {
-      targetSectionId: parent.sectionId,
-      columnIndex: parent.columnIndex,
-      index
-    };
-  }
-  function setContent(newContent, markDirty2 = true) {
-    state.content = newContent;
-    if (markDirty2) {
-      state.isDirty = true;
-    }
-  }
-  function selectBlock(blockId) {
-    if (blockId && isBlockLocked(blockId)) {
-      return;
-    }
-    state.selectedBlockId = blockId;
-  }
-  function setViewport(viewport) {
-    state.viewport = viewport;
-  }
-  function setDarkMode(darkMode) {
-    state.darkMode = darkMode;
-  }
-  function setUiTheme(theme) {
-    state.uiTheme = theme;
-  }
-  function setPreviewMode(previewMode) {
-    state.previewMode = previewMode;
-    if (previewMode) {
-      state.selectedBlockId = null;
-    }
-  }
-  function updateBlock(blockId, updates) {
-    if (isBlockLocked(blockId)) {
-      return;
-    }
-    const block = findBlockById(state.content.blocks, blockId);
-    if (block) {
-      Object.assign(block, updates);
-      state.isDirty = true;
-    }
-  }
-  function updateSettings(updates) {
-    state.content.settings = { ...state.content.settings, ...updates };
-    state.isDirty = true;
-  }
-  function addBlock(block, targetSectionId, columnIndex = 0, index) {
-    if (targetSectionId) {
-      if (isBlockLocked(targetSectionId)) {
-        return;
-      }
-      const section = findBlockById(state.content.blocks, targetSectionId);
-      if (section && section.type === "section") {
-        if (columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) {
-          return;
-        }
-        section.children[columnIndex] = section.children[columnIndex] || [];
-        const targetArray = section.children[columnIndex];
-        if (index !== void 0 && index < targetArray.length) {
-          targetArray.splice(index, 0, block);
-        } else {
-          targetArray.push(block);
-        }
-      }
-    } else {
-      if (index !== void 0 && index < state.content.blocks.length) {
-        state.content.blocks.splice(index, 0, block);
-      } else {
-        state.content.blocks.push(block);
-      }
-    }
-    state.isDirty = true;
-  }
-  function removeBlock(blockId) {
-    if (isBlockLocked(blockId)) {
-      return;
-    }
-    const parent = findBlockParent(state.content.blocks, blockId);
-    if (parent) {
-      const index = parent.blocks.findIndex((b) => b.id === blockId);
-      if (index !== -1) {
-        const [removed] = parent.blocks.splice(index, 1);
-        if (state.selectedBlockId) {
-          const removedIds = /* @__PURE__ */ new Set();
-          collectBlockIds(removed, removedIds);
-          if (removedIds.has(state.selectedBlockId)) {
-            state.selectedBlockId = null;
-          }
-        }
-        state.isDirty = true;
-      }
-    }
-  }
-  function moveBlock(blockId, newIndex, targetSectionId, columnIndex = 0) {
-    if (isBlockLocked(blockId)) {
-      return;
-    }
-    if (targetSectionId && isBlockLocked(targetSectionId)) {
-      return;
-    }
-    const parent = findBlockParent(state.content.blocks, blockId);
-    if (!parent) return;
-    const oldIndex = parent.blocks.findIndex((b) => b.id === blockId);
-    if (oldIndex === -1) return;
-    let targetArray;
-    if (targetSectionId) {
-      const section = findBlockById(state.content.blocks, targetSectionId);
-      if (!section || section.type !== "section") return;
-      if (columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) {
-        return;
-      }
-      section.children[columnIndex] = section.children[columnIndex] || [];
-      targetArray = section.children[columnIndex];
-    } else {
-      targetArray = state.content.blocks;
-    }
-    const [block] = parent.blocks.splice(oldIndex, 1);
-    targetArray.splice(newIndex, 0, block);
-    state.isDirty = true;
-  }
-  function markDirty() {
-    state.isDirty = true;
-  }
-  return {
-    state: readonly(state),
-    content,
-    selectedBlock,
-    isBlockLocked,
-    setContent,
-    selectBlock,
-    setViewport,
-    setDarkMode,
-    setUiTheme,
-    setPreviewMode,
-    updateBlock,
-    updateSettings,
-    addBlock,
-    removeBlock,
-    moveBlock,
-    markDirty,
-    findBlockLocation
-  };
+	const state = reactive({
+		content: options.content ?? createDefaultTemplateContent(options.defaultFontFamily, options.templateDefaults),
+		selectedBlockId: null,
+		viewport: "desktop",
+		darkMode: false,
+		previewMode: false,
+		isDirty: false,
+		uiTheme: "auto"
+	});
+	const content = computed({
+		get: () => state.content,
+		set: (value) => {
+			state.content = value;
+			state.isDirty = true;
+		}
+	});
+	const selectedBlock = computed(() => {
+		if (!state.selectedBlockId) return null;
+		return findBlockById(state.content.blocks, state.selectedBlockId);
+	});
+	function findBlockById(blocks, id) {
+		for (const block of blocks) {
+			if (block.id === id) return block;
+			if (block.type === "section") for (const column of block.children) {
+				const found = findBlockById(column, id);
+				if (found) return found;
+			}
+		}
+		return null;
+	}
+	function collectBlockIds(block, ids) {
+		ids.add(block.id);
+		if (block.type === "section") for (const column of block.children) for (const child of column) collectBlockIds(child, ids);
+	}
+	function findBlockParent(blocks, id, parent = { blocks }) {
+		for (let i = 0; i < blocks.length; i++) {
+			const block = blocks[i];
+			if (block.id === id) return parent;
+			if (block.type === "section") for (let colIdx = 0; colIdx < block.children.length; colIdx++) {
+				const result = findBlockParent(block.children[colIdx], id, {
+					blocks: block.children[colIdx],
+					sectionId: block.id,
+					columnIndex: colIdx
+				});
+				if (result) return result;
+			}
+		}
+		return null;
+	}
+	function isBlockLocked(blockId) {
+		return options.lockedBlocks?.value.has(blockId) ?? false;
+	}
+	function findBlockLocation(blockId) {
+		const parent = findBlockParent(state.content.blocks, blockId);
+		if (!parent) return null;
+		const index = parent.blocks.findIndex((b) => b.id === blockId);
+		if (index === -1) return null;
+		return {
+			targetSectionId: parent.sectionId,
+			columnIndex: parent.columnIndex,
+			index
+		};
+	}
+	function setContent(newContent, markDirty = true) {
+		state.content = newContent;
+		if (markDirty) state.isDirty = true;
+	}
+	function selectBlock(blockId) {
+		if (blockId && isBlockLocked(blockId)) return;
+		state.selectedBlockId = blockId;
+	}
+	function setViewport(viewport) {
+		state.viewport = viewport;
+	}
+	function setDarkMode(darkMode) {
+		state.darkMode = darkMode;
+	}
+	function setUiTheme(theme) {
+		state.uiTheme = theme;
+	}
+	function setPreviewMode(previewMode) {
+		state.previewMode = previewMode;
+		if (previewMode) state.selectedBlockId = null;
+	}
+	function updateBlock(blockId, updates) {
+		if (isBlockLocked(blockId)) return;
+		const block = findBlockById(state.content.blocks, blockId);
+		if (block) {
+			Object.assign(block, updates);
+			state.isDirty = true;
+		}
+	}
+	function updateSettings(updates) {
+		state.content.settings = {
+			...state.content.settings,
+			...updates
+		};
+		state.isDirty = true;
+	}
+	function addBlock(block, targetSectionId, columnIndex = 0, index) {
+		if (targetSectionId) {
+			if (isBlockLocked(targetSectionId)) return;
+			const section = findBlockById(state.content.blocks, targetSectionId);
+			if (section && section.type === "section") {
+				if (columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) return;
+				section.children[columnIndex] = section.children[columnIndex] || [];
+				const targetArray = section.children[columnIndex];
+				if (index !== void 0 && index < targetArray.length) targetArray.splice(index, 0, block);
+				else targetArray.push(block);
+			}
+		} else if (index !== void 0 && index < state.content.blocks.length) state.content.blocks.splice(index, 0, block);
+		else state.content.blocks.push(block);
+		state.isDirty = true;
+	}
+	function removeBlock(blockId) {
+		if (isBlockLocked(blockId)) return;
+		const parent = findBlockParent(state.content.blocks, blockId);
+		if (parent) {
+			const index = parent.blocks.findIndex((b) => b.id === blockId);
+			if (index !== -1) {
+				const [removed] = parent.blocks.splice(index, 1);
+				if (state.selectedBlockId) {
+					const removedIds = /* @__PURE__ */ new Set();
+					collectBlockIds(removed, removedIds);
+					if (removedIds.has(state.selectedBlockId)) state.selectedBlockId = null;
+				}
+				state.isDirty = true;
+			}
+		}
+	}
+	function moveBlock(blockId, newIndex, targetSectionId, columnIndex = 0) {
+		if (isBlockLocked(blockId)) return;
+		if (targetSectionId && isBlockLocked(targetSectionId)) return;
+		const parent = findBlockParent(state.content.blocks, blockId);
+		if (!parent) return;
+		const oldIndex = parent.blocks.findIndex((b) => b.id === blockId);
+		if (oldIndex === -1) return;
+		let targetArray;
+		if (targetSectionId) {
+			const section = findBlockById(state.content.blocks, targetSectionId);
+			if (!section || section.type !== "section") return;
+			if (columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) return;
+			section.children[columnIndex] = section.children[columnIndex] || [];
+			targetArray = section.children[columnIndex];
+		} else targetArray = state.content.blocks;
+		const [block] = parent.blocks.splice(oldIndex, 1);
+		targetArray.splice(newIndex, 0, block);
+		state.isDirty = true;
+	}
+	function markDirty() {
+		state.isDirty = true;
+	}
+	return {
+		state: readonly(state),
+		content,
+		selectedBlock,
+		isBlockLocked,
+		setContent,
+		selectBlock,
+		setViewport,
+		setDarkMode,
+		setUiTheme,
+		setPreviewMode,
+		updateBlock,
+		updateSettings,
+		addBlock,
+		removeBlock,
+		moveBlock,
+		markDirty,
+		findBlockLocation
+	};
 }
-
-// src/history.ts
-import { computed as computed2, ref } from "@vue/reactivity";
-var MAX_STACK_SIZE = 50;
-var DEBOUNCE_MS = 300;
-var NAVIGATE_IDLE_MS = 1500;
+//#endregion
+//#region src/history.ts
+const MAX_STACK_SIZE = 50;
+const DEBOUNCE_MS = 300;
+const NAVIGATE_IDLE_MS = 1500;
 function useHistory(options) {
-  const {
-    content,
-    setContent,
-    isRemoteOperation,
-    maxSize = MAX_STACK_SIZE
-  } = options;
-  const undoStack = ref([]);
-  const redoStack = ref([]);
-  const isNavigating = ref(false);
-  let navigatingTimeoutId = null;
-  let pendingDebounce = null;
-  const canUndo = computed2(() => undoStack.value.length > 0);
-  const canRedo = computed2(() => redoStack.value.length > 0);
-  function cloneContent() {
-    const seen = /* @__PURE__ */ new WeakSet();
-    return JSON.parse(
-      JSON.stringify(content.value, (_key, value) => {
-        if (typeof value === "object" && value !== null) {
-          if (seen.has(value)) return void 0;
-          seen.add(value);
-        }
-        return value;
-      })
-    );
-  }
-  function pushToUndoStack(snapshot) {
-    undoStack.value.push(snapshot);
-    if (undoStack.value.length > maxSize) {
-      undoStack.value.splice(0, undoStack.value.length - maxSize);
-    }
-  }
-  function flushPendingDebounce() {
-    if (pendingDebounce) {
-      clearTimeout(pendingDebounce.timeoutId);
-      pendingDebounce = null;
-    }
-  }
-  function record() {
-    if (isRemoteOperation?.()) {
-      return;
-    }
-    flushPendingDebounce();
-    pushToUndoStack(cloneContent());
-    redoStack.value = [];
-  }
-  function recordDebounced(blockId) {
-    if (isRemoteOperation?.()) {
-      return;
-    }
-    if (pendingDebounce && pendingDebounce.blockId === blockId) {
-      clearTimeout(pendingDebounce.timeoutId);
-      pendingDebounce.timeoutId = setTimeout(() => {
-        pendingDebounce = null;
-      }, DEBOUNCE_MS);
-      return;
-    }
-    flushPendingDebounce();
-    pushToUndoStack(cloneContent());
-    redoStack.value = [];
-    pendingDebounce = {
-      blockId,
-      timeoutId: setTimeout(() => {
-        pendingDebounce = null;
-      }, DEBOUNCE_MS)
-    };
-  }
-  function setNavigating() {
-    isNavigating.value = true;
-    if (navigatingTimeoutId) {
-      clearTimeout(navigatingTimeoutId);
-    }
-    navigatingTimeoutId = setTimeout(() => {
-      isNavigating.value = false;
-      navigatingTimeoutId = null;
-    }, NAVIGATE_IDLE_MS);
-  }
-  function undo() {
-    if (undoStack.value.length === 0) {
-      return;
-    }
-    flushPendingDebounce();
-    const snapshot = undoStack.value.pop();
-    redoStack.value.push(cloneContent());
-    setContent(snapshot, true);
-    setNavigating();
-  }
-  function redo() {
-    if (redoStack.value.length === 0) {
-      return;
-    }
-    flushPendingDebounce();
-    const snapshot = redoStack.value.pop();
-    undoStack.value.push(cloneContent());
-    setContent(snapshot, true);
-    setNavigating();
-  }
-  function clear() {
-    undoStack.value = [];
-    redoStack.value = [];
-    flushPendingDebounce();
-  }
-  function destroy() {
-    clear();
-    if (navigatingTimeoutId) {
-      clearTimeout(navigatingTimeoutId);
-      navigatingTimeoutId = null;
-    }
-  }
-  return {
-    canUndo,
-    canRedo,
-    isNavigating,
-    undo,
-    redo,
-    record,
-    recordDebounced,
-    clear,
-    destroy
-  };
+	const { content, setContent, isRemoteOperation, maxSize = MAX_STACK_SIZE } = options;
+	const undoStack = ref([]);
+	const redoStack = ref([]);
+	const isNavigating = ref(false);
+	let navigatingTimeoutId = null;
+	let pendingDebounce = null;
+	const canUndo = computed(() => undoStack.value.length > 0);
+	const canRedo = computed(() => redoStack.value.length > 0);
+	function cloneContent() {
+		const seen = /* @__PURE__ */ new WeakSet();
+		return JSON.parse(JSON.stringify(content.value, (_key, value) => {
+			if (typeof value === "object" && value !== null) {
+				if (seen.has(value)) return void 0;
+				seen.add(value);
+			}
+			return value;
+		}));
+	}
+	function pushToUndoStack(snapshot) {
+		undoStack.value.push(snapshot);
+		if (undoStack.value.length > maxSize) undoStack.value.splice(0, undoStack.value.length - maxSize);
+	}
+	function flushPendingDebounce() {
+		if (pendingDebounce) {
+			clearTimeout(pendingDebounce.timeoutId);
+			pendingDebounce = null;
+		}
+	}
+	function record() {
+		if (isRemoteOperation?.()) return;
+		flushPendingDebounce();
+		pushToUndoStack(cloneContent());
+		redoStack.value = [];
+	}
+	function recordDebounced(blockId) {
+		if (isRemoteOperation?.()) return;
+		if (pendingDebounce && pendingDebounce.blockId === blockId) {
+			clearTimeout(pendingDebounce.timeoutId);
+			pendingDebounce.timeoutId = setTimeout(() => {
+				pendingDebounce = null;
+			}, DEBOUNCE_MS);
+			return;
+		}
+		flushPendingDebounce();
+		pushToUndoStack(cloneContent());
+		redoStack.value = [];
+		pendingDebounce = {
+			blockId,
+			timeoutId: setTimeout(() => {
+				pendingDebounce = null;
+			}, DEBOUNCE_MS)
+		};
+	}
+	function setNavigating() {
+		isNavigating.value = true;
+		if (navigatingTimeoutId) clearTimeout(navigatingTimeoutId);
+		navigatingTimeoutId = setTimeout(() => {
+			isNavigating.value = false;
+			navigatingTimeoutId = null;
+		}, NAVIGATE_IDLE_MS);
+	}
+	function undo() {
+		if (undoStack.value.length === 0) return;
+		flushPendingDebounce();
+		const snapshot = undoStack.value.pop();
+		redoStack.value.push(cloneContent());
+		setContent(snapshot, true);
+		setNavigating();
+	}
+	function redo() {
+		if (redoStack.value.length === 0) return;
+		flushPendingDebounce();
+		const snapshot = redoStack.value.pop();
+		undoStack.value.push(cloneContent());
+		setContent(snapshot, true);
+		setNavigating();
+	}
+	function clear() {
+		undoStack.value = [];
+		redoStack.value = [];
+		flushPendingDebounce();
+	}
+	function destroy() {
+		clear();
+		if (navigatingTimeoutId) {
+			clearTimeout(navigatingTimeoutId);
+			navigatingTimeoutId = null;
+		}
+	}
+	return {
+		canUndo,
+		canRedo,
+		isNavigating,
+		undo,
+		redo,
+		record,
+		recordDebounced,
+		clear,
+		destroy
+	};
 }
-
-// src/block-actions.ts
-import { createBlock, generateId } from "@templatical/types";
+//#endregion
+//#region src/block-actions.ts
 function regenerateNestedIds(block) {
-  if (block.type === "table") {
-    block.rows = block.rows.map((row) => ({
-      ...row,
-      id: generateId(),
-      cells: row.cells.map((cell) => ({ ...cell, id: generateId() }))
-    }));
-  } else if (block.type === "social") {
-    block.icons = block.icons.map((icon) => ({ ...icon, id: generateId() }));
-  } else if (block.type === "menu") {
-    block.items = block.items.map((item) => ({ ...item, id: generateId() }));
-  }
+	if (block.type === "table") block.rows = block.rows.map((row) => ({
+		...row,
+		id: generateId(),
+		cells: row.cells.map((cell) => ({
+			...cell,
+			id: generateId()
+		}))
+	}));
+	else if (block.type === "social") block.icons = block.icons.map((icon) => ({
+		...icon,
+		id: generateId()
+	}));
+	else if (block.type === "menu") block.items = block.items.map((item) => ({
+		...item,
+		id: generateId()
+	}));
 }
 function useBlockActions(options) {
-  const { addBlock, removeBlock, updateBlock, selectBlock, findBlockLocation } = options;
-  function createAndAddBlock(type, targetSectionId, columnIndex) {
-    const block = createBlock(type, options.blockDefaults);
-    addBlock(block, targetSectionId, columnIndex);
-    selectBlock(block.id);
-    return block;
-  }
-  function duplicateBlock(block, targetSectionId, columnIndex) {
-    const cloned = JSON.parse(JSON.stringify(block));
-    cloned.id = generateId();
-    regenerateNestedIds(cloned);
-    if (cloned.type === "section") {
-      cloned.children = cloned.children.map(
-        (column) => column.map((child) => {
-          const clonedChild = JSON.parse(JSON.stringify(child));
-          clonedChild.id = generateId();
-          regenerateNestedIds(clonedChild);
-          return clonedChild;
-        })
-      );
-    }
-    if (targetSectionId !== void 0 || columnIndex !== void 0) {
-      addBlock(cloned, targetSectionId, columnIndex);
-    } else {
-      const sourceLocation = findBlockLocation?.(block.id) ?? null;
-      if (sourceLocation) {
-        addBlock(
-          cloned,
-          sourceLocation.targetSectionId,
-          sourceLocation.columnIndex,
-          sourceLocation.index + 1
-        );
-      } else {
-        addBlock(cloned, targetSectionId, columnIndex);
-      }
-    }
-    selectBlock(cloned.id);
-    return cloned;
-  }
-  function deleteBlock(blockId) {
-    removeBlock(blockId);
-  }
-  function updateBlockProperty(blockId, key, value) {
-    updateBlock(blockId, { [key]: value });
-  }
-  return {
-    createAndAddBlock,
-    duplicateBlock,
-    deleteBlock,
-    updateBlockProperty
-  };
+	const { addBlock, removeBlock, updateBlock, selectBlock, findBlockLocation } = options;
+	function createAndAddBlock(type, targetSectionId, columnIndex) {
+		const block = createBlock(type, options.blockDefaults);
+		addBlock(block, targetSectionId, columnIndex);
+		selectBlock(block.id);
+		return block;
+	}
+	function duplicateBlock(block, targetSectionId, columnIndex) {
+		const cloned = JSON.parse(JSON.stringify(block));
+		cloned.id = generateId();
+		regenerateNestedIds(cloned);
+		if (cloned.type === "section") cloned.children = cloned.children.map((column) => column.map((child) => {
+			const clonedChild = JSON.parse(JSON.stringify(child));
+			clonedChild.id = generateId();
+			regenerateNestedIds(clonedChild);
+			return clonedChild;
+		}));
+		if (targetSectionId !== void 0 || columnIndex !== void 0) addBlock(cloned, targetSectionId, columnIndex);
+		else {
+			const sourceLocation = findBlockLocation?.(block.id) ?? null;
+			if (sourceLocation) addBlock(cloned, sourceLocation.targetSectionId, sourceLocation.columnIndex, sourceLocation.index + 1);
+			else addBlock(cloned, targetSectionId, columnIndex);
+		}
+		selectBlock(cloned.id);
+		return cloned;
+	}
+	function deleteBlock(blockId) {
+		removeBlock(blockId);
+	}
+	function updateBlockProperty(blockId, key, value) {
+		updateBlock(blockId, { [key]: value });
+	}
+	return {
+		createAndAddBlock,
+		duplicateBlock,
+		deleteBlock,
+		updateBlockProperty
+	};
 }
-
-// src/auto-save.ts
-import { watch } from "@vue/reactivity";
+//#endregion
+//#region src/auto-save.ts
 function useAutoSave(options) {
-  const {
-    content,
-    isDirty,
-    onChange,
-    debounce = 1e3,
-    enabled = true
-  } = options;
-  let timeoutId = null;
-  let paused = false;
-  function isEnabled() {
-    return typeof enabled === "function" ? enabled() : enabled;
-  }
-  function pause() {
-    paused = true;
-    cancel();
-  }
-  function resume() {
-    paused = false;
-  }
-  function cancel() {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  }
-  function flush() {
-    cancel();
-    if (isDirty()) {
-      onChange(JSON.parse(JSON.stringify(content.value)));
-    }
-  }
-  function scheduleOnChange() {
-    if (!isEnabled() || paused) return;
-    cancel();
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      if (isEnabled() && !paused && isDirty()) {
-        onChange(JSON.parse(JSON.stringify(content.value)));
-      }
-    }, debounce);
-  }
-  const stopWatch = watch(
-    content,
-    () => {
-      if (isEnabled() && !paused && isDirty()) {
-        scheduleOnChange();
-      }
-    },
-    { deep: true }
-  );
-  function destroy() {
-    stopWatch();
-    cancel();
-  }
-  return {
-    flush,
-    cancel,
-    pause,
-    resume,
-    destroy
-  };
+	const { content, isDirty, onChange, debounce = 1e3, enabled = true } = options;
+	let timeoutId = null;
+	let paused = false;
+	function isEnabled() {
+		return typeof enabled === "function" ? enabled() : enabled;
+	}
+	function pause() {
+		paused = true;
+		cancel();
+	}
+	function resume() {
+		paused = false;
+	}
+	function cancel() {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+	}
+	function flush() {
+		cancel();
+		if (isDirty()) onChange(JSON.parse(JSON.stringify(content.value)));
+	}
+	function scheduleOnChange() {
+		if (!isEnabled() || paused) return;
+		cancel();
+		timeoutId = setTimeout(() => {
+			timeoutId = null;
+			if (isEnabled() && !paused && isDirty()) onChange(JSON.parse(JSON.stringify(content.value)));
+		}, debounce);
+	}
+	const stopWatch = watch(content, () => {
+		if (isEnabled() && !paused && isDirty()) scheduleOnChange();
+	}, { deep: true });
+	function destroy() {
+		stopWatch();
+		cancel();
+	}
+	return {
+		flush,
+		cancel,
+		pause,
+		resume,
+		destroy
+	};
 }
-
-// src/condition-preview.ts
-import { computed as computed3, reactive as reactive2 } from "@vue/reactivity";
+//#endregion
+//#region src/condition-preview.ts
 function useConditionPreview(editor) {
-  const hiddenBlockIds = reactive2(/* @__PURE__ */ new Set());
-  const hasHiddenBlocks = computed3(() => hiddenBlockIds.size > 0);
-  function isHidden(blockId) {
-    return hiddenBlockIds.has(blockId);
-  }
-  function toggleBlock(blockId) {
-    if (hiddenBlockIds.has(blockId)) {
-      hiddenBlockIds.delete(blockId);
-    } else {
-      hiddenBlockIds.add(blockId);
-      if (editor.state.selectedBlockId === blockId) {
-        editor.selectBlock(null);
-      }
-    }
-  }
-  function reset() {
-    hiddenBlockIds.clear();
-  }
-  return {
-    isHidden,
-    toggleBlock,
-    reset,
-    hasHiddenBlocks
-  };
+	const hiddenBlockIds = reactive(/* @__PURE__ */ new Set());
+	const hasHiddenBlocks = computed(() => hiddenBlockIds.size > 0);
+	function isHidden(blockId) {
+		return hiddenBlockIds.has(blockId);
+	}
+	function toggleBlock(blockId) {
+		if (hiddenBlockIds.has(blockId)) hiddenBlockIds.delete(blockId);
+		else {
+			hiddenBlockIds.add(blockId);
+			if (editor.state.selectedBlockId === blockId) editor.selectBlock(null);
+		}
+	}
+	function reset() {
+		hiddenBlockIds.clear();
+	}
+	return {
+		isHidden,
+		toggleBlock,
+		reset,
+		hasHiddenBlocks
+	};
 }
-
-// src/data-source-fetch.ts
-import { computed as computed4, ref as ref2 } from "@vue/reactivity";
+//#endregion
+//#region src/data-source-fetch.ts
 function useDataSourceFetch(options) {
-  const isFetching = ref2(false);
-  const fetchError = ref2(false);
-  const hasDataSource = computed4(() => !!options.definition.value?.dataSource);
-  const needsFetch = computed4(
-    () => hasDataSource.value && !options.block.value.dataSourceFetched
-  );
-  async function fetch() {
-    const def = options.definition.value;
-    if (!def?.dataSource) {
-      return;
-    }
-    isFetching.value = true;
-    fetchError.value = false;
-    try {
-      const result = await def.dataSource.onFetch({
-        fieldValues: { ...options.block.value.fieldValues },
-        blockId: options.block.value.id
-      });
-      if (result == null) {
-        return;
-      }
-      const merged = { ...options.block.value.fieldValues };
-      for (const key of Object.keys(merged)) {
-        if (key in result) {
-          merged[key] = result[key];
-        }
-      }
-      options.onUpdate(merged, true);
-    } catch (error) {
-      console.warn("[Templatical] Data source fetch error:", error);
-      fetchError.value = true;
-    } finally {
-      isFetching.value = false;
-    }
-  }
-  return {
-    isFetching,
-    fetchError,
-    fetch,
-    hasDataSource,
-    needsFetch
-  };
+	const isFetching = ref(false);
+	const fetchError = ref(false);
+	const hasDataSource = computed(() => !!options.definition.value?.dataSource);
+	const needsFetch = computed(() => hasDataSource.value && !options.block.value.dataSourceFetched);
+	async function fetch() {
+		const def = options.definition.value;
+		if (!def?.dataSource) return;
+		isFetching.value = true;
+		fetchError.value = false;
+		try {
+			const result = await def.dataSource.onFetch({
+				fieldValues: { ...options.block.value.fieldValues },
+				blockId: options.block.value.id
+			});
+			if (result == null) return;
+			const merged = { ...options.block.value.fieldValues };
+			for (const key of Object.keys(merged)) if (key in result) merged[key] = result[key];
+			options.onUpdate(merged, true);
+		} catch (error) {
+			console.warn("[Templatical] Data source fetch error:", error);
+			fetchError.value = true;
+		} finally {
+			isFetching.value = false;
+		}
+	}
+	return {
+		isFetching,
+		fetchError,
+		fetch,
+		hasDataSource,
+		needsFetch
+	};
 }
-
-// src/history-interceptor.ts
+//#endregion
+//#region src/history-interceptor.ts
+/**
+* Wraps editor mutation methods to record history snapshots before each
+* operation. Mutates the editor object in place.
+*
+* Must be applied **after** any collaboration broadcast wrapping so the
+* call chain is: history.record() → broadcast → original mutation.
+*/
 function useHistoryInterceptor(editor, history) {
-  const originalAddBlock = editor.addBlock;
-  const originalRemoveBlock = editor.removeBlock;
-  const originalMoveBlock = editor.moveBlock;
-  const originalUpdateBlock = editor.updateBlock;
-  const originalUpdateSettings = editor.updateSettings;
-  editor.addBlock = (block, targetSectionId, columnIndex, index) => {
-    if (targetSectionId && editor.isBlockLocked(targetSectionId)) {
-      return;
-    }
-    history.record();
-    originalAddBlock(block, targetSectionId, columnIndex, index);
-  };
-  editor.removeBlock = (blockId) => {
-    if (editor.isBlockLocked(blockId)) {
-      return;
-    }
-    history.record();
-    originalRemoveBlock(blockId);
-  };
-  editor.moveBlock = (blockId, newIndex, targetSectionId, columnIndex) => {
-    if (editor.isBlockLocked(blockId)) {
-      return;
-    }
-    if (targetSectionId && editor.isBlockLocked(targetSectionId)) {
-      return;
-    }
-    history.record();
-    originalMoveBlock(blockId, newIndex, targetSectionId, columnIndex);
-  };
-  editor.updateBlock = (blockId, updates) => {
-    if (editor.isBlockLocked(blockId)) {
-      return;
-    }
-    history.recordDebounced(blockId);
-    originalUpdateBlock(blockId, updates);
-  };
-  editor.updateSettings = (updates) => {
-    history.record();
-    originalUpdateSettings(updates);
-  };
+	const originalAddBlock = editor.addBlock;
+	const originalRemoveBlock = editor.removeBlock;
+	const originalMoveBlock = editor.moveBlock;
+	const originalUpdateBlock = editor.updateBlock;
+	const originalUpdateSettings = editor.updateSettings;
+	editor.addBlock = (block, targetSectionId, columnIndex, index) => {
+		if (targetSectionId && editor.isBlockLocked(targetSectionId)) return;
+		history.record();
+		originalAddBlock(block, targetSectionId, columnIndex, index);
+	};
+	editor.removeBlock = (blockId) => {
+		if (editor.isBlockLocked(blockId)) return;
+		history.record();
+		originalRemoveBlock(blockId);
+	};
+	editor.moveBlock = (blockId, newIndex, targetSectionId, columnIndex) => {
+		if (editor.isBlockLocked(blockId)) return;
+		if (targetSectionId && editor.isBlockLocked(targetSectionId)) return;
+		history.record();
+		originalMoveBlock(blockId, newIndex, targetSectionId, columnIndex);
+	};
+	editor.updateBlock = (blockId, updates) => {
+		if (editor.isBlockLocked(blockId)) return;
+		history.recordDebounced(blockId);
+		originalUpdateBlock(blockId, updates);
+	};
+	editor.updateSettings = (updates) => {
+		history.record();
+		originalUpdateSettings(updates);
+	};
 }
-export {
-  useAutoSave,
-  useBlockActions,
-  useConditionPreview,
-  useDataSourceFetch,
-  useEditor,
-  useHistory,
-  useHistoryInterceptor
-};
+//#endregion
+export { useAutoSave, useBlockActions, useConditionPreview, useDataSourceFetch, useEditor, useHistory, useHistoryInterceptor };
+
 //# sourceMappingURL=index.js.map