Integrate Vite & Rework Mix

modules/cms/twig/Extension.php

@@ -2,6 +2,7 @@
 
 use Block;
 use Event;
+use Illuminate\Foundation\Vite;
 use Twig\Extension\AbstractExtension as TwigExtension;
 use Twig\TwigFilter as TwigSimpleFilter;
 use Twig\TwigFunction as TwigSimpleFunction;
@@ -51,6 +52,7 @@ public function getFunctions(): array
             new TwigSimpleFunction('content', [$this, 'contentFunction'], $options),
             new TwigSimpleFunction('component', [$this, 'componentFunction'], $options),
             new TwigSimpleFunction('placeholder', [$this, 'placeholderFunction'], ['is_safe' => ['html']]),
+            new TwigSimpleFunction('vite', [$this, 'viteFunction'], $options),
         ];
     }
 
@@ -166,6 +168,20 @@ public function themeFilter($url): string
         return $this->controller->themeUrl($url);
     }
 
+    /**
+     * Generates Vite tags via Laravel's Vite Object.
+     *
+     * @param array $arguments
+     * @param string $base The relative base path of the plugin or theme
+     * @return \Illuminate\Support\HtmlString
+     */
+    public function viteFunction(array $arguments, string $base): \Illuminate\Support\HtmlString
+    {
+        $vite = app(Vite::class);
+        $vite->useHotFile(base_path($base . '/public/hot'));
+        return $vite($arguments, $base . '/public/build');
+    }
+
     /**
      * Opens a layout block.
      */

modules/system/ServiceProvider.php

@@ -8,6 +8,7 @@
 use Config;
 use DateInterval;
 use Event;
+use Illuminate\Foundation\Vite;
 use Illuminate\Pagination\Paginator;
 use Illuminate\Support\Facades\Schema;
 use Markdown;
@@ -142,6 +143,8 @@ protected function registerSingletons()
         $this->app->singleton('backend.auth', function () {
             return \Backend\Classes\AuthManager::instance();
         });
