Proyectos de Subversion Moodle

<?php

namespace PhpOffice\PhpSpreadsheet;

use JsonSerializable;

use PhpOffice\PhpSpreadsheet\Calculation\Calculation;

use PhpOffice\PhpSpreadsheet\Cell\IValueBinder;

use PhpOffice\PhpSpreadsheet\Document\Properties;

use PhpOffice\PhpSpreadsheet\Document\Security;

use PhpOffice\PhpSpreadsheet\Shared\Date;

use PhpOffice\PhpSpreadsheet\Shared\StringHelper;

use PhpOffice\PhpSpreadsheet\Style\Style;

use PhpOffice\PhpSpreadsheet\Worksheet\Iterator;

use PhpOffice\PhpSpreadsheet\Worksheet\Table;

use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;

class Spreadsheet implements JsonSerializable

{

    // Allowable values for workbook window visilbity

    const VISIBILITY_VISIBLE = 'visible';

    const VISIBILITY_HIDDEN = 'hidden';

    const VISIBILITY_VERY_HIDDEN = 'veryHidden';

    private const DEFINED_NAME_IS_RANGE = false;

    private const DEFINED_NAME_IS_FORMULA = true;

    private const WORKBOOK_VIEW_VISIBILITY_VALUES = [

        self::VISIBILITY_VISIBLE,

        self::VISIBILITY_HIDDEN,

        self::VISIBILITY_VERY_HIDDEN,

    ];

    protected int $excelCalendar = Date::CALENDAR_WINDOWS_1900;

    /**

     * Unique ID.

     */

    private string $uniqueID;

    /**

     * Document properties.

     */

    private Properties $properties;

    /**

     * Document security.

     */

    private Security $security;

    /**

     * Collection of Worksheet objects.

     *

     * @var Worksheet[]

     */

    private array $workSheetCollection;

    /**

     * Calculation Engine.

     */

    private ?Calculation $calculationEngine;

    /**

     * Active sheet index.

     */

    private int $activeSheetIndex;

    /**

     * Named ranges.

     *

     * @var DefinedName[]

     */

    private array $definedNames;

    /**

     * CellXf supervisor.

     */

    private Style $cellXfSupervisor;

    /**

     * CellXf collection.

     *

     * @var Style[]

     */

    private array $cellXfCollection = [];

    /**

     * CellStyleXf collection.

     *

     * @var Style[]

     */

    private array $cellStyleXfCollection = [];

    /**

     * hasMacros : this workbook have macros ?

     */

    private bool $hasMacros = false;

    /**

     * macrosCode : all macros code as binary data (the vbaProject.bin file, this include form, code,  etc.), null if no macro.

     */

    private ?string $macrosCode = null;

    /**

     * macrosCertificate : if macros are signed, contains binary data vbaProjectSignature.bin file, null if not signed.

     */

    private ?string $macrosCertificate = null;

    /**

     * ribbonXMLData : null if workbook is'nt Excel 2007 or not contain a customized UI.

     *

     * @var null|array{target: string, data: string}

     */

    private ?array $ribbonXMLData = null;

    /**

     * ribbonBinObjects : null if workbook is'nt Excel 2007 or not contain embedded objects (picture(s)) for Ribbon Elements

     * ignored if $ribbonXMLData is null.

     */

    private ?array $ribbonBinObjects = null;

    /**

     * List of unparsed loaded data for export to same format with better compatibility.

     * It has to be minimized when the library start to support currently unparsed data.

     */

    private array $unparsedLoadedData = [];

    /**

     * Controls visibility of the horizonal scroll bar in the application.

     */

    private bool $showHorizontalScroll = true;

    /**

     * Controls visibility of the horizonal scroll bar in the application.

     */

    private bool $showVerticalScroll = true;

    /**

     * Controls visibility of the sheet tabs in the application.

     */

    private bool $showSheetTabs = true;

