metaowl 0.4.1 → 0.5.0

package/build/runtime/modules/layouts.js

@@ -0,0 +1,163 @@
+/**
+ * @module Layouts
+ *
+ * Layout system for OWL applications, enabling shared page structures.
+ */
+import { Component, mount, xml } from '@odoo/owl';
+const layouts = new Map();
+let defaultLayout = 'default';
+let currentLayout = null;
+const listeners = [];
+const routeLayouts = new Map();
+export function registerLayout(name, layoutComponent, options = {}) {
+    layouts.set(name, layoutComponent);
+    if (options.default) {
+        defaultLayout = name;
+    }
+    for (const listener of listeners) {
+        listener({ type: 'register', name, layout: layoutComponent });
+    }
+}
+export function unregisterLayout(name) {
+    const removed = layouts.delete(name);
+    if (removed) {
+        for (const listener of listeners) {
+            listener({ type: 'unregister', name });
+        }
+    }
+    return removed;
+}
+export function getLayout(name) {
+    return layouts.get(name);
+}
+export function hasLayout(name) {
+    return layouts.has(name);
+}
+export function getLayoutNames() {
+    return Array.from(layouts.keys());
+}
+export function setDefaultLayout(name) {
+    if (!layouts.has(name)) {
+        console.warn(`[metaowl] Layout "${name}" is not registered yet`);
+    }
+    defaultLayout = name;
+}
+export function getDefaultLayout() {
+    return defaultLayout;
+}
+export function resolveLayout(component, routePath) {
+    if (routePath && routeLayouts.has(routePath)) {
+        return routeLayouts.get(routePath);
+    }
+    if (component.layout) {
+        return component.layout;
+    }
+    if (component._layout) {
+        return component._layout;
+    }
+    return defaultLayout;
+}
+export function setRouteLayout(routePath, layoutName) {
+    routeLayouts.set(routePath, layoutName);
+}
+export function getRouteLayout(routePath) {
+    return routeLayouts.get(routePath);
+}
+export function createLayoutWrapper(layoutComponent, pageComponent, props = {}) {
+    const LayoutClass = layoutComponent;
+    const PageClass = pageComponent;
+    return class LayoutWrapper extends Component {
+        static template = xml `
+      <t t-component="layout" t-props="layoutProps">
+        <t t-component="page" t-props="pageProps"/>
+      </t>
+    `;
+        layout;
+        page;
+        layoutProps;
+        pageProps;
+        setup() {
+            this.layout = LayoutClass;
+            this.page = PageClass;
+            this.layoutProps = {};
+            this.pageProps = props;
+        }
+    };
+}
+export async function mountWithLayout(pageComponent, target, options = {}, config = {}) {
+    const { routePath, props = {}, templates } = options;
+    const layoutName = resolveLayout(pageComponent, routePath);
+    const LayoutClass = getLayout(layoutName);
+    if (!LayoutClass) {
+        console.warn(`[metaowl] Layout "${layoutName}" not found, mounting page without layout`);
+        return await mount(pageComponent, target, { ...config, props, templates });
+    }
+    const WrapperClass = createLayoutWrapper(LayoutClass, pageComponent, props);
+    const instance = await mount(WrapperClass, target, { ...config, templates });
+    currentLayout = instance;
+    for (const listener of listeners) {
+        listener({ type: 'mount', layout: layoutName, page: pageComponent.name });
+    }
+    return instance;
+}
+export function getCurrentLayout() {
+    return currentLayout;
+}
+export function subscribeToLayouts(callback) {
+    listeners.push(callback);
+    return () => {
+        const index = listeners.indexOf(callback);
+        if (index > -1)
+            listeners.splice(index, 1);
+    };
+}
+export function clearLayouts() {
+    layouts.clear();
+    routeLayouts.clear();
+    listeners.length = 0;
+    defaultLayout = 'default';
+    currentLayout = null;
+}
+export function layout(name) {
+    return function decorator(componentClass) {
+        componentClass.layout = name;
+        return componentClass;
+    };
+}
+export function defineLayout(name, options = {}) {
+    return function decorator(componentClass) {
+        componentClass.layout = name;
+        componentClass.layoutOptions = options;
+        return componentClass;
+    };
+}
+export function buildLayouts(modules) {
+    const discoveredLayouts = {};
+    for (const [key, mod] of Object.entries(modules)) {
+        const match = key.match(/\.\/layouts\/([^/]+)/);
+        if (!match)
+            continue;
+        const layoutName = match[1];
+        const componentClass = resolveLayoutComponent(mod);
+        if (componentClass) {
+            discoveredLayouts[layoutName] = componentClass;
+            registerLayout(layoutName, componentClass);
+        }
+    }
+    return discoveredLayouts;
+}
+export async function discoverLayouts(options = {}) {
+    const { defaultLayout: nextDefaultLayout = 'default' } = options;
+    const modules = import.meta.glob('./layouts/**/*.js', { eager: true });
+    const discoveredLayouts = buildLayouts(modules);
+    if (discoveredLayouts[nextDefaultLayout]) {
+        setDefaultLayout(nextDefaultLayout);
+    }
+    return discoveredLayouts;
+}
+function resolveLayoutComponent(mod) {
+    if (typeof mod.default === 'function') {
+        return mod.default;
+    }
+    return Object.values(mod).find((value) => typeof value === 'function');
+}

