@willwade/aac-processors 0.0.22 → 0.0.23

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/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>;
+}

package/dist/validation/astericsValidator.js

@@ -0,0 +1,115 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstericsGridValidator = void 0;
+/* eslint-disable @typescript-eslint/require-await */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const baseValidator_1 = require("./baseValidator");
+/**
+ * Validator for Asterics Grid (.grd) JSON files
+ */
+class AstericsGridValidator extends baseValidator_1.BaseValidator {
+    /**
+     * Validate from disk
+     */
+    static async validateFile(filePath) {
+        const validator = new AstericsGridValidator();
+        const content = fs.readFileSync(filePath);
+        const stats = fs.statSync(filePath);
+        return validator.validate(content, path.basename(filePath), stats.size);
+    }
+    /**
+     * Identify whether the content appears to be an Asterics .grd file
+     */
+    static async identifyFormat(content, filename) {
+        const name = filename.toLowerCase();
+        if (name.endsWith('.grd')) {
+            return true;
+        }
+        try {
+            const str = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content);
+            const json = JSON.parse(str);
+            return Array.isArray(json?.grids);
+        }
+        catch {
+            return false;
+        }
+    }
+    async validate(content, filename, filesize) {
+        this.reset();
+        await this.add_check('filename', 'file extension', async () => {
+            if (!filename.toLowerCase().endsWith('.grd')) {
+                this.warn('filename should end with .grd');
+            }
+        });
+        let json = null;
+        await this.add_check('json_parse', 'valid JSON', async () => {
+            try {
+                let str = Buffer.isBuffer(content) ? content.toString('utf-8') : String(content);
+                if (str.charCodeAt(0) === 0xfeff) {
+                    str = str.slice(1);
+                }
+                json = JSON.parse(str);
+            }
+            catch (e) {
+                this.err(`Failed to parse JSON: ${e.message}`, true);
+            }
+        });
+        if (!json) {
+            return this.buildResult(filename, filesize, 'asterics');
+        }
+        await this.add_check('grids', 'grids array', async () => {
+            if (!Array.isArray(json.grids) || json.grids.length === 0) {
+                this.err('missing grids array in file', true);
+            }
+        });
+        const grids = Array.isArray(json.grids) ? json.grids.slice(0, 5) : [];
+        grids.forEach((grid, idx) => {
+            const prefix = `grid[${idx}]`;
+            this.add_check_sync(`${prefix}_id`, `${prefix} id`, () => {
+                if (!grid?.id || typeof grid.id !== 'string') {
+                    this.err('grid is missing an id');
+                }
+            });
+            this.add_check_sync(`${prefix}_rows`, `${prefix} rowCount`, () => {
+                if (typeof grid?.rowCount !== 'number' || grid.rowCount <= 0) {
+                    this.err('rowCount must be a positive number');
+                }
+            });
+            this.add_check_sync(`${prefix}_elements`, `${prefix} elements`, () => {
+                if (!Array.isArray(grid?.gridElements)) {
+                    this.err('gridElements must be an array');
+                    return;
+                }
+                if (grid.gridElements.length === 0) {
+                    this.warn('grid has no elements');
+                }
+            });
+        });
+        return this.buildResult(filename, filesize, 'asterics');
+    }
+}
+exports.AstericsGridValidator = AstericsGridValidator;

package/dist/validation/dotValidator.d.ts

@@ -0,0 +1,10 @@
+import { BaseValidator } from './baseValidator';
+import { ValidationResult } from './validationTypes';
+/**
+ * Validator for Graphviz DOT files
+ */
+export declare class DotValidator 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>;
+}