+
+        $this->app->singleton(Vite::class, Vite::class);
     }
 
     /**
@@ -316,12 +319,20 @@ protected function registerConsole()
         $this->registerConsoleCommand('plugin.rollback', \System\Console\PluginRollback::class);
         $this->registerConsoleCommand('plugin.list', \System\Console\PluginList::class);
 
-        $this->registerConsoleCommand('mix.install', \System\Console\MixInstall::class);
-        $this->registerConsoleCommand('mix.update', \System\Console\MixUpdate::class);
-        $this->registerConsoleCommand('mix.list', \System\Console\MixList::class);
-        $this->registerConsoleCommand('mix.compile', \System\Console\MixCompile::class);
-        $this->registerConsoleCommand('mix.watch', \System\Console\MixWatch::class);
-        $this->registerConsoleCommand('mix.run', \System\Console\MixRun::class);
+        $this->registerConsoleCommand('mix.compile', Console\Asset\Mix\MixCompile::class);
+        $this->registerConsoleCommand('mix.config', Console\Asset\Mix\MixConfig::class);
+        $this->registerConsoleCommand('mix.install', Console\Asset\Mix\MixInstall::class);
+        $this->registerConsoleCommand('mix.list', Console\Asset\Mix\MixList::class);
+        $this->registerConsoleCommand('mix.watch', Console\Asset\Mix\MixWatch::class);
+
+        $this->registerConsoleCommand('vite.compile', Console\Asset\Vite\ViteCompile::class);
+        $this->registerConsoleCommand('vite.config', Console\Asset\Vite\ViteConfig::class);
+        $this->registerConsoleCommand('vite.install', Console\Asset\Vite\ViteInstall::class);
+        $this->registerConsoleCommand('vite.list', Console\Asset\Vite\ViteList::class);
+        $this->registerConsoleCommand('vite.watch', Console\Asset\Vite\ViteWatch::class);
+
+        $this->registerConsoleCommand('npm.run', Console\NpmRun::class);
+        $this->registerConsoleCommand('npm.update', Console\NpmUpdate::class);
     }
 
     /*

modules/system/classes/CompilableAssets.php

@@ -0,0 +1,307 @@
+<?php namespace System\Classes;
+
+use Cms\Classes\Theme;
+use System\Classes\PluginManager;
+use Winter\Storm\Exception\SystemException;
+use Winter\Storm\Filesystem\PathResolver;
+use Winter\Storm\Support\Facades\Config;
+use Winter\Storm\Support\Facades\File;
+use Winter\Storm\Support\Str;
+
+/**
+ * Compilable assets using for Node.js compilation and processing.
+ *
+ * This works similar to the `System\Classes\CombineAssets` class in that it allows modules, plugins and themes to
+ * register configurations that will be passed on to Laravel Mix and Node.js for compilation and processing.
+ *
+ * @package winter\wn-system-module
+ * @author Ben Thomson <[email protected]>, Jack Wilkinson <[email protected]>
+ * @author Winter CMS
+ */
+class CompilableAssets
+{
+    use \Winter\Storm\Support\Traits\Singleton;
+
+    /**
+     * The filename that stores the package definition.
+     */
+    protected string $packageJson = 'package.json';
+
+    /**
+     * List of package types and registration methods
+     */
+    protected array $compilableConfigs = [
+        'mix' => [
+            'registrationMethod' => 'registerMixPackages',
+            'configFile' => 'winter.mix.js'
+        ],
+        'vite' => [
+            'registrationMethod' => 'registerVitePackages',
+            'configFile' => 'vite.config.js'
+        ]
+    ];
+
+    /**
+     * A list of packages registered for mixing.
+     */
+    protected array $packages = [];
+
+    /**
+     * Registered callbacks.
+     */
+    protected static array $callbacks = [];
+
+    /**
+     * Constructor.
+     */
+    public function init(): void
+    {
+        $packagePaths = [];
+
+        /*
+         * Get packages registered in plugins.
+         *
+         * In the Plugin.php file for your plugin, you can define the `registerMixPackages` or `registerVitePackages`
+         * method and return an array, with the name of the package being the key, and the build config path - relative
+         * to the plugin directory - as the value.
+         *
+         * Example:
+         *
+         *   public function registerMixPackages()
+         *   {
+         *       return [
+         *           'package-name-1' => 'winter.mix.js',
+         *           'package-name-2' => 'assets/js/build.js',
+         *       ];
+         *   }
+         *
+         *   public function registerVitePackages()
+         *   {
+         *       return [
+         *           'package-name-1' => 'vite.config.js',
+         *           'package-name-2' => 'assets/js/build.js',
+         *       ];
+         *   }
+         */
+        foreach ($this->compilableConfigs as $type => $config) {
+            $packages = PluginManager::instance()->getRegistrationMethodValues($config['registrationMethod']);
+            if (count($packages)) {
+                foreach ($packages as $pluginCode => $packageArray) {
+                    if (!is_array($packageArray)) {
+                        continue;
+                    }
+
+                    foreach ($packageArray as $name => $package) {
+                        $this->registerPackage(
+                            $name,
+                            PluginManager::instance()->getPluginPath($pluginCode) . '/' . $package,
+                            $type
+                        );
+                    }
+                }
+            }
+
+            // Get the currently enabled modules
+            $enabledModules = Config::get('cms.loadModules', []);
+
+            if (in_array('Cms', $enabledModules)) {
+                // Allow current theme to define mix assets
+                $theme = Theme::getActiveTheme();
+
+                if (!is_null($theme)) {
+                    $mix = $theme->getConfigValue($type, []);
+
+                    if (count($mix)) {
+                        foreach ($mix as $name => $file) {
+                            $this->registerPackage($name, $theme->getPath() . '/' . $file, $type);
+                        }
+                    }
+                }
+            }
+
+            // Search modules for compilable packages to autoregister
+            foreach ($enabledModules as $module) {
+                $module = strtolower($module);
+                $path = base_path('modules' . DIRECTORY_SEPARATOR . $module) . DIRECTORY_SEPARATOR . $config['configFile'];
+                if (File::exists($path)) {
+                    $packagePaths[$type]["module-$module"] = $path;
+                }
+            }
+
+            // Search plugins for compilable packages to autoregister
+            $plugins = PluginManager::instance()->getPlugins();
+            foreach ($plugins as $plugin) {
+                $path = $plugin->getPluginPath() . '/' . $config['configFile'];
+                if (File::exists($path)) {
+                    $packagePaths[$type][$plugin->getPluginIdentifier()] = $path;
+                }
+            }
+
+            // Search themes for compilable packages to autoregister
+            if (in_array('Cms', $enabledModules)) {
+                $themes = Theme::all();
+                foreach ($themes as $theme) {
+                    $path = $theme->getPath() . '/' . $config['configFile'];
+                    if (File::exists($path)) {
+                        $packagePaths[$type]["theme-" . $theme->getId()] = $path;
+                    }
+                }
+            }
+        }
+
+        // Register the autodiscovered compilable packages
+        foreach ($packagePaths as $type => $packages) {
+            foreach ($packages as $package => $path) {
+                try {
+                    $this->registerPackage($package, $path, $type);
+                } catch (SystemException $e) {
+                    // Either the package name or the config file path have already been registered, skip.
+                    continue;
+                }
+            }
+        }
+    }
+
+    /**
+     * Register a compilable config, this allows the
+     * @param string $name
+     * @param array $config
+     * @return void
+     */
+    public function registerCompilable(string $name, array $config): void
+    {
+        $this->compilableConfigs[$name] = $config;
+    }
+
+    /**
+     * Registers a callback for processing.
+     */
+    public static function registerCallback(callable $callback): void
+    {
+        static::$callbacks[] = $callback;
+    }
+
+    /**
+     * Calls the deferred callbacks.
+     */
+    public function fireCallbacks(): void
+    {
+        // Call callbacks
+        foreach (static::$callbacks as $callback) {
+            $callback($this);
+        }
+    }
+
+    /**
+     * Returns the count of packages registered.
+     */
+    public function getPackageCount(): int
+    {
+        return array_sum(array_map(fn ($packages) => count($packages), ...$this->packages));
+    }
+
+    /**
+     * Returns all packages registered.
+     */
+    public function getPackages(bool $includeIgnored = false, string $type = 'mix'): array
+    {
+        $packages = $this->packages[$type] ?? [];
+
+        ksort($packages);
+
+        if (!$includeIgnored) {
+            return array_filter($packages, function ($package) {
+                return !($package['ignored'] ?? false);
+            });
+        }
+
+        return $packages;
+    }
+
+    /**
+     * Registers an entity as a package for compilation.
+     *
+     * Entities can include plugins, components, themes, modules and much more.
+     *
+     * The name of the package is an alias that can be used to reference this package in other methods within this
+     * class.
+     *
+     * By default, the CompilableAssets class will look for a `package.json` file for Node dependencies, and a config
+     * file for the compilable configuration
+     *
+     * @param string $name The name of the package being registered
+     * @param string $path The path to the compilable JS configuration file. If there is a related package.json file
+     *                     then it is required to be present in the same directory as the config file
+     * @param string $type The type of compilable
+     * @throws SystemException
+     */
+    public function registerPackage(string $name, string $path, string $type = 'mix'): void
+    {
+        // Symbolize the path
+        $path = File::symbolizePath($path);
+
+        // Normalize the arguments
+        $name = strtolower($name);
+        $resolvedPath = PathResolver::resolve($path);
+        $pinfo = pathinfo($resolvedPath);
+        $path = Str::after($pinfo['dirname'], base_path() . DIRECTORY_SEPARATOR);
+        $configFile = $pinfo['basename'];
+
+        // Require $configFile to be a JS file
+        $extension = File::extension($configFile);
+        if ($extension !== 'js') {
+            throw new SystemException(
+                sprintf('Compilable configuration for package "%s" must be a JavaScript file ending with .js', $name)
+            );
+        }
+
+        // Check that the package path exists
+        if (!File::exists($path)) {
+            throw new SystemException(
+                sprintf('Cannot register "%s" as a compilable package; the "%s" path does not exist.', $name, $path)
+            );
+        }
+
+        // Check for any existing packages already registered under the provided name
+        if (isset($this->packages[$name])) {
+            throw new SystemException(sprintf(
+                'Cannot register "%s" as a compilable package; it has already been registered at %s.',
+                $name,
+                $this->packages[$name]['config']
+            ));
+        }
+
+        $package = "$path/{$this->packageJson}";
+        $config = $path . DIRECTORY_SEPARATOR . $configFile;
+
+        // Check for any existing package that already registers the given compilable config path
+        foreach ($this->packages[$type] ?? [] as $packageName => $settings) {
+            if ($settings['config'] === $config) {
+                throw new SystemException(sprintf(
+                    'Cannot register "%s" (%s) as a compilable package; it has already been registered as %s.',
+                    $name,
+                    $config,
+                    $packageName
+                ));
+            }
+        }
+
+        // Register the package
+        $this->packages[$type][$name] = [
+            'path' => $path,
+            'package' => $package,
+            'config' => $config,
+            'ignored' => $this->isPackageIgnored($path),
+        ];
+    }
+
+    /**
+     * Check if the provided package is ignored.
+     */
+    protected function isPackageIgnored(string $packagePath): bool
+    {
+        // Load the main package.json for the project
+        $packageJson = new PackageJson(base_path($this->packageJson));
+        return $packageJson->hasIgnoredPackage($packagePath);
+    }
+}