package/build/runtime/modules/link.js

@@ -0,0 +1,141 @@
+/**
+ * @module Link
+ *
+ * SPA Link component for metaowl with automatic external link detection.
+ */
+import { Component, onMounted, onWillUnmount, useState } from '@odoo/owl';
+const EXTERNAL_URL_REGEX = /^(https?:|\/\/|mailto:|tel:|ftp:|file:|javascript:)/i;
+function isExternalUrl(url) {
+    if (!url || typeof url !== 'string')
+        return false;
+    return EXTERNAL_URL_REGEX.test(url);
+}
+function isActiveLink(linkPath, currentPath) {
+    if (!linkPath || !currentPath)
+        return false;
+    const normalizedLink = linkPath.replace(/\/$/, '') || '/';
+    const normalizedCurrent = currentPath.replace(/\/$/, '') || '/';
+    return normalizedCurrent === normalizedLink ||
+        (normalizedLink !== '/' && normalizedCurrent.startsWith(normalizedLink + '/'));
+}
+export class Link extends Component {
+    static template = 'Link';
+    static props = {
+        to: { type: String, optional: false },
+        class: { type: String, optional: true },
+        activeClass: { type: String, optional: true },
+        target: { type: String, optional: true },
+        rel: { type: String, optional: true },
+        title: { type: String, optional: true },
+        download: { type: [String, Boolean], optional: true },
+        hreflang: { type: String, optional: true },
+        type: { type: String, optional: true },
+        ping: { type: String, optional: true },
+        referrerpolicy: { type: String, optional: true },
+        media: { type: String, optional: true },
+        '*': true
+    };
+    state;
+    _navigate = null;
+    _updateActiveState = () => { };
+    setup() {
+        this.state = useState({
+            isActive: false
+        });
+        onMounted(() => {
+            this._updateActiveState();
+            window.addEventListener('popstate', this._updateActiveState);
+        });
+        onWillUnmount(() => {
+            window.removeEventListener('popstate', this._updateActiveState);
+        });
+        this._updateActiveState = () => {
+            if (this.props.activeClass) {
+                this.state.isActive = isActiveLink(this.props.to, document.location.pathname);
+            }
+        };
+    }
+    get linkClasses() {
+        const classes = [];
+        if (this.props.class) {
+            classes.push(this.props.class);
+        }
+        if (this.state.isActive && this.props.activeClass) {
+            classes.push(this.props.activeClass);
+        }
+        return classes.join(' ');
+    }
+    get linkRel() {
+        if (this.props.rel)
+            return this.props.rel;
+        if (isExternalUrl(this.props.to) && this.props.target === '_blank') {
+            return 'noopener noreferrer';
+        }
+        return undefined;
+    }
+    get forwardedAttrs() {
+        const attrs = { ...this.props };
+        delete attrs.to;
+        delete attrs.class;
+        delete attrs.activeClass;
+        delete attrs.target;
+        delete attrs.rel;
+        delete attrs.title;
+        delete attrs.download;
+        return attrs;
+    }
+    onClick(ev) {
+        const url = this.props.to;
+        if (isExternalUrl(url)) {
+            return;
+        }
+        if (ev.ctrlKey || ev.metaKey || ev.altKey || ev.shiftKey) {
+            return;
+        }
+        if (ev.button !== 0) {
+            return;
+        }
+        if (this.props.download) {
+            return;
+        }
+        ev.preventDefault();
+        window.history.pushState({ path: url }, '', url);
+        if (typeof window.__metaowlNavigate === 'function') {
+            window.__metaowlNavigate(url);
+        }
+        else {
+            window.location.href = url;
+        }
+    }
+}
+export const LinkTemplate = /* xml */ `
+<templates>
+  <t t-name="Link">
+    <a
+      t-att="forwardedAttrs"
+      t-att-href="props.to"
+      t-att-class="linkClasses"
+      t-att-target="props.target"
+      t-att-rel="linkRel"
+      t-att-title="props.title"
+      t-att-download="props.download"
+      t-on-click="onClick"
+    >
+      <t t-slot="default"/>
+    </a>
+  </t>
+</templates>
+`;
+export function registerLinkTemplate(templates) {
+    if (typeof templates === 'string') {
+        const linkContent = LinkTemplate
+            .replace('<templates>', '')
+            .replace('</templates>', '')
+            .trim();
+        return templates.replace('</templates>', linkContent + '\n</templates>');
+    }
+    if (templates && typeof templates === 'object') {
+        templates.Link = LinkTemplate;
+    }
+}
+export default Link;

