wip

.github/workflows/ci.yml

@@ -3,11 +3,8 @@ on:
     branches:
       - master
       - Set-up-GHA-CI/CD
-    paths-ignore:
-      - 'Examples/**'
       
   pull_request:
-  
 
 jobs:
   validate:

Examples/Charts/ChartDataSeparatePage.ps1

@@ -1,35 +0,0 @@
-$data = ConvertFrom-Csv @"
-Region,State,Units,Price
-West,Texas,927,923.71
-North,Tennessee,466,770.67
-East,Florida,520,458.68
-East,Maine,828,661.24
-West,Virginia,465,053.58
-North,Missouri,436,235.67
-South,Kansas,214,992.47
-North,North Dakota,789,640.72
-South,Delaware,712,508.55
-"@
-
-$xlfile = "$PSScriptRoot\spike.xlsx"
-Remove-Item $xlfile -ErrorAction SilentlyContinue
-
-$xlpkg = $data | Export-Excel $xlfile -WorksheetName Data -AutoNameRange -PassThru
-
-$null = Add-Worksheet -ExcelPackage $xlpkg -WorksheetName Summary -Activate
-
-$params = @{
-    Worksheet = $xlpkg.Summary
-    Title     = "Sales by Region"
-    ChartType = 'ColumnClustered'
-    
-    # XRange    = "Data!A2:A10"
-    # YRange    = "Data!C2:C10"
-
-    XRange    = 'Data!Region'
-    YRange    = 'Data!Units'
-}
-
-Add-ExcelChart  @params
-
-Close-ExcelPackage $xlpkg -Show

GRADIENT_GUIDE.md

@@ -1,152 +0,0 @@
-# Working with Gradient Fills in ImportExcel
-
-## Overview
-
-ImportExcel now provides enhanced support for working with Excel gradient fills through three new functions that address EPPlus 4.x limitations with gradient color reading.
-
-## The Issue
-
-In EPPlus 4.x (used by ImportExcel), while gradient colors can be set using `SetColor()`, they cannot be read back via properties like `Rgb`, `Top`, `Bottom`, `Left`, `Right`. This prevents copying gradients between cells.
-
-## The Solution
-
-Three new functions provide a complete gradient workflow:
-
-### Set-ExcelGradientFill
-Sets gradient fill properties for Excel ranges.
-
-```powershell
-# Basic linear gradient
-Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 90 -Color1 Blue -Color2 Green
-
-# Path gradient
-Set-ExcelGradientFill -Range $ws.Cells["B1"] -Type Path -Color1 Red -Color2 Yellow
-
-# Advanced linear gradient with positioning
-Set-ExcelGradientFill -Range $ws.Cells["C1"] -Type Linear -Degree 45 -Color1 Purple -Color2 Orange -Top 0.1 -Bottom 0.9
-```
-
-### Get-ExcelGradientFill
-Reads gradient properties that can be reliably extracted from EPPlus.
-
-```powershell
-$gradient = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-# Returns: Type, Degree, Top, Bottom, Left, Right
-# Note: Color1 and Color2 are null due to EPPlus limitations
-```
-
-### Copy-ExcelGradientFill
-Copies gradient fills between ranges using two approaches:
-
-#### Approach 1: Copy Geometric Properties Only
-```powershell
-# Copies Type, Degree, and positioning but warns about colors
-Copy-ExcelGradientFill -SourceRange $ws.Cells["A1"] -TargetRange $ws.Cells["B1"]
-```
-
-#### Approach 2: Complete Gradient Definition
-```powershell
-# Create a complete gradient definition
-$gradientDef = @{
-    Type = "Linear"
-    Degree = 45
-    Color1 = [System.Drawing.Color]::Blue
-    Color2 = [System.Drawing.Color]::Green
-    Top = 0.2
-    Bottom = 0.8
-}
-
-Copy-ExcelGradientFill -TargetRange $ws.Cells["C1:E3"] -GradientDefinition $gradientDef
-```
-
-## Complete Example
-
-```powershell
-Import-Module ImportExcel
-
-$xl = Open-ExcelPackage -Path "gradients.xlsx" -Create
-$ws = Add-WorkSheet -ExcelPackage $xl -WorksheetName "Gradients"
-
-# Set original gradient
-Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 90 -Color1 Blue -Color2 Green
-
-# Get gradient properties (geometric only)
-$gradientInfo = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-
-# Create complete definition for copying
-$completeDef = @{
-    Type = $gradientInfo.Type
-    Degree = $gradientInfo.Degree
-    Top = $gradientInfo.Top
-    Bottom = $gradientInfo.Bottom
-    Left = $gradientInfo.Left
-    Right = $gradientInfo.Right
-    Color1 = [System.Drawing.Color]::Blue    # Must specify colors
-    Color2 = [System.Drawing.Color]::Green
-}
-
-# Copy to other cells
-Copy-ExcelGradientFill -TargetRange $ws.Cells["B1:D3"] -GradientDefinition $completeDef
-
-Close-ExcelPackage -ExcelPackage $xl -SaveAs "gradients.xlsx"
-```
-
-## Migration from Direct EPPlus Access
-
-### Before (Limited by EPPlus 4.x):
-```powershell
-# Setting worked
-$Sheet.Cells["A1"].Style.Fill.Gradient.Color1.SetColor("BLUE")
-$Sheet.Cells["A1"].Style.Fill.Gradient.Color2.SetColor("GREEN")
-
-# Reading failed - returned empty values
-$rgb = $Sheet.Cells["A1"].Style.Fill.Gradient.Color1.Rgb  # Empty!
-```
-
-### After (Using ImportExcel functions):
-```powershell
-# Setting is easier and more robust
-Set-ExcelGradientFill -Range $Sheet.Cells["A1"] -Type Linear -Degree 90 -Color1 Blue -Color2 Green
-
-# Reading works for geometric properties
-$gradient = Get-ExcelGradientFill -Range $Sheet.Cells["A1"]
-# $gradient.Type, $gradient.Degree work; colors need to be specified separately
-
-# Copying now possible with complete definitions
-$gradientDef = @{
-    Type = $gradient.Type
-    Degree = $gradient.Degree
-    Color1 = [System.Drawing.Color]::Blue
-    Color2 = [System.Drawing.Color]::Green
-}
-Copy-ExcelGradientFill -TargetRange $Sheet.Cells["B1"] -GradientDefinition $gradientDef
-```
-
-## Parameters Reference
-
-### Set-ExcelGradientFill Parameters
-- **Range**: Target Excel range (required)
-- **Type**: "Linear" or "Path" (required)
-- **Degree**: Angle for linear gradients (0-360, default 90)
-- **Color1**: First color - Color object or string name (required)
-- **Color2**: Second color - Color object or string name (required)
-- **Top/Bottom/Left/Right**: Position values (0-1, optional)
-
-### Copy-ExcelGradientFill Parameters
-- **SourceRange**: Source range (for copying geometric properties)
-- **TargetRange**: Target range (required)
-- **GradientDefinition**: Hashtable with gradient properties (alternative to SourceRange)
-
-## Limitations
-
-- Color properties cannot be read from existing gradients due to EPPlus 4.x limitations
-- When copying gradients, colors must be specified manually in the gradient definition
-- Functions provide warnings when color limitations affect operations
-
-## Benefits
-
-- Clean, PowerShell-friendly interface for gradient operations
-- Comprehensive parameter validation
-- Clear error messages and warnings
-- Supports both string color names and Color objects
-- Enables gradient copying workflows that weren't possible before

