metaowl 0.2.13 → 0.2.16

package/README.md

@@ -63,6 +63,7 @@ All powered by a batteries-included Vite plugin that handles the build pipeline,
 - [ESLint Config](#eslint-config)
 - [PostCSS Config](#postcss-config)
 - [TypeScript / jsconfig](#typescript--jsconfig)
+- [Deployment](#deployment)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -1370,6 +1371,69 @@ Extend from the included base configs to get sensible defaults:
 
 ---
 
+## Deployment
+
+MetaOWL provides two ways to build your application for production:
+
+### Option 1: `npm run generate` (Recommended)
+
+```bash
+npm run generate
+```
+
+This command generates static HTML files for all routes. The result works **without any server configuration** on all web hosts:
+
+- GitHub Pages
+- Vercel
+- Netlify
+- Cloudflare Pages
+- Any traditional web host
+
+All pages are generated as separate HTML files at build time, so every route can be accessed directly.
+
+### Option 2: `npm run build`
+
+```bash
+npm run build
+```
+
+This command creates a Single Page Application (SPA). Since all routes are handled client-side, the web server must **forward all requests to `index.html`** (SPA fallback).
+
+#### Web Server Configuration by Host:
+
+**Vercel, Netlify, Cloudflare Pages:**
+Create a `public/serve.json` file before building:
+
+```json
+{
+  "rewrites": [
+    { "source": "**", "destination": "/index.html" }
+  ]
+}
+```
+
+**Apache (.htaccess):**
+```apache
+RewriteEngine On
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule ^ /index.html [L]
+```
+
+**nginx:**
+```nginx
+location / {
+  try_files $uri $uri/ /index.html;
+}
+```
+
+**Node.js (with serve):**
+```bash
+npx serve -s dist
+```
+
+---
+
 ## Contributing
 
 Contributions are welcome! Please open an issue before submitting a pull request so we can discuss the change.

package/modules/templates-manager.js

@@ -2,59 +2,26 @@
  * @module TemplatesManager
  *
  * Template loading and merging utilities for OWL applications.
- * Supports both runtime loading (legacy) and build-time inlined templates.
  */
 import { loadFile } from '@odoo/owl'
 
-/**
- * Try to import inlined templates from build time.
- * Returns null if not available (dev mode without inline plugin or legacy setup).
- */
-async function getInlinedTemplates() {
-  try {
-    // In production (build), templates are inlined via Vite plugin
-    const { TEMPLATES } = await import('/src/templates.js')
-    return TEMPLATES
-  } catch (e) {
-    // In development or legacy setup, templates are loaded at runtime
-    return null
-  }
-}
-
 /**
  * Loads and concatenates a list of OWL XML template files into a single
  * `<templates>` string ready to be passed to OWL's mount() options.
  *
- * If inlined templates are available (from build time), those are used directly.
- * Otherwise, falls back to runtime loading of individual XML files.
- *
- * @param {string[]} [files] - Array of URL-style XML paths (ignored if inlined templates exist)
+ * @param {string[]} files - Array of URL-style XML paths, e.g. ['/owl/components/Header/Header.xml']
  * @returns {Promise<string>}
  */
-export async function mergeTemplates(files = []) {
-  // Try to get inlined templates first (production build)
-  const inlined = await getInlinedTemplates()
-  if (inlined) {
-    return inlined
-  }
-
-  // Fallback: load templates at runtime (development or legacy)
-  let templates = '<templates>'
-  for (const file of files) {
-    try {
-      templates += await loadFile(file)
-    } catch (e) {
-      console.error(`[metaowl] Failed to load template: ${file}`, e)
-    }
-  }
-  return templates + '</templates>'
-}
-
-/**
- * Check if inlined templates are available.
- * @returns {Promise<boolean>}
- */
-export async function hasInlinedTemplates() {
-  const templates = await getInlinedTemplates()
-  return templates !== null
+export async function mergeTemplates(files) {
+  const results = await Promise.all(
+    files.map(async (file) => {
+      try {
+        return await loadFile(file)
+      } catch (e) {
+        console.error(`[metaowl] Failed to load template: ${file}`, e)
+        return ''
+      }
+    })
+  )
+  return '<templates>' + results.join('') + '</templates>'
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metaowl",
-  "version": "0.2.13",
+  "version": "0.2.16",
   "description": "Lightweight meta-framework for Odoo OWL — file-based routing, app mounting, Fetch helper, Cache, Meta tags, SSG generator, and a Vite plugin.",
   "type": "module",
   "main": "index.js",

package/vite/plugin.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'node:url'
 import { resolve, dirname } from 'node:path'
-import { mkdirSync, copyFileSync, cpSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { mkdirSync, copyFileSync, cpSync, existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { globSync } from 'glob'
 import { config as dotenvConfig } from 'dotenv'
@@ -219,37 +219,20 @@ export async function metaowlPlugin(options = {}) {
       closeBundle() {
         const projectRoot = process.cwd()
 
-        // Collect and inline all XML templates into a single JS file
-        const xmlFiles = [
-          ...globSync(`${root}/${layoutsDir}/**/*.xml`),
-          ...globSync(`${root}/${pagesDir}/**/*.xml`),
-          ...globSync(`${root}/${componentsDir}/**/*.xml`)
-        ]
-
-        let templates = '<templates>'
-        for (const file of xmlFiles) {
-          try {
-            templates += readFileSync(file, 'utf-8')
-          } catch (e) {
-            console.warn(`[metaowl] Failed to read template: ${file}`)
-          }
+        // Copy OWL XML templates (loaded at runtime via fetch — not processed by Vite)
+        const xmlFiles = globSync([`${componentsDir}/**/*.xml`, `${pagesDir}/**/*.xml`, `${layoutsDir}/**/*.xml`])
+        for (const xmlFile of xmlFiles) {
+          const relPath = xmlFile.replace(new RegExp(`^${root}[\\/]`), '')
+          const dest = resolve(_outDirResolved, relPath)
+          mkdirSync(dirname(dest), { recursive: true })
+          copyFileSync(resolve(projectRoot, xmlFile), dest)
         }
-        templates += '</templates>'
-
-        // Escape for JavaScript string
-        const escaped = templates
-          .replace(/\\/g, '\\\\')
-          .replace(/'/g, "\\'")
-          .replace(/\n/g, '\\n')
-          .replace(/\r/g, '')
 
-        // Write templates.js
-        const templatesJs = `export const TEMPLATES = '${escaped}';\n`
-        const templatesDir = resolve(_outDirResolved, root)
-        mkdirSync(templatesDir, { recursive: true })
-        writeFileSync(resolve(templatesDir, 'templates.js'), templatesJs)
-
-        console.log(`[metaowl] Inlined ${xmlFiles.length} XML templates into templates.js`)
+        // Copy assets/images (referenced via absolute URLs in XML — not processed by Vite)
+        const srcImages = resolve(projectRoot, root, 'assets', 'images')
+        if (existsSync(srcImages)) {
+          cpSync(srcImages, resolve(_outDirResolved, 'assets', 'images'), { recursive: true })
+        }
       }
     }
   ]