@harpy-js/core 0.5.7 → 0.5.8

package/dist/client/router.d.ts

@@ -0,0 +1,11 @@
+export interface RouterOptions {
+    onLoadingStart?: () => void;
+    onLoadingEnd?: () => void;
+    onError?: (error: Error) => void;
+    enablePrefetch?: boolean;
+    contentSelector?: string;
+}
+export declare function prefetchPage(url: string): void;
+export declare function initRouter(options?: RouterOptions): () => void;
+export declare function clearPageCache(): void;
+export declare function navigateTo(url: string, options?: RouterOptions): void;

package/dist/client/router.js

@@ -0,0 +1,142 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchPage = prefetchPage;
+exports.initRouter = initRouter;
+exports.clearPageCache = clearPageCache;
+exports.navigateTo = navigateTo;
+const pageCache = new Map();
+let isNavigating = false;
+async function fetchPageData(url) {
+    if (pageCache.has(url)) {
+        return pageCache.get(url);
+    }
+    const response = await fetch(url, {
+        headers: {
+            'X-Harpy-SPA': 'true',
+            'Accept': 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch page: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    pageCache.set(url, data);
+    return data;
+}
+function updatePageContent(html, title, contentSelector) {
+    if (title) {
+        document.title = title;
+    }
+    const container = document.querySelector(contentSelector);
+    if (!container) {
+        console.error(`[Harpy Router] Content container not found: ${contentSelector}`);
+        window.location.reload();
+        return;
+    }
+    container.innerHTML = html;
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+    const scripts = container.querySelectorAll('script');
+    scripts.forEach((oldScript) => {
+        const newScript = document.createElement('script');
+        Array.from(oldScript.attributes).forEach((attr) => {
+            newScript.setAttribute(attr.name, attr.value);
+        });
+        newScript.textContent = oldScript.textContent;
+        oldScript.parentNode?.replaceChild(newScript, oldScript);
+    });
+}
+async function navigate(url, options) {
+    console.log('[Harpy Router] navigate() called for:', url, 'isNavigating:', isNavigating);
+    if (isNavigating) {
+        console.log('[Harpy Router] Navigation already in progress, skipping');
+        return;
+    }
+    isNavigating = true;
+    try {
+        console.log('[Harpy Router] Starting navigation...');
+        window.dispatchEvent(new Event('harpy:loading-start'));
+        options.onLoadingStart?.();
+        console.log('[Harpy Router] Fetching page data...');
+        const data = await fetchPageData(url);
+        console.log('[Harpy Router] Received page data:', data);
+        updatePageContent(data.html, data.title, options.contentSelector || '#__harpy_content');
+        window.dispatchEvent(new Event('harpy:loading-end'));
+        options.onLoadingEnd?.();
+        console.log('[Harpy Router] Navigation complete');
+    }
+    catch (error) {
+        console.error('[Harpy Router] Navigation error:', error);
+        window.dispatchEvent(new Event('harpy:loading-end'));
+        options.onError?.(error);
+        console.log('[Harpy Router] Falling back to full page navigation');
+        window.location.href = url;
+    }
+    finally {
+        isNavigating = false;
+    }
+}
+function prefetchPage(url) {
+    if (pageCache.has(url) || !url.startsWith('/')) {
+        return;
+    }
+    fetchPageData(url).catch((err) => {
+        console.warn('[Harpy Router] Prefetch failed:', err);
+    });
+}
+function initRouter(options = {}) {
+    if (typeof window === 'undefined') {
+        console.warn('[Harpy Router] Cannot initialize router on server');
+        return () => { };
+    }
+    console.log('[Harpy Router] Initializing SPA router');
+    const handlePopState = (event) => {
+        const url = window.location.pathname + window.location.search;
+        console.log('[Harpy Router] Popstate event, navigating to:', url);
+        navigate(url, options);
+    };
+    const handleLinkHover = (event) => {
+        if (!options.enablePrefetch)
+            return;
+        const target = event.target;
+        const link = target.closest('a');
+        if (link && link.href.startsWith(window.location.origin)) {
+            const url = new URL(link.href);
+            prefetchPage(url.pathname + url.search);
+        }
+    };
+    window.addEventListener('popstate', handlePopState);
+    if (options.enablePrefetch) {
+        document.addEventListener('mouseover', handleLinkHover);
+    }
+    const handleCustomNavigation = ((event) => {
+        const url = event.detail.url;
+        console.log('[Harpy Router] Received harpy:navigate event for:', url);
+        navigate(url, options);
+    });
+    const handlePrefetchEvent = ((event) => {
+        const url = event.detail.url;
+        console.log('[Harpy Router] Received harpy:prefetch event for:', url);
+        prefetchPage(url);
+    });
+    console.log('[Harpy Router] Adding event listeners');
+    window.addEventListener('harpy:navigate', handleCustomNavigation);
+    window.addEventListener('harpy:prefetch', handlePrefetchEvent);
+    return () => {
+        console.log('[Harpy Router] Cleaning up router');
+        window.removeEventListener('popstate', handlePopState);
+        window.removeEventListener('harpy:navigate', handleCustomNavigation);
+        window.removeEventListener('harpy:prefetch', handlePrefetchEvent);
+        if (options.enablePrefetch) {
+            document.removeEventListener('mouseover', handleLinkHover);
+        }
+        pageCache.clear();
+    };
+}
+function clearPageCache() {
+    pageCache.clear();
+}
+function navigateTo(url, options = {}) {
+    window.history.pushState({}, '', url);
+    navigate(url, options);
+}

package/dist/client/use-router.d.ts

@@ -0,0 +1,6 @@
+export interface UseRouterReturn {
+    isLoading: boolean;
+    navigate: (url: string, replace?: boolean) => void;
+    prefetch: (url: string) => void;
+}
+export declare function useRouter(): UseRouterReturn;

package/dist/client/use-router.js

@@ -0,0 +1,35 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRouter = useRouter;
+const react_1 = require("react");
+function useRouter() {
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        const handleLoadingStart = () => setIsLoading(true);
+        const handleLoadingEnd = () => setIsLoading(false);
+        window.addEventListener('harpy:loading-start', handleLoadingStart);
+        window.addEventListener('harpy:loading-end', handleLoadingEnd);
+        return () => {
+            window.removeEventListener('harpy:loading-start', handleLoadingStart);
+            window.removeEventListener('harpy:loading-end', handleLoadingEnd);
+        };
+    }, []);
+    const navigate = (0, react_1.useCallback)((url, replace = false) => {
+        const method = replace ? 'replaceState' : 'pushState';
+        window.history[method]({}, '', url);
+        window.dispatchEvent(new CustomEvent('harpy:navigate', {
+            detail: { url, replace },
+        }));
+    }, []);
+    const prefetch = (0, react_1.useCallback)((url) => {
+        window.dispatchEvent(new CustomEvent('harpy:prefetch', {
+            detail: { url },
+        }));
+    }, []);
+    return {
+        isLoading,
+        navigate,
+        prefetch,
+    };
+}

package/dist/core/spa-router.controller.d.ts

@@ -0,0 +1,4 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+export declare class SpaRouterController {
+    handleSpaRequest(req: FastifyRequest, res: FastifyReply): Promise<undefined>;
+}

package/dist/core/spa-router.controller.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaRouterController = void 0;
+const common_1 = require("@nestjs/common");
+let SpaRouterController = class SpaRouterController {
+    async handleSpaRequest(req, res) {
+        const isSpaRequest = req.headers['x-harpy-spa'] === 'true';
+        if (!isSpaRequest) {
+            return;
+        }
+        return res.status(501).send({
+            error: 'SPA navigation not yet fully implemented',
+            message: 'The SPA router is being set up. Full implementation coming soon.',
+        });
+    }
+};
+exports.SpaRouterController = SpaRouterController;
+__decorate([
+    (0, common_1.Get)('*'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], SpaRouterController.prototype, "handleSpaRequest", null);
+exports.SpaRouterController = SpaRouterController = __decorate([
+    (0, common_1.Controller)()
+], SpaRouterController);

package/dist/core/types/nav.types.d.ts

@@ -4,6 +4,7 @@ export interface NavItem {
     href?: string;
     active?: boolean;
     order?: number;
+    badge?: string;
 }
 export interface NavSection {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harpy-js/core",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Harpy - A powerful NestJS + React/JSX SSR framework with automatic hydration and i18n support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/types/nav.types.ts

@@ -14,6 +14,11 @@ export interface NavItem {
    * If omitted, registration order is used as a tiebreaker.
    */
   order?: number;
+  /**
+   * Optional badge to display next to the item (e.g., 'NEW', 'BETA', 'UPDATED').
+   * Used to highlight newly added or updated navigation items.
+   */
+  badge?: string;
 }
 
 export interface NavSection {

package/dist/core/lazy-route-loader.service.d.ts

@@ -1,28 +0,0 @@
-import { Type } from '@nestjs/common';
-import { LazyModuleLoader } from '@nestjs/core';
-import type { FastifyRequest, FastifyReply } from 'fastify';
-export interface LazyRouteConfig {
-    id: string;
-    path: string;
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    moduleLoader: () => Promise<Type<any>>;
-    controllerLoader: () => Promise<Type<any>>;
-    handlerMethod: string;
-}
-export declare class LazyRouteLoaderService {
-    private readonly lazyModuleLoader;
-    private readonly logger;
-    private readonly loadedModules;
-    private readonly registeredRoutes;
-    constructor(lazyModuleLoader: LazyModuleLoader);
-    registerLazyRoute(config: LazyRouteConfig): void;
-    getRegisteredRoutes(): LazyRouteConfig[];
-    handleLazyRoute(config: LazyRouteConfig, req: FastifyRequest, reply: FastifyReply): Promise<any>;
-    isModuleLoaded(moduleId: string): boolean;
-    getStatistics(): {
-        totalRegistered: number;
-        totalLoaded: number;
-        loadedModules: string[];
-        registeredRoutes: string[];
-    };
-}

package/dist/core/lazy-route-loader.service.js

@@ -1,79 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var LazyRouteLoaderService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LazyRouteLoaderService = void 0;
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-let LazyRouteLoaderService = LazyRouteLoaderService_1 = class LazyRouteLoaderService {
-    lazyModuleLoader;
-    logger = new common_1.Logger(LazyRouteLoaderService_1.name);
-    loadedModules = new Map();
-    registeredRoutes = new Map();
-    constructor(lazyModuleLoader) {
-        this.lazyModuleLoader = lazyModuleLoader;
-    }
-    registerLazyRoute(config) {
-        const routeKey = `${config.method}:${config.path}`;
-        this.registeredRoutes.set(routeKey, config);
-        this.logger.log(`Registered lazy route: ${routeKey} -> ${config.id}`);
-    }
-    getRegisteredRoutes() {
-        return Array.from(this.registeredRoutes.values());
-    }
-    async handleLazyRoute(config, req, reply) {
-        try {
-            let moduleRef = this.loadedModules.get(config.id);
-            if (!moduleRef) {
-                this.logger.log(`Loading lazy module: ${config.id}...`);
-                const startTime = Date.now();
-                const ModuleClass = await config.moduleLoader();
-                moduleRef = await this.lazyModuleLoader.load(() => ModuleClass);
-                this.loadedModules.set(config.id, moduleRef);
-                const loadTime = Date.now() - startTime;
-                this.logger.log(`Lazy module ${config.id} loaded in ${loadTime}ms`);
-            }
-            const ControllerClass = await config.controllerLoader();
-            const controller = moduleRef.get(ControllerClass, { strict: false });
-            if (!controller) {
-                throw new Error(`Controller instance not found in lazy module ${config.id}`);
-            }
-            const handler = controller[config.handlerMethod];
-            if (!handler || typeof handler !== 'function') {
-                throw new Error(`Handler method ${config.handlerMethod} not found in controller`);
-            }
-            const result = await handler.call(controller, req, reply);
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const errorStack = error instanceof Error ? error.stack : undefined;
-            this.logger.error(`Failed to handle lazy route ${config.id}: ${errorMessage}`, errorStack);
-            throw error;
-        }
-    }
-    isModuleLoaded(moduleId) {
-        return this.loadedModules.has(moduleId);
-    }
-    getStatistics() {
-        return {
-            totalRegistered: this.registeredRoutes.size,
-            totalLoaded: this.loadedModules.size,
-            loadedModules: Array.from(this.loadedModules.keys()),
-            registeredRoutes: Array.from(this.registeredRoutes.keys()),
-        };
-    }
-};
-exports.LazyRouteLoaderService = LazyRouteLoaderService;
-exports.LazyRouteLoaderService = LazyRouteLoaderService = LazyRouteLoaderService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.LazyModuleLoader])
-], LazyRouteLoaderService);

