Add Check for empty parts to OpenXmlValidator

src/DocumentFormat.OpenXml/Packaging/PresentationDocument.cs

@@ -2,11 +2,14 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using DocumentFormat.OpenXml.Builder;
+using DocumentFormat.OpenXml.Drawing;
 using DocumentFormat.OpenXml.Features;
+using DocumentFormat.OpenXml.Presentation;
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.IO.Packaging;
+using System.Linq;
 using System.Reflection;
 
 namespace DocumentFormat.OpenXml.Packaging
@@ -267,6 +270,120 @@ public static PresentationDocument Open(Package package, OpenSettings openSettin
                 .Build()
                 .Open(package);
 
+        /// <summary>
+        /// Validates whether the specified file is a minimum valid PresentationDocument.
+        /// </summary>
+        /// <param name="path">The path to the PresentationDocument file.</param>
+        /// <param name="documentType">
+        /// The expected type of the PresentationDocument. Defaults to <see cref="PresentationDocumentType.Presentation"/>.
+        /// Supported types are:
+        /// <list type="bullet">
+        /// <item><see cref="PresentationDocumentType.Presentation"/> (.pptx)</item>
+        /// <item><see cref="PresentationDocumentType.Template"/> (.potx)</item>
+        /// <item><see cref="PresentationDocumentType.MacroEnabledPresentation"/> (.pptm)</item>
+        /// <item><see cref="PresentationDocumentType.MacroEnabledTemplate"/> (.potm)</item>
+        /// </list>
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the file is a minimum valid PresentationDocument; otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="ArgumentException">
+        /// Thrown when the <paramref name="documentType"/> is invalid or unsupported.
+        /// </exception>
+        /// <remarks>
+        /// A minimum valid PresentationDocument must meet the following criteria:
+        /// <list type="bullet">
+        /// <item>The file must exist and have a valid extension matching the <paramref name="documentType"/>.</item>
+        /// <item>The file must contain a valid <see cref="NotesSize"/> element in the presentation part.</item>
+        /// </list>
+        /// Unsupported document types include:
+        /// <list type="bullet">
+        /// <item><see cref="PresentationDocumentType.AddIn"/> (.ppam)</item>
+        /// <item><see cref="PresentationDocumentType.Slideshow"/> (.ppsx)</item>
+        /// <item><see cref="PresentationDocumentType.MacroEnabledSlideshow"/> (.ppsm)</item>
+        /// </list>
+        /// </remarks>
+        public static bool IsMinimumDocument(string path, PresentationDocumentType documentType = PresentationDocumentType.Presentation)
+        {
+            if (documentType == PresentationDocumentType.AddIn || documentType == PresentationDocumentType.Slideshow || documentType == PresentationDocumentType.MacroEnabledSlideshow)
+            {
+                throw new ArgumentException($"Invalid value: {documentType}. Allowed values are PresentationDocumentType.Presentation, PresentationDocumentType.MacroEnabledPresentation, PresentationDocumentType.MacroEnabledTemplate, and PresentationDocumentType.Template.");
+            }
+
+            if (string.IsNullOrEmpty(path))
+            {
+                return false;
+            }
+
+            if (path.IndexOfAny(System.IO.Path.GetInvalidPathChars()) >= 0)
+            {
+                return false;
+            }
+
+            try
+            {
+                if (!File.Exists(path))
+                {
+                    return false;
+                }
+
+                string ext = new FileInfo(path).Extension.ToUpperInvariant();
+
+                switch (ext)
+                {
+                    case ".PPTX":
+                        if (documentType != PresentationDocumentType.Presentation)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".POTX":
+                        if (documentType != PresentationDocumentType.Template)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".PPTM":
+                        if (documentType != PresentationDocumentType.MacroEnabledPresentation)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".POTM":
+                        if (documentType != PresentationDocumentType.MacroEnabledTemplate)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".PPSX":
+                        throw new FileFormatException($"Validation for PresentationDocumentType.AddIn (.ppsx) is not supported.");
+                    case ".PPSM":
+                        throw new FileFormatException($"Validation for PresentationDocumentType.AddIn (.ppsm) is not supported.");
+                    case ".PPAM":
+                        throw new FileFormatException($"Validation for PresentationDocumentType.AddIn (.ppam) is not supported.");
+                    default:
+                        return false;
+                }
+
+                using (PresentationDocument presentationDocument = Open(path, false))
+                {
+                    NotesSize? notesSize = presentationDocument.PresentationPart?.Presentation?.NotesSize;
+
+                    return notesSize is not null && notesSize.Cx is not null && notesSize.Cx.HasValue &&
+                        notesSize.Cx >= 0 && notesSize.Cx <= 27273042316900 && notesSize.Cy is not null && notesSize.Cy.HasValue &&
+                        notesSize.Cy >= 0 && notesSize.Cy <= 27273042316900;
+                }
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
         /// <summary>
         /// Changes the document type.
         /// </summary>

src/DocumentFormat.OpenXml/Packaging/SpreadsheetDocument.cs

@@ -3,6 +3,7 @@
 
 using DocumentFormat.OpenXml.Builder;
 using DocumentFormat.OpenXml.Features;
+using DocumentFormat.OpenXml.Spreadsheet;
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
@@ -267,6 +268,111 @@ public static SpreadsheetDocument Open(System.IO.Stream stream, bool isEditable)
         public static SpreadsheetDocument Open(System.IO.Packaging.Package package)
             => Open(package, new OpenSettings());
 
+        /// <summary>
+        /// Validates whether the specified file is a minimum valid SpreadsheetDocument.
+        /// </summary>
+        /// <param name="path">The path to the SpreadsheetDocument file.</param>
+        /// <param name="documentType">
+        /// The expected type of the SpreadsheetDocument. Defaults to <see cref="SpreadsheetDocumentType.Workbook"/>.
+        /// Supported types are:
+        /// <list type="bullet">
+        /// <item><see cref="SpreadsheetDocumentType.Workbook"/> (.xlsx)</item>
+        /// <item><see cref="SpreadsheetDocumentType.Template"/> (.xltx)</item>
+        /// <item><see cref="SpreadsheetDocumentType.MacroEnabledWorkbook"/> (.xlsm)</item>
+        /// <item><see cref="SpreadsheetDocumentType.MacroEnabledTemplate"/> (.xltm)</item>
+        /// </list>
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the file is a minimum valid SpreadsheetDocument; otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="ArgumentException">
+        /// Thrown when the <paramref name="documentType"/> is invalid or unsupported.
+        /// </exception>
+        /// <remarks>
+        /// A minimum valid SpreadsheetDocument must meet the following criteria:
+        /// <list type="bullet">
+        /// <item>The file must exist and have a valid extension matching the <paramref name="documentType"/>.</item>
+        /// <item>The file must contain at least one <see cref="Sheet"/> element in the workbook part.</item>
+        /// <item>The file must contain at least one <see cref="SheetData"/> element in the worksheet part.</item>
+        /// </list>
+        /// Unsupported document types include <see cref="SpreadsheetDocumentType.AddIn"/> (.xlam).
+        /// </remarks>
+        public static bool IsMinimumDocument(string path, SpreadsheetDocumentType documentType = SpreadsheetDocumentType.Workbook)
+        {
+            if (documentType == SpreadsheetDocumentType.AddIn)
+            {
+                throw new ArgumentException($"Invalid value: {documentType}. Allowed values are SpreadsheetDocumentType.Workbook, SpreadsheetDocumentType.Template, SpreadsheetDocumentType.MacroEnabledWorkbook, and SpreadsheetDocumentType.MacroEnabledTemplate.");
+            }
+
+            if (string.IsNullOrEmpty(path))
+            {
+                return false;
+            }
+
+            if (path.IndexOfAny(System.IO.Path.GetInvalidPathChars()) >= 0)
+            {
+                return false;
+            }
+
+            try
+            {
+                if (!File.Exists(path))
+                {
+                    return false;
+                }
+
+                string ext = new FileInfo(path).Extension.ToUpperInvariant();
+
+                switch (ext)
+                {
+                    case ".XLSX":
+                        if (documentType != SpreadsheetDocumentType.Workbook)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".XLTX":
+                        if (documentType != SpreadsheetDocumentType.Template)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".XLSM":
+                        if (documentType != SpreadsheetDocumentType.MacroEnabledWorkbook)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".XLTM":
+                        if (documentType != SpreadsheetDocumentType.MacroEnabledTemplate)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".XLAM":
+                        throw new FileFormatException($"Validation for SpreadsheetDocument.AddIn (.xlam) is not supported.");
+                    default:
+                        return false;
+                }
+
+                using (SpreadsheetDocument spreadsheetDocument = Open(path, false))
+                {
+                    Sheet? sheet = spreadsheetDocument?.WorkbookPart?.Workbook?.Sheets?.GetFirstChild<Sheet>();
+                    SheetData? sheetData = spreadsheetDocument?.WorkbookPart?.WorksheetParts?.FirstOrDefaultAndMaxOne()?.Worksheet?.GetFirstChild<SheetData>();
+
+                    return sheet is not null && sheetData is not null;
+                }
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
         /// <summary>
         /// Changes the document type.
         /// </summary>

src/DocumentFormat.OpenXml/Packaging/WordprocessingDocument.cs

@@ -310,6 +310,96 @@ public static WordprocessingDocument Open(Package package, OpenSettings openSett
         public static WordprocessingDocument Open(Package package)
             => Open(package, new OpenSettings());
 
+        /// <summary>
+        /// Validates whether the specified file is a minimum valid WordprocessingDocument.
+        /// </summary>
+        /// <param name="path">The path to the WordprocessingDocument file.</param>
+        /// <param name="documentType">
+        /// The expected type of the WordprocessingDocument. Defaults to <see cref="WordprocessingDocumentType.Document"/>.
+        /// Supported types are:
+        /// <list type="bullet">
+        /// <item><see cref="WordprocessingDocumentType.Document"/> (.docx)</item>
+        /// <item><see cref="WordprocessingDocumentType.Template"/> (.dotx)</item>
+        /// <item><see cref="WordprocessingDocumentType.MacroEnabledDocument"/> (.docm)</item>
+        /// <item><see cref="WordprocessingDocumentType.MacroEnabledTemplate"/> (.dotm)</item>
+        /// </list>
+        /// </param>
+        /// <returns>
+        /// <c>true</c> if the file is a minimum valid WordprocessingDocument; otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        /// A minimum valid WordprocessingDocument must meet the following criteria:
+        /// <list type="bullet">
+        /// <item>The file must exist and have a valid extension matching the <paramref name="documentType"/>.</item>
+        /// <item>The file must contain a <see cref="Body"/> element in the main document part.</item>
+        /// </list>
+        /// </remarks>
+        public static bool IsMinimumDocument(string path, WordprocessingDocumentType documentType = WordprocessingDocumentType.Document)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return false;
+            }
+
+            if (path.IndexOfAny(System.IO.Path.GetInvalidPathChars()) >= 0)
+            {
+                return false;
+            }
+
+            try
+            {
+                if (!File.Exists(path))
+                {
+                    return false;
+                }
+
+                string ext = new FileInfo(path).Extension.ToUpperInvariant();
+
+                switch (ext)
+                {
+                    case ".DOCX":
+                        if (documentType != WordprocessingDocumentType.Document)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".DOTX":
+                        if (documentType != WordprocessingDocumentType.Template)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".DOCM":
+                        if (documentType != WordprocessingDocumentType.MacroEnabledDocument)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    case ".DOTM":
+                        if (documentType != WordprocessingDocumentType.MacroEnabledTemplate)
+                        {
+                            return false;
+                        }
+
+                        break;
+                    default:
+                        return false;
+                }
+
+                using (WordprocessingDocument wordprocessingDocument = Open(path, false))
+                {
+                    return wordprocessingDocument?.MainDocumentPart?.Document?.Body is not null;
+                }
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
         /// <summary>
         /// Changes the document type.
         /// </summary>