@willwade/aac-processors 0.0.22 → 0.0.24

package/dist/processors/dotProcessor.js

@@ -8,6 +8,8 @@ const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
 // Removed unused import: FileProcessor
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const validation_1 = require("../validation");
 class DotProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -72,78 +74,94 @@ class DotProcessor extends baseProcessor_1.BaseProcessor {
         return texts;
     }
     loadIntoTree(filePathOrBuffer) {
-        let content;
+        const filename = typeof filePathOrBuffer === 'string' ? path_1.default.basename(filePathOrBuffer) : 'upload.dot';
+        const buffer = Buffer.isBuffer(filePathOrBuffer)
+            ? filePathOrBuffer
+            : fs_1.default.readFileSync(filePathOrBuffer);
+        const filesize = buffer.byteLength;
         try {
-            content =
-                typeof filePathOrBuffer === 'string'
-                    ? fs_1.default.readFileSync(filePathOrBuffer, 'utf8')
-                    : filePathOrBuffer.toString('utf8');
+            const content = buffer.toString('utf8');
+            if (!content || content.trim().length === 0) {
+                const validation = (0, validation_1.buildValidationResultFromMessage)({
+                    filename,
+                    filesize,
+                    format: 'dot',
+                    message: 'DOT file is empty',
+                    type: 'content',
+                    description: 'DOT file content',
+                });
+                throw new validation_1.ValidationFailureError('Empty DOT content', validation);
+            }
+            // Check for binary data (contains null bytes or non-printable characters)
+            const head = content.substring(0, 100);
+            for (let i = 0; i < head.length; i++) {
+                const code = head.charCodeAt(i);
+                if (code === 0 || (code >= 0 && code <= 8) || (code >= 14 && code <= 31)) {
+                    const validation = (0, validation_1.buildValidationResultFromMessage)({
+                        filename,
+                        filesize,
+                        format: 'dot',
+                        message: 'DOT appears to be binary data',
+                        type: 'content',
+                        description: 'DOT file content',
+                    });
+                    throw new validation_1.ValidationFailureError('Invalid DOT content', validation);
+                }
+            }
+            const { nodes, edges } = this.parseDotFile(content);
+            const tree = new treeStructure_1.AACTree();
+            tree.metadata.format = 'dot';
+            // Create pages for each node and add a self button representing the node label
+            for (const node of nodes) {
+                const page = new treeStructure_1.AACPage({
+                    id: node.id,
+                    name: node.label,
+                    grid: [],
+                    buttons: [],
+                    parentId: null,
+                });
+                tree.addPage(page);
+                // Add a self button so single-node graphs yield one button
+                page.addButton(new treeStructure_1.AACButton({
+                    id: `${node.id}_self`,
+                    label: node.label,
+                    message: node.label,
+                    semanticAction: {
+                        intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+                        text: node.label,
+                        fallback: { type: 'SPEAK', message: node.label },
+                    },
+                }));
+            }
+            // Create navigation buttons based on edges
+            for (const edge of edges) {
+                const fromPage = tree.getPage(edge.from);
+                if (fromPage) {
+                    const button = new treeStructure_1.AACButton({
+                        id: `nav_${edge.from}_${edge.to}`,
+                        label: edge.label || edge.to,
+                        message: '',
+                        targetPageId: edge.to,
+                    });
+                    fromPage.addButton(button);
+                }
+            }
+            return tree;
         }
         catch (error) {
-            // Re-throw file system errors (like file not found)
-            if (typeof filePathOrBuffer === 'string') {
+            if (error instanceof validation_1.ValidationFailureError) {
                 throw error;
             }
-            // For buffer errors, return empty tree
-            return new treeStructure_1.AACTree();
-        }
-        // Check if content looks like text and is non-empty
-        if (!content || content.trim().length === 0) {
-            return new treeStructure_1.AACTree();
-        }
-        // Check for binary data (contains null bytes or non-printable characters) without control-regex
-        const head = content.substring(0, 100);
-        let hasControl = false;
-        for (let i = 0; i < head.length; i++) {
-            const code = head.charCodeAt(i);
-            // Allow UTF-8 characters (code >= 127)
-            if (code === 0 || (code >= 0 && code <= 8) || (code >= 14 && code <= 31)) {
-                hasControl = true;
-                break;
-            }
-        }
-        if (hasControl) {
-            return new treeStructure_1.AACTree();
-        }
-        const { nodes, edges } = this.parseDotFile(content);
-        const tree = new treeStructure_1.AACTree();
-        tree.metadata.format = 'dot';
-        // Create pages for each node and add a self button representing the node label
-        for (const node of nodes) {
-            const page = new treeStructure_1.AACPage({
-                id: node.id,
-                name: node.label,
-                grid: [],
-                buttons: [],
-                parentId: null,
+            const validation = (0, validation_1.buildValidationResultFromMessage)({
+                filename,
+                filesize,
+                format: 'dot',
+                message: error?.message || 'Failed to parse DOT file',
+                type: 'parse',
+                description: 'Parse DOT graph',
             });
-            tree.addPage(page);
-            // Add a self button so single-node graphs yield one button
-            page.addButton(new treeStructure_1.AACButton({
-                id: `${node.id}_self`,
-                label: node.label,
-                message: node.label,
-                semanticAction: {
-                    intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
-                    text: node.label,
-                    fallback: { type: 'SPEAK', message: node.label },
-                },
-            }));
-        }
-        // Create navigation buttons based on edges
-        for (const edge of edges) {
-            const fromPage = tree.getPage(edge.from);
-            if (fromPage) {
-                const button = new treeStructure_1.AACButton({
-                    id: `nav_${edge.from}_${edge.to}`,
-                    label: edge.label || edge.to,
-                    message: '',
-                    targetPageId: edge.to,
-                });
-                fromPage.addButton(button);
-            }
+            throw new validation_1.ValidationFailureError('Failed to load DOT file', validation, error);
         }
-        return tree;
     }
     processTexts(filePathOrBuffer, translations, outputPath) {
         const safeBuffer = Buffer.isBuffer(filePathOrBuffer)

package/dist/processors/gridsetProcessor.js

@@ -561,7 +561,9 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                     for (let r = 0; r < maxRows; r++) {
                         gridLayout[r] = new Array(maxCols).fill(null);
                     }
-                    const pagePredictedWords = new Set();
+                    // Track grid-level prediction wordlists so we can attach them to AutoContent
+                    const gridPredictionWords = [];
+                    let predictionCellCounter = 0;
                     // Extract words from grid-level AutoContentCommands (e.g., Prediction Bar)
                     if (grid.AutoContentCommands) {
                         const collections = grid.AutoContentCommands.AutoContentCommandCollection;
@@ -581,7 +583,7 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                     const wordListParam = paramArr.find((p) => (p['@_Key'] || p.Key || p.key) === 'wordlist');
                                     if (wordListParam) {
                                         const words = this._extractWordsFromWordList(wordListParam);
-                                        words.forEach((w) => pagePredictedWords.add(w));
+                                        gridPredictionWords.push(...words);
                                     }
                                 }
                             });
@@ -657,6 +659,14 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                         const message = label; // Use caption as message
                         // Detect plugin cell type (Workspace, LiveCell, AutoContent)
                         const pluginMetadata = (0, pluginTypes_1.detectPluginCellType)(content);
+                        // Default labels for prediction cells so they don't render blank
+                        if (pluginMetadata.cellType === pluginTypes_1.Grid3CellType.AutoContent &&
+                            pluginMetadata.autoContentType === 'Prediction') {
+                            predictionCellCounter += 1;
+                            if (!label) {
+                                label = `Prediction ${predictionCellCounter}`;
+                            }
+                        }
                         // Parse all command types from Grid3 and create semantic actions
                         let semanticAction;
                         let legacyAction = null;
@@ -664,6 +674,7 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                         let navigationTarget;
                         let detectedCommands = []; // Store detected command metadata
                         const commands = content.Commands?.Command || content.commands?.command;
+                        let predictionWords;
                         // Resolve image for this cell using FileMap and coordinate heuristics
                         const imageCandidate = captionAndImage?.Image ||
                             captionAndImage?.image ||
@@ -705,7 +716,9 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                     }
                                     if (wlP) {
                                         const words = this._extractWordsFromWordList(wlP);
-                                        words.forEach((w) => pagePredictedWords.add(w));
+                                        if (words.length > 0) {
+                                            predictionWords = words;
+                                        }
                                     }
                                 }
                             });
