metaowl 0.4.1 → 0.5.0

package/build/runtime/bin/metaowl-generate.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * metaowl generate — SSG production build.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { globSync } from 'glob';
+import { banner, cwd, resolveBin, resolveOwnRuntimeBin, run, step, success } from './utils.js';
+banner('generate');
+function escapeAttr(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+function extractMetaFromJs(src) {
+    const meta = {};
+    const fns = [
+        'title', 'description', 'keywords', 'author', 'canonical',
+        'ogTitle', 'ogDescription', 'ogImage', 'ogUrl', 'ogType', 'ogSiteName'
+    ];
+    for (const fn of fns) {
+        const match = src.match(new RegExp(`Meta\\.${fn}\\s*\\(\\s*(['"\`])([^'"\`]+)\\1\\s*\\)`));
+        if (match?.[2])
+            meta[fn] = match[2];
+    }
+    return meta;
+}
+function injectMeta(html, meta) {
+    let nextHtml = html;
+    if (meta.title) {
+        nextHtml = nextHtml.replace(/<title>[^<]*<\/title>/, `<title>${escapeAttr(meta.title)}</title>`);
+    }
+    const injectTag = (selector, tag) => {
+        nextHtml = nextHtml.replace(new RegExp(`\\s*${selector}[^>]*>\\s*`, 'gi'), '');
+        nextHtml = nextHtml.replace('</head>', `  ${tag}\n  </head>`);
+    };
+    if (meta.description)
+        injectTag('<meta\\s+name="description"', `<meta name="description" content="${escapeAttr(meta.description)}">`);
+    if (meta.keywords)
+        injectTag('<meta\\s+name="keywords"', `<meta name="keywords" content="${escapeAttr(meta.keywords)}">`);
+    if (meta.author)
+        injectTag('<meta\\s+name="author"', `<meta name="author" content="${escapeAttr(meta.author)}">`);
+    if (meta.canonical)
+        injectTag('<link\\s+rel="canonical"', `<link rel="canonical" href="${escapeAttr(meta.canonical)}">`);
+    if (meta.ogTitle)
+        injectTag('<meta\\s+property="og:title"', `<meta property="og:title" content="${escapeAttr(meta.ogTitle)}">`);
+    if (meta.ogDescription)
+        injectTag('<meta\\s+property="og:description"', `<meta property="og:description" content="${escapeAttr(meta.ogDescription)}">`);
+    if (meta.ogImage)
+        injectTag('<meta\\s+property="og:image"', `<meta property="og:image" content="${escapeAttr(meta.ogImage)}">`);
+    if (meta.ogUrl)
+        injectTag('<meta\\s+property="og:url"', `<meta property="og:url" content="${escapeAttr(meta.ogUrl)}">`);
+    if (meta.ogType)
+        injectTag('<meta\\s+property="og:type"', `<meta property="og:type" content="${escapeAttr(meta.ogType)}">`);
+    if (meta.ogSiteName)
+        injectTag('<meta\\s+property="og:site_name"', `<meta property="og:site_name" content="${escapeAttr(meta.ogSiteName)}">`);
+    return nextHtml;
+}
+const pkg = JSON.parse(readFileSync(resolve(cwd, 'package.json'), 'utf-8'));
+const metaowlConfig = pkg.metaowl ?? {};
+const pagesDir = metaowlConfig.pagesDir ?? 'src/pages';
+const outDir = metaowlConfig.outDir ?? 'dist';
+function deriveRoute(pageFile) {
+    const rel = pageFile.replace(new RegExp(`^${pagesDir}[\\/]`), '');
+    const parts = rel.split('/').slice(0, -1);
+    if (parts.length === 1 && parts[0] === 'index')
+        return '/';
+    return '/' + parts.join('/');
+}
+function extractLayoutName(pageFile) {
+    const jsSource = readFileSync(pageFile, 'utf-8');
+    let match = jsSource.match(/static\s+layout\s*=\s*['"]([^'"]+)['"]/);
+    if (match?.[1])
+        return match[1];
+    match = jsSource.match(/@layout\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (match?.[1])
+        return match[1];
+    match = jsSource.match(/@defineLayout\s*\(\s*['"]([^'"]+)['"]/);
+    if (match?.[1])
+        return match[1];
+    return 'default';
+}
+function xmlToStaticHtml(xml, pageContent = '', options = {}) {
+    const { templateCache } = options;
+    let html = xml;
+    html = html.replace(/<templates>/g, '').replace(/<\/templates>/g, '');
+    html = html.replace(/^\s*<t[^>]*>/, '').replace(/<\/t>\s*$/, '');
+    html = html.replace(/\s+t-name="[^"]*"/g, '');
+    html = html.replace(/\s+t-[\w-]+(="[^"]*")?/g, '');
+    html = html.replace(/<t\s*\/>/g, '');
+    html = html.replace(/<t(?:\s[^>]*)?>([\s\S]*?)<\/t>/g, (_match, inner) => inner);
+    if (pageContent) {
+        html = html.replace(/<t\s+t-slot="default"\s*\/?>/g, pageContent);
+        html = html.replace(/<t\s+t-slot="default"[^>]*>([\s\S]*?)<\/t>/g, pageContent);
+    }
+    if (templateCache) {
+        let previousHtml;
+        do {
+            previousHtml = html;
+            html = html.replace(/<([A-Z][A-Za-z0-9]*)\s*\/>/g, (match, componentName) => {
+                const templateNames = [
+                    componentName,
+                    componentName.charAt(0).toLowerCase() + componentName.slice(1),
+                    componentName + 'Component'
+                ];
+                for (const name of templateNames) {
+                    if (templateCache.has(name)) {
+                        return templateCache.get(name);
+                    }
+                }
+                return match;
+            });
+            html = html.replace(/<([A-Z][A-Za-z0-9]*)(?:\s[^>]*)?>([\s\S]*?)<\/\1>/g, (match, componentName) => {
+                const templateNames = [
+                    componentName,
+                    componentName.charAt(0).toLowerCase() + componentName.slice(1),
+                    componentName + 'Component'
+                ];
+                for (const name of templateNames) {
+                    if (templateCache.has(name)) {
+                        return templateCache.get(name);
+                    }
+                }
+                return match;
+            });
+        } while (html !== previousHtml);
+    }
+    else {
+        html = html.replace(/<([A-Z][A-Za-z0-9]*)\s*\/>/g, '<!-- $1 -->');
+        html = html.replace(/<([A-Z][A-Za-z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, '<!-- $1 -->');
+    }
+    return html.trim();
+}
+function buildShell(baseHtml, pageFile) {
+    let html = baseHtml;
+    const jsSource = readFileSync(resolve(cwd, pageFile), 'utf-8');
+    const meta = extractMetaFromJs(jsSource);
+    html = injectMeta(html, meta);
+    const layoutName = extractLayoutName(resolve(cwd, pageFile));
+    const layoutsDir = metaowlConfig.layoutsDir ?? 'src/layouts';
+    const componentsDir = metaowlConfig.componentsDir ?? 'src/components';
+    const templateCache = new Map();
+    const componentXmlFiles = globSync(`${componentsDir}/**/*.xml`, { cwd });
+    for (const componentXmlFile of componentXmlFiles) {
+        const content = readFileSync(resolve(cwd, componentXmlFile), 'utf-8');
+        const tNameMatches = content.matchAll(/<t\s+t-name="([^"]+)"[^>]*>([\s\S]*?)<\/t>/g);
+        for (const match of tNameMatches) {
+            if (match[1] && match[2]) {
+                templateCache.set(match[1], match[2]);
+            }
+        }
+        const rootMatch = content.match(/<templates>\s*<t[^>]*>([\s\S]*?)<\/t>\s*<\/templates>/);
+        if (rootMatch?.[1]) {
+            const fileName = componentXmlFile.replace(/\.xml$/, '').split('/').pop();
+            if (fileName) {
+                templateCache.set(fileName, rootMatch[1]);
+            }
+        }
+    }
+    const layoutXmlFiles = globSync(`${layoutsDir}/**/*.xml`, { cwd });
+    for (const layoutXmlFile of layoutXmlFiles) {
+        const content = readFileSync(resolve(cwd, layoutXmlFile), 'utf-8');
+        const tNameMatches = content.matchAll(/<t\s+t-name="([^"]+)"[^>]*>([\s\S]*?)<\/t>/g);
+        for (const match of tNameMatches) {
+            if (match[1] && match[2]) {
+                templateCache.set(match[1], match[2]);
+            }
+        }
+    }
+    const pageXmlFiles = globSync(`${pagesDir}/**/*.xml`, { cwd });
+    for (const pageXmlFile of pageXmlFiles) {
+        const content = readFileSync(resolve(cwd, pageXmlFile), 'utf-8');
+        const tNameMatches = content.matchAll(/<t\s+t-name="([^"]+)"[^>]*>([\s\S]*?)<\/t>/g);
+        for (const match of tNameMatches) {
+            if (match[1] && match[2]) {
+                templateCache.set(match[1], match[2]);
+            }
+        }
+        const rootMatch = content.match(/<templates>\s*<t[^>]*>([\s\S]*?)<\/t>\s*<\/templates>/);
+        if (rootMatch?.[1]) {
+            const fileName = pageXmlFile.replace(/\.xml$/, '').split('/').pop();
+            if (fileName) {
+                templateCache.set(fileName, rootMatch[1]);
+            }
+        }
+    }
+    let finalContent = '';
+    const layoutXmlFile = resolve(cwd, layoutsDir, layoutName, `${layoutName.charAt(0).toUpperCase() + layoutName.slice(1)}Layout.xml`);
+    const layoutXmlExists = existsSync(layoutXmlFile);
+    const pageXmlFile = resolve(cwd, pageFile.replace(/\.js$/, '.xml'));
+    const pageXmlExists = existsSync(pageXmlFile);
+    if (layoutXmlExists && pageXmlExists) {
+        const layoutXmlContent = readFileSync(layoutXmlFile, 'utf-8');
+        const pageXmlContent = readFileSync(pageXmlFile, 'utf-8');
+        const pageStaticHtml = xmlToStaticHtml(pageXmlContent, '', { templateCache });
+        finalContent = xmlToStaticHtml(layoutXmlContent, pageStaticHtml, { templateCache });
+    }
+    else if (pageXmlExists) {
+        const pageXmlContent = readFileSync(pageXmlFile, 'utf-8');
+        finalContent = xmlToStaticHtml(pageXmlContent, '', { templateCache });
+    }
+    if (finalContent) {
+        html = html.replace(/(<div\s+id="metaowl"[^>]*>)(<\/div>)/, `$1${finalContent}$2`);
+    }
+    return html;
+}
+run('Linting', `node "${resolveOwnRuntimeBin('metaowl-lint')}"`);
+run('Building', `"${resolveBin('vite')}" build`);
+step('Generating static pages...');
+console.log();
+const baseHtml = readFileSync(resolve(cwd, outDir, 'index.html'), 'utf-8');
+const pageFiles = globSync(`${pagesDir}/**/*.js`, { cwd });
+const seen = new Set();
+for (const pageFile of pageFiles) {
+    const route = deriveRoute(pageFile);
+    if (seen.has(route))
+        continue;
+    seen.add(route);
+    const shell = buildShell(baseHtml, pageFile);
+    if (route === '/') {
+        writeFileSync(resolve(cwd, outDir, 'index.html'), shell);
+        console.log('    /index.html');
+    }
+    else {
+        const destDir = resolve(cwd, outDir, route.slice(1));
+        mkdirSync(destDir, { recursive: true });
+        writeFileSync(resolve(destDir, 'index.html'), shell);
+        console.log(`    ${route}/index.html`);
+    }
+}
+console.log();
+success(`${seen.size} route(s) generated`);
+console.log();

package/build/runtime/bin/metaowl-lint.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * metaowl lint — format with Prettier then lint with ESLint.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { globSync } from 'glob';
+import { banner, cwd, failure, resolveBin, step, success } from './utils.js';
+banner('lint');
+let lintTargets = null;
+try {
+    const pkg = JSON.parse(readFileSync(resolve(cwd, 'package.json'), 'utf8'));
+    lintTargets = pkg.metaowl?.lint ?? null;
+}
+catch {
+    // No package.json or no metaowl config.
+}
+const defaults = [
+    'src/metaowl.js',
+    'src/css.js',
+    'src/pages/**',
+    'src/components/**'
+];
+const candidates = lintTargets ?? defaults;
+const existing = candidates.filter((pattern) => {
+    if (existsSync(resolve(cwd, pattern)))
+        return true;
+    return globSync(pattern, { cwd }).length > 0;
+});
+if (existing.length === 0) {
+    success('No lint targets found — skipping');
+    console.log();
+    process.exit(0);
+}
+const targets = existing.map((target) => `"${target}"`).join(' ');
+step('Formatting with Prettier...');
+console.log();
+try {
+    execSync(`"${resolveBin('prettier')}" src --single-quote --no-semi --write`, { stdio: 'inherit', cwd });
+}
+catch {
+    failure('Prettier failed');
+    process.exit(1);
+}
+console.log();
+step('Linting with ESLint...');
+console.log();
+try {
+    execSync(`"${resolveBin('eslint')}" ${targets} --fix`, { stdio: 'inherit', cwd });
+}
+catch {
+    failure('ESLint failed');
+    process.exit(1);
+}
+console.log();
+success('Lint complete');
+console.log();

package/build/runtime/bin/utils.js

@@ -0,0 +1,68 @@
+/**
+ * Shared CLI utilities for metaowl bin scripts.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function resolvePackageRoot() {
+    let currentDir = dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        if (existsSync(resolve(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        const parentDir = resolve(currentDir, '..');
+        if (parentDir === currentDir) {
+            throw new Error('[metaowl] Could not resolve package root for CLI runtime');
+        }
+        currentDir = parentDir;
+    }
+}
+export const metaowlRoot = resolvePackageRoot();
+export const bin = resolve(metaowlRoot, 'node_modules/.bin');
+export const cwd = process.cwd();
+const cwdBin = resolve(cwd, 'node_modules/.bin');
+const packageJson = JSON.parse(readFileSync(resolve(metaowlRoot, 'package.json'), 'utf-8'));
+export const version = packageJson.version;
+export function resolveOwnRuntimeBin(name) {
+    const fileName = name.endsWith('.js') ? name : `${name}.js`;
+    return resolve(metaowlRoot, 'build/runtime/bin', fileName);
+}
+export function resolveBin(name) {
+    const local = resolve(bin, name);
+    if (existsSync(local))
+        return local;
+    const project = resolve(cwdBin, name);
+    if (existsSync(project))
+        return project;
+    return name;
+}
+const tty = Boolean(process.stdout.isTTY);
+const a = (text, code) => tty ? `\x1b[${code}m${text}\x1b[0m` : text;
+export function banner(command) {
+    console.log();
+    console.log(`  ${a('metaowl', '1;36')} ${a(command, '1')}  ${a(`v${version}`, '2')}`);
+    console.log();
+}
+export function step(message) {
+    console.log(`  ${a('›', '36')} ${message}`);
+}
+export function success(message) {
+    console.log(`  ${a('✓', '32')} ${a(message, '2')}`);
+}
+export function failure(message) {
+    console.error(`  ${a('✗', '31')} ${message}`);
+}
+export function run(label, cmd, opts = {}) {
+    step(label);
+    console.log();
+    try {
+        execSync(cmd, { stdio: 'inherit', cwd, ...opts });
+    }
+    catch {
+        console.log();
+        failure(`${label} failed`);
+        process.exit(1);
+    }
+    console.log();
+}

package/build/runtime/index.js

@@ -0,0 +1,141 @@
+import { mountApp, configureOwl } from './modules/app-mounter.js';
+import { buildLayouts, clearLayouts, createLayoutWrapper, defineLayout, discoverLayouts, getCurrentLayout, getDefaultLayout, getLayout, getLayoutNames, getRouteLayout, hasLayout, layout, mountWithLayout, registerLayout, resolveLayout, setDefaultLayout, setRouteLayout, subscribeToLayouts, unregisterLayout } from './modules/layouts.js';
+import { afterEach, _setSpaNavigationCallback, back, beforeEach, cancelNavigation, forward, getCurrentRoute, getPreviousRoute, go, isNavigating, isSpaMode, navigate, navigateTo, processRoutes, push, replace, router, setSpaMode } from './modules/router.js';
+import { Link, registerLinkTemplate } from './modules/link.js';
+import { buildRoutes, createCatchAllRoute, createRedirectRoute, defineRoute, findRoute, generateUrl, isDynamicRoute, matchRoute, route, validateRouteParams } from './modules/file-router.js';
+import { captureError, clearErrorContext, errorBoundary, getErrorContext, initGlobalErrorHandling, onError, setErrorContext } from './modules/error-boundary.js';
+import { configureI18n, createNamespacedT, formatCurrency, formatDate, formatNumber, formatRelativeTime, getLocale, i18n, loadLocaleMessages, setLocale, t } from './modules/i18n.js';
+import { createSchema, fieldProps, useForm, validators } from './modules/forms.js';
+import { authenticate, call, configure, create, getSession, isAuthenticated, listDatabases, logout, OdooService, onAuthChange, read, searchCount, searchRead, unlink, versionInfo, write } from './modules/odoo-rpc.js';
+import { Composables, useAsyncState, useAuth, useCache, useDebounce, useFetch, useLocalStorage, useOnlineStatus, useThrottle, useWindowSize } from './modules/composables.js';
+import { createMockStore, dom, flushPromises, mockRouter, mountComponent, nextTick, TestUtils, userEvent, wait } from './modules/test-utils.js';
+import { createCanonicalUrl, generateOpenGraph, generateRobotsTxt, generateSitemap, generateSitemapIndex, generateTwitterCard, getPriorityByDepth, jsonLd, SEO, validateSitemap } from './modules/seo.js';
+import { cache, checkCapabilities, generateManifest, getStorageInfo, isOnline, isStandalone, PWA, registerServiceWorker, requestPersistentStorage, showNotification, subscribeToConnectivity, subscribeToPush, sync, unregisterServiceWorker, unsubscribeFromPush } from './modules/pwa.js';
+import Cache from './modules/cache.js';
+import Fetch from './modules/fetch.js';
+import * as Meta from './modules/meta.js';
+import { Store, createPersistencePlugin, createStore } from './modules/store.js';
+let appRoutes = null;
+let navSeq = 0;
+let mountingPromise = null;
+function handle404() {
+    const el = document.getElementById('metaowl');
+    if (el) {
+        el.innerHTML = [
+            '<div style="font-family:sans-serif;padding:3rem;text-align:center">',
+            '<h1 style="font-size:4rem;font-weight:700;margin:0;color:#6b7280">404</h1>',
+            '<p style="font-size:1.25rem;color:#9ca3af;margin-top:0.5rem">Page not found</p>',
+            '<p style="margin-top:2rem"><a href="/" style="color:#3b82f6;text-decoration:none">← Go home</a></p>',
+            '</div>'
+        ].join('');
+    }
+}
+function isNoRouteFoundError(error) {
+    return error instanceof Error && error.message.startsWith('No route found');
+}
+function isBootOptions(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && 'spa' in value;
+}
+async function spaNavigate(path) {
+    if (!appRoutes) {
+        console.error('[metaowl] Routes not available for SPA navigation');
+        return;
+    }
+    const seq = ++navSeq;
+    let resolvedRoute;
+    try {
+        resolvedRoute = await processRoutes(appRoutes, path);
+    }
+    catch (error) {
+        if (seq !== navSeq)
+            return;
+        if (isNoRouteFoundError(error)) {
+            console.warn('[metaowl]', error.message);
+            handle404();
+        }
+        else {
+            throw error;
+        }
+        return;
+    }
+    if (seq !== navSeq || !resolvedRoute)
+        return;
+    if (mountingPromise) {
+        await mountingPromise.catch(() => { });
+        if (seq !== navSeq)
+            return;
+    }
+    mountingPromise = mountApp(resolvedRoute);
+    try {
+        await mountingPromise;
+    }
+    finally {
+        mountingPromise = null;
+    }
+}
+export async function boot(routesOrModules = {}, layoutsOrModules = null, options = {}) {
+    const effectiveOptions = { ...options };
+    let layoutModules = null;
+    if (isBootOptions(layoutsOrModules)) {
+        Object.assign(effectiveOptions, layoutsOrModules);
+    }
+    else {
+        layoutModules = layoutsOrModules;
+    }
+    const { spa = true } = effectiveOptions;
+    try {
+        if (layoutModules && typeof layoutModules === 'object' && !Array.isArray(layoutModules)) {
+            buildLayouts(layoutModules);
+            setDefaultLayout('default');
+        }
+        else {
+            await discoverLayouts();
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.warn('[metaowl] Could not auto-discover layouts:', error.message);
+        }
+    }
+    const routes = Array.isArray(routesOrModules)
+        ? routesOrModules
+        : buildRoutes(routesOrModules);
+    appRoutes = routes;
+    if (spa) {
+        setSpaMode(true);
+        _setSpaNavigationCallback(spaNavigate);
+        window.__metaowlNavigate = spaNavigate;
+        window.addEventListener('popstate', () => {
+            const path = document.location.pathname;
+            void spaNavigate(path);
+        });
+    }
+    let resolvedRoute;
+    try {
+        resolvedRoute = await processRoutes(routes);
+    }
+    catch (error) {
+        if (isNoRouteFoundError(error)) {
+            console.warn('[metaowl]', error.message);
+            handle404();
+            return;
+        }
+        throw error;
+    }
+    if (!resolvedRoute)
+        return;
+    await mountApp(resolvedRoute);
+}
+export { Fetch, Cache, configureOwl, Meta, buildRoutes, Store, createPersistencePlugin, createStore };
+export { registerLayout, unregisterLayout, getLayout, hasLayout, getLayoutNames, setDefaultLayout, getDefaultLayout, resolveLayout, setRouteLayout, getRouteLayout, createLayoutWrapper, mountWithLayout, getCurrentLayout, subscribeToLayouts, clearLayouts, layout, defineLayout, buildLayouts, discoverLayouts };
+export { processRoutes, beforeEach, afterEach, getCurrentRoute, getPreviousRoute, isNavigating, cancelNavigation, navigate, navigateTo, push, replace, back, forward, go, router, setSpaMode, isSpaMode };
+export { Link, registerLinkTemplate };
+export { matchRoute, isDynamicRoute, findRoute, generateUrl, validateRouteParams, createCatchAllRoute, createRedirectRoute, defineRoute, route };
+export { onError, setErrorContext, getErrorContext, clearErrorContext, captureError, initGlobalErrorHandling, errorBoundary };
+export { configureI18n, t, getLocale, setLocale, i18n, loadLocaleMessages, formatDate, formatNumber, formatCurrency, formatRelativeTime, createNamespacedT };
+export { useForm, validators, createSchema, fieldProps };
+export { OdooService, configure, authenticate, logout, searchRead, call, read, create, write, unlink, searchCount, listDatabases, versionInfo, isAuthenticated, getSession, onAuthChange };
+export { useAuth, useLocalStorage, useFetch, useDebounce, useThrottle, useWindowSize, useOnlineStatus, useAsyncState, useCache, Composables };
+export { createMockStore, mockRouter, mountComponent, wait, nextTick, flushPromises, userEvent, dom, TestUtils };
+export { generateSitemap, generateRobotsTxt, jsonLd, createCanonicalUrl, generateOpenGraph, generateTwitterCard, validateSitemap, getPriorityByDepth, generateSitemapIndex, SEO };
+export { generateManifest, registerServiceWorker, unregisterServiceWorker, isStandalone, isOnline, subscribeToConnectivity, requestPersistentStorage, getStorageInfo, sync, subscribeToPush, unsubscribeFromPush, showNotification, cache, checkCapabilities, PWA };

package/build/runtime/modules/app-mounter.js

@@ -0,0 +1,65 @@
+/**
+ * @module AppMounter
+ *
+ * OWL application mounting with template merging.
+ */
+import { mount } from '@odoo/owl';
+import { Link } from './link.js';
+import { getLayout, mountWithLayout, resolveLayout } from './layouts.js';
+import { mergeTemplates } from './templates-manager.js';
+const defaults = {
+    warnIfNoStaticProps: true,
+    willStartTimeout: 10000,
+    translatableAttributes: ['title', 'placeholder', 'label', 'alt']
+};
+let config = { ...defaults };
+let currentApp = null;
+let cachedTemplates = null;
+export function configureOwl(nextConfig) {
+    config = { ...defaults, ...nextConfig };
+}
+export async function mountApp(route) {
+    const components = typeof COMPONENTS !== 'undefined' ? COMPONENTS : [];
+    if (!cachedTemplates) {
+        cachedTemplates = await mergeTemplates(components);
+    }
+    const templates = cachedTemplates;
+    const mountElement = document.getElementById('metaowl');
+    if (currentApp) {
+        try {
+            currentApp.destroy();
+        }
+        catch {
+            // Ignore destroy errors from stale app instances.
+        }
+        currentApp = null;
+    }
+    if (!mountElement) {
+        throw new Error('[metaowl] Mount element "#metaowl" not found');
+    }
+    mountElement.innerHTML = '';
+    const pageComponent = route[0]?.component;
+    const pagePath = document.location.pathname;
+    if (!pageComponent) {
+        throw new Error('[metaowl] Invalid route passed to mountApp()');
+    }
+    const pageComponentClass = pageComponent;
+    const layoutName = resolveLayout(pageComponentClass, pagePath);
+    const layoutClass = getLayout(layoutName);
+    const baseConfig = {
+        ...config,
+        templates,
+        components: {
+            Link,
+            't-link': Link
+        }
+    };
+    let instance;
+    if (layoutClass) {
+        instance = await mountWithLayout(pageComponentClass, mountElement, { routePath: pagePath, templates }, baseConfig);
+    }
+    else {
+        instance = await mount(pageComponentClass, mountElement, baseConfig);
+    }
+    currentApp = instance?.__owl__?.app ?? null;
+}