@reidelsaltres/pureper 0.1.49

package/src/foundation/worker/Router.ts

@@ -0,0 +1,124 @@
+// Add RouterConfig type to window for TypeScript
+declare global {
+  interface Window {
+    RouterConfig?: { ASSET_PATH: string };
+  }
+}
+import { AnyConstructor } from "../component_api/mixin/Proto";
+import Page from "../component_api/Page";
+import UniHtml from "../component_api/UniHtml.js";
+import { ServiceWorkerGlobalScope } from "./api/ServiceWorkerGlobalScope";
+
+const globals = self as any as ServiceWorkerGlobalScope;
+
+export interface Route<T extends UniHtml = UniHtml> {
+  route: string;
+  path: string;
+
+  pageFactory: (search?: URLSearchParams) => T;
+}
+export enum AccessType {
+  OFFLINE,
+  ONLINE,
+  BOTH
+}
+
+export const ROUTES: Route[] = [];
+export const TO_CACHE: string[] = [];
+
+export abstract class Router {
+  public static savePersistedRoute(url: URL) {
+    try {
+      sessionStorage.setItem("spa:persisted-route", url.toJSON());
+    } catch (error) {
+      console.warn("[Router Init]: Unable to access sessionStorage.", error);
+    }
+  }
+  public static getPersistedRoute(): URL | null {
+    try {
+      const item = sessionStorage.getItem("spa:persisted-route");
+      return item ? URL.parse(item) : null;
+    } catch (error) {
+      console.warn("[Router Init]: Unable to access sessionStorage.", error);
+      return null;
+    }
+  }
+  public static clearPersistedRoute() {
+    try {
+      sessionStorage.removeItem("spa:persisted-route");
+    } catch (error) {
+      console.warn("[Router Init]: Unable to clear persisted route.", error);
+    }
+  }
+
+
+  public static legacyRouteTo(route: string) {
+    let url = new URL(route, window.location.origin);
+    if (window.location.pathname !== route) {
+      window.location.replace(url.href);
+    }
+  }
+  public static tryRouteTo(url: URL) {
+    try {
+      const found: Route = this.tryFindRoute(url);
+      const page: UniHtml = this.createPage(found, url.searchParams);
+
+      page.load(document.getElementById('page')!);
+
+      if (typeof window !== "undefined" && window.location) {
+        window.history.pushState(page, '', url.href);
+      }
+    } catch (error) {
+      console.error("[Router]: Unable to route to ", url.href, error);
+    }
+  }
+  public static tryFindRoute(url: URL): Route {
+    const found = ROUTES.find(r => r.route === url.pathname);
+    if (!found) {
+      throw new Error(`[Router]: Route not found: ${url.pathname}`);
+    }
+    return found;
+  }
+
+  public static async registerRoute<T extends UniHtml>(path: string, route: string, pageFactory: (search?: URLSearchParams) => T,
+    inheritedRoute?: Route): Promise<Route> {
+
+    let prepRoute = route
+    let fullRoute = inheritedRoute ? inheritedRoute.route + prepRoute : prepRoute;
+
+    let routeObj: Route = { route: fullRoute, path, pageFactory };
+
+    ROUTES.push(routeObj);
+    console.log(`[Router]: Registered route: ${fullRoute} -> ${path}`);
+
+    return Promise.resolve(routeObj);
+  }
+
+
+  private static createPage(route: Route, search?: URLSearchParams): UniHtml {
+    return route.pageFactory(search);
+  }
+}
+
+document.addEventListener('click', e => {
+  const target = e.target as Element | null;
+  if (target) {
+    const link = target.closest('a[data-link]') ?? target.closest('re-button[data-link]');
+    if (link) {
+      e.preventDefault();
+      const url : URL = new URL(link.getAttribute('href')!, window.location.origin);
+      Router.tryRouteTo(url);
+    }
+  }
+});
+
+window.addEventListener('DOMContentLoaded', () => {
+  const checkRoutes = () => {
+    const routes = ROUTES;
+    if (routes) {
+      console.log('[Init] [Router]: available routes =', routes.map(r => r.route).join(', '));
+    }
+  };
+
+  checkRoutes();
+});

