indesign-cli 0.2.0__py3-none-any.whl

cli_anything/indesign/server/src/handlers/textHandlers.js

@@ -0,0 +1,431 @@
+/**
+ * Text frame handlers
+ */
+import { ScriptExecutor } from '../core/scriptExecutor.js';
+import { formatResponse, formatErrorResponse, escapeJsxString } from '../utils/stringUtils.js';
+import { sessionManager } from '../core/sessionManager.js';
+
+export class TextHandlers {
+    /**
+     * Create a text frame on the active page
+     */
+    static async createTextFrame(args) {
+        const {
+            content,
+            x,
+            y,
+            width,
+            height,
+            fontSize = 12,
+            fontName = 'Arial\\tRegular',
+            textColor = 'Black',
+            alignment = 'LEFT',
+            paragraphStyle = null,
+            characterStyle = null
+        } = args;
+
+        const numericInputs = { x, y, width, height, fontSize };
+        for (const [field, value] of Object.entries(numericInputs)) {
+            if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value))) {
+                return formatErrorResponse(`${field} must be a valid number`, "Create Text Frame");
+            }
+        }
+
+        // Use session manager for positioning if coordinates not provided
+        const positioning = sessionManager.getCalculatedPositioning({ x, y, width, height });
+
+        // Validate positioning before creating content
+        const validation = sessionManager.validatePositioning(positioning.x, positioning.y, positioning.width, positioning.height);
+        if (!validation.valid) {
+            // Apply suggested corrections if available, otherwise use safe defaults
+            if (validation.suggested) {
+                Object.assign(positioning, validation.suggested);
+            } else {
+                // Fallback to safe positioning
+                const safePos = sessionManager.getCalculatedPositioning({});
+                Object.assign(positioning, safePos);
+            }
+        }
+
+        const escapedContent = escapeJsxString(content);
+        const escapedFontName = escapeJsxString(fontName);
+        const escapedParagraphStyle = paragraphStyle ? escapeJsxString(paragraphStyle) : '';
+        const escapedCharacterStyle = characterStyle ? escapeJsxString(characterStyle) : '';
+        const sanitizedTextColor = typeof textColor === 'string' && textColor.trim() !== '' ? textColor : 'Black';
+        const escapedTextColor = escapeJsxString(sanitizedTextColor);
+        const alignmentOptions = new Set(['LEFT', 'CENTER', 'RIGHT', 'JUSTIFY']);
+        const normalizedAlignment = typeof alignment === 'string' ? alignment.trim().toUpperCase() : 'LEFT';
+        const safeAlignment = alignmentOptions.has(normalizedAlignment) ? normalizedAlignment : 'LEFT';
+        const escapedAlignment = escapeJsxString(safeAlignment);
+
+        const script = [
+            'if (app.documents.length === 0) {',
+            '  "No document open";',
+            '} else {',
+            '  var doc = app.activeDocument;',
+            '  var page = app.activeWindow.activePage || doc.pages[0];',
+            '  var textFrame;',
+            '  var styleMessage = "";',
+            '',
+            '  try {',
+            '    // Create text frame',
+            `    textFrame = page.textFrames.add();`,
+            `    textFrame.geometricBounds = [${positioning.y}, ${positioning.x}, ${positioning.y + positioning.height}, ${positioning.x + positioning.width}];`,
+            `    textFrame.contents = "${escapedContent}";`,
+            '',
+            '    // Apply paragraph style if specified',
+            `    if ("${escapedParagraphStyle}" !== "") {`,
+            '      try {',
+            `        var paragraphStyle = doc.paragraphStyles.itemByName("${escapedParagraphStyle}");`,
+            '        if (paragraphStyle.isValid) {',
+            '          textFrame.paragraphs[0].appliedParagraphStyle = paragraphStyle;',
+            `          styleMessage += "Paragraph style '${escapedParagraphStyle}' applied. ";`,
+            '        } else {',
+            `          styleMessage += "Paragraph style '${escapedParagraphStyle}' not found. ";`,
+            '        }',
+            '      } catch (styleError) {',
+            `        styleMessage += "Error applying paragraph style: " + styleError.message + ". ";`,
+            '      }',
+            '    }',
+            '',
+            '    // Apply character style if specified',
+            `    if ("${escapedCharacterStyle}" !== "") {`,
+            '      try {',
+            `        var characterStyle = doc.characterStyles.itemByName("${escapedCharacterStyle}");`,
+            '        if (characterStyle.isValid) {',
+            '          textFrame.texts[0].appliedCharacterStyle = characterStyle;',
+            `          styleMessage += "Character style '${escapedCharacterStyle}' applied. ";`,
+            '        } else {',
+            `          styleMessage += "Character style '${escapedCharacterStyle}' not found. ";`,
+            '        }',
+            '      } catch (styleError) {',
+            `        styleMessage += "Error applying character style: " + styleError.message + ". ";`,
+            '      }',
+            '    }',
+            '',
+            '    // Apply direct formatting only if no styles were applied',
+            `    if ("${escapedParagraphStyle}" === "" && "${escapedCharacterStyle}" === "") {`,
+            '      // Apply text formatting',
+            '      try {',
+            `        textFrame.texts[0].appliedFont = app.fonts.itemByName("${escapedFontName}");`,
+            '      } catch (fontError) {',
+            '        // Keep the document default font when the requested font is unavailable.',
+            '      }',
+            `      textFrame.texts[0].pointSize = ${fontSize};`,
+            '',
+            '      // Apply color',
+            `      if ("${escapedTextColor}" !== "Black") {`,
+            '        try {',
+            `          textFrame.texts[0].fillColor = app.colors.itemByName("${escapedTextColor}");`,
+            '        } catch (colorError) {',
+            '          // Use default color if specified color not found',
+            '        }',
+            '      }',
+            '',
+            '      // Apply alignment',
+            `      if ("${escapedAlignment}" === "CENTER") {`,
+            '        textFrame.texts[0].justification = Justification.CENTER_ALIGN;',
+            `      } else if ("${escapedAlignment}" === "RIGHT") {`,
+            '        textFrame.texts[0].justification = Justification.RIGHT_ALIGN;',
+            `      } else if ("${escapedAlignment}" === "JUSTIFY") {`,
+            '        textFrame.texts[0].justification = Justification.FULLY_JUSTIFIED;',
+            '      } else {',
+            '        textFrame.texts[0].justification = Justification.LEFT_ALIGN;',
+            '      }',
+            '    }',
+            '',
+            '    "Text frame created successfully. " + styleMessage;',
+            '  } catch (error) {',
+            '    "Error creating text frame: " + error.message;',
+            '  }',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+
+        // Check if the operation was successful
+        const isSuccess = result.includes("Text frame created successfully");
+
+        if (isSuccess) {
+            // Store the created item info in session
+            sessionManager.setLastCreatedItem({
+                type: 'textFrame',
+                content: content,
+                position: positioning,
+                fontSize: fontSize,
+                fontName: fontName,
+                paragraphStyle: paragraphStyle,
+                characterStyle: characterStyle,
+                textColor: sanitizedTextColor,
+                alignment: safeAlignment
+            });
+        }
+
+        return isSuccess ?
+            formatResponse(result, "Create Text Frame") :
+            formatErrorResponse(result, "Create Text Frame");
+    }
+
+    /**
+     * Edit an existing text frame
+     */
+    static async editTextFrame(args) {
+        const {
+            frameIndex,
+            content,
+            fontSize,
+            fontName,
+            textColor,
+            alignment
+        } = args;
+
+        const escapedContent = content ? escapeJsxString(content) : '';
+        const escapedFontName = fontName ? escapeJsxString(fontName) : '';
+        const sanitizedTextColor = typeof textColor === 'string' ? textColor.trim() : '';
+        const escapedTextColor = sanitizedTextColor ? escapeJsxString(sanitizedTextColor) : '';
+        const normalizedAlignment = typeof alignment === 'string' ? alignment.trim().toUpperCase() : '';
+        const safeAlignment = ['LEFT', 'CENTER', 'RIGHT', 'JUSTIFY'].includes(normalizedAlignment) ? normalizedAlignment : '';
+        const escapedAlignment = safeAlignment ? escapeJsxString(safeAlignment) : '';
+
+        const script = [
+            'if (app.documents.length === 0) {',
+            '  "No document open";',
+            '} else {',
+            '  var doc = app.activeDocument;',
+            '  var page = app.activeWindow.activePage || doc.pages[0];',
+            '',
+            '  try {',
+            `    if (${frameIndex} >= page.textFrames.length) {`,
+            '      "Text frame index out of range";',
+            '    } else {',
+            `      var textFrame = page.textFrames[${frameIndex}];`,
+            '',
+            `      if ("${escapedContent}" !== "") {`,
+            `        textFrame.contents = "${escapedContent}";`,
+            '      }',
+            '',
+            `      if (${fontSize}) {`,
+            `        textFrame.texts[0].pointSize = ${fontSize};`,
+            '      }',
+            '',
+            `      if ("${escapedFontName}" !== "") {`,
+            `        textFrame.texts[0].appliedFont = app.fonts.itemByName("${escapedFontName}");`,
+            '      }',
+            '',
+            `      if ("${escapedTextColor}" !== "") {`,
+            '      try {',
+            `        textFrame.texts[0].fillColor = app.colors.itemByName("${escapedTextColor}");`,
+            '      } catch (colorError) {',
+            '        // Use default color if specified color not found',
+            '      }',
+            '      }',
+            '',
+            `      if ("${escapedAlignment}" !== "") {`,
+            `        if ("${escapedAlignment}" === "CENTER") {`,
+            '          textFrame.texts[0].justification = Justification.CENTER_ALIGN;',
+            `        } else if ("${escapedAlignment}" === "RIGHT") {`,
+            '          textFrame.texts[0].justification = Justification.RIGHT_ALIGN;',
+            `        } else if ("${escapedAlignment}" === "JUSTIFY") {`,
+            '          textFrame.texts[0].justification = Justification.FULLY_JUSTIFIED;',
+            '        } else {',
+            '          textFrame.texts[0].justification = Justification.LEFT_ALIGN;',
+            '        }',
+            '      }',
+            '',
+            '      "Text frame updated successfully";',
+            '    }',
+            '  } catch (error) {',
+            '    "Error updating text frame: " + error.message;',
+            '  }',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+        return formatResponse(result, "Edit Text Frame");
+    }
+
+    /**
+     * Create a table on the active page
+     */
+    static async createTable(args) {
+        const {
+            rows = 3,
+            columns = 3,
+            x,
+            y,
+            width,
+            height,
+            headerRows = 1,
+            headerColumns = 0
+        } = args;
+
+        // Use session manager for positioning if coordinates not provided
+        const positioning = sessionManager.getCalculatedPositioning({ x, y, width, height });
+
+        const script = [
+            'if (app.documents.length === 0) {',
+            '  "No document open";',
+            '} else {',
+            '  var doc = app.activeDocument;',
+            '  var page = app.activeWindow.activePage || doc.pages[0];',
+            '  var table;',
+            '',
+            '  try {',
+            '    // Create text frame for table',
+            '    var textFrame = page.textFrames.add();',
+            `    textFrame.geometricBounds = [${positioning.y}, ${positioning.x}, ${positioning.y + positioning.height}, ${positioning.x + positioning.width}];`,
+            '',
+            '    // Create table',
+            `    table = textFrame.insertionPoints[0].tables.add({bodyRowCount: ${rows}, bodyColumnCount: ${columns}});`,
+            '',
+            '    // Set header rows and columns',
+            `    try { table.headerRowCount = ${headerRows}; } catch (headerRowError) {}`,
+            `    try { table.headerColumnCount = ${headerColumns}; } catch (headerColumnError) {}`,
+            '',
+            '    "Table created successfully";',
+            '  } catch (error) {',
+            '    "Error creating table: " + error.message;',
+            '  }',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+
+        // Store the created item info in session
+        sessionManager.setLastCreatedItem({
+            type: 'table',
+            rows: rows,
+            columns: columns,
+            position: positioning,
+            headerRows: headerRows,
+            headerColumns: headerColumns
+        });
+
+        return formatResponse(result, "Create Table");
+    }
+
+    /**
+     * Populate a table with data
+     */
+    static async populateTable(args) {
+        const {
+            tableIndex = 0,
+            data,
+            startRow = 0,
+            startColumn = 0
+        } = args;
+
+        if (!data || !Array.isArray(data)) {
+            return formatResponse("Invalid data provided. Expected array of arrays.", "Populate Table");
+        }
+
+        const escapedData = data.map(row =>
+            row.map(cell => escapeJsxString(cell.toString()))
+        );
+
+        const script = [
+            'if (app.documents.length === 0) {',
+            '  "No document open";',
+            '} else {',
+            '  var doc = app.activeDocument;',
+            '  var page = app.activeWindow.activePage || doc.pages[0];',
+            '',
+            '  try {',
+            '    // Find table in text frames',
+            '    var table = null;',
+            '    var tableCount = 0;',
+            '',
+            '    for (var i = 0; i < page.textFrames.length; i++) {',
+            '      var textFrame = page.textFrames[i];',
+            '      if (textFrame.tables.length > 0) {',
+            `        if (tableCount === ${tableIndex}) {`,
+            '          table = textFrame.tables[0];',
+            '          break;',
+            '        }',
+            '        tableCount++;',
+            '      }',
+            '    }',
+            '',
+            '    if (!table) {',
+            `      "Table index ${tableIndex} not found";`,
+            '    } else {',
+            '      // Populate table with data',
+            `      var data = ${JSON.stringify(escapedData)};`,
+            `      var startRow = ${startRow};`,
+            `      var startColumn = ${startColumn};`,
+            '',
+            '      for (var row = 0; row < data.length; row++) {',
+            '        for (var col = 0; col < data[row].length; col++) {',
+            '          var cellRow = startRow + row;',
+            '          var cellCol = startColumn + col;',
+            '',
+            '          if (cellRow < table.rows.length && cellCol < table.columns.length) {',
+            '            var cell = table.cells.item(cellRow, cellCol);',
+            '            cell.contents = data[row][col];',
+            '          }',
+            '        }',
+            '      }',
+            '',
+            '      "Table populated successfully";',
+            '    }',
+            '  } catch (error) {',
+            '    "Error populating table: " + error.message;',
+            '  }',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+        return formatResponse(result, "Populate Table");
+    }
+
+    /**
+     * Find and replace text in the document
+     */
+    static async findReplaceText(args) {
+        const {
+            findText,
+            replaceText,
+            caseSensitive = false,
+            wholeWord = false
+        } = args;
+
+        const escapedFindText = escapeJsxString(findText);
+        const escapedReplaceText = escapeJsxString(replaceText);
+
+        const script = [
+            'if (app.documents.length === 0) {',
+            '  "No document open";',
+            '} else {',
+            '  var doc = app.activeDocument;',
+            '  var findTextPreferences = app.findTextPreferences;',
+            '  var changeTextPreferences = app.changeTextPreferences;',
+            '',
+            '  try {',
+            '    // Clear previous preferences',
+            '    app.findTextPreferences = NothingEnum.NOTHING;',
+            '    app.changeTextPreferences = NothingEnum.NOTHING;',
+            '',
+            '    // Set find preferences',
+            `    app.findTextPreferences.findWhat = "${escapedFindText}";`,
+            `    try { app.findTextPreferences.caseSensitive = ${caseSensitive}; } catch (caseError) {}`,
+            `    try { app.findTextPreferences.wholeWord = ${wholeWord}; } catch (wordError) {}`,
+            '',
+            '    // Set change preferences',
+            `    app.changeTextPreferences.changeTo = "${escapedReplaceText}";`,
+            '',
+            '    // Perform find and replace',
+            '    var foundItems = doc.changeText();',
+            '    app.findTextPreferences = NothingEnum.NOTHING;',
+            '    app.changeTextPreferences = NothingEnum.NOTHING;',
+            '',
+            '    "Find and replace completed. Items changed: " + foundItems.length;',
+            '  } catch (error) {',
+            '    "Error during find and replace: " + error.message;',
+            '  }',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+        return formatResponse(result, "Find Replace Text");
+    }
+} 

cli_anything/indesign/server/src/handlers/utilityHandlers.js

@@ -0,0 +1,83 @@
+/**
+ * Utility handlers for InDesign MCP Server
+ */
+import { ScriptExecutor } from '../core/scriptExecutor.js';
+import { formatResponse } from '../utils/stringUtils.js';
+import { sessionManager } from '../core/sessionManager.js';
+
+export class UtilityHandlers {
+    /**
+     * Execute custom InDesign code
+     */
+    static async executeInDesignCode(args) {
+        const { code } = args;
+        // Insert code as-is to avoid breaking syntax; execution wrapper handles errors
+        const script = [
+            'try {',
+            '  app.scriptPreferences.userInteractionLevel = UserInteractionLevels.NEVER_INTERACT;',
+            code || '"No code provided";',
+            '} catch (error) {',
+            '  "Error executing code: " + error.message;',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+        return formatResponse(result, "Execute InDesign Code");
+    }
+
+    /**
+     * View document information and current state
+     */
+    static async viewDocument() {
+        const script = [
+            'if (app.documents.length === 0) {',
+            '  "No document open";',
+            '} else {',
+            '  var doc = app.activeDocument;',
+            '  var activePage = null;',
+            '  try { if (app.layoutWindows.length > 0) activePage = app.layoutWindows[0].activePage; } catch (activePageError) {}',
+            '  if (!activePage && doc.pages.length > 0) activePage = doc.pages[0];',
+            '  var info = "=== DOCUMENT VIEW ===\\n";',
+            '  info += "Document: " + doc.name + "\\n";',
+            '  info += "Pages: " + doc.pages.length + "\\n";',
+            '  info += "Active Page: " + (activePage ? activePage.name : "None") + "\\n";',
+            '  try { info += "Zoom: " + app.activeWindow.zoomPercentage + "%\\n"; } catch (zoomError) { info += "Zoom: Not available\\n"; }',
+            '  try { info += "View Mode: " + app.activeWindow.displaySettings.overprintPreview + "\\n"; } catch (viewError) { info += "View Mode: Not available\\n"; }',
+            '',
+            '  // Page information',
+            '  if (doc.pages.length > 0) {',
+            '    var page = doc.pages[0];',
+            '    info += "\\n=== FIRST PAGE INFO ===\\n";',
+            '    info += "Page Name: " + page.name + "\\n";',
+            '    info += "Page Width: " + (page.bounds[3] - page.bounds[1]) + "\\n";',
+            '    info += "Page Height: " + (page.bounds[2] - page.bounds[0]) + "\\n";',
+            '    info += "Text Frames: " + page.textFrames.length + "\\n";',
+            '    info += "Rectangles: " + page.rectangles.length + "\\n";',
+            '    info += "Ovals: " + page.ovals.length + "\\n";',
+            '    info += "Polygons: " + page.polygons.length + "\\n";',
+            '  }',
+            '',
+            '  info;',
+            '}'
+        ].join('\n');
+
+        const result = await ScriptExecutor.executeInDesignScript(script);
+        return formatResponse(result, "View Document");
+    }
+
+    /**
+     * Get session information
+     */
+    static async getSessionInfo() {
+        const sessionInfo = sessionManager.getSessionSummary();
+        return formatResponse(JSON.stringify(sessionInfo, null, 2), "Get Session Info");
+    }
+
+    /**
+     * Clear session data
+     */
+    static async clearSession() {
+        sessionManager.clearSession();
+        return formatResponse("Session data cleared successfully", "Clear Session");
+    }
+} 

cli_anything/indesign/server/src/index.js

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for InDesign MCP Server
+ */
+import { InDesignMCPServer } from './core/InDesignMCPServer.js';
+
+async function main() {
+    try {
+        const server = new InDesignMCPServer();
+        await server.run();
+    } catch (error) {
+        // Log to stderr instead of stdout to avoid interfering with MCP protocol
+        console.error('Failed to start server:', error);
+        process.exit(1);
+    }
+}
+
+main(); 

cli_anything/indesign/server/src/types/index.js

@@ -0,0 +1,106 @@
+/**
+ * Tool definitions index for InDesign MCP Server
+ * Central import and export of all tool definitions
+ */
+
+import { pageToolDefinitions as rawPageToolDefinitions } from './toolDefinitionsPage.js';
+import { contentToolDefinitions as rawContentToolDefinitions } from './toolDefinitionsContent.js';
+import { documentToolDefinitions as rawDocumentToolDefinitions } from './toolDefinitionsDocument.js';
+import { exportToolDefinitions as rawExportToolDefinitions } from './toolDefinitionsExport.js';
+import { presentationToolDefinitions as rawPresentationToolDefinitions } from './toolDefinitionsPresentation.js';
+import { bookToolDefinitions as rawBookToolDefinitions } from './toolDefinitionsBook.js';
+import { utilityToolDefinitions as rawUtilityToolDefinitions } from './toolDefinitionsUtility.js';
+import { pageItemGroupToolDefinitions as rawPageItemGroupToolDefinitions } from './toolDefinitionsPageItemGroup.js';
+import { masterSpreadToolDefinitions as rawMasterSpreadToolDefinitions } from './toolDefinitionsMasterSpread.js';
+import { spreadToolDefinitions as rawSpreadToolDefinitions } from './toolDefinitionsSpread.js';
+import { layerToolDefinitions as rawLayerToolDefinitions } from './toolDefinitionsLayer.js';
+
+// Normalize schemas to comply with JSON Schema 2020-12 strictness
+function normalizeSchema(schema) {
+  if (!schema || typeof schema !== 'object') return schema;
+
+  let normalized = { ...schema };
+
+  // Recurse common combinators
+  for (const key of ['anyOf', 'oneOf', 'allOf']) {
+    if (Array.isArray(normalized[key])) {
+      normalized[key] = normalized[key].map((s) => normalizeSchema(s));
+    }
+  }
+
+  if (normalized.type === 'object') {
+    if (!Object.prototype.hasOwnProperty.call(normalized, 'additionalProperties')) {
+      normalized.additionalProperties = false;
+    }
+    const requiredFromChildren = [];
+    if (normalized.properties && typeof normalized.properties === 'object') {
+      const newProps = {};
+      for (const [k, v] of Object.entries(normalized.properties)) {
+        // Capture non-standard property-level required: true
+        if (v && typeof v === 'object' && Object.prototype.hasOwnProperty.call(v, 'required')) {
+          if (v.required === true) {
+            requiredFromChildren.push(k);
+          }
+          // Remove invalid usage regardless of value type
+          const { required, ...rest } = v;
+          newProps[k] = normalizeSchema(rest);
+        } else {
+          newProps[k] = normalizeSchema(v);
+        }
+      }
+      normalized.properties = newProps;
+    }
+    if (requiredFromChildren.length) {
+      const existing = Array.isArray(normalized.required) ? normalized.required.slice() : [];
+      for (const r of requiredFromChildren) {
+        if (!existing.includes(r)) existing.push(r);
+      }
+      normalized.required = existing;
+    }
+  }
+
+  if (normalized.type === 'array' && normalized.items) {
+    normalized.items = normalizeSchema(normalized.items);
+  }
+
+  return normalized;
+}
+
+function normalizeToolDefinition(tool) {
+  if (!tool || typeof tool !== 'object') return tool;
+  const t = { ...tool };
+  if (t.inputSchema) {
+    t.inputSchema = normalizeSchema(t.inputSchema);
+  }
+  return t;
+}
+
+// Produce normalized exports used by the server
+export const pageToolDefinitions = rawPageToolDefinitions.map(normalizeToolDefinition);
+export const contentToolDefinitions = rawContentToolDefinitions.map(normalizeToolDefinition);
+export const documentToolDefinitions = rawDocumentToolDefinitions.map(normalizeToolDefinition);
+export const exportToolDefinitions = rawExportToolDefinitions.map(normalizeToolDefinition);
+export const presentationToolDefinitions = rawPresentationToolDefinitions.map(normalizeToolDefinition);
+export const bookToolDefinitions = rawBookToolDefinitions.map(normalizeToolDefinition);
+export const utilityToolDefinitions = rawUtilityToolDefinitions.map(normalizeToolDefinition);
+export const pageItemGroupToolDefinitions = rawPageItemGroupToolDefinitions.map(normalizeToolDefinition);
+export const masterSpreadToolDefinitions = rawMasterSpreadToolDefinitions.map(normalizeToolDefinition);
+export const spreadToolDefinitions = rawSpreadToolDefinitions.map(normalizeToolDefinition);
+export const layerToolDefinitions = rawLayerToolDefinitions.map(normalizeToolDefinition);
+
+// Combine all tool definitions into a single array
+export const allToolDefinitions = [
+    ...pageToolDefinitions,
+    ...contentToolDefinitions,
+    ...documentToolDefinitions,
+    ...exportToolDefinitions,
+    ...presentationToolDefinitions,
+    ...bookToolDefinitions,
+    ...utilityToolDefinitions,
+    ...pageItemGroupToolDefinitions,
+    ...masterSpreadToolDefinitions,
+    ...spreadToolDefinitions,
+    ...layerToolDefinitions,
+];
+
+// Named exports already declared above