package/dist/core/lazy-routes.module.d.ts

@@ -1,2 +0,0 @@
-export declare class LazyRoutesModule {
-}

package/dist/core/lazy-routes.module.js

@@ -1,21 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LazyRoutesModule = void 0;
-const common_1 = require("@nestjs/common");
-const lazy_route_loader_service_1 = require("./lazy-route-loader.service");
-let LazyRoutesModule = class LazyRoutesModule {
-};
-exports.LazyRoutesModule = LazyRoutesModule;
-exports.LazyRoutesModule = LazyRoutesModule = __decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({
-        providers: [lazy_route_loader_service_1.LazyRouteLoaderService],
-        exports: [lazy_route_loader_service_1.LazyRouteLoaderService],
-    })
-], LazyRoutesModule);

package/dist/decorators/lazy-route.decorator.d.ts

@@ -1,12 +0,0 @@
-export declare const LAZY_ROUTE_METADATA = "harpy:lazy-route";
-export interface LazyRouteDecoratorConfig {
-    id: string;
-    moduleLoader: () => Promise<any>;
-    controllerLoader: () => Promise<any>;
-    handlerMethod: string;
-}
-export interface LazyRouteMetadata extends LazyRouteDecoratorConfig {
-    path: string;
-    method: string;
-}
-export declare function LazyRoute(path: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH', config: LazyRouteDecoratorConfig): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/decorators/lazy-route.decorator.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LAZY_ROUTE_METADATA = void 0;
-exports.LazyRoute = LazyRoute;
-const common_1 = require("@nestjs/common");
-exports.LAZY_ROUTE_METADATA = 'harpy:lazy-route';
-function LazyRoute(path, method, config) {
-    const methodDecorator = method === 'GET'
-        ? (0, common_1.Get)(path)
-        : method === 'POST'
-            ? (0, common_1.Post)(path)
-            : method === 'PUT'
-                ? (0, common_1.Put)(path)
-                : method === 'DELETE'
-                    ? (0, common_1.Delete)(path)
-                    : (0, common_1.Patch)(path);
-    return (0, common_1.applyDecorators)(methodDecorator, (0, common_1.SetMetadata)(exports.LAZY_ROUTE_METADATA, {
-        ...config,
-        path,
-        method,
-    }));
-}

package/dist/hydration-manifest.json

@@ -1 +0,0 @@
-{}