metaowl 0.4.1 → 0.6.0

package/build/runtime/modules/router.js

@@ -0,0 +1,384 @@
+/**
+ * @module Router
+ *
+ * Enhanced router with navigation guards support.
+ */
+import { buildSimpleRoutePattern } from './constants.js';
+let currentRoute = null;
+let previousRoute = null;
+const beforeEachGuards = [];
+const afterEachHooks = [];
+let navigating = false;
+let cancelCurrentNavigation = null;
+let spaNavigationCallback = null;
+let spaEnabled = false;
+class Router {
+    routes;
+    routeMap;
+    constructor(routes) {
+        this.routes = routes;
+        this.routeMap = new Map();
+        for (const route of routes) {
+            for (const path of route.path) {
+                this.routeMap.set(path, route);
+            }
+        }
+    }
+    resolve(path) {
+        const currentPath = path || document.location.pathname;
+        if (this.routeMap.has(currentPath)) {
+            return this.routeMap.get(currentPath) || null;
+        }
+        for (const route of this.routes) {
+            if (this.matchRoute(route, currentPath)) {
+                return route;
+            }
+        }
+        return null;
+    }
+    matchRoute(route, path) {
+        for (const routePath of route.path) {
+            if (this.pathMatches(routePath, path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    pathMatches(routePath, currentPath) {
+        if (!routePath.includes(':') && !routePath.includes('*')) {
+            const normalizedRoute = (routePath.replace(/\/$/, '') || '/');
+            const normalizedCurrent = (currentPath.replace(/\/$/, '') || '/');
+            return normalizedRoute === normalizedCurrent;
+        }
+        const pattern = buildSimpleRoutePattern(routePath);
+        return new RegExp(pattern).test(currentPath);
+    }
+    extractParams(route, path) {
+        const params = {};
+        for (const routePath of route.path) {
+            const match = this.matchAndExtract(routePath, path);
+            if (match) {
+                Object.assign(params, match);
+            }
+        }
+        return params;
+    }
+    matchAndExtract(routePath, currentPath) {
+        if (!routePath.includes(':')) {
+            return null;
+        }
+        const paramNames = [];
+        const pattern = routePath
+            .replace(/:([^/(]+)\(\.\*\)/g, (_match, name) => {
+            paramNames.push(name);
+            return '(.*)';
+        })
+            .replace(/\/:([^/(]+)\?/g, (_match, name) => {
+            paramNames.push(name);
+            return '(?:/([^/]+))?';
+        })
+            .replace(/:([^/(?\s]+)/g, (_match, name) => {
+            paramNames.push(name);
+            return '([^/]+)';
+        });
+        const matches = currentPath.match(new RegExp('^' + pattern + '$'));
+        if (!matches)
+            return null;
+        const params = {};
+        for (let index = 0; index < paramNames.length; index++) {
+            const value = matches[index + 1];
+            if (value !== undefined) {
+                params[paramNames[index]] = value;
+            }
+        }
+        return params;
+    }
+}
+const injectedRouteSets = new WeakSet();
+export async function processRoutes(routes, customPath) {
+    const targetPath = customPath || document.location.pathname;
+    if (!injectedRouteSets.has(routes)) {
+        injectedRouteSets.add(routes);
+        for (const route of routes) {
+            const originalPaths = [...route.path];
+            for (const path of originalPaths) {
+                if (typeof path === 'string') {
+                    injectSystemRoutes(route, path);
+                }
+            }
+        }
+    }
+    const routerInstance = new Router(routes);
+    const toRoute = routerInstance.resolve(targetPath);
+    if (!toRoute) {
+        throw new Error(`No route found for "${targetPath}".`);
+    }
+    const to = buildRouteObject(toRoute, routerInstance);
+    const from = currentRoute;
+    try {
+        await runGuards(to, from);
+        previousRoute = currentRoute;
+        currentRoute = to;
+        for (const hook of afterEachHooks) {
+            hook(to, from);
+        }
+        return [toRoute];
+    }
+    catch (error) {
+        if (isNavigationRedirect(error) && error.path) {
+            window.location.href = error.path;
+            return null;
+        }
+        throw error;
+    }
+}
+function buildRouteObject(routeDef, routerInstance) {
+    const currentPath = document.location.pathname;
+    const params = routerInstance.extractParams(routeDef, currentPath);
+    return {
+        name: routeDef.name,
+        path: routeDef.path,
+        fullPath: currentPath,
+        component: routeDef.component,
+        meta: routeDef.meta || {},
+        beforeEnter: routeDef.beforeEnter,
+        params,
+        query: parseQuery(document.location.search)
+    };
+}
+function parseQuery(search) {
+    const query = {};
+    if (!search || search === '?')
+        return query;
+    const params = new URLSearchParams(search.substring(1));
+    for (const [key, value] of params) {
+        const existing = query[key];
+        if (existing) {
+            if (Array.isArray(existing)) {
+                existing.push(value);
+            }
+            else {
+                query[key] = [existing, value];
+            }
+        }
+        else {
+            query[key] = value;
+        }
+    }
+    return query;
+}
+async function runGuards(to, from) {
+    navigating = true;
+    let cancelled = false;
+    cancelCurrentNavigation = () => {
+        cancelled = true;
+    };
+    try {
+        for (const guard of beforeEachGuards) {
+            if (cancelled)
+                break;
+            const result = await runGuard(guard, to, from);
+            if (result === false) {
+                throw new NavigationCancelled();
+            }
+            if (typeof result === 'string') {
+                throw new NavigationRedirect(result);
+            }
+            if (result && typeof result === 'object' && 'path' in result && typeof result.path === 'string') {
+                throw new NavigationRedirect(result.path);
+            }
+        }
+        if (to.beforeEnter && !cancelled) {
+            const result = await runGuard(to.beforeEnter, to, from);
+            if (result === false) {
+                throw new NavigationCancelled();
+            }
+            if (typeof result === 'string') {
+                throw new NavigationRedirect(result);
+            }
+        }
+    }
+    finally {
+        navigating = false;
+        cancelCurrentNavigation = null;
+    }
+}
+async function runGuard(guard, to, from) {
+    return await new Promise((resolve, reject) => {
+        const next = (result) => {
+            if (result instanceof Error) {
+                reject(result);
+            }
+            else {
+                resolve(result);
+            }
+        };
+        try {
+            const guardResult = guard(to, from, next);
+            if (guardResult && typeof guardResult.then === 'function') {
+                ;
+                guardResult.then(resolve).catch(reject);
+            }
+            else if (guardResult !== undefined) {
+                resolve(guardResult);
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+export function resetRouter() {
+    beforeEachGuards.length = 0;
+    afterEachHooks.length = 0;
+    navigating = false;
+    cancelCurrentNavigation = null;
+    currentRoute = null;
+    previousRoute = null;
+    spaNavigationCallback = null;
+    spaEnabled = false;
+}
+class NavigationCancelled extends Error {
+    constructor() {
+        super('Navigation cancelled');
+        this.name = 'NavigationCancelled';
+    }
+}
+class NavigationRedirect extends Error {
+    path;
+    constructor(path) {
+        super('Navigation redirect');
+        this.name = 'NavigationRedirect';
+        this.path = path;
+    }
+}
+function isNavigationRedirect(error) {
+    return error instanceof Error && error.name === 'NavigationRedirect' && 'path' in error;
+}
+export function beforeEach(guard) {
+    beforeEachGuards.push(guard);
+    return () => {
+        const index = beforeEachGuards.indexOf(guard);
+        if (index > -1)
+            beforeEachGuards.splice(index, 1);
+    };
+}
+export function afterEach(hook) {
+    afterEachHooks.push(hook);
+    return () => {
+        const index = afterEachHooks.indexOf(hook);
+        if (index > -1)
+            afterEachHooks.splice(index, 1);
+    };
+}
+export function getCurrentRoute() {
+    return currentRoute;
+}
+export function getPreviousRoute() {
+    return previousRoute;
+}
+export function isNavigating() {
+    return navigating;
+}
+export function cancelNavigation() {
+    if (cancelCurrentNavigation) {
+        cancelCurrentNavigation();
+    }
+}
+export function _setSpaNavigationCallback(callback) {
+    spaNavigationCallback = callback;
+}
+export function setSpaMode(enabled) {
+    spaEnabled = enabled;
+}
+export function isSpaMode() {
+    return spaEnabled;
+}
+export async function navigateTo(path, options = {}) {
+    const { replace = false } = options;
+    if (!spaEnabled || !spaNavigationCallback) {
+        if (replace) {
+            window.location.replace(path);
+        }
+        else {
+            window.location.href = path;
+        }
+        return false;
+    }
+    try {
+        if (replace) {
+            window.history.replaceState({ path }, '', path);
+        }
+        else {
+            window.history.pushState({ path }, '', path);
+        }
+        await spaNavigationCallback(path);
+        return true;
+    }
+    catch (error) {
+        console.error('[metaowl] SPA navigation failed:', error);
+        window.location.href = path;
+        return false;
+    }
+}
+export function navigate(path, options = {}) {
+    const { replace = false, reload = true } = options;
+    if (reload || !spaEnabled) {
+        if (replace) {
+            window.location.replace(path);
+        }
+        else {
+            window.location.href = path;
+        }
+    }
+    else {
+        void navigateTo(path, { replace });
+    }
+}
+export function push(path) {
+    void navigateTo(path, { replace: false });
+}
+export function replace(path) {
+    void navigateTo(path, { replace: true });
+}
+export function back() {
+    window.history.back();
+}
+export function forward() {
+    window.history.forward();
+}
+export function go(n) {
+    window.history.go(n);
+}
+export const router = {
+    beforeEach,
+    afterEach,
+    get currentRoute() { return getCurrentRoute(); },
+    get previousRoute() { return getPreviousRoute(); },
+    get isNavigating() { return isNavigating(); },
+    cancel: cancelNavigation,
+    push,
+    replace,
+    back,
+    forward,
+    go,
+    navigate,
+    navigateTo,
+    setSpaMode,
+    isSpaMode
+};
+function injectSystemRoutes(route, path) {
+    if (path === '/') {
+        if (!route.path.includes('/index.html'))
+            route.path.push('/index.html');
+    }
+    else {
+        if (!route.path.includes(`${path}.html`))
+            route.path.push(`${path}.html`);
+        if (!route.path.includes(`${path}/`))
+            route.path.push(`${path}/`);
+        if (!route.path.includes(`${path}/index.html`))
+            route.path.push(`${path}/index.html`);
+    }
+    return route;
+}

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, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;');
+}
+export const SEO = {
+    generateSitemap,
+    generateRobotsTxt,
+    jsonLd,
+    createCanonicalUrl,
+    generateOpenGraph,
+    generateTwitterCard,
+    validateSitemap,
+    getPriorityByDepth,
+    generateSitemapIndex
+};
+export default SEO;