metaowl 0.4.1 → 0.6.0

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,144 @@
+import { mountApp, configureOwl } from './modules/app-mounter.js';
+import { buildLayouts, clearLayouts, createLayoutWrapper, createNestedLayoutWrapper, defineLayout, defineNestedLayout, discoverLayouts, getCurrentLayout, getDefaultLayout, getLayout, getLayoutChain, getLayoutNames, getParentLayout, getRouteLayout, hasLayout, layout, mountWithLayout, registerLayout, resolveLayout, setDefaultLayout, setParentLayout, 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 Fonts from './modules/fonts.js';
+import { ImageOptimizer } from './modules/image.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, createNestedLayoutWrapper, mountWithLayout, getCurrentLayout, subscribeToLayouts, clearLayouts, layout, defineLayout, defineNestedLayout, buildLayouts, discoverLayouts, setParentLayout, getParentLayout, getLayoutChain };
+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 };
+export { ImageOptimizer as Image, Fonts };

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

@@ -0,0 +1,73 @@
+/**
+ * @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,
+        translatableAttributes: nextConfig.translatableAttributes
+            ? Array.isArray(nextConfig.translatableAttributes)
+                ? nextConfig.translatableAttributes
+                : [nextConfig.translatableAttributes]
+            : defaults.translatableAttributes
+    };
+}
+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;
+}

package/build/runtime/modules/auto-import.js

@@ -0,0 +1,140 @@
+/**
+ * @module AutoImport
+ *
+ * Automatic component importing for MetaOwl applications.
+ */
+import { globSync } from 'glob';
+import { basename, dirname, extname, relative, resolve } from 'node:path';
+let importMap = null;
+export function generateComponentMap(componentsDir, pattern = '*.js') {
+    const map = new Map();
+    const globPattern = pattern.includes('/') ? pattern : `${componentsDir}/${pattern}`;
+    const files = globSync(globPattern);
+    for (const file of files) {
+        if (file.includes('.test.') || file.includes('.spec.'))
+            continue;
+        const name = getComponentName(file);
+        if (!name)
+            continue;
+        const importPath = `/@components/${relative(componentsDir, file).replace(/\\/g, '/')}`;
+        map.set(name, importPath);
+    }
+    return map;
+}
+function getComponentName(filePath) {
+    const ext = extname(filePath);
+    const base = basename(filePath, ext);
+    if (basename(filePath) === base + ext) {
+        return base;
+    }
+    const dir = relative(process.cwd(), filePath).split('/');
+    if (base === 'index' && dir.length > 1) {
+        return toPascalCase(dir[dir.length - 2] ?? '');
+    }
+    return toPascalCase(base);
+}
+function toPascalCase(str) {
+    return str
+        .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+        .replace(/^[a-z]/, (char) => char.toUpperCase());
+}
+export async function scanComponents(componentsDir, options = {}) {
+    const { pattern: _pattern = '*.js' } = options;
+    const absoluteDir = resolve(componentsDir);
+    const fs = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const components = [];
+    async function scanDir(dir) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await scanDir(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.js')) {
+                    if (entry.name.includes('.test.') || entry.name.includes('.spec.'))
+                        continue;
+                    const name = getComponentName(fullPath);
+                    if (name && !components.includes(name)) {
+                        components.push(name);
+                    }
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+    }
+    await scanDir(absoluteDir);
+    return components;
+}
+export async function generateComponentDts(components, outputPath) {
+    const { mkdirSync, writeFileSync } = await import('node:fs');
+    const dir = dirname(outputPath);
+    mkdirSync(dir, { recursive: true });
+    const declarations = components
+        .map((name) => `  ${name}: typeof import('./components/${name}/${name}.js').default`)
+        .join('\n');
+    const content = `// Auto-generated by metaowl - do not edit\ndeclare module '@metaowl/components' {\n${declarations}\n}\n`;
+    writeFileSync(outputPath, content, 'utf-8');
+}
+export function generateImports(componentMap) {
+    const lines = [];
+    for (const [name, path] of componentMap) {
+        lines.push(`import ${name} from '${path}'`);
+    }
+    return lines.join('\n');
+}
+export function generateComponentsObject(componentMap) {
+    const entries = Array.from(componentMap.keys())
+        .map((name) => `  ${name}`)
+        .join(',\n');
+    return `{\n${entries}\n}`;
+}
+export function createAutoImportPlugin(options = {}) {
+    const { enabled = false, componentsDir = 'src/components', pattern = '**/*.js' } = options;
+    if (!enabled) {
+        return null;
+    }
+    importMap = generateComponentMap(componentsDir, `${componentsDir}/${pattern}`);
+    return {
+        name: 'metaowl:auto-import',
+        enforce: 'pre',
+        config(config) {
+            config.resolve ||= {};
+            config.resolve.alias ||= {};
+            config.resolve.alias['/@components'] = resolve(process.cwd(), componentsDir);
+        },
+        transform(code, id) {
+            if (!id.includes('/pages/') || !/\.[jt]s$/.test(id)) {
+                return null;
+            }
+            if (!code.includes('/* auto-import */') && !code.includes('// auto-import')) {
+                return null;
+            }
+            if (!importMap) {
+                return null;
+            }
+            const imports = generateImports(importMap);
+            const componentsObj = generateComponentsObject(importMap);
+            let transformed = imports + '\n\n' + code;
+            if (transformed.includes('extends Component')) {
+                transformed = transformed.replace(/(class\s+\w+\s+extends\s+Component\s*\{)/, `$1\n  static components = ${componentsObj}\n`);
+            }
+            return { code: transformed, map: null };
+        }
+    };
+}
+export function registerAutoImport(name, path) {
+    if (!importMap) {
+        importMap = new Map();
+    }
+    importMap.set(name, path);
+}
+export function getAutoImportMap() {
+    return importMap ? new Map(importMap) : null;
+}
+export function clearAutoImports() {
+    importMap = null;
+}

package/build/runtime/modules/cache.js

@@ -0,0 +1,49 @@
+/**
+ * @module Cache
+ *
+ * Async-style localStorage wrapper.
+ *
+ * Values are automatically JSON-serialised on write and deserialised on read.
+ * All methods return Promises so they are interchangeable with IndexedDB-based
+ * alternatives without changing call-sites.
+ */
+export default class Cache {
+    /**
+     * Retrieve a value by key.
+     */
+    static async get(key) {
+        const rawValue = localStorage.getItem(key);
+        return rawValue === null ? null : JSON.parse(rawValue);
+    }
+    /**
+     * Store a value under the given key.
+     */
+    static async set(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    /**
+     * Remove a single entry.
+     */
+    static async remove(key) {
+        localStorage.removeItem(key);
+    }
+    /**
+     * Remove all entries from localStorage.
+     */
+    static async clear() {
+        localStorage.clear();
+    }
+    /**
+     * Return all keys currently stored in localStorage.
+     */
+    static async keys() {
+        const keys = [];
+        for (let index = 0; index < localStorage.length; index++) {
+            const key = localStorage.key(index);
+            if (key !== null) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
+}