metaowl 0.2.14 → 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,68 +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() {
-  // Skip in test environment (Vitest doesn't have the same import.meta behavior)
-  // Also skip if we're not in a browser environment
-  if (typeof window === 'undefined' && typeof globalThis.importMeta === 'undefined') {
-    return null
-  }
-
-  try {
-    // In production (build), templates are inlined via Vite plugin
-    // Use dynamic import with a path that Vite can resolve at runtime
-    // The templates.js is generated in the output directory
-    // Using eval to prevent Vite's static analysis from failing
-    const templatesModule = await new Function('return import("/templates.js")')()
-    return templatesModule.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.14",
+  "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,36 +219,16 @@ export async function metaowlPlugin(options = {}) {
       closeBundle() {
         const projectRoot = process.cwd()
 
-        // Collect and inline all XML templates into a single JS file
-        // Use already collected XML arrays to avoid duplicate glob operations
-        const xmlFiles = [
-          ...layoutXml,
-          ...pageXml,
-          ...componentXml
-        ]
-
-        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 using JSON encoding for safety
-        const escaped = JSON.stringify(templates).slice(1, -1)
-
-        // Write templates.js to the output root (accessible as /templates.js)
-        const templatesJs = `export const TEMPLATES = '${escaped}';\n`
-        const templatesDir = _outDirResolved
-        mkdirSync(templatesDir, { recursive: true })
-        writeFileSync(resolve(templatesDir, 'templates.js'), templatesJs)
-
-        console.log(`[metaowl] Inlined ${xmlFiles.length} XML templates into templates.js`)
 
-        // Restore: Copy assets/images (referenced via absolute URLs in XML)
+        // 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 })