    /**

     * Specifies a boolean value that indicates whether the workbook window

     * is minimized.

     */

    private bool $minimized = false;

    /**

     * Specifies a boolean value that indicates whether to group dates

     * when presenting the user with filtering optiomd in the user

     * interface.

     */

    private bool $autoFilterDateGrouping = true;

    /**

     * Specifies the index to the first sheet in the book view.

     */

    private int $firstSheetIndex = 0;

    /**

     * Specifies the visible status of the workbook.

     */

    private string $visibility = self::VISIBILITY_VISIBLE;

    /**

     * Specifies the ratio between the workbook tabs bar and the horizontal

     * scroll bar.  TabRatio is assumed to be out of 1000 of the horizontal

     * window width.

     */

    private int $tabRatio = 600;

    private Theme $theme;

    private ?IValueBinder $valueBinder = null;

    public function getTheme(): Theme

    {

        return $this->theme;

    }

    /**

     * The workbook has macros ?

     */

    public function hasMacros(): bool

    {

        return $this->hasMacros;

    }

    /**

     * Define if a workbook has macros.

     *

     * @param bool $hasMacros true|false

     */

    public function setHasMacros(bool $hasMacros): void

    {

        $this->hasMacros = (bool) $hasMacros;

    }

    /**

     * Set the macros code.

     */

    public function setMacrosCode(?string $macroCode): void

    {

        $this->macrosCode = $macroCode;

        $this->setHasMacros($macroCode !== null);

    }

    /**

     * Return the macros code.

     */

    public function getMacrosCode(): ?string

    {

        return $this->macrosCode;

    }

    /**

     * Set the macros certificate.

     */

    public function setMacrosCertificate(?string $certificate): void

    {

        $this->macrosCertificate = $certificate;

    }

    /**

     * Is the project signed ?

     *

     * @return bool true|false

     */

    public function hasMacrosCertificate(): bool

    {

        return $this->macrosCertificate !== null;

    }

    /**

     * Return the macros certificate.

     */

    public function getMacrosCertificate(): ?string

    {

        return $this->macrosCertificate;

    }

    /**

     * Remove all macros, certificate from spreadsheet.

     */

    public function discardMacros(): void

    {

        $this->hasMacros = false;

        $this->macrosCode = null;

        $this->macrosCertificate = null;

    }

    /**

     * set ribbon XML data.

     */

    public function setRibbonXMLData(mixed $target, mixed $xmlData): void

    {

        if (is_string($target) && is_string($xmlData)) {

            $this->ribbonXMLData = ['target' => $target, 'data' => $xmlData];

        } else {

            $this->ribbonXMLData = null;

        }

    }

    /**

     * retrieve ribbon XML Data.

     */

    public function getRibbonXMLData(string $what = 'all'): null|array|string //we need some constants here...

    {

        $returnData = null;

        $what = strtolower($what);

        switch ($what) {

            case 'all':

                $returnData = $this->ribbonXMLData;

                break;

            case 'target':

            case 'data':

                if (is_array($this->ribbonXMLData)) {

                    $returnData = $this->ribbonXMLData[$what];

                }

                break;

        }

        return $returnData;

    }

    /**

     * store binaries ribbon objects (pictures).

     */

    public function setRibbonBinObjects(mixed $binObjectsNames, mixed $binObjectsData): void

    {

        if ($binObjectsNames !== null && $binObjectsData !== null) {

            $this->ribbonBinObjects = ['names' => $binObjectsNames, 'data' => $binObjectsData];

        } else {

            $this->ribbonBinObjects = null;

        }

    }

    /**

     * List of unparsed loaded data for export to same format with better compatibility.

     * It has to be minimized when the library start to support currently unparsed data.

     *

     * @internal

     */

    public function getUnparsedLoadedData(): array

    {

        return $this->unparsedLoadedData;

    }

