extension.php

См. документацию.

<?php
 
namespace Bitrix\MobileApp\Janative\Entity;
 
use Bitrix\Main\IO\File;
use Bitrix\Main\IO\Path;
use Bitrix\Main\SystemException;
use Bitrix\Main\Web\Json;
use Bitrix\MobileApp\Janative\Manager;
use Bitrix\MobileApp\Janative\Utils;
 
class Extension extends Base
{
    protected static array $modificationDates = [];
    protected static array $dependencies = [];
    protected static array $resolvedDependencies = [];
    protected static array $extensionCache = [];
    protected static $paths = [];
    public ?string $result = null;

    public static function getInstance($identifier): Extension
    {
        if (!isset(self::$extensionCache[$identifier]))
        {
            self::$extensionCache[$identifier] = new Extension($identifier);
        }
 
        return self::$extensionCache[$identifier];
    }
    public static function getInstance($identifier): Extension {…}
 
    public function __construct($identifier)
    {
        $identifier = Path::normalize($identifier);
        $this->baseFileName = 'extension';
        $desc = Utils::extractEntityDescription($identifier);
        $this->name = $desc['name'];
        $this->namespace = $desc['namespace'];
        if (isset(self::$paths[$desc['fullname']]))
        {
            $this->path = self::$paths[$desc['fullname']];
        }
        else
        {
            $this->path = Manager::getExtensionPath($identifier);
            self::$paths[$desc['fullname']] = $this->path;
        }
 
        if (!$this->path)
        {
            throw new SystemException("Extension '{$desc['fullname']}' doesn't exists");
        }
    }
    public function __construct($identifier) {…}
 
    private function getBundleContent(): string
    {
        $files = $this->getBundleFiles();
        $content = "";
        foreach ($files as $path)
        {
            $file = new File($path);
            if ($file->isExists())
            {
                $content .= "\n".$file->getContents()."\n";
            }
        }
 
        return $content;
    }

    public function getContent($excludeResult = false): string
    {
        $content = "";
        $extensionFile = new File($this->path . '/' . $this->baseFileName . '.js');
        if ($excludeResult !== true) {
            $content .= $this->getResultExpression();
        }
        else
        {
            $this->result = $this->getResult();
        }
 
        if ($extensionFile->isExists() && $extensionContent = $extensionFile->getContents())
        {
            $content .= $this->getBundleContent();
            $content .= $extensionContent;
        }
 
        $content .= "\n\n";
 
        return $content;
    }
    public function getContent($excludeResult = false): string {…}
 
    public function getResultExpression(): string {
        $this->result = $this->getResult();
        if ($this->result != null && $this->result !== '')
        {
            $name = ($this->namespace != "bitrix"? $this->namespace.":" : "").$this->name;
            return <<<JS
this.jnExtensionData.set("{$name}", {$this->result});
JS;
        }
 
        return "";
    }
    public function getResultExpression(): string {…}
 
    private function getResult(): ?string
    {
        $file = new File($this->path . '/extension.php');
        $result = null;
        if ($file->isExists())
        {
            $result = include($file->getPath());
        }
 
        if (!empty($result) && is_array($result))
        {
            return Json::encode($result);
        }
 
        return null;
    }
 
    public function getIncludeExpression($callbackName = 'onExtensionsLoaded'): string
    {
        $relativePath = $this->getPath() . 'extension.js';
        $localizationPhrases = $this->getLangDefinitionExpression();
        $content = "\n//extension '{$this->name}'\n";
        $content .= "{$localizationPhrases}\n";
        $content .= "loadScript(\"{$relativePath}\", false, {$callbackName});";
 
        return $content;
    }
    public function getIncludeExpression($callbackName = 'onExtensionsLoaded'): string {…}

    public static function getResolvedDependencyList($name, &$list = [], &$alreadyResolved = [], $margin = 0): array
    {
        $baseExtension = Extension::getInstance($name);
        $depsList = $baseExtension->getDependencyList();
        $alreadyResolved[] = $name;
        if (!empty($depsList))
        {
            $margin++;
            foreach ($depsList as $ext)
            {
                $depExtension = Extension::getInstance($ext);
                $extDepsList = $depExtension->getDependencyList();
                if (empty($extDepsList))
                {
                    array_unshift($list, $ext);
                }
                elseif (!in_array($ext, $alreadyResolved))
                {
                    self::getResolvedDependencyList($ext, $list, $alreadyResolved, $margin);
                }
            }
        }
 
        $list[] = $name;
 
        return array_unique($list);
    }
    public static function getResolvedDependencyList($name, &$list = [], &$alreadyResolved = [], $margin = 0): array {…}
 
    protected function onBeforeModificationMarkerSave(array &$value)
    {
        $files = $this->getBundleFiles();
        foreach ($files as $path)
        {
            $file = new File($path);
            if ($file->isExists())
            {
                $value[] = Utils::getFileHash($file);
            }
        }
    }
    protected function onBeforeModificationMarkerSave(array &$value) {…}

    protected function resolveDependencies(): array
    {
        $name = ($this->namespace !== "bitrix" ? $this->namespace . ":" : "") . $this->name;
        return self::getResolvedDependencyList($name);
    }
    protected function resolveDependencies(): array {…}
 
    public function getDependencies(): array
    {
        $fullyQualifiedName = $this->getFullyQualifiedName();
        self::$resolvedDependencies[$fullyQualifiedName] ??= array_values($this->resolveDependencies());
 
        return self::$resolvedDependencies[$fullyQualifiedName];
    }
    public function getDependencies(): array {…}
 
    public function getDependencyList()
    {
        $fullyQualifiedName = $this->getFullyQualifiedName();
        self::$dependencies[$fullyQualifiedName] ??= parent::getDependencyList();
 
        return self::$dependencies[$fullyQualifiedName];
    }
    public function getDependencyList() {…}
}
class Extension extends Base {…};