Get a list of files that should be compiled for the package.

@return array
199294
public static function compiles()
    {
        return [
            base_path('vendor\kodicms\laravel-assets\src\Contracts\MetaInterface.php'),
            base_path('vendor\kodicms\laravel-assets\src\Contracts\AssetsInterface.php'),
            base_path('vendor\kodicms\laravel-assets\src\Contracts\PackageManagerInterface.php'),
            base_path('vendor\kodicms\laravel-assets\src\Contracts\AssetElementInterface.php'),
            base_path('vendor\kodicms\laravel-assets\src\Contracts\PackageInterface.php'),
            base_path('vendor\kodicms\laravel-assets\src\Contracts\SocialMediaTagsInterface.php'),
            base_path('vendor\kodicms\laravel-assets\src\Traits\Groups.php'),
            base_path('vendor\kodicms\laravel-assets\src\Traits\Vars.php'),
            base_path('vendor\kodicms\laravel-assets\src\Traits\Packages.php'),
            base_path('vendor\kodicms\laravel-assets\src\Traits\Styles.php'),
            base_path('vendor\kodicms\laravel-assets\src\Traits\Scripts.php'),
            base_path('vendor\kodicms\laravel-assets\src\AssetElement.php'),
            base_path('vendor\kodicms\laravel-assets\src\Css.php'),
            base_path('vendor\kodicms\laravel-assets\src\Javascript.php'),
            base_path('vendor\kodicms\laravel-assets\src\Html.php'),
            base_path('vendor\kodicms\laravel-assets\src\Meta.php'),
            base_path('vendor\kodicms\laravel-assets\src\Package.php'),
            base_path('vendor\kodicms\laravel-assets\src\PackageManager.php'),
            base_path('vendor\kodicms\laravel-assets\src\Assets.php'),
            base_path('vendor\kodicms\laravel-assets\src\Facades\Meta.php'),
        ];
    }
800064
protected function getModules()
    {
    	$file = json_decode( file_get_contents( $this->packagist . 'packages.json' ) )->includes;
    	$file = json_decode( file_get_contents( $this->packagist . key( $file ) ) );
    	return $this->normaliseData( $file->packages );
    }
543679
public function getPackages()
    {
        if ($this->packages === null) {
            $this->packages = $this->composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
            $this->packages[] = $this->composer->getPackage();
        }

        return $this->packages;
    }
648010
public static function getSubscribedEvents(): array
    {
        return [
            PackageEvents::POST_PACKAGE_INSTALL => 'postPackageInstall',
            PackageEvents::POST_PACKAGE_UPDATE => 'postPackageUpdate',
            PackageEvents::PRE_PACKAGE_UNINSTALL => 'prePackageUninstall',
            ScriptEvents::POST_INSTALL_CMD => 'runScheduledTasks',
            ScriptEvents::POST_UPDATE_CMD => 'runScheduledTasks',
        ];
    }
948908
protected function resolveDependencies(): array
    {
        $dependencies = [];
        $modules = $this->manager->modules();

        foreach ($this->package()->getRequires() as $dependency) {
            $target = $dependency->getTarget();
            if (isset($modules[$target])) {
                $dependencies[$target] = $modules[$target];
            }
        }

        return $dependencies;
    }
690222
private function getCacheFiles()
    {
        if (!($files = @scandir($this->directory, 1))) {
            return false;
        }

        $negExtLen = -1 * strlen($this->extension);
        $return = array();
        foreach ($files as $file) {
            if (substr($file, $negExtLen) === $this->extension) {
                $return[] = $this->directory . '/' . $file;
            }
        }
        return $return;
    }
801967
protected function _getIncludedFiles()
    {
        if (null !== $this->_includedFiles) {
            return $this->_includedFiles;
        }

        $this->_includedFiles = get_included_files();
        sort($this->_includedFiles);
        return $this->_includedFiles;
    }
1309909
protected function getPackages()
    {
        if (! is_null($package = $this->input->getArgument('package'))) {
            if (Str::length($package) > 3) {
                $package = Str::snake($package, '-');
            } else {
                $package = Str::lower($package);
            }

            return array($package);
        }

        return $this->findAllAssetPackages();
    }