    /**

     * List of unparsed loaded data for export to same format with better compatibility.

     * It has to be minimized when the library start to support currently unparsed data.

     *

     * @internal

     */

    public function setUnparsedLoadedData(array $unparsedLoadedData): void

    {

        $this->unparsedLoadedData = $unparsedLoadedData;

    }

    /**

     * retrieve Binaries Ribbon Objects.

     */

    public function getRibbonBinObjects(string $what = 'all'): ?array

    {

        $ReturnData = null;

        $what = strtolower($what);

        switch ($what) {

            case 'all':

                return $this->ribbonBinObjects;

            case 'names':

            case 'data':

                if (is_array($this->ribbonBinObjects) && isset($this->ribbonBinObjects[$what])) {

                    $ReturnData = $this->ribbonBinObjects[$what];

                }

                break;

            case 'types':

                if (

                    is_array($this->ribbonBinObjects)

                    && isset($this->ribbonBinObjects['data']) && is_array($this->ribbonBinObjects['data'])

                ) {

                    $tmpTypes = array_keys($this->ribbonBinObjects['data']);

                    $ReturnData = array_unique(array_map(fn (string $path): string => pathinfo($path, PATHINFO_EXTENSION), $tmpTypes));

                } else {

                    $ReturnData = []; // the caller want an array... not null if empty

                }

                break;

        }

        return $ReturnData;

    }

    /**

     * This workbook have a custom UI ?

     */

    public function hasRibbon(): bool

    {

        return $this->ribbonXMLData !== null;

    }

    /**

     * This workbook have additionnal object for the ribbon ?

     */

    public function hasRibbonBinObjects(): bool

    {

        return $this->ribbonBinObjects !== null;

    }

    /**

     * Check if a sheet with a specified code name already exists.

     *

     * @param string $codeName Name of the worksheet to check

     */

    public function sheetCodeNameExists(string $codeName): bool

    {

        return $this->getSheetByCodeName($codeName) !== null;

    }

    /**

     * Get sheet by code name. Warning : sheet don't have always a code name !

     *

     * @param string $codeName Sheet name

     */

    public function getSheetByCodeName(string $codeName): ?Worksheet

    {

        $worksheetCount = count($this->workSheetCollection);

        for ($i = 0; $i < $worksheetCount; ++$i) {

            if ($this->workSheetCollection[$i]->getCodeName() == $codeName) {

                return $this->workSheetCollection[$i];

            }

        }

        return null;

    }

    /**

     * Create a new PhpSpreadsheet with one Worksheet.

     */

    public function __construct()

    {

        $this->uniqueID = uniqid('', true);

        $this->calculationEngine = new Calculation($this);

        $this->theme = new Theme();

        // Initialise worksheet collection and add one worksheet

        $this->workSheetCollection = [];

        $this->workSheetCollection[] = new Worksheet($this);

        $this->activeSheetIndex = 0;

        // Create document properties

        $this->properties = new Properties();

        // Create document security

        $this->security = new Security();

        // Set defined names

        $this->definedNames = [];

        // Create the cellXf supervisor

        $this->cellXfSupervisor = new Style(true);

        $this->cellXfSupervisor->bindParent($this);

        // Create the default style

        $this->addCellXf(new Style());

        $this->addCellStyleXf(new Style());

    }

    /**

     * Code to execute when this worksheet is unset().

     */

    public function __destruct()

    {

        $this->disconnectWorksheets();

        $this->calculationEngine = null;

        $this->cellXfCollection = [];

        $this->cellStyleXfCollection = [];

        $this->definedNames = [];

    }

    /**

     * Disconnect all worksheets from this PhpSpreadsheet workbook object,

     * typically so that the PhpSpreadsheet object can be unset.

     */

    public function disconnectWorksheets(): void

    {

        foreach ($this->workSheetCollection as $worksheet) {

            $worksheet->disconnectCells();

            unset($worksheet);

        }

        $this->workSheetCollection = [];

    }