@@ -746,20 +759,21 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                 // Skip PredictThis in primary action loop as it was handled in pre-pass
                                 // unless we need a primary action and nothing else exists
                                 if (commandId === 'Prediction.PredictThis') {
-                                    if (!semanticAction) {
-                                        const wlParam = getRawParam('wordlist');
-                                        if (wlParam) {
-                                            const words = this._extractWordsFromWordList(wlParam);
-                                            semanticAction = {
-                                                category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
-                                                intent: treeStructure_1.AACSemanticIntent.PLATFORM_SPECIFIC,
-                                                text: words.slice(0, 3).join(', '),
-                                                platformData: {
-                                                    grid3: { commandId, parameters: { wordlist: words } },
-                                                },
-                                                fallback: { type: 'ACTION', message: 'Predict words' },
-                                            };
-                                        }
+                                    const wlParam = getRawParam('wordlist');
+                                    const words = wlParam ? this._extractWordsFromWordList(wlParam) : [];
+                                    if (words.length > 0) {
+                                        predictionWords = words;
+                                    }
+                                    if (!semanticAction && words.length > 0) {
+                                        semanticAction = {
+                                            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                                            intent: treeStructure_1.AACSemanticIntent.PLATFORM_SPECIFIC,
+                                            text: words.slice(0, 3).join(', '),
+                                            platformData: {
+                                                grid3: { commandId, parameters: { wordlist: words } },
+                                            },
+                                            fallback: { type: 'ACTION', message: 'Predict words' },
+                                        };
                                     }
                                     continue;
                                 }
@@ -881,13 +895,9 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                     }
                                     case 'Prediction.PredictThis': {
                                         const wlParam = getRawParam('wordlist');
-                                        if (wlParam) {
-                                            const words = this._extractWordsFromWordList(wlParam);
-                                            // Add to page-wide set of predicted words
-                                            words.forEach((w) => pagePredictedWords.add(w));
-                                            // Store words in a way that analyzer can find them
-                                            // For now, we'll attach to semanticAction so it can be used later
-                                            // We only set this as the primary action if we don't have one yet
+                                        const words = wlParam ? this._extractWordsFromWordList(wlParam) : [];
+                                        if (words.length > 0) {
+                                            predictionWords = words;
                                             if (!semanticAction) {
                                                 semanticAction = {
                                                     category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
@@ -1214,6 +1224,15 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                 symbolLibraryRef: symbolLibraryRef, // Store full symbol reference
                                 grammar: isSmartGrammarCell ? grammar : undefined,
                                 isSmartGrammarCell: isSmartGrammarCell,
+                                predictions: predictionWords?.length
+                                    ? [...predictionWords]
+                                    : gridPredictionWords.length > 0
+                                        ? [...gridPredictionWords]
+                                        : undefined,
+                                predictionSlot: pluginMetadata.cellType === pluginTypes_1.Grid3CellType.AutoContent &&
+                                    pluginMetadata.autoContentType === 'Prediction'
+                                    ? predictionCellCounter
+                                    : undefined,
                             },
                         });
                         // Add button to page
@@ -1227,59 +1246,6 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             }
                         }
                     });
