metaowl 0.2.12 → 0.2.14

package/modules/templates-manager.js

@@ -2,17 +2,52 @@
  * @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.
  *
- * @param {string[]} files - Array of URL-style XML paths, e.g. ['/owl/components/Header/Header.xml']
+ * 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)
  * @returns {Promise<string>}
  */
-export async function mergeTemplates(files) {
+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 {
@@ -23,3 +58,12 @@ export async function mergeTemplates(files) {
   }
   return templates + '</templates>'
 }
+
+/**
+ * Check if inlined templates are available.
+ * @returns {Promise<boolean>}
+ */
+export async function hasInlinedTemplates() {
+  const templates = await getInlinedTemplates()
+  return templates !== null
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metaowl",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "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 } from 'node:fs'
+import { mkdirSync, copyFileSync, cpSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { globSync } from 'glob'
 import { config as dotenvConfig } from 'dotenv'
@@ -63,7 +63,7 @@ export async function metaowlPlugin(options = {}) {
   const componentXml = collectXml(`${componentsDir}/**/*.xml`)
   const pageXml = collectXml(`${pagesDir}/**/*.xml`)
   const layoutXml = collectXml(`${layoutsDir}/**/*.xml`)
-  const allComponents = [...pageXml, ...componentXml, ...layoutXml]
+  const allComponents = [...layoutXml, ...pageXml, ...componentXml]
 
   const defaultRestartGlobs = [
     `${root}/**/*.[jt]s`,
@@ -219,16 +219,36 @@ export async function metaowlPlugin(options = {}) {
       closeBundle() {
         const projectRoot = process.cwd()
 
-        // 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)
+        // 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}`)
+          }
         }
+        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`)
 
-        // Copy assets/images (referenced via absolute URLs in XML — not processed by Vite)
+        // Restore: Copy assets/images (referenced via absolute URLs in XML)
         const srcImages = resolve(projectRoot, root, 'assets', 'images')
         if (existsSync(srcImages)) {
           cpSync(srcImages, resolve(_outDirResolved, 'assets', 'images'), { recursive: true })