    /**

     * Return the calculation engine for this worksheet.

     */

    public function getCalculationEngine(): ?Calculation

    {

        return $this->calculationEngine;

    }

    /**

     * Get properties.

     */

    public function getProperties(): Properties

    {

        return $this->properties;

    }

    /**

     * Set properties.

     */

    public function setProperties(Properties $documentProperties): void

    {

        $this->properties = $documentProperties;

    }

    /**

     * Get security.

     */

    public function getSecurity(): Security

    {

        return $this->security;

    }

    /**

     * Set security.

     */

    public function setSecurity(Security $documentSecurity): void

    {

        $this->security = $documentSecurity;

    }

    /**

     * Get active sheet.

     */

    public function getActiveSheet(): Worksheet

    {

        return $this->getSheet($this->activeSheetIndex);

    }

    /**

     * Create sheet and add it to this workbook.

     *

     * @param null|int $sheetIndex Index where sheet should go (0,1,..., or null for last)

     */

    public function createSheet(?int $sheetIndex = null): Worksheet

    {

        $newSheet = new Worksheet($this);

        $this->addSheet($newSheet, $sheetIndex, true);

        return $newSheet;

    }

    /**

     * Check if a sheet with a specified name already exists.

     *

     * @param string $worksheetName Name of the worksheet to check

     */

    public function sheetNameExists(string $worksheetName): bool

    {

        return $this->getSheetByName($worksheetName) !== null;

    }

    public function duplicateWorksheetByTitle(string $title): Worksheet

    {

        $original = $this->getSheetByNameOrThrow($title);

        $index = $this->getIndex($original) + 1;

        $clone = clone $original;

        return $this->addSheet($clone, $index, true);

    }

    /**

     * Add sheet.

     *

     * @param Worksheet $worksheet The worksheet to add

     * @param null|int $sheetIndex Index where sheet should go (0,1,..., or null for last)

     */

    public function addSheet(Worksheet $worksheet, ?int $sheetIndex = null, bool $retitleIfNeeded = false): Worksheet

    {

        if ($retitleIfNeeded) {

            $title = $worksheet->getTitle();

            if ($this->sheetNameExists($title)) {

                $i = 1;

                $newTitle = "$title $i";

                while ($this->sheetNameExists($newTitle)) {

                    ++$i;

                    $newTitle = "$title $i";

                }

                $worksheet->setTitle($newTitle);

            }

        }

        if ($this->sheetNameExists($worksheet->getTitle())) {

            throw new Exception(

                "Workbook already contains a worksheet named '{$worksheet->getTitle()}'. Rename this worksheet first."

            );

        }

        if ($sheetIndex === null) {

            if ($this->activeSheetIndex < 0) {

                $this->activeSheetIndex = 0;

            }

            $this->workSheetCollection[] = $worksheet;

        } else {

            // Insert the sheet at the requested index

            array_splice(

                $this->workSheetCollection,

                $sheetIndex,

                0,

                [$worksheet]

            );

            // Adjust active sheet index if necessary

            if ($this->activeSheetIndex >= $sheetIndex) {

                ++$this->activeSheetIndex;

            }

            if ($this->activeSheetIndex < 0) {

                $this->activeSheetIndex = 0;

            }

        }

        if ($worksheet->getParent() === null) {

            $worksheet->rebindParent($this);

        }

        return $worksheet;

    }

    /**

     * Remove sheet by index.

     *

     * @param int $sheetIndex Index position of the worksheet to remove

     */

    public function removeSheetByIndex(int $sheetIndex): void

    {

        $numSheets = count($this->workSheetCollection);

        if ($sheetIndex > $numSheets - 1) {

            throw new Exception(

                "You tried to remove a sheet by the out of bounds index: {$sheetIndex}. The actual number of sheets is {$numSheets}."

            );

        }

        array_splice($this->workSheetCollection, $sheetIndex, 1);

        // Adjust active sheet index if necessary

        if (

            ($this->activeSheetIndex >= $sheetIndex)

            && ($this->activeSheetIndex > 0 || $numSheets <= 1)

        ) {

            --$this->activeSheetIndex;

        }

    }