-                    // Process predicted words: Populate AutoContent slots first, then add virtual buttons at bottom
-                    if (pagePredictedWords.size > 0) {
-                        const extraWords = Array.from(pagePredictedWords).filter((w) => w.trim().length > 0);
-                        if (extraWords.length > 0) {
-                            let wordIdx = 0;
-                            // Step 1: Fill dedicated AutoContent prediction slots (e.g. at the top)
-                            page.buttons.forEach((btn) => {
-                                if (btn.contentType === 'AutoContent' &&
-                                    btn.contentSubType === 'Prediction' &&
-                                    wordIdx < extraWords.length) {
-                                    const word = extraWords[wordIdx++];
-                                    btn.label = word;
-                                    btn.message = word;
-                                    btn.semanticAction = {
-                                        category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
-                                        intent: treeStructure_1.AACSemanticIntent.INSERT_TEXT,
-                                        text: word,
-                                        fallback: { type: 'SPEAK', message: word },
-                                    };
-                                }
-                            });
-                            // Step 2: Add remaining words as virtual buttons at the bottom
-                            if (wordIdx < extraWords.length) {
-                                const remainingWords = extraWords.slice(wordIdx);
-                                const extraRowsCount = Math.ceil(remainingWords.length / maxCols);
-                                for (let r = 0; r < extraRowsCount; r++) {
-                                    const row = new Array(maxCols).fill(null);
-                                    for (let c = 0; c < maxCols; c++) {
-                                        const idx = r * maxCols + c;
-                                        if (idx < remainingWords.length) {
-                                            const word = remainingWords[idx];
-                                            const vBtn = new treeStructure_1.AACButton({
-                                                id: `${gridId}_vpredict_${wordIdx + idx}`,
-                                                label: word,
-                                                message: word,
-                                                x: c,
-                                                y: maxRows + r,
-                                                semanticAction: {
-                                                    category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
-                                                    intent: treeStructure_1.AACSemanticIntent.INSERT_TEXT,
-                                                    text: word,
-                                                    fallback: { type: 'SPEAK', message: word },
-                                                },
-                                            });
-                                            row[c] = vBtn;
-                                            page.addButton(vBtn);
-                                        }
-                                    }
-                                    gridLayout.push(row);
-                                }
-                            }
-                        }
-                    }
                     // Set the page's grid layout
                     page.grid = gridLayout;
                     // Generate clone_id for each button in the grid

