@vituum/vite-plugin-latte 0.1.21 → 1.0.0-alpha.2

package/handler.js

@@ -7,6 +7,8 @@ const type = process.argv[3]
 
 params = params.map(value => Buffer.from(value, 'base64').toString('utf-8'))
 
-const output = await vite.plugins.filter(({ name }) => name === '@vituum/vite-plugin-latte')[0]._params[type][name](...params)
+const output = await vite.plugins.find(plugin => plugin[0]?.name === '@vituum/vite-plugin-latte')[0]._options[type][name](...params)
 
-console.log(Buffer.from(output.toString(), 'utf-8').toString('base64'))
+if (output) {
+    console.log(Buffer.from(output.toString(), 'utf-8').toString('base64'))
+}

package/index.js

@@ -1,28 +1,30 @@
-import { resolve, dirname } from 'path'
-import { fileURLToPath } from 'url'
-import fs from 'fs'
+import { resolve, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import fs from 'node:fs'
 import process from 'node:process'
-import * as childProcess from 'child_process'
+import * as childProcess from 'node:child_process'
 import FastGlob from 'fast-glob'
-import lodash from 'lodash'
 import { minimatch } from 'minimatch'
-import chalk from 'chalk'
+import { getPackageInfo, pluginError, pluginReload, merge, pluginBundle } from 'vituum/utils/common.js'
+import { renameBuildEnd, renameBuildStart } from 'vituum/utils/build.js'
 
-const defaultParams = {
+const { name } = getPackageInfo(import.meta.url)
+
+/**
+ * @type {import('@vituum/vite-plugin-latte/types/index.d.ts').PluginUserConfig} options
+ */
+const defaultOptions = {
     reload: true,
     root: null,
-    bin: 'php',
     filters: {},
     functions: {},
     tags: {},
     globals: {},
-    data: '',
-    isStringFilter: undefined,
-    ignoredPaths: [],
-    filetypes: {
-        html: /.(json.html|latte.json.html|latte.html)$/,
-        json: /.(json.latte.html)$/
-    }
+    data: ['src/data/**/*.json'],
+    formats: ['latte', 'json.latte', 'json'],
+    bin: 'php',
+    renderTransformedHtml: () => false,
+    ignoredPaths: []
 }
 
 const execSync = (cmd) => {
@@ -38,7 +40,9 @@ const execSync = (cmd) => {
     }
 }
 
-const renderTemplate = (path, params, content) => {
+const renderTemplate = ({ path, filename, cwd, packageRoot }, params, content) => {
+    const renderTransformedHtml = params.renderTransformedHtml(filename)
+
     if (params.data) {
         const normalizePaths = Array.isArray(params.data) ? params.data.map(path => path.replace(/\\/g, '/')) : params.data.replace(/\\/g, '/')
 
@@ -57,100 +61,102 @@ const renderTemplate = (path, params, content) => {
         }
     })
 
-    if (params.isString) {
+    if (renderTransformedHtml) {
         const timestamp = Math.floor(Date.now() * Math.random())
 
         params.contentTimestamp = timestamp
 
-        if (!fs.existsSync(resolve(params.packageRoot, 'temp'))) {
-            fs.mkdirSync(resolve(params.packageRoot, 'temp'))
+        if (!fs.existsSync(resolve(packageRoot, 'temp'))) {
+            fs.mkdirSync(resolve(packageRoot, 'temp'))
         }
 
-        fs.writeFileSync(resolve(params.packageRoot, `temp/${timestamp}.html`), content)
+        fs.writeFileSync(resolve(packageRoot, `temp/${timestamp}.html`), content)
     }
 
-    return execSync(`${params.bin} ${params.packageRoot}/index.php ${params.root + path} ${JSON.stringify(JSON.stringify(params))}`)
+    return execSync(`${params.bin} ${packageRoot}/index.php ${join(params.root, path)} ${JSON.stringify(JSON.stringify(Object.assign({ packageRoot, cwd, renderTransformedHtml }, params)))}`)
 }
 
-const latte = (params = {}) => {
-    params.cwd = process.cwd()
+/**
+ * @param {import('@vituum/vite-plugin-latte/types/index.d.ts').PluginUserConfig} options
+ * @returns [import('vite').Plugin]
+ */
+const plugin = (options = {}) => {
+    let resolvedConfig
+    let userEnv
 
-    params = lodash.merge(defaultParams, params)
+    options = merge(defaultOptions, options)
 
-    params.packageRoot = dirname((fileURLToPath(import.meta.url)))
+    const cwd = process.cwd()
+    const packageRoot = dirname((fileURLToPath(import.meta.url)))
 
-    if (fs.existsSync(resolve(params.packageRoot, 'temp'))) {
-        fs.rmSync(resolve(params.packageRoot, 'temp'), { recursive: true, force: true })
+    if (fs.existsSync(resolve(packageRoot, 'temp'))) {
+        fs.rmSync(resolve(packageRoot, 'temp'), { recursive: true, force: true })
     }
 
-    if (params.bin === 'docker') {
-        params.bin = `docker run --rm --name index -v "${process.cwd()}":/usr/src/app -w /usr/src/app php:8-cli php`
+    if (options.bin === 'docker') {
+        options.bin = `docker run --rm --name index -v "${process.cwd()}":/usr/src/app -w /usr/src/app php:8-cli php`
     }
 
-    return {
-        _params: params,
-        name: '@vituum/vite-plugin-latte',
-        config: ({ root }) => {
-            if (!params.root) {
-                params.root = root
+    return [{
+        _options: options,
+        name,
+        config (userConfig, env) {
+            userEnv = env
+        },
+        configResolved (config) {
+            resolvedConfig = config
+
+            if (!options.root) {
+                options.root = config.root
             }
         },
+        buildStart: async () => {
+            if (userEnv.command !== 'build') {
+                return
+            }
+
+            await renameBuildStart(resolvedConfig.build.rollupOptions.input, options.formats)
+        },
+        buildEnd: async () => {
+            if (userEnv.command !== 'build') {
+                return
+            }
+
+            await renameBuildEnd(resolvedConfig.build.rollupOptions.input, options.formats)
+        },
         transformIndexHtml: {
             enforce: 'pre',
-            async transform(content, { path, filename, server }) {
+            async transform (content, { path, filename, server }) {
                 path = path.replace('?raw', '')
                 filename = filename.replace('?raw', '')
 
-                if (params.ignoredPaths.filter(ignoredPaths => minimatch(path.replace('.html', '').replace('.vituum', ''), ignoredPaths)).length !== 0) {
+                if (options.ignoredPaths.find(ignoredPath => minimatch(path.replace('.html', ''), ignoredPath) === true)) {
                     return content
                 }
 
-                if (
-                    !params.filetypes.html.test(path) &&
-                    !params.filetypes.json.test(path) &&
-                    !content.startsWith('<script type="application/json" data-format="latte"')
-                ) {
+                if (!options.formats.find(format => path.endsWith(`${format}.html`))) {
                     return content
                 }
 
-                if (typeof params.isStringFilter === 'function' && params.isStringFilter(filename)) {
-                    params.isString = true
-                } else {
-                    params.isString = false
-                }
+                const render = renderTemplate({ path, filename, cwd, packageRoot }, options, content)
+                const warningLog = render.output.includes('Warning: Undefined')
 
-                const renderLatte = renderTemplate(path, params, content)
-                const warningLog = renderLatte.output.includes('Warning: Undefined')
+                if (render.error || warningLog) {
+                    const message = warningLog ? 'Warning: Undefined' + render.output.split('Warning: Undefined').pop() : render.output
+                    const renderError = pluginError(message, server, name)
 
-                if (renderLatte.error || warningLog) {
-                    if (!server) {
-                        console.error(chalk.red(renderLatte.output))
+                    if (renderError && server) {
                         return
+                    } else if (renderError) {
+                        return renderError
                     }
-
-                    const message = warningLog ? 'Warning: Undefined' + renderLatte.output.split('Warning: Undefined').pop() : renderLatte.output
-
-                    setTimeout(() => server.ws.send({
-                        type: 'error',
-                        err: {
-                            message,
-                            plugin: '@vituum/vite-plugin-latte'
-                        }
-                    }), 50)
                 }
 
-                return renderLatte.output
+                return render.output
             }
         },
-        handleHotUpdate({ file, server }) {
-            if (
-                (typeof params.reload === 'function' && params.reload(file)) ||
-                (typeof params.reload === 'boolean' && params.reload && (params.filetypes.html.test(file) || params.filetypes.json.test(file)))
-            ) {
-                server.ws.send({ type: 'full-reload' })
-            }
-        }
-    }
+        handleHotUpdate: ({ file, server }) => pluginReload({ file, server }, options)
+    }, pluginBundle(options.formats)]
 }
 
-export default latte
+export default plugin

package/index.php

@@ -164,7 +164,7 @@ if (!file_exists(str_replace($config->cwd, ROOT_DIR, $params->template))) {
     throw new Error('File not found ' . str_replace($config->cwd, ROOT_DIR, $params->template));
 }
 
-if (isset($config->isString) && $config->isString) {
+if (isset($config->renderTransformedHtml) && $config->renderTransformedHtml) {
     if (isset($config->contentTimestamp)) {
         $content = file_get_contents(__DIR__ . '/temp/' . $config->contentTimestamp . '.html');
         unlink(__DIR__ . '/temp/' . $config->contentTimestamp . '.html');

package/latte/AssetFilter.php

@@ -6,6 +6,6 @@ class AssetFilter
 {
     public static function execute($source): string
     {
-        return str_starts_with($source, 'http') ? $source : str_replace("/src/", "/", $source);
+        return $source;
     }
 }

package/package.json

@@ -1,31 +1,38 @@
 {
   "name": "@vituum/vite-plugin-latte",
-  "version": "0.1.21",
+  "version": "1.0.0-alpha.2",
   "type": "module",
   "main": "index.js",
   "scripts": {
     "dev": "vite dev",
-    "build": "vite build && mv public/views/* public && rm -rf public/views",
+    "build": "vite build",
     "preview": "vite preview"
   },
   "dependencies": {
+    "vituum": "^1.0.0-alpha.16",
     "fast-glob": "^3.2.12",
     "lodash": "^4.17.21",
-    "chalk": "^5.2.0",
-    "minimatch": "^9.0.0"
+    "minimatch": "^9.0.1"
   },
   "devDependencies": {
-    "vite": "^4.2.2",
-    "eslint": "^8.38.0",
-    "eslint-config-standard": "^17.0.0"
+    "@types/node": "^20.3.1",
+    "vite": "^4.3.9",
+    "eslint": "^8.42.0",
+    "eslint-config-standard": "^17.1.0",
+    "typescript": "^5.1.3"
   },
   "files": [
     "index.js",
     "handler.js",
     "index.php",
     "latte",
-    "vendor"
+    "vendor",
+    "types"
   ],
+  "exports": {
+    ".": "./index.js",
+    "./types": "./types/*"
+  },
   "engines": {
     "node": ">=16.0.0",
     "npm": ">=8.0.0"

package/types/index.d.ts

@@ -0,0 +1,13 @@
+export interface PluginUserConfig {
+    reload?: boolean | Function
+    root?: string
+    filters?: Object
+    functions?: Object
+    tags?: Object
+    globals?: Object
+    data?: string | string[]
+    formats?: string[]
+    bin?: string
+    renderTransformedHtml?: (filename: string) => boolean
+    ignoredPaths?: string[]
+}