metaowl 0.2.11 → 0.2.13

package/index.js

@@ -1,6 +1,7 @@
 import { mountApp } from './modules/app-mounter.js'
 import { buildRoutes } from './modules/file-router.js'
 import { processRoutes } from './modules/router.js'
+import { discoverLayouts } from './modules/layouts.js'
 
 export { default as Fetch } from './modules/fetch.js'
 export { default as Cache } from './modules/cache.js'
@@ -170,7 +171,21 @@ export {
  *
  * @param {Record<string, object>|object[]} [routesOrModules]
  */
-export async function boot(routesOrModules = {}) {
+export async function boot(routesOrModules = {}, layoutsOrModules = null) {
+  // Auto-discover layouts
+  try {
+    if (layoutsOrModules) {
+      // Use layouts provided by Vite plugin transformation
+      const { buildLayouts, setDefaultLayout } = await import('./modules/layouts.js')
+      buildLayouts(layoutsOrModules)
+      setDefaultLayout('default')
+    } else {
+      await discoverLayouts()
+    }
+  } catch (e) {
+    console.warn('[metaowl] Could not auto-discover layouts:', e.message)
+  }
+
   const routes = Array.isArray(routesOrModules)
     ? routesOrModules
     : buildRoutes(routesOrModules)

package/modules/templates-manager.js

@@ -2,17 +2,43 @@
  * @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.
  *
- * @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 +49,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.11",
+  "version": "0.2.13",
   "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`,
@@ -191,10 +191,7 @@ export async function metaowlPlugin(options = {}) {
         return {
           code: code.replace(
             /boot\(\s*\)/,
-            `boot(import.meta.glob('./${pagesRel}/**/*.js', { eager: true }))`
-          ).replace(
-            /discoverLayouts\(\s*\)/,
-            `discoverLayouts(import.meta.glob('./${layoutsRel}/**/*.js', { eager: true }))`
+            `boot(import.meta.glob('./${pagesRel}/**/*.js', { eager: true }), import.meta.glob('./${layoutsRel}/**/*.js', { eager: true }))`
           ),
           map: null
         }
@@ -222,20 +219,37 @@ 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
+        const xmlFiles = [
+          ...globSync(`${root}/${layoutsDir}/**/*.xml`),
+          ...globSync(`${root}/${pagesDir}/**/*.xml`),
+          ...globSync(`${root}/${componentsDir}/**/*.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 })
+        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
+        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`)
       }
     }
   ]