package/src/foundation/worker/ServiceWorker.ts

@@ -0,0 +1,160 @@
+/**
+ * Service Worker for Pureper SPA
+ * Handles client-side routing by intercepting navigation requests
+ * and serving index.html for all SPA routes
+ */
+import type { ExtendableEvent } from './api/ExtendableEvent';
+import type { FetchEvent } from './api/FetchEvent';
+import type { ExtendableMessageEvent } from './api/ExtendableMessageEvent';
+import type { Clients } from './api/Clients';
+import type { ServiceWorkerGlobalScope } from './api/ServiceWorkerGlobalScope';
+
+// Type assertion for Service Worker context
+declare let self: ServiceWorkerGlobalScope
+const swSelf = self;
+
+// Автоматически генерируем CACHE_NAME из base.json
+//import base from '../../../data/base.json';
+const CACHE_NAME = `pureper-v1`;
+
+const BASE_PATH = '/Pureper'; // GitHub Pages base path
+const IS_GITHUB_PAGES = swSelf.location.hostname.includes('github.io');
+
+const STATIC_ASSETS: string[] = [
+    '/index.html'
+];
+
+if ('serviceWorker' in navigator) {
+    window.addEventListener('load', () => {
+        navigator.serviceWorker.register('../out/src/foundation/worker/ServiceWorker.js', { type: 'module' })
+            .then((registration) => {
+                console.log('ServiceWorker registration successful:', registration.scope);
+            })
+            .catch((error) => {
+                console.error('ServiceWorker registration failed:', error);
+            });
+    });
+    window.addEventListener('fetch', (event: FetchEvent) => {
+        event.respondWith(
+            caches.match(event.request).then((cachedResponse) => {
+                console.log(`[ServiceWorker]: Fetching ${event.request.url}`);
+                return cachedResponse || fetch(event.request);
+            })
+        );
+    });
+}
+
+/**
+ * Install event - cache static assets
+ */
+window.addEventListener('install', (event: ExtendableEvent) => {
+    console.log('ServiceWorker: Installing...');
+    const assetsToCache = [
+        ...STATIC_ASSETS
+    ];
+    // Remove duplicates
+    const uniqueAssets = Array.from(new Set(assetsToCache));
+    event.waitUntil(
+        caches.open(CACHE_NAME)
+            .then((cache: Cache) => {
+                console.log('ServiceWorker: Caching static assets and SPA routes');
+                return cache.addAll(uniqueAssets);
+            })
+            .then(() => {
+                console.log('ServiceWorker: Installation complete');
+                return swSelf.skipWaiting();
+            })
+    );
+});
+
+export default class ServiceWorker {
+    /**
+     * Sends a message to the service worker to cache a specific URL.
+     * @param url The URL of the resource to cache.
+     */
+    static async addToCache(url: string): Promise<void> {
+        if ('serviceWorker' in navigator && navigator.serviceWorker.controller) {
+            navigator.serviceWorker.controller.postMessage({
+                type: 'CACHE_URL',
+                url: url
+            });
+        } else {
+            // Fallback: try to cache directly using the Cache API
+            try {
+                const cache = await caches.open('pureper-v1');
+                const response = await fetch(url);
+                if (response.ok) {
+                    await cache.put(url, response);
+                    console.log('[ServiceWorker]: Resource cached directly:', url);
+                }
+            } catch (e) {
+                console.warn('[ServiceWorker]: Failed to cache resource:', url, e);
+            }
+        }
+    }
+
+    /**
+     * Asks the service worker to skip waiting and activate the new version.
+     */
+    static skipWaiting(): void {
+        if ('serviceWorker' in navigator && navigator.serviceWorker.controller) {
+            navigator.serviceWorker.controller.postMessage({ type: 'SKIP_WAITING' });
+        }
+    }
+
+    /**
+     * Gets the version of the currently active service worker.
+     * @returns A promise that resolves with the version string.
+     */
+    static getVersion(): Promise<string> {
+        return new Promise((resolve, reject) => {
+            if ('serviceWorker' in navigator && navigator.serviceWorker.controller) {
+                const messageChannel = new MessageChannel();
+                messageChannel.port1.onmessage = (event) => {
+                    if (event.data.error) {
+                        reject(event.data.error);
+                    } else {
+                        resolve(event.data.version);
+                    }
+                };
+                navigator.serviceWorker.controller.postMessage({ type: 'GET_VERSION' }, [messageChannel.port2]);
+            } else {
+                reject('Service worker not available.');
+            }
+        });
+    }
+
+    /**
+     * Checks if the given URL is present in the Service Worker's cache.
+     */
+    static isCached(url: string): Promise<boolean> {
+        return new Promise((resolve) => {
+            if ('serviceWorker' in navigator && navigator.serviceWorker.controller) {
+                const mc = new MessageChannel();
+                mc.port1.onmessage = (ev) => {
+                    if (ev.data && typeof ev.data.cached === 'boolean') {
+                        resolve(ev.data.cached);
+                    } else {
+                        resolve(false);
+                    }
+                };
+                navigator.serviceWorker.controller.postMessage({ type: 'HAS_URL', url }, [mc.port2]);
+            } else {
+                // Fallback: try CacheStorage directly (same-origin only)
+                caches.match(url).then(match => resolve(!!match)).catch(() => resolve(false));
+            }
+        });
+    }
+
+    /**
+     * Checks if the browser is online.
+     */
+    static async isOnline(): Promise<boolean> {
+        try {
+            const response = await fetch('./index.html', { cache: 'no-store' });
+            return response && response.ok;
+        } catch {
+            return false;
+        }
+    }
+}