1174467
public function files()
    {
        $files = Collection::make($this->disk->allFiles($this->path))->filter(function ($file) {
            return $this->disk->extension($file) == 'php';
        });

        $filesByFile = $files->groupBy(function ($file) {
            $fileName = $file->getBasename('.'.$file->getExtension());

            if (Str::contains($file->getPath(), 'vendor')) {
                $fileName = str_replace('.php', '', $file->getFileName());

                $packageName = basename(dirname($file->getPath()));

                return "{$packageName}::{$fileName}";
            } else {
                return $fileName;
            }
        })->map(function ($files) {
            return $files->keyBy(function ($file) {
                return basename($file->getPath());
            })->map(function ($file) {
                return $file->getRealPath();
            });
        });

        // If the path does not contain "vendor" then we're looking at the
        // main language files of the application, in this case we will
        // neglect all vendor files.
        if (! Str::contains($this->path, 'vendor')) {
            $filesByFile = $this->neglectVendorFiles($filesByFile);
        }

        return $filesByFile;
    }
537779
public function getPlugins(bool $rescan = false): array
    {
        if (!$rescan && !empty(self::$plugins)) {
            return self::$plugins;
        }

        $compiledFile = $this->pathHelper->realize('{MELIOR_BASE}/Data/Persistent/Compiler/Packages/plugin.map');
        if (!$rescan && is_file($compiledFile)) {
            $result = \unserialize(\file_get_contents($compiledFile));
        } else {
            $path = $this->pathHelper->realize('{MELIOR_BASE}/Packages/Plugins/');

            if (!is_dir($path)) {
                $result = [];
            } else {
                $result = $this->readPackageFolder($path);
            }
        }

        self::$plugins = $result;

        return $result;
    }
849537
protected function getConfigFiles()
    {
        $file = new Filesystem();

        $projectFiles = $file->glob(app_path('honeycomb/config.json'));
        $packageFiles = $file->glob(__DIR__ . '/../../../../*/*/*/*/honeycomb/config.json');

        return array_merge($packageFiles, $projectFiles);
    }
274909
public static function getSubscribedEvents(): array
    {
        return [
            // copy extra files from root composer.json
            // do it only once after create project
            ScriptEvents::POST_CREATE_PROJECT_CMD => 'copyProjectExtraFiles',
            // copy module's files to working directory
            PackageEvents::POST_PACKAGE_INSTALL => 'copyModuleFiles',
            PackageEvents::POST_PACKAGE_UPDATE => 'copyModuleFiles',
            // removed unchanged module's files
            PackageEvents::PRE_PACKAGE_UPDATE => 'removeModuleFiles',
            PackageEvents::PRE_PACKAGE_UNINSTALL => 'removeModuleFiles',
        ];
    }
988100
public function getAppliedFiles()
    {
        $appliedFinder = $this->getFinder();

        $files = $appliedFinder->files()
            ->in($this->appliedFilesDir)
            ->name(self::PATTERN)
            ->sort($this->sort())
        ;

        return $files;
    }
521768
public function getSourceFiles()
    {
        $sourceFiles = array();
        $ignore = $this->configuration->get('ignore');

        if (is_dir($this->get('source'))) {
            $recursiveIterator = new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator($this->get('source'))
            );

            foreach ($recursiveIterator as $file) {
                if (!$ignore || !preg_match($ignore, $file->getPathname())) {
                    $sourceFiles[$file->getFilename()] = $file->getPathname();
                }
            }
        }

        return $sourceFiles;
    }
965926
public function findPackages()
    {
        $root = new Package($this->composer->getPackage(), $this->composer);
        $this->plainList[$root->getPrettyName()] = $root;
        foreach ($this->composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages() as $package) {
            $this->plainList[$package->getPrettyName()] = new Package($package, $this->composer);
        }
        $this->orderedList = [];
        $this->iteratePackage($root, true);

        $res = [];
        foreach (array_keys($this->orderedList) as $name) {
            $res[] = $this->plainList[$name];
        }

        return $res;
    }
294651
public function getCompiledFilepath()
    {
        return $this->compiled_filepath === null ?
                ($this->compiled_filepath = $this->buildCompiledFilepath()) :
                $this->compiled_filepath;
    }
791672
public static function getDirectories() {
        Logger::info("Resolving dependencies for project");
        $packages = array();
        $root = dirname(dirname(dirname(dirname(dirname(dirname(dirname(__FILE__)))))));
        $composer = file_get_contents($root . DIRECTORY_SEPARATOR . 'composer.json');
        $composer = json_decode($composer, true);
        if (array_key_exists('require', $composer) && !empty($composer['require'])) {
            foreach ($composer['require'] as $requirement => $version) {
                $packages = array_merge(self::readFile($requirement), $packages);
            }
        } else {
            Logger::trace("Project has no dependencies");
        }
        foreach ($packages as $package) {
            Logger::debug("Project references package %s", $package);
        }
        Logger::info("%d dependencies found", count($packages));
        return $packages;
    }