metaowl 0.4.1 → 0.6.0

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,265 @@
+/**
+ * @module OdooRPC
+ *
+ * Odoo JSON-RPC Service for MetaOwl applications.
+ */
+import { MAGIC_STRINGS } from './constants.js';
+let config = null;
+let session = null;
+let csrfToken = null;
+const authListeners = [];
+const SESSION_KEY = MAGIC_STRINGS.STORE_SESSION_KEY;
+const CSRF_KEY = MAGIC_STRINGS.STORE_CSRF_KEY;
+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=([a-zA-Z0-9_-]+)/);
+        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;

package/build/runtime/modules/pwa.js

@@ -0,0 +1,272 @@
+/**
+ * @module PWA
+ *
+ * Progressive Web App utilities for MetaOwl applications.
+ */
+export function generateManifest(options) {
+    const { name, shortName, description, startUrl = './', display = 'standalone', themeColor = '#000000', backgroundColor = '#ffffff', scope = './', icons = [] } = options;
+    const manifest = {
+        name,
+        short_name: shortName,
+        start_url: startUrl,
+        display,
+        theme_color: themeColor,
+        background_color: backgroundColor,
+        scope,
+        orientation: 'any'
+    };
+    if (description) {
+        manifest.description = description;
+    }
+    if (icons.length > 0) {
+        manifest.icons = icons;
+    }
+    return manifest;
+}
+export async function registerServiceWorker(path, options = {}) {
+    const { onUpdate, onReady } = options;
+    if (!('serviceWorker' in navigator)) {
+        console.warn('[PWA] Service workers not supported');
+        return null;
+    }
+    try {
+        const registration = await navigator.serviceWorker.register(path);
+        registration.addEventListener('updatefound', () => {
+            const newWorker = registration.installing;
+            if (!newWorker)
+                return;
+            newWorker.addEventListener('statechange', () => {
+                if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
+                    if (onUpdate) {
+                        onUpdate(registration);
+                    }
+                }
+                else if (newWorker.state === 'activated') {
+                    if (onReady) {
+                        onReady(registration);
+                    }
+                }
+            });
+        });
+        if (registration.active && onReady) {
+            onReady(registration);
+        }
+        return registration;
+    }
+    catch (error) {
+        console.error('[PWA] Service worker registration failed:', error);
+        return null;
+    }
+}
+export async function unregisterServiceWorker() {
+    if (!('serviceWorker' in navigator)) {
+        return false;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        await registration.unregister();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isStandalone() {
+    if (window.matchMedia) {
+        const standaloneNavigator = window.navigator;
+        return window.matchMedia('(display-mode: standalone)').matches || standaloneNavigator.standalone === true;
+    }
+    return false;
+}
+export function isOnline() {
+    return navigator.onLine;
+}
+export function subscribeToConnectivity(callbacks) {
+    const { onOnline, onOffline } = callbacks;
+    const handleOnline = () => {
+        if (onOnline)
+            onOnline();
+    };
+    const handleOffline = () => {
+        if (onOffline)
+            onOffline();
+    };
+    window.addEventListener('online', handleOnline);
+    window.addEventListener('offline', handleOffline);
+    return () => {
+        window.removeEventListener('online', handleOnline);
+        window.removeEventListener('offline', handleOffline);
+    };
+}
+export async function requestPersistentStorage() {
+    if (navigator.storage?.persist) {
+        return await navigator.storage.persist();
+    }
+    return false;
+}
+export async function getStorageInfo() {
+    if (navigator.storage?.estimate) {
+        return await navigator.storage.estimate();
+    }
+    return null;
+}
+export async function sync(tag) {
+    if (!('serviceWorker' in navigator)) {
+        return false;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        const syncRegistration = registration;
+        if (syncRegistration.sync) {
+            await syncRegistration.sync.register(tag);
+            return true;
+        }
+    }
+    catch {
+        // Background sync not supported or failed
+    }
+    return false;
+}
+export async function subscribeToPush(options) {
+    const { serverUrl, publicKey } = options;
+    if (!('serviceWorker' in navigator) || !('PushManager' in window)) {
+        console.warn('[PWA] Push notifications not supported');
+        return null;
+    }
+    try {
+        const permission = await Notification.requestPermission();
+        if (permission !== 'granted') {
+            return null;
+        }
+        const registration = await navigator.serviceWorker.ready;
+        const subscription = await registration.pushManager.subscribe({
+            userVisibleOnly: true,
+            applicationServerKey: urlBase64ToUint8Array(publicKey)
+        });
+        if (serverUrl) {
+            await fetch(serverUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(subscription)
+            });
+        }
+        return subscription;
+    }
+    catch (error) {
+        console.error('[PWA] Push subscription failed:', error);
+        return null;
+    }
+}
+export async function unsubscribeFromPush() {
+    if (!('serviceWorker' in navigator)) {
+        return false;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        const subscription = await registration.pushManager.getSubscription();
+        if (subscription) {
+            await subscription.unsubscribe();
+            return true;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return false;
+}
+export async function showNotification(title, options = {}) {
+    if (!('serviceWorker' in navigator)) {
+        return;
+    }
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        await registration.showNotification(title, options);
+    }
+    catch (error) {
+        console.error('[PWA] Show notification failed:', error);
+    }
+}
+function urlBase64ToUint8Array(base64String) {
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding)
+        .replace(/-/g, '+')
+        .replace(/_/g, '/');
+    const rawData = window.atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let index = 0; index < rawData.length; ++index) {
+        outputArray[index] = rawData.charCodeAt(index);
+    }
+    return outputArray;
+}
+export const cache = {
+    async add(cacheName, urls) {
+        if (!('caches' in window))
+            return;
+        const cacheStorage = await caches.open(cacheName);
+        await cacheStorage.addAll(urls);
+    },
+    async remove(cacheName, urls) {
+        if (!('caches' in window))
+            return;
+        const cacheStorage = await caches.open(cacheName);
+        for (const url of urls) {
+            await cacheStorage.delete(url);
+        }
+    },
+    async clear() {
+        if (!('caches' in window))
+            return;
+        const cacheKeys = await caches.keys();
+        await Promise.all(cacheKeys.map((key) => caches.delete(key)));
+    },
+    async info() {
+        if (!('caches' in window))
+            return [];
+        const cacheKeys = await caches.keys();
+        const info = [];
+        for (const key of cacheKeys) {
+            const cacheStorage = await caches.open(key);
+            const requests = await cacheStorage.keys();
+            info.push({ name: key, size: requests.length });
+        }
+        return info;
+    }
+};
+export async function checkCapabilities() {
+    let backgroundSync = false;
+    if ('serviceWorker' in navigator) {
+        try {
+            const registration = await navigator.serviceWorker.ready;
+            backgroundSync = 'sync' in registration;
+        }
+        catch {
+            // Service worker not available
+        }
+    }
+    return {
+        serviceWorker: 'serviceWorker' in navigator,
+        push: 'PushManager' in window,
+        notifications: 'Notification' in window,
+        backgroundSync,
+        persistentStorage: Boolean(navigator.storage?.persist),
+        addToHomeScreen: !isStandalone(),
+        offline: 'serviceWorker' in navigator
+    };
+}
+export const PWA = {
+    generateManifest,
+    registerServiceWorker,
+    unregisterServiceWorker,
+    isStandalone,
+    isOnline,
+    subscribeToConnectivity,
+    requestPersistentStorage,
+    getStorageInfo,
+    sync,
+    subscribeToPush,
+    unsubscribeFromPush,
+    showNotification,
+    cache,
+    checkCapabilities
+};
+export default PWA;