package/src/foundation/worker/api/Clients.ts

@@ -0,0 +1,3 @@
+export interface Clients {
+    claim(): Promise<void>;
+}

package/src/foundation/worker/api/ExtendableEvent.ts

@@ -0,0 +1,3 @@
+export interface ExtendableEvent extends Event {
+    waitUntil(promise: Promise<any>): void;
+}

package/src/foundation/worker/api/ExtendableMessageEvent.ts

@@ -0,0 +1,6 @@
+import { ExtendableEvent } from './ExtendableEvent';
+
+export interface ExtendableMessageEvent extends ExtendableEvent {
+    data: any;
+    ports: MessagePort[];
+}

package/src/foundation/worker/api/FetchEvent.ts

@@ -0,0 +1,6 @@
+import { ExtendableEvent } from './ExtendableEvent';
+
+export interface FetchEvent extends ExtendableEvent {
+    request: Request;
+    respondWith(response: Promise<Response> | Response): void;
+}

package/src/foundation/worker/api/ServiceWorkerGlobalScope.ts

@@ -0,0 +1,14 @@
+import { Clients } from './Clients';
+import { ExtendableEvent } from './ExtendableEvent';
+import { FetchEvent } from './FetchEvent';
+import { ExtendableMessageEvent } from './ExtendableMessageEvent';
+
+export interface ServiceWorkerGlobalScope {
+    skipWaiting(): Promise<void>;
+    clients: Clients;
+    location: Location;
+    addEventListener(type: 'install', listener: (event: ExtendableEvent) => void): void;
+    addEventListener(type: 'activate', listener: (event: ExtendableEvent) => void): void;
+    addEventListener(type: 'fetch', listener: (event: FetchEvent) => void): void;
+    addEventListener(type: 'message', listener: (event: ExtendableMessageEvent) => void): void;
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+// Public package entry — re-export foundation APIs
+export { default as ElementHolder } from './foundation/api/ElementHolder';
+export { default as EmptyConstructor } from './foundation/api/EmptyConstructor';
+export { default as Lazy } from './foundation/api/Lazy';
+
+export * from './foundation/component_api/mixin/Proto';
+
+export { default as UniHtml } from './foundation/component_api/UniHtml';
+export { default as Page } from './foundation/component_api/Page';
+export { default as Component } from './foundation/component_api/Component';
+
+export { default as Triplet } from './foundation/Triplet';
+
+export { default as Fetcher } from './foundation/Fetcher';
+
+
+export { Router } from './foundation/worker/Router';
+export { default as ServiceWorker } from './foundation/worker/ServiceWorker';
+
+
+
+export * from './foundation/Theme';