ImportExcel.psd1

@@ -6,7 +6,7 @@
     RootModule         = 'ImportExcel.psm1'
 
     # Version number of this module.
-    ModuleVersion      = '7.8.10'
+    ModuleVersion      = '7.8.4'
 
     # ID used to uniquely identify this module
     GUID               = '60dd4136-feff-401a-ba27-a84458c57ede'
@@ -46,7 +46,6 @@ Check out the How To Videos https://www.youtube.com/watch?v=U3Ne_yX4tYo&list=PL5
         'ConvertFrom-ExcelSheet',
         'ConvertFrom-ExcelToSQLInsert',
         'ConvertTo-ExcelXlsx',
-        'Copy-ExcelGradientFill',
         'Copy-ExcelWorksheet',
         'DoChart',
         'Enable-ExcelAutoFilter',
@@ -55,9 +54,7 @@ Check out the How To Videos https://www.youtube.com/watch?v=U3Ne_yX4tYo&list=PL5
         'Export-Excel',
         'Export-ExcelSheet',        
         'Get-ExcelColumnName',
-        'Get-ExcelFileSchema',
         'Get-ExcelFileSummary', 
-        'Get-ExcelGradientFill',
         'Get-ExcelSheetDimensionAddress',       
         'Get-ExcelSheetInfo',
         'Get-ExcelWorkbookInfo',
@@ -94,7 +91,6 @@ Check out the How To Videos https://www.youtube.com/watch?v=U3Ne_yX4tYo&list=PL5
         'Set-CellComment',
         'Set-CellStyle',
         'Set-ExcelColumn',
-        'Set-ExcelGradientFill',
         'Set-ExcelRange',
         'Set-ExcelRow',
         'Set-WorksheetProtection',
@@ -153,7 +149,7 @@ Check out the How To Videos https://www.youtube.com/watch?v=U3Ne_yX4tYo&list=PL5
             Tags         = @("Excel", "EPPlus", "Export", "Import")
 
             # The web address of an icon which can be used in galleries to represent this module
-            #IconUri = 
+            #IconUri = "http://pesterbdd.com/images/Pester.png"
 
             # The web address of this module's project or support homepage.
             ProjectUri   = "https://github.com/dfinke/ImportExcel"
@@ -218,4 +214,4 @@ Check out the How To Videos https://www.youtube.com/watch?v=U3Ne_yX4tYo&list=PL5
     # Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix.
     # DefaultCommandPrefix = ''
 
-}
+}

Private/ArgumentCompletion.ps1