    /**

     * Get sheet by index.

     *

     * @param int $sheetIndex Sheet index

     */

    public function getSheet(int $sheetIndex): Worksheet

    {

        if (!isset($this->workSheetCollection[$sheetIndex])) {

            $numSheets = $this->getSheetCount();

            throw new Exception(

                "Your requested sheet index: {$sheetIndex} is out of bounds. The actual number of sheets is {$numSheets}."

            );

        }

        return $this->workSheetCollection[$sheetIndex];

    }

    /**

     * Get all sheets.

     *

     * @return Worksheet[]

     */

    public function getAllSheets(): array

    {

        return $this->workSheetCollection;

    }

    /**

     * Get sheet by name.

     *

     * @param string $worksheetName Sheet name

     */

    public function getSheetByName(string $worksheetName): ?Worksheet

    {

        $worksheetCount = count($this->workSheetCollection);

        for ($i = 0; $i < $worksheetCount; ++$i) {

            if (strcasecmp($this->workSheetCollection[$i]->getTitle(), trim($worksheetName, "'")) === 0) {

                return $this->workSheetCollection[$i];

            }

        }

        return null;

    }

    /**

     * Get sheet by name, throwing exception if not found.

     */

    public function getSheetByNameOrThrow(string $worksheetName): Worksheet

    {

        $worksheet = $this->getSheetByName($worksheetName);

        if ($worksheet === null) {

            throw new Exception("Sheet $worksheetName does not exist.");

        }

        return $worksheet;

    }

    /**

     * Get index for sheet.

     *

     * @return int index

     */

    public function getIndex(Worksheet $worksheet, bool $noThrow = false): int

    {

        $wsHash = $worksheet->getHashInt();

        foreach ($this->workSheetCollection as $key => $value) {

            if ($value->getHashInt() === $wsHash) {

                return $key;

            }

        }

        if ($noThrow) {

            return -1;

        }

        throw new Exception('Sheet does not exist.');

    }

    /**

     * Set index for sheet by sheet name.

     *

     * @param string $worksheetName Sheet name to modify index for

     * @param int $newIndexPosition New index for the sheet

     *

     * @return int New sheet index

     */

    public function setIndexByName(string $worksheetName, int $newIndexPosition): int

    {

        $oldIndex = $this->getIndex($this->getSheetByNameOrThrow($worksheetName));

        $worksheet = array_splice(

            $this->workSheetCollection,

            $oldIndex,

            1

        );

        array_splice(

            $this->workSheetCollection,

            $newIndexPosition,

            0,

            $worksheet

        );

        return $newIndexPosition;

    }

    /**

     * Get sheet count.

     */

    public function getSheetCount(): int

    {

        return count($this->workSheetCollection);

    }

    /**

     * Get active sheet index.

     *

     * @return int Active sheet index

     */

    public function getActiveSheetIndex(): int

    {

        return $this->activeSheetIndex;

    }

    /**

     * Set active sheet index.

     *

     * @param int $worksheetIndex Active sheet index

     */

    public function setActiveSheetIndex(int $worksheetIndex): Worksheet

    {

        $numSheets = count($this->workSheetCollection);

        if ($worksheetIndex > $numSheets - 1) {

            throw new Exception(

                "You tried to set a sheet active by the out of bounds index: {$worksheetIndex}. The actual number of sheets is {$numSheets}."

            );

        }

        $this->activeSheetIndex = $worksheetIndex;

        return $this->getActiveSheet();

    }

    /**

     * Set active sheet index by name.

     *

     * @param string $worksheetName Sheet title

     */

    public function setActiveSheetIndexByName(string $worksheetName): Worksheet

