metaowl 0.4.1 → 0.5.0

package/build/runtime/modules/seo.js

@@ -0,0 +1,186 @@
+/**
+ * @module SEO
+ *
+ * SEO utilities for MetaOwl applications.
+ */
+const VALID_CHANGE_FREQUENCIES = ['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never'];
+export function generateSitemap(entries, options = {}) {
+    const { baseUrl } = options;
+    if (!baseUrl) {
+        throw new Error('[SEO] baseUrl is required for sitemap generation');
+    }
+    const normalizedBase = baseUrl.replace(/\/$/, '');
+    const urls = entries.map((entry) => {
+        const routeUrl = entry.url ?? '';
+        const location = routeUrl.startsWith('http')
+            ? routeUrl
+            : `${normalizedBase}${routeUrl.startsWith('/') ? routeUrl : '/' + routeUrl}`;
+        let urlXml = `  <url>\n    <loc>${escapeXml(location)}</loc>\n`;
+        if (entry.lastmod) {
+            urlXml += `    <lastmod>${entry.lastmod}</lastmod>\n`;
+        }
+        if (entry.changefreq && VALID_CHANGE_FREQUENCIES.includes(entry.changefreq)) {
+            urlXml += `    <changefreq>${entry.changefreq}</changefreq>\n`;
+        }
+        if (entry.priority !== undefined) {
+            const priority = Math.max(0, Math.min(1, entry.priority)).toFixed(1);
+            urlXml += `    <priority>${priority}</priority>\n`;
+        }
+        if (entry.image) {
+            urlXml += '    <image:image xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">\n';
+            urlXml += `      <image:loc>${escapeXml(entry.image)}</image:loc>\n`;
+            urlXml += '    </image:image>\n';
+        }
+        urlXml += '  </url>';
+        return urlXml;
+    });
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls.join('\n')}\n</urlset>`;
+}
+export function generateRobotsTxt(config = {}) {
+    const configs = Array.isArray(config) ? config : [config];
+    const sections = configs.map((cfg) => {
+        const { userAgent = '*', allow = [], disallow = [], crawlDelay } = cfg;
+        let section = `User-agent: ${userAgent}\n`;
+        for (const path of allow) {
+            section += `Allow: ${path}\n`;
+        }
+        for (const path of disallow) {
+            section += `Disallow: ${path}\n`;
+        }
+        if (crawlDelay !== undefined && crawlDelay > 0) {
+            section += `Crawl-delay: ${crawlDelay}\n`;
+        }
+        return section.trim();
+    });
+    const globalConfig = configs.find((cfg) => cfg.sitemap || cfg.host);
+    if (globalConfig?.sitemap) {
+        sections.push(`Sitemap: ${globalConfig.sitemap}`);
+    }
+    if (globalConfig?.host) {
+        sections.push(`Host: ${globalConfig.host}`);
+    }
+    return sections.join('\n\n');
+}
+export function jsonLd(schema) {
+    const fullSchema = {
+        '@context': 'https://schema.org',
+        ...schema
+    };
+    return JSON.stringify(fullSchema, null, 2);
+}
+export function createCanonicalUrl(baseUrl, path, options = {}) {
+    const { removeQueryParams = false, allowedParams = [] } = options;
+    const normalizedBase = baseUrl.replace(/\/$/, '');
+    const [pathname, queryString] = path.split('?');
+    const normalizedPath = pathname.startsWith('/') ? pathname : '/' + pathname;
+    if (!queryString || removeQueryParams) {
+        return `${normalizedBase}${normalizedPath}`;
+    }
+    if (allowedParams.length > 0) {
+        const params = new URLSearchParams(queryString);
+        const filtered = new URLSearchParams();
+        for (const key of allowedParams) {
+            const value = params.get(key);
+            if (value !== null) {
+                filtered.set(key, value);
+            }
+        }
+        const filteredQuery = filtered.toString();
+        return filteredQuery
+            ? `${normalizedBase}${normalizedPath}?${filteredQuery}`
+            : `${normalizedBase}${normalizedPath}`;
+    }
+    return `${normalizedBase}${normalizedPath}?${queryString}`;
+}
+export function generateOpenGraph(data) {
+    const { title, description, type = 'website', url, image, siteName } = data;
+    const tags = {
+        'og:title': title,
+        'og:type': type
+    };
+    if (description)
+        tags['og:description'] = description;
+    if (url)
+        tags['og:url'] = url;
+    if (image)
+        tags['og:image'] = image;
+    if (siteName)
+        tags['og:site_name'] = siteName;
+    return tags;
+}
+export function generateTwitterCard(data) {
+    const { title, description, card = 'summary_large_image', image, site } = data;
+    const tags = {
+        'twitter:card': card,
+        'twitter:title': title
+    };
+    if (description)
+        tags['twitter:description'] = description;
+    if (image)
+        tags['twitter:image'] = image;
+    if (site)
+        tags['twitter:site'] = site;
+    return tags;
+}
+export function validateSitemap(entries) {
+    const errors = [];
+    for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index];
+        if (!entry.url) {
+            errors.push(`Entry ${index}: Missing required 'url'`);
+        }
+        if (entry.priority !== undefined && (entry.priority < 0 || entry.priority > 1)) {
+            errors.push(`Entry ${index}: Priority must be between 0 and 1`);
+        }
+        if (entry.changefreq && !VALID_CHANGE_FREQUENCIES.includes(entry.changefreq)) {
+            errors.push(`Entry ${index}: Invalid changefreq '${entry.changefreq}'`);
+        }
+        if (entry.lastmod) {
+            const date = new Date(entry.lastmod);
+            if (Number.isNaN(date.getTime())) {
+                errors.push(`Entry ${index}: Invalid lastmod date '${entry.lastmod}'`);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+export function getPriorityByDepth(url, options = {}) {
+    const { maxDepth = 3 } = options;
+    const depth = url.split('/').filter(Boolean).length;
+    const priority = Math.max(0.1, 1 - (depth / maxDepth) * 0.3);
+    return Math.round(priority * 10) / 10;
+}
+export function generateSitemapIndex(sitemaps) {
+    const entries = sitemaps.map((sitemap) => {
+        let entry = `  <sitemap>\n    <loc>${escapeXml(sitemap.loc)}</loc>\n`;
+        if (sitemap.lastmod) {
+            entry += `    <lastmod>${sitemap.lastmod}</lastmod>\n`;
+        }
+        entry += '  </sitemap>';
+        return entry;
+    });
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${entries.join('\n')}\n</sitemapindex>`;
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '<')
+        .replace(/>/g, '>')
+        .replace(/"/g, '"')
+        .replace(/'/g, '&#x27;');
+}
+export const SEO = {
+    generateSitemap,
+    generateRobotsTxt,
+    jsonLd,
+    createCanonicalUrl,
+    generateOpenGraph,
+    generateTwitterCard,
+    validateSitemap,
+    getPriorityByDepth,
+    generateSitemapIndex
+};
+export default SEO;

package/build/runtime/modules/store.js

@@ -0,0 +1,196 @@
+/**
+ * @module Store
+ *
+ * Lightweight state management for OWL applications, inspired by Pinia/Vuex.
+ */
+import { reactive } from '@odoo/owl';
+const stores = new Map();
+const plugins = [];
+export class Store {
+    _id;
+    _config;
+    _state;
+    _getters;
+    _mutations;
+    _actions;
+    _subscribers;
+    _actionSubscribers;
+    constructor(id, config) {
+        this._id = id;
+        this._config = config;
+        this._state = reactive(config.state ? config.state() : {});
+        this._getters = {};
+        this._mutations = config.mutations || {};
+        this._actions = config.actions || {};
+        this._subscribers = [];
+        this._actionSubscribers = [];
+        if (config.getters) {
+            for (const [name, fn] of Object.entries(config.getters)) {
+                Object.defineProperty(this._getters, name, {
+                    get: () => fn(this._state, this._getters),
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+        }
+        for (const plugin of plugins) {
+            plugin(this);
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    get state() {
+        return this._state;
+    }
+    get getters() {
+        return this._getters;
+    }
+    commit(type, payload) {
+        const mutation = this._mutations[type];
+        if (!mutation) {
+            throw new Error(`[metaowl] Mutation "${type}" not found in store "${this._id}"`);
+        }
+        const prevState = JSON.parse(JSON.stringify(this._state));
+        const result = mutation(this._state, payload);
+        for (const subscriber of this._subscribers) {
+            subscriber({ type, payload }, this._state, prevState);
+        }
+        return result;
+    }
+    async dispatch(type, payload) {
+        const action = this._actions[type];
+        if (!action) {
+            throw new Error(`[metaowl] Action "${type}" not found in store "${this._id}"`);
+        }
+        const context = {
+            state: this._state,
+            getters: this._getters,
+            commit: this.commit.bind(this),
+            dispatch: this.dispatch.bind(this)
+        };
+        for (const subscriber of this._actionSubscribers) {
+            subscriber({ type, payload }, 'before');
+        }
+        try {
+            const result = await action(context, payload);
+            for (const subscriber of this._actionSubscribers) {
+                subscriber({ type, payload }, 'after', result);
+            }
+            return result;
+        }
+        catch (error) {
+            for (const subscriber of this._actionSubscribers) {
+                subscriber({ type, payload }, 'error', error);
+            }
+            throw error;
+        }
+    }
+    subscribe(callback) {
+        this._subscribers.push(callback);
+        return () => {
+            const index = this._subscribers.indexOf(callback);
+            if (index > -1)
+                this._subscribers.splice(index, 1);
+        };
+    }
+    subscribeAction(callback) {
+        this._actionSubscribers.push(callback);
+        return () => {
+            const index = this._actionSubscribers.indexOf(callback);
+            if (index > -1)
+                this._actionSubscribers.splice(index, 1);
+        };
+    }
+    reset() {
+        if (this._config.state) {
+            const initialState = this._config.state();
+            Object.keys(this._state).forEach((key) => {
+                delete this._state[key];
+            });
+            Object.assign(this._state, initialState);
+        }
+    }
+    static define(id, config) {
+        return function useStore() {
+            if (!stores.has(id)) {
+                stores.set(id, new Store(id, config));
+            }
+            return stores.get(id);
+        };
+    }
+    static get(id) {
+        return stores.get(id);
+    }
+    static has(id) {
+        return stores.has(id);
+    }
+    static remove(id) {
+        const store = stores.get(id);
+        if (store) {
+            store.reset();
+            return stores.delete(id);
+        }
+        return false;
+    }
+    static clear() {
+        stores.clear();
+    }
+    static storeIds() {
+        return Array.from(stores.keys());
+    }
+    static use(plugin) {
+        plugins.push(plugin);
+    }
+}
+export function createPersistencePlugin(options = {}) {
+    const { storage = localStorage, key, paths } = options;
+    return function persistencePlugin(store) {
+        const storageKey = key || `metaowl:store:${store.id}`;
+        try {
+            const saved = storage.getItem(storageKey);
+            if (saved) {
+                const persisted = JSON.parse(saved);
+                if (paths) {
+                    for (const path of paths) {
+                        if (path in persisted && path in store.state) {
+                            store.state[path] = persisted[path];
+                        }
+                    }
+                }
+                else {
+                    Object.assign(store.state, persisted);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('[metaowl] Failed to restore store from storage:', error);
+        }
+        store.subscribe((_mutation, state) => {
+            try {
+                const toPersist = paths
+                    ? Object.fromEntries(paths.map((path) => [path, state[path]]))
+                    : state;
+                storage.setItem(storageKey, JSON.stringify(toPersist));
+            }
+            catch (error) {
+                console.warn('[metaowl] Failed to persist store:', error);
+            }
+        });
+    };
+}
+export function createStore(initialState = {}) {
+    const state = reactive({ ...initialState });
+    state.$patch = (partialState) => {
+        Object.assign(state, partialState);
+    };
+    state.$reset = () => {
+        Object.keys(state).forEach((key) => {
+            if (!key.startsWith('$')) {
+                delete state[key];
+            }
+        });
+        Object.assign(state, initialState);
+    };
+    return state;
+}

package/build/runtime/modules/templates-manager.js

@@ -0,0 +1,52 @@
+/**
+ * @module TemplatesManager
+ *
+ * Template loading and merging utilities for OWL applications.
+ */
+import { loadFile } from '@odoo/owl';
+const LINK_COMPONENT_TEMPLATE = /* xml */ `
+  <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>
+`;
+const INTERNAL_TEMPLATES = [LINK_COMPONENT_TEMPLATE];
+export async function mergeTemplates(files) {
+    const fileArray = Array.isArray(files) ? files : [files];
+    if (fileArray.length === 1) {
+        try {
+            const content = await loadFile(fileArray[0]);
+            if (content.trim().startsWith('<templates>')) {
+                return content.replace('</templates>', INTERNAL_TEMPLATES.join('') + '</templates>');
+            }
+            return '<templates>' + content + INTERNAL_TEMPLATES.join('') + '</templates>';
+        }
+        catch (error) {
+            console.error(`[metaowl] Failed to load template: ${fileArray[0]}`, error);
+            return '<templates>' + INTERNAL_TEMPLATES.join('') + '</templates>';
+        }
+    }
+    const results = await Promise.all(fileArray.map(async (file) => {
+        try {
+            return await loadFile(file);
+        }
+        catch (error) {
+            console.error(`[metaowl] Failed to load template: ${file}`, error);
+            return '';
+        }
+    }));
+    return '<templates>' + results.join('') + INTERNAL_TEMPLATES.join('') + '</templates>';
+}
+export function getInternalTemplates() {
+    return [...INTERNAL_TEMPLATES];
+}

package/build/runtime/modules/test-utils.js

@@ -0,0 +1,238 @@
+/**
+ * @module TestUtils
+ *
+ * Testing utilities for MetaOwl OWL applications.
+ */
+import { mount, reactive } from '@odoo/owl';
+export function createMockStore(config = {}) {
+    const { state: initialState = {}, getters: getterDefs = {}, mutations: mutationDefs = {}, actions: actionDefs = {} } = config;
+    const state = reactive({ ...initialState });
+    const getters = {};
+    for (const [name, fn] of Object.entries(getterDefs)) {
+        Object.defineProperty(getters, name, {
+            get: () => fn(state),
+            enumerable: true
+        });
+    }
+    const mutations = {};
+    for (const [name, fn] of Object.entries(mutationDefs)) {
+        mutations[name] = (payload) => {
+            fn(state, payload);
+        };
+    }
+    const actions = {};
+    for (const [name, fn] of Object.entries(actionDefs)) {
+        actions[name] = async (payload) => {
+            const context = {
+                state,
+                getters,
+                commit: (mutation, nextPayload) => mutations[mutation]?.(nextPayload),
+                dispatch: (action, nextPayload) => actions[action]?.(nextPayload)
+            };
+            return await fn(context, payload);
+        };
+    }
+    return {
+        state,
+        getters,
+        mutations,
+        actions,
+        commit(name, payload) {
+            if (mutations[name]) {
+                mutations[name](payload);
+            }
+            else {
+                console.warn(`[TestUtils] Mutation '${name}' not found`);
+            }
+        },
+        async dispatch(name, payload) {
+            if (actions[name]) {
+                return await actions[name](payload);
+            }
+            console.warn(`[TestUtils] Action '${name}' not found`);
+            return undefined;
+        },
+        reset() {
+            Object.keys(state).forEach((key) => delete state[key]);
+            Object.assign(state, initialState);
+        },
+        setState(newState) {
+            Object.assign(state, newState);
+        }
+    };
+}
+export function mockRouter(config = {}) {
+    const { initialRoute = '/', routes = [] } = config;
+    const currentRoute = reactive({
+        path: initialRoute,
+        name: null,
+        params: {},
+        query: {},
+        hash: ''
+    });
+    const beforeEachGuards = [];
+    const afterEachHooks = [];
+    function parseUrl(url) {
+        const [pathAndQuery, hash = ''] = url.split('#');
+        const [path = '', queryString = ''] = pathAndQuery.split('?');
+        const query = {};
+        if (queryString) {
+            queryString.split('&').forEach((param) => {
+                const [key, value] = param.split('=');
+                query[decodeURIComponent(key)] = decodeURIComponent(value || '');
+            });
+        }
+        let matchedRoute = null;
+        let params = {};
+        for (const route of routes) {
+            const match = matchPath(path, route.path);
+            if (match) {
+                matchedRoute = route;
+                params = match.params;
+                break;
+            }
+        }
+        return {
+            path,
+            name: matchedRoute?.name || null,
+            params,
+            query,
+            hash
+        };
+    }
+    function matchPath(path, pattern) {
+        const paramNames = [];
+        const regexPattern = pattern
+            .replace(/\*/g, '.*')
+            .replace(/:([^/]+)/g, (_match, name) => {
+            paramNames.push(name);
+            return '([^/]+)';
+        });
+        const regex = new RegExp(`^${regexPattern}$`);
+        const match = path.match(regex);
+        if (!match)
+            return null;
+        const params = {};
+        paramNames.forEach((name, index) => {
+            params[name] = match[index + 1];
+        });
+        return { params };
+    }
+    Object.assign(currentRoute, parseUrl(initialRoute));
+    return {
+        currentRoute,
+        async push(path) {
+            const to = parseUrl(path);
+            const from = { ...currentRoute };
+            for (const guard of beforeEachGuards) {
+                const result = await guard(to, from, () => { });
+                if (result === false)
+                    return;
+            }
+            Object.assign(currentRoute, to);
+            for (const hook of afterEachHooks) {
+                await hook(to, from);
+            }
+        },
+        async replace(path) {
+            await this.push(path);
+        },
+        back() {
+            // Mock - does nothing in test environment
+        },
+        beforeEach(guard) {
+            beforeEachGuards.push(guard);
+            return () => {
+                const index = beforeEachGuards.indexOf(guard);
+                if (index > -1)
+                    beforeEachGuards.splice(index, 1);
+            };
+        },
+        afterEach(hook) {
+            afterEachHooks.push(hook);
+            return () => {
+                const index = afterEachHooks.indexOf(hook);
+                if (index > -1)
+                    afterEachHooks.splice(index, 1);
+            };
+        },
+        resolve(name, params = {}) {
+            const route = routes.find((candidate) => candidate.name === name);
+            if (!route)
+                return '/';
+            let path = route.path;
+            for (const [key, value] of Object.entries(params)) {
+                path = path.replace(`:${key}`, String(value));
+            }
+            return path;
+        }
+    };
+}
+export async function mountComponent(ComponentClass, options = {}) {
+    const { props = {}, store = null, router = null, target = document.createElement('div') } = options;
+    const env = {};
+    if (store)
+        env.store = store;
+    if (router)
+        env.router = router;
+    return await mount(ComponentClass, target, {
+        props,
+        env
+    });
+}
+export function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function nextTick() {
+    return new Promise((resolve) => {
+        requestAnimationFrame(() => resolve());
+    });
+}
+export async function flushPromises() {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+}
+export const userEvent = {
+    async click(element) {
+        element.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+        await flushPromises();
+    },
+    async type(input, text) {
+        input.value = text;
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        await flushPromises();
+    },
+    async submit(form) {
+        form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+        await flushPromises();
+    },
+    async select(select, value) {
+        select.value = value;
+        select.dispatchEvent(new Event('change', { bubbles: true }));
+        await flushPromises();
+    }
+};
+export const dom = {
+    query(selector, container = document) {
+        return container.querySelector(selector);
+    },
+    queryAll(selector, container = document) {
+        return container.querySelectorAll(selector);
+    },
+    hasClass(element, className) {
+        return element?.classList?.contains(className) || false;
+    },
+    text(element) {
+        return element?.textContent?.trim() || '';
+    }
+};
+export const TestUtils = {
+    createMockStore,
+    mockRouter,
+    mountComponent,
+    wait,
+    nextTick,
+    flushPromises,
+    userEvent,
+    dom
+};
+export default TestUtils;