package/dist/processors/opmlProcessor.js

@@ -9,6 +9,8 @@ const treeStructure_1 = require("../core/treeStructure");
 // Removed unused import: FileProcessor
 const fast_xml_parser_1 = require("fast-xml-parser");
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const validation_1 = require("../validation");
 class OpmlProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
@@ -88,55 +90,91 @@ class OpmlProcessor extends baseProcessor_1.BaseProcessor {
         return texts;
     }
     loadIntoTree(filePathOrBuffer) {
-        const content = typeof filePathOrBuffer === 'string'
-            ? fs_1.default.readFileSync(filePathOrBuffer, 'utf8')
-            : filePathOrBuffer.toString('utf8');
-        if (!content || !content.trim()) {
-            throw new Error('Empty OPML content');
-        }
-        // Validate XML before parsing, fast-xml-parser is permissive by default
-        const validationResult = fast_xml_parser_1.XMLValidator.validate(content);
-        if (validationResult !== true) {
-            const reason = validationResult?.err?.msg || JSON.stringify(validationResult);
-            throw new Error(`Invalid OPML XML: ${reason}`);
-        }
-        const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false });
-        let data;
+        const filename = typeof filePathOrBuffer === 'string' ? path_1.default.basename(filePathOrBuffer) : 'upload.opml';
+        const buffer = Buffer.isBuffer(filePathOrBuffer)
+            ? filePathOrBuffer
+            : fs_1.default.readFileSync(filePathOrBuffer);
+        const content = buffer.toString('utf8');
         try {
-            data = parser.parse(content);
-        }
-        catch (e) {
-            throw new Error(`Invalid OPML XML: ${e?.message || String(e)}`);
-        }
-        const tree = new treeStructure_1.AACTree();
-        tree.metadata.format = 'opml';
-        // Handle case where body.outline might not exist or be in different formats
-        const bodyOutline = data.opml?.body?.outline;
-        if (!bodyOutline) {
-            return tree; // Return empty tree if no outline data
-        }
-        const outlines = Array.isArray(bodyOutline) ? bodyOutline : [bodyOutline];
-        let firstRootId = null;
-        outlines.forEach((outline) => {
-            const { page, childPages } = this.processOutline(outline);
-            if (page && page.id) {
-                tree.addPage(page);
-                if (!firstRootId)
-                    firstRootId = page.id;
+            if (!content || !content.trim()) {
+                const validationResult = (0, validation_1.buildValidationResultFromMessage)({
+                    filename,
+                    filesize: buffer.byteLength,
+                    format: 'opml',
+                    message: 'Empty OPML content',
+                    type: 'content',
+                    description: 'OPML content is empty',
+                });
+                throw new validation_1.ValidationFailureError('Empty OPML content', validationResult);
             }
-            childPages.forEach((childPage) => {
-                if (childPage && childPage.id)
-                    tree.addPage(childPage);
+            // Validate XML before parsing, fast-xml-parser is permissive by default
+            const validationResult = fast_xml_parser_1.XMLValidator.validate(content);
+            if (validationResult !== true) {
+                const reason = validationResult?.err?.msg || JSON.stringify(validationResult);
+                const structured = (0, validation_1.buildValidationResultFromMessage)({
+                    filename,
+                    filesize: buffer.byteLength,
+                    format: 'opml',
+                    message: `Invalid OPML XML: ${reason}`,
+                    type: 'xml',
+                    description: 'OPML XML validation',
+                });
+                throw new validation_1.ValidationFailureError('Invalid OPML XML', structured);
+            }
+            const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false });
+            const data = parser.parse(content);
+            const tree = new treeStructure_1.AACTree();
+            tree.metadata.format = 'opml';
+            // Handle case where body.outline might not exist or be in different formats
+            const bodyOutline = data.opml?.body?.outline;
+            if (!bodyOutline) {
+                const structured = (0, validation_1.buildValidationResultFromMessage)({
+                    filename,
+                    filesize: buffer.byteLength,
+                    format: 'opml',
+                    message: 'Missing body.outline in OPML document',
+                    type: 'structure',
+                    description: 'OPML outline root',
+                });
+                throw new validation_1.ValidationFailureError('Invalid OPML structure', structured);
+            }
+            const outlines = Array.isArray(bodyOutline) ? bodyOutline : [bodyOutline];
+            let firstRootId = null;
+            outlines.forEach((outline) => {
+                const { page, childPages } = this.processOutline(outline);
+                if (page && page.id) {
+                    tree.addPage(page);
+                    if (!firstRootId)
+                        firstRootId = page.id;
+                }
+                childPages.forEach((childPage) => {
+                    if (childPage && childPage.id)
+                        tree.addPage(childPage);
+                });
             });
-        });
-        // Set rootId to first root page, or fallback to first page if any exist
-        if (firstRootId) {
-            tree.rootId = firstRootId;
+            // Set rootId to first root page, or fallback to first page if any exist
+            if (firstRootId) {
+                tree.rootId = firstRootId;
+            }
+            else if (Object.keys(tree.pages).length > 0) {
+                tree.rootId = Object.keys(tree.pages)[0];
+            }
+            return tree;
         }
-        else if (Object.keys(tree.pages).length > 0) {
-            tree.rootId = Object.keys(tree.pages)[0];
+        catch (err) {
+            if (err instanceof validation_1.ValidationFailureError) {
+                throw err;
+            }
+            const validationResult = (0, validation_1.buildValidationResultFromMessage)({
+                filename,
+                filesize: buffer.byteLength,
+                format: 'opml',
+                message: err?.message || 'Failed to parse OPML',
+                type: 'parse',
+                description: 'Parse OPML XML',
+            });
+            throw new validation_1.ValidationFailureError('Failed to load OPML file', validationResult, err);
         }
-        return tree;
     }
     processTexts(filePathOrBuffer, translations, outputPath) {
         const content = typeof filePathOrBuffer === 'string'

package/dist/validation/applePanelsValidator.d.ts

@@ -0,0 +1,10 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Apple Panels (.plist or .ascconfig directory)
+ */
+export declare class ApplePanelsValidator extends BaseValidator {
+    static validateFile(filePath: string): Promise<ValidationResult>;
+    static identifyFormat(content: any, filename: string): Promise<boolean>;
+    validate(content: Buffer | Uint8Array, filename: string, filesize: number): Promise<ValidationResult>;
+}

package/dist/validation/applePanelsValidator.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplePanelsValidator = void 0;
+/* eslint-disable @typescript-eslint/require-await */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plist_1 = __importDefault(require("plist"));
+const baseValidator_1 = require("./baseValidator");
+/**
+ * Validator for Apple Panels (.plist or .ascconfig directory)
+ */
+class ApplePanelsValidator extends baseValidator_1.BaseValidator {
+    static async validateFile(filePath) {
+        const validator = new ApplePanelsValidator();
+        let content;
+        const filename = path.basename(filePath);
+        let size = 0;
+        const stats = fs.existsSync(filePath) ? fs.statSync(filePath) : null;
+        if (stats?.isDirectory() && filename.toLowerCase().endsWith('.ascconfig')) {
+            const panelPath = path.join(filePath, 'Contents', 'Resources', 'PanelDefinitions.plist');
+            if (!fs.existsSync(panelPath)) {
+                return validator.validate(Buffer.alloc(0), filename, 0);
+            }
+            content = fs.readFileSync(panelPath);
+            size = fs.statSync(panelPath).size;
+        }
+        else {
+            content = fs.readFileSync(filePath);
+            size = stats?.size || content.byteLength;
+        }
+        return validator.validate(content, filename, size);
+    }
+    static async identifyFormat(content, filename) {
+        const name = filename.toLowerCase();
+        if (name.endsWith('.plist') || name.endsWith('.ascconfig')) {
+            return true;
+        }
+        try {
+            const str = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content);
+            const parsed = plist_1.default.parse(str);
+            return Boolean(parsed.panels || parsed.Panels);
+        }
+        catch {
+            return false;
+        }
+    }
+    async validate(content, filename, filesize) {
+        this.reset();
+        await this.add_check('filename', 'file extension', async () => {
+            if (!filename.toLowerCase().match(/\.(plist|ascconfig)$/)) {
+                this.warn('filename should end with .plist or .ascconfig');
+            }
+        });
+        let parsed = null;
+        await this.add_check('plist_parse', 'valid plist/XML', async () => {
+            try {
+                const str = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content);
+                parsed = plist_1.default.parse(str);
+            }
+            catch (e) {
+                this.err(`Failed to parse plist: ${e.message}`, true);
+            }
+        });
+        if (!parsed) {
+            return this.buildResult(filename, filesize, 'applepanels');
+        }
+        let panels = [];
+        await this.add_check('panels', 'panels present', async () => {
+            if (Array.isArray(parsed?.panels)) {
+                panels = parsed?.panels;
+            }
+            else if (parsed?.Panels && typeof parsed.Panels === 'object') {
+                panels = Object.values(parsed.Panels);
+            }
+            else {
+                this.err('missing panels/PanelDefinitions content', true);
+            }
+        });
+        panels.slice(0, 5).forEach((panel, idx) => {
+            const prefix = `panel[${idx}]`;
+            this.add_check_sync(`${prefix}_id`, `${prefix} id`, () => {
+                if (!panel?.ID && !panel?.id) {
+                    this.err('panel missing ID');
+                }
+            });
+            this.add_check_sync(`${prefix}_buttons`, `${prefix} buttons`, () => {
+                const buttons = Array.isArray(panel?.PanelObjects)
+                    ? panel.PanelObjects.filter((obj) => obj?.PanelObjectType === 'Button')
+                    : [];
+                if (buttons.length === 0) {
+                    this.warn('panel has no buttons');
+                }
+            });
+        });
+        return this.buildResult(filename, filesize, 'applepanels');
+    }
+}
+exports.ApplePanelsValidator = ApplePanelsValidator;

package/dist/validation/astericsValidator.d.ts

@@ -0,0 +1,16 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Asterics Grid (.grd) JSON files
+ */
+export declare class AstericsGridValidator extends BaseValidator {
+    /**
+     * Validate from disk
+     */
+    static validateFile(filePath: string): Promise<ValidationResult>;
+    /**
+     * Identify whether the content appears to be an Asterics .grd file
+     */
+    static identifyFormat(content: any, filename: string): Promise<boolean>;
+    validate(content: Buffer | Uint8Array, filename: string, filesize: number): Promise<ValidationResult>;
+}