package/build/runtime/modules/meta.js

@@ -0,0 +1,117 @@
+/**
+ * @module Meta
+ *
+ * Programmatic helpers for managing document meta tags at runtime.
+ *
+ * Each function is idempotent: the relevant <meta> or <link> element is
+ * created on first call if it does not already exist, then its content is
+ * updated on every subsequent call as well.
+ *
+ * Import the entire namespace via:
+ *   import { Meta } from 'metaowl'
+ *   Meta.title('My Page')
+ */
+function nameMeta(name, value) {
+    if (!value)
+        return;
+    let element = document.querySelector(`meta[name="${name}"]`);
+    if (!element) {
+        element = document.createElement('meta');
+        element.name = name;
+        document.head.appendChild(element);
+    }
+    element.content = String(value);
+}
+function propertyMeta(property, value) {
+    if (!value)
+        return;
+    let element = document.querySelector(`meta[property="${property}"]`);
+    if (!element) {
+        element = document.createElement('meta');
+        element.setAttribute('property', property);
+        document.head.appendChild(element);
+    }
+    element.content = String(value);
+}
+export function title(value) {
+    if (!value)
+        return;
+    document.title = value;
+}
+export function description(value) {
+    nameMeta('description', value);
+}
+export function keywords(value) {
+    nameMeta('keywords', value);
+}
+export function author(value) {
+    nameMeta('author', value);
+}
+export function canonical(value) {
+    if (!value)
+        return;
+    let element = document.querySelector('link[rel="canonical"]');
+    if (!element) {
+        element = document.createElement('link');
+        element.rel = 'canonical';
+        document.head.appendChild(element);
+    }
+    element.href = value;
+}
+export function ogTitle(value) {
+    propertyMeta('og:title', value);
+}
+export function ogDescription(value) {
+    propertyMeta('og:description', value);
+}
+export function ogImage(value) {
+    propertyMeta('og:image', value);
+}
+export function ogUrl(value) {
+    propertyMeta('og:url', value);
+}
+export function ogType(value) {
+    propertyMeta('og:type', value);
+}
+export function ogSiteName(value) {
+    propertyMeta('og:site_name', value);
+}
+export function ogLocale(value) {
+    propertyMeta('og:locale', value);
+}
+export function ogImageWidth(value) {
+    propertyMeta('og:image:width', value);
+}
+export function ogImageHeight(value) {
+    propertyMeta('og:image:height', value);
+}
+export function twitterCard(value) {
+    nameMeta('twitter:card', value);
+}
+export function twitterSite(value) {
+    nameMeta('twitter:site', value);
+}
+export function twitterCreator(value) {
+    nameMeta('twitter:creator', value);
+}
+export function twitterTitle(value) {
+    nameMeta('twitter:title', value);
+}
+export function twitterDescription(value) {
+    nameMeta('twitter:description', value);
+}
+export function twitterImage(value) {
+    nameMeta('twitter:image', value);
+}
+export function twitterImageAlt(value) {
+    nameMeta('twitter:image:alt', value);
+}
+export function twitterUrl(value) {
+    nameMeta('twitter:url', value);
+}
+export function twitterSiteId(value) {
+    nameMeta('twitter:site:id', value);
+}
+export function twitterCreatorId(value) {
+    nameMeta('twitter:creator:id', value);
+}

