metaowl 0.4.1 → 0.5.0

package/build/runtime/modules/pwa.js

@@ -0,0 +1,262 @@
+/**
+ * @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 function checkCapabilities() {
+    return {
+        serviceWorker: 'serviceWorker' in navigator,
+        push: 'PushManager' in window,
+        notifications: 'Notification' in window,
+        backgroundSync: false,
+        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;

package/build/runtime/modules/router.js

@@ -0,0 +1,389 @@
+/**
+ * @module Router
+ *
+ * Enhanced router with navigation guards support.
+ */
+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;
+        }
+        let pattern = routePath
+            .replace(/\//g, '\\/')
+            .replace(/:([^/(]+)\(\.\*\)/g, '(.*)')
+            .replace(/\/:([^/(]+)\?/g, '(?:/([^/]+))?')
+            .replace(/:([^/(?\s]+)/g, '([^/]+)')
+            .replace(/\*/g, '(.*)');
+        pattern = '^' + pattern + '$';
+        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;
+}