    {

        if (($worksheet = $this->getSheetByName($worksheetName)) instanceof Worksheet) {

            $this->setActiveSheetIndex($this->getIndex($worksheet));

            return $worksheet;

        }

        throw new Exception('Workbook does not contain sheet:' . $worksheetName);

    }

    /**

     * Get sheet names.

     *

     * @return string[]

     */

    public function getSheetNames(): array

    {

        $returnValue = [];

        $worksheetCount = $this->getSheetCount();

        for ($i = 0; $i < $worksheetCount; ++$i) {

            $returnValue[] = $this->getSheet($i)->getTitle();

        }

        return $returnValue;

    }

    /**

     * Add external sheet.

     *

     * @param Worksheet $worksheet External sheet to add

     * @param null|int $sheetIndex Index where sheet should go (0,1,..., or null for last)

     */

    public function addExternalSheet(Worksheet $worksheet, ?int $sheetIndex = null): Worksheet

    {

        if ($this->sheetNameExists($worksheet->getTitle())) {

            throw new Exception("Workbook already contains a worksheet named '{$worksheet->getTitle()}'. Rename the external sheet first.");

        }

        // count how many cellXfs there are in this workbook currently, we will need this below

        $countCellXfs = count($this->cellXfCollection);

        // copy all the shared cellXfs from the external workbook and append them to the current

        foreach ($worksheet->getParentOrThrow()->getCellXfCollection() as $cellXf) {

            $this->addCellXf(clone $cellXf);

        }

        // move sheet to this workbook

        $worksheet->rebindParent($this);

        // update the cellXfs

        foreach ($worksheet->getCoordinates(false) as $coordinate) {

            $cell = $worksheet->getCell($coordinate);

            $cell->setXfIndex($cell->getXfIndex() + $countCellXfs);

        }

        // update the column dimensions Xfs

        foreach ($worksheet->getColumnDimensions() as $columnDimension) {

            $columnDimension->setXfIndex($columnDimension->getXfIndex() + $countCellXfs);

        }

        // update the row dimensions Xfs

        foreach ($worksheet->getRowDimensions() as $rowDimension) {

            $xfIndex = $rowDimension->getXfIndex();

            if ($xfIndex !== null) {

                $rowDimension->setXfIndex($xfIndex + $countCellXfs);

            }

        }

        return $this->addSheet($worksheet, $sheetIndex);

    }

    /**

     * Get an array of all Named Ranges.

     *

     * @return DefinedName[]

     */

    public function getNamedRanges(): array

    {

        return array_filter(

            $this->definedNames,

            fn (DefinedName $definedName): bool => $definedName->isFormula() === self::DEFINED_NAME_IS_RANGE

        );

    }

    /**

     * Get an array of all Named Formulae.

     *

     * @return DefinedName[]

     */

    public function getNamedFormulae(): array

    {

        return array_filter(

            $this->definedNames,

            fn (DefinedName $definedName): bool => $definedName->isFormula() === self::DEFINED_NAME_IS_FORMULA

        );

    }

    /**

     * Get an array of all Defined Names (both named ranges and named formulae).

     *

     * @return DefinedName[]

     */

    public function getDefinedNames(): array

    {

        return $this->definedNames;

    }

    /**

     * Add a named range.

     * If a named range with this name already exists, then this will replace the existing value.

     */

    public function addNamedRange(NamedRange $namedRange): void

    {

        $this->addDefinedName($namedRange);

    }

    /**

     * Add a named formula.

     * If a named formula with this name already exists, then this will replace the existing value.

     */

    public function addNamedFormula(NamedFormula $namedFormula): void

    {

        $this->addDefinedName($namedFormula);

    }

    /**

     * Add a defined name (either a named range or a named formula).

     * If a defined named with this name already exists, then this will replace the existing value.

     */

    public function addDefinedName(DefinedName $definedName): void