@@ -67,8 +67,9 @@ function WorksheetArgumentCompleter {
     param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameter)
     $xlPath = $fakeBoundParameter['Path']
     if (Test-Path -Path $xlPath) {
-        $xlSheet = Get-ExcelSheetInfo -Path $xlPath
-        $WorksheetNames = $xlSheet.Name
+        $xlpkg = Open-ExcelPackage -ReadOnly -Path $xlPath
+        $WorksheetNames = $xlPkg.Workbook.Worksheets.Name
+        Close-ExcelPackage -nosave -ExcelPackage $xlpkg
         $WorksheetNames.where( { $_ -like "*$wordToComplete*" }) | foreach-object {
             New-Object -TypeName System.Management.Automation.CompletionResult -ArgumentList "'$_'",
             $_ , ([System.Management.Automation.CompletionResultType]::ParameterValue) , $_

Public/ConvertFrom-ExcelData.ps1

@@ -8,8 +8,7 @@ function ConvertFrom-ExcelData {
         [ScriptBlock]$ScriptBlock,
         [Alias("Sheet")]
         $WorksheetName = 1,
-		[Alias('HeaderRow', 'TopRow')]
-        [int]$StartRow = 1,
+        [int]$HeaderRow = 1,
         [string[]]$Header,
         [switch]$NoHeader,
         [switch]$DataOnly

Public/ConvertTo-ExcelXlsx.ps1

@@ -45,18 +45,11 @@ function ConvertTo-ExcelXlsx {
             throw "Could not create Excel.Application ComObject. Please verify that Excel is installed."
         }
 
-        try {  
-            $Excel.Visible = $false
-            $null = $Excel.Workbooks.Open($xlsFile.FullName, $null, $true)
-            $Excel.ActiveWorkbook.SaveAs($xlsxPath, $xlFixedFormat)
-        }
-        finally {
-            if ($null -ne $Excel.ActiveWorkbook) {
-                $Excel.ActiveWorkbook.Close()
-            }
-            
-            $Excel.Quit()
-        }
+        $Excel.Visible = $false
+        $null = $Excel.Workbooks.Open($xlsFile.FullName)
+        $Excel.ActiveWorkbook.SaveAs($xlsxPath, $xlFixedFormat)
+        $Excel.ActiveWorkbook.Close()
+        $Excel.Quit()
     }
 }
 

Public/Copy-ExcelGradientFill.ps1

@@ -1,119 +0,0 @@
-function Copy-ExcelGradientFill {
-    <#
-    .SYNOPSIS
-    Copies gradient fill settings from one Excel range to another.
-    
-    .DESCRIPTION
-    Due to limitations in EPPlus 4.x, gradient color properties cannot be read directly.
-    This function provides a workaround by storing gradient definitions and applying them
-    to target ranges.
-    
-    .PARAMETER SourceRange
-    The source range with the gradient fill to copy.
-    
-    .PARAMETER TargetRange
-    The target range where the gradient fill should be applied.
-    
-    .PARAMETER GradientDefinition
-    A hashtable containing gradient definition with properties:
-    - Type: Linear or Path
-    - Degree: Angle for linear gradients (0-360)
-    - Top, Bottom, Left, Right: Position values (0-1)
-    - Color1: First color (System.Drawing.Color or color name)
-    - Color2: Second color (System.Drawing.Color or color name)
-    
-    .EXAMPLE
-    # Copy gradient from A1 to B1:C2
-    Copy-ExcelGradientFill -SourceRange $ws.Cells["A1"] -TargetRange $ws.Cells["B1:C2"]
-    
-    .EXAMPLE
-    # Apply a custom gradient definition
-    $gradient = @{
-        Type = "Linear"
-        Degree = 45
-        Color1 = [System.Drawing.Color]::Blue
-        Color2 = [System.Drawing.Color]::Green
-        Top = 0
-        Bottom = 1
-        Left = 0
-        Right = 1
-    }
-    Copy-ExcelGradientFill -TargetRange $ws.Cells["A1:B2"] -GradientDefinition $gradient
-    
-    .NOTES
-    This function works around EPPlus 4.x limitations with gradient color reading.
-    #>
-    [CmdletBinding(DefaultParameterSetName = 'CopyFromSource')]
-    param(
-        [Parameter(ParameterSetName = 'CopyFromSource', Mandatory)]
-        $SourceRange,
-        
-        [Parameter(Mandatory)]
-        $TargetRange,
-        
-        [Parameter(ParameterSetName = 'ApplyDefinition', Mandatory)]
-        [hashtable]$GradientDefinition
-    )
-    
-    if ($PSCmdlet.ParameterSetName -eq 'CopyFromSource') {
-        # Extract gradient properties from source
-        $sourceGradient = $SourceRange.Style.Fill.Gradient
-        
-        # Create gradient definition from source
-        $GradientDefinition = @{
-            Type = $sourceGradient.Type
-            Degree = $sourceGradient.Degree
-            Top = $sourceGradient.Top
-            Bottom = $sourceGradient.Bottom
-            Left = $sourceGradient.Left
-            Right = $sourceGradient.Right
-        }
-        
-        # Note: Colors cannot be copied due to EPPlus limitation
-        Write-Warning "Gradient colors cannot be copied due to EPPlus 4.x limitations. Only geometric properties (Type, Degree, positioning) are copied. Please use Set-ExcelGradientFill to set colors."
-    }
-    
-    # Apply gradient definition to target
-    $targetGradient = $TargetRange.Style.Fill.Gradient
-    
-    if ($GradientDefinition.Type) {
-        $targetGradient.Type = [OfficeOpenXml.Style.ExcelFillGradientType]::$($GradientDefinition.Type)
-    }
-    
-    if ($GradientDefinition.ContainsKey('Degree')) {
-        $targetGradient.Degree = $GradientDefinition.Degree
-    }
-    
-    if ($GradientDefinition.ContainsKey('Top')) {
-        $targetGradient.Top = $GradientDefinition.Top
-    }
-    
-    if ($GradientDefinition.ContainsKey('Bottom')) {
-        $targetGradient.Bottom = $GradientDefinition.Bottom
-    }
-    
-    if ($GradientDefinition.ContainsKey('Left')) {
-        $targetGradient.Left = $GradientDefinition.Left
-    }
-    
-    if ($GradientDefinition.ContainsKey('Right')) {
-        $targetGradient.Right = $GradientDefinition.Right
-    }
-    
-    # Set colors if provided
-    if ($GradientDefinition.Color1) {
-        $color1 = $GradientDefinition.Color1
-        if ($color1 -is [string]) {
-            $color1 = [System.Drawing.Color]::$color1
-        }
-        $targetGradient.Color1.SetColor($color1)
-    }
-    
-    if ($GradientDefinition.Color2) {
-        $color2 = $GradientDefinition.Color2
-        if ($color2 -is [string]) {
-            $color2 = [System.Drawing.Color]::$color2
-        }
-        $targetGradient.Color2.SetColor($color2)
-    }
-}

Public/Get-ExcelFileSchema.ps1

@@ -1,47 +0,0 @@
-function Get-ExcelFileSchema {
-    <#
-        .SYNOPSIS
-            Gets the schema of an Excel file.
-
-        .DESCRIPTION
-            The Get-ExcelFileSchema function gets the schema of an Excel file by returning the property names of the first row of each worksheet in the file.
-
-        .PARAMETER Path
-            Specifies the path to the Excel file.
-
-        .PARAMETER Compress
-            Indicates whether to compress the json output.
-
-        .OUTPUTS
-            Json
-
-        .EXAMPLE
-            Get-ExcelFileSchema -Path .\example.xlsx
-    #>
-
-    [CmdletBinding()]
-    param(
-        [Parameter(ValueFromPipelineByPropertyName, Mandatory)]
-        [Alias('FullName')]    
-        $Path,
-        [Switch]$Compress
-    )
-
-    Begin {
-        $result = @()
-    }
-
-    Process {        
-        $excelFiles = Get-ExcelFileSummary $Path
-        
-        foreach ($excelFile in $excelFiles) {
-            $data = Import-Excel $Path -WorksheetName $excelFile.WorksheetName | Select-Object -First 1
-            $names = $data[0].PSObject.Properties.name
-            $result += $excelFile | Add-Member -MemberType NoteProperty -Name "PropertyNames" -Value $names -PassThru
-        }
-    }
-
-    End {
-        $result | ConvertTo-Json -Compress:$Compress
-    }
-}

Public/Get-ExcelGradientFill.ps1

@@ -1,52 +0,0 @@
-function Get-ExcelGradientFill {
-    <#
-    .SYNOPSIS
-    Gets gradient fill properties from an Excel range.
-    
-    .DESCRIPTION
-    This function extracts gradient fill properties that can be reliably read from EPPlus 4.x.
-    Due to EPPlus limitations, gradient colors cannot be read directly and will return $null.
-    
-    .PARAMETER Range
-    The Excel range to read gradient properties from.
-    
-    .EXAMPLE
-    # Get gradient properties from a cell
-    $gradientInfo = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-    
-    .EXAMPLE
-    # Get gradient properties and use them to copy to another range
-    $gradient = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-    # Add colors since they can't be read
-    $gradient.Color1 = [System.Drawing.Color]::Blue
-    $gradient.Color2 = [System.Drawing.Color]::Green
-    Copy-ExcelGradientFill -TargetRange $ws.Cells["B1:C2"] -GradientDefinition $gradient
-    
-    .NOTES
-    Due to EPPlus 4.x limitations, Color1 and Color2 properties will always be $null.
-    This function is provided for completeness and to work with Copy-ExcelGradientFill.
-    #>
-    [CmdletBinding()]
-    param(
-        [Parameter(Mandatory, ValueFromPipeline)]
-        $Range
-    )
-    
-    process {
-        $gradient = $Range.Style.Fill.Gradient
-        
-        $result = [PSCustomObject]@{
-            Type = $gradient.Type
-            Degree = $gradient.Degree
-            Top = $gradient.Top
-            Bottom = $gradient.Bottom
-            Left = $gradient.Left
-            Right = $gradient.Right
-            Color1 = $null  # Cannot be read due to EPPlus 4.x limitation
-            Color2 = $null  # Cannot be read due to EPPlus 4.x limitation
-            ColorLimitationNote = "Color properties cannot be read due to EPPlus 4.x limitations"
-        }
-        
-        return $result
-    }
-}

Public/Get-HtmlTable.ps1

@@ -50,9 +50,7 @@ function Get-HtmlTable {
     else {
         $h    = ConvertFrom-Html -Content $r.Content
         if ($TableIndex -is [valuetype]) { $TableIndex += 1}
-        $rows = try {
-               $h.SelectSingleNode("//table[$TableIndex]").SelectNodes(".//tr")
-        } catch {}
+        $rows =    $h.SelectNodes("//table[$TableIndex]//tr")
         if (-not $rows) {Write-Warning "Could not find rows for `"//table[$TableIndex]`" in $Url ."}
         if ( -not  $propertyNames) {
             if (   $tableHeaders  = $rows[$FirstDataRow].SelectNodes("th")) {

Public/Import-Excel.ps1

@@ -37,7 +37,8 @@
         [ValidateNotNullOrEmpty()]
         [String]$Password,
         [Int[]]$ImportColumns,
-        [Switch]$Raw
+        [Switch]$Raw,
+        [Switch]$UseSpectre
     )
     end {
         $sw = [System.Diagnostics.Stopwatch]::StartNew()
@@ -252,6 +253,9 @@
                         $entry.Value
                     }
                 }
+                elseif ($UseSpectre) {
+                    $xlBook | Format-SpectreTable
+                }
                 elseif ($Worksheet.Count -eq 1) {
                     $xlBook["$targetSheetname"]
                 }

Public/Set-ExcelGradientFill.ps1

@@ -1,128 +0,0 @@
-function Set-ExcelGradientFill {
-    <#
-    .SYNOPSIS
-    Sets gradient fill properties for an Excel range.
-    
-    .DESCRIPTION
-    This function provides a complete interface for setting gradient fills in Excel ranges,
-    working around EPPlus 4.x limitations with gradient handling.
-    
-    .PARAMETER Range
-    The Excel range to apply the gradient fill to.
-    
-    .PARAMETER Type
-    The gradient type: Linear or Path.
-    
-    .PARAMETER Degree
-    The angle for linear gradients (0-360 degrees).
-    
-    .PARAMETER Color1
-    The first gradient color. Can be a System.Drawing.Color object or color name.
-    
-    .PARAMETER Color2
-    The second gradient color. Can be a System.Drawing.Color object or color name.
-    
-    .PARAMETER Top
-    The top position for gradient positioning (0-1).
-    
-    .PARAMETER Bottom
-    The bottom position for gradient positioning (0-1).
-    
-    .PARAMETER Left
-    The left position for gradient positioning (0-1).
-    
-    .PARAMETER Right
-    The right position for gradient positioning (0-1).
-    
-    .EXAMPLE
-    # Set a simple blue to green linear gradient
-    Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 90 -Color1 Blue -Color2 Green
-    
-    .EXAMPLE
-    # Set a more complex gradient with positioning
-    Set-ExcelGradientFill -Range $ws.Cells["A1:C3"] -Type Linear -Degree 45 -Color1 ([System.Drawing.Color]::Red) -Color2 ([System.Drawing.Color]::Yellow) -Top 0.2 -Bottom 0.8
-    
-    .EXAMPLE
-    # Set a path gradient
-    Set-ExcelGradientFill -Range $ws.Cells["B1:D3"] -Type Path -Color1 "DarkBlue" -Color2 "LightBlue"
-    
-    .NOTES
-    This function addresses the EPPlus 4.x limitation where gradient colors cannot be read back.
-    #>
-    [CmdletBinding()]
-    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Does not change system state')]
-    param(
-        [Parameter(Mandatory, ValueFromPipeline)]
-        $Range,
-        
-        [Parameter(Mandatory)]
-        [ValidateSet('Linear', 'Path')]
-        [string]$Type,
-        
-        [Parameter()]
-        [ValidateRange(0, 360)]
-        [double]$Degree = 90,
-        
-        [Parameter(Mandatory)]
-        $Color1,
-        
-        [Parameter(Mandatory)]
-        $Color2,
-        
-        [Parameter()]
-        [ValidateRange(0, 1)]
-        [double]$Top,
-        
-        [Parameter()]
-        [ValidateRange(0, 1)]
-        [double]$Bottom,
-        
-        [Parameter()]
-        [ValidateRange(0, 1)]
-        [double]$Left,
-        
-        [Parameter()]
-        [ValidateRange(0, 1)]
-        [double]$Right
-    )
-    
-    process {
-        $gradient = $Range.Style.Fill.Gradient
-        
-        # Set gradient type
-        $gradient.Type = [OfficeOpenXml.Style.ExcelFillGradientType]::$Type
-        
-        # Set degree for linear gradients
-        if ($Type -eq 'Linear') {
-            $gradient.Degree = $Degree
-        }
-        
-        # Set positioning if provided
-        if ($PSBoundParameters.ContainsKey('Top')) {
-            $gradient.Top = $Top
-        }
-        
-        if ($PSBoundParameters.ContainsKey('Bottom')) {
-            $gradient.Bottom = $Bottom
-        }
-        
-        if ($PSBoundParameters.ContainsKey('Left')) {
-            $gradient.Left = $Left
-        }
-        
-        if ($PSBoundParameters.ContainsKey('Right')) {
-            $gradient.Right = $Right
-        }
-        
-        # Set colors
-        if ($Color1 -is [string]) {
-            $Color1 = [System.Drawing.Color]::$Color1
-        }
-        $gradient.Color1.SetColor($Color1)
-        
-        if ($Color2 -is [string]) {
-            $Color2 = [System.Drawing.Color]::$Color2
-        }
-        $gradient.Color2.SetColor($Color2)
-    }
-}

README.md

@@ -19,13 +19,10 @@ Consider donating. Thank you!
 <br>
 <br>
 
-[![Follow on Twitter](https://img.shields.io/twitter/follow/dfinke.svg?style=social&label=Follow%20%40dfinke)](https://twitter.com/dfinke)
-[![Subscribe on YouTube](https://img.shields.io/youtube/channel/subscribers/UCP47ZkO5EDkoI2sr-3P4ShQ
-)](https://youtube.com/@dougfinke/)
-<br/>
-<br/>
+[![Build Status](https://dougfinke.visualstudio.com/ImportExcel/_apis/build/status/dfinke.ImportExcel?branchName=master)](https://dougfinke.visualstudio.com/ImportExcel/_build)
 [![](https://img.shields.io/powershellgallery/v/ImportExcel.svg)](https://www.powershellgallery.com/packages/ImportExcel)
 [![](https://img.shields.io/powershellgallery/dt/ImportExcel.svg)](https://www.powershellgallery.com/packages/ImportExcel)
+[![](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/dfinke/ImportExcel/tree/70ab9e46c776e96fb287682d5b9b4b51a0ec3bac/LICENSE.txt)
 <a href="https://www.paypal.com/paypalme/DougCharlesFinke"><img src="https://img.shields.io/badge/Donate-PayPal-green.svg" alt="Donate"></a>
 
 # Overview
@@ -191,14 +188,4 @@ ForEach-Object { $_.Value | Export-Csv ($_.key + '.csv') }
 ## Contributing
 Contributions are welcome! Open a pull request to fix a bug, or open an issue to discuss a new feature or change.
 
-## New Features
-
-### Gradient Fill Support
-ImportExcel now includes enhanced gradient fill support with three new functions:
-- `Set-ExcelGradientFill` - Apply gradient fills to Excel ranges
-- `Get-ExcelGradientFill` - Read gradient properties from ranges  
-- `Copy-ExcelGradientFill` - Copy gradients between ranges
-
-These functions work around EPPlus 4.x limitations with gradient color reading. See [GRADIENT_GUIDE.md](GRADIENT_GUIDE.md) for detailed usage examples.
-
 Original [README.md](./README.original.md)

__tests__/Get-ExcelFileSchema.tests.ps1

@@ -1,54 +0,0 @@
-if (-not (Get-command Import-Excel -ErrorAction SilentlyContinue)) {
-    Import-Module $PSScriptRoot\..\ImportExcel.psd1
-}
-
-Describe "Test getting the schema of an Excel file" -Tag GetExcelFileSchema {
-
-    BeforeAll {
-        $script:excelFile = "TestDrive:\test.xlsx"
-        $data = ConvertFrom-Csv @"
-Region,State,Units,Price
-West,Texas,927,923.71
-North,Tennessee,466,770.67
-East,Florida,520,458.68
-East,Maine,828,661.24
-West,Virginia,465,053.58
-North,Missouri,436,235.67
-South,Kansas,214,992.47
-North,North Dakota,789,640.72
-South,Delaware,712,508.55
-"@
-        $data | Export-Excel $excelFile 
-    }
-
-    It "Test Get-ExcelFileSchema function exists" {        
-        $function = Get-Command Get-ExcelFileSchema -ErrorAction SilentlyContinue
-        $function | Should -Not -Be $null
-    }
-
-    It "Test Get-ExcelFileSchema returns json" {
-        $actual = Get-ExcelFileSchema -Path $excelFile
-        $actual | Should -Not -Be $null
-        $actual | Should -BeOfType [string]        
-    }
-
-    It "Test Get-ExcelFileSchema correct json" {
-        $actual = Get-ExcelFileSchema -Path $excelFile
-        $actual = $actual | ConvertFrom-Json 
-
-        $actual.ExcelFile | Should -BeExactly "test.xlsx"
-        $actual.WorksheetName | Should -BeExactly "Sheet1"
-        $actual.Visible | Should -Be $true
-        $actual.Rows | Should -Be 10
-        $actual.Columns | Should -Be 4
-        $actual.Address | Should -BeExactly "A1:D10"
-        
-        $actual.Path | Should -BeExactly ("TestDrive:" + [System.IO.Path]::DirectorySeparatorChar)
-        
-        $actual.PropertyNames.Count | Should -Be 4
-        $actual.PropertyNames[0] | Should -BeExactly "Region"
-        $actual.PropertyNames[1] | Should -BeExactly "State"
-        $actual.PropertyNames[2] | Should -BeExactly "Units"
-        $actual.PropertyNames[3] | Should -BeExactly "Price"
-    }
-}

__tests__/GradientFill.tests.ps1

@@ -1,219 +0,0 @@
-Describe "Gradient Fill Functions" {
-    BeforeAll {
-        $script:testPath = "TestDrive:\GradientTest.xlsx"
-        Remove-Item -Path $testPath -ErrorAction SilentlyContinue
-        
-        # Import the module
-        Import-Module "$PSScriptRoot\..\ImportExcel.psd1" -Force
-    }
-    
-    Context "Set-ExcelGradientFill Tests" {
-        BeforeEach {
-            $script:xl = Open-ExcelPackage -Path $testPath -Create
-            $script:ws = Add-WorkSheet -ExcelPackage $xl -WorksheetName "GradientTest"
-        }
-        
-        AfterEach {
-            Close-ExcelPackage -ExcelPackage $xl
-            Remove-Item -Path $testPath -ErrorAction SilentlyContinue
-        }
-        
-        It "Should set linear gradient with basic properties" {
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 90 -Color1 Blue -Color2 Green
-            
-            $gradient = $ws.Cells["A1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Linear"
-            $gradient.Degree | Should -Be 90
-        }
-        
-        It "Should set path gradient" {
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Path -Color1 Red -Color2 Yellow
-            
-            $gradient = $ws.Cells["A1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Path"
-        }
-        
-        It "Should set linear gradient with positioning" {
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 45 -Color1 Blue -Color2 Green -Top 0.2 -Bottom 0.8 -Left 0.1 -Right 0.9
-            
-            $gradient = $ws.Cells["A1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Linear"
-            $gradient.Degree | Should -Be 45
-            $gradient.Top | Should -Be 0.2
-            $gradient.Bottom | Should -Be 0.8
-            $gradient.Left | Should -Be 0.1
-            $gradient.Right | Should -Be 0.9
-        }
-        
-        It "Should accept System.Drawing.Color objects" {
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Color1 ([System.Drawing.Color]::Red) -Color2 ([System.Drawing.Color]::Blue)
-            
-            $gradient = $ws.Cells["A1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Linear"
-        }
-        
-        It "Should work with ranges" {
-            Set-ExcelGradientFill -Range $ws.Cells["A1:C3"] -Type Linear -Degree 135 -Color1 "Purple" -Color2 "Orange"
-            
-            $gradient = $ws.Cells["A1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Linear"
-            $gradient.Degree | Should -Be 135
-        }
-        
-        It "Should validate degree range" {
-            { Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 400 -Color1 Blue -Color2 Green } | Should -Throw
-        }
-        
-        It "Should validate position range" {
-            { Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Color1 Blue -Color2 Green -Top 1.5 } | Should -Throw
-        }
-    }
-    
-    Context "Get-ExcelGradientFill Tests" {
-        BeforeEach {
-            $script:xl = Open-ExcelPackage -Path $testPath -Create
-            $script:ws = Add-WorkSheet -ExcelPackage $xl -WorksheetName "GradientTest"
-        }
-        
-        AfterEach {
-            Close-ExcelPackage -ExcelPackage $xl
-            Remove-Item -Path $testPath -ErrorAction SilentlyContinue
-        }
-        
-        It "Should get gradient properties that can be read" {
-            # Set a gradient first
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 45 -Color1 Blue -Color2 Green -Top 0.3 -Bottom 0.7
-            
-            $result = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-            
-            $result.Type | Should -Be "Linear"
-            $result.Degree | Should -Be 45
-            $result.Top | Should -Be 0.3
-            $result.Bottom | Should -Be 0.7
-            $result.Color1 | Should -BeNullOrEmpty
-            $result.Color2 | Should -BeNullOrEmpty
-            $result.ColorLimitationNote | Should -Match "EPPlus.*limitation"
-        }
-        
-        It "Should return PSCustomObject with expected properties" {
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Path -Color1 Red -Color2 Blue
-            
-            $result = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-            
-            $result | Should -BeOfType [PSCustomObject]
-            $result.PSObject.Properties.Name | Should -Contain "Type"
-            $result.PSObject.Properties.Name | Should -Contain "Degree"
-            $result.PSObject.Properties.Name | Should -Contain "Color1"
-            $result.PSObject.Properties.Name | Should -Contain "Color2"
-            $result.PSObject.Properties.Name | Should -Contain "ColorLimitationNote"
-        }
-    }
-    
-    Context "Copy-ExcelGradientFill Tests" {
-        BeforeEach {
-            $script:xl = Open-ExcelPackage -Path $testPath -Create
-            $script:ws = Add-WorkSheet -ExcelPackage $xl -WorksheetName "GradientTest"
-        }
-        
-        AfterEach {
-            Close-ExcelPackage -ExcelPackage $xl
-            Remove-Item -Path $testPath -ErrorAction SilentlyContinue
-        }
-        
-        It "Should copy gradient geometric properties from source to target" {
-            # Set up source
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 60 -Color1 Blue -Color2 Green -Top 0.1 -Bottom 0.9
-            
-            # Copy to target (should warn about colors)
-            $warningVar = $null
-            Copy-ExcelGradientFill -SourceRange $ws.Cells["A1"] -TargetRange $ws.Cells["B1"] -WarningVariable warningVar
-            
-            $targetGradient = $ws.Cells["B1"].Style.Fill.Gradient
-            $targetGradient.Type | Should -Be "Linear"
-            $targetGradient.Degree | Should -Be 60
-            $targetGradient.Top | Should -Be 0.1
-            $targetGradient.Bottom | Should -Be 0.9
-            
-            $warningVar | Should -Match "cannot be copied"
-        }
-        
-        It "Should apply custom gradient definition" {
-            $gradientDef = @{
-                Type = "Linear"
-                Degree = 120
-                Color1 = [System.Drawing.Color]::Purple
-                Color2 = [System.Drawing.Color]::Yellow
-                Top = 0.25
-                Bottom = 0.75
-                Left = 0.2
-                Right = 0.8
-            }
-            
-            Copy-ExcelGradientFill -TargetRange $ws.Cells["C1"] -GradientDefinition $gradientDef
-            
-            $gradient = $ws.Cells["C1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Linear"
-            $gradient.Degree | Should -Be 120
-            $gradient.Top | Should -Be 0.25
-            $gradient.Bottom | Should -Be 0.75
-            $gradient.Left | Should -Be 0.2
-            $gradient.Right | Should -Be 0.8
-        }
-        
-        It "Should apply gradient definition with string colors" {
-            $gradientDef = @{
-                Type = "Path"
-                Color1 = "Red"
-                Color2 = "Blue"
-            }
-            
-            Copy-ExcelGradientFill -TargetRange $ws.Cells["D1:F3"] -GradientDefinition $gradientDef
-            
-            $gradient = $ws.Cells["D1"].Style.Fill.Gradient
-            $gradient.Type | Should -Be "Path"
-        }
-    }
-    
-    Context "Integration Tests" {
-        BeforeEach {
-            $script:xl = Open-ExcelPackage -Path $testPath -Create
-            $script:ws = Add-WorkSheet -ExcelPackage $xl -WorksheetName "GradientTest"
-        }
-        
-        AfterEach {
-            Close-ExcelPackage -ExcelPackage $xl
-            Remove-Item -Path $testPath -ErrorAction SilentlyContinue
-        }
-        
-        It "Should work with the original issue scenario" {
-            # Reproduce the original issue scenario but with new functions
-            Set-ExcelGradientFill -Range $ws.Cells["A1"] -Type Linear -Degree 90 -Color1 Blue -Color2 Green
-            
-            # Get gradient info (which will have limited color info)
-            $gradientInfo = Get-ExcelGradientFill -Range $ws.Cells["A1"]
-            
-            # Should be able to copy geometric properties
-            $gradientInfo.Type | Should -Be "Linear"
-            $gradientInfo.Degree | Should -Be 90
-            
-            # Should be able to create a complete gradient definition for copying
-            $completeDef = @{
-                Type = $gradientInfo.Type
-                Degree = $gradientInfo.Degree
-                Top = $gradientInfo.Top
-                Bottom = $gradientInfo.Bottom
-                Left = $gradientInfo.Left
-                Right = $gradientInfo.Right
-                Color1 = [System.Drawing.Color]::Blue  # Need to specify colors
-                Color2 = [System.Drawing.Color]::Green
-            }
-            
-            # Should be able to copy to another cell
-            Copy-ExcelGradientFill -TargetRange $ws.Cells["B1"] -GradientDefinition $completeDef
-            
-            $targetGradient = $ws.Cells["B1"].Style.Fill.Gradient
-            $targetGradient.Type | Should -Be "Linear"
-            $targetGradient.Degree | Should -Be 90
-        }
-    }
-}

changelog.md

@@ -1,60 +1,3 @@
-# 7.8.10
-
-- Thank you https://github.com/evenmartinsen for the PR to fix the AV
-
-# 7.8.9
-
-- Thanks to (Edward Miller)[https://github.com/edwardmiller-mesirow] for improving `ConvertTo-ExcelXlsx`and making it more robust
-
-# 7.8.8
-
-- Fix the release
-
-# 7.8.7
-
-- Thanks to [Phil Bossman](https://github.com/pbossman) for the PR and fixing this.
-    
-    Now, back again, you can type `Import-Excel .\yearlySales.xlsx`, press <ctrl+space> and get a list of the worksheets in the Excel file
-
-    ![alt text](images/AutoCompleteSheetNames.png)    
-
-# Infrastructure change
-
-- Thank you to [RipFence](https://github.com/RipFence) who asked how to place a chart on a different sheet from the data and then did a PR adding the example.
-- added `ignore` so files checked into examples do not trigger a CI run
-
-# 7.8.6
-
-- Thank you [John Boyne](https://github.com/kyllath)
-    - Add missing parameter aliases to align with caller/callee
-
-# 7.8.5
-
-- Added `Get-ExcelFileSchema` to get the schema of an Excel file.
-- This was added to support interacting with `ChatGPT`. Passing the schema to the `ChatGPT` via `PowerShellAI` let's you ask questions about the data including generating code based on the schema.
-
-```powershell
-Get-ExcelFileSchema .\salesData.xlsx
-```
-
-```json
-{
-  "ExcelFile": "salesData.xlsx",
-  "WorksheetName": "Sheet1",
-  "Visible": true,
-  "Rows": 10,
-  "Columns": 4,
-  "Address": "A1:D10",
-  "Path": ".",
-  "PropertyNames": [
-    "Region",
-    "State",
-    "Units",
-    "Price"
-  ]
-}
-```
-
 # 7.8.x
 
 Thanks to [Thomas Hofkens](https://github.com/thkn-hofa)