package/build/runtime/modules/odoo-rpc.js

@@ -0,0 +1,264 @@
+/**
+ * @module OdooRPC
+ *
+ * Odoo JSON-RPC Service for MetaOwl applications.
+ */
+let config = null;
+let session = null;
+let csrfToken = null;
+const authListeners = [];
+const SESSION_KEY = 'metaowl:odoo:session';
+const CSRF_KEY = 'metaowl:odoo:csrf';
+export function configure(nextConfig) {
+    config = {
+        persistSession: true,
+        baseUrl: '',
+        database: '',
+        ...nextConfig
+    };
+    if (config.persistSession) {
+        restoreSession();
+    }
+}
+export function getConfig() {
+    return config;
+}
+export function isConfigured() {
+    return config !== null && Boolean(config.baseUrl) && Boolean(config.database);
+}
+function restoreSession() {
+    try {
+        const sessionData = localStorage.getItem(SESSION_KEY);
+        const csrfData = localStorage.getItem(CSRF_KEY);
+        if (sessionData) {
+            session = JSON.parse(sessionData);
+        }
+        if (csrfData) {
+            csrfToken = csrfData;
+        }
+    }
+    catch {
+        // Ignore storage errors
+    }
+}
+function saveSession() {
+    if (!config?.persistSession)
+        return;
+    try {
+        if (session) {
+            localStorage.setItem(SESSION_KEY, JSON.stringify(session));
+        }
+        else {
+            localStorage.removeItem(SESSION_KEY);
+        }
+        if (csrfToken) {
+            localStorage.setItem(CSRF_KEY, csrfToken);
+        }
+        else {
+            localStorage.removeItem(CSRF_KEY);
+        }
+    }
+    catch {
+        // Ignore storage errors
+    }
+}
+async function jsonRpc(service, method, args = []) {
+    if (!isConfigured() || !config) {
+        throw new Error('[metaowl] OdooService not configured. Call configure() first.');
+    }
+    const url = `${config.baseUrl}/jsonrpc`;
+    const payload = {
+        jsonrpc: '2.0',
+        method: 'call',
+        params: {
+            service,
+            method,
+            args
+        },
+        id: Math.floor(Math.random() * 1000000000)
+    };
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    if (csrfToken) {
+        headers['X-CSRF-Token'] = csrfToken;
+    }
+    const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(payload),
+        credentials: 'include'
+    });
+    if (!response.ok) {
+        throw new Error(`[metaowl] HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        const error = data.error;
+        throw new Error(`[metaowl] Odoo Error: ${error.message || error.data?.message || JSON.stringify(error)}`);
+    }
+    const setCookie = response.headers.get('set-cookie');
+    if (setCookie?.includes('csrf_token')) {
+        const match = setCookie.match(/csrf_token=([^;]+)/);
+        if (match) {
+            csrfToken = match[1] ?? null;
+            saveSession();
+        }
+    }
+    return data.result;
+}
+export async function authenticate(username, password) {
+    const user = username || config?.username;
+    const pass = password || config?.password || config?.apiKey;
+    if (!user || !pass || !config) {
+        throw new Error('[metaowl] Authentication requires username and password/apiKey');
+    }
+    const uid = await jsonRpc('common', 'authenticate', [
+        config.database,
+        user,
+        pass,
+        {}
+    ]);
+    if (!uid) {
+        throw new Error('[metaowl] Authentication failed: invalid credentials');
+    }
+    session = {
+        uid,
+        username: user
+    };
+    try {
+        const userInfo = await searchRead('res.users', {
+            domain: [['id', '=', uid]],
+            fields: ['name', 'partner_id', 'lang', 'tz'],
+            limit: 1
+        });
+        if (userInfo.length > 0) {
+            const firstUser = userInfo[0];
+            session.name = typeof firstUser.name === 'string' ? firstUser.name : undefined;
+            session.partner_id = Array.isArray(firstUser.partner_id) ? Number(firstUser.partner_id[0]) : undefined;
+            session.lang = typeof firstUser.lang === 'string' ? firstUser.lang : undefined;
+            session.tz = typeof firstUser.tz === 'string' ? firstUser.tz : undefined;
+        }
+    }
+    catch {
+        // Ignore user info fetch errors
+    }
+    saveSession();
+    notifyAuthListeners();
+    return session;
+}
+export function isAuthenticated() {
+    return session !== null && session.uid !== null;
+}
+export function getSession() {
+    return session;
+}
+export function logout() {
+    session = null;
+    csrfToken = null;
+    saveSession();
+    notifyAuthListeners();
+}
+export async function searchRead(model, options = {}) {
+    const { domain = [], fields = [], limit = 80, offset = 0, order = '', context = {} } = options;
+    if (!isAuthenticated() || !config || !session) {
+        throw new Error('[metaowl] Not authenticated. Call authenticate() first.');
+    }
+    const args = [
+        config.database,
+        session.uid,
+        config.password || config.apiKey,
+        model,
+        'search_read',
+        [domain],
+        { fields, limit, offset, order, context }
+    ];
+    return await jsonRpc('object', 'execute_kw', args);
+}
+export async function call(model, method, args = [], kwargs = {}) {
+    if (!isAuthenticated() || !config || !session) {
+        throw new Error('[metaowl] Not authenticated. Call authenticate() first.');
+    }
+    const rpcArgs = [
+        config.database,
+        session.uid,
+        config.password || config.apiKey,
+        model,
+        method,
+        args,
+        kwargs
+    ];
+    return await jsonRpc('object', 'execute_kw', rpcArgs);
+}
+export async function read(model, ids, fields = []) {
+    return await call(model, 'read', [ids], { fields });
+}
+export async function create(model, values) {
+    return await call(model, 'create', [[values]]);
+}
+export async function write(model, ids, values) {
+    return await call(model, 'write', [ids, values]);
+}
+export async function unlink(model, ids) {
+    return await call(model, 'unlink', [ids]);
+}
+export async function searchCount(model, domain = []) {
+    return await call(model, 'search_count', [domain]);
+}
+export async function listDatabases() {
+    return await jsonRpc('db', 'list', []);
+}
+export async function versionInfo() {
+    if (!config) {
+        throw new Error('[metaowl] OdooService not configured. Call configure() first.');
+    }
+    const response = await fetch(`${config.baseUrl}/web/webclient/version_info`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: '{}'
+    });
+    if (!response.ok) {
+        throw new Error(`[metaowl] Failed to get version info: ${response.status}`);
+    }
+    const data = await response.json();
+    return data.result;
+}
+export function onAuthChange(callback) {
+    authListeners.push(callback);
+    return () => {
+        const index = authListeners.indexOf(callback);
+        if (index > -1) {
+            authListeners.splice(index, 1);
+        }
+    };
+}
+function notifyAuthListeners() {
+    for (const listener of authListeners) {
+        try {
+            listener(session);
+        }
+        catch {
+            // Ignore listener errors
+        }
+    }
+}
+export const OdooService = {
+    configure,
+    getConfig,
+    isConfigured,
+    authenticate,
+    isAuthenticated,
+    getSession,
+    logout,
+    searchRead,
+    call,
+    read,
+    create,
+    write,
+    unlink,
+    searchCount,
+    listDatabases,
+    versionInfo,
+    onAuthChange
+};
+export default OdooService;