    {

        $upperCaseName = StringHelper::strToUpper($definedName->getName());

        if ($definedName->getScope() == null) {

            // global scope

            $this->definedNames[$upperCaseName] = $definedName;

        } else {

            // local scope

            $this->definedNames[$definedName->getScope()->getTitle() . '!' . $upperCaseName] = $definedName;

        }

    }

    /**

     * Get named range.

     *

     * @param null|Worksheet $worksheet Scope. Use null for global scope

     */

    public function getNamedRange(string $namedRange, ?Worksheet $worksheet = null): ?NamedRange

    {

        $returnValue = null;

        if ($namedRange !== '') {

            $namedRange = StringHelper::strToUpper($namedRange);

            // first look for global named range

            $returnValue = $this->getGlobalDefinedNameByType($namedRange, self::DEFINED_NAME_IS_RANGE);

            // then look for local named range (has priority over global named range if both names exist)

            $returnValue = $this->getLocalDefinedNameByType($namedRange, self::DEFINED_NAME_IS_RANGE, $worksheet) ?: $returnValue;

        }

        return $returnValue instanceof NamedRange ? $returnValue : null;

    }

    /**

     * Get named formula.

     *

     * @param null|Worksheet $worksheet Scope. Use null for global scope

     */

    public function getNamedFormula(string $namedFormula, ?Worksheet $worksheet = null): ?NamedFormula

    {

        $returnValue = null;

        if ($namedFormula !== '') {

            $namedFormula = StringHelper::strToUpper($namedFormula);

            // first look for global named formula

            $returnValue = $this->getGlobalDefinedNameByType($namedFormula, self::DEFINED_NAME_IS_FORMULA);

            // then look for local named formula (has priority over global named formula if both names exist)

            $returnValue = $this->getLocalDefinedNameByType($namedFormula, self::DEFINED_NAME_IS_FORMULA, $worksheet) ?: $returnValue;

        }

        return $returnValue instanceof NamedFormula ? $returnValue : null;

    }

    private function getGlobalDefinedNameByType(string $name, bool $type): ?DefinedName

    {

        if (isset($this->definedNames[$name]) && $this->definedNames[$name]->isFormula() === $type) {

            return $this->definedNames[$name];

        }

        return null;

    }

    private function getLocalDefinedNameByType(string $name, bool $type, ?Worksheet $worksheet = null): ?DefinedName

    {

        if (

            ($worksheet !== null) && isset($this->definedNames[$worksheet->getTitle() . '!' . $name])

            && $this->definedNames[$worksheet->getTitle() . '!' . $name]->isFormula() === $type

        ) {

            return $this->definedNames[$worksheet->getTitle() . '!' . $name];

        }

        return null;

    }

    /**

     * Get named range.

     *

     * @param null|Worksheet $worksheet Scope. Use null for global scope

     */

    public function getDefinedName(string $definedName, ?Worksheet $worksheet = null): ?DefinedName

    {

        $returnValue = null;

        if ($definedName !== '') {

            $definedName = StringHelper::strToUpper($definedName);

            // first look for global defined name

            if (isset($this->definedNames[$definedName])) {

                $returnValue = $this->definedNames[$definedName];

            }

            // then look for local defined name (has priority over global defined name if both names exist)

            if (($worksheet !== null) && isset($this->definedNames[$worksheet->getTitle() . '!' . $definedName])) {

                $returnValue = $this->definedNames[$worksheet->getTitle() . '!' . $definedName];

            }

        }

        return $returnValue;

    }

    /**

     * Remove named range.

     *

     * @param null|Worksheet $worksheet scope: use null for global scope

     *

     * @return $this

     */

    public function removeNamedRange(string $namedRange, ?Worksheet $worksheet = null): self

    {

        if ($this->getNamedRange($namedRange, $worksheet) === null) {

            return $this;

        }

        return $this->removeDefinedName($namedRange, $worksheet);

    }